




import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import DonutSwinModel
   from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST




class 			a__       :







     def __init__(	self  ,		A  ,		A=13  ,		A=32  ,		A=2  ,		A=3  ,		A=16  ,		A=[1, 2, 1]  ,		A=[2, 2, 4]  ,		A=2  ,		A=2.0  ,		A=True  ,		A=0.0  ,		A=0.0  ,		A=0.1  ,		A="gelu"  ,		A=False  ,		A=True  ,		A=0.0_2  ,		A=1e-5  ,		A=True  ,		A=None  ,		A=True  ,		A=10  ,		A=8  ,		)  ->    Any:



          '''simple docstring'''



          a      =      parent
          a      =      batch_size
          a      =      image_size
          a      =      patch_size
          a      =      num_channels
          a      =      embed_dim
          a      =      depths
          a      =      num_heads
          a      =      window_size
          a      =      mlp_ratio
          a      =      qkv_bias
          a      =      hidden_dropout_prob
          a      =      attention_probs_dropout_prob
          a      =      drop_path_rate
          a      =      hidden_act
          a      =      use_absolute_embeddings
          a      =      patch_norm
          a      =      layer_norm_eps
          a      =      initializer_range
          a      =      is_training
          a      =      scope
          a      =      use_labels
          a      =      type_sequence_label_size
          a      =      encoder_stride







     def 			lowerCAmelCase_				(	self )  ->    Dict:



          '''simple docstring'''



          a      =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

          a      =      None
          if self.use_labels:
               a      =      ids_tensor([self.batch_size]  ,		self.type_sequence_label_size )

          a      =      self.get_config()

          return config, pixel_values, labels







     def 			lowerCAmelCase_				(	self )  ->    Optional[int]:



          '''simple docstring'''



          return DonutSwinConfig(
              image_size=self.image_size  ,		patch_size=self.patch_size  ,		num_channels=self.num_channels  ,		embed_dim=self.embed_dim  ,		depths=self.depths  ,		num_heads=self.num_heads  ,		window_size=self.window_size  ,		mlp_ratio=self.mlp_ratio  ,		qkv_bias=self.qkv_bias  ,		hidden_dropout_prob=self.hidden_dropout_prob  ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,		drop_path_rate=self.drop_path_rate  ,		hidden_act=self.hidden_act  ,		use_absolute_embeddings=self.use_absolute_embeddings  ,		path_norm=self.patch_norm  ,		layer_norm_eps=self.layer_norm_eps  ,		initializer_range=self.initializer_range  ,		encoder_stride=self.encoder_stride  ,		)







     def 			lowerCAmelCase_				(	self  ,		A  ,		A  ,		A )  ->    Dict:



          '''simple docstring'''



          a      =      DonutSwinModel(config=lowercase_ )
          model.to(lowercase_ )
          model.eval()
          a      =      model(lowercase_ )

          a      =      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
          a      =      int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

          self.parent.assertEqual(result.last_hidden_state.shape  ,		(self.batch_size, expected_seq_len, expected_dim) )







     def 			lowerCAmelCase_				(	self )  ->    Dict:



          '''simple docstring'''



          a      =      self.prepare_config_and_inputs()
          (
              (
              a							
          )  ,      (
              a							
          )  ,      (
              a							
          )  ,      							
          )      =      config_and_inputs
          a      =      {"pixel_values": pixel_values}
          return config, inputs_dict







@require_torch
class 			a__       (					SCREAMING_SNAKE_CASE_   ,					SCREAMING_SNAKE_CASE_   ,					unittest.TestCase      ):
     a		:			Union[str, Any]							=	(DonutSwinModel,) if is_torch_available() else ()
     a		:			List[Any]							=	{"feature-extraction": DonutSwinModel} if is_torch_available() else {}
     a		:			List[Any]							=	True

     a		:			str							=	False
     a		:			Any							=	False
     a		:			Dict							=	False







     def 			lowerCAmelCase_				(	self )  ->    Union[str, Any]:



          '''simple docstring'''



          a      =      DonutSwinModelTester(self )
          a      =      ConfigTester(self  ,		config_class=lowercase_  ,		embed_dim=37 )







     def 			lowerCAmelCase_				(	self )  ->    List[Any]:



          '''simple docstring'''



          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()







     def 			lowerCAmelCase_				(	self )  ->    Any:



          '''simple docstring'''



          return







     def 			lowerCAmelCase_				(	self )  ->    Any:



          '''simple docstring'''



          a      =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_ )







     def 			lowerCAmelCase_				(	self )  ->    Dict:



          '''simple docstring'''



          pass







     def 			lowerCAmelCase_				(	self )  ->    int:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a      =      model_class(lowercase_ )
               self.assertIsInstance(model.get_input_embeddings()  ,		(nn.Module) )
               a      =      model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(lowercase_  ,		nn.Linear ) )







     def 			lowerCAmelCase_				(	self )  ->    Optional[Any]:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               a      =      model_class(lowercase_ )
               a      =      inspect.signature(model.forward )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               a      =      [*signature.parameters.keys()]

               a      =      ["pixel_values"]
               self.assertListEqual(arg_names[:1]  ,		lowercase_ )







     def 			lowerCAmelCase_				(	self )  ->    Any:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()
          a      =      True

          for model_class in self.all_model_classes:
               a      =      True
               a      =      False
               a      =      True
               a      =      model_class(lowercase_ )
               model.to(lowercase_ )
               model.eval()
               with torch.no_grad():
                    a      =      model(**self._prepare_for_class(lowercase_  ,		lowercase_ ) )
               a      =      outputs.attentions
               a      =      len(self.model_tester.depths )
               self.assertEqual(len(lowercase_ )  ,		lowercase_ )

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               a      =      True
               a      =      config.window_size**2
               a      =      model_class(lowercase_ )
               model.to(lowercase_ )
               model.eval()
               with torch.no_grad():
                    a      =      model(**self._prepare_for_class(lowercase_  ,		lowercase_ ) )
               a      =      outputs.attentions
               self.assertEqual(len(lowercase_ )  ,		lowercase_ )

               self.assertListEqual(
                   list(attentions[0].shape[-3:] )  ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,		)
               a      =      len(lowercase_ )

               # Check attention is always last and order is fine
               a      =      True
               a      =      True
               a      =      model_class(lowercase_ )
               model.to(lowercase_ )
               model.eval()
               with torch.no_grad():
                    a      =      model(**self._prepare_for_class(lowercase_  ,		lowercase_ ) )

               if hasattr(self.model_tester  ,		"num_hidden_states_types" ):
                    a      =      self.model_tester.num_hidden_states_types
               else:
                    # also another +1 for reshaped_hidden_states
                    a      =      2
               self.assertEqual(out_len + added_hidden_states  ,		len(lowercase_ ) )

               a      =      outputs.attentions

               self.assertEqual(len(lowercase_ )  ,		lowercase_ )

               self.assertListEqual(
                   list(self_attentions[0].shape[-3:] )  ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,		)







     def 			lowerCAmelCase_				(	self  ,		A  ,		A  ,		A  ,		A )  ->    Tuple:



          '''simple docstring'''



          a      =      model_class(lowercase_ )
          model.to(lowercase_ )
          model.eval()

          with torch.no_grad():
               a      =      model(**self._prepare_for_class(lowercase_  ,		lowercase_ ) )

          a      =      outputs.hidden_states

          a      =      getattr(
              self.model_tester  ,		"expected_num_hidden_layers"  ,		len(self.model_tester.depths ) + 1 )
          self.assertEqual(len(lowercase_ )  ,		lowercase_ )

          # DonutSwin has a different seq_length
          a      =      (
              config.patch_size
              if isinstance(config.patch_size  ,		collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          a      =      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:] )  ,		[num_patches, self.model_tester.embed_dim]  ,		)

          a      =      outputs.reshaped_hidden_states
          self.assertEqual(len(lowercase_ )  ,		lowercase_ )

          a  ,      a  ,      a  ,      a      =      reshaped_hidden_states[0].shape
          a      =      (
              reshaped_hidden_states[0].view(lowercase_  ,		lowercase_  ,		height * width ).permute(0  ,		2  ,		1 )
          )
          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:] )  ,		[num_patches, self.model_tester.embed_dim]  ,		)







     def 			lowerCAmelCase_				(	self )  ->    List[str]:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()

          a      =      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size  ,		collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )

          for model_class in self.all_model_classes:
               a      =      True
               self.check_hidden_states_output(lowercase_  ,		lowercase_  ,		lowercase_  ,		lowercase_ )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               a      =      True

               self.check_hidden_states_output(lowercase_  ,		lowercase_  ,		lowercase_  ,		lowercase_ )







     def 			lowerCAmelCase_				(	self )  ->    Union[str, Any]:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()
          a      =      3

          a      =      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size  ,		collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )
          a      =      (
              config.patch_size
              if isinstance(config.patch_size  ,		collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          a      =      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          a      =      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
               a      =      True
               self.check_hidden_states_output(lowercase_  ,		lowercase_  ,		lowercase_  ,		(padded_height, padded_width) )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               a      =      True
               self.check_hidden_states_output(lowercase_  ,		lowercase_  ,		lowercase_  ,		(padded_height, padded_width) )







     @slow
     def 			lowerCAmelCase_				(	self )  ->    Optional[Any]:



          '''simple docstring'''



          for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               a      =      DonutSwinModel.from_pretrained(lowercase_ )
               self.assertIsNotNone(lowercase_ )







     def 			lowerCAmelCase_				(	self )  ->    List[str]:



          '''simple docstring'''



          a  ,      a      =      self.model_tester.prepare_config_and_inputs_for_common()

          a      =      _config_zero_init(lowercase_ )
          for model_class in self.all_model_classes:
               a      =      model_class(config=lowercase_ )
               for name, param in model.named_parameters():
                    if "embeddings" not in name and param.requires_grad:
                         self.assertIn(
                             ((param.data.mean() * 1e9).round() / 1e9).item()  ,		[0.0, 1.0]  ,		msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''  ,		)



"""simple docstring"""

from typing import SupportsIndex

import numpy as np
from scipy.ndimage import convolve




def 			lowercase__  (    lowerCAmelCase :    np.ndarray       , lowerCAmelCase :    np.ndarray       , lowerCAmelCase :    np.ndarray       )       ->					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 			lowercase__  (    lowerCAmelCase :    np.ndarray       , lowerCAmelCase :    np.ndarray       , lowerCAmelCase :    SupportsIndex       , lowerCAmelCase :    float | None = None       , )       ->					tuple[np.ndarray, np.ndarray]:






    """simple docstring"""




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

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



