



"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
	from transformers import (
	    AutoConfig,
	    BertConfig,
	    GPTaConfig,
	    TaConfig,
	    TFAutoModel,
	    TFAutoModelForCausalLM,
	    TFAutoModelForMaskedLM,
	    TFAutoModelForPreTraining,
	    TFAutoModelForQuestionAnswering,
	    TFAutoModelForSeqaSeqLM,
	    TFAutoModelForSequenceClassification,
	    TFAutoModelWithLMHead,
	    TFBertForMaskedLM,
	    TFBertForPreTraining,
	    TFBertForQuestionAnswering,
	    TFBertForSequenceClassification,
	    TFBertModel,
	    TFGPTaLMHeadModel,
	    TFRobertaForMaskedLM,
	    TFTaForConditionalGeneration,
	)
	from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
	from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
	from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
	from transformers import (
	    AutoModel,
	    AutoModelForCausalLM,
	    AutoModelForMaskedLM,
	    AutoModelForPreTraining,
	    AutoModelForQuestionAnswering,
	    AutoModelForSeqaSeqLM,
	    AutoModelForSequenceClassification,
	    AutoModelWithLMHead,
	    BertForMaskedLM,
	    BertForPreTraining,
	    BertForQuestionAnswering,
	    BertForSequenceClassification,
	    BertModel,
	    GPTaLMHeadModel,
	    RobertaForMaskedLM,
	    TaForConditionalGeneration,
	)



@is_pt_tf_cross_test
class 			A__   (  unittest.TestCase							):




	'''simple docstring'''





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

				"""simple docstring"""

				for model_name in ["bert-base-uncased"]:
							__lowerCAmelCase      :  Optional[int]												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Optional[Any]												=       TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Tuple												=       AutoModel.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		Union[str, Any])				->       Tuple:

				"""simple docstring"""

				for model_name in ["bert-base-uncased"]:
							__lowerCAmelCase      :  Union[str, Any]												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Optional[Any]												=       TFAutoModelForPreTraining.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  int												=       AutoModelForPreTraining.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[Any])				->       Dict:

				"""simple docstring"""

				for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase      :  Union[str, Any]												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  int												=       TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  str												=       TFAutoModelForCausalLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  int												=       AutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  int												=       AutoModelForCausalLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		Any)				->       Optional[Any]:

				"""simple docstring"""

				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase      :  str												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Union[str, Any]												=       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Union[str, Any]												=       AutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		str)				->       Any:

				"""simple docstring"""

				for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase      :  Dict												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Dict												=       TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  Dict												=       TFAutoModelForMaskedLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Tuple												=       AutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  Any												=       AutoModelForMaskedLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[Any])				->       List[Any]:

				"""simple docstring"""

				for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase      :  Union[str, Any]												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  str												=       TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  Optional[Any]												=       TFAutoModelForSeqaSeqLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  str												=       AutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							__lowerCAmelCase						,	__lowerCAmelCase      :  str												=       AutoModelForSeqaSeqLM.from_pretrained(
							    _SCREAMING_SNAKE_CASE       ,			output_loading_info=_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		int)				->       int:

				"""simple docstring"""

				for model_name in ["bert-base-uncased"]:
							__lowerCAmelCase      :  Tuple												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  int												=       TFAutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Optional[int]												=       AutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	@slow
	def 							_SCREAMING_SNAKE_CASE   (     self:		str)				->       int:

				"""simple docstring"""

				for model_name in ["bert-base-uncased"]:
							__lowerCAmelCase      :  Optional[int]												=       AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Optional[int]												=       TFAutoModelForQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

							__lowerCAmelCase      :  Union[str, Any]												=       AutoModelForQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
							self.assertIsNotNone(_SCREAMING_SNAKE_CASE)
							self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)

	def 							_SCREAMING_SNAKE_CASE   (     self:		Dict)				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Dict												=       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
				self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)
				self.assertEqual(model.num_parameters()       ,			1_4410)
				self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE)       ,			1_4410)

				__lowerCAmelCase      :  Union[str, Any]												=       AutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
				self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)
				self.assertEqual(model.num_parameters()       ,			1_4410)
				self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE)       ,			1_4410)







	def 							_SCREAMING_SNAKE_CASE   (     self:		str)				->       Dict:

				"""simple docstring"""

				__lowerCAmelCase      :  Any												=       TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_pt=_SCREAMING_SNAKE_CASE)
				self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)
				self.assertEqual(model.num_parameters()       ,			1_4410)
				self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE)       ,			1_4410)

				__lowerCAmelCase      :  Optional[Any]												=       AutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE       ,			from_tf=_SCREAMING_SNAKE_CASE)
				self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE)
				self.assertEqual(model.num_parameters()       ,			1_4410)
				self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE)       ,			1_4410)




"""simple docstring"""






#
# This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or
# many nodes) can talk to each other via nccl and allocate gpu memory.
#
# To run first adjust the number of processes and nodes:
#
# python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port
#
# You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d
#
# use torch.distributed.launch instead of torch.distributed.run for torch < 1.9
#
# If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with:
#
# NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# which should tell you what's going on behind the scenes.
#
#
# This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that
# runs on 2 nodes of 4 gpus per node:
#
# #SBATCH --job-name=test-nodes        # name
# #SBATCH --nodes=2                    # nodes
# #SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
# #SBATCH --cpus-per-task=10           # number of cores per tasks
# #SBATCH --gres=gpu:4                 # number of gpus
# #SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
# #SBATCH --output=%x-%j.out           # output file name
#
# GPUS_PER_NODE=4
# MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
# MASTER_PORT=6000
#
# srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \
# --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \
# --master_addr $MASTER_ADDR --master_port $MASTER_PORT \
# torch-distributed-gpu-test.py'
#

import fcntl
import os
import socket

import torch
import torch.distributed as dist


def 			_lowercase				(  *__snake_case	)						->   Optional[Any]:
			with open(__snake_case					,"r"	) as fh:
						fcntl.flock(__snake_case					,fcntl.LOCK_EX	)
						try:
									print(*__snake_case	)
						finally:
									fcntl.flock(__snake_case					,fcntl.LOCK_UN	)


__snake_case							:   List[Any]      =    int(os.environ['LOCAL_RANK'])
torch.cuda.set_device(local_rank)
__snake_case							:   List[str]      =    torch.device('cuda', local_rank)
__snake_case							:   Optional[Any]      =    socket.gethostname()

__snake_case							:   str      =    F"""[{hostname}-{local_rank}]"""

try:
	# test distributed
	dist.init_process_group('nccl')
	dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM)
	dist.barrier()

	# test cuda is available and can allocate memory
	torch.cuda.is_available()
	torch.ones(1).cuda(local_rank)

	# global rank
	__snake_case							:   Tuple      =    dist.get_rank()
	__snake_case							:   Any      =    dist.get_world_size()

	printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""")

	dist.barrier()
	if rank == 0:
		printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""")

except Exception:
	printflock(F"""{gpu} is broken""")
	raise