


'''simple docstring'''



import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_torch_available
from transformers.testing_utils import require_torch, torch_device


if is_torch_available():
	from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments






@require_torch
class 	UpperCamelCase__(       unittest.TestCase	):




				def 					a__(		self      :			int				,   lowerCAmelCase      :			Optional[int]				)->					Any:

										"""simple docstring"""




										for model_result in results.values():
																for batch_size, sequence_length in zip(model_result['''bs''']				,   model_result['''ss''']				):
																						UpperCAmelCase					    =     model_result['''result'''][batch_size][sequence_length]
																						self.assertIsNotNone(lowercase_				)




				def 					a__(		self      :			Dict				)->					Any:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     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]				)->					Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sgugger/tiny-distilbert-classification'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   only_pretrain_model=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     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				)->					str:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   torchscript=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     benchmark.run()
										self.check_results_dict_not_empty(results.time_inference_result				)
										self.check_results_dict_not_empty(results.memory_inference_result				)




				@unittest.skipIf(torch_device == '''cpu'''				,   '''Cant do half precision'''				)
				def 					a__(		self      :			Optional[int]				)->					int:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   fpaa=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     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      :			Union[str, Any]				)->					Any:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     AutoConfig.from_pretrained(lowercase_				)
										# set architectures equal to `None`
										UpperCAmelCase					    =     None
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				,   configs=[config]				)
										UpperCAmelCase					    =     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      :			Union[str, Any]				)->					str:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     benchmark.run()
										self.check_results_dict_not_empty(results.time_train_result				)
										self.check_results_dict_not_empty(results.memory_train_result				)




				@unittest.skipIf(torch_device == '''cpu'''				,   '''Can\'t do half precision'''				)
				def 					a__(		self      :			int				)->					Tuple:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   fpaa=lowercase_				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
										UpperCAmelCase					    =     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      :			Any				)->					Optional[int]:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     AutoConfig.from_pretrained(lowercase_				)
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				,   configs=[config]				)
										UpperCAmelCase					    =     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      :			Dict				)->					Dict:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tinier_bart'''
										UpperCAmelCase					    =     AutoConfig.from_pretrained(lowercase_				)
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				,   configs=[config]				)
										UpperCAmelCase					    =     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[int]				)->					List[Any]:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										UpperCAmelCase					    =     AutoConfig.from_pretrained(lowercase_				)
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				,   configs=[config]				)
										UpperCAmelCase					    =     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      :			Union[str, Any]				)->					Any:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tinier_bart'''
										UpperCAmelCase					    =     AutoConfig.from_pretrained(lowercase_				)
										UpperCAmelCase					    =     PyTorchBenchmarkArguments(
										    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   multi_process=lowercase_				,   )
										UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				,   configs=[config]				)
										UpperCAmelCase					    =     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      :			Dict				)->					Any:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''
										with tempfile.TemporaryDirectory() as tmp_dir:
																UpperCAmelCase					    =     PyTorchBenchmarkArguments(
																    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   save_to_csv=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   inference_time_csv_file=os.path.join(lowercase_				,   '''inf_time.csv'''				)				,   train_memory_csv_file=os.path.join(lowercase_				,   '''train_mem.csv'''				)				,   inference_memory_csv_file=os.path.join(lowercase_				,   '''inf_mem.csv'''				)				,   train_time_csv_file=os.path.join(lowercase_				,   '''train_time.csv'''				)				,   env_info_csv_file=os.path.join(lowercase_				,   '''env.csv'''				)				,   multi_process=lowercase_				,   )
																UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
																benchmark.run()
																self.assertTrue(Path(os.path.join(lowercase_				,   '''inf_time.csv'''				)				).exists()				)
																self.assertTrue(Path(os.path.join(lowercase_				,   '''train_time.csv'''				)				).exists()				)
																self.assertTrue(Path(os.path.join(lowercase_				,   '''inf_mem.csv'''				)				).exists()				)
																self.assertTrue(Path(os.path.join(lowercase_				,   '''train_mem.csv'''				)				).exists()				)
																self.assertTrue(Path(os.path.join(lowercase_				,   '''env.csv'''				)				).exists()				)





				def 					a__(		self      :			Tuple				)->					Optional[int]:

										"""simple docstring"""




										UpperCAmelCase					    =     '''sshleifer/tiny-gpt2'''

										def _check_summary_is_not_empty(lowerCAmelCase      :			List[Any]				):
																self.assertTrue(hasattr(lowercase_				,   '''sequential'''				)				)
																self.assertTrue(hasattr(lowercase_				,   '''cumulative'''				)				)
																self.assertTrue(hasattr(lowercase_				,   '''current'''				)				)
																self.assertTrue(hasattr(lowercase_				,   '''total'''				)				)

										with tempfile.TemporaryDirectory() as tmp_dir:
																UpperCAmelCase					    =     PyTorchBenchmarkArguments(
																    models=[MODEL_ID]				,   training=lowercase_				,   inference=lowercase_				,   sequence_lengths=[8]				,   batch_sizes=[1]				,   log_filename=os.path.join(lowercase_				,   '''log.txt'''				)				,   log_print=lowercase_				,   trace_memory_line_by_line=lowercase_				,   multi_process=lowercase_				,   )
																UpperCAmelCase					    =     PyTorchBenchmark(lowercase_				)
																UpperCAmelCase					    =     benchmark.run()
																_check_summary_is_not_empty(result.inference_summary				)
																_check_summary_is_not_empty(result.train_summary				)
																self.assertTrue(Path(os.path.join(lowercase_				,   '''log.txt'''				)				).exists()				)









'''simple docstring'''



def 				lowerCamelCase__				(	A       :      int				,       A       :      int					):




						'''simple docstring'''






						return int(input_a == input_a == 0					)


def 				lowerCamelCase__				(	):




						'''simple docstring'''






						print('''Truth Table of NOR Gate:'''					)
						print('''|   Input 1   |  Input 2  | Output |'''					)
						print(f"""|      0      |    0      |  {nor_gate(0				,       0					)}     |"""					)
						print(f"""|      0      |    1      |  {nor_gate(0				,       1					)}     |"""					)
						print(f"""|      1      |    0      |  {nor_gate(1				,       0					)}     |"""					)
						print(f"""|      1      |    1      |  {nor_gate(1				,       1					)}     |"""					)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()





