





import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import evaluate
import numpy as np
import torch
from datasets import load_dataset
from PIL import Image
from torchvision.transforms import (
    CenterCrop,
    Compose,
    Normalize,
    RandomHorizontalFlip,
    RandomResizedCrop,
    Resize,
    ToTensor,
)

import transformers
from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    AutoModelForImageClassification,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
_a 						=      logging.getLogger(__name__)

# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("4.31.0")

require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-classification/requirements.txt")

_a 						=      list(MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING.keys())
_a 						=      tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES)





def lowerCAmelCase__(__snake_case							)				->      Optional[Any]:







	'''simple docstring'''







	with open(__snake_case       ,'''rb'''							) as f:
		lowerCamelCase__								=		Image.open(__snake_case							)
		return im.convert('''RGB'''							)






@dataclass
class 					__A    :

			'''simple docstring'''







			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={
			        """help""": """Name of a dataset from the hub (could be your own, possibly private dataset hosted on the hub)."""
			    }			,				)
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={"""help""": """The configuration name of the dataset to use (via the datasets library)."""} )
			lowerCAmelCase_							     =						field(default=lowerCAmelCase			,				metadata={"""help""": """A folder containing the training data."""} )
			lowerCAmelCase_							     =						field(default=lowerCAmelCase			,				metadata={"""help""": """A folder containing the validation data."""} )
			lowerCAmelCase_							     =						field(
			    default=0.1_5			,				metadata={"""help""": """Percent to split off of train for validation."""} )
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={
			        """help""": (
			            """For debugging purposes or quicker training, truncate the number of training examples to this """
			            """value if set."""
			        )
			    }			,				)
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={
			        """help""": (
			            """For debugging purposes or quicker training, truncate the number of evaluation examples to this """
			            """value if set."""
			        )
			    }			,				)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				if self.dataset_name is None and (self.train_dir is None and self.validation_dir is None):
					raise ValueError(
					    '''You must specify either a dataset name from the hub or a train and/or validation directory.'''							)






@dataclass
class 					__A    :

			'''simple docstring'''







			lowerCAmelCase_							     =						field(
			    default="""google/vit-base-patch16-224-in21k"""			,				metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}			,				)
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={"""help""": """If training from scratch, pass a model type from the list: """ + """, """.join(lowerCAmelCase )}			,				)
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={"""help""": """Pretrained config name or path if not the same as model_name"""} )
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={"""help""": """Where do you want to store the pretrained models downloaded from s3"""} )
			lowerCAmelCase_							     =						field(
			    default="""main"""			,				metadata={"""help""": """The specific model version to use (can be a branch name, tag name or commit id)."""}			,				)
			lowerCAmelCase_							     =						field(default=lowerCAmelCase			,				metadata={"""help""": """Name or path of preprocessor config."""} )
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={
			        """help""": (
			            """Will use the token generated when running `huggingface-cli login` (necessary to use this script """
			            """with private models)."""
			        )
			    }			,				)
			lowerCAmelCase_							     =						field(
			    default=lowerCAmelCase			,				metadata={"""help""": """Will enable to load a pretrained model whose head dimensions are different."""}			,				)





def lowerCAmelCase__(__snake_case							)				->      Dict:







	'''simple docstring'''







	lowerCamelCase__								=		torch.stack([example['''pixel_values'''] for example in examples]							)
	lowerCamelCase__								=		torch.tensor([example['''labels'''] for example in examples]							)
	return {"pixel_values": pixel_values, "labels": labels}





def lowerCAmelCase__()				->      List[str]:







	'''simple docstring'''







	lowerCamelCase__								=		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)							)
	if len(sys.argv							) == 2 and sys.argv[1].endswith('''.json'''							):
		# If we pass only one argument to the script and it's the path to a json file,
		# let's parse it to get our arguments.
		lowerCamelCase__				,	lowerCamelCase__				,	lowerCamelCase__								=		parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]							)							)
	else:
		lowerCamelCase__				,	lowerCamelCase__				,	lowerCamelCase__								=		parser.parse_args_into_dataclasses()

	# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
	# information sent is the one passed as arguments along with your Python/PyTorch versions.
	send_example_telemetry('''run_image_classification'''       ,__snake_case       ,__snake_case							)

	# Setup logging
	logging.basicConfig(
	    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s'''       ,datefmt='''%m/%d/%Y %H:%M:%S'''       ,handlers=[logging.StreamHandler(sys.stdout							)]       ,)

	if training_args.should_log:
		# The default of training_args.log_level is passive, so we set log level at info here to have that default.
		transformers.utils.logging.set_verbosity_info()

	lowerCamelCase__								=		training_args.get_process_log_level()
	logger.setLevel(__snake_case							)
	transformers.utils.logging.set_verbosity(__snake_case							)
	transformers.utils.logging.enable_default_handler()
	transformers.utils.logging.enable_explicit_format()

	# Log on each process the small summary:
	logger.warning(
	    F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
	    + F'distributed training: {bool(training_args.local_rank != -1							)}, 16-bits training: {training_args.fpaa}'							)
	logger.info(F'Training/evaluation parameters {training_args}'							)

	# Detecting last checkpoint.
	lowerCamelCase__								=		None
	if os.path.isdir(training_args.output_dir							) and training_args.do_train and not training_args.overwrite_output_dir:
		lowerCamelCase__								=		get_last_checkpoint(training_args.output_dir							)
		if last_checkpoint is None and len(os.listdir(training_args.output_dir							)							) > 0:
			raise ValueError(
			    F'Output directory ({training_args.output_dir}) already exists and is not empty. '
			    '''Use --overwrite_output_dir to overcome.'''							)
		elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
			logger.info(
			    F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
			    '''the `--output_dir` or add `--overwrite_output_dir` to train from scratch.'''							)

    # Set seed before initializing model.
	set_seed(training_args.seed							)

	# Initialize our dataset and prepare it for the 'image-classification' task.
	if data_args.dataset_name is not None:
		lowerCamelCase__								=		load_dataset(
		    data_args.dataset_name       ,data_args.dataset_config_name       ,cache_dir=model_args.cache_dir       ,task='''image-classification'''       ,use_auth_token=True if model_args.use_auth_token else None       ,)
	else:
		lowerCamelCase__								=		{}
		if data_args.train_dir is not None:
			lowerCamelCase__								=		os.path.join(data_args.train_dir       ,'''**'''							)
		if data_args.validation_dir is not None:
			lowerCamelCase__								=		os.path.join(data_args.validation_dir       ,'''**'''							)
		lowerCamelCase__								=		load_dataset(
		    '''imagefolder'''       ,data_files=__snake_case       ,cache_dir=model_args.cache_dir       ,task='''image-classification'''       ,)

	# If we don't have a validation split, split off a percentage of train as validation.
	lowerCamelCase__								=		None if '''validation''' in dataset.keys() else data_args.train_val_split
	if isinstance(data_args.train_val_split       ,__snake_case							) and data_args.train_val_split > 0.0:
		lowerCamelCase__								=		dataset['''train'''].train_test_split(data_args.train_val_split							)
		lowerCamelCase__								=		split['''train''']
		lowerCamelCase__								=		split['''test''']

	# Prepare label mappings.
	# We'll include these in the model's config to get human readable labels in the Inference API.
	lowerCamelCase__								=		dataset['''train'''].features['''labels'''].names
	lowerCamelCase__				,	lowerCamelCase__								=		{}, {}
	for i, label in enumerate(__snake_case							):
		lowerCamelCase__								=		str(__snake_case							)
		lowerCamelCase__								=		label

	# Load the accuracy metric from the datasets package
	lowerCamelCase__								=		evaluate.load('''accuracy'''							)

	# Define our compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a
	# predictions and label_ids field) and has to return a dictionary string to float.
	def compute_metrics(__snake_case							):
		return metric.compute(predictions=np.argmax(p.predictions       ,axis=1							)       ,references=p.label_ids							)

	lowerCamelCase__								=		AutoConfig.from_pretrained(
	    model_args.config_name or model_args.model_name_or_path       ,num_labels=len(__snake_case							)       ,labelaid=__snake_case       ,idalabel=__snake_case       ,finetuning_task='''image-classification'''       ,cache_dir=model_args.cache_dir       ,revision=model_args.model_revision       ,use_auth_token=True if model_args.use_auth_token else None       ,)
	lowerCamelCase__								=		AutoModelForImageClassification.from_pretrained(
	    model_args.model_name_or_path       ,from_tf=bool('''.ckpt''' in model_args.model_name_or_path							)       ,config=__snake_case       ,cache_dir=model_args.cache_dir       ,revision=model_args.model_revision       ,use_auth_token=True if model_args.use_auth_token else None       ,ignore_mismatched_sizes=model_args.ignore_mismatched_sizes       ,)
	lowerCamelCase__								=		AutoImageProcessor.from_pretrained(
	    model_args.image_processor_name or model_args.model_name_or_path       ,cache_dir=model_args.cache_dir       ,revision=model_args.model_revision       ,use_auth_token=True if model_args.use_auth_token else None       ,)

	# Define torchvision transforms to be applied to each image.
	if "shortest_edge" in image_processor.size:
		lowerCamelCase__								=		image_processor.size['''shortest_edge''']
	else:
		lowerCamelCase__								=		(image_processor.size['''height'''], image_processor.size['''width'''])
	lowerCamelCase__								=		Normalize(mean=image_processor.image_mean       ,std=image_processor.image_std							)
	lowerCamelCase__								=		Compose(
	    [
	        RandomResizedCrop(__snake_case							),
	        RandomHorizontalFlip(),
	        ToTensor(),
	        normalize,
	    ]							)
	lowerCamelCase__								=		Compose(
	    [
	        Resize(__snake_case							),
	        CenterCrop(__snake_case							),
	        ToTensor(),
	        normalize,
	    ]							)

	def train_transforms(__snake_case							):
		lowerCamelCase__								=		[
		    _train_transforms(pil_img.convert('''RGB'''							)							) for pil_img in example_batch['''image''']
		]
		return example_batch

	def val_transforms(__snake_case							):
		lowerCamelCase__								=		[_val_transforms(pil_img.convert('''RGB'''							)							) for pil_img in example_batch['''image''']]
		return example_batch

	if training_args.do_train:
		if "train" not in dataset:
			raise ValueError('''--do_train requires a train dataset'''							)
		if data_args.max_train_samples is not None:
			lowerCamelCase__								=		(
			    dataset['''train'''].shuffle(seed=training_args.seed							).select(range(data_args.max_train_samples							)							)
			)
		# Set the training transforms
		dataset["train"].set_transform(__snake_case							)

	if training_args.do_eval:
		if "validation" not in dataset:
			raise ValueError('''--do_eval requires a validation dataset'''							)
		if data_args.max_eval_samples is not None:
			lowerCamelCase__								=		(
			    dataset['''validation'''].shuffle(seed=training_args.seed							).select(range(data_args.max_eval_samples							)							)
			)
		# Set the validation transforms
		dataset["validation"].set_transform(__snake_case							)

	# Initalize our trainer
	lowerCamelCase__								=		Trainer(
	    model=__snake_case       ,args=__snake_case       ,train_dataset=dataset['''train'''] if training_args.do_train else None       ,eval_dataset=dataset['''validation'''] if training_args.do_eval else None       ,compute_metrics=__snake_case       ,tokenizer=__snake_case       ,data_collator=__snake_case       ,)

	# Training
	if training_args.do_train:
		lowerCamelCase__								=		None
		if training_args.resume_from_checkpoint is not None:
			lowerCamelCase__								=		training_args.resume_from_checkpoint
		elif last_checkpoint is not None:
			lowerCamelCase__								=		last_checkpoint
		lowerCamelCase__								=		trainer.train(resume_from_checkpoint=__snake_case							)
		trainer.save_model()
		trainer.log_metrics('''train'''       ,train_result.metrics							)
		trainer.save_metrics('''train'''       ,train_result.metrics							)
		trainer.save_state()

	# Evaluation
	if training_args.do_eval:
		lowerCamelCase__								=		trainer.evaluate()
		trainer.log_metrics('''eval'''       ,__snake_case							)
		trainer.save_metrics('''eval'''       ,__snake_case							)

	# Write model card and (optionally) push to hub
	lowerCamelCase__								=		{
	    '''finetuned_from''': model_args.model_name_or_path,
	    '''tasks''': '''image-classification''',
	    '''dataset''': data_args.dataset_name,
	    '''tags''': ['''image-classification''', '''vision'''],
	}
	if training_args.push_to_hub:
		trainer.push_to_hub(**__snake_case							)
	else:
		trainer.create_model_card(**__snake_case							)


if __name__ == "__main__":
			main()










from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_a 						=      logging.get_logger(__name__)

_a 						=      {
    "hustvl/yolos-small": "https://huggingface.co/hustvl/yolos-small/resolve/main/config.json",
    # See all YOLOS models at https://huggingface.co/models?filter=yolos
}






class 					__A    (    lowerCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						"""yolos"""





			def __init__(    self       ,  __lowerCAmelCase=7_6_8       ,  __lowerCAmelCase=1_2       ,  __lowerCAmelCase=1_2       ,  __lowerCAmelCase=3_0_7_2       ,  __lowerCAmelCase="gelu"       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=0.02       ,  __lowerCAmelCase=1E-12       ,  __lowerCAmelCase=[5_1_2, 8_6_4]       ,  __lowerCAmelCase=1_6       ,  __lowerCAmelCase=3       ,  __lowerCAmelCase=True       ,  __lowerCAmelCase=1_0_0       ,  __lowerCAmelCase=True       ,  __lowerCAmelCase=False       ,  __lowerCAmelCase=1       ,  __lowerCAmelCase=5       ,  __lowerCAmelCase=2       ,  __lowerCAmelCase=5       ,  __lowerCAmelCase=2       ,  __lowerCAmelCase=0.1       ,  **__lowerCAmelCase       ,  ):



				'''simple docstring'''







				super().__init__(**__lowerCAmelCase							)

				lowerCamelCase__								=		hidden_size
				lowerCamelCase__								=		num_hidden_layers
				lowerCamelCase__								=		num_attention_heads
				lowerCamelCase__								=		intermediate_size
				lowerCamelCase__								=		hidden_act
				lowerCamelCase__								=		hidden_dropout_prob
				lowerCamelCase__								=		attention_probs_dropout_prob
				lowerCamelCase__								=		initializer_range
				lowerCamelCase__								=		layer_norm_eps
				lowerCamelCase__								=		image_size
				lowerCamelCase__								=		patch_size
				lowerCamelCase__								=		num_channels
				lowerCamelCase__								=		qkv_bias
				lowerCamelCase__								=		num_detection_tokens
				lowerCamelCase__								=		use_mid_position_embeddings
				lowerCamelCase__								=		auxiliary_loss
				# Hungarian matcher
				lowerCamelCase__								=		class_cost
				lowerCamelCase__								=		bbox_cost
				lowerCamelCase__								=		giou_cost
				# Loss coefficients
				lowerCamelCase__								=		bbox_loss_coefficient
				lowerCamelCase__								=		giou_loss_coefficient
				lowerCamelCase__								=		eos_coefficient






class 					__A    (    lowerCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						version.parse("""1.11""" )





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return OrderedDict(
				    [
				        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
				    ]							)





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return 1E-4





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return 1_2



