
'''simple docstring'''

import numpy

# List of input, output pairs
snake_case									=    (
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
snake_case									=    (((5_15, 22, 13), 5_55), ((61, 35, 49), 1_50))
snake_case									=    [2, 4, 1, 5]
snake_case									=    len(train_data)
snake_case									=    0.009


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_="train"			):







 """simple docstring"""


 return calculate_hypothesis_value(A__      ,			A__			) - output(
     A__      ,			A__			)


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	0
 for i in range(len(A__			) - 1			):
  hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
 hyp_val += parameter_vector[0]
 return hyp_val


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 if data_set == "train":
  return train_data[example_no][1]
 elif data_set == "test":
  return test_data[example_no][1]
 return None


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 if data_set == "train":
  return _hypothesis_value(train_data[example_no][0]			)
 elif data_set == "test":
  return _hypothesis_value(test_data[example_no][0]			)
 return None


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_=m			):







 """simple docstring"""


 lowerCAmelCase__     :   Optional[int]     		=	0
 for i in range(A__			):
  if index == -1:
   summation_value += _error(A__			)
  else:
   summation_value += _error(A__			) * train_data[i][0][index]
 return summation_value


def        UpperCAmelCase_ (  lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Dict     		=	summation_of_cost_derivative(A__      ,			A__			) / m
 return cost_derivative_value


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 global parameter_vector
 # Tune these values to set a tolerance value for predicted output
 lowerCAmelCase__     :   Dict     		=	0.00_0002
 lowerCAmelCase__     :   Optional[int]     		=	0
 lowerCAmelCase__     :   Tuple     		=	0
 while True:
  j += 1
  lowerCAmelCase__     :   Tuple     		=	[0, 0, 0, 0]
  for i in range(0      ,			len(A__			)			):
   lowerCAmelCase__     :   Dict     		=	get_cost_derivative(i - 1			)
   lowerCAmelCase__     :   Optional[Any]     		=	(
       parameter_vector[i] - LEARNING_RATE * cost_derivative
   )
  if numpy.allclose(
      A__      ,			A__      ,			atol=A__      ,			rtol=A__      ,			):
   break
  lowerCAmelCase__     :   str     		=	temp_parameter_vector
 print(("Number of iterations:", j)			)


def        UpperCAmelCase_ (  ):







 """simple docstring"""


 for i in range(len(A__			)			):
  print(("Actual output value:", output(A__      ,			"test"			))			)
  print(("Hypothesis output:", calculate_hypothesis_value(A__      ,			"test"			))			)


if __name__ == "__main__":
     run_gradient_descent()
     print("""\nTesting gradient descent for a linear hypothesis function.\n""")
     test_gradient_descent()













"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import DistilBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
			import tensorflow as tf

			from transformers.models.distilbert.modeling_tf_distilbert import (
			    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFDistilBertForMaskedLM,
			    TFDistilBertForMultipleChoice,
			    TFDistilBertForQuestionAnswering,
			    TFDistilBertForSequenceClassification,
			    TFDistilBertForTokenClassification,
			    TFDistilBertModel,
			)







class      UpperCamelCase_			:





	def __init__( self   :					Optional[Any]      ,      lowerCAmelCase_   :					int      ,      )		->     Tuple:
				UpperCAmelCase_	:					Optional[int]     	=   parent
				UpperCAmelCase_	:					Tuple     	=   13
				UpperCAmelCase_	:					int     	=   7
				UpperCAmelCase_	:					Optional[Any]     	=   True
				UpperCAmelCase_	:					int     	=   True
				UpperCAmelCase_	:					Tuple     	=   False
				UpperCAmelCase_	:					Any     	=   True
				UpperCAmelCase_	:					List[Any]     	=   99
				UpperCAmelCase_	:					Any     	=   32
				UpperCAmelCase_	:					str     	=   2
				UpperCAmelCase_	:					Tuple     	=   4
				UpperCAmelCase_	:					Dict     	=   37
				UpperCAmelCase_	:					Optional[int]     	=   "gelu"
				UpperCAmelCase_	:					List[str]     	=   0.1
				UpperCAmelCase_	:					Tuple     	=   0.1
				UpperCAmelCase_	:					Any     	=   512
				UpperCAmelCase_	:					List[str]     	=   16
				UpperCAmelCase_	:					Optional[Any]     	=   2
				UpperCAmelCase_	:					Union[str, Any]     	=   0.0_2
				UpperCAmelCase_	:					str     	=   3
				UpperCAmelCase_	:					Optional[int]     	=   4
				UpperCAmelCase_	:					Dict     	=   None





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     List[str]:
				UpperCAmelCase_	:					Tuple     	=   ids_tensor([self.batch_size, self.seq_length]      ,      self.vocab_size		)

				UpperCAmelCase_	:					Optional[Any]     	=   None
				if self.use_input_mask:
							UpperCAmelCase_	:					Optional[int]     	=   random_attention_mask([self.batch_size, self.seq_length]		)

				UpperCAmelCase_	:					Tuple     	=   None
				UpperCAmelCase_	:					List[str]     	=   None
				UpperCAmelCase_	:					Dict     	=   None
				if self.use_labels:
							UpperCAmelCase_	:					Optional[Any]     	=   ids_tensor([self.batch_size]      ,      self.type_sequence_label_size		)
							UpperCAmelCase_	:					Any     	=   ids_tensor([self.batch_size, self.seq_length]      ,      self.num_labels		)
							UpperCAmelCase_	:					Tuple     	=   ids_tensor([self.batch_size]      ,      self.num_choices		)

				UpperCAmelCase_	:					Dict     	=   DistilBertConfig(
				    vocab_size=self.vocab_size      ,      dim=self.hidden_size      ,      n_layers=self.num_hidden_layers      ,      n_heads=self.num_attention_heads      ,      hidden_dim=self.intermediate_size      ,      hidden_act=self.hidden_act      ,      dropout=self.hidden_dropout_prob      ,      attention_dropout=self.attention_probs_dropout_prob      ,      max_position_embeddings=self.max_position_embeddings      ,      initializer_range=self.initializer_range      ,      )

				return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					Any		)		->     str:
				UpperCAmelCase_	:					Optional[Any]     	=   TFDistilBertModel(config=lowerCAmelCase_		)
				UpperCAmelCase_	:					Any     	=   {"input_ids": input_ids, "attention_mask": input_mask}

				UpperCAmelCase_	:					str     	=   model(lowerCAmelCase_		)

				UpperCAmelCase_	:					List[Any]     	=   [input_ids, input_mask]

				UpperCAmelCase_	:					Optional[int]     	=   model(lowerCAmelCase_		)

				self.parent.assertEqual(result.last_hidden_state.shape      ,      (self.batch_size, self.seq_length, self.hidden_size)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple      ,      lowerCAmelCase_   :					Optional[Any]      ,      lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					Dict      ,      lowerCAmelCase_   :					Optional[Any]      ,      lowerCAmelCase_   :					str      ,      lowerCAmelCase_   :					Union[str, Any]		)		->     List[str]:
				UpperCAmelCase_	:					Dict     	=   TFDistilBertForMaskedLM(config=lowerCAmelCase_		)
				UpperCAmelCase_	:					int     	=   {"input_ids": input_ids, "attention_mask": input_mask}
				UpperCAmelCase_	:					List[str]     	=   model(lowerCAmelCase_		)
				self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.seq_length, self.vocab_size)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]      ,      lowerCAmelCase_   :					int      ,      lowerCAmelCase_   :					List[str]      ,      lowerCAmelCase_   :					Dict      ,      lowerCAmelCase_   :					int      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					Dict		)		->     Dict:
				UpperCAmelCase_	:					Optional[Any]     	=   TFDistilBertForQuestionAnswering(config=lowerCAmelCase_		)
				UpperCAmelCase_	:					List[Any]     	=   {
				    "input_ids": input_ids,
				    "attention_mask": input_mask,
				}
				UpperCAmelCase_	:					Any     	=   model(lowerCAmelCase_		)
				self.parent.assertEqual(result.start_logits.shape      ,      (self.batch_size, self.seq_length)		)
				self.parent.assertEqual(result.end_logits.shape      ,      (self.batch_size, self.seq_length)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					int      ,      lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					str      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					Dict      ,      lowerCAmelCase_   :					Optional[Any]		)		->     Optional[int]:
				UpperCAmelCase_	:					List[Any]     	=   self.num_labels
				UpperCAmelCase_	:					Tuple     	=   TFDistilBertForSequenceClassification(lowerCAmelCase_		)
				UpperCAmelCase_	:					int     	=   {"input_ids": input_ids, "attention_mask": input_mask}
				UpperCAmelCase_	:					Optional[Any]     	=   model(lowerCAmelCase_		)
				self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.num_labels)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]      ,      lowerCAmelCase_   :					str      ,      lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					Optional[Any]      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					Union[str, Any]		)		->     Optional[Any]:
				UpperCAmelCase_	:					Union[str, Any]     	=   self.num_choices
				UpperCAmelCase_	:					List[Any]     	=   TFDistilBertForMultipleChoice(lowerCAmelCase_		)
				UpperCAmelCase_	:					List[Any]     	=   tf.tile(tf.expand_dims(lowerCAmelCase_      ,      1		)      ,      (1, self.num_choices, 1)		)
				UpperCAmelCase_	:					List[Any]     	=   tf.tile(tf.expand_dims(lowerCAmelCase_      ,      1		)      ,      (1, self.num_choices, 1)		)
				UpperCAmelCase_	:					Any     	=   {
				    "input_ids": multiple_choice_inputs_ids,
				    "attention_mask": multiple_choice_input_mask,
				}
				UpperCAmelCase_	:					List[Any]     	=   model(lowerCAmelCase_		)
				self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.num_choices)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple      ,      lowerCAmelCase_   :					Union[str, Any]      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					Any      ,      lowerCAmelCase_   :					Union[str, Any]      ,      lowerCAmelCase_   :					Union[str, Any]		)		->     Tuple:
				UpperCAmelCase_	:					Union[str, Any]     	=   self.num_labels
				UpperCAmelCase_	:					List[str]     	=   TFDistilBertForTokenClassification(lowerCAmelCase_		)
				UpperCAmelCase_	:					int     	=   {"input_ids": input_ids, "attention_mask": input_mask}
				UpperCAmelCase_	:					Optional[Any]     	=   model(lowerCAmelCase_		)
				self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.seq_length, self.num_labels)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Dict:
				UpperCAmelCase_	:					Optional[int]     	=   self.prepare_config_and_inputs()
				((UpperCAmelCase_)	,      (UpperCAmelCase_)	,      (UpperCAmelCase_)	,      (UpperCAmelCase_)	,      (UpperCAmelCase_)	,      (UpperCAmelCase_))	:					str     	=   config_and_inputs
				UpperCAmelCase_	:					List[str]     	=   {"input_ids": input_ids, "attention_mask": input_mask}
				return config, inputs_dict







@require_tf
class      UpperCamelCase_			(__A							,		__A							,		unittest.TestCase	):
	__magic_name__       =							(
	    (
	        TFDistilBertModel,
	        TFDistilBertForMaskedLM,
	        TFDistilBertForQuestionAnswering,
	        TFDistilBertForSequenceClassification,
	        TFDistilBertForTokenClassification,
	        TFDistilBertForMultipleChoice,
	    )
	    if is_tf_available()
	    else None
	)
	__magic_name__       =							(
	    {
	        '''feature-extraction''': TFDistilBertModel,
	        '''fill-mask''': TFDistilBertForMaskedLM,
	        '''question-answering''': TFDistilBertForQuestionAnswering,
	        '''text-classification''': TFDistilBertForSequenceClassification,
	        '''token-classification''': TFDistilBertForTokenClassification,
	        '''zero-shot''': TFDistilBertForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	__magic_name__       =							False
	__magic_name__       =							False





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Tuple:
				UpperCAmelCase_	:					Any     	=   TFDistilBertModelTester(self		)
				UpperCAmelCase_	:					List[str]     	=   ConfigTester(self      ,      config_class=lowerCAmelCase_      ,      dim=37		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     Optional[int]:
				self.config_tester.run_common_tests()





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     int:
				UpperCAmelCase_	:					str     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     Union[str, Any]:
				UpperCAmelCase_	:					List[Any]     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     Optional[Any]:
				UpperCAmelCase_	:					str     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Union[str, Any]:
				UpperCAmelCase_	:					Optional[Any]     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     int:
				UpperCAmelCase_	:					Optional[Any]     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Tuple:
				UpperCAmelCase_	:					str     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase_		)





	@slow
	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]		)		->     Dict:
				for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]		):
							UpperCAmelCase_	:					Tuple     	=   TFDistilBertModel.from_pretrained(lowerCAmelCase_		)
							self.assertIsNotNone(lowerCAmelCase_		)







@require_tf
class      UpperCamelCase_			(unittest.TestCase	):





	@slow
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     Optional[int]:
				UpperCAmelCase_	:					Optional[int]     	=   TFDistilBertModel.from_pretrained("distilbert-base-uncased"		)
				UpperCAmelCase_	:					Tuple     	=   tf.constant([[0, 1, 2, 3, 4, 5]]		)
				UpperCAmelCase_	:					Dict     	=   model(lowerCAmelCase_		)[0]

				UpperCAmelCase_	:					Union[str, Any]     	=   [1, 6, 768]
				self.assertEqual(output.shape      ,      lowerCAmelCase_		)

				UpperCAmelCase_	:					Dict     	=   tf.constant(
				    [
				        [
				            [0.1_9_2_6_1_8_8_5, -0.1_3_7_3_2_9_5_5, 0.4_1_1_9_7_9_9],
				            [0.2_2_1_5_0_1_5_6, -0.0_7_4_2_2_6_6_1, 0.3_9_0_3_7_2_0_4],
				            [0.2_2_7_5_6_0_1_8, -0.0_8_9_6_4_1_4, 0.3_7_0_1_4_6_7],
				        ]
				    ]		)
				tf.debugging.assert_near(output[:, :3, :3]      ,      lowerCAmelCase_      ,      atol=1e-4		)



