
    wi                     j    d dl mZmZmZmZ d dlZddlmZ ddlm	Z	 ddl
mZmZ  G d d	e          ZdS )
    )ListOptionalTupleUnionN   )DDIMScheduler)randn_tensor   )DiffusionPipelineImagePipelineOutputc                        e Zd ZdZdZ fdZ ej                    	 	 	 	 	 	 	 dd
ede	e
ej        eej                 f                  dedede	e         de	e         dede
eef         fd            Z x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`].
    unetc                     t                                                       t          j        |j                  }|                     ||           d S )N)r   	scheduler)super__init__r   from_configconfigregister_modules)selfr   r   	__class__s      v/root/.openclaw/workspace/chatterbox_venv_py311/lib/python3.11/site-packages/diffusers/pipelines/ddim/pipeline_ddim.pyr   zDDIMPipeline.__init__)   sM     "-i.>??	49=====       N        2   pilT
batch_size	generatoretanum_inference_stepsuse_clipped_model_outputoutput_typereturn_dictreturnc           	         t          | j        j        j        t                    r4|| j        j        j        | j        j        j        | j        j        j        f}n%|| j        j        j        g| j        j        j        R }t          |t                    r6t          |          |k    r#t          dt          |           d| d          t          ||| j
        | j        j                  }	| j                            |           |                     | j        j                  D ]B}
|                     |	|
          j        }| j                            ||
|	|||          j        }	C|	dz  dz                       dd	          }	|	                                                    ddd
d	                                          }	|dk    r|                     |	          }	|s|	fS t1          |	          S )uU
  
        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://arxiv.org/abs/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clampcpupermutenumpynumpy_to_pilr   )r   r   r    r!   r"   r#   r$   r%   image_shapeimagetmodel_outputs               r   __call__zDDIMPipeline.__call__1   s   B di&2C88 	d	 ,	 ,	 ,	KK &ty'7'CcdiFVFbccKi&& 	3y>>Z+G+Gi#i.. i i&i i i  
 [IdF\dhdmdsttt 	$$%8999""4>#;<< 		 		A99UA..5L
 N''aCJbnw (   E S''1--		##Aq!Q//5577%%%e,,E 	8O"%0000r   )r   Nr   r   Nr   T)__name__
__module____qualname____doc__model_cpu_offload_seqr   torchno_gradr-   r   r   	Generatorr   floatboolstrr   r   rB   __classcell__)r   s   @r   r   r      s         #> > > > > U]__ MQ#%37%* h1 h1h1 E%/43H"HIJh1 	h1
 !h1 #+4.h1 c]h1 h1 
"E)	*h1 h1 h1 _h1 h1 h1 h1 h1r   r   )typingr   r   r   r   rH   
schedulersr   utils.torch_utilsr	   pipeline_utilsr   r   r    r   r   <module>rT      s    0 / / / / / / / / / / /  ' ' ' ' ' ' - - - - - - C C C C C C C CB1 B1 B1 B1 B1$ B1 B1 B1 B1 B1r   