"""simple docstring"""




from __future__ import annotations

import unittest

import numpy as np

from transformers import OPTConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel







def 							_UpperCAmelCase		(       lowerCamelCase__			,  lowerCamelCase__			,  lowerCamelCase__=None			,  lowerCamelCase__=None     ):





		"""simple docstring"""




		if attention_mask is None:
				lowerCAmelCase__        =   tf.cast(tf.math.not_equal(lowerCamelCase__			,  config.pad_token_id     )			,  tf.inta     )
		return {"input_ids": input_ids, "attention_mask": attention_mask}

@require_tf
class       a_      :
					UpperCamelCase_ :	Union[str, Any]			=    OPTConfig
					UpperCamelCase_ :	Union[str, Any]			=    {}
					UpperCamelCase_ :	str			=    "gelu"




					def __init__(	self						:     Tuple  ,						snake_case__						:     Tuple  ,						snake_case__						:     Dict=13  ,						snake_case__						:     Tuple=7  ,						snake_case__						:     List[str]=True  ,						snake_case__						:     int=False  ,						snake_case__						:     str=99  ,						snake_case__						:     List[str]=16  ,						snake_case__						:     str=2  ,						snake_case__						:     Optional[Any]=4  ,						snake_case__						:     List[Any]=4  ,						snake_case__						:     int="gelu"  ,						snake_case__						:     Optional[int]=0.1  ,						snake_case__						:     int=0.1  ,						snake_case__						:     List[str]=20  ,						snake_case__						:     List[Any]=2  ,						snake_case__						:     int=1  ,						snake_case__						:     List[str]=0  ,						snake_case__						:     Dict=16  ,						snake_case__						:     str=16  ,						):
							lowerCAmelCase__        =   parent
							lowerCAmelCase__        =   batch_size
							lowerCAmelCase__        =   seq_length
							lowerCAmelCase__        =   is_training
							lowerCAmelCase__        =   use_labels
							lowerCAmelCase__        =   vocab_size
							lowerCAmelCase__        =   hidden_size
							lowerCAmelCase__        =   num_hidden_layers
							lowerCAmelCase__        =   num_attention_heads
							lowerCAmelCase__        =   intermediate_size
							lowerCAmelCase__        =   hidden_act
							lowerCAmelCase__        =   hidden_dropout_prob
							lowerCAmelCase__        =   attention_probs_dropout_prob
							lowerCAmelCase__        =   max_position_embeddings
							lowerCAmelCase__        =   eos_token_id
							lowerCAmelCase__        =   pad_token_id
							lowerCAmelCase__        =   bos_token_id
							lowerCAmelCase__        =   embed_dim
							lowerCAmelCase__        =   word_embed_proj_dim
							lowerCAmelCase__        =   False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   ids_tensor([self.batch_size, self.seq_length - 1]  ,						self.vocab_size     )
							lowerCAmelCase__        =   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size     )  ,						1     )
							lowerCAmelCase__        =   tf.concat([input_ids, eos_tensor]  ,						axis=1     )

							lowerCAmelCase__        =   self.config_cls(
							    vocab_size=self.vocab_size  ,						hidden_size=self.hidden_size  ,						num_hidden_layers=self.num_hidden_layers  ,						num_attention_heads=self.num_attention_heads  ,						ffn_dim=self.intermediate_size  ,						dropout=self.hidden_dropout_prob  ,						attention_dropout=self.attention_probs_dropout_prob  ,						max_position_embeddings=self.max_position_embeddings  ,						eos_token_id=self.eos_token_id  ,						bos_token_id=self.bos_token_id  ,						pad_token_id=self.pad_token_id  ,						embed_dim=self.embed_dim  ,						word_embed_proj_dim=self.word_embed_proj_dim  ,						is_encoder_decoder=snake_case__  ,						**self.config_updates  ,						)
							lowerCAmelCase__        =   prepare_opt_inputs_dict(snake_case__  ,						snake_case__     )
							return config, inputs_dict




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]  ,						snake_case__						:     Optional[int]  ,						snake_case__						:     Any     ):
							lowerCAmelCase__        =   TFOPTModel(config=snake_case__     )
							lowerCAmelCase__        =   inputs_dict["""input_ids"""]

							lowerCAmelCase__        =   input_ids[:1, :]
							lowerCAmelCase__        =   inputs_dict["""attention_mask"""][:1, :]
							lowerCAmelCase__        =   1

							# first forward pass
							lowerCAmelCase__        =   model(snake_case__  ,						attention_mask=snake_case__  ,						use_cache=snake_case__     )

							lowerCAmelCase__   ,					lowerCAmelCase__        =   outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							lowerCAmelCase__        =   ids_tensor((self.batch_size, 3)  ,						config.vocab_size     )
							lowerCAmelCase__        =   tf.cast(ids_tensor((self.batch_size, 3)  ,						2     )  ,						tf.inta     )

							# append to next input_ids and
							lowerCAmelCase__        =   tf.concat([input_ids, next_tokens]  ,						axis=-1     )
							lowerCAmelCase__        =   tf.concat([attention_mask, next_attn_mask]  ,						axis=-1     )

							lowerCAmelCase__        =   model(snake_case__  ,						attention_mask=snake_case__     )[0]
							lowerCAmelCase__        =   model(snake_case__  ,						attention_mask=snake_case__  ,						past_key_values=snake_case__     )[0]

							self.parent.assertEqual(next_tokens.shape[1]  ,						output_from_past.shape[1]     )

							# select random slice
							lowerCAmelCase__        =   int(ids_tensor((1,)  ,						output_from_past.shape[-1]     )     )
							lowerCAmelCase__        =   output_from_no_past[:, -3:, random_slice_idx]
							lowerCAmelCase__        =   output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(snake_case__  ,						snake_case__  ,						rtol=1E-3     )

@require_tf
class       a_      (     __UpperCamelCase ,		__UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	Optional[int]			=    (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
					UpperCamelCase_ :	List[str]			=    (TFOPTForCausalLM,) if is_tf_available() else ()
					UpperCamelCase_ :	List[Any]			=    (
					    {"feature-extraction": TFOPTModel, "text-generation": TFOPTForCausalLM} if is_tf_available() else {}
					)
					UpperCamelCase_ :	Dict			=    False
					UpperCamelCase_ :	Optional[Any]			=    False
					UpperCamelCase_ :	List[Any]			=    False
					UpperCamelCase_ :	Dict			=    10




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   TFOPTModelTester(self     )
							lowerCAmelCase__        =   ConfigTester(self  ,						config_class=snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							self.config_tester.run_common_tests()




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()

							def _get_word_embedding_weight(snake_case__						:     Tuple  ,						snake_case__						:     Tuple     ):
									if hasattr(snake_case__  ,						"""weight"""     ):
											return embedding_layer.weight
									else:
											# Here we build the word embeddings weights if not exists.
											# And then we retry to get the attribute once built.
											model.build()
											if hasattr(snake_case__  ,						"""weight"""     ):
													return embedding_layer.weight
											else:
													return None

							for model_class in self.all_model_classes:
									for size in [config.vocab_size - 10, config.vocab_size + 10]:
											# build the embeddings
											lowerCAmelCase__        =   model_class(config=snake_case__     )
											lowerCAmelCase__        =   _get_word_embedding_weight(snake_case__  ,						model.get_input_embeddings()     )
											lowerCAmelCase__        =   _get_word_embedding_weight(snake_case__  ,						model.get_output_embeddings()     )

											# reshape the embeddings
											model.resize_token_embeddings(snake_case__     )
											lowerCAmelCase__        =   _get_word_embedding_weight(snake_case__  ,						model.get_input_embeddings()     )
											lowerCAmelCase__        =   _get_word_embedding_weight(snake_case__  ,						model.get_output_embeddings()     )

											# check that the resized embeddings size matches the desired size.
											lowerCAmelCase__        =   size if size is not None else config.vocab_size

											self.assertEqual(new_input_embeddings.shape[0]  ,						snake_case__     )

											# check that weights remain the same after resizing
											lowerCAmelCase__        =   True
											for pa, pa in zip(old_input_embeddings.value()  ,						new_input_embeddings.value()     ):
													if tf.math.reduce_sum(tf.math.abs(pa - pa     )     ) > 0:
															lowerCAmelCase__        =   False
											self.assertTrue(snake_case__     )

											if old_output_embeddings is not None and new_output_embeddings is not None:
													self.assertEqual(new_output_embeddings.shape[0]  ,						snake_case__     )

													lowerCAmelCase__        =   True
													for pa, pa in zip(old_output_embeddings.value()  ,						new_output_embeddings.value()     ):
															if tf.math.reduce_sum(tf.math.abs(pa - pa     )     ) > 0:
																	lowerCAmelCase__        =   False
													self.assertTrue(snake_case__     )







def 							_UpperCAmelCase		(       lowerCamelCase__     ):





		"""simple docstring"""




		return tf.constant(lowerCamelCase__			,  dtype=tf.intaa     )

@require_tf
class       a_      (     unittest.TestCase			):
					UpperCamelCase_ :	Union[str, Any]			=    99




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   tf.ones((4, 1)  ,						dtype=tf.intaa     ) * 2
							lowerCAmelCase__        =   tf.concat([ids_tensor((4, 6)  ,						self.vocab_size - 3     ) + 3, eos_column_vector]  ,						axis=1     )
							lowerCAmelCase__        =   input_ids.shape[0]
							lowerCAmelCase__        =   OPTConfig(
							    vocab_size=self.vocab_size  ,						hidden_size=24  ,						num_hidden_layers=2  ,						num_attention_heads=2  ,						ffn_dim=32  ,						max_position_embeddings=48  ,						eos_token_id=2  ,						pad_token_id=1  ,						bos_token_id=0  ,						)
							return config, input_ids, batch_size

@require_sentencepiece
@require_tf
class       a_      (     unittest.TestCase			):




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							lowerCAmelCase__        =   TFOPTModel.from_pretrained("""facebook/opt-350m"""     )
							lowerCAmelCase__        =   _long_tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]     )
							lowerCAmelCase__        =   tf.not_equal(snake_case__  ,						model.config.pad_token_id     )
							with tf.GradientTape():
									lowerCAmelCase__        =   model(input_ids=snake_case__  ,						attention_mask=snake_case__     ).last_hidden_state
							lowerCAmelCase__        =   (1, 11, 512)
							self.assertEqual(output.shape  ,						snake_case__     )
							lowerCAmelCase__        =   tf.constant(
							    [[-0.2873, -1.9218, -0.3033], [-1.2710, -0.1338, -0.1902], [0.4095, 0.1214, -1.3121]]     )
							self.assertTrue(np.allclose(output[:, :3, :3]  ,						snake_case__  ,						atol=4E-3     )     )

							lowerCAmelCase__        =   tf.function(snake_case__  ,						jit_compile=snake_case__     )
							lowerCAmelCase__        =   xla_generate(snake_case__  ,						snake_case__     )[0]
							self.assertTrue(np.allclose(output[:, :3, :3]  ,						snake_case__  ,						atol=4E-2     )     )

@require_tf
@slow
class       a_      (     unittest.TestCase			):




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							super().setUp()
							lowerCAmelCase__        =   """facebook/opt-350m"""




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   TFOPTForCausalLM.from_pretrained(self.path_model     )
							lowerCAmelCase__        =   GPTaTokenizer.from_pretrained(self.path_model     )

							lowerCAmelCase__        =   [
							    """Today is a beautiful day and I want to""",
							    """In the city of""",
							    """Paris is the capital of France and""",
							    """Computers and mobile phones have taken""",
							]
							# verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
							lowerCAmelCase__        =   tokenizer(snake_case__  ,						return_tensors="""tf"""  ,						padding=snake_case__  ,						add_special_tokens=snake_case__     )
							lowerCAmelCase__        =   tf.math.reduce_mean(model(inputs.input_ids  ,						attention_mask=inputs.attention_mask     )[0]  ,						axis=-1     )
							lowerCAmelCase__        =   tf.constant(
							    [
							        [1.3851, -13.8923, -10.5229, -10.7533, -0.2309, -10.2384, -0.5365, -9.0947, -5.1670],
							        [-4.7073, -10.6276, -3.9415, -21.5242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
							        [0.6247, -3.4229, -8.9179, -1.4297, -14.1650, 1.4146, -9.0218, -0.2703, -0.2703],
							        [6.4783, -1.9913, -10.7926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
							    ]     )
							self.assertTrue(np.allclose(snake_case__  ,						snake_case__  ,						atol=1E-4     )     )

							lowerCAmelCase__        =   tf.function(snake_case__  ,						jit_compile=snake_case__     )
							lowerCAmelCase__        =   tf.math.reduce_mean(xla_generate(inputs.input_ids  ,						attention_mask=inputs.attention_mask     )[0]  ,						axis=-1     )
							self.assertTrue(np.allclose(snake_case__  ,						snake_case__  ,						atol=1E-4     )     )

@require_tf
@slow
class       a_      (     unittest.TestCase			):




					@property
					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							return [
							    "Today is a beautiful day and I want",
							    "In the city of",
							    "Paris is the capital of France and",
							    "Computers and mobile phones have taken",
							]




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							lowerCAmelCase__        =   """facebook/opt-125m"""

							lowerCAmelCase__        =   [
							    """Today is a beautiful day and I want to""",
							    """In the city of New York, the city""",
							    """Paris is the capital of France and the capital""",
							    """Computers and mobile phones have taken over the""",
							]

							lowerCAmelCase__        =   []
							lowerCAmelCase__        =   GPTaTokenizer.from_pretrained(snake_case__     )
							lowerCAmelCase__        =   TFOPTForCausalLM.from_pretrained(snake_case__     )

							for prompt in self.prompts:
									lowerCAmelCase__        =   tokenizer(snake_case__  ,						return_tensors="""tf"""     ).input_ids

									lowerCAmelCase__        =   model.generate(snake_case__  ,						max_length=10     )

									lowerCAmelCase__        =   tokenizer.batch_decode(snake_case__  ,						skip_special_tokens=snake_case__     )
									predicted_outputs += generated_string

							self.assertListEqual(snake_case__  ,						snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   """facebook/opt-350m"""

							lowerCAmelCase__        =   GPTaTokenizer.from_pretrained(snake_case__     )
							lowerCAmelCase__        =   TFOPTForCausalLM.from_pretrained(snake_case__     )

							lowerCAmelCase__        =   """left"""

							# use different length sentences to test batching
							lowerCAmelCase__        =   [
							    """Hello, my dog is a little""",
							    """Today, I""",
							]

							lowerCAmelCase__        =   tokenizer(snake_case__  ,						return_tensors="""tf"""  ,						padding=snake_case__     )
							lowerCAmelCase__        =   inputs["""input_ids"""]

							lowerCAmelCase__        =   model.generate(input_ids=snake_case__  ,						attention_mask=inputs["""attention_mask"""]     )

							lowerCAmelCase__        =   tokenizer(sentences[0]  ,						return_tensors="""tf"""     ).input_ids
							lowerCAmelCase__        =   model.generate(input_ids=snake_case__     )

							lowerCAmelCase__        =   inputs_non_padded.shape[-1] - tf.math.reduce_sum(
							    tf.cast(inputs["""attention_mask"""][-1]  ,						tf.intaa     )     )
							lowerCAmelCase__        =   tokenizer(sentences[1]  ,						return_tensors="""tf"""     ).input_ids
							lowerCAmelCase__        =   model.generate(input_ids=snake_case__  ,						max_length=model.config.max_length - num_paddings     )

							lowerCAmelCase__        =   tokenizer.batch_decode(snake_case__  ,						skip_special_tokens=snake_case__     )
							lowerCAmelCase__        =   tokenizer.decode(output_non_padded[0]  ,						skip_special_tokens=snake_case__     )
							lowerCAmelCase__        =   tokenizer.decode(output_padded[0]  ,						skip_special_tokens=snake_case__     )

							lowerCAmelCase__        =   [
							    """Hello, my dog is a little bit of a dork.\nI'm a little bit""",
							    """Today, I was in the middle of a conversation with a friend about the""",
							]
							self.assertListEqual(snake_case__  ,						snake_case__     )
							self.assertListEqual(snake_case__  ,						[non_padded_sentence, padded_sentence]     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   """facebook/opt-350m"""

							lowerCAmelCase__        =   [
							    """Today is a beautiful day and I want to""",
							    """In the city of San Francisco, the city""",
							    """Paris is the capital of France and the capital""",
							    """Computers and mobile phones have taken over the""",
							]

							lowerCAmelCase__        =   []
							lowerCAmelCase__        =   GPTaTokenizer.from_pretrained(snake_case__     )
							lowerCAmelCase__        =   TFOPTForCausalLM.from_pretrained(snake_case__     )

							for prompt in self.prompts:
									lowerCAmelCase__        =   tokenizer(snake_case__  ,						return_tensors="""tf"""     ).input_ids

									lowerCAmelCase__        =   model.generate(snake_case__  ,						max_length=10     )

									lowerCAmelCase__        =   tokenizer.batch_decode(snake_case__  ,						skip_special_tokens=snake_case__     )
									predicted_outputs += generated_string

							self.assertListEqual(snake_case__  ,						snake_case__     )





"""simple docstring"""




import os







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		lowerCAmelCase__        =   os.path.dirname(os.path.realpath(lowerCamelCase__     )     )
		lowerCAmelCase__        =   os.path.join(lowerCamelCase__			,  """triangle.txt"""     )

		with open(lowerCamelCase__     ) as f:
				lowerCAmelCase__        =   f.readlines()

		lowerCAmelCase__        =   []
		for line in triangle:
				lowerCAmelCase__        =   []
				for number in line.strip().split(""" """     ):
						numbers_from_line.append(int(lowerCamelCase__     )     )
				a.append(lowerCamelCase__     )

		for i in range(1			,  len(lowerCamelCase__     )     ):
				for j in range(len(a[i]     )     ):
						lowerCAmelCase__        =   a[i - 1][j] if j != len(a[i - 1]     ) else 0
						lowerCAmelCase__        =   a[i - 1][j - 1] if j > 0 else 0
						a[i][j] += max(lowerCamelCase__			,  lowerCamelCase__     )
		return max(a[-1]     )


if __name__ == "__main__":
			print(solution())




