"""simple docstring"""


import os
import tempfile
import unittest

from transformers import DistilBertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
     DistilBertForMaskedLM,
     DistilBertForMultipleChoice,
     DistilBertForQuestionAnswering,
     DistilBertForSequenceClassification,
     DistilBertForTokenClassification,
     DistilBertModel,
 )






class    a__    (   _a	):


   def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase=13,				_UpperCAmelCase=7,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=False,				_UpperCAmelCase=True,				_UpperCAmelCase=99,				_UpperCAmelCase=32,				_UpperCAmelCase=5,				_UpperCAmelCase=4,				_UpperCAmelCase=37,				_UpperCAmelCase="gelu",				_UpperCAmelCase=0.1,				_UpperCAmelCase=0.1,				_UpperCAmelCase=512,				_UpperCAmelCase=16,				_UpperCAmelCase=2,				_UpperCAmelCase=0.02,				_UpperCAmelCase=3,				_UpperCAmelCase=4,				_UpperCAmelCase=None,				):
        '''simple docstring'''



        lowercase__				 =							parent
        lowercase__				 =							batch_size
        lowercase__				 =							seq_length
        lowercase__				 =							is_training
        lowercase__				 =							use_input_mask
        lowercase__				 =							use_token_type_ids
        lowercase__				 =							use_labels
        lowercase__				 =							vocab_size
        lowercase__				 =							hidden_size
        lowercase__				 =							num_hidden_layers
        lowercase__				 =							num_attention_heads
        lowercase__				 =							intermediate_size
        lowercase__				 =							hidden_act
        lowercase__				 =							hidden_dropout_prob
        lowercase__				 =							attention_probs_dropout_prob
        lowercase__				 =							max_position_embeddings
        lowercase__				 =							type_vocab_size
        lowercase__				 =							type_sequence_label_size
        lowercase__				 =							initializer_range
        lowercase__				 =							num_labels
        lowercase__				 =							num_choices
        lowercase__				 =							scope


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							ids_tensor([self.batch_size, self.seq_length],				self.vocab_size  )

        lowercase__				 =							None
        if self.use_input_mask:
             lowercase__				 =							random_attention_mask([self.batch_size, self.seq_length]  )

        lowercase__				 =							None
        lowercase__				 =							None
        lowercase__				 =							None
        if self.use_labels:
             lowercase__				 =							ids_tensor([self.batch_size],				self.type_sequence_label_size  )
             lowercase__				 =							ids_tensor([self.batch_size, self.seq_length],				self.num_labels  )
             lowercase__				 =							ids_tensor([self.batch_size],				self.num_choices  )

        lowercase__				 =							self.get_config()

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        return 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,				)


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							DistilBertModel(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							model(_UpperCAmelCase,				_UpperCAmelCase  )
        lowercase__				 =							model(_UpperCAmelCase  )
        self.parent.assertEqual(result.last_hidden_state.shape,				(self.batch_size, self.seq_length, self.hidden_size)  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							DistilBertForMaskedLM(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase,				labels=_UpperCAmelCase  )
        self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size)  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							DistilBertForQuestionAnswering(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							model(
            _UpperCAmelCase,				attention_mask=_UpperCAmelCase,				start_positions=_UpperCAmelCase,				end_positions=_UpperCAmelCase  )
        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 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.num_labels
        lowercase__				 =							DistilBertForSequenceClassification(_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase,				labels=_UpperCAmelCase  )
        self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_labels)  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.num_labels
        lowercase__				 =							DistilBertForTokenClassification(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()

        lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase,				labels=_UpperCAmelCase  )
        self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.num_labels)  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.num_choices
        lowercase__				 =							DistilBertForMultipleChoice(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							input_ids.unsqueeze(1  ).expand(-1,				self.num_choices,				-1  ).contiguous()
        lowercase__				 =							input_mask.unsqueeze(1  ).expand(-1,				self.num_choices,				-1  ).contiguous()
        lowercase__				 =							model(
            _UpperCAmelCase,				attention_mask=_UpperCAmelCase,				labels=_UpperCAmelCase,				)
        self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_choices)  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.prepare_config_and_inputs()
        ((lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__))				 =							config_and_inputs
        lowercase__				 =							{"input_ids": input_ids, "attention_mask": input_mask}
        return config, inputs_dict






@require_torch
class    a__    (   _a					,					_a					,					unittest.TestCase	):
   snake_case_							=      (
       (
           DistilBertModel,
           DistilBertForMaskedLM,
           DistilBertForMultipleChoice,
           DistilBertForQuestionAnswering,
           DistilBertForSequenceClassification,
           DistilBertForTokenClassification,
       )
       if is_torch_available()
       else None
   )
   snake_case_							=      (
       {
           "feature-extraction": DistilBertModel,
           "fill-mask": DistilBertForMaskedLM,
           "question-answering": DistilBertForQuestionAnswering,
           "text-classification": DistilBertForSequenceClassification,
           "token-classification": DistilBertForTokenClassification,
           "zero-shot": DistilBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   snake_case_							=      True
   snake_case_							=      True
   snake_case_							=      True
   snake_case_							=      True


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							DistilBertModelTester(self  )
        lowercase__				 =							ConfigTester(self,				config_class=_UpperCAmelCase,				dim=37  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        self.config_tester.run_common_tests()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_model(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_for_masked_lm(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_for_question_answering(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_for_sequence_classification(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_for_token_classification(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_distilbert_for_multiple_choice(*_UpperCAmelCase  )


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase__				 =							DistilBertModel.from_pretrained(_UpperCAmelCase  )
             self.assertIsNotNone(_UpperCAmelCase  )


   @slow
   @require_torch_gpu
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__ ,						lowercase__				 =							self.model_tester.prepare_config_and_inputs_for_common()
        for model_class in self.all_model_classes:
             # BertForMultipleChoice behaves incorrectly in JIT environments.
             if model_class == DistilBertForMultipleChoice:
                  return

             lowercase__				 =							True
             lowercase__				 =							model_class(config=_UpperCAmelCase  )

             lowercase__				 =							self._prepare_for_class(_UpperCAmelCase,				_UpperCAmelCase  )
             lowercase__				 =							torch.jit.trace(
                 _UpperCAmelCase,				(inputs_dict["input_ids"].to("cpu"  ), inputs_dict["attention_mask"].to("cpu"  ))  )

             with tempfile.TemporaryDirectory() as tmp:
                  torch.jit.save(_UpperCAmelCase,				os.path.join(_UpperCAmelCase,				"traced_model.pt"  )  )
                  lowercase__				 =							torch.jit.load(os.path.join(_UpperCAmelCase,				"traced_model.pt"  ),				map_location=_UpperCAmelCase  )
                  loaded(inputs_dict["input_ids"].to(_UpperCAmelCase  ),				inputs_dict["attention_mask"].to(_UpperCAmelCase  )  )






@require_torch
class    a__    (   unittest.TestCase	):


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							DistilBertModel.from_pretrained("distilbert-base-uncased"  )
        lowercase__				 =							torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
        lowercase__				 =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
        with torch.no_grad():
             lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase  )[0]
        lowercase__				 =							torch.Size((1, 11, 768)  )
        self.assertEqual(output.shape,				_UpperCAmelCase  )
        lowercase__				 =							torch.tensor(
            [[[-0.1_639, 0.3_299, 0.1_648], [-0.1_746, 0.3_289, 0.1_710], [-0.1_884, 0.3_357, 0.1_810]]]  )

        self.assertTrue(torch.allclose(output[:, 1:4, 1:4],				_UpperCAmelCase,				atol=1E-4  )  )





"""simple docstring"""


from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403







def 					__a   (		A    ,				A    ,				A = "x"    ,				A = 10**-10    ,				A = 1    ,				):






     '''simple docstring'''



     lowercase__				 =							symbols(A      )
     lowercase__				 =							lambdify(A    ,				A      )
     lowercase__				 =							lambdify(A    ,				diff(A    ,				A      )      )

     lowercase__				 =							starting_point

     while True:
          if diff_function(A      ) != 0:
               lowercase__				 =							prev_guess - multiplicity * func(A      ) / diff_function(
                   A      )
          else:
               raise ZeroDivisionError("Could not find root"      ) from None

          # Precision is checked by comparing the difference of consecutive guesses
          if abs(next_guess - prev_guess      ) < precision:
               return next_guess

          lowercase__				 =							next_guess


# Let's Execute
if __name__ == "__main__":
 # Find root of trigonometric function
 # Find value of pi
 print(F'The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}')

 # Find root of polynomial
 # Find fourth Root of 5
 print(F'The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5j)}')

 # Find value of e
 print(
     "The root of log(y) - 1 = 0 is ",
     F'{newton_raphson("log(y) - 1", 2, variable="y")}',
 )

 # Exponential Roots
 print(
     "The root of exp(x) - 1 = 0 is",
     F'{newton_raphson("exp(x) - 1", 1_0, precision=0.005)}',
 )

 # Find root of cos(x)
 print(F'The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}')




