
'''simple docstring'''





import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaTokenizer, GPTNeoConfig, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
 import jax
 import jax.numpy as jnp

 from transformers.modeling_flax_pytorch_utils import (
     convert_pytorch_state_dict_to_flax,
     load_flax_weights_in_pytorch_model,
 )
 from transformers.models.gpt_neo.modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel

if is_torch_available():
 import torch


class 			UpperCamelCase__	:






 def __init__(      self	:Optional[Any]						,					_A	:Tuple						,					_A	:Optional[int]=14						,					_A	:Optional[Any]=7						,					_A	:Dict=True						,					_A	:List[Any]=True						,					_A	:str=False						,					_A	:str=True						,					_A	:List[Any]=99						,					_A	:Union[str, Any]=32						,					_A	:List[Any]=4						,					_A	:int=4						,					_A	:Optional[int]=[[["global", "local"], 2]]						,					_A	:Optional[int]=37						,					_A	:str="gelu"						,					_A	:str=0.1						,					_A	:Union[str, Any]=0.1						,					_A	:Any=512						,					_A	:int=7						,					_A	:Union[str, Any]=0.02						,					)					->      List[Any]:







       '''simple docstring'''



       __A													=      parent
       __A													=      batch_size
       __A													=      seq_length
       __A													=      is_training
       __A													=      use_input_mask
       __A													=      use_token_type_ids
       __A													=      use_labels
       __A													=      vocab_size
       __A													=      hidden_size
       __A													=      num_hidden_layers
       __A													=      num_attention_heads
       __A													=      attention_types
       __A													=      intermediate_size
       __A													=      hidden_act
       __A													=      hidden_dropout_prob
       __A													=      attention_probs_dropout_prob
       __A													=      max_position_embeddings
       __A													=      window_size
       __A													=      initializer_range
       __A													=      None
       __A													=      vocab_size - 1
       __A													=      vocab_size - 1
       __A													=      vocab_size - 1






 def 						lowercase_    (      self	:Dict      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      ids_tensor([self.batch_size, self.seq_length]						,					self.vocab_size      )

       __A													=      None
       if self.use_input_mask:
             __A													=      random_attention_mask([self.batch_size, self.seq_length]      )

       __A													=      GPTNeoConfig(
           vocab_size=self.vocab_size						,					hidden_size=self.hidden_size						,					num_layers=self.num_hidden_layers						,					num_heads=self.num_attention_heads						,					max_position_embeddings=self.max_position_embeddings						,					use_cache=_A						,					bos_token_id=self.bos_token_id						,					eos_token_id=self.eos_token_id						,					pad_token_id=self.pad_token_id						,					window_size=self.window_size						,					attention_types=self.attention_types						,					)

       return (config, input_ids, input_mask)






 def 						lowercase_    (      self	:Tuple      )					->      int:







       '''simple docstring'''



       __A													=      self.prepare_config_and_inputs()
       __A						,   __A						,   __A													=      config_and_inputs
       __A													=      {'input_ids': input_ids, 'attention_mask': attention_mask}
       return config, inputs_dict






 def 						lowercase_    (      self	:Any						,					_A	:List[Any]						,					_A	:Optional[int]						,					_A	:List[Any]						,					_A	:Union[str, Any]      )					->      Union[str, Any]:







       '''simple docstring'''



       __A													=      20
       __A													=      model_class_name(_A      )

       __A													=      model.init_cache(input_ids.shape[0]						,					_A      )
       __A													=      jnp.ones((input_ids.shape[0], max_decoder_length)						,					dtype='i4'      )

       __A													=      jnp.broadcast_to(
           jnp.arange(input_ids.shape[-1] - 1      )[None, :]						,					(input_ids.shape[0], input_ids.shape[-1] - 1)      )
       __A													=      model(
           input_ids[:, :-1]						,					attention_mask=_A						,					past_key_values=_A						,					position_ids=_A						,					)

       __A													=      jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]						,					dtype='i4'      )
       __A													=      model(
           input_ids[:, -1:]						,					attention_mask=_A						,					past_key_values=outputs_cache.past_key_values						,					position_ids=_A						,					)

       __A													=      model(_A      )

       __A													=      np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])      )      )
       self.parent.assertTrue(diff < 1E-3						,					msg=F'Max diff is {diff}'      )






 def 						lowercase_    (      self	:Tuple						,					_A	:Union[str, Any]						,					_A	:Optional[Any]						,					_A	:Tuple						,					_A	:int      )					->      str:







       '''simple docstring'''



       __A													=      20
       __A													=      model_class_name(_A      )

       __A													=      jnp.concatenate(
           [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])      )]						,					axis=-1						,					)

       __A													=      model.init_cache(input_ids.shape[0]						,					_A      )
       __A													=      jnp.broadcast_to(
           jnp.arange(input_ids.shape[-1] - 1      )[None, :]						,					(input_ids.shape[0], input_ids.shape[-1] - 1)      )

       __A													=      model(
           input_ids[:, :-1]						,					attention_mask=_A						,					past_key_values=_A						,					position_ids=_A						,					)
       __A													=      jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]						,					dtype='i4'      )
       __A													=      model(
           input_ids[:, -1:]						,					past_key_values=outputs_cache.past_key_values						,					attention_mask=_A						,					position_ids=_A						,					)

       __A													=      model(_A						,					attention_mask=_A      )

       __A													=      np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])      )      )
       self.parent.assertTrue(diff < 1E-3						,					msg=F'Max diff is {diff}'      )


@require_flax
class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     Union[str, Any]    					=       (FlaxGPTNeoModel, FlaxGPTNeoForCausalLM) if is_flax_available() else ()
 UpperCAmelCase__     :     List[str]    					=       (FlaxGPTNeoForCausalLM,) if is_flax_available() else ()






 def 						lowercase_    (      self	:List[str]      )					->      Optional[int]:







       '''simple docstring'''



       __A													=      FlaxGPTNeoModelTester(self      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      List[Any]:







       '''simple docstring'''



       for model_class_name in self.all_model_classes:
             __A						,   __A						,   __A													=      self.model_tester.prepare_config_and_inputs()
             self.model_tester.check_use_cache_forward(_A						,					_A						,					_A						,					_A      )






 def 						lowercase_    (      self	:int      )					->      int:







       '''simple docstring'''



       for model_class_name in self.all_model_classes:
             __A						,   __A						,   __A													=      self.model_tester.prepare_config_and_inputs()
             self.model_tester.check_use_cache_forward_with_attn_mask(
                 _A						,					_A						,					_A						,					_A      )






 @slow
 def 						lowercase_    (      self	:Tuple      )					->      int:







       '''simple docstring'''



       __A													=      GPTaTokenizer.from_pretrained('gpt2'						,					pad_token='<|endoftext|>'						,					padding_side='left'      )
       __A													=      tokenizer(['Hello this is a long string', 'Hey']						,					return_tensors='np'						,					padding=_A						,					truncation=_A      )

       __A													=      FlaxGPTNeoForCausalLM.from_pretrained('EleutherAI/gpt-neo-125M'      )
       __A													=      False
       __A													=      model.config.eos_token_id

       __A													=      jax.jit(model.generate      )

       __A													=      jit_generate(
           inputs['input_ids']						,					attention_mask=inputs['attention_mask']						,					pad_token_id=tokenizer.pad_token_id      ).sequences

       __A													=      tokenizer.batch_decode(_A						,					skip_special_tokens=_A      )

       __A													=      [
           'Hello this is a long string of text.\n\nI\'m trying to get the text of the',
           'Hey, I\'m a little late to the party. I\'m going to',
       ]

       self.assertListEqual(_A						,					_A      )






 @is_pt_flax_cross_test
 def 						lowercase_    (      self	:List[str]      )					->      List[str]:







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__      ):
                   # prepare inputs
                   __A													=      self._prepare_for_class(_A						,					_A      )
                   __A													=      {k: torch.tensor(v.tolist()      ) for k, v in prepared_inputs_dict.items()}

                   # load corresponding PyTorch class
                   __A													=      model_class.__name__[4:]  # Skip the "Flax" at the beginning
                   __A													=      getattr(_A						,					_A      )

                   __A						,   __A													=      pt_inputs['input_ids'].shape
                   __A													=      np.random.randint(0						,					seq_length - 1						,					size=(batch_size,)      )
                   for batch_idx, start_index in enumerate(_A      ):
                         __A													=      0
                         __A													=      1
                         __A													=      0
                         __A													=      1
                   __A													=      pt_model_class(_A      ).eval()
                   __A													=      model_class(_A						,					dtype=jnp.floataa      )

                   __A													=      convert_pytorch_state_dict_to_flax(pt_model.state_dict()						,					_A      )
                   __A													=      fx_state

                   with torch.no_grad():
                         __A													=      pt_model(**_A      ).to_tuple()

                   __A													=      fx_model(**_A      ).to_tuple()
                   self.assertEqual(len(_A      )						,					len(_A      )						,					'Output lengths differ between Flax and PyTorch'      )
                   for fx_output, pt_output in zip(_A						,					_A      ):
                         self.assert_almost_equals(fx_output[:, -1]						,					pt_output[:, -1].numpy()						,					4E-2      )

                   with tempfile.TemporaryDirectory() as tmpdirname:
                         pt_model.save_pretrained(_A      )
                         __A													=      model_class.from_pretrained(_A						,					from_pt=_A      )

                   __A													=      fx_model_loaded(**_A      ).to_tuple()
                   self.assertEqual(
                       len(_A      )						,					len(_A      )						,					'Output lengths differ between Flax and PyTorch'      )
                   for fx_output_loaded, pt_output in zip(_A						,					_A      ):
                         self.assert_almost_equals(fx_output_loaded[:, -1]						,					pt_output[:, -1].numpy()						,					4E-2      )






 @is_pt_flax_cross_test
 def 						lowercase_    (      self	:Any      )					->      List[str]:







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__      ):
                   # prepare inputs
                   __A													=      self._prepare_for_class(_A						,					_A      )
                   __A													=      {k: torch.tensor(v.tolist()      ) for k, v in prepared_inputs_dict.items()}

                   # load corresponding PyTorch class
                   __A													=      model_class.__name__[4:]  # Skip the "Flax" at the beginning
                   __A													=      getattr(_A						,					_A      )

                   __A													=      pt_model_class(_A      ).eval()
                   __A													=      model_class(_A						,					dtype=jnp.floataa      )

                   __A													=      load_flax_weights_in_pytorch_model(_A						,					fx_model.params      )
                   __A						,   __A													=      pt_inputs['input_ids'].shape
                   __A													=      np.random.randint(0						,					seq_length - 1						,					size=(batch_size,)      )
                   for batch_idx, start_index in enumerate(_A      ):
                         __A													=      0
                         __A													=      1
                         __A													=      0
                         __A													=      1

                   # make sure weights are tied in PyTorch
                   pt_model.tie_weights()

                   with torch.no_grad():
                         __A													=      pt_model(**_A      ).to_tuple()

                   __A													=      fx_model(**_A      ).to_tuple()
                   self.assertEqual(len(_A      )						,					len(_A      )						,					'Output lengths differ between Flax and PyTorch'      )
                   for fx_output, pt_output in zip(_A						,					_A      ):
                         self.assert_almost_equals(fx_output[:, -1]						,					pt_output[:, -1].numpy()						,					4E-2      )

                   with tempfile.TemporaryDirectory() as tmpdirname:
                         fx_model.save_pretrained(_A      )
                         __A													=      pt_model_class.from_pretrained(_A						,					from_flax=_A      )

                   with torch.no_grad():
                         __A													=      pt_model_loaded(**_A      ).to_tuple()

                   self.assertEqual(
                       len(_A      )						,					len(_A      )						,					'Output lengths differ between Flax and PyTorch'      )
                   for fx_output, pt_output in zip(_A						,					_A      ):
                         self.assert_almost_equals(fx_output[:, -1]						,					pt_output[:, -1].numpy()						,					4E-2      )






 @slow
 def 						lowercase_    (      self	:Dict      )					->      str:







       '''simple docstring'''



       for model_class_name in self.all_model_classes:
             __A													=      model_class_name.from_pretrained('EleutherAI/gpt-neo-125M'      )
             __A													=      model(np.ones((1, 1)      )      )
             self.assertIsNotNone(_A      )










"""simple docstring"""







import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


__a      			= [nn.LayerNorm]

__a      			= logging.get_logger(__name__)

__a      			= version.parse(version.parse(torch.__version__).base_version)

__a      			= parsed_torch_version_base >= version.parse("2.0")
__a      			= parsed_torch_version_base >= version.parse("1.12")
__a      			= parsed_torch_version_base >= version.parse("1.11")
__a      			= parsed_torch_version_base < version.parse("1.11")






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      self			):





						"""simple docstring"""

						from torch import _softmax_backward_data

						if is_torch_less_than_1_11:
												return _softmax_backward_data(_UpperCamelCase						,      _UpperCamelCase						,      parent.dim						,      self			)
						else:
												return _softmax_backward_data(_UpperCamelCase						,      _UpperCamelCase						,      parent.dim						,      self.dtype			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = 0			):





						"""simple docstring"""

						UpperCAmelCase__												=     index.to(layer.weight.device			)
						UpperCAmelCase__												=     layer.weight.index_select(_UpperCamelCase						,      _UpperCamelCase			).clone().detach()
						if layer.bias is not None:
												if dim == 1:
																		UpperCAmelCase__												=     layer.bias.clone().detach()
												else:
																		UpperCAmelCase__												=     layer.bias[index].clone().detach()
						UpperCAmelCase__												=     list(layer.weight.size()			)
						UpperCAmelCase__												=     len(_UpperCamelCase			)
						UpperCAmelCase__												=     nn.Linear(new_size[1]						,      new_size[0]						,      bias=layer.bias is not None			).to(layer.weight.device			)
						UpperCAmelCase__												=     False
						new_layer.weight.copy_(W.contiguous()			)
						UpperCAmelCase__												=     True
						if layer.bias is not None:
												UpperCAmelCase__												=     False
												new_layer.bias.copy_(b.contiguous()			)
												UpperCAmelCase__												=     True
						return new_layer
class 				lowerCamelCase							(      nn.Module			):


							"""simple docstring"""






							def __init__(    self			:  str		,			lowerCamelCase_			:  Any		,			lowerCamelCase_			:  Dict					):
													super().__init__()
													UpperCAmelCase__												=     nf
													UpperCAmelCase__												=     nn.Parameter(torch.empty(lowerCamelCase_		,			lowerCamelCase_					)					)
													UpperCAmelCase__												=     nn.Parameter(torch.zeros(lowerCamelCase_					)					)
													nn.init.normal_(self.weight		,			std=0.02					)






							def        lowerCAmelCase  (    self			:  Any		,			lowerCamelCase_			:  Tuple					):
													UpperCAmelCase__												=     x.size()[:-1] + (self.nf,)
													UpperCAmelCase__												=     torch.addmm(self.bias		,			x.view(-1		,			x.size(-1					)					)		,			self.weight					)
													UpperCAmelCase__												=     x.view(lowerCamelCase_					)
													return x






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = 1			):





						"""simple docstring"""

						UpperCAmelCase__												=     index.to(layer.weight.device			)
						UpperCAmelCase__												=     layer.weight.index_select(_UpperCamelCase						,      _UpperCamelCase			).clone().detach()
						if dim == 0:
												UpperCAmelCase__												=     layer.bias.clone().detach()
						else:
												UpperCAmelCase__												=     layer.bias[index].clone().detach()
						UpperCAmelCase__												=     list(layer.weight.size()			)
						UpperCAmelCase__												=     len(_UpperCamelCase			)
						UpperCAmelCase__												=     ConvaD(new_size[1]						,      new_size[0]			).to(layer.weight.device			)
						UpperCAmelCase__												=     False
						new_layer.weight.copy_(W.contiguous()			)
						UpperCAmelCase__												=     True
						UpperCAmelCase__												=     False
						new_layer.bias.copy_(b.contiguous()			)
						UpperCAmelCase__												=     True
						return new_layer






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase = None			):





						"""simple docstring"""

						if isinstance(_UpperCamelCase						,      nn.Linear			):
												return prune_linear_layer(_UpperCamelCase						,      _UpperCamelCase						,      dim=0 if dim is None else dim			)
						elif isinstance(_UpperCamelCase						,      _UpperCamelCase			):
												return prune_convad_layer(_UpperCamelCase						,      _UpperCamelCase						,      dim=1 if dim is None else dim			)
						else:
												raise ValueError(F"""Can't prune layer of class {layer.__class__}"""			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      *_UpperCamelCase			):





						"""simple docstring"""

						assert len(_UpperCamelCase			) > 0, F"""{input_tensors} has to be a tuple/list of tensors"""

						# inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
						UpperCAmelCase__												=     len(inspect.signature(_UpperCamelCase			).parameters			)
						if num_args_in_forward_chunk_fn != len(_UpperCamelCase			):
												raise ValueError(
												    F"""forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(_UpperCamelCase			)} input """
												    '''tensors are given'''			)

						if chunk_size > 0:
												UpperCAmelCase__												=     input_tensors[0].shape[chunk_dim]
												for input_tensor in input_tensors:
																		if input_tensor.shape[chunk_dim] != tensor_shape:
																								raise ValueError(
																								    F"""All input tenors have to be of the same shape: {tensor_shape}, """
																								    F"""found shape {input_tensor.shape[chunk_dim]}"""			)

												if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
																		raise ValueError(
																		    F"""The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk """
																		    F"""size {chunk_size}"""			)

												UpperCAmelCase__												=     input_tensors[0].shape[chunk_dim] // chunk_size

												# chunk input tensor into tuples
												UpperCAmelCase__												=     tuple(input_tensor.chunk(_UpperCamelCase						,      dim=_UpperCamelCase			) for input_tensor in input_tensors			)
												# apply forward fn to every tuple
												UpperCAmelCase__												=     tuple(forward_fn(*_UpperCamelCase			) for input_tensors_chunk in zip(*_UpperCamelCase			)			)
												# concatenate output at same dimension
												return torch.cat(_UpperCamelCase						,      dim=_UpperCamelCase			)

						return forward_fn(*_UpperCamelCase			)






def        a__			(							_UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase			):





						"""simple docstring"""

						UpperCAmelCase__												=     torch.ones(_UpperCamelCase						,      _UpperCamelCase			)
						UpperCAmelCase__												=     set(_UpperCamelCase			) - already_pruned_heads  # Convert to set and remove already pruned heads
						for head in heads:
												# Compute how many pruned heads are before the head and move the index accordingly
												UpperCAmelCase__												=     head - sum(1 if h < head else 0 for h in already_pruned_heads			)
												UpperCAmelCase__												=     0
						UpperCAmelCase__												=     mask.view(-1			).contiguous().eq(1			)
						UpperCAmelCase__												=     torch.arange(len(_UpperCamelCase			)			)[mask].long()
						return heads, index






def        a__			(							*_UpperCamelCase						,      _UpperCamelCase = None			):





						"""simple docstring"""

						return torch.meshgrid(*_UpperCamelCase						,      indexing=_UpperCamelCase			)






def        a__			(							_UpperCamelCase			):





						"""simple docstring"""

						return tensor.device, storage_ptr(_UpperCamelCase			), storage_size(_UpperCamelCase			)