


"""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


A	:  str            =     logging.get_logger(__name__)

A	:  str            =     {
    "Helsinki-NLP/opus-mt-en-de": "https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json",
    # See all Marian models at https://huggingface.co/models?filter=marian
}
class     _UpperCamelCase    (  lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Dict							 ="""marian"""
							__UpperCAmelCase		:       List[str]							 =["""past_key_values"""]
							__UpperCAmelCase		:       Union[str, Any]							 ={"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}

							def __init__(	self       ,  __a=5_81_01       ,  __a=None       ,  __a=10_24       ,  __a=12       ,  __a=40_96       ,  __a=16       ,  __a=12       ,  __a=40_96       ,  __a=16       ,  __a=0.0       ,  __a=0.0       ,  __a=True       ,  __a=True       ,  __a="gelu"       ,  __a=10_24       ,  __a=0.1       ,  __a=0.0       ,  __a=0.0       ,  __a=0.0_2       ,  __a=5_81_00       ,  __a=False       ,  __a=5_81_00       ,  __a=0       ,  __a=0       ,  __a=True       ,  **__a       ,  ):
										__lowerCAmelCase							       =     vocab_size
										__lowerCAmelCase							       =     decoder_vocab_size or vocab_size
										__lowerCAmelCase							       =     max_position_embeddings
										__lowerCAmelCase							       =     d_model
										__lowerCAmelCase							       =     encoder_ffn_dim
										__lowerCAmelCase							       =     encoder_layers
										__lowerCAmelCase							       =     encoder_attention_heads
										__lowerCAmelCase							       =     decoder_ffn_dim
										__lowerCAmelCase							       =     decoder_layers
										__lowerCAmelCase							       =     decoder_attention_heads
										__lowerCAmelCase							       =     dropout
										__lowerCAmelCase							       =     attention_dropout
										__lowerCAmelCase							       =     activation_dropout
										__lowerCAmelCase							       =     activation_function
										__lowerCAmelCase							       =     init_std
										__lowerCAmelCase							       =     encoder_layerdrop
										__lowerCAmelCase							       =     decoder_layerdrop
										__lowerCAmelCase							       =     use_cache
										__lowerCAmelCase							       =     encoder_layers
										__lowerCAmelCase							       =     scale_embedding  # scale factor will be sqrt(d_model) if True
										__lowerCAmelCase							       =     share_encoder_decoder_embeddings
										super().__init__(
										    pad_token_id=__a       ,  eos_token_id=__a       ,  is_encoder_decoder=__a       ,  decoder_start_token_id=__a       ,  forced_eos_token_id=__a       ,  **__a       ,  )
class     _UpperCamelCase    (  lowerCAmelCase__						):
							'''simple docstring'''







							@property
							# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
							def      snake_case							(	self      ):
										if self.task in ["default", "seq2seq-lm"]:
													__lowerCAmelCase							       =     OrderedDict(
													    [
													        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
													        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
													    ]      )

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

													if self.use_past:
																self.fill_with_past_key_values_(__a       ,  direction="inputs"      )
										elif self.task == "causal-lm":
													# TODO: figure this case out.
													__lowerCAmelCase							       =     OrderedDict(
													    [
													        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
													        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
													    ]      )
													if self.use_past:
																__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.num_layers
																for i in range(__a      ):
																			__lowerCAmelCase							       =     {0: "batch", 2: "past_sequence + sequence"}
																			__lowerCAmelCase							       =     {0: "batch", 2: "past_sequence + sequence"}
										else:
													__lowerCAmelCase							       =     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
							# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
							def      snake_case							(	self      ):
										if self.task in ["default", "seq2seq-lm"]:
													__lowerCAmelCase							       =     super().outputs
										else:
													__lowerCAmelCase							       =     super(__a       ,  self      ).outputs
													if self.use_past:
																__lowerCAmelCase       ,      __lowerCAmelCase							       =     self.num_layers
																for i in range(__a      ):
																			__lowerCAmelCase							       =     {0: "batch", 2: "past_sequence + sequence"}
																			__lowerCAmelCase							       =     {0: "batch", 2: "past_sequence + sequence"}
										return common_outputs

							def      snake_case							(	self       ,  __a       ,  __a = -1       ,  __a = -1       ,  __a = False       ,  __a = None       ,  ):
										__lowerCAmelCase							       =     self._generate_dummy_inputs_for_encoder_and_decoder(
										    __a       ,  __a       ,  __a       ,  __a       ,  __a      )

										# Generate decoder inputs
										__lowerCAmelCase							       =     seq_length if not self.use_past else 1
										__lowerCAmelCase							       =     self._generate_dummy_inputs_for_encoder_and_decoder(
										    __a       ,  __a       ,  __a       ,  __a       ,  __a      )
										__lowerCAmelCase							       =     {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
										__lowerCAmelCase							       =     dict(**__a       ,  **__a      )

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

													__lowerCAmelCase							       =     torch.cat(
													    [common_inputs["decoder_attention_mask"], torch.ones(__a       ,  __a      )]       ,  dim=1      )

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

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

							def      snake_case							(	self       ,  __a       ,  __a = -1       ,  __a = -1       ,  __a = False       ,  __a = None       ,  ):
										__lowerCAmelCase							       =     self._generate_dummy_inputs_for_encoder_and_decoder(
										    __a       ,  __a       ,  __a       ,  __a       ,  __a      )

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

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

							def      snake_case							(	self       ,  __a       ,  __a = -1       ,  __a = -1       ,  __a = False       ,  __a = 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
										__lowerCAmelCase							       =     compute_effective_axis_dimension(
										    __a       ,  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
										__lowerCAmelCase							       =     tokenizer.num_special_tokens_to_add(__a      )
										__lowerCAmelCase							       =     compute_effective_axis_dimension(
										    __a       ,  fixed_dimension=OnnxConfig.default_fixed_sequence       ,  num_token_to_add=__a      )

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

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

										else:
													__lowerCAmelCase							       =     self._generate_dummy_inputs_for_causal_lm(
													    __a       ,  batch_size=__a       ,  seq_length=__a       ,  is_pair=__a       ,  framework=__a      )

										return common_inputs

							def      snake_case							(	self       ,  __a       ,  __a       ,  __a       ,  __a      ):
										if self.task in ["default", "seq2seq-lm"]:
													__lowerCAmelCase							       =     super()._flatten_past_key_values_(__a       ,  __a       ,  __a       ,  __a      )
										else:
													__lowerCAmelCase							       =     super(__a       ,  self      )._flatten_past_key_values_(
													    __a       ,  __a       ,  __a       ,  __a      )



							@property
							def      snake_case							(	self      ):
										return 1e-4








"""simple docstring"""


from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			return math.sqrt(sum(pow(a - b       ,					2 ) for a, b in zip(_UpperCamelCase       ,					_UpperCamelCase ) ) )


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			if dataset.ndim != value_array.ndim:
						__lowerCAmelCase							       =     (
						    "Wrong input data's dimensions... "
						    f"dataset : {dataset.ndim}, value_array : {value_array.ndim}"
						)
						raise ValueError(_UpperCamelCase )

			try:
						if dataset.shape[1] != value_array.shape[1]:
									__lowerCAmelCase							       =     (
									    "Wrong input data's shape... "
									    f"dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}"
									)
									raise ValueError(_UpperCamelCase )
			except IndexError:
						if dataset.ndim != value_array.ndim:
									raise TypeError("Wrong shape" )

			if dataset.dtype != value_array.dtype:
						__lowerCAmelCase							       =     (
						    "Input data have different datatype... "
						    f"dataset : {dataset.dtype}, value_array : {value_array.dtype}"
						)
						raise TypeError(_UpperCamelCase )

			__lowerCAmelCase							       =     []

			for value in value_array:
						__lowerCAmelCase							       =     euclidean(_UpperCamelCase       ,					dataset[0] )
						__lowerCAmelCase							       =     dataset[0].tolist()

						for dataset_value in dataset[1:]:
									__lowerCAmelCase							       =     euclidean(_UpperCamelCase       ,					_UpperCamelCase )

									if dist > temp_dist:
												__lowerCAmelCase							       =     temp_dist
												__lowerCAmelCase							       =     dataset_value.tolist()

						answer.append([vector, dist] )

			return answer


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			return np.dot(_UpperCamelCase       ,					_UpperCamelCase ) / (norm(_UpperCamelCase ) * norm(_UpperCamelCase ))


if __name__ == "__main__":
	import doctest

	doctest.testmod()




