






"""simple docstring"""





import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						Any:
    """simple docstring"""

    UpperCamelCase__								=     TimesformerConfig()

    if "large" in model_name:
        UpperCamelCase__								=     96

    if "hr" in model_name:
        UpperCamelCase__								=     16
        UpperCamelCase__								=     4_48

    UpperCamelCase__								=     'huggingface/label-files'
    if "k400" in model_name:
        UpperCamelCase__								=     4_00
        UpperCamelCase__								=     'kinetics400-id2label.json'
    elif "k600" in model_name:
        UpperCamelCase__								=     6_00
        UpperCamelCase__								=     'kinetics600-id2label.json'
    elif "ssv2" in model_name:
        UpperCamelCase__								=     1_74
        UpperCamelCase__								=     'something-something-v2-id2label.json'
    else:
        raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'       )
    UpperCamelCase__								=     json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						repo_type='dataset'       )			,						'r'       )       )
    UpperCamelCase__								=     {int(SCREAMING_SNAKE_CASE       ): v for k, v in idalabel.items()}
    UpperCamelCase__								=     idalabel
    UpperCamelCase__								=     {v: k for k, v in idalabel.items()}

    return config







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						Optional[int]:
    """simple docstring"""

    if "encoder." in name:
        UpperCamelCase__								=     name.replace('encoder.'			,						''       )
    if "cls_token" in name:
        UpperCamelCase__								=     name.replace('cls_token'			,						'timesformer.embeddings.cls_token'       )
    if "pos_embed" in name:
        UpperCamelCase__								=     name.replace('pos_embed'			,						'timesformer.embeddings.position_embeddings'       )
    if "time_embed" in name:
        UpperCamelCase__								=     name.replace('time_embed'			,						'timesformer.embeddings.time_embeddings'       )
    if "patch_embed.proj" in name:
        UpperCamelCase__								=     name.replace('patch_embed.proj'			,						'timesformer.embeddings.patch_embeddings.projection'       )
    if "patch_embed.norm" in name:
        UpperCamelCase__								=     name.replace('patch_embed.norm'			,						'timesformer.embeddings.norm'       )
    if "blocks" in name:
        UpperCamelCase__								=     name.replace('blocks'			,						'timesformer.encoder.layer'       )
    if "attn.proj" in name:
        UpperCamelCase__								=     name.replace('attn.proj'			,						'attention.output.dense'       )
    if "attn" in name and "bias" not in name and "temporal" not in name:
        UpperCamelCase__								=     name.replace('attn'			,						'attention.self'       )
    if "attn" in name and "temporal" not in name:
        UpperCamelCase__								=     name.replace('attn'			,						'attention.attention'       )
    if "temporal_norm1" in name:
        UpperCamelCase__								=     name.replace('temporal_norm1'			,						'temporal_layernorm'       )
    if "temporal_attn.proj" in name:
        UpperCamelCase__								=     name.replace('temporal_attn'			,						'temporal_attention.output.dense'       )
    if "temporal_fc" in name:
        UpperCamelCase__								=     name.replace('temporal_fc'			,						'temporal_dense'       )
    if "norm1" in name and "temporal" not in name:
        UpperCamelCase__								=     name.replace('norm1'			,						'layernorm_before'       )
    if "norm2" in name:
        UpperCamelCase__								=     name.replace('norm2'			,						'layernorm_after'       )
    if "mlp.fc1" in name:
        UpperCamelCase__								=     name.replace('mlp.fc1'			,						'intermediate.dense'       )
    if "mlp.fc2" in name:
        UpperCamelCase__								=     name.replace('mlp.fc2'			,						'output.dense'       )
    if "norm.weight" in name and "fc" not in name and "temporal" not in name:
        UpperCamelCase__								=     name.replace('norm.weight'			,						'timesformer.layernorm.weight'       )
    if "norm.bias" in name and "fc" not in name and "temporal" not in name:
        UpperCamelCase__								=     name.replace('norm.bias'			,						'timesformer.layernorm.bias'       )
    if "head" in name:
        UpperCamelCase__								=     name.replace('head'			,						'classifier'       )

    return name







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )       ->						int:
    """simple docstring"""

    for key in orig_state_dict.copy().keys():
        UpperCamelCase__								=     orig_state_dict.pop(SCREAMING_SNAKE_CASE       )

        if key.startswith('model.'       ):
            UpperCamelCase__								=     key.replace('model.'			,						''       )

        if "qkv" in key:
            UpperCamelCase__								=     key.split('.'       )
            UpperCamelCase__								=     int(key_split[1]       )
            UpperCamelCase__								=     'timesformer.encoder.layer.'
            if "temporal" in key:
                UpperCamelCase__								=     '.temporal_attention.attention.qkv.'
            else:
                UpperCamelCase__								=     '.attention.attention.qkv.'
            if "weight" in key:
                UpperCamelCase__								=     val
            else:
                UpperCamelCase__								=     val
        else:
            UpperCamelCase__								=     val

    return orig_state_dict







def 	lowerCAmelCase_(			)       ->						Tuple:
    """simple docstring"""

    UpperCamelCase__								=     hf_hub_download(
        repo_id='hf-internal-testing/spaghetti-video'			,						filename='eating_spaghetti.npy'			,						repo_type='dataset'       )
    UpperCamelCase__								=     np.load(SCREAMING_SNAKE_CASE       )
    return list(SCREAMING_SNAKE_CASE       )







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )       ->						List[Any]:
    """simple docstring"""

    UpperCamelCase__								=     get_timesformer_config(SCREAMING_SNAKE_CASE       )

    UpperCamelCase__								=     TimesformerForVideoClassification(SCREAMING_SNAKE_CASE       )

    # download original checkpoint, hosted on Google Drive
    UpperCamelCase__								=     'pytorch_model.bin'
    gdown.cached_download(SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						quiet=SCREAMING_SNAKE_CASE       )
    UpperCamelCase__								=     torch.load(SCREAMING_SNAKE_CASE			,						map_location='cpu'       )
    if "model" in files:
        UpperCamelCase__								=     files['model']
    elif "module" in files:
        UpperCamelCase__								=     files['module']
    else:
        UpperCamelCase__								=     files['model_state']
    UpperCamelCase__								=     convert_state_dict(SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )

    model.load_state_dict(SCREAMING_SNAKE_CASE       )
    model.eval()

    # verify model on basic input
    UpperCamelCase__								=     VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,						image_std=[0.5, 0.5, 0.5]       )
    UpperCamelCase__								=     prepare_video()
    UpperCamelCase__								=     image_processor(video[:8]			,						return_tensors='pt'       )

    UpperCamelCase__								=     model(**SCREAMING_SNAKE_CASE       )
    UpperCamelCase__								=     outputs.logits

    UpperCamelCase__								=     [
        # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-k400',
        'timesformer-large-finetuned-k400',
        'timesformer-hr-finetuned-k400',
        # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-k600',
        'timesformer-large-finetuned-k600',
        'timesformer-hr-finetuned-k600',
        # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
        'timesformer-base-finetuned-ssv2',
        'timesformer-large-finetuned-ssv2',
        'timesformer-hr-finetuned-ssv2',
    ]

    # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
    if model_name == "timesformer-base-finetuned-k400":
        UpperCamelCase__								=     torch.Size([1, 4_00]       )
        UpperCamelCase__								=     torch.tensor([-0.3016, -0.7713, -0.4205]       )
    elif model_name == "timesformer-base-finetuned-k600":
        UpperCamelCase__								=     torch.Size([1, 6_00]       )
        UpperCamelCase__								=     torch.tensor([-0.7267, -0.7466, 3.2404]       )
    elif model_name == "timesformer-base-finetuned-ssv2":
        UpperCamelCase__								=     torch.Size([1, 1_74]       )
        UpperCamelCase__								=     torch.tensor([-0.9059, 0.6433, -3.1457]       )
    elif model_name == "timesformer-large-finetuned-k400":
        UpperCamelCase__								=     torch.Size([1, 4_00]       )
        UpperCamelCase__								=     torch.tensor([0, 0, 0]       )
    elif model_name == "timesformer-large-finetuned-k600":
        UpperCamelCase__								=     torch.Size([1, 6_00]       )
        UpperCamelCase__								=     torch.tensor([0, 0, 0]       )
    elif model_name == "timesformer-large-finetuned-ssv2":
        UpperCamelCase__								=     torch.Size([1, 1_74]       )
        UpperCamelCase__								=     torch.tensor([0, 0, 0]       )
    elif model_name == "timesformer-hr-finetuned-k400":
        UpperCamelCase__								=     torch.Size([1, 4_00]       )
        UpperCamelCase__								=     torch.tensor([-0.9617, -3.7311, -3.7708]       )
    elif model_name == "timesformer-hr-finetuned-k600":
        UpperCamelCase__								=     torch.Size([1, 6_00]       )
        UpperCamelCase__								=     torch.tensor([2.5273, 0.7127, 1.8848]       )
    elif model_name == "timesformer-hr-finetuned-ssv2":
        UpperCamelCase__								=     torch.Size([1, 1_74]       )
        UpperCamelCase__								=     torch.tensor([-3.6756, -0.7513, 0.7180]       )
    else:
        raise ValueError(F'Model name not supported. Should be one of {model_names}'       )

    # verify logits
    assert logits.shape == expected_shape
    assert torch.allclose(logits[0, :3]			,						SCREAMING_SNAKE_CASE			,						atol=1E-4       )
    print('Logits ok!'       )

    if pytorch_dump_folder_path is not None:
        print(F'Saving model and image processor to {pytorch_dump_folder_path}'       )
        image_processor.save_pretrained(SCREAMING_SNAKE_CASE       )
        model.save_pretrained(SCREAMING_SNAKE_CASE       )

    if push_to_hub:
        print('Pushing to the hub...'       )
        model.push_to_hub(F'fcakyon/{model_name}'       )


if __name__ == "__main__":
  A__       :			Dict=						argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--checkpoint_url""",
      default="""https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download""",
      type=str,
      help=(
          """URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"""
          """ download link."""
      ),
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""",
      default="""""",
      type=str,
      help="""Path to the output PyTorch model directory.""",
  )
  parser.add_argument("""--model_name""", default="""timesformer-base-finetuned-k400""", type=str, help="""Name of the model.""")
  parser.add_argument(
      """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
  )

  A__       :			Optional[int]=						parser.parse_args()
  convert_timesformer_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  )












"""simple docstring"""





from __future__ import annotations

from PIL import Image

# Define the first generation of cells
# fmt: off
A__       :			str=						[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						list[int]:
    """simple docstring"""

    return [int(SCREAMING_SNAKE_CASE       ) for c in F'{ruleset:08}'[:8]]







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE			,						SCREAMING_SNAKE_CASE       )       ->						list[int]:
    """simple docstring"""

    UpperCamelCase__								=     len(cells[0]       )  # 31
    UpperCamelCase__								=     []
    for i in range(SCREAMING_SNAKE_CASE       ):
        # Get the neighbors of each cell
        # Handle neighbours outside bounds by using 0 as their value
        UpperCamelCase__								=     0 if i == 0 else cells[time][i - 1]
        UpperCamelCase__								=     0 if i == population - 1 else cells[time][i + 1]
        # Define a new cell and add it to the new generation
        UpperCamelCase__								=     7 - int(F'{left_neighbor}{cells[time][i]}{right_neighbor}'			,						2       )
        next_generation.append(rule[situation]       )
    return next_generation







def 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						Image.Image:
    """simple docstring"""

    UpperCamelCase__								=     Image.new('RGB'			,						(len(cells[0]       ), len(SCREAMING_SNAKE_CASE       ))       )
    UpperCamelCase__								=     img.load()
    # Generates image
    for w in range(img.width       ):
        for h in range(img.height       ):
            UpperCamelCase__								=     2_55 - int(2_55 * cells[h][w]       )
            UpperCamelCase__								=     (color, color, color)
    return img


if __name__ == "__main__":
  A__       :			Optional[int]=						bin(int(input("""Rule:\n""").strip()))[2:]
  A__       :			str=						format_ruleset(int(rule_num))
  for time in range(16):
    CELLS.append(new_generation(CELLS, rule, time))
  A__       :			Tuple=						generate_image(CELLS)
  # Uncomment to save the image
  # img.save(f"rule_{rule_num}.png")
  img.show()




