"""simple docstring"""


from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..utils import maybe_allow_in_graph
from .activations import get_activation
from .attention_processor import Attention
from .embeddings import CombinedTimestepLabelEmbeddings


@maybe_allow_in_graph
class 							a					(		nn.Module ):


    def __init__(       self						:	Tuple ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	Dict=0.0 ,					__lowerCAmelCase						:	Optional[int] = None ,					__lowerCAmelCase						:	str = "geglu" ,					__lowerCAmelCase						:	Optional[int] = None ,					__lowerCAmelCase						:	bool = False ,					__lowerCAmelCase						:	bool = False ,					__lowerCAmelCase						:	bool = False ,					__lowerCAmelCase						:	bool = False ,					__lowerCAmelCase						:	bool = True ,					__lowerCAmelCase						:	str = "layer_norm" ,					__lowerCAmelCase						:	bool = False ,					):
      super().__init__()
      _UpperCAmelCase    			=   only_cross_attention

      _UpperCAmelCase    			=   (num_embeds_ada_norm is not None) and norm_type == "ada_norm_zero"
      _UpperCAmelCase    			=   (num_embeds_ada_norm is not None) and norm_type == "ada_norm"

      if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None:
        raise ValueError(
            f'''`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to'''
            f''' define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.'''       )

      # Define 3 blocks. Each block has its own normalization layer.
      # 1. Self-Attn
      if self.use_ada_layer_norm:
        _UpperCAmelCase    			=   AdaLayerNorm(__lowerCAmelCase ,					__lowerCAmelCase       )
      elif self.use_ada_layer_norm_zero:
        _UpperCAmelCase    			=   AdaLayerNormZero(__lowerCAmelCase ,					__lowerCAmelCase       )
      else:
        _UpperCAmelCase    			=   nn.LayerNorm(__lowerCAmelCase ,					elementwise_affine=__lowerCAmelCase       )
      _UpperCAmelCase    			=   Attention(
          query_dim=__lowerCAmelCase ,					heads=__lowerCAmelCase ,					dim_head=__lowerCAmelCase ,					dropout=__lowerCAmelCase ,					bias=__lowerCAmelCase ,					cross_attention_dim=cross_attention_dim if only_cross_attention else None ,					upcast_attention=__lowerCAmelCase ,					)

      # 2. Cross-Attn
      if cross_attention_dim is not None or double_self_attention:
        # We currently only use AdaLayerNormZero for self attention where there will only be one attention block.
        # I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during
        # the second cross attention block.
        _UpperCAmelCase    			=   (
            AdaLayerNorm(__lowerCAmelCase ,					__lowerCAmelCase       )
            if self.use_ada_layer_norm
            else nn.LayerNorm(__lowerCAmelCase ,					elementwise_affine=__lowerCAmelCase       )
        )
        _UpperCAmelCase    			=   Attention(
            query_dim=__lowerCAmelCase ,					cross_attention_dim=cross_attention_dim if not double_self_attention else None ,					heads=__lowerCAmelCase ,					dim_head=__lowerCAmelCase ,					dropout=__lowerCAmelCase ,					bias=__lowerCAmelCase ,					upcast_attention=__lowerCAmelCase ,					)  # is self-attn if encoder_hidden_states is none
      else:
        _UpperCAmelCase    			=   None
        _UpperCAmelCase    			=   None

      # 3. Feed-forward
      _UpperCAmelCase    			=   nn.LayerNorm(__lowerCAmelCase ,					elementwise_affine=__lowerCAmelCase       )
      _UpperCAmelCase    			=   FeedForward(__lowerCAmelCase ,					dropout=__lowerCAmelCase ,					activation_fn=__lowerCAmelCase ,					final_dropout=__lowerCAmelCase       )

      # let chunk size default to None
      _UpperCAmelCase    			=   None
      _UpperCAmelCase    			=   0


    def   lowerCAmelCase_	(       self						:	Dict ,					__lowerCAmelCase						:	Optional[int] ,					__lowerCAmelCase						:	int       ):
      # Sets chunk feed-forward
      _UpperCAmelCase    			=   chunk_size
      _UpperCAmelCase    			=   dim


    def   lowerCAmelCase_	(       self						:	List[Any] ,					__lowerCAmelCase						:	torch.FloatTensor ,					__lowerCAmelCase						:	Optional[torch.FloatTensor] = None ,					__lowerCAmelCase						:	Optional[torch.FloatTensor] = None ,					__lowerCAmelCase						:	Optional[torch.FloatTensor] = None ,					__lowerCAmelCase						:	Optional[torch.LongTensor] = None ,					__lowerCAmelCase						:	Dict[str, Any] = None ,					__lowerCAmelCase						:	Optional[torch.LongTensor] = None ,					):
      # Notice that normalization is always applied before the real computation in the following blocks.
      # 1. Self-Attention
      if self.use_ada_layer_norm:
        _UpperCAmelCase    			=   self.norma(__lowerCAmelCase ,					__lowerCAmelCase       )
      elif self.use_ada_layer_norm_zero:
        _UpperCAmelCase    			=   self.norma(
            __lowerCAmelCase ,					__lowerCAmelCase ,					__lowerCAmelCase ,					hidden_dtype=hidden_states.dtype       )
      else:
        _UpperCAmelCase    			=   self.norma(__lowerCAmelCase       )

      _UpperCAmelCase    			=   cross_attention_kwargs if cross_attention_kwargs is not None else {}

      _UpperCAmelCase    			=   self.attna(
          __lowerCAmelCase ,					encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None ,					attention_mask=__lowerCAmelCase ,					**__lowerCAmelCase ,					)
      if self.use_ada_layer_norm_zero:
        _UpperCAmelCase    			=   gate_msa.unsqueeze(1       ) * attn_output
      _UpperCAmelCase    			=   attn_output + hidden_states

      # 2. Cross-Attention
      if self.attna is not None:
        _UpperCAmelCase    			=   (
            self.norma(__lowerCAmelCase ,					__lowerCAmelCase       ) if self.use_ada_layer_norm else self.norma(__lowerCAmelCase       )
        )

        _UpperCAmelCase    			=   self.attna(
            __lowerCAmelCase ,					encoder_hidden_states=__lowerCAmelCase ,					attention_mask=__lowerCAmelCase ,					**__lowerCAmelCase ,					)
        _UpperCAmelCase    			=   attn_output + hidden_states

      # 3. Feed-forward
      _UpperCAmelCase    			=   self.norma(__lowerCAmelCase       )

      if self.use_ada_layer_norm_zero:
        _UpperCAmelCase    			=   norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]

      if self._chunk_size is not None:
        # "feed_forward_chunk_size" can be used to save memory
        if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0:
          raise ValueError(
              f'''`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.'''       )

        _UpperCAmelCase    			=   norm_hidden_states.shape[self._chunk_dim] // self._chunk_size
        _UpperCAmelCase    			=   torch.cat(
            [self.ff(__lowerCAmelCase       ) for hid_slice in norm_hidden_states.chunk(__lowerCAmelCase ,					dim=self._chunk_dim       )] ,					dim=self._chunk_dim ,					)
      else:
        _UpperCAmelCase    			=   self.ff(__lowerCAmelCase       )

      if self.use_ada_layer_norm_zero:
        _UpperCAmelCase    			=   gate_mlp.unsqueeze(1       ) * ff_output

      _UpperCAmelCase    			=   ff_output + hidden_states

      return hidden_states



class 							a					(		nn.Module ):


    def __init__(       self						:	Optional[Any] ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	Optional[int] = None ,					__lowerCAmelCase						:	int = 4 ,					__lowerCAmelCase						:	float = 0.0 ,					__lowerCAmelCase						:	str = "geglu" ,					__lowerCAmelCase						:	bool = False ,					):
      super().__init__()
      _UpperCAmelCase    			=   int(dim * mult       )
      _UpperCAmelCase    			=   dim_out if dim_out is not None else dim

      if activation_fn == "gelu":
        _UpperCAmelCase    			=   GELU(__lowerCAmelCase ,					__lowerCAmelCase       )
      if activation_fn == "gelu-approximate":
        _UpperCAmelCase    			=   GELU(__lowerCAmelCase ,					__lowerCAmelCase ,					approximate="""tanh"""       )
      elif activation_fn == "geglu":
        _UpperCAmelCase    			=   GEGLU(__lowerCAmelCase ,					__lowerCAmelCase       )
      elif activation_fn == "geglu-approximate":
        _UpperCAmelCase    			=   ApproximateGELU(__lowerCAmelCase ,					__lowerCAmelCase       )

      _UpperCAmelCase    			=   nn.ModuleList([]       )
      # project in
      self.net.append(__lowerCAmelCase       )
      # project dropout
      self.net.append(nn.Dropout(__lowerCAmelCase       )       )
      # project out
      self.net.append(nn.Linear(__lowerCAmelCase ,					__lowerCAmelCase       )       )
      # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
      if final_dropout:
        self.net.append(nn.Dropout(__lowerCAmelCase       )       )


    def   lowerCAmelCase_	(       self						:	Dict ,					__lowerCAmelCase						:	int       ):
      for module in self.net:
        _UpperCAmelCase    			=   module(__lowerCAmelCase       )
      return hidden_states



class 							a					(		nn.Module ):


    def __init__(       self						:	List[Any] ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	str = "none"       ):
      super().__init__()
      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					__lowerCAmelCase       )
      _UpperCAmelCase    			=   approximate


    def   lowerCAmelCase_	(       self						:	Optional[int] ,					__lowerCAmelCase						:	Union[str, Any]       ):
      if gate.device.type != "mps":
        return F.gelu(__lowerCAmelCase ,					approximate=self.approximate       )
      # mps: gelu is not implemented for float16
      return F.gelu(gate.to(dtype=torch.floataa       ) ,					approximate=self.approximate       ).to(dtype=gate.dtype       )


    def   lowerCAmelCase_	(       self						:	int ,					__lowerCAmelCase						:	str       ):
      _UpperCAmelCase    			=   self.proj(__lowerCAmelCase       )
      _UpperCAmelCase    			=   self.gelu(__lowerCAmelCase       )
      return hidden_states



class 							a					(		nn.Module ):


    def __init__(       self						:	Union[str, Any] ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int       ):
      super().__init__()
      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					dim_out * 2       )


    def   lowerCAmelCase_	(       self						:	int ,					__lowerCAmelCase						:	int       ):
      if gate.device.type != "mps":
        return F.gelu(__lowerCAmelCase       )
      # mps: gelu is not implemented for float16
      return F.gelu(gate.to(dtype=torch.floataa       )       ).to(dtype=gate.dtype       )


    def   lowerCAmelCase_	(       self						:	Tuple ,					__lowerCAmelCase						:	Dict       ):
      _UpperCAmelCase    			=   self.proj(__lowerCAmelCase       ).chunk(2 ,					dim=-1       )
      return hidden_states * self.gelu(__lowerCAmelCase       )



class 							a					(		nn.Module ):


    def __init__(       self						:	Optional[int] ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int       ):
      super().__init__()
      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					__lowerCAmelCase       )


    def   lowerCAmelCase_	(       self						:	int ,					__lowerCAmelCase						:	str       ):
      _UpperCAmelCase    			=   self.proj(__lowerCAmelCase       )
      return x * torch.sigmoid(1.702 * x       )



class 							a					(		nn.Module ):


    def __init__(       self						:	str ,					__lowerCAmelCase						:	str ,					__lowerCAmelCase						:	Tuple       ):
      super().__init__()
      _UpperCAmelCase    			=   nn.Embedding(__lowerCAmelCase ,					__lowerCAmelCase       )
      _UpperCAmelCase    			=   nn.SiLU()
      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					embedding_dim * 2       )
      _UpperCAmelCase    			=   nn.LayerNorm(__lowerCAmelCase ,					elementwise_affine=__lowerCAmelCase       )


    def   lowerCAmelCase_	(       self						:	str ,					__lowerCAmelCase						:	Any ,					__lowerCAmelCase						:	Tuple       ):
      _UpperCAmelCase    			=   self.linear(self.silu(self.emb(__lowerCAmelCase       )       )       )
      _UpperCAmelCase    			=   torch.chunk(__lowerCAmelCase ,					2       )
      _UpperCAmelCase    			=   self.norm(__lowerCAmelCase       ) * (1 + scale) + shift
      return x



class 							a					(		nn.Module ):


    def __init__(       self						:	Union[str, Any] ,					__lowerCAmelCase						:	Optional[Any] ,					__lowerCAmelCase						:	List[Any]       ):
      super().__init__()

      _UpperCAmelCase    			=   CombinedTimestepLabelEmbeddings(__lowerCAmelCase ,					__lowerCAmelCase       )

      _UpperCAmelCase    			=   nn.SiLU()
      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					6 * embedding_dim ,					bias=__lowerCAmelCase       )
      _UpperCAmelCase    			=   nn.LayerNorm(__lowerCAmelCase ,					elementwise_affine=__lowerCAmelCase ,					eps=1e-6       )


    def   lowerCAmelCase_	(       self						:	List[Any] ,					__lowerCAmelCase						:	Dict ,					__lowerCAmelCase						:	Optional[Any] ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	Dict=None       ):
      _UpperCAmelCase    			=   self.linear(self.silu(self.emb(__lowerCAmelCase ,					__lowerCAmelCase ,					hidden_dtype=__lowerCAmelCase       )       )       )
      _UpperCAmelCase    			=   emb.chunk(6 ,					dim=1       )
      _UpperCAmelCase    			=   self.norm(__lowerCAmelCase       ) * (1 + scale_msa[:, None]) + shift_msa[:, None]
      return x, gate_msa, shift_mlp, scale_mlp, gate_mlp



class 							a					(		nn.Module ):


    def __init__(       self						:	Dict ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	int ,					__lowerCAmelCase						:	Optional[str] = None ,					__lowerCAmelCase						:	float = 1e-5       ):
      super().__init__()
      _UpperCAmelCase    			=   num_groups
      _UpperCAmelCase    			=   eps

      if act_fn is None:
        _UpperCAmelCase    			=   None
      else:
        _UpperCAmelCase    			=   get_activation(__lowerCAmelCase       )

      _UpperCAmelCase    			=   nn.Linear(__lowerCAmelCase ,					out_dim * 2       )


    def   lowerCAmelCase_	(       self						:	Dict ,					__lowerCAmelCase						:	List[str] ,					__lowerCAmelCase						:	Any       ):
      if self.act:
        _UpperCAmelCase    			=   self.act(__lowerCAmelCase       )
      _UpperCAmelCase    			=   self.linear(__lowerCAmelCase       )
      _UpperCAmelCase    			=   emb[:, :, None, None]
      _UpperCAmelCase    			=   emb.chunk(2 ,					dim=1       )

      _UpperCAmelCase    			=   F.group_norm(__lowerCAmelCase ,					self.num_groups ,					eps=self.eps       )
      _UpperCAmelCase    			=   x * (1 + scale) + shift
      return x





"""simple docstring"""




import random

import torch
from huggingface_hub import HfApi

from diffusers import UNetaDModel


_lowerCAmelCase							:   Any				=				HfApi()

_lowerCAmelCase							:   int				=				{}
# fmt: off
_lowerCAmelCase							:   List[Any]				=				torch.tensor([
    -0.7_5_1_5, -1.6_8_8_3, 0.2_4_2_0, 0.0_3_0_0, 0.6_3_4_7, 1.3_4_3_3, -1.1_7_4_3, -3.7_4_6_7,
    1.2_3_4_2, -2.2_4_8_5, 0.4_6_3_6, 0.8_0_7_6, -0.7_9_9_1, 0.3_9_6_9, 0.8_4_9_8, 0.9_1_8_9,
    -1.8_8_8_7, -3.3_5_2_2, 0.7_6_3_9, 0.2_0_4_0, 0.6_2_7_1, -2.7_1_4_8, -1.6_3_1_6, 3.0_8_3_9,
    0.3_1_8_6, 0.2_7_2_1, -0.9_7_5_9, -1.2_4_6_1, 2.6_2_5_7, 1.3_5_5_7
])
_lowerCAmelCase							:   Any				=				torch.tensor([
    -2.3_6_3_9, -2.5_3_4_4, 0.0_0_5_4, -0.6_6_7_4, 1.5_9_9_0, 1.0_1_5_8, 0.3_1_2_4, -2.1_4_3_6,
    1.8_7_9_5, -2.5_4_2_9, -0.1_5_6_6, -0.3_9_7_3, 1.2_4_9_0, 2.6_4_4_7, 1.2_2_8_3, -0.5_2_0_8,
    -2.8_1_5_4, -3.5_1_1_9, 2.3_8_3_8, 1.2_0_3_3, 1.7_2_0_1, -2.1_2_5_6, -1.4_5_7_6, 2.7_9_4_8,
    2.4_2_0_4, -0.9_7_5_2, -1.2_5_4_6, 0.8_0_2_7, 3.2_7_5_8, 3.1_3_6_5
])
_lowerCAmelCase							:   List[str]				=				torch.tensor([
    -0.6_5_3_1, -0.6_8_9_1, -0.3_1_7_2, -0.5_3_7_5, -0.9_1_4_0, -0.5_3_6_7, -0.1_1_7_5, -0.7_8_6_9,
    -0.3_8_0_8, -0.4_5_1_3, -0.2_0_9_8, -0.0_0_8_3, 0.3_1_8_3, 0.5_1_4_0, 0.2_2_4_7, -0.1_3_0_4,
    -0.1_3_0_2, -0.2_8_0_2, -0.2_0_8_4, -0.2_0_2_5, -0.4_9_6_7, -0.4_8_7_3, -0.0_8_6_1, 0.6_9_2_5,
    0.0_2_5_0, 0.1_2_9_0, -0.1_5_4_3, 0.6_3_1_6, 1.0_4_6_0, 1.4_9_4_3
])
_lowerCAmelCase							:   Optional[int]				=				torch.tensor([
    0.0_9_1_1, 0.1_1_0_7, 0.0_1_8_2, 0.0_4_3_5, -0.0_8_0_5, -0.0_6_0_8, 0.0_3_8_1, 0.2_1_7_2,
    -0.0_2_8_0, 0.1_3_2_7, -0.0_2_9_9, -0.0_2_5_5, -0.0_0_5_0, -0.1_1_7_0, -0.1_0_4_6, 0.0_3_0_9,
    0.1_3_6_7, 0.1_7_2_8, -0.0_5_3_3, -0.0_7_4_8, -0.0_5_3_4, 0.1_6_2_4, 0.0_3_8_4, -0.1_8_0_5,
    -0.0_7_0_7, 0.0_6_4_2, 0.0_2_2_0, -0.0_1_3_4, -0.1_3_3_3, -0.1_5_0_5
])
_lowerCAmelCase							:   List[Any]				=				torch.tensor([
    0.1_3_2_1, 0.1_3_3_7, 0.0_4_4_0, 0.0_6_2_2, -0.0_5_9_1, -0.0_3_7_0, 0.0_5_0_3, 0.2_1_3_3,
    -0.0_1_7_7, 0.1_4_1_5, -0.0_1_1_6, -0.0_1_1_2, 0.0_0_4_4, -0.0_9_8_0, -0.0_7_8_9, 0.0_3_9_5,
    0.1_5_0_2, 0.1_7_8_5, -0.0_4_8_8, -0.0_5_1_4, -0.0_4_0_4, 0.1_5_3_9, 0.0_4_5_4, -0.1_5_5_9,
    -0.0_6_6_5, 0.0_6_5_9, 0.0_3_8_3, -0.0_0_0_5, -0.1_2_6_6, -0.1_3_8_6
])
_lowerCAmelCase							:   Optional[int]				=				torch.tensor([
    0.1_1_5_4, 0.1_2_1_8, 0.0_3_0_7, 0.0_5_2_6, -0.0_7_1_1, -0.0_5_4_1, 0.0_3_6_6, 0.2_0_7_8,
    -0.0_2_6_7, 0.1_3_1_7, -0.0_2_2_6, -0.0_1_9_3, -0.0_0_1_4, -0.1_0_5_5, -0.0_9_0_2, 0.0_3_3_0,
    0.1_3_9_1, 0.1_7_0_9, -0.0_5_6_2, -0.0_6_9_3, -0.0_5_6_0, 0.1_4_8_2, 0.0_3_8_1, -0.1_6_8_3,
    -0.0_6_8_1, 0.0_6_6_1, 0.0_3_3_1, -0.0_0_4_6, -0.1_2_6_8, -0.1_4_3_1
])
_lowerCAmelCase							:   Optional[Any]				=				torch.tensor([
    0.1_1_9_2, 0.1_2_4_0, 0.0_4_1_4, 0.0_6_0_6, -0.0_5_5_7, -0.0_4_1_2, 0.0_4_3_0, 0.2_0_4_2,
    -0.0_2_0_0, 0.1_3_8_5, -0.0_1_1_5, -0.0_1_3_2, 0.0_0_1_7, -0.0_9_6_5, -0.0_8_0_2, 0.0_3_9_8,
    0.1_4_3_3, 0.1_7_4_7, -0.0_4_5_8, -0.0_5_3_3, -0.0_4_0_7, 0.1_5_4_5, 0.0_4_1_9, -0.1_5_7_4,
    -0.0_6_4_5, 0.0_6_2_6, 0.0_3_4_1, -0.0_0_1_0, -0.1_1_9_9, -0.1_3_9_0
])
_lowerCAmelCase							:   List[str]				=				torch.tensor([
    0.1_0_7_5, 0.1_0_7_4, 0.0_2_0_5, 0.0_4_3_1, -0.0_7_7_4, -0.0_6_0_7, 0.0_2_9_8, 0.2_0_4_2,
    -0.0_3_2_0, 0.1_2_6_7, -0.0_2_8_1, -0.0_2_5_0, -0.0_0_6_4, -0.1_0_9_1, -0.0_9_4_6, 0.0_2_9_0,
    0.1_3_2_8, 0.1_6_5_0, -0.0_5_8_0, -0.0_7_3_8, -0.0_5_8_6, 0.1_4_4_0, 0.0_3_3_7, -0.1_7_4_6,
    -0.0_7_1_2, 0.0_6_0_5, 0.0_2_5_0, -0.0_0_9_9, -0.1_3_1_6, -0.1_4_7_3
])
_lowerCAmelCase							:   Any				=				torch.tensor([
    -1.4_5_7_2, -2.0_4_8_1, -0.0_4_1_4, -0.6_0_0_5, 1.4_1_3_6, 0.5_8_4_8, 0.4_0_2_8, -2.7_3_3_0,
    1.2_2_1_2, -2.1_2_2_8, 0.2_1_5_5, 0.4_0_3_9, 0.7_6_6_2, 2.0_5_3_5, 0.7_4_7_7, -0.3_2_4_3,
    -2.1_7_5_8, -2.7_6_4_8, 1.6_9_4_7, 0.7_0_2_6, 1.2_3_3_8, -1.6_0_7_8, -0.8_6_8_2, 2.2_8_1_0,
    1.8_5_7_4, -0.5_7_1_8, -0.5_5_8_6, -0.0_1_8_6, 2.3_4_1_5, 2.1_2_5_1])
_lowerCAmelCase							:   int				=				torch.tensor([
    -1.3_6_9_0, -1.9_7_2_0, -0.4_0_9_0, -0.6_9_6_6, 1.4_6_6_0, 0.9_9_3_8, -0.1_3_8_5, -2.7_3_2_4,
    0.7_7_3_6, -1.8_9_1_7, 0.2_9_2_3, 0.4_2_9_3, 0.1_6_9_3, 1.4_1_1_2, 1.1_8_8_7, -0.3_1_8_1,
    -2.2_1_6_0, -2.6_3_8_1, 1.3_1_7_0, 0.8_1_6_3, 0.9_2_4_0, -1.6_5_4_4, -0.6_0_9_9, 2.5_2_5_9,
    1.6_4_3_0, -0.9_0_9_0, -0.9_3_9_2, -0.0_1_2_6, 2.4_2_6_8, 2.3_2_6_6
])
_lowerCAmelCase							:   Union[str, Any]				=				torch.tensor([
    -1.3_5_2_5, -1.9_6_2_8, -0.3_9_5_6, -0.6_8_6_0, 1.4_6_6_4, 1.0_0_1_4, -0.1_2_5_9, -2.7_2_1_2,
    0.7_7_7_2, -1.8_8_1_1, 0.2_9_9_6, 0.4_3_8_8, 0.1_7_0_4, 1.4_0_2_9, 1.1_7_0_1, -0.3_0_2_7,
    -2.2_0_5_3, -2.6_2_8_7, 1.3_3_5_0, 0.8_1_3_1, 0.9_2_7_4, -1.6_2_9_2, -0.6_0_9_8, 2.5_1_3_1,
    1.6_5_0_5, -0.8_9_5_8, -0.9_2_9_8, -0.0_1_5_1, 2.4_2_5_7, 2.3_3_5_5
])
_lowerCAmelCase							:   str				=				torch.tensor([
    -2.0_5_8_5, -2.7_8_9_7, -0.2_8_5_0, -0.8_9_4_0, 1.9_0_5_2, 0.5_7_0_2, 0.6_3_4_5, -3.8_9_5_9,
    1.5_9_3_2, -3.2_3_1_9, 0.1_9_7_4, 0.0_2_8_7, 1.7_5_6_6, 2.6_5_4_3, 0.8_3_8_7, -0.5_3_5_1,
    -3.2_7_3_6, -4.3_3_7_5, 2.9_0_2_9, 1.6_3_9_0, 1.4_6_4_0, -2.1_7_0_1, -1.9_0_1_3, 2.9_3_4_1,
    3.4_9_8_1, -0.6_2_5_5, -1.1_6_4_4, -0.1_5_9_1, 3.7_0_9_7, 3.2_0_6_6
])
_lowerCAmelCase							:   Optional[int]				=				torch.tensor([
    -2.3_1_3_9, -2.5_5_9_4, -0.0_1_9_7, -0.6_7_8_5, 1.7_0_0_1, 1.1_6_0_6, 0.3_0_7_5, -2.1_7_4_0,
    1.8_0_7_1, -2.5_6_3_0, -0.0_9_2_6, -0.3_8_1_1, 1.2_1_1_6, 2.6_2_4_6, 1.2_7_3_1, -0.5_3_9_8,
    -2.8_1_5_3, -3.6_1_4_0, 2.3_8_9_3, 1.3_2_6_2, 1.6_2_5_8, -2.1_8_5_6, -1.3_2_6_7, 2.8_3_9_5,
    2.3_7_7_9, -1.0_6_2_3, -1.2_4_6_8, 0.8_9_5_9, 3.3_3_6_7, 3.2_2_4_3
])
_lowerCAmelCase							:   Union[str, Any]				=				torch.tensor([
    -2.0_6_2_8, -2.7_6_6_7, -0.2_0_8_9, -0.8_2_6_3, 2.0_5_3_9, 0.5_9_9_2, 0.6_4_9_5, -3.8_3_3_6,
    1.6_0_2_5, -3.2_8_1_7, 0.1_7_2_1, -0.0_6_3_3, 1.7_5_1_6, 2.7_0_3_9, 0.8_1_0_0, -0.5_9_0_8,
    -3.2_1_1_3, -4.4_3_4_3, 2.9_2_5_7, 1.3_6_3_2, 1.5_5_6_2, -2.1_4_8_9, -1.9_8_9_4, 3.0_5_6_0,
    3.3_3_9_6, -0.7_3_2_8, -1.0_4_1_7, 0.0_3_8_3, 3.7_0_9_3, 3.2_3_4_3
])
_lowerCAmelCase							:   Any				=				torch.tensor([
    -1.4_5_7_4, -2.0_5_6_9, -0.0_4_7_3, -0.6_1_1_7, 1.4_0_1_8, 0.5_7_6_9, 0.4_1_2_9, -2.7_3_4_4,
    1.2_2_4_1, -2.1_3_9_7, 0.2_0_0_0, 0.3_9_3_7, 0.7_6_1_6, 2.0_4_5_3, 0.7_3_2_4, -0.3_3_9_1,
    -2.1_7_4_6, -2.7_7_4_4, 1.6_9_6_3, 0.6_9_2_1, 1.2_1_8_7, -1.6_1_7_2, -0.8_8_7_7, 2.2_4_3_9,
    1.8_4_7_1, -0.5_8_3_9, -0.5_6_0_5, -0.0_4_6_4, 2.3_2_5_0, 2.1_2_1_9
])
# fmt: on

_lowerCAmelCase							:   Optional[Any]				=				api.list_models(filter="diffusers")
for mod in models:
 if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256":
  _lowerCAmelCase							:   List[Any]				=				"/home/patrick/google_checkpoints/" + mod.modelId.split("/")[-1]

  print(F"Started running {mod.modelId}!!!")

  if mod.modelId.startswith("CompVis"):
   _lowerCAmelCase							:   Tuple				=				UNetaDModel.from_pretrained(local_checkpoint, subfolder="unet")
  else:
   _lowerCAmelCase							:   List[Any]				=				UNetaDModel.from_pretrained(local_checkpoint)

  torch.manual_seed(0)
  random.seed(0)

  _lowerCAmelCase							:   Optional[Any]				=				torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
  _lowerCAmelCase							:   Tuple				=				torch.tensor([10] * noise.shape[0])
  with torch.no_grad():
   _lowerCAmelCase							:   Optional[Any]				=				model(noise, time_step).sample

  assert torch.allclose(
      logits[0, 0, 0, :30], results["_".join("_".join(mod.modelId.split("/")).split("-"))], atol=1E-3
  )
  print(F"{mod.modelId} has passed successfully!!!")
