"""simple docstring"""






from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve



def   a_						( lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase	):
				UpperCAmelCase__					=							np.stack((horizontal_flow, vertical_flow) ,      2	)

				# Create a grid of all pixel coordinates and subtract the flow to get the
				# target pixels coordinates
				UpperCAmelCase__					=							np.stack(
				    np.meshgrid(np.arange(0 ,      image.shape[1]	) ,      np.arange(0 ,      image.shape[0]	)	) ,      2	)
				UpperCAmelCase__					=							np.round(grid - flow	).astype(np.intaa	)

				# Find the locations outside of the original image
				UpperCAmelCase__					=							(grid < 0) | (grid >= np.array([image.shape[1], image.shape[0]]	))
				UpperCAmelCase__					=							0

				UpperCAmelCase__					=							image[grid[:, :, 1], grid[:, :, 0]]

				# Set pixels at invalid locations to 0
				UpperCAmelCase__					=							0

				return warped



def   a_						( lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase = None ,      ):
				if alpha is None:
								UpperCAmelCase__					=							0.1

				# Initialize flow
				UpperCAmelCase__					=							np.zeros_like(lowerCamelCase	)
				UpperCAmelCase__					=							np.zeros_like(lowerCamelCase	)

				# Prepare kernels for the calculation of the derivatives and the average velocity
				UpperCAmelCase__					=							np.array([[-1, 1], [-1, 1]]	) * 0.25
				UpperCAmelCase__					=							np.array([[-1, -1], [1, 1]]	) * 0.25
				UpperCAmelCase__					=							np.array([[1, 1], [1, 1]]	) * 0.25
				UpperCAmelCase__					=							np.array(
				    [[1 / 1_2, 1 / 6, 1 / 1_2], [1 / 6, 0, 1 / 6], [1 / 1_2, 1 / 6, 1 / 1_2]]	)

				# Iteratively refine the flow
				for _ in range(lowerCamelCase	):
								UpperCAmelCase__					=							warp(lowerCamelCase ,      lowerCamelCase ,      lowerCamelCase	)
								UpperCAmelCase__					=							convolve(lowerCamelCase ,      lowerCamelCase	) + convolve(lowerCamelCase ,      lowerCamelCase	)
								UpperCAmelCase__					=							convolve(lowerCamelCase ,      lowerCamelCase	) + convolve(lowerCamelCase ,      lowerCamelCase	)
								UpperCAmelCase__					=							convolve(lowerCamelCase ,      lowerCamelCase	) + convolve(lowerCamelCase ,      -kernel_t	)

								UpperCAmelCase__					=							convolve(lowerCamelCase ,      lowerCamelCase	)
								UpperCAmelCase__					=							convolve(lowerCamelCase ,      lowerCamelCase	)

								# This updates the flow as proposed in the paper (Step 12)
								UpperCAmelCase__					=							(
								    derivative_x * avg_horizontal_velocity
								    + derivative_y * avg_vertical_velocity
								    + derivative_t
								)
								UpperCAmelCase__					=							update / (alpha**2 + derivative_x**2 + derivative_y**2)

								UpperCAmelCase__					=							avg_horizontal_velocity - derivative_x * update
								UpperCAmelCase__					=							avg_vertical_velocity - derivative_y * update

				return horizontal_flow, vertical_flow


if __name__ == "__main__":
						import doctest

						doctest.testmod()


"""simple docstring"""






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

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowerCAmelCase__  :  Any											=     logging.get_logger(__name__)

lowerCAmelCase__  :  Union[str, Any]											=     {
    'gpt2': 'https://huggingface.co/gpt2/resolve/main/config.json',
    'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/config.json',
    'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/config.json',
    'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/config.json',
    'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/config.json',
}
class     snake_case	(			__UpperCAmelCase    ):




					"""simple docstring"""

					snake_case__       =			"gpt2"
					snake_case__       =			["past_key_values"]
					snake_case__       =			{
					    "hidden_size": "n_embd",
					    "max_position_embeddings": "n_positions",
					    "num_attention_heads": "n_head",
					    "num_hidden_layers": "n_layer",
					}







					def __init__(    self       :     Any   ,lowerCamelCase__       :     List[Any]=50_257   ,lowerCamelCase__       :     Union[str, Any]=1_024   ,lowerCamelCase__       :     Dict=768   ,lowerCamelCase__       :     List[str]=12   ,lowerCamelCase__       :     Dict=12   ,lowerCamelCase__       :     List[str]=None   ,lowerCamelCase__       :     List[str]="gelu_new"   ,lowerCamelCase__       :     int=0.1   ,lowerCamelCase__       :     Dict=0.1   ,lowerCamelCase__       :     str=0.1   ,lowerCamelCase__       :     Union[str, Any]=1e-5   ,lowerCamelCase__       :     Optional[Any]=0.0_2   ,lowerCamelCase__       :     str="cls_index"   ,lowerCamelCase__       :     Union[str, Any]=True   ,lowerCamelCase__       :     List[Any]=None   ,lowerCamelCase__       :     List[str]=True   ,lowerCamelCase__       :     int=0.1   ,lowerCamelCase__       :     Tuple=True   ,lowerCamelCase__       :     str=True   ,lowerCamelCase__       :     Optional[int]=50_256   ,lowerCamelCase__       :     Union[str, Any]=50_256   ,lowerCamelCase__       :     Union[str, Any]=False   ,lowerCamelCase__       :     List[Any]=False   ,**lowerCamelCase__       :     Tuple   ,):
									UpperCAmelCase__					=							vocab_size
									UpperCAmelCase__					=							n_positions
									UpperCAmelCase__					=							n_embd
									UpperCAmelCase__					=							n_layer
									UpperCAmelCase__					=							n_head
									UpperCAmelCase__					=							n_inner
									UpperCAmelCase__					=							activation_function
									UpperCAmelCase__					=							resid_pdrop
									UpperCAmelCase__					=							embd_pdrop
									UpperCAmelCase__					=							attn_pdrop
									UpperCAmelCase__					=							layer_norm_epsilon
									UpperCAmelCase__					=							initializer_range
									UpperCAmelCase__					=							summary_type
									UpperCAmelCase__					=							summary_use_proj
									UpperCAmelCase__					=							summary_activation
									UpperCAmelCase__					=							summary_first_dropout
									UpperCAmelCase__					=							summary_proj_to_labels
									UpperCAmelCase__					=							scale_attn_weights
									UpperCAmelCase__					=							use_cache
									UpperCAmelCase__					=							scale_attn_by_inverse_layer_idx
									UpperCAmelCase__					=							reorder_and_upcast_attn

									UpperCAmelCase__					=							bos_token_id
									UpperCAmelCase__					=							eos_token_id

									super().__init__(bos_token_id=lowerCamelCase__   ,eos_token_id=lowerCamelCase__   ,**lowerCamelCase__      )






class     snake_case	(			__UpperCAmelCase    ):




					"""simple docstring"""

					def __init__(    self       :     List[str]   ,lowerCamelCase__       :     PretrainedConfig   ,lowerCamelCase__       :     str = "default"   ,lowerCamelCase__       :     List[PatchingSpec] = None   ,lowerCamelCase__       :     bool = False   ,):
									super().__init__(lowerCamelCase__   ,task=lowerCamelCase__   ,patching_specs=lowerCamelCase__   ,use_past=lowerCamelCase__      )
									if not getattr(self._config   ,'pad_token_id'   ,lowerCamelCase__      ):
													# TODO: how to do that better?
													UpperCAmelCase__					=							0







					@property
					def 		__lowerCAmelCase						(    self       :     Dict      ):
									UpperCAmelCase__					=							OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}}      )
									if self.use_past:
													self.fill_with_past_key_values_(lowerCamelCase__   ,direction='inputs'      )
													UpperCAmelCase__					=							{0: 'batch', 1: 'past_sequence + sequence'}
									else:
													UpperCAmelCase__					=							{0: 'batch', 1: 'sequence'}

									return common_inputs







					@property
					def 		__lowerCAmelCase						(    self       :     Union[str, Any]      ):
									return self._config.n_layer







					@property
					def 		__lowerCAmelCase						(    self       :     Optional[int]      ):
									return self._config.n_head







					def 		__lowerCAmelCase						(    self       :     int   ,lowerCamelCase__       :     PreTrainedTokenizer   ,lowerCamelCase__       :     int = -1   ,lowerCamelCase__       :     int = -1   ,lowerCamelCase__       :     bool = False   ,lowerCamelCase__       :     Optional[TensorType] = None   ,):
									UpperCAmelCase__					=							super(lowerCamelCase__   ,self      ).generate_dummy_inputs(
									    lowerCamelCase__   ,batch_size=lowerCamelCase__   ,seq_length=lowerCamelCase__   ,is_pair=lowerCamelCase__   ,framework=lowerCamelCase__      )

									# We need to order the input in the way they appears in the forward()
									UpperCAmelCase__					=							OrderedDict({'input_ids': common_inputs['input_ids']}      )

									# Need to add the past_keys
									if self.use_past:
													if not is_torch_available():
																	raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'      )
													else:
																	import torch

																	UpperCAmelCase__				,     UpperCAmelCase__					=							common_inputs['input_ids'].shape
																	# Not using the same length for past_key_values
																	UpperCAmelCase__					=							seqlen + 2
																	UpperCAmelCase__					=							(
																	    batch,
																	    self.num_attention_heads,
																	    past_key_values_length,
																	    self._config.hidden_size // self.num_attention_heads,
																	)
																	UpperCAmelCase__					=							[
																	    (torch.zeros(lowerCamelCase__      ), torch.zeros(lowerCamelCase__      )) for _ in range(self.num_layers      )
																	]

									UpperCAmelCase__					=							common_inputs['attention_mask']
									if self.use_past:
													UpperCAmelCase__					=							ordered_inputs['attention_mask'].dtype
													UpperCAmelCase__					=							torch.cat(
													    [ordered_inputs['attention_mask'], torch.ones(lowerCamelCase__   ,lowerCamelCase__   ,dtype=lowerCamelCase__      )]   ,dim=1      )

									return ordered_inputs







					@property
					def 		__lowerCAmelCase						(    self       :     Optional[int]      ):
									return 13



