o
    qôjQ  ã                   @   sº   d Z ddlZddlZddlZddlmZ ddlZddlmZm	Z	m
Z
mZmZmZmZmZmZ ddeddfd	d
„Zdefdd„Zdedefdd„Z			ddee dedee fdd„ZdS )z“
A collection of utilities for ensuring that training can always occur. Heavily influenced by the
[toma](https://github.com/BlackHC/toma) library.
é    N)ÚOptionalé   )	Úis_cuda_availableÚis_hpu_availableÚis_mlu_availableÚis_mps_availableÚis_musa_availableÚis_neuron_availableÚis_npu_availableÚis_sdaa_availableÚis_xpu_availableFÚgarbage_collectionÚreturnc                 C   s¾   | rt  ¡  tƒ rtj ¡  dS tƒ rtj ¡  dS tƒ r$tj	 ¡  dS t
ƒ r.tj ¡  dS tƒ r8tj ¡  dS tdd�rDtj ¡  dS tƒ rNtj ¡  dS tƒ rSdS tƒ r]tj ¡  dS dS )z½
    Clears the device cache by calling `torch.{backend}.empty_cache`. Can also run `gc.collect()`, but do note that
    this is a *considerable* slowdown and should be used sparingly.
    z2.0)Úmin_versionN)ÚgcÚcollectr   ÚtorchÚxpuÚempty_cacher   Úmlur   Úsdaar   Úmusar
   Únpur   Úmpsr   Úcudar   r	   Úneuron©r   © r   úh/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/accelerate/utils/memory.pyÚclear_device_cache(   s*   
þr   c                  G   s:   t | tƒs	t| ƒ} tt| ƒƒD ]}d| |< qtdd� | S )aN  
    Releases memory from `objects` by setting them to `None` and calls `gc.collect()` and `torch.cuda.empty_cache()`.
    Returned objects should be reassigned to the same variables.

    Args:
        objects (`Iterable`):
            An iterable of objects
    Returns:
        A list of `None` objects to replace `objects`

    Example:

        ```python
        >>> import torch
        >>> from accelerate.utils import release_memory

        >>> a = torch.ones(1000, 1000).cuda()
        >>> b = torch.ones(1000, 1000).cuda()
        >>> a, b = release_memory(a, b)
        ```
    NTr   )Ú
isinstanceÚlistÚrangeÚlenr   )ÚobjectsÚir   r   r   Úrelease_memoryF   s   


r&   Ú	exceptionc                    s:   g d¢}t ˆ tƒrtˆ jƒdkrt‡ fdd„|D ƒƒS dS )z«
    Checks if `exception` relates to CUDA, XPU, MPS or CPU out-of-memory, or CUDNN not supported

    Args:
        exception (`Exception`):
            An exception
    )z out of memory.zMPS backend out of memoryz(cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.z*DefaultCPUAllocator: can't allocate memoryz1FATAL ERROR :: MODULE:PT_DEVMEM Allocation failedr   c                 3   s   � | ]
}|ˆ j d  v V  qdS )r   N)Úargs)Ú.0Úerr©r'   r   r   Ú	<genexpr>t   s   € z+should_reduce_batch_size.<locals>.<genexpr>F)r    ÚRuntimeErrorr#   r(   Úany)r'   Z_statementsr   r+   r   Úshould_reduce_batch_sized   s   r/   é€   ÚfunctionÚstarting_batch_sizeÚreduce_batch_size_fnc                    sD   ˆdu rt jt|ˆd�S |‰ ˆdu r‡ fdd„‰‡ ‡‡fdd„}|S )a  
    A basic decorator that will try to execute `function`. If it fails from exceptions related to out-of-memory or
    CUDNN, the batch size is multiplied by 0.9 and passed to `function`

    `function` must take in a `batch_size` parameter as its first argument.

    Args:
        function (`callable`, *optional*):
            A function to wrap
        starting_batch_size (`int`, *optional*):
            The batch size to try and fit into memory
        reduce_batch_size_fn (`callable`, *optional*):
            A function to determine the new batch size after an out-of-memory error. If not
            provided, the batch size is multiplied by 0.9 on each failure. The function takes
            no arguments and should return the new (reduced) batch size as an `int`.

    Example:

    ```python
    >>> from accelerate.utils import find_executable_batch_size


    >>> @find_executable_batch_size(starting_batch_size=128)
    ... def train(batch_size, model, optimizer):
    ...     ...


    >>> train(model, optimizer)
    ```
    N)r2   r3   c                      s   t ˆ d ƒ‰ ˆ S )NgÍÌÌÌÌÌì?)Úintr   )Ú
batch_sizer   r   r3   ¥   s   z8find_executable_batch_size.<locals>.reduce_batch_size_fnc               
      sê   t dd� tt ˆ¡j ¡ ƒ}t|ƒt| ƒd k r>d dd„ t|dd … | dd … ƒD ƒ¡}t	dˆj
› dˆj
› d	|› d
�ƒ‚	 ˆ dkrGtdƒ‚zˆˆ g| ¢R i |¤ŽW S  tys } zt|ƒrht dd� ˆƒ ‰ n‚ W Y d }~nd }~ww q?)NTr   r   z, c                 S   s   g | ]\}}|› d |› �‘qS )ú=r   )r)   ÚargÚvaluer   r   r   Ú
<listcomp>°   s    zAfind_executable_batch_size.<locals>.decorator.<locals>.<listcomp>zBatch size was passed into `zS` as the first argument when called.Remove this as the decorator already does so: `ú(z)`r   z-No executable batch size found, reached zero.)r   r!   ÚinspectÚ	signatureÚ
parametersÚkeysr#   ÚjoinÚzipÚ	TypeErrorÚ__name__r-   Ú	Exceptionr/   )r(   ÚkwargsÚparamsÚarg_strÚe©r5   r1   r3   r   r   Ú	decoratorª   s2   
*
ÿÿÿ
þ€ýûz-find_executable_batch_size.<locals>.decorator)Ú	functoolsÚpartialÚfind_executable_batch_size)r1   r2   r3   rI   r   rH   r   rL   x   s   #ýrL   )F)Nr0   N)Ú__doc__rJ   r   r;   Útypingr   r   Úimportsr   r   r   r   r   r	   r
   r   r   Úboolr   r!   r&   rC   r/   Úcallabler4   rL   r   r   r   r   Ú<module>   s(   ,ýÿþý