
    bi                         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 ddlmZ dd	lmZmZ  e       rd dlmc mZ d
ZndZ G d de      Zy)    )ListOptionalTupleUnionN   )UNet2DModel)DDPMScheduler)is_torch_xla_available)randn_tensor   )DiffusionPipelineImagePipelineOutputTFc                        e Zd ZdZdZdedef fdZ ej                         	 	 	 	 	 dde
deeej                  eej                     f      de
dee   d	ed
eeef   fd       Z xZS )DDPMPipelinea1  
    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                 H    t         |           | j                  ||       y )N)r   r   )super__init__register_modules)selfr   r   	__class__s      a/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/pipelines/ddpm/pipeline_ddpm.pyr   zDDPMPipeline.__init__4   s!    49=    
batch_size	generatornum_inference_stepsoutput_typereturn_dictreturnc                    t        | j                  j                  j                  t              ra|| j                  j                  j
                  | j                  j                  j                  | j                  j                  j                  f}nC|| j                  j                  j
                  g| j                  j                  j                  }| j                  j                  dk(  r>t        ||| j                  j                        }|j                  | j                        }n-t        ||| j                  | j                  j                        }| j                  j                  |       | j                  | j                  j                        D ]b  }| j                  ||      j                  }	| j                  j!                  |	|||      j"                  }t$        sOt'        j(                          d |dz  dz   j+                  dd      }|j-                         j/                  ddd	d      j1                         }|d
k(  r| j3                  |      }|s|fS t5        |      S )aa  
        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.
            num_inference_steps (`int`, *optional*, defaults to 1000):
                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
                expense of slower inference.
            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 DDPMPipeline

        >>> # load model and scheduler
        >>> pipe = DDPMPipeline.from_pretrained("google/ddpm-cat-256")

        >>> # run pipeline in inference (sample random noise and denoise)
        >>> image = pipe().images[0]

        >>> # save image
        >>> image.save("ddpm_generated_image.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
        mps)r   dtype)r   devicer#   )r   r   g      ?r      r   pil)images)
isinstancer   configsample_sizeintin_channelsr$   typer   r#   tor   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   image_shapeimagetmodel_outputs
             r   __call__zDDPMPipeline.__call__8   s   ^ dii&&22C8		  ,,		  ,,		  ,,	K &tyy'7'7'C'CcdiiFVFVFbFbcK;;u$ 	YEHHT[[)E 	$++]a]f]f]l]lmE 	$$%89""4>>#;#;< 	A99UA.55L NN''a)'T``E	 S''1-		##Aq!Q/557%%%e,E8O"%00r   )r%   Ni  r&   T)__name__
__module____qualname____doc__model_cpu_offload_seqr   r	   r   torchno_gradr+   r   r   	Generatorr   strboolr   r   rA   __classcell__)r   s   @r   r   r   #   s     #>[ >] > U]]_ MQ#'%* T1T1 E%//43H"HIJT1 !	T1
 c]T1 T1 
"E)	*T1 T1r   r   )typingr   r   r   r   rG   modelsr   
schedulersr	   utilsr
   utils.torch_utilsr   pipeline_utilsr   r   torch_xla.core.xla_modelcore	xla_modelr6   r5   r    r   r   <module>rW      sF     0 /  ! ' + - C ))MMj1$ j1r   