




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 			A			(		unittest.TestCase		):
     """simple docstring"""

     @slow
     @unittest.skip('Model is not available.'			)
     def  __snake_case   (    self  :   Optional[int]			)				->       Optional[Any]:
           lowerCamelCase__        =				'nvidia/megatron-gpt2-345m/'
           if "MYDIR" in os.environ:
                 lowerCamelCase__        =				os.path.join(os.environ['MYDIR']	,  A__			)
           lowerCamelCase__        =				GPTaLMHeadModel.from_pretrained(A__			)
           model.to(A__			)
           model.half()

           lowerCamelCase__        =				torch.tensor(
               [[1_0_1, 7_1_1_0, 1_0_0_5, 1_0_5_6, 2_0_2_3, 1_1_3_3_3, 1_7_4_1_3, 1_0_2_9, 1_0_2]]	,  device=A__	,  dtype=torch.long	,  )

           with torch.no_grad():
                 lowerCamelCase__        =				model(A__			).logits

           lowerCamelCase__        =				torch.Size((1, 9, 5_0_2_5_7)			)
           self.assertEqual(output.shape	,  A__			)

           lowerCamelCase__        =				torch.tensor(
               [
                   4.9414,
                   -0.2920,
                   -1.2148,
                   -4.0273,
                   -0.5161,
                   -5.2109,
                   -1.2412,
                   -1.8301,
                   -1.7734,
                   -4.7148,
                   -0.2317,
                   -1.0811,
                   -2.1777,
                   0.4141,
                   -3.7969,
                   -4.0586,
                   -2.5332,
                   -3.3809,
                   4.3867,
               ]	,  device=A__	,  dtype=torch.half	,  )

           for i in range(1_9			):
                 lowerCamelCase__  ,		lowerCamelCase__        =				8 * i // 1_7, 2_7_9_2 * i  # along the diagonal
                 lowerCamelCase__  ,		lowerCamelCase__        =				output[0, r, c], expected_diag[i]
                 lowerCamelCase__        =				F"""row={r} col={c} computed={computed} expected={expected}"""
                 self.assertAlmostEqual(A__	,  A__	,  delta=1E-4	,  msg=A__			)





import importlib.metadata
import sys

from transformers.testing_utils import TestCasePlus
from transformers.utils.versions import require_version, require_version_core


__SCREAMING_SNAKE_CASE    :   int       =importlib.metadata.version("""numpy""")
__SCREAMING_SNAKE_CASE    :   Optional[int]       =""".""".join([str(x) for x in sys.version_info[:3]])






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     def  __snake_case   (    self  :   List[Any]			)				->       Optional[int]:
           # lt + different version strings
           require_version_core('numpy<1000.4.5'			)
           require_version_core('numpy<1000.4'			)
           require_version_core('numpy<1000'			)

           # le
           require_version_core('numpy<=1000.4.5'			)
           require_version_core(F"""numpy<={numpy_ver}"""			)

           # eq
           require_version_core(F"""numpy=={numpy_ver}"""			)

           # ne
           require_version_core('numpy!=1000.4.5'			)

           # ge
           require_version_core('numpy>=1.0'			)
           require_version_core('numpy>=1.0.0'			)
           require_version_core(F"""numpy>={numpy_ver}"""			)

           # gt
           require_version_core('numpy>1.0.0'			)

           # mix
           require_version_core('numpy>1.0.0,<1000'			)

           # requirement w/o version
           require_version_core('numpy'			)

           # unmet requirements due to version conflict
           for req in ["numpy==1.0.0", "numpy>=1000.0.0", F"""numpy<{numpy_ver}"""]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn('but found'	,  str(A__			)			)

        # unmet requirements due to missing module
           for req in ["numpipypie>1", "numpipypie2"]:
                 try:
                       require_version_core(A__			)
                 except importlib.metadata.PackageNotFoundError as e:
                       self.assertIn(F"""The '{req}' distribution was not found and is required by this application"""	,  str(A__			)			)
                       self.assertIn('Try: pip install transformers -U'	,  str(A__			)			)

        # bogus requirements formats:
        # 1. whole thing
           for req in ["numpy??1.0.0", "numpy1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('requirement needs to be in the pip package format'	,  str(A__			)			)
        # 2. only operators
           for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ValueError as e:
                       self.assertIn('need one of '	,  str(A__			)			)




     def  __snake_case   (    self  :   str			)				->       Optional[int]:
           # matching requirement
           require_version('python>=3.6.0'			)

           # not matching requirements
           for req in ["python>9.9.9", "python<3.0.0"]:
                 try:
                       require_version_core(A__			)
                 except ImportError as e:
                       self.assertIn(F"""{req} is required"""	,  str(A__			)			)
                       self.assertIn(F"""but found python=={python_ver}"""	,  str(A__			)			)