

'''simple docstring'''







import collections
import gzip
import os
import urllib

import numpy
from tensorflow.python.framework import dtypes, random_seed
from tensorflow.python.platform import gfile
from tensorflow.python.util.deprecation import deprecated

__lowerCamelCase						    =      collections.namedtuple('''_Datasets''', ['''train''', '''validation''', '''test'''])

# CVDF mirror of http://yann.lecun.com/exdb/mnist/
__lowerCamelCase						    =      '''https://storage.googleapis.com/cvdf-datasets/mnist/'''
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     Tuple:
       A_		   = numpy.dtype(numpy.uintaa			).newbyteorder(""">"""			)
       return numpy.frombuffer(bytestream.read(4			),    dtype=UpperCAmelCase__			)[0]
@deprecated(UpperCAmelCase__,    """Please use tf.data to implement this functionality."""			)
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     List[str]:
       print("""Extracting""",    f.name			)
       with gzip.GzipFile(fileobj=UpperCAmelCase__			) as bytestream:
              A_		   = _readaa(UpperCAmelCase__			)
              if magic != 20_51:
                     raise ValueError(
                         """Invalid magic number %d in MNIST image file: %s""" % (magic, f.name)			)
              A_		   = _readaa(UpperCAmelCase__			)
              A_		   = _readaa(UpperCAmelCase__			)
              A_		   = _readaa(UpperCAmelCase__			)
              A_		   = bytestream.read(rows * cols * num_images			)
              A_		   = numpy.frombuffer(UpperCAmelCase__,    dtype=numpy.uinta			)
              A_		   = data.reshape(UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__,    1			)
              return data
@deprecated(UpperCAmelCase__,    """Please use tf.one_hot on tensors."""			)
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__			)     ->     Union[str, Any]:
       A_		   = labels_dense.shape[0]
       A_		   = numpy.arange(UpperCAmelCase__			) * num_classes
       A_		   = numpy.zeros((num_labels, num_classes)			)
       A_		   = 1
       return labels_one_hot
@deprecated(UpperCAmelCase__,    """Please use tf.data to implement this functionality."""			)
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__=False,    UpperCAmelCase__=10			)     ->     str:
       print("""Extracting""",    f.name			)
       with gzip.GzipFile(fileobj=UpperCAmelCase__			) as bytestream:
              A_		   = _readaa(UpperCAmelCase__			)
              if magic != 20_49:
                     raise ValueError(
                         """Invalid magic number %d in MNIST label file: %s""" % (magic, f.name)			)
              A_		   = _readaa(UpperCAmelCase__			)
              A_		   = bytestream.read(UpperCAmelCase__			)
              A_		   = numpy.frombuffer(UpperCAmelCase__,    dtype=numpy.uinta			)
              if one_hot:
                     return _dense_to_one_hot(UpperCAmelCase__,    UpperCAmelCase__			)
              return labels


class    A__ :



    @deprecated(
        UpperCamelCase__						,			"""Please use alternatives such as official/mnist/_DataSet.py"""
        """ from tensorflow/models."""						,			)
    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__=False						,			UpperCamelCase__=False						,			UpperCamelCase__=dtypes.floataa						,			UpperCamelCase__=True						,			UpperCamelCase__=None						,			)  -> List[str]:





           '''simple docstring'''
           A_   ,     A_		   = random_seed.get_seed(UpperCamelCase__    )
           # If op level seed is not set, use whatever graph level seed is returned
           numpy.random.seed(seeda if seed is None else seeda    )
           A_		   = dtypes.as_dtype(UpperCamelCase__    ).base_dtype
           if dtype not in (dtypes.uinta, dtypes.floataa):
                  raise TypeError("""Invalid image dtype %r, expected uint8 or float32""" % dtype    )
           if fake_data:
                  A_		   = 10000
                  A_		   = one_hot
           else:
                  assert (
                      images.shape[0] == labels.shape[0]
                  ), f'''images.shape: {images.shape} labels.shape: {labels.shape}'''
                  A_		   = images.shape[0]

                  # Convert shape from [num examples, rows, columns, depth]
                  # to [num examples, rows*columns] (assuming depth == 1)
                  if reshape:
                         assert images.shape[3] == 1
                         A_		   = images.reshape(
                             images.shape[0]						,			images.shape[1] * images.shape[2]    )
                  if dtype == dtypes.floataa:
                         # Convert from [0, 255] -> [0.0, 1.0].
                         A_		   = images.astype(numpy.floataa    )
                         A_		   = numpy.multiply(UpperCamelCase__						,			1.0 / 255.0    )
           A_		   = images
           A_		   = labels
           A_		   = 0
           A_		   = 0



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._images



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._labels



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._num_examples



    @property
    def    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           return self._epochs_completed







    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__=False						,			UpperCamelCase__=True    )  -> Union[str, Any]:





           '''simple docstring'''
           if fake_data:
                  A_		   = [1] * 784
                  A_		   = [1] + [0] * 9 if self.one_hot else 0
                  return (
                      [fake_image for _ in range(UpperCamelCase__    )],
                      [fake_label for _ in range(UpperCamelCase__    )],
                  )
           A_		   = self._index_in_epoch
           # Shuffle for the first epoch
           if self._epochs_completed == 0 and start == 0 and shuffle:
                  A_		   = numpy.arange(self._num_examples    )
                  numpy.random.shuffle(UpperCamelCase__    )
                  A_		   = self.images[perma]
                  A_		   = self.labels[perma]
           # Go to the next epoch
           if start + batch_size > self._num_examples:
                  # Finished epoch
                  self._epochs_completed += 1
                  # Get the rest examples in this epoch
                  A_		   = self._num_examples - start
                  A_		   = self._images[start : self._num_examples]
                  A_		   = self._labels[start : self._num_examples]
                  # Shuffle the data
                  if shuffle:
                         A_		   = numpy.arange(self._num_examples    )
                         numpy.random.shuffle(UpperCamelCase__    )
                         A_		   = self.images[perm]
                         A_		   = self.labels[perm]
                  # Start next epoch
                  A_		   = 0
                  A_		   = batch_size - rest_num_examples
                  A_		   = self._index_in_epoch
                  A_		   = self._images[start:end]
                  A_		   = self._labels[start:end]
                  return (
                      numpy.concatenate((images_rest_part, images_new_part)						,			axis=0    ),
                      numpy.concatenate((labels_rest_part, labels_new_part)						,			axis=0    ),
                  )
           else:
                  self._index_in_epoch += batch_size
                  A_		   = self._index_in_epoch
                  return self._images[start:end], self._labels[start:end]

@deprecated(UpperCAmelCase__,    """Please write your own downloading logic."""			)
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__			)     ->     Union[str, Any]:
       if not gfile.Exists(UpperCAmelCase__			):
              gfile.MakeDirs(UpperCAmelCase__			)
       A_		   = os.path.join(UpperCAmelCase__,    UpperCAmelCase__			)
       if not gfile.Exists(UpperCAmelCase__			):
              urllib.request.urlretrieve(UpperCAmelCase__,    UpperCAmelCase__			)  # noqa: S310
              with gfile.GFile(UpperCAmelCase__			) as f:
                     A_		   = f.size()
              print("""Successfully downloaded""",    UpperCAmelCase__,    UpperCAmelCase__,    """bytes."""			)
       return filepath







@deprecated(
    UpperCAmelCase__,    """Please use alternatives such as:""" """ tensorflow_datasets.load('mnist')"""			)
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__=False,    UpperCAmelCase__=False,    UpperCAmelCase__=dtypes.floataa,    UpperCAmelCase__=True,    UpperCAmelCase__=50_00,    UpperCAmelCase__=None,    UpperCAmelCase__=DEFAULT_SOURCE_URL,    )     ->     List[str]:
       if fake_data:

              def fake():
                     return _DataSet(
                         [],    [],    fake_data=UpperCAmelCase__,    one_hot=UpperCAmelCase__,    dtype=UpperCAmelCase__,    seed=UpperCAmelCase__			)

              A_		   = fake()
              A_		   = fake()
              A_		   = fake()
              return _Datasets(train=UpperCAmelCase__,    validation=UpperCAmelCase__,    test=UpperCAmelCase__			)

       if not source_url:  # empty string check
              A_		   = DEFAULT_SOURCE_URL

       A_		   = """train-images-idx3-ubyte.gz"""
       A_		   = """train-labels-idx1-ubyte.gz"""
       A_		   = """t10k-images-idx3-ubyte.gz"""
       A_		   = """t10k-labels-idx1-ubyte.gz"""

       A_		   = _maybe_download(
           UpperCAmelCase__,    UpperCAmelCase__,    source_url + train_images_file			)
       with gfile.Open(UpperCAmelCase__,    """rb"""			) as f:
              A_		   = _extract_images(UpperCAmelCase__			)

       A_		   = _maybe_download(
           UpperCAmelCase__,    UpperCAmelCase__,    source_url + train_labels_file			)
       with gfile.Open(UpperCAmelCase__,    """rb"""			) as f:
              A_		   = _extract_labels(UpperCAmelCase__,    one_hot=UpperCAmelCase__			)

       A_		   = _maybe_download(
           UpperCAmelCase__,    UpperCAmelCase__,    source_url + test_images_file			)
       with gfile.Open(UpperCAmelCase__,    """rb"""			) as f:
              A_		   = _extract_images(UpperCAmelCase__			)

       A_		   = _maybe_download(
           UpperCAmelCase__,    UpperCAmelCase__,    source_url + test_labels_file			)
       with gfile.Open(UpperCAmelCase__,    """rb"""			) as f:
              A_		   = _extract_labels(UpperCAmelCase__,    one_hot=UpperCAmelCase__			)

       if not 0 <= validation_size <= len(UpperCAmelCase__			):
              A_		   = (
                  """Validation size should be between 0 and """
                  F'''{len(UpperCAmelCase__			)}. Received: {validation_size}.'''
              )
              raise ValueError(UpperCAmelCase__			)

       A_		   = train_images[:validation_size]
       A_		   = train_labels[:validation_size]
       A_		   = train_images[validation_size:]
       A_		   = train_labels[validation_size:]

       A_		   = {"""dtype""": dtype, """reshape""": reshape, """seed""": seed}

       A_		   = _DataSet(UpperCAmelCase__,    UpperCAmelCase__,    **UpperCAmelCase__			)
       A_		   = _DataSet(UpperCAmelCase__,    UpperCAmelCase__,    **UpperCAmelCase__			)
       A_		   = _DataSet(UpperCAmelCase__,    UpperCAmelCase__,    **UpperCAmelCase__			)

       return _Datasets(train=UpperCAmelCase__,    validation=UpperCAmelCase__,    test=UpperCAmelCase__			)



'''simple docstring'''







from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)


@flax.struct.dataclass
class    A__ ( _snake_case     ):
    lowercase		   =						42
    lowercase		   =						42


class    A__ ( nn.Module     ):
    lowercase		   =						42
    lowercase		   =						(16, 32, 96, 256)
    lowercase		   =						jnp.floataa



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = nn.Conv(
               self.block_out_channels[0]						,			kernel_size=(3, 3)						,			padding=((1, 1), (1, 1))						,			dtype=self.dtype						,			)

           A_		   = []
           for i in range(len(self.block_out_channels    ) - 1    ):
                  A_		   = self.block_out_channels[i]
                  A_		   = self.block_out_channels[i + 1]
                  A_		   = nn.Conv(
                      UpperCamelCase__						,			kernel_size=(3, 3)						,			padding=((1, 1), (1, 1))						,			dtype=self.dtype						,			)
                  blocks.append(UpperCamelCase__    )
                  A_		   = nn.Conv(
                      UpperCamelCase__						,			kernel_size=(3, 3)						,			strides=(2, 2)						,			padding=((1, 1), (1, 1))						,			dtype=self.dtype						,			)
                  blocks.append(UpperCamelCase__    )
           A_		   = blocks

           A_		   = nn.Conv(
               self.conditioning_embedding_channels						,			kernel_size=(3, 3)						,			padding=((1, 1), (1, 1))						,			kernel_init=nn.initializers.zeros_init()						,			bias_init=nn.initializers.zeros_init()						,			dtype=self.dtype						,			)







    def __call__(   self						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_		   = self.conv_in(UpperCamelCase__    )
           A_		   = nn.silu(UpperCamelCase__    )

           for block in self.blocks:
                  A_		   = block(UpperCamelCase__    )
                  A_		   = nn.silu(UpperCamelCase__    )

           A_		   = self.conv_out(UpperCamelCase__    )

           return embedding


@flax_register_to_config
class    A__ ( nn.Module  ,  _snake_case  ,  _snake_case     ):
    lowercase		   =						32
    lowercase		   =						4
    lowercase		   =						(
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "CrossAttnDownBlock2D",
        "DownBlock2D",
    )
    lowercase		   =						False
    lowercase		   =						(320, 640, 1_280, 1_280)
    lowercase		   =						2
    lowercase		   =						8
    lowercase		   =						None
    lowercase		   =						1_280
    lowercase		   =						0.0
    lowercase		   =						False
    lowercase		   =						jnp.floataa
    lowercase		   =						True
    lowercase		   =						0
    lowercase		   =						"rgb"
    lowercase		   =						(16, 32, 96, 256)



    def    snake_case_     (   self						,			UpperCamelCase__    )  -> FrozenDict:





           '''simple docstring'''
           # init input tensors
           A_		   = (1, self.in_channels, self.sample_size, self.sample_size)
           A_		   = jnp.zeros(UpperCamelCase__						,			dtype=jnp.floataa    )
           A_		   = jnp.ones((1,)						,			dtype=jnp.intaa    )
           A_		   = jnp.zeros((1, 1, self.cross_attention_dim)						,			dtype=jnp.floataa    )
           A_		   = (1, 3, self.sample_size * 8, self.sample_size * 8)
           A_		   = jnp.zeros(UpperCamelCase__						,			dtype=jnp.floataa    )

           A_   ,     A_		   = jax.random.split(UpperCamelCase__    )
           A_		   = {"""params""": params_rng, """dropout""": dropout_rng}

           return self.init(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )["params"]



    def    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           A_		   = self.block_out_channels
           A_		   = block_out_channels[0] * 4

           # If `num_attention_heads` is not defined (which is the case for most models)
           # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
           # The reason for this behavior is to correct for incorrectly named variables that were introduced
           # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
           # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
           # which is why we correct for the naming here.
           A_		   = self.num_attention_heads or self.attention_head_dim

           # input
           A_		   = nn.Conv(
               block_out_channels[0]						,			kernel_size=(3, 3)						,			strides=(1, 1)						,			padding=((1, 1), (1, 1))						,			dtype=self.dtype						,			)

           # time
           A_		   = FlaxTimesteps(
               block_out_channels[0]						,			flip_sin_to_cos=self.flip_sin_to_cos						,			freq_shift=self.config.freq_shift    )
           A_		   = FlaxTimestepEmbedding(UpperCamelCase__						,			dtype=self.dtype    )

           A_		   = FlaxControlNetConditioningEmbedding(
               conditioning_embedding_channels=block_out_channels[0]						,			block_out_channels=self.conditioning_embedding_out_channels						,			)

           A_		   = self.only_cross_attention
           if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = (only_cross_attention,) * len(self.down_block_types    )

           if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                  A_		   = (num_attention_heads,) * len(self.down_block_types    )

           # down
           A_		   = []
           A_		   = []

           A_		   = block_out_channels[0]

           A_		   = nn.Conv(
               UpperCamelCase__						,			kernel_size=(1, 1)						,			padding="""VALID"""						,			kernel_init=nn.initializers.zeros_init()						,			bias_init=nn.initializers.zeros_init()						,			dtype=self.dtype						,			)
           controlnet_down_blocks.append(UpperCamelCase__    )

           for i, down_block_type in enumerate(self.down_block_types    ):
                  A_		   = output_channel
                  A_		   = block_out_channels[i]
                  A_		   = i == len(UpperCamelCase__    ) - 1

                  if down_block_type == "CrossAttnDownBlock2D":
                         A_		   = FlaxCrossAttnDownBlockaD(
                             in_channels=UpperCamelCase__						,			out_channels=UpperCamelCase__						,			dropout=self.dropout						,			num_layers=self.layers_per_block						,			num_attention_heads=num_attention_heads[i]						,			add_downsample=not is_final_block						,			use_linear_projection=self.use_linear_projection						,			only_cross_attention=only_cross_attention[i]						,			dtype=self.dtype						,			)
                  else:
                         A_		   = FlaxDownBlockaD(
                             in_channels=UpperCamelCase__						,			out_channels=UpperCamelCase__						,			dropout=self.dropout						,			num_layers=self.layers_per_block						,			add_downsample=not is_final_block						,			dtype=self.dtype						,			)

                  down_blocks.append(UpperCamelCase__    )

                  for _ in range(self.layers_per_block    ):
                         A_		   = nn.Conv(
                             UpperCamelCase__						,			kernel_size=(1, 1)						,			padding="""VALID"""						,			kernel_init=nn.initializers.zeros_init()						,			bias_init=nn.initializers.zeros_init()						,			dtype=self.dtype						,			)
                         controlnet_down_blocks.append(UpperCamelCase__    )

                  if not is_final_block:
                         A_		   = nn.Conv(
                             UpperCamelCase__						,			kernel_size=(1, 1)						,			padding="""VALID"""						,			kernel_init=nn.initializers.zeros_init()						,			bias_init=nn.initializers.zeros_init()						,			dtype=self.dtype						,			)
                         controlnet_down_blocks.append(UpperCamelCase__    )

           A_		   = down_blocks
           A_		   = controlnet_down_blocks

           # mid
           A_		   = block_out_channels[-1]
           A_		   = FlaxUNetMidBlockaDCrossAttn(
               in_channels=UpperCamelCase__						,			dropout=self.dropout						,			num_attention_heads=num_attention_heads[-1]						,			use_linear_projection=self.use_linear_projection						,			dtype=self.dtype						,			)

           A_		   = nn.Conv(
               UpperCamelCase__						,			kernel_size=(1, 1)						,			padding="""VALID"""						,			kernel_init=nn.initializers.zeros_init()						,			bias_init=nn.initializers.zeros_init()						,			dtype=self.dtype						,			)







    def __call__(   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__ = 1.0						,			UpperCamelCase__ = True						,			UpperCamelCase__ = False						,			)  -> Union[FlaxControlNetOutput, Tuple]:





           '''simple docstring'''
           A_		   = self.controlnet_conditioning_channel_order
           if channel_order == "bgr":
                  A_		   = jnp.flip(UpperCamelCase__						,			axis=1    )

           # 1. time
           if not isinstance(UpperCamelCase__						,			jnp.ndarray    ):
                  A_		   = jnp.array([timesteps]						,			dtype=jnp.intaa    )
           elif isinstance(UpperCamelCase__						,			jnp.ndarray    ) and len(timesteps.shape    ) == 0:
                  A_		   = timesteps.astype(dtype=jnp.floataa    )
                  A_		   = jnp.expand_dims(UpperCamelCase__						,			0    )

           A_		   = self.time_proj(UpperCamelCase__    )
           A_		   = self.time_embedding(UpperCamelCase__    )

           # 2. pre-process
           A_		   = jnp.transpose(UpperCamelCase__						,			(0, 2, 3, 1)    )
           A_		   = self.conv_in(UpperCamelCase__    )

           A_		   = jnp.transpose(UpperCamelCase__						,			(0, 2, 3, 1)    )
           A_		   = self.controlnet_cond_embedding(UpperCamelCase__    )
           sample += controlnet_cond

           # 3. down
           A_		   = (sample,)
           for down_block in self.down_blocks:
                  if isinstance(UpperCamelCase__						,			UpperCamelCase__    ):
                         A_   ,     A_		   = down_block(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			deterministic=not train    )
                  else:
                         A_   ,     A_		   = down_block(UpperCamelCase__						,			UpperCamelCase__						,			deterministic=not train    )
                  down_block_res_samples += res_samples

           # 4. mid
           A_		   = self.mid_block(UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			deterministic=not train    )

           # 5. contronet blocks
           A_		   = ()
           for down_block_res_sample, controlnet_block in zip(UpperCamelCase__						,			self.controlnet_down_blocks    ):
                  A_		   = controlnet_block(UpperCamelCase__    )
                  controlnet_down_block_res_samples += (down_block_res_sample,)

           A_		   = controlnet_down_block_res_samples

           A_		   = self.controlnet_mid_block(UpperCamelCase__    )

           # 6. scaling
           A_		   = [sample * conditioning_scale for sample in down_block_res_samples]
           mid_block_res_sample *= conditioning_scale

           if not return_dict:
                  return (down_block_res_samples, mid_block_res_sample)

           return FlaxControlNetOutput(
               down_block_res_samples=UpperCamelCase__						,			mid_block_res_sample=UpperCamelCase__    )
