o
    ۷i                     @   s~   d dl Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
mZ e r3d dlm  mZ d	Znd
ZG dd de
ZdS )    N   )UNet2DModel)DDIMScheduler)is_torch_xla_available)randn_tensor   )DiffusionPipelineImagePipelineOutputTFc                       s   e Zd ZdZdZdedef fddZe	 							
	dde
dejeej B dB dede
dedB dedB dedeeB fddZ  ZS )DDIMPipelinea1  
    Pipeline for image generation.

    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
    implemented for all pipelines (downloading, saving, running on a particular device, etc.).

    Parameters:
        unet ([`UNet2DModel`]):
            A `UNet2DModel` to denoise the encoded image latents.
        scheduler ([`SchedulerMixin`]):
            A scheduler to be used in combination with `unet` to denoise the encoded image. Can be one of
            [`DDPMScheduler`], or [`DDIMScheduler`].
    unet	schedulerc                    s(   t    t|j}| j||d d S )N)r   r   )super__init__r   from_configconfigregister_modules)selfr   r   	__class__ \/home/ubuntu/vllm_env/lib/python3.10/site-packages/diffusers/pipelines/ddim/pipeline_ddim.pyr   1   s   
zDDIMPipeline.__init__   N        2   pilT
batch_size	generatoretanum_inference_stepsuse_clipped_model_outputoutput_typereturn_dictreturnc              	   C   s6  t | jjjtr|| jjj| jjj| jjjf}n|| jjjg| jjjR }t |tr=t||kr=tdt| d| dt	||| j
| jjd}	| j| | | jjD ]}
| |	|
j}| jj||
|	|||dj}	trqt  qU|	d d dd	}	|	 ddd
d	 }	|dkr| |	}	|s|	fS t|	dS )u]
  
        The call function to the pipeline for generation.

        Args:
            batch_size (`int`, *optional*, defaults to 1):
                The number of images to generate.
            generator (`torch.Generator`, *optional*):
                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
                generation deterministic.
            eta (`float`, *optional*, defaults to 0.0):
                Corresponds to parameter eta (η) from the [DDIM](https://huggingface.co/papers/2010.02502) paper. Only
                applies to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers. A value of `0`
                corresponds to DDIM and `1` corresponds to DDPM.
            num_inference_steps (`int`, *optional*, defaults to 50):
                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
                expense of slower inference.
            use_clipped_model_output (`bool`, *optional*, defaults to `None`):
                If `True` or `False`, see documentation for [`DDIMScheduler.step`]. If `None`, nothing is passed
                downstream to the scheduler (use `None` for schedulers which don't support this argument).
            output_type (`str`, *optional*, defaults to `"pil"`):
                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
            return_dict (`bool`, *optional*, defaults to `True`):
                Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple.

        Example:

        ```py
        >>> from diffusers import DDIMPipeline
        >>> import PIL.Image
        >>> import numpy as np

        >>> # load model and scheduler
        >>> pipe = DDIMPipeline.from_pretrained("fusing/ddim-lsun-bedroom")

        >>> # run pipeline in inference (sample random noise and denoise)
        >>> image = pipe(eta=0.0, num_inference_steps=50)

        >>> # process image to PIL
        >>> image_processed = image.cpu().permute(0, 2, 3, 1)
        >>> image_processed = (image_processed + 1.0) * 127.5
        >>> image_processed = image_processed.numpy().astype(np.uint8)
        >>> image_pil = PIL.Image.fromarray(image_processed[0])

        >>> # save image
        >>> image_pil.save("test.png")
        ```

        Returns:
            [`~pipelines.ImagePipelineOutput`] or `tuple`:
                If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is
                returned where the first element is a list with the generated images
        z/You have passed a list of generators of length z+, but requested an effective batch size of z@. Make sure the batch size matches the length of the generators.)r   devicedtype)r   r   r   r   g      ?r   r   r   r   )images)
isinstancer   r   sample_sizeintin_channelslistlen
ValueErrorr   _execution_devicer$   r   set_timestepsprogress_bar	timestepssamplestepprev_sampleXLA_AVAILABLExm	mark_stepclampcpupermutenumpynumpy_to_pilr	   )r   r   r   r   r   r   r    r!   image_shapeimagetmodel_outputr   r   r   __call__9   s@   A

zDDIMPipeline.__call__)r   Nr   r   Nr   T)__name__
__module____qualname____doc__model_cpu_offload_seqr   r   r   torchno_gradr(   	Generatorr*   floatboolstrr	   tupler@   __classcell__r   r   r   r   r
       s:    	r
   )rF   modelsr   
schedulersr   utilsr   utils.torch_utilsr   pipeline_utilsr   r	   torch_xla.core.xla_modelcore	xla_modelr5   r4   r
   r   r   r   r   <module>   s   