

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a__												=						logging.get_logger(__name__)

a__												=						{
    '''bigcode/gpt_bigcode-santacoder''': '''https://huggingface.co/bigcode/gpt_bigcode-santacoder/resolve/main/config.json''',
}

class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[Any]             =       "gpt_bigcode"
							UpperCAmelCase__			:		Optional[Any]             =       ["past_key_values"]
							UpperCAmelCase__			:		Tuple             =       {
							    "hidden_size": "n_embd",
							    "max_position_embeddings": "n_positions",
							    "num_attention_heads": "n_head",
							    "num_hidden_layers": "n_layer",
							}


							def __init__(     self			,				_a=5_0_2_5_7			,				_a=1_0_2_4			,				_a=7_6_8			,				_a=1_2			,				_a=1_2			,				_a=None			,				_a="gelu_pytorch_tanh"			,				_a=0.1			,				_a=0.1			,				_a=0.1			,				_a=1e-5			,				_a=0.02			,				_a=True			,				_a=True			,				_a=5_0_2_5_6			,				_a=5_0_2_5_6			,				_a=True			,				_a=True			,				_a=True			,				**_a			,				)       ->       List[str]:
												_a      :       Optional[int]   =						vocab_size
												_a      :       Union[str, Any]   =						n_positions
												_a      :       Optional[int]   =						n_embd
												_a      :       List[Any]   =						n_layer
												_a      :       Optional[int]   =						n_head
												_a      :       Any   =						n_inner
												_a      :       Optional[int]   =						activation_function
												_a      :       Optional[int]   =						resid_pdrop
												_a      :       Union[str, Any]   =						embd_pdrop
												_a      :       Any   =						attn_pdrop
												_a      :       int   =						layer_norm_epsilon
												_a      :       List[Any]   =						initializer_range
												_a      :       List[str]   =						scale_attn_weights
												_a      :       List[Any]   =						use_cache
												_a      :       List[Any]   =						attention_softmax_in_fpaa
												_a      :       List[str]   =						scale_attention_softmax_in_fpaa
												_a      :       Dict   =						multi_query

												_a      :       List[Any]   =						bos_token_id
												_a      :       str   =						eos_token_id

												super().__init__(bos_token_id=_a			,				eos_token_id=_a			,				**_a			)









from __future__ import annotations

from decimal import Decimal

from numpy import array

def lowercase    (  SCREAMING_SNAKE_CASE )			->							list[list[float]]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_								=						Decimal

			# Check if the provided matrix has 2 rows and 2 columns
			# since this implementation only works for 2x2 matrices
			if len(SCREAMING_SNAKE_CASE ) == 2 and len(matrix[0] ) == 2 and len(matrix[1] ) == 2:
						# Calculate the determinant of the matrix
						SCREAMING_SNAKE_CASE_								=						float(
						    d(matrix[0][0] ) * d(matrix[1][1] ) - d(matrix[1][0] ) * d(matrix[0][1] ) )
						if determinant == 0:
									raise ValueError('This matrix has no inverse.' )

						# Creates a copy of the matrix with swapped positions of the elements
						SCREAMING_SNAKE_CASE_								=						[[0.0, 0.0], [0.0, 0.0]]
						SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						matrix[1][1], matrix[0][0]
						SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						-matrix[1][0], -matrix[0][1]

						# Calculate the inverse of the matrix
						return [
						    [(float(d(SCREAMING_SNAKE_CASE ) ) / determinant) or 0.0 for n in row] for row in swapped_matrix
						]
			elif (
			    len(SCREAMING_SNAKE_CASE ) == 3
			    and len(matrix[0] ) == 3
			    and len(matrix[1] ) == 3
			    and len(matrix[2] ) == 3
			):
						# Calculate the determinant of the matrix using Sarrus rule
						SCREAMING_SNAKE_CASE_								=						float(
						    (
						        (d(matrix[0][0] ) * d(matrix[1][1] ) * d(matrix[2][2] ))
						        + (d(matrix[0][1] ) * d(matrix[1][2] ) * d(matrix[2][0] ))
						        + (d(matrix[0][2] ) * d(matrix[1][0] ) * d(matrix[2][1] ))
						    )
						    - (
						        (d(matrix[0][2] ) * d(matrix[1][1] ) * d(matrix[2][0] ))
						        + (d(matrix[0][1] ) * d(matrix[1][0] ) * d(matrix[2][2] ))
						        + (d(matrix[0][0] ) * d(matrix[1][2] ) * d(matrix[2][1] ))
						    ) )
						if determinant == 0:
									raise ValueError('This matrix has no inverse.' )

						# Creating cofactor matrix
						SCREAMING_SNAKE_CASE_								=						[
						    [d(0.0 ), d(0.0 ), d(0.0 )],
						    [d(0.0 ), d(0.0 ), d(0.0 )],
						    [d(0.0 ), d(0.0 ), d(0.0 )],
						]
						SCREAMING_SNAKE_CASE_								=						(d(matrix[1][1] ) * d(matrix[2][2] )) - (
						    d(matrix[1][2] ) * d(matrix[2][1] )
						)
						SCREAMING_SNAKE_CASE_								=						-(
						    (d(matrix[1][0] ) * d(matrix[2][2] )) - (d(matrix[1][2] ) * d(matrix[2][0] ))
						)
						SCREAMING_SNAKE_CASE_								=						(d(matrix[1][0] ) * d(matrix[2][1] )) - (
						    d(matrix[1][1] ) * d(matrix[2][0] )
						)
						SCREAMING_SNAKE_CASE_								=						-(
						    (d(matrix[0][1] ) * d(matrix[2][2] )) - (d(matrix[0][2] ) * d(matrix[2][1] ))
						)
						SCREAMING_SNAKE_CASE_								=						(d(matrix[0][0] ) * d(matrix[2][2] )) - (
						    d(matrix[0][2] ) * d(matrix[2][0] )
						)
						SCREAMING_SNAKE_CASE_								=						-(
						    (d(matrix[0][0] ) * d(matrix[2][1] )) - (d(matrix[0][1] ) * d(matrix[2][0] ))
						)
						SCREAMING_SNAKE_CASE_								=						(d(matrix[0][1] ) * d(matrix[1][2] )) - (
						    d(matrix[0][2] ) * d(matrix[1][1] )
						)
						SCREAMING_SNAKE_CASE_								=						-(
						    (d(matrix[0][0] ) * d(matrix[1][2] )) - (d(matrix[0][2] ) * d(matrix[1][0] ))
						)
						SCREAMING_SNAKE_CASE_								=						(d(matrix[0][0] ) * d(matrix[1][1] )) - (
						    d(matrix[0][1] ) * d(matrix[1][0] )
						)

						# Transpose the cofactor matrix (Adjoint matrix)
						SCREAMING_SNAKE_CASE_								=						array(SCREAMING_SNAKE_CASE )
						for i in range(3 ):
									for j in range(3 ):
												SCREAMING_SNAKE_CASE_								=						cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
						SCREAMING_SNAKE_CASE_								=						array(SCREAMING_SNAKE_CASE )
						for i in range(3 ):
									for j in range(3 ):
												inverse_matrix[i][j] /= d(SCREAMING_SNAKE_CASE )

        # Calculate the inverse of the matrix
						return [[float(d(SCREAMING_SNAKE_CASE ) ) or 0.0 for n in row] for row in inverse_matrix]
			raise ValueError('Please provide a matrix of size 2x2 or 3x3.' )
