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, 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.
          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()
  
      # 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_semantic_segmentation", 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)],
      )
  
      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: {bool(training_args.local_rank != -1)}, 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."
              )
  
      # Load dataset
      # In distributed training, the load_dataset function guarantees that only one local process can concurrently
      # download the dataset.
      # TODO support datasets from local folders
      dataset = load_dataset(
          data_args.dataset_name, cache_dir=model_args.cache_dir
      )
  
      # Rename column names to standardized names (only "image" and "label" need to be present)
      if "pixel_values" in dataset["train"].column_names:
          dataset = dataset.rename_columns({"pixel_values": "image"})
      if "annotation" in dataset["train"].column_names:
          dataset = dataset.rename_columns({"annotation": "label"})
  
      # 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.
      if data_args.dataset_name == "scene_parse_150":
          repo_id = "huggingface/label-files"
          filename = "ade20k-id2label.json"
      else:
          repo_id = data_args.dataset_name
          filename = "id2label.json"
      id2label = json.load(
          open(
              hf_hub_download(repo_id, filename, repo_type="dataset"),
              "r",
          )
      )
      id2label = {int(k): v for k, v in id2label.items()}
      label2id = {v: str(k) for k, v in id2label.items()}
  
      # Load the mean IoU metric from the datasets package
      metric = evaluate.load("mean_iou")
  
      # 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.
      @torch.no_grad()
      def compute_metrics(eval_pred):
          logits, labels = eval_pred
          logits_tensor = torch.from_numpy(logits)
          # scale the logits to the size of the label
          logits_tensor = nn.functional.interpolate(
              logits_tensor,
              size=labels.shape[-2:],
              mode="bilinear",
              align_corners=False,
          ).argmax(dim=1)
  
          pred_labels = logits_tensor.detach().cpu().numpy()
          metrics = metric.compute(
              predictions=pred_labels,
              references=labels,
              num_labels=len(id2label),
              ignore_index=0,
              reduce_labels=feature_extractor.reduce_labels,
          )
          # add per category metrics as individual key-value pairs
          per_category_accuracy = metrics.pop(
              "per_category_accuracy"
          ).tolist()
          per_category_iou = metrics.pop("per_category_iou").tolist()
  
          metrics.update(
              {
                  f"accuracy_{id2label[i]}": v
                  for i, v in enumerate(per_category_accuracy)
              }
          )
          metrics.update(
              {
                  f"iou_{id2label[i]}": v
                  for i, v in enumerate(per_category_iou)
              }
          )
  
          return metrics
  
      config = AutoConfig.from_pretrained(
          model_args.config_name or model_args.model_name_or_path,
          label2id=label2id,
          id2label=id2label,
          cache_dir=model_args.cache_dir,
          revision=model_args.model_revision,
          use_auth_token=True if model_args.use_auth_token else None,
      )
      model = AutoModelForSemanticSegmentation.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,
          use_auth_token=True if model_args.use_auth_token else None,
      )
      feature_extractor = AutoFeatureExtractor.from_pretrained(
          model_args.feature_extractor_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 + target.
      # Not that straightforward in torchvision: https://github.com/pytorch/vision/issues/9
      # Currently based on official torchvision references: https://github.com/pytorch/vision/blob/main/references/segmentation/transforms.py
      train_transforms = Compose(
          [
              ReduceLabels() if data_args.reduce_labels else Identity(),
              RandomCrop(size=feature_extractor.size),
              RandomHorizontalFlip(flip_prob=0.5),
              PILToTensor(),
              ConvertImageDtype(torch.float),
              Normalize(
                  mean=feature_extractor.image_mean,
                  std=feature_extractor.image_std,
              ),
          ]
      )
      # Define torchvision transform to be applied to each image.
      # jitter = ColorJitter(brightness=0.25, contrast=0.25, saturation=0.25, hue=0.1)
      val_transforms = Compose(
          [
              ReduceLabels() if data_args.reduce_labels else Identity(),
              Resize(
                  size=(feature_extractor.size, feature_extractor.size)
              ),
              PILToTensor(),
              ConvertImageDtype(torch.float),
              Normalize(
                  mean=feature_extractor.image_mean,
                  std=feature_extractor.image_std,
              ),
          ]
      )
  
      def preprocess_train(example_batch):
          pixel_values = []
          labels = []
          for image, target in zip(
              example_batch["image"], example_batch["label"]
          ):
              image, target = train_transforms(
                  image.convert("RGB"), target
              )
              pixel_values.append(image)
              labels.append(target)
  
          encoding = dict()
          encoding["pixel_values"] = torch.stack(pixel_values)
          encoding["labels"] = torch.stack(labels)
  
          return encoding
  
      def preprocess_val(example_batch):
          pixel_values = []
          labels = []
          for image, target in zip(
              example_batch["image"], example_batch["label"]
          ):
              image, target = val_transforms(
                  image.convert("RGB"), target
              )
              pixel_values.append(image)
              labels.append(target)
  
          encoding = dict()
          encoding["pixel_values"] = torch.stack(pixel_values)
          encoding["labels"] = torch.stack(labels)
  
          return encoding
  
      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(preprocess_train)
  
      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(preprocess_val)
  
      # Initalize our trainer
      trainer = Trainer(
          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=feature_extractor,
          data_collator=default_data_collator,
      )
  
      # 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,
          "dataset": data_args.dataset_name,
          "tags": ["image-segmentation", "vision"],
      }
      if training_args.push_to_hub:
          trainer.push_to_hub(**kwargs)
      else:
          trainer.create_model_card(**kwargs)
  
imports: import json
  import logging
  import os
  import random
  import sys
  from dataclasses import dataclass, field
  from typing import Optional
  import numpy
  import torch
  from datasets import load_dataset
  from PIL import Image
  from torch import nn
  from torchvision import transforms
  from torchvision.transforms import functional
  import evaluate
  import transformers
  from huggingface_hub import hf_hub_download
  from transformers import AutoConfig, AutoFeatureExtractor, AutoModelForSemanticSegmentation, HfArgumentParser, Trainer, TrainingArguments, default_data_collator
  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
label_desc: Use image node_id 2 for calling a global function with example usage: main() and returns: metrics, encoding, encoding