




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCamelCase      			=						logging.get_logger(__name__)




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Dict	,					__UpperCamelCase      :						int=False	,					__UpperCamelCase      :						Optional[int]=False	,					__UpperCamelCase      :						Optional[int]=False				)  ->							Optional[Any]:
    UpperCAmelCase_										=					[]
    for i in range(config.num_hidden_layers				):
        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
        rename_keys.append((f'transformer.blocks.{i}.norm1.weight', f'vilt.encoder.layer.{i}.layernorm_before.weight')				)
        rename_keys.append((f'transformer.blocks.{i}.norm1.bias', f'vilt.encoder.layer.{i}.layernorm_before.bias')				)
        rename_keys.append(
            (f'transformer.blocks.{i}.attn.proj.weight', f'vilt.encoder.layer.{i}.attention.output.dense.weight')				)
        rename_keys.append(
            (f'transformer.blocks.{i}.attn.proj.bias', f'vilt.encoder.layer.{i}.attention.output.dense.bias')				)
        rename_keys.append((f'transformer.blocks.{i}.norm2.weight', f'vilt.encoder.layer.{i}.layernorm_after.weight')				)
        rename_keys.append((f'transformer.blocks.{i}.norm2.bias', f'vilt.encoder.layer.{i}.layernorm_after.bias')				)
        rename_keys.append(
            (f'transformer.blocks.{i}.mlp.fc1.weight', f'vilt.encoder.layer.{i}.intermediate.dense.weight')				)
        rename_keys.append((f'transformer.blocks.{i}.mlp.fc1.bias', f'vilt.encoder.layer.{i}.intermediate.dense.bias')				)
        rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.weight', f'vilt.encoder.layer.{i}.output.dense.weight')				)
        rename_keys.append((f'transformer.blocks.{i}.mlp.fc2.bias', f'vilt.encoder.layer.{i}.output.dense.bias')				)

    # embeddings
    rename_keys.extend(
        [
            # text embeddings
            ('''text_embeddings.word_embeddings.weight''', '''vilt.embeddings.text_embeddings.word_embeddings.weight'''),
            (
                '''text_embeddings.position_embeddings.weight''',
                '''vilt.embeddings.text_embeddings.position_embeddings.weight''',
            ),
            ('''text_embeddings.position_ids''', '''vilt.embeddings.text_embeddings.position_ids'''),
            (
                '''text_embeddings.token_type_embeddings.weight''',
                '''vilt.embeddings.text_embeddings.token_type_embeddings.weight''',
            ),
            ('''text_embeddings.LayerNorm.weight''', '''vilt.embeddings.text_embeddings.LayerNorm.weight'''),
            ('''text_embeddings.LayerNorm.bias''', '''vilt.embeddings.text_embeddings.LayerNorm.bias'''),
            # patch embeddings
            ('''transformer.cls_token''', '''vilt.embeddings.cls_token'''),
            ('''transformer.patch_embed.proj.weight''', '''vilt.embeddings.patch_embeddings.projection.weight'''),
            ('''transformer.patch_embed.proj.bias''', '''vilt.embeddings.patch_embeddings.projection.bias'''),
            ('''transformer.pos_embed''', '''vilt.embeddings.position_embeddings'''),
            # token type embeddings
            ('''token_type_embeddings.weight''', '''vilt.embeddings.token_type_embeddings.weight'''),
        ]				)

    # final layernorm + pooler
    rename_keys.extend(
        [
            ('''transformer.norm.weight''', '''vilt.layernorm.weight'''),
            ('''transformer.norm.bias''', '''vilt.layernorm.bias'''),
            ('''pooler.dense.weight''', '''vilt.pooler.dense.weight'''),
            ('''pooler.dense.bias''', '''vilt.pooler.dense.bias'''),
        ]				)

    # classifier head(s)
    if vqa_model:
        # classification head
        rename_keys.extend(
            [
                ('''vqa_classifier.0.weight''', '''classifier.0.weight'''),
                ('''vqa_classifier.0.bias''', '''classifier.0.bias'''),
                ('''vqa_classifier.1.weight''', '''classifier.1.weight'''),
                ('''vqa_classifier.1.bias''', '''classifier.1.bias'''),
                ('''vqa_classifier.3.weight''', '''classifier.3.weight'''),
                ('''vqa_classifier.3.bias''', '''classifier.3.bias'''),
            ]				)
    elif nlvr_model:
        # classification head
        rename_keys.extend(
            [
                ('''nlvr2_classifier.0.weight''', '''classifier.0.weight'''),
                ('''nlvr2_classifier.0.bias''', '''classifier.0.bias'''),
                ('''nlvr2_classifier.1.weight''', '''classifier.1.weight'''),
                ('''nlvr2_classifier.1.bias''', '''classifier.1.bias'''),
                ('''nlvr2_classifier.3.weight''', '''classifier.3.weight'''),
                ('''nlvr2_classifier.3.bias''', '''classifier.3.bias'''),
            ]				)
    else:
        pass

    return rename_keys




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						int	,					__UpperCamelCase      :						Tuple				)  ->							List[str]:
    for i in range(config.num_hidden_layers				):
        UpperCAmelCase_										=					'''vilt.'''
        # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
        UpperCAmelCase_										=					state_dict.pop(f'transformer.blocks.{i}.attn.qkv.weight'				)
        UpperCAmelCase_										=					state_dict.pop(f'transformer.blocks.{i}.attn.qkv.bias'				)
        # next, add query, keys and values (in that order) to the state dict
        UpperCAmelCase_										=					in_proj_weight[
            : config.hidden_size, :
        ]
        UpperCAmelCase_										=					in_proj_bias[: config.hidden_size]
        UpperCAmelCase_										=					in_proj_weight[
            config.hidden_size : config.hidden_size * 2, :
        ]
        UpperCAmelCase_										=					in_proj_bias[
            config.hidden_size : config.hidden_size * 2
        ]
        UpperCAmelCase_										=					in_proj_weight[
            -config.hidden_size :, :
        ]
        UpperCAmelCase_										=					in_proj_bias[-config.hidden_size :]




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Any				)  ->							Optional[Any]:
    UpperCAmelCase_										=					['''head.weight''', '''head.bias''']
    for k in ignore_keys:
        state_dict.pop(__UpperCamelCase	,					__UpperCamelCase				)




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Optional[Any]	,					__UpperCamelCase      :						List[Any]	,					__UpperCamelCase      :						Optional[Any]				)  ->							Dict:
    UpperCAmelCase_										=					dct.pop(__UpperCamelCase				)
    UpperCAmelCase_										=					val




@torch.no_grad()
def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						List[str]	,					__UpperCamelCase      :						str				)  ->							str:
    UpperCAmelCase_										=					ViltConfig(image_size=384	,					patch_size=32	,					tie_word_embeddings=__UpperCamelCase				)
    UpperCAmelCase_										=					False
    UpperCAmelCase_										=					False
    UpperCAmelCase_										=					False
    UpperCAmelCase_										=					False
    if "vqa" in checkpoint_url:
        UpperCAmelCase_										=					True
        UpperCAmelCase_										=					3129
        UpperCAmelCase_										=					'''huggingface/label-files'''
        UpperCAmelCase_										=					'''vqa2-id2label.json'''
        UpperCAmelCase_										=					json.load(open(hf_hub_download(__UpperCamelCase	,					__UpperCamelCase	,					repo_type='''dataset'''				)	,					'''r'''				)				)
        UpperCAmelCase_										=					{int(__UpperCamelCase				): v for k, v in idalabel.items()}
        UpperCAmelCase_										=					idalabel
        UpperCAmelCase_										=					{v: k for k, v in idalabel.items()}
        UpperCAmelCase_										=					ViltForQuestionAnswering(__UpperCamelCase				)
    elif "nlvr" in checkpoint_url:
        UpperCAmelCase_										=					True
        UpperCAmelCase_										=					2
        UpperCAmelCase_										=					{0: '''False''', 1: '''True'''}
        UpperCAmelCase_										=					{v: k for k, v in config.idalabel.items()}
        UpperCAmelCase_										=					3
        UpperCAmelCase_										=					ViltForImagesAndTextClassification(__UpperCamelCase				)
    elif "irtr" in checkpoint_url:
        UpperCAmelCase_										=					True
        UpperCAmelCase_										=					ViltForImageAndTextRetrieval(__UpperCamelCase				)
    elif "mlm_itm" in checkpoint_url:
        UpperCAmelCase_										=					True
        UpperCAmelCase_										=					ViltForMaskedLM(__UpperCamelCase				)
    else:
        raise ValueError('''Unknown model type'''				)

    # load state_dict of original model, remove and rename some keys
    UpperCAmelCase_										=					torch.hub.load_state_dict_from_url(__UpperCamelCase	,					map_location='''cpu'''				)['''state_dict''']
    UpperCAmelCase_										=					create_rename_keys(__UpperCamelCase	,					__UpperCamelCase	,					__UpperCamelCase	,					__UpperCamelCase				)
    for src, dest in rename_keys:
        rename_key(__UpperCamelCase	,					__UpperCamelCase	,					__UpperCamelCase				)
    read_in_q_k_v(__UpperCamelCase	,					__UpperCamelCase				)
    if mlm_model or irtr_model:
        UpperCAmelCase_										=					['''itm_score.fc.weight''', '''itm_score.fc.bias''']
        for k in ignore_keys:
            state_dict.pop(__UpperCamelCase	,					__UpperCamelCase				)

    # load state dict into HuggingFace model
    model.eval()
    if mlm_model:
        UpperCAmelCase_			,							UpperCAmelCase_										=					model.load_state_dict(__UpperCamelCase	,					strict=__UpperCamelCase				)
        assert missing_keys == ["mlm_score.decoder.bias"]
    else:
        model.load_state_dict(__UpperCamelCase				)

    # Define processor
    UpperCAmelCase_										=					ViltImageProcessor(size=384				)
    UpperCAmelCase_										=					BertTokenizer.from_pretrained('''bert-base-uncased'''				)
    UpperCAmelCase_										=					ViltProcessor(__UpperCamelCase	,					__UpperCamelCase				)

    # Forward pass on example inputs (image + text)
    if nlvr_model:
        UpperCAmelCase_										=					Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''	,					stream=__UpperCamelCase				).raw				)
        UpperCAmelCase_										=					Image.open(requests.get('''https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'''	,					stream=__UpperCamelCase				).raw				)
        UpperCAmelCase_										=					(
            '''The left image contains twice the number of dogs as the right image, and at least two dogs in total are'''
            ''' standing.'''
        )
        UpperCAmelCase_										=					processor(__UpperCamelCase	,					__UpperCamelCase	,					return_tensors='''pt'''				)
        UpperCAmelCase_										=					processor(__UpperCamelCase	,					__UpperCamelCase	,					return_tensors='''pt'''				)
        UpperCAmelCase_										=					model(
            input_ids=encoding_a.input_ids	,					pixel_values=encoding_a.pixel_values	,					pixel_values_a=encoding_a.pixel_values	,					)
    else:
        UpperCAmelCase_										=					Image.open(requests.get('''http://images.cocodataset.org/val2017/000000039769.jpg'''	,					stream=__UpperCamelCase				).raw				)
        if mlm_model:
            UpperCAmelCase_										=					'''a bunch of [MASK] laying on a [MASK].'''
        else:
            UpperCAmelCase_										=					'''How many cats are there?'''
        UpperCAmelCase_										=					processor(__UpperCamelCase	,					__UpperCamelCase	,					return_tensors='''pt'''				)
        UpperCAmelCase_										=					model(**__UpperCamelCase				)

    # Verify outputs
    if mlm_model:
        UpperCAmelCase_										=					torch.Size([1, 11, 3_0522]				)
        UpperCAmelCase_										=					torch.tensor([-12.5_061, -12.5_123, -12.5_174]				)
        assert outputs.logits.shape == expected_shape
        assert torch.allclose(outputs.logits[0, 0, :3]	,					__UpperCamelCase	,					atol=1e-4				)

        # verify masked token prediction equals "cats"
        UpperCAmelCase_										=					outputs.logits[0, 4, :].argmax(-1				).item()
        assert tokenizer.decode([predicted_id]				) == "cats"
    elif vqa_model:
        UpperCAmelCase_										=					torch.Size([1, 3129]				)
        UpperCAmelCase_										=					torch.tensor([-15.9_495, -18.1_472, -10.3_041]				)
        assert torch.allclose(outputs.logits[0, :3]	,					__UpperCamelCase	,					atol=1e-4				)
        assert outputs.logits.shape == expected_shape
        assert torch.allclose(outputs.logits[0, 0, :3]	,					__UpperCamelCase	,					atol=1e-4				)

        # verify vqa prediction equals "2"
        UpperCAmelCase_										=					outputs.logits.argmax(-1				).item()
        assert model.config.idalabel[predicted_idx] == "2"
    elif nlvr_model:
        UpperCAmelCase_										=					torch.Size([1, 2]				)
        UpperCAmelCase_										=					torch.tensor([-2.8_721, 2.1_291]				)
        assert torch.allclose(outputs.logits[0, :3]	,					__UpperCamelCase	,					atol=1e-4				)
        assert outputs.logits.shape == expected_shape

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


if __name__ == "__main__":
 _lowerCamelCase      			=						argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--checkpoint_url',
     default='https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt',
     type=str,
     help='URL of the checkpoint you\'d like to convert.',
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
 )

 _lowerCamelCase      			=						parser.parse_args()
 convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)











from __future__ import annotations

_lowerCamelCase      			=						list[list[int]]

# assigning initial values to the grid
_lowerCamelCase      			=						[
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
_lowerCamelCase      			=						[
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Matrix	,					__UpperCamelCase      :						int	,					__UpperCamelCase      :						int	,					__UpperCamelCase      :						int				)  ->							bool:
    for i in range(9				):
        if grid[row][i] == n or grid[i][column] == n:
            return False

    for i in range(3				):
        for j in range(3				):
            if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
                return False

    return True




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Matrix				)  ->							tuple[int, int] | None:
    for i in range(9				):
        for j in range(9				):
            if grid[i][j] == 0:
                return i, j
    return None




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Matrix				)  ->							Matrix | None:
    if location := find_empty_location(__UpperCamelCase				):
        UpperCAmelCase_			,							UpperCAmelCase_										=					location
    else:
        # If the location is ``None``, then the grid is solved.
        return grid

    for digit in range(1	,					10				):
        if is_safe(__UpperCamelCase	,					__UpperCamelCase	,					__UpperCamelCase	,					__UpperCamelCase				):
            UpperCAmelCase_										=					digit

            if sudoku(__UpperCamelCase				) is not None:
                return grid

            UpperCAmelCase_										=					0

    return None




def  SCREAMING_SNAKE_CASE     (	__UpperCamelCase      :						Matrix				)  ->							None:
    for row in grid:
        for cell in row:
            print(__UpperCamelCase	,					end=''' '''				)
        print()


if __name__ == "__main__":
 # make a copy of grid so that you can compare with the unmodified grid
 for example_grid in (initial_grid, no_solution):
  print('\nExample grid:\n' + '=' * 20)
  print_solution(example_grid)
  print('\nExample grid solution:')
  _lowerCamelCase      			=						sudoku(example_grid)
  if solution is not None:
   print_solution(solution)
  else:
   print('Cannot find a solution.')





