



import argparse
import logging
import os

import datasets
import tensorflow as tf

from transformers import AutoTokenizer


lowercase_						=       logging.getLogger(__name__)



def __lowerCAmelCase	(       ):
			lowercase__   					=			argparse.ArgumentParser(
			    description="Prepare TFRecord shards from pre-tokenized samples of the wikitext dataset."					)
			parser.add_argument(
			    "--dataset_name"  ,					type=SCREAMING_SNAKE_CASE_  ,					default="wikitext"  ,					help="Name of the training. Explore datasets at: hf.co/datasets."  ,					)
			parser.add_argument(
			    "--dataset_config"  ,					type=SCREAMING_SNAKE_CASE_  ,					default="wikitext-103-raw-v1"  ,					help="Configuration name of the dataset."					)
			parser.add_argument(
			    "--tokenizer_name_or_path"  ,					type=SCREAMING_SNAKE_CASE_  ,					default="sayakpaul/unigram-tokenizer-wikitext"  ,					help="Tokenizer identifier. Can be a local filepath or a Hub identifier."  ,					)
			parser.add_argument(
			    "--shard_size"  ,					type=SCREAMING_SNAKE_CASE_  ,					default=1000  ,					help="Number of entries to go in a single shard."  ,					)
			parser.add_argument("--split"  ,					type=SCREAMING_SNAKE_CASE_  ,					default="train"  ,					choices=["train", "test", "validation"]					)
			parser.add_argument(
			    "--limit"  ,					default=SCREAMING_SNAKE_CASE_  ,					type=SCREAMING_SNAKE_CASE_  ,					help="Limit the number of shards (used for debugging)."  ,					)
			parser.add_argument(
			    "--max_length"  ,					type=SCREAMING_SNAKE_CASE_  ,					default=512  ,					help="Maximum sequence length. For training on TPUs, it helps to have a maximum"
			    " sequence length that is a multiple of 8."  ,					)
			parser.add_argument(
			    "--output_dir"  ,					default="tf-tpu"  ,					type=SCREAMING_SNAKE_CASE_  ,					help="Output directory where the TFRecord shards will be saved. If the"
			    " path is appended with `gs://` ('gs://tf-tpu', for example) then the TFRecord"
			    " shards will be directly saved to a Google Cloud Storage bucket."  ,					)

			lowercase__   					=			parser.parse_args()
			return args



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			def fn(SCREAMING_SNAKE_CASE_					):
						return tokenizer(examples["text"]					)

			return fn



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			[]
			for i in range(len(tokenized_data["input_ids"]					)					):
						lowercase__   					=			{
						    "input_ids": tf.train.Feature(intaa_list=tf.train.IntaaList(value=tokenized_data["input_ids"][i]					)					),
						    "attention_mask": tf.train.Feature(
						        intaa_list=tf.train.IntaaList(value=tokenized_data["attention_mask"][i]					)					),
						}
						lowercase__   					=			tf.train.Features(feature=SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			tf.train.Example(features=SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			example.SerializeToString()
						records.append(SCREAMING_SNAKE_CASE_					)
			return records



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			datasets.load_dataset(args.dataset_name  ,					args.dataset_config  ,					split=args.split					)

			if args.limit is not None:
						lowercase__   					=			min(len(SCREAMING_SNAKE_CASE_					)  ,					args.limit					)
						lowercase__   					=			dataset.select(range(SCREAMING_SNAKE_CASE_					)					)
						print(f'''Limiting the dataset to {args.limit} entries.'''					)

			lowercase__   					=			AutoTokenizer.from_pretrained(args.tokenizer_name_or_path					)

			# Handle output directory creation.
			# For serializing into a Google Cloud Storage Bucket, one needs to first
			# create a bucket.
			if "gs" not in args.output_dir:
						if not os.path.exists(args.output_dir					):
									os.makedirs(args.output_dir					)
						lowercase__   					=			os.path.join(args.output_dir  ,					args.split					)
						if not os.path.exists(SCREAMING_SNAKE_CASE_					):
									os.makedirs(SCREAMING_SNAKE_CASE_					)
			else:
						lowercase__   					=			os.path.join(args.output_dir  ,					args.split					)

			# Tokenize the whole dataset at once.
			lowercase__   					=			tokenize_function(SCREAMING_SNAKE_CASE_					)
			lowercase__   					=			dataset.map(SCREAMING_SNAKE_CASE_  ,					batched=SCREAMING_SNAKE_CASE_  ,					num_proc=4  ,					remove_columns=["text"]					)

			# We need to concatenate all our texts together, and then split the result
			# into chunks of a fixed size, which we will call block_size. To do this, we
			# will use the map method again, with the option batched=True. When we use batched=True,
			# the function we pass to map() will be passed multiple inputs at once, allowing us
			# to group them into more or fewer examples than we had in the input.
			# This allows us to create our new fixed-length samples. The advantage of this
			# method is that we don't lose a whole lot of content from the dataset compared to the
			# case where we simply tokenize with a pre-defined max_length.

			def group_texts(SCREAMING_SNAKE_CASE_					):
						# Concatenate all texts.
						lowercase__   					=			{k: sum(examples[k]  ,					[]					) for k in examples.keys()}
						lowercase__   					=			len(concatenated_examples[list(examples.keys()					)[0]]					)
						# We drop the small remainder, though you could add padding instead if the model supports it
						# In this, as in all things, we advise you to follow your heart 🫀
						lowercase__   					=			(total_length // args.max_length) * args.max_length
						# Split by chunks of max_len.
						lowercase__   					=			{
						    k: [t[i : i + args.max_length] for i in range(0  ,					SCREAMING_SNAKE_CASE_  ,					args.max_length					)]
						    for k, t in concatenated_examples.items()
						}
						return result

			lowercase__   					=			dataset_tokenized.map(SCREAMING_SNAKE_CASE_  ,					batched=SCREAMING_SNAKE_CASE_  ,					batch_size=1000  ,					num_proc=4					)

			lowercase__   					=			0
			lowercase__   					=			0
			for shard in range(0  ,					len(SCREAMING_SNAKE_CASE_					)  ,					args.shard_size					):
						lowercase__   					=			grouped_dataset[shard : shard + args.shard_size]
						lowercase__   					=			len(dataset_snapshot["input_ids"]					)
						lowercase__   					=			os.path.join(SCREAMING_SNAKE_CASE_  ,					f'''dataset-{shard_count}-{records_containing}.tfrecord'''					)
						lowercase__   					=			get_serialized_examples(SCREAMING_SNAKE_CASE_					)

						with tf.io.TFRecordWriter(SCREAMING_SNAKE_CASE_					) as out_file:
									for i in range(len(SCREAMING_SNAKE_CASE_					)					):
												lowercase__   					=			serialized_examples[i]
												out_file.write(SCREAMING_SNAKE_CASE_					)
									print("Wrote file {} containing {} records".format(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					)					)

						shard_count += 1
						total_records += records_containing

			with open(f'''split-{args.split}-records-count.txt'''  ,					"w"					) as f:
						print(f'''Total {args.split} records: {total_records}'''  ,					file=SCREAMING_SNAKE_CASE_					)


if __name__ == "__main__":
		lowercase_						=       parse_args()
		main(args)









import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


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



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			"huggingface/label-files"
			lowercase__   					=			"imagenet-1k-id2label.json"
			lowercase__   					=			json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					repo_type="dataset"					)  ,					"r"					)					)
			lowercase__   					=			{int(SCREAMING_SNAKE_CASE_					): v for k, v in idalabel.items()}
			lowercase__   					=			{v: k for k, v in idalabel.items()}

			lowercase__   					=			"std_conv" if "bit" in model_name else False

			# note that when using BiT as backbone for ViT-hybrid checkpoints,
			# one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
			# config.conv_layer = "std_conv_same"
			lowercase__   					=			BitConfig(
			    conv_layer=SCREAMING_SNAKE_CASE_  ,					num_labels=1000  ,					idalabel=SCREAMING_SNAKE_CASE_  ,					labelaid=SCREAMING_SNAKE_CASE_  ,					)

			return config



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			if "stem.conv" in name:
						lowercase__   					=			name.replace("stem.conv"  ,					"bit.embedder.convolution"					)
			if "blocks" in name:
						lowercase__   					=			name.replace("blocks"  ,					"layers"					)
			if "head.fc" in name:
						lowercase__   					=			name.replace("head.fc"  ,					"classifier.1"					)
			if name.startswith("norm"					):
						lowercase__   					=			"bit." + name
			if "bit" not in name and "classifier" not in name:
						lowercase__   					=			"bit.encoder." + name

			return name



def __lowerCAmelCase	(       ):
			lowercase__   					=			"http://images.cocodataset.org/val2017/000000039769.jpg"
			lowercase__   					=			Image.open(requests.get(SCREAMING_SNAKE_CASE_  ,					stream=SCREAMING_SNAKE_CASE_					).raw					)
			return im



@torch.no_grad()
def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_=False					):
			lowercase__   					=			get_config(SCREAMING_SNAKE_CASE_					)

			# load original model from timm
			lowercase__   					=			create_model(SCREAMING_SNAKE_CASE_  ,					pretrained=SCREAMING_SNAKE_CASE_					)
			timm_model.eval()

			# load state_dict of original model
			lowercase__   					=			timm_model.state_dict()
			for key in state_dict.copy().keys():
						lowercase__   					=			state_dict.pop(SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			val.squeeze() if "head" in key else val

			# load HuggingFace model
			lowercase__   					=			BitForImageClassification(SCREAMING_SNAKE_CASE_					)
			model.eval()
			model.load_state_dict(SCREAMING_SNAKE_CASE_					)

			# create image processor
			lowercase__   					=			create_transform(**resolve_data_config({}  ,					model=SCREAMING_SNAKE_CASE_					)					)
			lowercase__   					=			transform.transforms

			lowercase__   					=			{
			    "bilinear": PILImageResampling.BILINEAR,
			    "bicubic": PILImageResampling.BICUBIC,
			    "nearest": PILImageResampling.NEAREST,
			}

			lowercase__   					=			BitImageProcessor(
			    do_resize=SCREAMING_SNAKE_CASE_  ,					size={"shortest_edge": timm_transforms[0].size}  ,					resample=pillow_resamplings[timm_transforms[0].interpolation.value]  ,					do_center_crop=SCREAMING_SNAKE_CASE_  ,					crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]}  ,					do_normalize=SCREAMING_SNAKE_CASE_  ,					image_mean=timm_transforms[-1].mean.tolist()  ,					image_std=timm_transforms[-1].std.tolist()  ,					)

			lowercase__   					=			prepare_img()
			lowercase__   					=			transform(SCREAMING_SNAKE_CASE_					).unsqueeze(0					)
			lowercase__   					=			processor(SCREAMING_SNAKE_CASE_  ,					return_tensors="pt"					).pixel_values

			# verify pixel values
			assert torch.allclose(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					)

			# verify logits
			with torch.no_grad():
						lowercase__   					=			model(SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			outputs.logits

			print("Logits:"  ,					logits[0, :3]					)
			print("Predicted class:"  ,					model.config.idalabel[logits.argmax(-1					).item()]					)
			lowercase__   					=			timm_model(SCREAMING_SNAKE_CASE_					)
			assert timm_logits.shape == outputs.logits.shape
			assert torch.allclose(SCREAMING_SNAKE_CASE_  ,					outputs.logits  ,					atol=1e-3					)
			print("Looks ok!"					)

			if pytorch_dump_folder_path is not None:
						Path(SCREAMING_SNAKE_CASE_					).mkdir(exist_ok=SCREAMING_SNAKE_CASE_					)
						print(f'''Saving model {model_name} and processor to {pytorch_dump_folder_path}'''					)
						model.save_pretrained(SCREAMING_SNAKE_CASE_					)
						processor.save_pretrained(SCREAMING_SNAKE_CASE_					)

			if push_to_hub:
						print(f'''Pushing model {model_name} and processor to the hub'''					)
						model.push_to_hub(f'''ybelkada/{model_name}'''					)
						processor.push_to_hub(f'''ybelkada/{model_name}'''					)


if __name__ == "__main__":
							lowercase_						=       argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--model_name""",
							    default="""resnetv2_50x1_bitm""",
							    type=str,
							    help="""Name of the BiT timm model you'd like to convert.""",
							)
							parser.add_argument(
							    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
							)
							parser.add_argument(
							    """--push_to_hub""",
							    action="""store_true""",
							    help="""Whether to push the model to the hub.""",
							)

							lowercase_						=       parser.parse_args()
							convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




