code: def main():
      # See all possible arguments in src/transformers/training_args.py
      # or by passing the --help flag to this script.
      # We now keep distinct sets of args, for a cleaner separation of concerns.
  
      parser = HfArgumentParser(
          (ModelArguments, DataTrainingArguments, ORTTrainingArguments)
      )
      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.
          model_args, data_args, training_args = parser.parse_json_file(
              json_file=os.path.abspath(sys.argv[1])
          )
      else:
          (
              model_args,
              data_args,
              training_args,
          ) = parser.parse_args_into_dataclasses()
  
      if model_args.use_auth_token is not None:
          warnings.warn(
              "The `use_auth_token` argument is deprecated and will be removed in v4.34.",
              FutureWarning,
          )
          if model_args.token is not None:
              raise ValueError(
                  "`token` and `use_auth_token` are both specified. Please set only the argument `token`."
              )
          model_args.token = model_args.use_auth_token
  
      # 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", model_args, data_args
      )
  
      # 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()
  
      log_level = training_args.get_process_log_level()
      logger.setLevel(log_level)
      transformers.utils.logging.set_verbosity(log_level)
      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: {training_args.parallel_mode.value == 'distributed'}, 16-bits training: {training_args.fp16}"
      )
      logger.info(f"Training/evaluation parameters {training_args}")
  
      # Detecting last checkpoint.
      last_checkpoint = None
      if (
          os.path.isdir(training_args.output_dir)
          and training_args.do_train
          and not training_args.overwrite_output_dir
      ):
          last_checkpoint = 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:
          dataset = load_dataset(
              data_args.dataset_name,
              data_args.dataset_config_name,
              cache_dir=model_args.cache_dir,
              task="image-classification",
              token=model_args.token,
          )
      else:
          data_files = {}
          if data_args.train_dir is not None:
              data_files["train"] = os.path.join(
                  data_args.train_dir, "**"
              )
          if data_args.validation_dir is not None:
              data_files["validation"] = os.path.join(
                  data_args.validation_dir, "**"
              )
          dataset = load_dataset(
              "imagefolder",
              data_files=data_files,
              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.
      data_args.train_val_split = (
          None
          if "validation" in dataset.keys()
          else data_args.train_val_split
      )
      if (
          isinstance(data_args.train_val_split, float)
          and data_args.train_val_split > 0.0
      ):
          split = dataset["train"].train_test_split(
              data_args.train_val_split
          )
          dataset["train"] = split["train"]
          dataset["validation"] = split["test"]
  
      # Prepare label mappings.
      # We'll include these in the model's config to get human readable labels in the Inference API.
      labels = dataset["train"].features["labels"].names
      label2id, id2label = {}, {}
      for i, label in enumerate(labels):
          label2id[label] = str(i)
          id2label[str(i)] = label
  
      # Load the accuracy metric from the datasets package
      metric = 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(p):
          """Computes accuracy on a batch of predictions"""
          return metric.compute(
              predictions=np.argmax(p.predictions, axis=1),
              references=p.label_ids,
          )
  
      config = AutoConfig.from_pretrained(
          model_args.config_name or model_args.model_name_or_path,
          num_labels=len(labels),
          label2id=label2id,
          id2label=id2label,
          finetuning_task="image-classification",
          cache_dir=model_args.cache_dir,
          revision=model_args.model_revision,
          token=model_args.token,
          trust_remote_code=model_args.trust_remote_code,
      )
      model = AutoModelForImageClassification.from_pretrained(
          model_args.model_name_or_path,
          from_tf=bool(".ckpt" in model_args.model_name_or_path),
          config=config,
          cache_dir=model_args.cache_dir,
          revision=model_args.model_revision,
          token=model_args.token,
          trust_remote_code=model_args.trust_remote_code,
          ignore_mismatched_sizes=model_args.ignore_mismatched_sizes,
      )
      image_processor = 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,
          token=model_args.token,
          trust_remote_code=model_args.trust_remote_code,
      )
  
      # Define torchvision transforms to be applied to each image.
      if "shortest_edge" in image_processor.size:
          size = image_processor.size["shortest_edge"]
      else:
          size = (
              image_processor.size["height"],
              image_processor.size["width"],
          )
      normalize = Normalize(
          mean=image_processor.image_mean, std=image_processor.image_std
      )
      _train_transforms = Compose(
          [
              RandomResizedCrop(size),
              RandomHorizontalFlip(),
              ToTensor(),
              normalize,
          ]
      )
      _val_transforms = Compose(
          [
              Resize(size),
              CenterCrop(size),
              ToTensor(),
              normalize,
          ]
      )
  
      def train_transforms(example_batch):
          """Apply _train_transforms across a batch."""
          example_batch["pixel_values"] = [
              _train_transforms(pil_img.convert("RGB"))
              for pil_img in example_batch["image"]
          ]
          return example_batch
  
      def val_transforms(example_batch):
          """Apply _val_transforms across a batch."""
          example_batch["pixel_values"] = [
              _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:
              dataset["train"] = (
                  dataset["train"]
                  .shuffle(seed=training_args.seed)
                  .select(range(data_args.max_train_samples))
              )
          # Set the training transforms
          dataset["train"].set_transform(train_transforms)
  
      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:
              dataset["validation"] = (
                  dataset["validation"]
                  .shuffle(seed=training_args.seed)
                  .select(range(data_args.max_eval_samples))
              )
          # Set the validation transforms
          dataset["validation"].set_transform(val_transforms)
  
      # Initalize our trainer
      trainer = ORTTrainer(
          model=model,
          args=training_args,
          train_dataset=dataset["train"]
          if training_args.do_train
          else None,
          eval_dataset=dataset["validation"]
          if training_args.do_eval
          else None,
          compute_metrics=compute_metrics,
          tokenizer=image_processor,
          data_collator=collate_fn,
      )
  
      # Training
      if training_args.do_train:
          checkpoint = None
          if training_args.resume_from_checkpoint is not None:
              checkpoint = training_args.resume_from_checkpoint
          elif last_checkpoint is not None:
              checkpoint = last_checkpoint
          train_result = trainer.train(
              resume_from_checkpoint=checkpoint
          )
          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:
          metrics = trainer.evaluate()
          trainer.log_metrics("eval", metrics)
          trainer.save_metrics("eval", metrics)
  
      # Write model card and (optionally) push to hub
      kwargs = {
          "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(**kwargs)
      else:
          trainer.create_model_card(**kwargs)
  
imports: import logging
  import os
  import sys
  import warnings
  from dataclasses import dataclass, field
  from typing import Optional
  import evaluate
  import numpy
  import torch
  import transformers
  from datasets import load_dataset
  from PIL import Image
  from torchvision.transforms import CenterCrop, Compose, Normalize, RandomHorizontalFlip, RandomResizedCrop, Resize, ToTensor
  from transformers import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING, AutoConfig, AutoImageProcessor, AutoModelForImageClassification, HfArgumentParser, 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
  from optimum.onnxruntime import ORTTrainer, ORTTrainingArguments
label_desc: Use image node_id 3 for calling a global function with example usage: main() and returns: metric, example_batch, example_batch