o
    Gi%                     @   sz   d dl mZ d dlZd dlZddlmZmZ ddlm	Z	 ddl
mZ ddlmZ eG d	d
 d
e	ZG dd deeZdS )    )	dataclassN   )ConfigMixinregister_to_config)
BaseOutput)randn_tensor   )SchedulerMixinc                   @   s8   e Zd ZU dZejed< ejed< dZejdB ed< dS )KarrasVeOutputa  
    Output class for the scheduler's step function output.

    Args:
        prev_sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
            Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the
            denoising loop.
        derivative (`torch.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
            Derivative of predicted original image sample (x_0).
        pred_original_sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
            The predicted denoised sample (x_{0}) based on the model output from the current timestep.
            `pred_original_sample` can be used to preview progress or for guidance.
    prev_sample
derivativeNpred_original_sample)__name__
__module____qualname____doc__torchTensor__annotations__r    r   r   h/home/ubuntu/.local/lib/python3.10/site-packages/diffusers/schedulers/deprecated/scheduling_karras_ve.pyr
      s
   
 

r
   c                   @   s  e Zd ZdZdZe						d-d	ed
ededededefddZd.dej	de
dej	fddZd.de
deejB fddZ	d.dej	dedejdB deej	ef fddZ	d/d ej	d!ed"ed#ej	d$edeeB fd%d&Z	d/d ej	d!ed"ed#ej	d'ej	d(ej	d$edeeB fd)d*Zd+d, ZdS )0KarrasVeScheduleraI  
    A stochastic scheduler tailored to variance-expanding models.

    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
    methods the library implements for all schedulers such as loading and saving.

    > [!TIP] > For more details on the parameters, see [Appendix E](https://huggingface.co/papers/2206.00364). The grid
    search > values used to find the optimal `{s_noise, s_churn, s_min, s_max}` for a specific model are described in
    Table 5 of > the paper.

    Args:
        sigma_min (`float`, defaults to 0.02):
            The minimum noise magnitude.
        sigma_max (`float`, defaults to 100):
            The maximum noise magnitude.
        s_noise (`float`, defaults to 1.007):
            The amount of additional noise to counteract loss of detail during sampling. A reasonable range is [1.000,
            1.011].
        s_churn (`float`, defaults to 80):
            The parameter controlling the overall amount of stochasticity. A reasonable range is [0, 100].
        s_min (`float`, defaults to 0.05):
            The start value of the sigma range to add noise (enable stochasticity). A reasonable range is [0, 10].
        s_max (`float`, defaults to 50):
            The end value of the sigma range to add noise. A reasonable range is [0.2, 80].
    r   {Gz?d   &1?P   皙?2   	sigma_min	sigma_maxs_noises_churns_mins_maxc                 C   s   || _ d | _d | _d | _d S N)init_noise_sigmanum_inference_steps	timestepsschedule)selfr   r   r    r!   r"   r#   r   r   r   __init__M   s   
zKarrasVeScheduler.__init__Nsampletimestepreturnc                 C   s   |S )a  
        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
        current timestep.

        Args:
            sample (`torch.Tensor`):
                The input sample.
            timestep (`int`, *optional*):
                The current timestep in the diffusion chain.

        Returns:
            `torch.Tensor`:
                A scaled input sample.
        r   )r)   r+   r,   r   r   r   scale_model_input_   s   z#KarrasVeScheduler.scale_model_inputr&   devicec                    sb    _ tdj ddd  }t||_ fddjD }tj|tj	|d_
dS )a  
        Sets the discrete timesteps used for the diffusion chain (to be run before inference).

        Args:
            num_inference_steps (`int`):
                The number of diffusion steps used when generating samples with a pre-trained model.
            device (`str` or `torch.device`, *optional*):
                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
        r   Nc                    s<   g | ]}j jd  j jd  j jd   | d    qS )r      )configr   r   ).0ir&   r)   r   r   
<listcomp>}   s    
"z3KarrasVeScheduler.set_timesteps.<locals>.<listcomp>)dtyper/   )r&   nparangecopyr   
from_numpytor'   tensorfloat32r(   )r)   r&   r/   r'   r(   r   r5   r   set_timestepsp   s   
zKarrasVeScheduler.set_timestepssigma	generatorc                 C   s   | j j|  kr| j jkrn nt| j j| j d}nd}| j jt|j|d	|j
 }|||  }||d |d  d |  }||fS )u  
        Explicit Langevin-like "churn" step of adding noise to the sample according to a `gamma_i ≥ 0` to reach a
        higher noise level `sigma_hat = sigma_i + gamma_i*sigma_i`.

        Args:
            sample (`torch.Tensor`):
                The input sample.
            sigma (`float`):
            generator (`torch.Generator`, *optional*):
                A random number generator.
        g4y?r   )rA   r         ?)r2   r"   r#   minr!   r&   r    r   shaper<   r/   )r)   r+   r@   rA   gammaeps	sigma_hat
sample_hatr   r   r   add_noise_to_input   s    z$KarrasVeScheduler.add_noise_to_inputTmodel_outputrG   
sigma_prevrH   return_dictc           	      C   sB   |||  }|| | }||| |  }|s||fS t |||dS )a  
        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
        process from the learned model outputs (most often the predicted noise).

        Args:
            model_output (`torch.Tensor`):
                The direct output from learned diffusion model.
            sigma_hat (`float`):
            sigma_prev (`float`):
            sample_hat (`torch.Tensor`):
            return_dict (`bool`, *optional*, defaults to `True`):
                Whether or not to return a [`~schedulers.scheduling_karras_ve.KarrasVESchedulerOutput`] or `tuple`.

        Returns:
            [`~schedulers.scheduling_karras_ve.KarrasVESchedulerOutput`] or `tuple`:
                If return_dict is `True`, [`~schedulers.scheduling_karras_ve.KarrasVESchedulerOutput`] is returned,
                otherwise a tuple is returned where the first element is the sample tensor.

        r   r   r   r
   )	r)   rJ   rG   rK   rH   rL   r   r   sample_prevr   r   r   step   s   zKarrasVeScheduler.steprO   r   c           
      C   sN   |||  }|| | }	||| d| d|	    }|s ||fS t |||dS )a  
        Corrects the predicted sample based on the `model_output` of the network.

        Args:
            model_output (`torch.Tensor`):
                The direct output from learned diffusion model.
            sigma_hat (`float`): TODO
            sigma_prev (`float`): TODO
            sample_hat (`torch.Tensor`): TODO
            sample_prev (`torch.Tensor`): TODO
            derivative (`torch.Tensor`): TODO
            return_dict (`bool`, *optional*, defaults to `True`):
                Whether or not to return a [`~schedulers.scheduling_ddpm.DDPMSchedulerOutput`] or `tuple`.

        Returns:
            prev_sample (TODO): updated sample in the diffusion chain. derivative (TODO): TODO

        rB   rM   rN   )
r)   rJ   rG   rK   rH   rO   r   rL   r   derivative_corrr   r   r   step_correct   s   zKarrasVeScheduler.step_correctc                 C   s   t  r$   )NotImplementedError)r)   original_samplesnoiser'   r   r   r   	add_noise   s   zKarrasVeScheduler.add_noise)r   r   r   r   r   r   r$   )T)r   r   r   r   orderr   floatr*   r   r   intr.   strr/   r?   	GeneratortuplerI   boolr
   rP   rR   rV   r   r   r   r   r   0   s    
 
/	
'r   )dataclassesr   numpyr8   r   configuration_utilsr   r   utilsr   utils.torch_utilsr   scheduling_utilsr	   r
   r   r   r   r   r   <module>   s   