
'''simple docstring'''





from __future__ import annotations
def 	snake_case_							(				_a  :				list[list[int]]			,       _a  :				int			,       _a  :				int			,       _a  :				int | float      ):
      snake_case_							,						snake_case_    							=				m - 1, 0
      while i >= 0 and j < n:
            if key == mat[i][j]:
                  print(F'''Key {key} found at row- {i + 1} column- {j + 1}'''      )
                  return
            if key < mat[i][j]:
                  i -= 1
            else:
                  j += 1
      print(F'''Key {key} not found'''      )
def 	snake_case_							(				):
      snake_case_    							=				[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
      snake_case_    							=				int(input("Enter the element to be searched:"      )      )
      print(_a      )
      search_in_a_sorted_matrix(_a			,       len(_a      )			,       len(mat[0]      )			,       _a      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()




import argparse
import json
import os.path
from collections import OrderedDict

import numpy as np
import requests
import torch
from flax.training.checkpoints import restore_checkpoint
from huggingface_hub import hf_hub_download

from transformers import VivitConfig, VivitForVideoClassification, VivitImageProcessor
from transformers.image_utils import PILImageResampling

def      a__	(						UpperCAmelCase				:     Dict     )    ->		Any:
  UpperCAmelCase			:				List[str]										=					'''https://storage.googleapis.com/scenic-bucket/vivit/kinetics_400/vivit_base_16x2_unfactorized/checkpoint'''

  with open(UpperCAmelCase							,					'''wb'''     ) as f:
    with requests.get(UpperCAmelCase							,					stream=UpperCAmelCase     ) as req:
      for chunk in req.iter_content(chunk_size=2_048     ):
        f.write(UpperCAmelCase     )

def      a__	(						)    ->		VivitConfig:
  UpperCAmelCase			:				Any										=					VivitConfig()

  UpperCAmelCase			:				Any										=					400
  UpperCAmelCase			:				int										=					'''huggingface/label-files'''
  UpperCAmelCase			:				int										=					'''kinetics400-id2label.json'''

  UpperCAmelCase			:				Tuple										=					json.load(open(hf_hub_download(UpperCAmelCase							,					UpperCAmelCase							,					repo_type='''dataset'''     )							,					'''r'''     )     )
  UpperCAmelCase			:				Dict										=					{int(UpperCAmelCase     ): v for k, v in idalabel.items()}
  UpperCAmelCase			:				Optional[Any]										=					idalabel
  UpperCAmelCase			:				Tuple										=					{v: k for k, v in idalabel.items()}
  return config

def      a__	(						)    ->		List[Any]:
  UpperCAmelCase			:				int										=					hf_hub_download(
      repo_id='''hf-internal-testing/spaghetti-video'''							,					filename='''eating_spaghetti_32_frames.npy'''							,					repo_type='''dataset'''     )
  UpperCAmelCase			:				Tuple										=					np.load(UpperCAmelCase     )
  return list(UpperCAmelCase     )

def      a__	(						UpperCAmelCase				:     np.ndarray     )    ->		Any:
  if np.ndim(UpperCAmelCase     ) == 2:
    return transform_attention_bias(UpperCAmelCase     )

  elif np.ndim(UpperCAmelCase     ) == 3:
    return transform_attention_kernel(UpperCAmelCase     )

  else:
    raise Exception(f'''Invalid number of dimesions: {np.ndim(UpperCAmelCase     )}'''     )

def      a__	(						UpperCAmelCase				:     np.ndarray     )    ->		List[Any]:
  return current.flatten()

def      a__	(						UpperCAmelCase				:     np.ndarray     )    ->		Optional[Any]:
  return np.reshape(UpperCAmelCase							,					(current.shape[0], current.shape[1] * current.shape[2])     ).T

def      a__	(						UpperCAmelCase				:     np.ndarray     )    ->		Any:
  return np.reshape(UpperCAmelCase							,					(current.shape[0] * current.shape[1], current.shape[2])     ).T

def      a__	(						UpperCAmelCase				:     Dict							,					UpperCAmelCase				:     Union[str, Any]     )    ->		Dict:
  UpperCAmelCase			:				Any										=					state_dict['''optimizer''']['''target''']['''Transformer'''][f'''encoderblock_{i}''']

  UpperCAmelCase			:				Dict										=					f'''encoder.layer.{i}.'''
  UpperCAmelCase			:				Optional[int]										=					{
      prefix + '''intermediate.dense.bias''': state['''MlpBlock_0''']['''Dense_0''']['''bias'''],
      prefix + '''intermediate.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_0''']['''kernel''']     ),
      prefix + '''output.dense.bias''': state['''MlpBlock_0''']['''Dense_1''']['''bias'''],
      prefix + '''output.dense.weight''': np.transpose(state['''MlpBlock_0''']['''Dense_1''']['''kernel''']     ),
      prefix + '''layernorm_before.bias''': state['''LayerNorm_0''']['''bias'''],
      prefix + '''layernorm_before.weight''': state['''LayerNorm_0''']['''scale'''],
      prefix + '''layernorm_after.bias''': state['''LayerNorm_1''']['''bias'''],
      prefix + '''layernorm_after.weight''': state['''LayerNorm_1''']['''scale'''],
      prefix
      + '''attention.attention.query.bias''': transform_attention(
          state['''MultiHeadDotProductAttention_0''']['''query''']['''bias''']     ),
      prefix
      + '''attention.attention.query.weight''': transform_attention(
          state['''MultiHeadDotProductAttention_0''']['''query''']['''kernel''']     ),
      prefix
      + '''attention.attention.key.bias''': transform_attention(state['''MultiHeadDotProductAttention_0''']['''key''']['''bias''']     ),
      prefix
      + '''attention.attention.key.weight''': transform_attention(
          state['''MultiHeadDotProductAttention_0''']['''key''']['''kernel''']     ),
      prefix
      + '''attention.attention.value.bias''': transform_attention(
          state['''MultiHeadDotProductAttention_0''']['''value''']['''bias''']     ),
      prefix
      + '''attention.attention.value.weight''': transform_attention(
          state['''MultiHeadDotProductAttention_0''']['''value''']['''kernel''']     ),
      prefix + '''attention.output.dense.bias''': state['''MultiHeadDotProductAttention_0''']['''out''']['''bias'''],
      prefix
      + '''attention.output.dense.weight''': transform_attention_output_weight(
          state['''MultiHeadDotProductAttention_0''']['''out''']['''kernel''']     ),
  }

  return new_state

def      a__	(						UpperCAmelCase				:     Any     )    ->		List[str]:
  return sum([1 if '''encoderblock_''' in k else 0 for k in state_dict['''optimizer''']['''target''']['''Transformer'''].keys()]     )

def      a__	(						UpperCAmelCase				:     Any							,					UpperCAmelCase				:     Dict=False     )    ->		Dict:
  UpperCAmelCase			:				int										=					get_n_layers(UpperCAmelCase     )

  UpperCAmelCase			:				List[str]										=					OrderedDict()

  UpperCAmelCase			:				int										=					state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''bias''']
  UpperCAmelCase			:				Tuple										=					state_dict['''optimizer''']['''target''']['''Transformer''']['''encoder_norm''']['''scale''']

  UpperCAmelCase			:				Union[str, Any]										=					np.transpose(
      state_dict['''optimizer''']['''target''']['''embedding''']['''kernel''']							,					(4, 3, 0, 1, 2)     )
  UpperCAmelCase			:				List[str]										=					state_dict['''optimizer''']['''target''']['''embedding''']['''bias''']

  UpperCAmelCase			:				Optional[int]										=					state_dict['''optimizer''']['''target''']['''cls''']
  UpperCAmelCase			:				str										=					state_dict['''optimizer''']['''target''']['''Transformer''']['''posembed_input'''][
      '''pos_embedding'''
  ]

  for i in range(UpperCAmelCase     ):
    new_state.update(transform_state_encoder_block(UpperCAmelCase							,					UpperCAmelCase     )     )

  if classification_head:
    UpperCAmelCase			:				List[Any]										=					{'''vivit.''' + k: v for k, v in new_state.items()}
    UpperCAmelCase			:				str										=					np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''kernel''']     )
    UpperCAmelCase			:				Dict										=					np.transpose(state_dict['''optimizer''']['''target''']['''output_projection''']['''bias''']     )

  return {k: torch.tensor(UpperCAmelCase     ) for k, v in new_state.items()}

def      a__	(						)    ->		VivitImageProcessor:
  UpperCAmelCase			:				Optional[int]										=					VivitImageProcessor()

  assert extractor.do_resize is True
  assert extractor.size == {"shortest_edge": 256}
  assert extractor.do_center_crop is True
  assert extractor.crop_size == {"width": 224, "height": 224}
  assert extractor.resample == PILImageResampling.BILINEAR

  # here: https://github.com/deepmind/dmvr/blob/master/dmvr/modalities.py
  # one can seen that add_image has default values for normalization_mean and normalization_std set to 0 and 1
  # which effectively means no normalization (and ViViT does not overwrite those when calling this func)
  assert extractor.do_normalize is False
  assert extractor.do_rescale is True
  assert extractor.rescale_factor == 1 / 255

  # zero-centering = True in original implementation
  assert extractor.do_zero_centering is True

  return extractor

def      a__	(						UpperCAmelCase				:     str     )    ->		Tuple:
  UpperCAmelCase			:				Union[str, Any]										=					'''checkpoint'''

  if not os.path.exists(UpperCAmelCase     ):
    download_checkpoint(UpperCAmelCase     )

  UpperCAmelCase			:				Tuple										=					restore_checkpoint(UpperCAmelCase							,					UpperCAmelCase     )
  UpperCAmelCase			:				Any										=					transform_state(UpperCAmelCase							,					classification_head=UpperCAmelCase     )

  UpperCAmelCase			:				Union[str, Any]										=					get_vivit_config()

  assert config.image_size == 224
  assert config.num_frames == 32

  UpperCAmelCase			:				Optional[int]										=					VivitForVideoClassification(UpperCAmelCase     )
  model.load_state_dict(UpperCAmelCase     )
  model.eval()

  UpperCAmelCase			:				List[Any]										=					get_processor()

  UpperCAmelCase			:				str										=					prepare_video()
  UpperCAmelCase			:				Union[str, Any]										=					extractor(UpperCAmelCase							,					return_tensors='''pt'''     )

  UpperCAmelCase			:				Optional[Any]										=					model(**UpperCAmelCase     )

  UpperCAmelCase			:				str										=					torch.Size([1, 400]     )
  UpperCAmelCase			:				int										=					torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]     )

  assert outputs.logits.shape == expected_shape
  assert torch.allclose(outputs.logits[0, :5]							,					UpperCAmelCase							,					atol=1E-4     ), outputs.logits[0, :5]

  model.save_pretrained(UpperCAmelCase     )
  extractor.save_pretrained(UpperCAmelCase     )


if __name__ == "__main__":
     _lowerCamelCase							:  Optional[Any]     =				argparse.ArgumentParser()

     parser.add_argument("--output_model_name", "-o", type=str, help="Output path for the converted HuggingFace model")

     _lowerCamelCase							:  str     =				parser.parse_args()
     convert(args.output_model_name)





