
    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)DDIMScheduler)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
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`].
    unet	schedulerc                     t         |           t        j                  |j                        }| j                  ||       y )N)r   r   )super__init__r	   from_configconfigregister_modules)selfr   r   	__class__s      a/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/pipelines/ddim/pipeline_ddim.pyr   zDDIMPipeline.__init__3   s9     "--i.>.>?	49=    
batch_size	generatoretanum_inference_stepsuse_clipped_model_output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                  }t        |t              r)t        |      |k7  rt        dt        |       d| d      t        ||| j                  | j                  j                        }	| j                  j                  |       | j                  | j                  j                        D ]d  }
| j                  |	|
      j                   }| j                  j#                  ||
|	|||      j$                  }	t&        sQt)        j*                          f |	dz  dz   j-                  dd	      }	|	j/                         j1                  ddd
d	      j3                         }	|dk(  r| j5                  |	      }	|s|	fS t7        |	      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   pil)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_outputs               r   __call__zDDIMPipeline.__call__;   s   B dii&&22C8		  ,,		  ,,		  ,,	K &tyy'7'7'C'CcdiiFVFVFbFbcKi&3y>Z+GA#i.AQ R&<'gi 
 [IdF\F\dhdmdmdsdst 	$$%89""4>>#;#;< 	A99UA.55L
 NN''aCJbnw ( k  	 S''1-		##Aq!Q/557%%%e,E8O"%00r   )r(   Ng        2   Nr)   T)__name__
__module____qualname____doc__model_cpu_offload_seqr   r	   r   torchno_gradr-   r   r   	Generatorr   floatboolstrr   r   rE   __classcell__)r   s   @r   r   r   "   s     #>[ >] > U]]_ MQ#%37%* k1k1 E%//43H"HIJk1 	k1
 !k1 #+4.k1 c]k1 k1 
"E)	*k1 k1r   r   )typingr   r   r   r   rL   modelsr   
schedulersr	   utilsr
   utils.torch_utilsr   pipeline_utilsr   r   torch_xla.core.xla_modelcore	xla_modelr:   r9   r    r   r   <module>r]      sF    0 /  ! ' + - C ))MME1$ E1r   