o %ݫi^@sdZddlZddlmZddlmZddlmZmZddl Z eGdddZ Gdd d Z de j fd eed ee j fd d ZdS)zThis module implements utilities and abstractions for use with `torch.autocast`, i.e. Automatic Mixed Precision. Authors * Sylvain de Langen 2023 * Adel Moumen 2025 N) nullcontext) dataclass)CallableOptionalc@s(eZdZUdZejed<eddZdS) AMPConfigzConfiguration for automatic mixed precision (AMP). Arguments --------- dtype : torch.dtype The dtype to use for AMP. dtypecCsN|dus|dkr ttjS|dkrttjS|dkrttjStd|d)a8Create an AMPConfig from a string name. Arguments --------- name : str The name of the AMPConfig to create. Must be one of `fp32`, `fp16`, or `bf16`. Returns ------- AMPConfig The AMPConfig corresponding to the name. Nfp32fp16bf16zSpecified autocast mode (z4) incorrect, expected one of `fp32`, `fp16`, `bf16`.)rtorchfloat32float16bfloat16 ValueError)selfnamerN/home/ubuntu/.local/lib/python3.10/site-packages/speechbrain/utils/autocast.py from_names    zAMPConfig.from_nameN) __name__ __module__ __qualname____doc__r r__annotations__ classmethodrrrrrrs  rc@s(eZdZdZddZddZddZdS) TorchAutocasta A context manager that conditionally enables ``torch.autocast`` for GPU operations. This manager wraps around ``torch.autocast`` to automatically enable autocasting when running on a GPU and a data type other than float32 is specified. If the desired data type is float32, autocasting is bypassed and the context manager behaves as a no-op. Parameters ---------- *args : tuple Positional arguments forwarded to `torch.autocast`. See the PyTorch documentation: https://pytorch.org/docs/stable/amp.html#torch.autocast **kwargs : dict Keyword arguments forwarded to `torch.autocast`. Typically includes the `dtype` argument to specify the desired precision. See the PyTorch documentation for more details. cOs:|dtjtjk}|rtj|i||_dSt|_dS)Nr)getr r autocastcontextr)rargskwargsenabledrrr__init__Ls zTorchAutocast.__init__c Cshz|jWSty3}z!t|jdr.t|jdr.|jj}|jj}td|d|d|d}~ww)a Enter the autocast context. Returns ------- context The result of entering the underlying autocast context manager. Raises ------ RuntimeError If an error occurs while entering the autocast context and the context provides 'device' and 'fast_dtype' attributes, a RuntimeError is raised with additional diagnostic information. device fast_dtypez$Error during autocasting with dtype=z on device=z. N)r __enter__ RuntimeErrorhasattrr#r$)rer#rrrrr%Ss  zTorchAutocast.__enter__cCs|j|||S)a Exit the autocast context. Parameters ---------- exc_type : type Exception type if an exception occurred, otherwise None. exc_val : Exception Exception instance if an exception occurred, otherwise None. exc_tb : traceback Traceback object if an exception occurred, otherwise None. Returns ------- bool or None The result of exiting the underlying autocast context manager. )r__exit__)rexc_typeexc_valexc_tbrrrr)qszTorchAutocast.__exit__N)rrrrr"r%r)rrrrr8s  rfwd cast_inputscsPdur tjt|dStjjj|dtdddtffdd}|S)aDecorator for forward methods which, by default, *disables* autocast and casts any floating-point tensor parameters into the specified dtype (much like `torch.cuda.amp.custom_fwd`). The *wrapped forward* will gain an additional `force_allow_autocast` keyword parameter. When set to `True`, the function will ignore `cast_inputs` and will not disable autocast, as if this decorator was not specified. (Thus, modules can specify a default recommended precision, and users can override that behavior when desired.) Note that as of PyTorch 2.1.1, this will **only** affect **CUDA** AMP. Non-CUDA AMP will be unaffected and no input tensors will be cast! This usecase may be supported by this function in the future. When autocast is *not* active, this decorator does not change any behavior. Arguments --------- fwd: Optional[Callable] The function to wrap. If omitted, returns a partial application of the decorator, e.g. allowing `new_decorator = fwd_default_precision(cast_inputs=torch.float32)`. Reminder: If you are decorating a function directly, this argument is already specified implicitly. cast_inputs: Optional[torch.dtype] If not `None` (the default being `torch.float32`), then any floating-point inputs to the wrapped function will be cast to the specified type. Note: When autocasting is enabled, output tensors of autocast-compatible operations may be of the autocast data type. Disabling autocast *without* casting inputs will not change this fact, so lower precision operations can happen even inside of an autocast-disabled region, which this argument helps avoid if desired. Returns ------- The wrapped function N)r.F)force_allow_autocastr/cs |r |i|S|i|S)a-Wrapped forward function from fwd_default_precision. Arguments --------- *args: tuple Arguments to be forwarded to the unwrapped function. force_allow_autocast: bool When `True`, the wrapped function will be executed directly with no change to the autocast context and no input casting. **kwargs: dict Arguments to be forwarded to the unwrapped function. Returns ------- The wrapped function if force_allow_autocast, else the original r)r/rr r- wrapped_fwdrrwrappersz&fwd_default_precision..wrapper) functoolspartialfwd_default_precisionr cudaamp custom_fwdwrapsbool)r-r.r2rr0rr5s .r5)rr3 contextlibr dataclassesrtypingrrr rrr rr5rrrrs   &O