




"""simple docstring"""

from ..utils import DummyObject, requires_backends
class      A__   (   metaclass=_lowerCAmelCase  ):
	A_				:					List[Any]      =   ["torch", "librosa"]




	def __init__( self	:						List[str]   ,     *lowercase	:						int   ,     **lowercase	:						Any						)       ->			Tuple:
						requires_backends(self   ,     ["""torch""", """librosa"""]						)




	@classmethod
	def 				a_		( cls	:						Optional[Any]   ,     *lowercase	:						Union[str, Any]   ,     **lowercase	:						List[Any]						)       ->			Optional[Any]:
						requires_backends(cls   ,     ["""torch""", """librosa"""]						)




	@classmethod
	def 				a_		( cls	:						Union[str, Any]   ,     *lowercase	:						Any   ,     **lowercase	:						List[Any]						)       ->			List[Any]:
						requires_backends(cls   ,     ["""torch""", """librosa"""]						)

class      A__   (   metaclass=_lowerCAmelCase  ):
	A_				:					Any      =   ["torch", "librosa"]




	def __init__( self	:						List[str]   ,     *lowercase	:						Optional[int]   ,     **lowercase	:						Optional[Any]						)       ->			List[str]:
						requires_backends(self   ,     ["""torch""", """librosa"""]						)




	@classmethod
	def 				a_		( cls	:						Tuple   ,     *lowercase	:						Union[str, Any]   ,     **lowercase	:						Any						)       ->			Optional[Any]:
						requires_backends(cls   ,     ["""torch""", """librosa"""]						)




	@classmethod
	def 				a_		( cls	:						Dict   ,     *lowercase	:						Tuple   ,     **lowercase	:						List[str]						)       ->			Optional[Any]:
						requires_backends(cls   ,     ["""torch""", """librosa"""]						)










"""simple docstring"""


import os
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
       import torch

       from transformers import GPTaLMHeadModel


@require_torch
@require_sentencepiece
@require_tokenizers
class    snake_case						(				unittest.TestCase		):


   '''simple docstring'''

   @slow
   @unittest.skip('''Model is not available.'''    )
   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

     '''simple docstring'''
     __A		     =					'''nvidia/megatron-gpt2-345m/'''
     if "MYDIR" in os.environ:
       __A		     =					os.path.join(os.environ['''MYDIR'''],			_lowerCamelCase    )
     __A		     =					GPTaLMHeadModel.from_pretrained(_lowerCamelCase    )
     model.to(_lowerCamelCase    )
     model.half()

     __A		     =					torch.tensor(
         [[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]],			device=_lowerCamelCase,			dtype=torch.long,			)

     with torch.no_grad():
       __A		     =					model(_lowerCamelCase    ).logits

     __A		     =					torch.Size((1, 9, 5_02_57)    )
     self.assertEqual(output.shape,			_lowerCamelCase    )

     __A		     =					torch.tensor(
         [
             4.94_14,
             -0.29_20,
             -1.21_48,
             -4.02_73,
             -0.51_61,
             -5.21_09,
             -1.24_12,
             -1.83_01,
             -1.77_34,
             -4.71_48,
             -0.23_17,
             -1.08_11,
             -2.17_77,
             0.41_41,
             -3.79_69,
             -4.05_86,
             -2.53_32,
             -3.38_09,
             4.38_67,
         ],			device=_lowerCamelCase,			dtype=torch.half,			)

     for i in range(19    ):
       __A     ,       __A		     =					8 * i // 17, 27_92 * i  # along the diagonal
       __A     ,       __A		     =					output[0, r, c], expected_diag[i]
       __A		     =					f'row={r} col={c} computed={computed} expected={expected}'
       self.assertAlmostEqual(_lowerCamelCase,			_lowerCamelCase,			delta=1e-4,			msg=_lowerCamelCase    )




