

import time
from contextlib import contextmanager
from pathlib import Path

import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder


lowerCAmelCase__								=		"""__DUMMY_TRANSFORMERS_USER__"""
lowerCAmelCase__								=		"""Dummy User"""
lowerCAmelCase__								=		"""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"""

lowerCAmelCase__								=		"""https://hub-ci.huggingface.co"""
lowerCAmelCase__								=		CI_HUB_ENDPOINT + """/datasets/{repo_id}/resolve/{revision}/{path}"""
lowerCAmelCase__								=		CI_HUB_ENDPOINT + """/{repo_id}/resolve/{revision}/{filename}"""
lowerCAmelCase__								=		Path("""~/.huggingface/hub_ci_token""").expanduser()






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     str	)						->				Dict:




	'''simple docstring'''




	monkeypatch.setattr(
	    'huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE'							,       UpperCAmelCase_	)






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     Any	)						->				Optional[Any]:




	'''simple docstring'''




	monkeypatch.setattr('datasets.config.HF_ENDPOINT'							,       UpperCAmelCase_	)
	monkeypatch.setattr('datasets.config.HUB_DATASETS_URL'							,       UpperCAmelCase_	)






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     Optional[Any]	)						->				Optional[int]:




	'''simple docstring'''




	monkeypatch.setattr('huggingface_hub.hf_api.HfFolder.path_token'							,       UpperCAmelCase_	)






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     Tuple							,       UpperCAmelCase_							:     Union[str, Any]	)						->				Optional[int]:




	'''simple docstring'''




	HfFolder.save_token(UpperCAmelCase_	)
	yield
	HfFolder.delete_token()






@pytest.fixture(scope='session'	)
def 					lowerCamelCase_     (							)						->				int:




	'''simple docstring'''




	return HfApi(endpoint=UpperCAmelCase_	)






@pytest.fixture(scope='session'	)
def 					lowerCamelCase_     (							UpperCAmelCase_							:     HfApi	)						->				List[Any]:




	'''simple docstring'''




	_UpperCamelCase   :		str			=						HfFolder.get_token()
	HfFolder.save_token(UpperCAmelCase_	)
	yield CI_HUB_USER_TOKEN
	if previous_token is not None:
		HfFolder.save_token(UpperCAmelCase_	)






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     List[Any]	)						->				Any:




	'''simple docstring'''




	def _cleanup_repo(UpperCAmelCase_							:     List[str]	):
		hf_api.delete_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'	)

	return _cleanup_repo






@pytest.fixture
def 					lowerCamelCase_     (							UpperCAmelCase_							:     List[str]	)						->				int:




	'''simple docstring'''




	@contextmanager
	def _temporary_repo(UpperCAmelCase_							:     Union[str, Any]	):
		try:
			yield repo_id
		finally:
			cleanup_repo(UpperCAmelCase_	)

	return _temporary_repo






@pytest.fixture(scope='session'	)
def 					lowerCamelCase_     (							UpperCAmelCase_							:     HfApi							,       UpperCAmelCase_							:     List[str]							,       UpperCAmelCase_							:     Any	)						->				str:




	'''simple docstring'''




	_UpperCamelCase   :		Union[str, Any]			=						F'''repo_txt_data-{int(time.time() * 1_0e3	)}'''
	_UpperCamelCase   :		Union[str, Any]			=						F'''{CI_HUB_USER}/{repo_name}'''
	hf_api.create_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'							,       private=UpperCAmelCase_	)
	hf_api.upload_file(
	    token=UpperCAmelCase_							,       path_or_fileobj=str(UpperCAmelCase_	)							,       path_in_repo='data/text_data.txt'							,       repo_id=UpperCAmelCase_							,       repo_type='dataset'							,       )
	yield repo_id
	try:
		hf_api.delete_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'	)
	except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
		pass






@pytest.fixture()
def 					lowerCamelCase_     (							UpperCAmelCase_							:     List[Any]							,       UpperCAmelCase_							:     Tuple							,       UpperCAmelCase_							:     List[str]	)						->				Union[str, Any]:




	'''simple docstring'''




	return hf_private_dataset_repo_txt_data_






@pytest.fixture(scope='session'	)
def 					lowerCamelCase_     (							UpperCAmelCase_							:     HfApi							,       UpperCAmelCase_							:     Tuple							,       UpperCAmelCase_							:     Optional[int]	)						->				str:




	'''simple docstring'''




	_UpperCamelCase   :		Dict			=						F'''repo_zipped_txt_data-{int(time.time() * 1_0e3	)}'''
	_UpperCamelCase   :		str			=						F'''{CI_HUB_USER}/{repo_name}'''
	hf_api.create_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'							,       private=UpperCAmelCase_	)
	hf_api.upload_file(
	    token=UpperCAmelCase_							,       path_or_fileobj=str(UpperCAmelCase_	)							,       path_in_repo='data.zip'							,       repo_id=UpperCAmelCase_							,       repo_type='dataset'							,       )
	yield repo_id
	try:
		hf_api.delete_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'	)
	except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
		pass






@pytest.fixture()
def 					lowerCamelCase_     (							UpperCAmelCase_							:     str							,       UpperCAmelCase_							:     List[Any]							,       UpperCAmelCase_							:     Tuple	)						->				str:




	'''simple docstring'''




	return hf_private_dataset_repo_zipped_txt_data_






@pytest.fixture(scope='session'	)
def 					lowerCamelCase_     (							UpperCAmelCase_							:     HfApi							,       UpperCAmelCase_							:     str							,       UpperCAmelCase_							:     Dict	)						->				int:




	'''simple docstring'''




	_UpperCamelCase   :		str			=						F'''repo_zipped_img_data-{int(time.time() * 1_0e3	)}'''
	_UpperCamelCase   :		int			=						F'''{CI_HUB_USER}/{repo_name}'''
	hf_api.create_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'							,       private=UpperCAmelCase_	)
	hf_api.upload_file(
	    token=UpperCAmelCase_							,       path_or_fileobj=str(UpperCAmelCase_	)							,       path_in_repo='data.zip'							,       repo_id=UpperCAmelCase_							,       repo_type='dataset'							,       )
	yield repo_id
	try:
		hf_api.delete_repo(UpperCAmelCase_							,       token=UpperCAmelCase_							,       repo_type='dataset'	)
	except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
		pass







@pytest.fixture()
def 					lowerCamelCase_     (							UpperCAmelCase_							:     List[Any]							,       UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     List[str]	)						->				List[str]:




	'''simple docstring'''




	return hf_private_dataset_repo_zipped_img_data_







import math
import os
import unittest

from transformers import MegatronBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_PRETRAINING_MAPPING,
							    MegatronBertForCausalLM,
							    MegatronBertForMaskedLM,
							    MegatronBertForMultipleChoice,
							    MegatronBertForNextSentencePrediction,
							    MegatronBertForPreTraining,
							    MegatronBertForQuestionAnswering,
							    MegatronBertForSequenceClassification,
							    MegatronBertForTokenClassification,
							    MegatronBertModel,
							)







class 	lowercase    :


		"""simple docstring"""




		def __init__(				self	,       __snake_case	,       __snake_case=13	,       __snake_case=7	,       __snake_case=True	,       __snake_case=True	,       __snake_case=True	,       __snake_case=True	,       __snake_case=99	,       __snake_case=64	,       __snake_case=32	,       __snake_case=5	,       __snake_case=4	,       __snake_case=37	,       __snake_case="gelu"	,       __snake_case=0.1	,       __snake_case=0.1	,       __snake_case=5_12	,       __snake_case=16	,       __snake_case=2	,       __snake_case=0.0_2	,       __snake_case=3	,       __snake_case=4	,       __snake_case=None	,       ):
			_UpperCamelCase   :		List[Any]			=						parent
			_UpperCamelCase   :		Optional[Any]			=						batch_size
			_UpperCamelCase   :		int			=						seq_length
			_UpperCamelCase   :		str			=						is_training
			_UpperCamelCase   :		Tuple			=						use_input_mask
			_UpperCamelCase   :		Union[str, Any]			=						use_token_type_ids
			_UpperCamelCase   :		Union[str, Any]			=						use_labels
			_UpperCamelCase   :		Optional[Any]			=						vocab_size
			_UpperCamelCase   :		List[Any]			=						hidden_size
			_UpperCamelCase   :		Optional[Any]			=						embedding_size
			_UpperCamelCase   :		str			=						num_hidden_layers
			_UpperCamelCase   :		str			=						num_attention_heads
			_UpperCamelCase   :		int			=						intermediate_size
			_UpperCamelCase   :		int			=						hidden_act
			_UpperCamelCase   :		Tuple			=						hidden_dropout_prob
			_UpperCamelCase   :		int			=						attention_probs_dropout_prob
			_UpperCamelCase   :		Tuple			=						max_position_embeddings
			_UpperCamelCase   :		List[str]			=						type_vocab_size
			_UpperCamelCase   :		Dict			=						type_sequence_label_size
			_UpperCamelCase   :		List[str]			=						initializer_range
			_UpperCamelCase   :		Optional[Any]			=						num_labels
			_UpperCamelCase   :		Tuple			=						num_choices
			_UpperCamelCase   :		List[str]			=						scope


		def 		A__					(				self):
			_UpperCamelCase   :		List[str]			=						ids_tensor([self.batch_size, self.seq_length]	,       self.vocab_size)

			_UpperCamelCase   :		Any			=						None
			if self.use_input_mask:
				_UpperCamelCase   :		int			=						random_attention_mask([self.batch_size, self.seq_length])

			_UpperCamelCase   :		Optional[Any]			=						None
			if self.use_token_type_ids:
				_UpperCamelCase   :		Dict			=						ids_tensor([self.batch_size, self.seq_length]	,       self.type_vocab_size)

			_UpperCamelCase   :		int			=						None
			_UpperCamelCase   :		List[str]			=						None
			_UpperCamelCase   :		Dict			=						None
			if self.use_labels:
				_UpperCamelCase   :		Any			=						ids_tensor([self.batch_size]	,       self.type_sequence_label_size)
				_UpperCamelCase   :		Optional[Any]			=						ids_tensor([self.batch_size, self.seq_length]	,       self.num_labels)
				_UpperCamelCase   :		List[str]			=						ids_tensor([self.batch_size]	,       self.num_choices)

			_UpperCamelCase   :		Union[str, Any]			=						self.get_config()

			return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


		def 		A__					(				self):
			return MegatronBertConfig(
			    vocab_size=self.vocab_size	,       hidden_size=self.hidden_size	,       num_hidden_layers=self.num_hidden_layers	,       num_attention_heads=self.num_attention_heads	,       intermediate_size=self.intermediate_size	,       embedding_size=self.embedding_size	,       hidden_act=self.hidden_act	,       hidden_dropout_prob=self.hidden_dropout_prob	,       attention_probs_dropout_prob=self.attention_probs_dropout_prob	,       max_position_embeddings=self.max_position_embeddings	,       type_vocab_size=self.type_vocab_size	,       is_decoder=__snake_case	,       initializer_range=self.initializer_range	,       )


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		List[str]			=						MegatronBertModel(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		Optional[int]			=						model(__snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case)
			_UpperCamelCase   :		Dict			=						model(__snake_case	,       token_type_ids=__snake_case)
			_UpperCamelCase   :		Optional[Any]			=						model(__snake_case)

			self.parent.assertEqual(result.last_hidden_state.shape	,       (self.batch_size, self.seq_length, self.hidden_size))
			self.parent.assertEqual(result.pooler_output.shape	,       (self.batch_size, self.hidden_size))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		int			=						MegatronBertForMaskedLM(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		Dict			=						model(__snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case)
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.seq_length, self.vocab_size))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		str			=						MegatronBertForCausalLM(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		Optional[int]			=						model(__snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case)
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.seq_length, self.vocab_size))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		Tuple			=						MegatronBertForNextSentencePrediction(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		Optional[Any]			=						model(
			    __snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case	,       )
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, 2))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		Optional[Any]			=						MegatronBertForPreTraining(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		List[str]			=						model(
			    __snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case	,       next_sentence_label=__snake_case	,       )
			self.parent.assertEqual(result.prediction_logits.shape	,       (self.batch_size, self.seq_length, self.vocab_size))
			self.parent.assertEqual(result.seq_relationship_logits.shape	,       (self.batch_size, 2))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		int			=						MegatronBertForQuestionAnswering(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		List[Any]			=						model(
			    __snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       start_positions=__snake_case	,       end_positions=__snake_case	,       )
			self.parent.assertEqual(result.start_logits.shape	,       (self.batch_size, self.seq_length))
			self.parent.assertEqual(result.end_logits.shape	,       (self.batch_size, self.seq_length))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		Optional[int]			=						self.num_labels
			_UpperCamelCase   :		Union[str, Any]			=						MegatronBertForSequenceClassification(__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		str			=						model(__snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case)
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.num_labels))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		Any			=						self.num_labels
			_UpperCamelCase   :		Optional[int]			=						MegatronBertForTokenClassification(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		Tuple			=						model(__snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case)
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.seq_length, self.num_labels))


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case	,       __snake_case):
			_UpperCamelCase   :		List[str]			=						self.num_choices
			_UpperCamelCase   :		Optional[int]			=						MegatronBertForMultipleChoice(config=__snake_case)
			model.to(__snake_case)
			model.eval()
			_UpperCamelCase   :		List[Any]			=						input_ids.unsqueeze(1).expand(-1	,       self.num_choices	,       -1).contiguous()
			_UpperCamelCase   :		List[Any]			=						token_type_ids.unsqueeze(1).expand(-1	,       self.num_choices	,       -1).contiguous()
			_UpperCamelCase   :		Optional[Any]			=						input_mask.unsqueeze(1).expand(-1	,       self.num_choices	,       -1).contiguous()
			_UpperCamelCase   :		Union[str, Any]			=						model(
			    __snake_case	,       attention_mask=__snake_case	,       token_type_ids=__snake_case	,       labels=__snake_case	,       )
			self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.num_choices))






		def 		A__					(				self):
			_UpperCamelCase   :		Union[str, Any]			=						self.prepare_config_and_inputs()
			(
			    (
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		(
			    _UpperCamelCase
			)	,		
			)   :		Optional[int]			=						config_and_inputs
			_UpperCamelCase   :		int			=						{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
			return config, inputs_dict







@require_torch
class 	lowercase    (				_lowercase    ,							_lowercase    ,							unittest.TestCase							):


		"""simple docstring"""




		a__					       =  (
		    (
		        MegatronBertModel,
		        MegatronBertForMaskedLM,
		        MegatronBertForCausalLM,
		        MegatronBertForMultipleChoice,
		        MegatronBertForNextSentencePrediction,
		        MegatronBertForPreTraining,
		        MegatronBertForQuestionAnswering,
		        MegatronBertForSequenceClassification,
		        MegatronBertForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		a__					       =  (
		    {
		        "feature-extraction": MegatronBertModel,
		        "fill-mask": MegatronBertForMaskedLM,
		        "question-answering": MegatronBertForQuestionAnswering,
		        "text-classification": MegatronBertForSequenceClassification,
		        "text-generation": MegatronBertForCausalLM,
		        "token-classification": MegatronBertForTokenClassification,
		        "zero-shot": MegatronBertForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		a__					       =  True
		# test_resize_embeddings = False
		a__					       =  False


		def 		A__					(				self	,       __snake_case	,       __snake_case	,       __snake_case=False):
			_UpperCamelCase   :		str			=						super()._prepare_for_class(__snake_case	,       __snake_case	,       return_labels=__snake_case)

			if return_labels:
				if model_class in get_values(__snake_case):
					_UpperCamelCase   :		Optional[Any]			=						torch.zeros(
					    (self.model_tester.batch_size, self.model_tester.seq_length)	,       dtype=torch.long	,       device=__snake_case)
					_UpperCamelCase   :		str			=						torch.zeros(
					    self.model_tester.batch_size	,       dtype=torch.long	,       device=__snake_case)
			return inputs_dict


		def 		A__					(				self):
			_UpperCamelCase   :		Any			=						MegatronBertModelTester(self)
			_UpperCamelCase   :		int			=						ConfigTester(self	,       config_class=__snake_case	,       hidden_size=37)


		def 		A__					(				self):
			self.config_tester.run_common_tests()


		def 		A__					(				self):
			_UpperCamelCase   :		Optional[int]			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_model(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		Dict			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_masked_lm(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		int			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_multiple_choice(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		Dict			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_next_sequence_prediction(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		str			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_pretraining(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		List[Any]			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_question_answering(*__snake_case)


		def 		A__					(				self):
			_UpperCamelCase   :		Optional[Any]			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_sequence_classification(*__snake_case)






		def 		A__					(				self):
			_UpperCamelCase   :		Any			=						self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_megatron_bert_for_token_classification(*__snake_case)






def 					lowerCamelCase_     (							UpperCAmelCase_							:     str	)						->				Optional[Any]:




	'''simple docstring'''




	return torch.tensor(
	    UpperCAmelCase_							,       dtype=torch.long							,       device=UpperCAmelCase_							,       )


lowerCAmelCase__								=		1e-4







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


		"""simple docstring"""




		@slow
		@unittest.skip('Model is not available.')
		def 		A__					(				self):
			_UpperCamelCase   :		int			=						'nvidia/megatron-bert-uncased-345m'
			if "MYDIR" in os.environ:
				_UpperCamelCase   :		int			=						os.path.join(os.environ['MYDIR']	,       __snake_case)
			_UpperCamelCase   :		Optional[int]			=						MegatronBertModel.from_pretrained(__snake_case)
			model.to(__snake_case)
			model.half()
			_UpperCamelCase   :		Optional[Any]			=						_long_tensor([[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]])
			with torch.no_grad():
				_UpperCamelCase   :		str			=						model(__snake_case)[0]
			_UpperCamelCase   :		Optional[int]			=						torch.Size((1, 9, 10_24))
			self.assertEqual(output.shape	,       __snake_case)

			_UpperCamelCase   :		Union[str, Any]			=						[-0.6_0_4_0, -0.2_5_1_7, -0.1_0_2_5, 0.3_4_2_0, -0.6_7_5_8, -0.0_0_1_7, -0.1_0_8_9, -0.1_9_9_0, 0.5_7_2_8]
			for ii in range(3):
				for jj in range(3):
					_UpperCamelCase   :		Optional[Any]			=						output[0, ii, jj]
					_UpperCamelCase   :		Dict			=						expected[3 * ii + jj]
					_UpperCamelCase   :		Optional[int]			=						'ii={} jj={} a={} b={}'.format(__snake_case	,       __snake_case	,       __snake_case	,       __snake_case)
					self.assertTrue(math.isclose(__snake_case	,       __snake_case	,       rel_tol=__snake_case	,       abs_tol=__snake_case)	,       msg=__snake_case)




