





import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard

class      A_	(unittest.TestCase      ):
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    {
				    '''model_details''': {
				        '''Organization''': '''testing''',
				        '''Model date''': '''today''',
				        '''Model version''': '''v2.1, Developed by Test Corp in 2019.''',
				        '''Architecture''': '''Convolutional Neural Network.''',
				    },
				    '''metrics''': '''BLEU and ROUGE-1''',
				    '''evaluation_data''': {
				        '''Datasets''': {'''BLEU''': '''My-great-dataset-v1''', '''ROUGE-1''': '''My-short-dataset-v2.1'''},
				        '''Preprocessing''': '''See details on https://arxiv.org/pdf/1810.03993.pdf''',
				    },
				    '''training_data''': {
				        '''Dataset''': '''English Wikipedia dump dated 2018-12-01''',
				        '''Preprocessing''': (
				            '''Using SentencePiece vocabulary of size 52k tokens. See details on'''
				            ''' https://arxiv.org/pdf/1810.03993.pdf'''
				        ),
				    },
				    '''quantitative_analyses''': {'''BLEU''': 55.1, '''ROUGE-1''': 7_6},
				}
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				self.assertTrue(hasattr(_A							, '''model_details'''		)		)
				self.assertTrue(hasattr(_A							, '''intended_use'''		)		)
				self.assertTrue(hasattr(_A							, '''factors'''		)		)
				self.assertTrue(hasattr(_A							, '''metrics'''		)		)
				self.assertTrue(hasattr(_A							, '''evaluation_data'''		)		)
				self.assertTrue(hasattr(_A							, '''training_data'''		)		)
				self.assertTrue(hasattr(_A							, '''quantitative_analyses'''		)		)
				self.assertTrue(hasattr(_A							, '''ethical_considerations'''		)		)
				self.assertTrue(hasattr(_A							, '''caveats_and_recommendations'''		)		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)
				UpperCAmelCase       		=    json.loads(modelcard.to_json_string()		)
				for key, value in self.inputs_dict.items():
							self.assertEqual(obj[key]							, _A		)
	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase       		=    os.path.join(_A							, '''modelcard.json'''		)
							model_card_first.to_json_file(_A		)
							UpperCAmelCase       		=    ModelCard.from_json_file(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)







	def 					_lowercase    (   self		):






				'''simple docstring'''







				UpperCAmelCase       		=    ModelCard.from_dict(self.inputs_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							model_card_first.save_pretrained(_A		)
							UpperCAmelCase       		=    ModelCard.from_pretrained(_A		)

				self.assertEqual(model_card_second.to_dict()							, model_card_first.to_dict()		)










from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve





def 						__SCREAMING_SNAKE_CASE  (    UpperCamelCase__      ,      UpperCamelCase__      ,      UpperCamelCase__			)  ->    np.ndarray:







			'''simple docstring'''

			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 						__SCREAMING_SNAKE_CASE  (    UpperCamelCase__      ,      UpperCamelCase__      ,      UpperCamelCase__      ,      UpperCamelCase__ = None      ,      )  ->    tuple[np.ndarray, np.ndarray]:







			'''simple docstring'''

			if alpha is None:
						UpperCAmelCase       		=    0.1

			# Initialize flow
			UpperCAmelCase       		=    np.zeros_like(UpperCamelCase__			)
			UpperCAmelCase       		=    np.zeros_like(UpperCamelCase__			)

			# 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 / 12, 1 / 6, 1 / 12], [1 / 6, 0, 1 / 6], [1 / 12, 1 / 6, 1 / 12]]			)

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

						UpperCAmelCase       		=    convolve(UpperCamelCase__      ,      UpperCamelCase__			)
						UpperCAmelCase       		=    convolve(UpperCamelCase__      ,      UpperCamelCase__			)

						# 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()



