
'''simple docstring'''

import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
		import tensorflow as tf
		from tensorflow.python.framework.errors_impl import ResourceExhaustedError

		from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
		import pyanvml.pyanvml as nvml

UpperCAmelCase__ :			Any											=		logging.get_logger(__name__)







def 	A  (   UpperCamelCase_       :  bool    ,						UpperCamelCase_       :  bool   )       ->							str:







			'''simple docstring'''



			def run_func(UpperCamelCase_       :  Dict   ):
						@wraps(__UpperCamelCase   )
						def run_in_eager_mode(*UpperCamelCase_       :  List[str]    ,						**UpperCamelCase_       :  Union[str, Any]   ):
									return func(*__UpperCamelCase    ,						**__UpperCamelCase   )

						@wraps(__UpperCamelCase   )
						@tf.function(experimental_compile=__UpperCamelCase   )
						def run_in_graph_mode(*UpperCamelCase_       :  str    ,						**UpperCamelCase_       :  Union[str, Any]   ):
									return func(*__UpperCamelCase    ,						**__UpperCamelCase   )

						if do_eager_mode is True:
									if use_xla is not False:
												raise ValueError(
												    "Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`."   )
									return run_in_eager_mode
						else:
									return run_in_graph_mode

			return run_func







def 	A  (   UpperCamelCase_       :  int    ,						UpperCamelCase_       :  int    ,						UpperCamelCase_       :  int   )       ->							int:







			'''simple docstring'''



			lowerCAmelCase__										=				random.Random()
			lowerCAmelCase__										=				[rng.randint(0    ,						vocab_size - 1   ) for i in range(batch_size * sequence_length   )]
			return tf.constant(__UpperCamelCase    ,						shape=(batch_size, sequence_length)    ,						dtype=tf.intaa   )






class  A  (						SCREAMING_SNAKE_CASE__     ):
	snake_case__   :TensorFlowBenchmarkArguments
	snake_case__   :PretrainedConfig
	snake_case__   :str   =  "TensorFlow"





	@property
	def 				__SCREAMING_SNAKE_CASE	(       self      :							List[str]				):


				"""simple docstring"""

				return tf.__version__





	def 				__SCREAMING_SNAKE_CASE	(       self      :							Optional[Any]   ,				__magic_name__      :							Dict   ,				__magic_name__      :							Dict   ,				__magic_name__      :							Any				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.args.strategy
				if strategy is None:
							raise ValueError("A device strategy has to be initialized before using TensorFlow."				)
				lowerCAmelCase__										=				self._prepare_inference_func(__magic_name__   ,				__magic_name__   ,				__magic_name__				)
				return self._measure_speed(_inference				)





	def 				__SCREAMING_SNAKE_CASE	(       self      :							str   ,				__magic_name__      :							List[str]   ,				__magic_name__      :							str   ,				__magic_name__      :							Optional[Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.args.strategy
				if strategy is None:
							raise ValueError("A device strategy has to be initialized before using TensorFlow."				)
				lowerCAmelCase__										=				self._prepare_train_func(__magic_name__   ,				__magic_name__   ,				__magic_name__				)
				return self._measure_speed(_train				)





	def 				__SCREAMING_SNAKE_CASE	(       self      :							List[Any]   ,				__magic_name__      :							Tuple   ,				__magic_name__      :							int   ,				__magic_name__      :							Any				):


				"""simple docstring"""

				if self.args.is_gpu:
							tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]   ,				__magic_name__				)
				lowerCAmelCase__										=				self.args.strategy
				if strategy is None:
							raise ValueError("A device strategy has to be initialized before using TensorFlow."				)
				lowerCAmelCase__										=				self._prepare_inference_func(__magic_name__   ,				__magic_name__   ,				__magic_name__				)
				return self._measure_memory(_inference				)





	def 				__SCREAMING_SNAKE_CASE	(       self      :							int   ,				__magic_name__      :							List[Any]   ,				__magic_name__      :							Dict   ,				__magic_name__      :							int				):


				"""simple docstring"""

				if self.args.is_gpu:
							tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]   ,				__magic_name__				)
				lowerCAmelCase__										=				self.args.strategy
				if strategy is None:
							raise ValueError("A device strategy has to be initialized before using TensorFlow."				)

				lowerCAmelCase__										=				self._prepare_train_func(__magic_name__   ,				__magic_name__   ,				__magic_name__				)
				return self._measure_memory(_train				)





	def 				__SCREAMING_SNAKE_CASE	(       self      :							Tuple   ,				__magic_name__      :							Any   ,				__magic_name__      :							int   ,				__magic_name__      :							Union[str, Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.config_dict[model_name]

				if self.args.fpaa:
							raise NotImplementedError("Mixed precision is currently not supported."				)

				lowerCAmelCase__										=				(
				    hasattr(__magic_name__   ,				"architectures"				)
				    and isinstance(config.architectures   ,				__magic_name__				)
				    and len(config.architectures				) > 0
				)
				if not self.args.only_pretrain_model and has_model_class_in_config:
							try:
										lowerCAmelCase__										=				'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
										lowerCAmelCase__										=				__import__("transformers"   ,				fromlist=[model_class]				)
										lowerCAmelCase__										=				getattr(__magic_name__   ,				__magic_name__				)
										lowerCAmelCase__										=				model_cls(__magic_name__				)
							except ImportError:
										raise ImportError(
										    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
										    " set `--only_pretrain_model` or `args.only_pretrain_model=True`."				)
				else:
							lowerCAmelCase__										=				TF_MODEL_MAPPING[config.__class__](__magic_name__				)

				# encoder-decoder has vocab size saved differently
				lowerCAmelCase__										=				config.vocab_size if hasattr(__magic_name__   ,				"vocab_size"				) else config.encoder.vocab_size
				lowerCAmelCase__										=				random_input_ids(__magic_name__   ,				__magic_name__   ,				__magic_name__				)

				@run_with_tf_optimizations(self.args.eager_mode   ,				self.args.use_xla				)
				def encoder_decoder_forward():
							return model(__magic_name__   ,				decoder_input_ids=__magic_name__   ,				training=__magic_name__				)

				@run_with_tf_optimizations(self.args.eager_mode   ,				self.args.use_xla				)
				def encoder_forward():
							return model(__magic_name__   ,				training=__magic_name__				)

				lowerCAmelCase__										=				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

				return _inference





	def 				__SCREAMING_SNAKE_CASE	(       self      :							Optional[int]   ,				__magic_name__      :							Union[str, Any]   ,				__magic_name__      :							int   ,				__magic_name__      :							Optional[Any]				):


				"""simple docstring"""

				lowerCAmelCase__										=				self.config_dict[model_name]

				if self.args.eager_mode is not False:
							raise ValueError("Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`."				)

				if self.args.fpaa:
							raise NotImplementedError("Mixed precision is currently not supported."				)

				lowerCAmelCase__										=				(
				    hasattr(__magic_name__   ,				"architectures"				)
				    and isinstance(config.architectures   ,				__magic_name__				)
				    and len(config.architectures				) > 0
				)
				if not self.args.only_pretrain_model and has_model_class_in_config:
							try:
										lowerCAmelCase__										=				'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
										lowerCAmelCase__										=				__import__("transformers"   ,				fromlist=[model_class]				)
										lowerCAmelCase__										=				getattr(__magic_name__   ,				__magic_name__				)
										lowerCAmelCase__										=				model_cls(__magic_name__				)
							except ImportError:
										raise ImportError(
										    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
										    " set `--only_pretrain_model` or `args.only_pretrain_model=True`."				)
				else:
							lowerCAmelCase__										=				TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__magic_name__				)

				# encoder-decoder has vocab size saved differently
				lowerCAmelCase__										=				config.vocab_size if hasattr(__magic_name__   ,				"vocab_size"				) else config.encoder.vocab_size
				lowerCAmelCase__										=				random_input_ids(__magic_name__   ,				__magic_name__   ,				__magic_name__				)

				@run_with_tf_optimizations(self.args.eager_mode   ,				self.args.use_xla				)
				def encoder_decoder_train():
							lowerCAmelCase__										=				model(__magic_name__   ,				decoder_input_ids=__magic_name__   ,				labels=__magic_name__   ,				training=__magic_name__				)[0]
							lowerCAmelCase__										=				tf.gradients(__magic_name__   ,				model.trainable_variables				)
							return gradients

				@run_with_tf_optimizations(self.args.eager_mode   ,				self.args.use_xla				)
				def encoder_train():
							lowerCAmelCase__										=				model(__magic_name__   ,				labels=__magic_name__   ,				training=__magic_name__				)[0]
							lowerCAmelCase__										=				tf.gradients(__magic_name__   ,				model.trainable_variables				)
							return gradients

				lowerCAmelCase__										=				encoder_decoder_train if config.is_encoder_decoder else encoder_train

				return _train





	def 				__SCREAMING_SNAKE_CASE	(       self      :							Tuple   ,				__magic_name__      :							Optional[Any]				):


				"""simple docstring"""

				with self.args.strategy.scope():
							try:
										if self.args.is_tpu or self.args.use_xla:
													# run additional 10 times to stabilize compilation for tpu
													logger.info("Do inference on TPU. Running model 5 times to stabilize compilation"				)
													timeit.repeat(__magic_name__   ,				repeat=1   ,				number=5				)

										# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
										lowerCAmelCase__										=				timeit.repeat(
										    __magic_name__   ,				repeat=self.args.repeat   ,				number=10   ,				)

										return min(__magic_name__				) / 10.0
							except ResourceExhaustedError as e:
										self.print_fn(f"""Doesn't fit on GPU. {e}"""				)







	def 				__SCREAMING_SNAKE_CASE	(       self      :							Optional[int]   ,				__magic_name__      :							str				):


				"""simple docstring"""

				logger.info(
				    "Note that TensorFlow allocates more memory than "
				    "it might need to speed up computation. "
				    "The memory reported here corresponds to the memory "
				    "reported by `nvidia-smi`, which can vary depending "
				    "on total available memory on the GPU that is used."				)
				with self.args.strategy.scope():
							try:
										if self.args.trace_memory_line_by_line:
													if not self.args.eager_mode:
																raise ValueError(
																    "`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory"
																    " consumption line by line."				)
													lowerCAmelCase__										=				start_memory_tracing("transformers"				)

										if self.args.is_tpu:
													# tpu
													raise NotImplementedError(
													    "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking"
													    " with `args.memory=False`"				)
										elif self.args.is_gpu:
													# gpu
													if not is_pyanvml_available():
																logger.warning(
																    "py3nvml not installed, we won\'t log GPU memory usage. "
																    "Install py3nvml (pip install py3nvml) to log information about GPU."				)
																lowerCAmelCase__										=				'N/A'
													else:
																logger.info(
																    "Measuring total GPU usage on GPU device. Make sure to not have additional processes"
																    " running on the same GPU."				)
																# init nvml
																nvml.nvmlInit()
																func()
																lowerCAmelCase__										=				nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx				)
																lowerCAmelCase__										=				nvml.nvmlDeviceGetMemoryInfo(__magic_name__				)
																lowerCAmelCase__										=				meminfo.used
																lowerCAmelCase__										=				Memory(__magic_name__				)
																# shutdown nvml
																nvml.nvmlShutdown()
										else:
													# cpu
													if self.args.trace_memory_line_by_line:
																logger.info(
																    "When enabling line by line tracing, the max peak memory for CPU is inaccurate in"
																    " TensorFlow."				)
																lowerCAmelCase__										=				None
													else:
																lowerCAmelCase__										=				measure_peak_memory_cpu(__magic_name__				)
																lowerCAmelCase__										=				Memory(__magic_name__				) if isinstance(__magic_name__   ,				__magic_name__				) else memory_bytes
										if self.args.trace_memory_line_by_line:
													lowerCAmelCase__										=				stop_memory_tracing(__magic_name__				)
													if memory is None:
																lowerCAmelCase__										=				summary.total
										else:
													lowerCAmelCase__										=				None

										return memory, summary
							except ResourceExhaustedError as e:
										self.print_fn(f"""Doesn't fit on GPU. {e}"""				)
										return "N/A", None











'''simple docstring'''



from typing import Any






class 							_a				:





       '''simple docstring'''






       def __init__(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						data
             SCREAMING_SNAKE_CASE   :      Any    					=						None







       def __repr__(      self  ):







             '''simple docstring'''







             return F"Node({self.data})"






class 							_a				:





       '''simple docstring'''






       def __init__(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						None







       def __iter__(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.head
             while node:
                   yield node.data
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						node.next







       def __len__(      self  ):







             '''simple docstring'''







             return sum(1 for _ in self  )







       def __repr__(      self  ):







             '''simple docstring'''







             return "->".join([str(A  ) for item in self]  )







       def __getitem__(      self,							A  ):







             '''simple docstring'''







             if not 0 <= index < len(self  ):
                   raise ValueError('list index out of range.'  )
             for i, node in enumerate(self  ):
                   if i == index:
                         return node
             return None







       def __setitem__(      self,							A,							A  ):







             '''simple docstring'''







             if not 0 <= index < len(self  ):
                   raise ValueError('list index out of range.'  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.head
             for _ in range(A  ):
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						current.next
             SCREAMING_SNAKE_CASE   :      Any    					=						data







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             self.insert_nth(len(self  ),							A  )







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             self.insert_nth(0,							A  )







       def        UpperCamelCase_							(      self,							A,							A  ):







             '''simple docstring'''







             if not 0 <= index <= len(self  ):
                   raise IndexError('list index out of range'  )
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						Node(A  )
             if self.head is None:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						new_node
             elif index == 0:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head  # link new_node to head
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						new_node
             else:
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.head
                   for _ in range(index - 1  ):
                         SCREAMING_SNAKE_CASE   :      str    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						new_node







       def        UpperCamelCase_							(      self  ):  # print every node data







             '''simple docstring'''







             print(self  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return self.delete_nth(0  )







       def        UpperCamelCase_							(      self  ):  # delete from tail







             '''simple docstring'''







             return self.delete_nth(len(self  ) - 1  )







       def        UpperCamelCase_							(      self,							A = 0  ):







             '''simple docstring'''







             if not 0 <= index <= len(self  ) - 1:  # test if index is valid
                   raise IndexError('List index out of range.'  )
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head  # default first node
             if index == 0:
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						self.head.next
             else:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						self.head
                   for _ in range(index - 1  ):
                         SCREAMING_SNAKE_CASE   :      Any    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      List[str]    					=						temp.next
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						temp.next.next
             return delete_node.data







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return self.head is None







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      int    					=						None
             SCREAMING_SNAKE_CASE   :      Any    					=						self.head

             while current:
                   # Store the current node's next node.
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						current.next
                   # Make the current node's next point backwards
                   SCREAMING_SNAKE_CASE   :      int    					=						prev
                   # Make the previous node be the current node
                   SCREAMING_SNAKE_CASE   :      int    					=						current
                   # Make the current node the next node (to progress iteration)
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						next_node
             # Return prev in order to put the head at the end
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						prev




def   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Dict    					=						LinkedList()
      assert linked_list.is_empty() is True
      assert str(__UpperCamelCase    ) == ""

      try:
            linked_list.delete_head()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      try:
            linked_list.delete_tail()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      for i in range(10    ):
            assert len(__UpperCamelCase    ) == i
            linked_list.insert_nth(__UpperCamelCase      ,i + 1    )
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(1      ,11    )    )

      linked_list.insert_head(0    )
      linked_list.insert_tail(11    )
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(0      ,12    )    )

      assert linked_list.delete_head() == 0
      assert linked_list.delete_nth(9    ) == 10
      assert linked_list.delete_tail() == 11
      assert len(__UpperCamelCase    ) == 9
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(1      ,10    )    )

      assert all(linked_list[i] == i + 1 for i in range(0      ,9    )    ) is True

      for i in range(0      ,9    ):
            SCREAMING_SNAKE_CASE   :      Any    					=						-i
      assert all(linked_list[i] == -i for i in range(0      ,9    )    ) is True

      linked_list.reverse()
      assert str(__UpperCamelCase    ) == "->".join(str(__UpperCamelCase    ) for i in range(-8      ,1    )    )




def   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      List[str]    					=						[
          -9,
          1_00,
          Node(77_34_51_12    ),
          'dlrow olleH',
          7,
          55_55,
          0,
          -1_9_2.5_5_5_5_5,
          'Hello, world!',
          7_7.9,
          Node(10    ),
          None,
          None,
          1_2.2_0,
      ]
      SCREAMING_SNAKE_CASE   :      Optional[int]    					=						LinkedList()

      for i in test_input:
            linked_list.insert_tail(__UpperCamelCase    )

      # Check if it's empty or not
      assert linked_list.is_empty() is False
      assert (
          str(__UpperCamelCase    ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
          "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
      )

      # Delete the head
      SCREAMING_SNAKE_CASE   :      str    					=						linked_list.delete_head()
      assert result == -9
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None->None->12.2"
      )

      # Delete the tail
      SCREAMING_SNAKE_CASE   :      Dict    					=						linked_list.delete_tail()
      assert result == 1_2.2
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None->None"
      )

      # Delete a node in specific location in linked list
      SCREAMING_SNAKE_CASE   :      str    					=						linked_list.delete_nth(10    )
      assert result is None
      assert (
          str(__UpperCamelCase    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None"
      )

      # Add a Node instance to its head
      linked_list.insert_head(Node('Hello again, world!'    )    )
      assert (
          str(__UpperCamelCase    )
          == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
          "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
      )

      # Add None to its tail
      linked_list.insert_tail(__UpperCamelCase    )
      assert (
          str(__UpperCamelCase    )
          == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
          "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
      )

      # Reverse the linked list
      linked_list.reverse()
      assert (
          str(__UpperCamelCase    )
          == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
          "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
      )




def   lowercase__(			):

      """simple docstring"""






      from doctest import testmod

      testmod()

      SCREAMING_SNAKE_CASE   :      Dict    					=						LinkedList()
      linked_list.insert_head(input('Inserting 1st at head '    ).strip()    )
      linked_list.insert_head(input('Inserting 2nd at head '    ).strip()    )
      print('\nPrint list:'    )
      linked_list.print_list()
      linked_list.insert_tail(input('\nInserting 1st at tail '    ).strip()    )
      linked_list.insert_tail(input('Inserting 2nd at tail '    ).strip()    )
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nDelete head'    )
      linked_list.delete_head()
      print('Delete tail'    )
      linked_list.delete_tail()
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nReverse linked list'    )
      linked_list.reverse()
      print('\nPrint list:'    )
      linked_list.print_list()
      print('\nString representation of linked list:'    )
      print(__UpperCamelCase    )
      print('\nReading/changing Node data using indexing:'    )
      print(f"Element at Position 1: {linked_list[1]}"    )
      SCREAMING_SNAKE_CASE   :      str    					=						input('Enter New Value: '    ).strip()
      print('New list:'    )
      print(__UpperCamelCase    )
      print(f"length of linked_list is : {len(__UpperCamelCase    )}"    )


if __name__ == "__main__":
      main()


