



# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


UpperCamelCase_										=					'3'

print('''Python version:''', sys.version)
print('''transformers version:''', transformers.__version__)

try:
      import torch

      print('''Torch version:''', torch.__version__)
      print('''Cuda available:''', torch.cuda.is_available())
      print('''Cuda version:''', torch.version.cuda)
      print('''CuDNN version:''', torch.backends.cudnn.version())
      print('''Number of GPUs available:''', torch.cuda.device_count())
      print('''NCCL version:''', torch.cuda.nccl.version())
except ImportError:
      print('''Torch version:''', None)

try:
      import deepspeed

      print('''DeepSpeed version:''', deepspeed.__version__)
except ImportError:
      print('''DeepSpeed version:''', None)

try:
      import tensorflow as tf

      print('''TensorFlow version:''', tf.__version__)
      print('''TF GPUs available:''', bool(tf.config.list_physical_devices('''GPU''')))
      print('''Number of TF GPUs available:''', len(tf.config.list_physical_devices('''GPU''')))
except ImportError:
      print('''TensorFlow version:''', None)

import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
					import tensorflow as tf

					from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments





@require_tf
class 					lowercase__						(   unittest.TestCase):


						def        __A       (       self	:				str    ,		UpperCamelCase__	:				int						):





												'''simple docstring'''





												for model_result in results.values():
																		for batch_size, sequence_length in zip(model_result['''bs''']    ,		model_result['''ss''']						):
																								SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							model_result['''result'''][batch_size][sequence_length]
																								self.assertIsNotNone(UpperCamelCase__						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    List[Any]							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		eager_mode=UpperCamelCase__    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    str							=							TensorFlowBenchmark(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    List[Any]							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    str							=							'''sgugger/tiny-distilbert-classification'''
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		only_pretrain_model=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    List[str]							=							TensorFlowBenchmark(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    int							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TensorFlowBenchmark(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    int							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    int							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		eager_mode=UpperCamelCase__    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    str							=							TensorFlowBenchmark(UpperCamelCase__    ,		[config]						)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Dict							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    List[str]							=							TensorFlowBenchmark(UpperCamelCase__    ,		[config]						)
												SCREAMING_SNAKE_CASE							:    int							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				List[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    str							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    int							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							TensorFlowBenchmark(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Tuple							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_train_result						)
												self.check_results_dict_not_empty(results.memory_train_result						)


						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    int							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Tuple							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Dict							=							TensorFlowBenchmark(UpperCamelCase__    ,		[config]						)
												SCREAMING_SNAKE_CASE							:    str							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_train_result						)
												self.check_results_dict_not_empty(results.memory_train_result						)


						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							'''patrickvonplaten/t5-tiny-random'''
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							AutoConfig.from_pretrained(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Dict							=							TensorFlowBenchmark(UpperCamelCase__    ,		configs=[config]						)
												SCREAMING_SNAKE_CASE							:    Dict							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						@unittest.skipIf(is_tf_available() and len(tf.config.list_physical_devices('''GPU'''						)						) == 0    ,		'''Cannot do xla on CPU.'''						)
						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							'''sshleifer/tiny-gpt2'''
												SCREAMING_SNAKE_CASE							:    Tuple							=							TensorFlowBenchmarkArguments(
												    models=[MODEL_ID]    ,		training=UpperCamelCase__    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		use_xla=UpperCamelCase__    ,		multi_process=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Any							=							TensorFlowBenchmark(UpperCamelCase__						)
												SCREAMING_SNAKE_CASE							:    List[Any]							=							benchmark.run()
												self.check_results_dict_not_empty(results.time_inference_result						)
												self.check_results_dict_not_empty(results.memory_inference_result						)


						def        __A       (       self	:				List[str]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							'''sshleifer/tiny-gpt2'''
												with tempfile.TemporaryDirectory() as tmp_dir:
																		SCREAMING_SNAKE_CASE							:    Tuple							=							TensorFlowBenchmarkArguments(
																		    models=[MODEL_ID]    ,		inference=UpperCamelCase__    ,		save_to_csv=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		inference_time_csv_file=os.path.join(UpperCamelCase__    ,		'''inf_time.csv'''						)    ,		inference_memory_csv_file=os.path.join(UpperCamelCase__    ,		'''inf_mem.csv'''						)    ,		env_info_csv_file=os.path.join(UpperCamelCase__    ,		'''env.csv'''						)    ,		multi_process=UpperCamelCase__    ,		)
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							TensorFlowBenchmark(UpperCamelCase__						)
																		benchmark.run()
																		self.assertTrue(Path(os.path.join(UpperCamelCase__    ,		'''inf_time.csv'''						)						).exists()						)
																		self.assertTrue(Path(os.path.join(UpperCamelCase__    ,		'''inf_mem.csv'''						)						).exists()						)
																		self.assertTrue(Path(os.path.join(UpperCamelCase__    ,		'''env.csv'''						)						).exists()						)



						def        __A       (       self	:				int						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Any							=							'''sshleifer/tiny-gpt2'''

												def _check_summary_is_not_empty(UpperCamelCase__	:				Dict						):
																		self.assertTrue(hasattr(UpperCamelCase__    ,		'''sequential'''						)						)
																		self.assertTrue(hasattr(UpperCamelCase__    ,		'''cumulative'''						)						)
																		self.assertTrue(hasattr(UpperCamelCase__    ,		'''current'''						)						)
																		self.assertTrue(hasattr(UpperCamelCase__    ,		'''total'''						)						)

												with tempfile.TemporaryDirectory() as tmp_dir:
																		SCREAMING_SNAKE_CASE							:    List[str]							=							TensorFlowBenchmarkArguments(
																		    models=[MODEL_ID]    ,		inference=UpperCamelCase__    ,		sequence_lengths=[8]    ,		batch_sizes=[1]    ,		log_filename=os.path.join(UpperCamelCase__    ,		'''log.txt'''						)    ,		log_print=UpperCamelCase__    ,		trace_memory_line_by_line=UpperCamelCase__    ,		eager_mode=UpperCamelCase__    ,		multi_process=UpperCamelCase__    ,		)
																		SCREAMING_SNAKE_CASE							:    List[Any]							=							TensorFlowBenchmark(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    Dict							=							benchmark.run()
																		_check_summary_is_not_empty(result.inference_summary						)
																		self.assertTrue(Path(os.path.join(UpperCamelCase__    ,		'''log.txt'''						)						).exists()						)





