




'''simple docstring'''







from collections.abc import Callable

_lowerCamelCase							:						Optional[Any]							     =  Callable[[float], float]  # type alias for a real -> real function






def 		_lowercase		(     lowercase_						,							lowercase_						,							lowercase_						,							):



		'''simple docstring'''







		_snake_case     	=	float(lowercase_  )
		while True:
				try:
						_snake_case     	=	prev_guess - function(lowercase_  ) / derivative(lowercase_  )
				except ZeroDivisionError:
						raise ZeroDivisionError("Could not find root"  ) from None
				if abs(prev_guess - next_guess  ) < 10**-5:
						return next_guess
				_snake_case     	=	next_guess






def 		_lowercase		(     lowercase_  ):



		'''simple docstring'''







		return (x**3) - (2 * x) - 5






def 		_lowercase		(     lowercase_  ):



		'''simple docstring'''







		return 3 * (x**2) - 2


if __name__ == "__main__":
						print(newton(f, fa, 3))











'''simple docstring'''







from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_lowerCamelCase							:						Any							     =  logging.get_logger(__name__)

_lowerCamelCase							:						List[str]							     =  {
    'google/bigbird-pegasus-large-arxiv': (
        'https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-pubmed': (
        'https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-bigpatent': (
        'https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}





class 					lowerCamelCase_							(	UpperCAmelCase_							):




					'''simple docstring'''






					lowercase__   =			"""bigbird_pegasus"""
					lowercase__   =			["""past_key_values"""]
					lowercase__   =			{
					    """num_attention_heads""": """encoder_attention_heads""",
					    """hidden_size""": """d_model""",
					    """attention_probs_dropout_prob""": """attention_dropout""",
					}






					def __init__(   self,  __UpperCamelCase=96_103,  __UpperCamelCase=4_096,  __UpperCamelCase=16,  __UpperCamelCase=4_096,  __UpperCamelCase=16,  __UpperCamelCase=16,  __UpperCamelCase=4_096,  __UpperCamelCase=16,  __UpperCamelCase=0.0,  __UpperCamelCase=0.0,  __UpperCamelCase=True,  __UpperCamelCase=True,  __UpperCamelCase="gelu_new",  __UpperCamelCase=1_024,  __UpperCamelCase=0.1,  __UpperCamelCase=0.0,  __UpperCamelCase=0.0,  __UpperCamelCase=0.02,  __UpperCamelCase=2,  __UpperCamelCase=0.0,  __UpperCamelCase=True,  __UpperCamelCase=0,  __UpperCamelCase=2,  __UpperCamelCase=1,  __UpperCamelCase="block_sparse",  __UpperCamelCase=64,  __UpperCamelCase=3,  __UpperCamelCase=False,  **__UpperCamelCase,  ):
							_snake_case     	=	vocab_size
							_snake_case     	=	max_position_embeddings
							_snake_case     	=	d_model
							_snake_case     	=	encoder_ffn_dim
							_snake_case     	=	encoder_layers
							_snake_case     	=	encoder_attention_heads
							_snake_case     	=	decoder_ffn_dim
							_snake_case     	=	decoder_layers
							_snake_case     	=	decoder_attention_heads
							_snake_case     	=	dropout
							_snake_case     	=	attention_dropout
							_snake_case     	=	activation_dropout
							_snake_case     	=	activation_function
							_snake_case     	=	init_std
							_snake_case     	=	encoder_layerdrop
							_snake_case     	=	decoder_layerdrop
							_snake_case     	=	classifier_dropout
							_snake_case     	=	use_cache
							_snake_case     	=	encoder_layers
							_snake_case     	=	scale_embedding  # scale factor will be sqrt(d_model) if True

							# extra config
							_snake_case     	=	attention_type
							_snake_case     	=	block_size
							_snake_case     	=	num_random_blocks
							_snake_case     	=	use_bias

							super().__init__(
							    pad_token_id=__UpperCamelCase,  bos_token_id=__UpperCamelCase,  eos_token_id=__UpperCamelCase,  is_encoder_decoder=__UpperCamelCase,  decoder_start_token_id=__UpperCamelCase,  **__UpperCamelCase,  )





class 					lowerCamelCase_							(	UpperCAmelCase_							):




					'''simple docstring'''






					@property
					def     __SCREAMING_SNAKE_CASE     (   self			):
							if self.task in ["default", "seq2seq-lm"]:
									_snake_case     	=	OrderedDict(
									    [
									        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
									        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
									    ]			)

									if self.use_past:
											_snake_case     	=	{0: "batch"}
											_snake_case     	=	{0: "batch", 1: "past_decoder_sequence + sequence"}
									else:
											_snake_case     	=	{0: "batch", 1: "decoder_sequence"}
											_snake_case     	=	{0: "batch", 1: "decoder_sequence"}

									if self.use_past:
											self.fill_with_past_key_values_(__UpperCamelCase,  direction="inputs"			)
							elif self.task == "causal-lm":
									# TODO: figure this case out.
									_snake_case     	=	OrderedDict(
									    [
									        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
									        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
									    ]			)
									if self.use_past:
											_snake_case	,   _snake_case     	=	self.num_layers
											for i in range(__UpperCamelCase			):
													_snake_case     	=	{0: "batch", 2: "past_sequence + sequence"}
													_snake_case     	=	{0: "batch", 2: "past_sequence + sequence"}
							else:
									_snake_case     	=	OrderedDict(
									    [
									        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
									        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
									        ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
									        ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
									    ]			)

							return common_inputs






					@property
					def     __SCREAMING_SNAKE_CASE     (   self			):
							if self.task in ["default", "seq2seq-lm"]:
									_snake_case     	=	super().outputs
							else:
									_snake_case     	=	super(__UpperCamelCase,  self			).outputs
									if self.use_past:
											_snake_case	,   _snake_case     	=	self.num_layers
											for i in range(__UpperCamelCase			):
													_snake_case     	=	{0: "batch", 2: "past_sequence + sequence"}
													_snake_case     	=	{0: "batch", 2: "past_sequence + sequence"}
							return common_outputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)

							# Generate decoder inputs
							_snake_case     	=	seq_length if not self.use_past else 1
							_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)
							_snake_case     	=	{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
							_snake_case     	=	dict(**__UpperCamelCase,  **__UpperCamelCase			)

							if self.use_past:
									if not is_torch_available():
											raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."			)
									else:
											import torch
									_snake_case	,   _snake_case     	=	common_inputs["input_ids"].shape
									_snake_case     	=	common_inputs["decoder_input_ids"].shape[1]
									_snake_case	,   _snake_case     	=	self.num_attention_heads
									_snake_case     	=	(
									    batch,
									    num_encoder_attention_heads,
									    encoder_seq_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)
									_snake_case     	=	decoder_seq_length + 3
									_snake_case     	=	(
									    batch,
									    num_decoder_attention_heads,
									    decoder_past_length,
									    self._config.hidden_size // num_decoder_attention_heads,
									)

									_snake_case     	=	torch.cat(
									    [common_inputs["decoder_attention_mask"], torch.ones(__UpperCamelCase,  __UpperCamelCase			)],  dim=1			)

									_snake_case     	=	[]
									# If the number of encoder and decoder layers are present in the model configuration, both are considered
									_snake_case	,   _snake_case     	=	self.num_layers
									_snake_case     	=	min(__UpperCamelCase,  __UpperCamelCase			)
									_snake_case     	=	max(__UpperCamelCase,  __UpperCamelCase			) - min_num_layers
									_snake_case     	=	"encoder" if num_encoder_layers > num_decoder_layers else "decoder"

									for _ in range(__UpperCamelCase			):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											    )			)
									# TODO: test this.
									_snake_case     	=	encoder_shape if remaining_side_name == "encoder" else decoder_shape
									for _ in range(__UpperCamelCase,  __UpperCamelCase			):
											common_inputs["past_key_values"].append((torch.zeros(__UpperCamelCase			), torch.zeros(__UpperCamelCase			))			)
							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)

							if self.use_past:
									if not is_torch_available():
											raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."			)
									else:
											import torch
									_snake_case	,   _snake_case     	=	common_inputs["input_ids"].shape
									# Not using the same length for past_key_values
									_snake_case     	=	seqlen + 2
									_snake_case	,   _snake_case     	=	self.num_layers
									_snake_case	,   _snake_case     	=	self.num_attention_heads
									_snake_case     	=	(
									    batch,
									    num_encoder_attention_heads,
									    past_key_values_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)

									_snake_case     	=	common_inputs["attention_mask"].dtype
									_snake_case     	=	torch.cat(
									    [common_inputs["attention_mask"], torch.ones(__UpperCamelCase,  __UpperCamelCase,  dtype=__UpperCamelCase			)],  dim=1			)
									_snake_case     	=	[
									    (torch.zeros(__UpperCamelCase			), torch.zeros(__UpperCamelCase			)) for _ in range(__UpperCamelCase			)
									]
							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							# Copied from OnnxConfig.generate_dummy_inputs
							# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
							# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
							_snake_case     	=	compute_effective_axis_dimension(
							    __UpperCamelCase,  fixed_dimension=OnnxConfig.default_fixed_batch,  num_token_to_add=0			)

							# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
							_snake_case     	=	tokenizer.num_special_tokens_to_add(__UpperCamelCase			)
							_snake_case     	=	compute_effective_axis_dimension(
							    __UpperCamelCase,  fixed_dimension=OnnxConfig.default_fixed_sequence,  num_token_to_add=__UpperCamelCase			)

							# Generate dummy inputs according to compute batch and sequence
							_snake_case     	=	[" ".join([tokenizer.unk_token]			) * seq_length] * batch_size
							_snake_case     	=	dict(tokenizer(__UpperCamelCase,  return_tensors=__UpperCamelCase			)			)
							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							if self.task in ["default", "seq2seq-lm"]:
									_snake_case     	=	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
									    __UpperCamelCase,  batch_size=__UpperCamelCase,  seq_length=__UpperCamelCase,  is_pair=__UpperCamelCase,  framework=__UpperCamelCase			)

							elif self.task == "causal-lm":
									_snake_case     	=	self._generate_dummy_inputs_for_causal_lm(
									    __UpperCamelCase,  batch_size=__UpperCamelCase,  seq_length=__UpperCamelCase,  is_pair=__UpperCamelCase,  framework=__UpperCamelCase			)
							else:
									_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
									    __UpperCamelCase,  batch_size=__UpperCamelCase,  seq_length=__UpperCamelCase,  is_pair=__UpperCamelCase,  framework=__UpperCamelCase			)

							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			):
							if self.task in ["default", "seq2seq-lm"]:
									_snake_case     	=	super()._flatten_past_key_values_(__UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)
							else:
									_snake_case     	=	super(__UpperCamelCase,  self			)._flatten_past_key_values_(
									    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)





