


import argparse
from pathlib import Path

import requests
import torch
from PIL import Image

from transformers import (
    RobertaTokenizer,
    TrOCRConfig,
    TrOCRForCausalLM,
    TrOCRProcessor,
    VisionEncoderDecoderModel,
    ViTConfig,
    ViTImageProcessor,
    ViTModel,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowercase_	   =     logging.get_logger(__name__)
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							str		 =						[]
 for i in range(encoder_config.num_hidden_layers						):
  # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.norm1.weight', f'encoder.encoder.layer.{i}.layernorm_before.weight')						)
  rename_keys.append((f'encoder.deit.blocks.{i}.norm1.bias', f'encoder.encoder.layer.{i}.layernorm_before.bias')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.attn.proj.weight', f'encoder.encoder.layer.{i}.attention.output.dense.weight')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.attn.proj.bias', f'encoder.encoder.layer.{i}.attention.output.dense.bias')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.norm2.weight', f'encoder.encoder.layer.{i}.layernorm_after.weight')						)
  rename_keys.append((f'encoder.deit.blocks.{i}.norm2.bias', f'encoder.encoder.layer.{i}.layernorm_after.bias')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.mlp.fc1.weight', f'encoder.encoder.layer.{i}.intermediate.dense.weight')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.mlp.fc1.bias', f'encoder.encoder.layer.{i}.intermediate.dense.bias')						)
  rename_keys.append(
      (f'encoder.deit.blocks.{i}.mlp.fc2.weight', f'encoder.encoder.layer.{i}.output.dense.weight')						)
  rename_keys.append((f'encoder.deit.blocks.{i}.mlp.fc2.bias', f'encoder.encoder.layer.{i}.output.dense.bias')						)

 # cls token, position embeddings and patch embeddings of encoder
 rename_keys.extend(
     [
         ('encoder.deit.cls_token', 'encoder.embeddings.cls_token'),
         ('encoder.deit.pos_embed', 'encoder.embeddings.position_embeddings'),
         ('encoder.deit.patch_embed.proj.weight', 'encoder.embeddings.patch_embeddings.projection.weight'),
         ('encoder.deit.patch_embed.proj.bias', 'encoder.embeddings.patch_embeddings.projection.bias'),
         ('encoder.deit.norm.weight', 'encoder.layernorm.weight'),
         ('encoder.deit.norm.bias', 'encoder.layernorm.bias'),
     ]						)

 return rename_keys
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 for i in range(encoder_config.num_hidden_layers						):
  # queries, keys and values (only weights, no biases)
  __lowerCamelCase		:							Tuple		 =						state_dict.pop(f'encoder.deit.blocks.{i}.attn.qkv.weight'						)

  __lowerCamelCase		:							Union[str, Any]		 =						in_proj_weight[
      : encoder_config.hidden_size, :
  ]
  __lowerCamelCase		:							List[Any]		 =						in_proj_weight[
      encoder_config.hidden_size : encoder_config.hidden_size * 2, :
  ]
  __lowerCamelCase		:							List[Any]		 =						in_proj_weight[
      -encoder_config.hidden_size :, :
  ]
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							int		 =						dct.pop(SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							Any		 =						val
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__						):
 if "handwritten" in checkpoint_url:
  __lowerCamelCase		:							Union[str, Any]		 =						'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg'  # industry
  # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-12.jpg" # have
  # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-10.jpg" # let
  # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"  #
  # url = "https://fki.tic.heia-fr.ch/static/img/a01-122.jpg"
 elif "printed" in checkpoint_url or "stage1" in checkpoint_url:
  __lowerCamelCase		:							int		 =						'https://www.researchgate.net/profile/Dinh-Sang/publication/338099565/figure/fig8/AS:840413229350922@1577381536857/An-receipt-example-in-the-SROIE-2019-dataset_Q640.jpg'
 __lowerCamelCase		:							Optional[Any]		 =						Image.open(requests.get(SCREAMING_SNAKE_CASE__      ,	stream=SCREAMING_SNAKE_CASE__						).raw						).convert('RGB'						)
 return im
@torch.no_grad()
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase		:							Dict		 =						ViTConfig(image_size=384      ,	qkv_bias=SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							int		 =						TrOCRConfig()

 # size of the architecture
 if "base" in checkpoint_url:
  __lowerCamelCase		:							str		 =						768
 elif "large" in checkpoint_url:
  # use ViT-large encoder
  __lowerCamelCase		:							List[Any]		 =						1_024
  __lowerCamelCase		:							int		 =						4_096
  __lowerCamelCase		:							Union[str, Any]		 =						24
  __lowerCamelCase		:							Optional[Any]		 =						16
  __lowerCamelCase		:							str		 =						1_024
 else:
  raise ValueError('Should either find \'base\' or \'large\' in checkpoint URL'						)

 # the large-printed + stage1 checkpoints uses sinusoidal position embeddings, no layernorm afterwards
 if "large-printed" in checkpoint_url or "stage1" in checkpoint_url:
  __lowerCamelCase		:							Optional[int]		 =						False
  __lowerCamelCase		:							Any		 =						'relu'
  __lowerCamelCase		:							Dict		 =						1_024
  __lowerCamelCase		:							List[Any]		 =						True
  __lowerCamelCase		:							Union[str, Any]		 =						False
  __lowerCamelCase		:							Union[str, Any]		 =						False

 # load HuggingFace model
 __lowerCamelCase		:							int		 =						ViTModel(SCREAMING_SNAKE_CASE__      ,	add_pooling_layer=SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							List[str]		 =						TrOCRForCausalLM(SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							Optional[int]		 =						VisionEncoderDecoderModel(encoder=SCREAMING_SNAKE_CASE__      ,	decoder=SCREAMING_SNAKE_CASE__						)
 model.eval()

 # load state_dict of original model, rename some keys
 __lowerCamelCase		:							List[Any]		 =						torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__      ,	map_location='cpu'      ,	check_hash=SCREAMING_SNAKE_CASE__						)['model']

 __lowerCamelCase		:							Optional[int]		 =						create_rename_keys(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
 for src, dest in rename_keys:
  rename_key(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
 read_in_q_k_v(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)

 # remove parameters we don't need
 del state_dict["encoder.deit.head.weight"]
 del state_dict["encoder.deit.head.bias"]
 del state_dict["decoder.version"]

 # add prefix to decoder keys
 for key, val in state_dict.copy().items():
  __lowerCamelCase		:							int		 =						state_dict.pop(SCREAMING_SNAKE_CASE__						)
  if key.startswith('decoder'						) and "output_projection" not in key:
   __lowerCamelCase		:							List[str]		 =						val
  else:
   __lowerCamelCase		:							int		 =						val

    # load state dict
 model.load_state_dict(SCREAMING_SNAKE_CASE__						)

 # Check outputs on an image
 __lowerCamelCase		:							Any		 =						ViTImageProcessor(size=encoder_config.image_size						)
 __lowerCamelCase		:							List[Any]		 =						RobertaTokenizer.from_pretrained('roberta-large'						)
 __lowerCamelCase		:							Optional[int]		 =						TrOCRProcessor(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)

 __lowerCamelCase		:							Dict		 =						processor(images=prepare_img(SCREAMING_SNAKE_CASE__						)      ,	return_tensors='pt'						).pixel_values

 # verify logits
 __lowerCamelCase		:							str		 =						torch.tensor([[model.config.decoder.decoder_start_token_id]]						)
 __lowerCamelCase		:							Union[str, Any]		 =						model(pixel_values=SCREAMING_SNAKE_CASE__      ,	decoder_input_ids=SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							Dict		 =						outputs.logits

 __lowerCamelCase		:							Union[str, Any]		 =						torch.Size([1, 1, 50_265]						)
 if "trocr-base-handwritten" in checkpoint_url:
  __lowerCamelCase		:							List[str]		 =						torch.tensor(
      [-1.4_502, -4.6_683, -0.5_347, -2.9_291, 9.1_435, -3.0_571, 8.9_764, 1.7_560, 8.7_358, -1.5_311]						)
 elif "trocr-large-handwritten" in checkpoint_url:
  __lowerCamelCase		:							Optional[Any]		 =						torch.tensor(
      [-2.6_437, -1.3_129, -2.2_596, -5.3_455, 6.3_539, 1.7_604, 5.4_991, 1.4_702, 5.6_113, 2.0_170]						)
 elif "trocr-base-printed" in checkpoint_url:
  __lowerCamelCase		:							List[Any]		 =						torch.tensor(
      [-5.6_816, -5.8_388, 1.1_398, -6.9_034, 6.8_505, -2.4_393, 1.2_284, -1.0_232, -1.9_661, -3.9_210]						)
 elif "trocr-large-printed" in checkpoint_url:
  __lowerCamelCase		:							Optional[Any]		 =						torch.tensor(
      [-6.0_162, -7.0_959, 4.4_155, -5.1_063, 7.0_468, -3.1_631, 2.6_466, -0.3_081, -0.8_106, -1.7_535]						)

 if "stage1" not in checkpoint_url:
  assert logits.shape == expected_shape, "Shape of logits not as expected"
  assert torch.allclose(logits[0, 0, :10]      ,	SCREAMING_SNAKE_CASE__      ,	atol=1e-3						), "First elements of logits not as expected"

 Path(SCREAMING_SNAKE_CASE__						).mkdir(exist_ok=SCREAMING_SNAKE_CASE__						)
 print(f'Saving model to {pytorch_dump_folder_path}'						)
 model.save_pretrained(SCREAMING_SNAKE_CASE__						)
 print(f'Saving processor to {pytorch_dump_folder_path}'						)
 processor.save_pretrained(SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       lowercase_	   =     argparse.ArgumentParser()

       parser.add_argument(
           '--checkpoint_url',
           default='https://layoutlm.blob.core.windows.net/trocr/model_zoo/fairseq/trocr-base-handwritten.pt',
           type=str,
           help='URL to the original PyTorch checkpoint (.pth file).',
       )
       parser.add_argument(
           '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
       )
       lowercase_	   =     parser.parse_args()
       convert_tr_ocr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





from math import pow
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	):
 if current_sum == needed_sum:
  # If the sum of the powers is equal to needed_sum, then we have a solution.
  solutions_count += 1
  return current_sum, solutions_count

 __lowerCamelCase		:							Optional[Any]		 =						int(pow(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)						)
 if current_sum + i_to_n <= needed_sum:
  # If the sum of the powers is less than needed_sum, then continue adding powers.
  current_sum += i_to_n
  __lowerCamelCase ,					__lowerCamelCase		:							Optional[Any]		 =						backtrack(
      SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	current_number + 1      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
  current_sum -= i_to_n
 if i_to_n < needed_sum:
  # If the power of i is less than needed_sum, then try with the next power.
  __lowerCamelCase ,					__lowerCamelCase		:							Dict		 =						backtrack(
      SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	current_number + 1      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						)
 return current_sum, solutions_count
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 if not (1 <= needed_sum <= 1_000 and 2 <= power <= 10):
  raise ValueError(
      'Invalid input\n'
      'needed_sum must be between 1 and 1000, power between 2 and 10.'						)

 return backtrack(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	1      ,	0      ,	0						)[1]  # Return the solutions_count


if __name__ == "__main__":
       import doctest

       doctest.testmod()

