





import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
snake_case__					:							int													=     logging.get_logger(__name__)

snake_case__					:							int													=     {
    'b0': efficientnet.EfficientNetBa,
    'b1': efficientnet.EfficientNetBa,
    'b2': efficientnet.EfficientNetBa,
    'b3': efficientnet.EfficientNetBa,
    'b4': efficientnet.EfficientNetBa,
    'b5': efficientnet.EfficientNetBa,
    'b6': efficientnet.EfficientNetBa,
    'b7': efficientnet.EfficientNetBa,
}

snake_case__					:							Any													=     {
    'b0': {
        'hidden_dim': 1280,
        'width_coef': 1.0,
        'depth_coef': 1.0,
        'image_size': 224,
        'dropout_rate': 0.2,
        'dw_padding': [],
    },
    'b1': {
        'hidden_dim': 1280,
        'width_coef': 1.0,
        'depth_coef': 1.1,
        'image_size': 240,
        'dropout_rate': 0.2,
        'dw_padding': [16],
    },
    'b2': {
        'hidden_dim': 1408,
        'width_coef': 1.1,
        'depth_coef': 1.2,
        'image_size': 260,
        'dropout_rate': 0.3,
        'dw_padding': [5, 8, 16],
    },
    'b3': {
        'hidden_dim': 1536,
        'width_coef': 1.2,
        'depth_coef': 1.4,
        'image_size': 300,
        'dropout_rate': 0.3,
        'dw_padding': [5, 18],
    },
    'b4': {
        'hidden_dim': 1792,
        'width_coef': 1.4,
        'depth_coef': 1.8,
        'image_size': 380,
        'dropout_rate': 0.4,
        'dw_padding': [6],
    },
    'b5': {
        'hidden_dim': 2048,
        'width_coef': 1.6,
        'depth_coef': 2.2,
        'image_size': 456,
        'dropout_rate': 0.4,
        'dw_padding': [13, 27],
    },
    'b6': {
        'hidden_dim': 2304,
        'width_coef': 1.8,
        'depth_coef': 2.6,
        'image_size': 528,
        'dropout_rate': 0.5,
        'dw_padding': [31],
    },
    'b7': {
        'hidden_dim': 2560,
        'width_coef': 2.0,
        'depth_coef': 3.1,
        'image_size': 600,
        'dropout_rate': 0.5,
        'dw_padding': [18],
    },
}



def _a				(	lowerCamelCase:   List[Any] )	->						Dict:







      '''simple docstring'''






      __A          =				EfficientNetConfig()
      __A          =				CONFIG_MAP[model_name]['''hidden_dim''']
      __A          =				CONFIG_MAP[model_name]['''width_coef''']
      __A          =				CONFIG_MAP[model_name]['''depth_coef''']
      __A          =				CONFIG_MAP[model_name]['''image_size''']
      __A          =				CONFIG_MAP[model_name]['''dropout_rate''']
      __A          =				CONFIG_MAP[model_name]['''dw_padding''']

      __A          =				'''huggingface/label-files'''
      __A          =				'''imagenet-1k-id2label.json'''
      __A          =				10_00
      __A          =				json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				repo_type='''dataset''' )					,				'''r''' ) )
      __A          =				{int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()}

      __A          =				idalabel
      __A          =				{v: k for k, v in idalabel.items()}
      return config



def _a				(	)	->						int:







      '''simple docstring'''






      __A          =				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
      __A          =				Image.open(requests.get(SCREAMING_SNAKE_CASE__					,				stream=SCREAMING_SNAKE_CASE__ ).raw )
      return im



def _a				(	lowerCamelCase:   Union[str, Any] )	->						Tuple:







      '''simple docstring'''






      __A          =				CONFIG_MAP[model_name]['''image_size''']
      __A          =				EfficientNetImageProcessor(
          size={'''height''': size, '''width''': size}					,				image_mean=[0.485, 0.456, 0.406]					,				image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]					,				do_center_crop=SCREAMING_SNAKE_CASE__					,				)
      return preprocessor



def _a				(	lowerCamelCase:   str )	->						str:







      '''simple docstring'''






      __A          =				[v.split('''_''' )[0].split('''block''' )[1] for v in original_param_names if v.startswith('''block''' )]
      __A          =				sorted(set(SCREAMING_SNAKE_CASE__ ) )
      __A          =				len(SCREAMING_SNAKE_CASE__ )
      __A          =				{b: str(SCREAMING_SNAKE_CASE__ ) for b, i in zip(SCREAMING_SNAKE_CASE__					,				range(SCREAMING_SNAKE_CASE__ ) )}

      __A          =				[]
      rename_keys.append(('''stem_conv/kernel:0''', '''embeddings.convolution.weight''') )
      rename_keys.append(('''stem_bn/gamma:0''', '''embeddings.batchnorm.weight''') )
      rename_keys.append(('''stem_bn/beta:0''', '''embeddings.batchnorm.bias''') )
      rename_keys.append(('''stem_bn/moving_mean:0''', '''embeddings.batchnorm.running_mean''') )
      rename_keys.append(('''stem_bn/moving_variance:0''', '''embeddings.batchnorm.running_var''') )

      for b in block_names:
            __A          =				block_name_mapping[b]
            rename_keys.append((F"""block{b}_expand_conv/kernel:0""", F"""encoder.blocks.{hf_b}.expansion.expand_conv.weight""") )
            rename_keys.append((F"""block{b}_expand_bn/gamma:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.weight""") )
            rename_keys.append((F"""block{b}_expand_bn/beta:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.bias""") )
            rename_keys.append(
                (F"""block{b}_expand_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_mean""") )
            rename_keys.append(
                (F"""block{b}_expand_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_var""") )
            rename_keys.append(
                (F"""block{b}_dwconv/depthwise_kernel:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight""") )
            rename_keys.append((F"""block{b}_bn/gamma:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight""") )
            rename_keys.append((F"""block{b}_bn/beta:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias""") )
            rename_keys.append(
                (F"""block{b}_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean""") )
            rename_keys.append(
                (F"""block{b}_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var""") )

            rename_keys.append((F"""block{b}_se_reduce/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.weight""") )
            rename_keys.append((F"""block{b}_se_reduce/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.bias""") )
            rename_keys.append((F"""block{b}_se_expand/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.weight""") )
            rename_keys.append((F"""block{b}_se_expand/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.bias""") )
            rename_keys.append(
                (F"""block{b}_project_conv/kernel:0""", F"""encoder.blocks.{hf_b}.projection.project_conv.weight""") )
            rename_keys.append((F"""block{b}_project_bn/gamma:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.weight""") )
            rename_keys.append((F"""block{b}_project_bn/beta:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.bias""") )
            rename_keys.append(
                (F"""block{b}_project_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_mean""") )
            rename_keys.append(
                (F"""block{b}_project_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_var""") )

      rename_keys.append(('''top_conv/kernel:0''', '''encoder.top_conv.weight''') )
      rename_keys.append(('''top_bn/gamma:0''', '''encoder.top_bn.weight''') )
      rename_keys.append(('''top_bn/beta:0''', '''encoder.top_bn.bias''') )
      rename_keys.append(('''top_bn/moving_mean:0''', '''encoder.top_bn.running_mean''') )
      rename_keys.append(('''top_bn/moving_variance:0''', '''encoder.top_bn.running_var''') )

      __A          =				{}
      for item in rename_keys:
            if item[0] in original_param_names:
                  __A          =				'''efficientnet.''' + item[1]

      __A          =				'''classifier.weight'''
      __A          =				'''classifier.bias'''
      return key_mapping



def _a				(	lowerCamelCase:   Union[str, Any]					,				lowerCamelCase:   Optional[Any]					,				lowerCamelCase:   Tuple )	->						Dict:







      '''simple docstring'''






      for key, value in tf_params.items():
            if "normalization" in key:
                  continue

            __A          =				key_mapping[key]
            if "_conv" in key and "kernel" in key:
                  __A          =				torch.from_numpy(SCREAMING_SNAKE_CASE__ ).permute(3					,				2					,				0					,				1 )
            elif "depthwise_kernel" in key:
                  __A          =				torch.from_numpy(SCREAMING_SNAKE_CASE__ ).permute(2					,				3					,				0					,				1 )
            elif "kernel" in key:
                  __A          =				torch.from_numpy(np.transpose(SCREAMING_SNAKE_CASE__ ) )
            else:
                  __A          =				torch.from_numpy(SCREAMING_SNAKE_CASE__ )

            # Replace HF parameters with original TF model parameters
            assert hf_params[hf_key].shape == new_hf_value.shape
            hf_params[hf_key].copy_(SCREAMING_SNAKE_CASE__ )



@torch.no_grad()
def _a				(	lowerCamelCase:   List[Any]					,				lowerCamelCase:   Dict					,				lowerCamelCase:   List[Any]					,				lowerCamelCase:   Union[str, Any] )	->						List[Any]:







      '''simple docstring'''






      __A          =				model_classes[model_name](
          include_top=SCREAMING_SNAKE_CASE__					,				weights='''imagenet'''					,				input_tensor=SCREAMING_SNAKE_CASE__					,				input_shape=SCREAMING_SNAKE_CASE__					,				pooling=SCREAMING_SNAKE_CASE__					,				classes=10_00					,				classifier_activation='''softmax'''					,				)

      __A          =				original_model.trainable_variables
      __A          =				original_model.non_trainable_variables
      __A          =				{param.name: param.numpy() for param in tf_params}
      for param in tf_non_train_params:
            __A          =				param.numpy()
      __A          =				list(tf_params.keys() )

      # Load HuggingFace model
      __A          =				get_efficientnet_config(SCREAMING_SNAKE_CASE__ )
      __A          =				EfficientNetForImageClassification(SCREAMING_SNAKE_CASE__ ).eval()
      __A          =				hf_model.state_dict()

      # Create src-to-dst parameter name mapping dictionary
      print('''Converting parameters...''' )
      __A          =				rename_keys(SCREAMING_SNAKE_CASE__ )
      replace_params(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ )

      # Initialize preprocessor and preprocess input image
      __A          =				convert_image_processor(SCREAMING_SNAKE_CASE__ )
      __A          =				preprocessor(images=prepare_img()					,				return_tensors='''pt''' )

      # HF model inference
      hf_model.eval()
      with torch.no_grad():
            __A          =				hf_model(**SCREAMING_SNAKE_CASE__ )
      __A          =				outputs.logits.detach().numpy()

      # Original model inference
      __A          =				False
      __A          =				CONFIG_MAP[model_name]['''image_size''']
      __A          =				prepare_img().resize((image_size, image_size)					,				resample=PIL.Image.NEAREST )
      __A          =				image.img_to_array(SCREAMING_SNAKE_CASE__ )
      __A          =				np.expand_dims(SCREAMING_SNAKE_CASE__					,				axis=0 )
      __A          =				original_model.predict(SCREAMING_SNAKE_CASE__ )

      # Check whether original and HF model outputs match  -> np.allclose
      assert np.allclose(SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__					,				atol=1e-3 ), "The predicted logits are not the same."
      print('''Model outputs match!''' )

      if save_model:
            # Create folder to save model
            if not os.path.isdir(SCREAMING_SNAKE_CASE__ ):
                  os.mkdir(SCREAMING_SNAKE_CASE__ )
            # Save converted model and image processor
            hf_model.save_pretrained(SCREAMING_SNAKE_CASE__ )
            preprocessor.save_pretrained(SCREAMING_SNAKE_CASE__ )

      if push_to_hub:
            # Push model and image processor to hub
            print(F"""Pushing converted {model_name} to the hub...""" )
            __A          =				F"""efficientnet-{model_name}"""
            preprocessor.push_to_hub(SCREAMING_SNAKE_CASE__ )
            hf_model.push_to_hub(SCREAMING_SNAKE_CASE__ )


if __name__ == "__main__":
       snake_case__					:							Optional[Any]													=     argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '--model_name',
           default='b0',
           type=str,
           help='Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].',
       )
       parser.add_argument(
           '--pytorch_dump_folder_path',
           default='hf_model',
           type=str,
           help='Path to the output PyTorch model directory.',
       )
       parser.add_argument('--save_model', action='store_true', help='Save model to local')
       parser.add_argument('--push_to_hub', action='store_true', help='Push model and image processor to the hub')

       snake_case__					:							Tuple													=     parser.parse_args()
       convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)









from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload






class     UpperCAmelCase__       :



    """simple docstring"""






    def __init__(			self					,   A_ = None    )  ->       None:
         if components is None:
              __UpperCamelCase    							=[]
         __UpperCamelCase    							=list(A_    )






    def __len__(			self    )  ->       int:
         return len(self.__components    )






    def __str__(			self    )  ->       str:
         return "(" + ",".join(map(A_					,   self.__components    )    ) + ")"






    def __add__(			self					,   A_    )  ->       Vector:
         __UpperCamelCase    							=len(self    )
         if size == len(A_    ):
              __UpperCamelCase    							=[self.__components[i] + other.component(A_    ) for i in range(A_    )]
              return Vector(A_    )
         else:
              raise Exception('must have the same size'    )






    def __sub__(			self					,   A_    )  ->       Vector:
         __UpperCamelCase    							=len(self    )
         if size == len(A_    ):
              __UpperCamelCase    							=[self.__components[i] - other.component(A_    ) for i in range(A_    )]
              return Vector(A_    )
         else:  # error case
              raise Exception('must have the same size'    )






    @overload
    def __mul__(			self					,   A_    )  ->       Vector:
         ...






    @overload
    def __mul__(			self					,   A_    )  ->       float:
         ...






    def __mul__(			self					,   A_    )  ->       float | Vector:
         if isinstance(A_					,   (float, int)    ):
              __UpperCamelCase    							=[c * other for c in self.__components]
              return Vector(A_    )
         elif isinstance(A_					,   A_    ) and len(self    ) == len(A_    ):
              __UpperCamelCase    							=len(self    )
              __UpperCamelCase    							=[self.__components[i] * other.component(A_    ) for i in range(A_    )]
              return sum(A_    )
         else:  # error case
              raise Exception('invalid operand!'    )






    def _a					(			self    )  ->       Vector:
         return Vector(self.__components    )






    def _a					(			self					,   A_    )  ->       float:
         if isinstance(A_					,   A_    ) and -len(self.__components    ) <= i < len(self.__components    ):
              return self.__components[i]
         else:
              raise Exception('index out of range'    )






    def _a					(			self					,   A_					,   A_    )  ->       None:
         assert -len(self.__components    ) <= pos < len(self.__components    )
         __UpperCamelCase    							=value






    def _a					(			self    )  ->       float:
         if len(self.__components    ) == 0:
              raise Exception('Vector is empty'    )
         __UpperCamelCase    							=[c**2 for c in self.__components]
         return math.sqrt(sum(A_    )    )






    def _a					(			self					,   A_					,   A_ = False    )  ->       float:
         __UpperCamelCase    							=self * other
         __UpperCamelCase    							=self.euclidean_length() * other.euclidean_length()
         if deg:
              return math.degrees(math.acos(num / den    )    )
         else:
              return math.acos(num / den    )

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     assert isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
     return Vector([0] * dimension				)

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     assert isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) and (isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				))
     __UpperCamelCase    							=[0] * dimension
     __UpperCamelCase    							=1
     return Vector(SCREAMING_SNAKE_CASE__				)

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					float			,     SCREAMING_SNAKE_CASE__			:					Vector			,     SCREAMING_SNAKE_CASE__			:					Vector				):
     assert (
         isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
         and isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
         and (isinstance(SCREAMING_SNAKE_CASE__			,     (int, float)				))
     )
     return x * scalar + y

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     random.seed(SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=[random.randint(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) for _ in range(SCREAMING_SNAKE_CASE__				)]
     return Vector(SCREAMING_SNAKE_CASE__				)






class     UpperCAmelCase__       :



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_    )  ->       None:
         __UpperCamelCase    							=matrix
         __UpperCamelCase    							=w
         __UpperCamelCase    							=h






    def __str__(			self    )  ->       str:
         __UpperCamelCase    							=''
         for i in range(self.__height    ):
              ans += "|"
              for j in range(self.__width    ):
                   if j < self.__width - 1:
                        ans += str(self.__matrix[i][j]    ) + ","
                   else:
                        ans += str(self.__matrix[i][j]    ) + "|\n"
         return ans






    def __add__(			self					,   A_    )  ->       Matrix:
         if self.__width == other.width() and self.__height == other.height():
              __UpperCamelCase    							=[]
              for i in range(self.__height    ):
                   __UpperCamelCase    							=[
                       self.__matrix[i][j] + other.component(A_					,   A_    )
                       for j in range(self.__width    )
                   ]
                   matrix.append(A_    )
              return Matrix(A_					,   self.__width					,   self.__height    )
         else:
              raise Exception('matrix must have the same dimension!'    )






    def __sub__(			self					,   A_    )  ->       Matrix:
         if self.__width == other.width() and self.__height == other.height():
              __UpperCamelCase    							=[]
              for i in range(self.__height    ):
                   __UpperCamelCase    							=[
                       self.__matrix[i][j] - other.component(A_					,   A_    )
                       for j in range(self.__width    )
                   ]
                   matrix.append(A_    )
              return Matrix(A_					,   self.__width					,   self.__height    )
         else:
              raise Exception('matrices must have the same dimension!'    )






    @overload
    def __mul__(			self					,   A_    )  ->       Matrix:
         ...






    @overload
    def __mul__(			self					,   A_    )  ->       Vector:
         ...






    def __mul__(			self					,   A_    )  ->       Vector | Matrix:
         if isinstance(A_					,   A_    ):  # matrix-vector
              if len(A_    ) == self.__width:
                   __UpperCamelCase    							=zero_vector(self.__height    )
                   for i in range(self.__height    ):
                        __UpperCamelCase    							=[
                            self.__matrix[i][j] * other.component(A_    )
                            for j in range(self.__width    )
                        ]
                        ans.change_component(A_					,   sum(A_    )    )
                   return ans
              else:
                   raise Exception(
                       'vector must have the same size as the '
                       'number of columns of the matrix!'    )
         elif isinstance(A_					,   (int, float)    ):  # matrix-scalar
              __UpperCamelCase    							=[
                  [self.__matrix[i][j] * other for j in range(self.__width    )]
                  for i in range(self.__height    )
              ]
              return Matrix(A_					,   self.__width					,   self.__height    )
         return None






    def _a					(			self    )  ->       int:
         return self.__height






    def _a					(			self    )  ->       int:
         return self.__width






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if 0 <= x < self.__height and 0 <= y < self.__width:
              return self.__matrix[x][y]
         else:
              raise Exception('change_component: indices out of bounds'    )






    def _a					(			self					,   A_					,   A_					,   A_    )  ->       None:
         if 0 <= x < self.__height and 0 <= y < self.__width:
              __UpperCamelCase    							=value
         else:
              raise Exception('change_component: indices out of bounds'    )






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         __UpperCamelCase    							=self.__matrix[:x] + self.__matrix[x + 1 :]
         for i in range(len(A_    )    ):
              __UpperCamelCase    							=minor[i][:y] + minor[i][y + 1 :]
         return Matrix(A_					,   self.__width - 1					,   self.__height - 1    ).determinant()






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         if 0 <= x < self.__height and 0 <= y < self.__width:
              return (-1) ** (x + y) * self.minor(A_					,   A_    )
         else:
              raise Exception('Indices out of bounds'    )






    def _a					(			self    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         if self.__height < 1:
              raise Exception('Matrix has no element'    )
         elif self.__height == 1:
              return self.__matrix[0][0]
         elif self.__height == 2:
              return (
                  self.__matrix[0][0] * self.__matrix[1][1]
                  - self.__matrix[0][1] * self.__matrix[1][0]
              )
         else:
              __UpperCamelCase    							=[
                  self.__matrix[0][y] * self.cofactor(0					,   A_    ) for y in range(self.__width    )
              ]
              return sum(A_    )

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     __UpperCamelCase    							=[[0] * n for _ in range(SCREAMING_SNAKE_CASE__				)]
     return Matrix(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)





def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     random.seed(SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=[
         [random.randint(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) for _ in range(SCREAMING_SNAKE_CASE__				)] for _ in range(SCREAMING_SNAKE_CASE__				)
     ]
     return Matrix(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)





