code: def build_tiny_model_summary(results, organization=None, token=None):
      """Build a summary: a dictionary of the form
      {
        model architecture name:
          {
            "tokenizer_classes": [...],
            "processor_classes": [...],
            "model_classes": [...],
          }
        ..
      }
      """
      tiny_model_summary = {}
      for config_name in results:
          processors = [
              key
              for key, value in results[config_name][
                  "processor"
              ].items()
          ]
          tokenizer_classes = sorted(
              [
                  x
                  for x in processors
                  if x.endswith("TokenizerFast")
                  or x.endswith("Tokenizer")
              ]
          )
          processor_classes = sorted(
              [x for x in processors if x not in tokenizer_classes]
          )
          for framework in FRAMEWORKS:
              if framework not in results[config_name]:
                  continue
              for arch_name in results[config_name][framework]:
                  model_classes = [arch_name]
                  base_arch_name = (
                      arch_name[2:]
                      if arch_name.startswith("TF")
                      else arch_name
                  )
                  # tiny model is not created for `arch_name`
                  if (
                      results[config_name][framework][arch_name][
                          "model"
                      ]
                      is None
                  ):
                      model_classes = []
                  if base_arch_name not in tiny_model_summary:
                      tiny_model_summary[base_arch_name] = {}
                  tiny_model_summary[base_arch_name].update(
                      {
                          "tokenizer_classes": tokenizer_classes,
                          "processor_classes": processor_classes,
                      }
                  )
                  tiny_model_summary[base_arch_name][
                      "model_classes"
                  ] = sorted(
                      tiny_model_summary[base_arch_name].get(
                          "model_classes", []
                      )
                      + model_classes
                  )
                  if organization is not None:
                      repo_name = f"tiny-random-{base_arch_name}"
                      # composite models' checkpoints have more precise repo. names on the Hub.
                      if base_arch_name in COMPOSITE_MODELS:
                          repo_name = f"tiny-random-{COMPOSITE_MODELS[base_arch_name]}"
                      repo_id = f"{organization}/{repo_name}"
                      try:
                          commit_hash = hf_api.repo_info(
                              repo_id, token=token
                          ).sha
                      except Exception:
                          # The directory is not created, but processor(s) is/are included in `results`.
                          logger.warning(
                              f"Failed to get information for {repo_id}.\n{traceback.format_exc()}"
                          )
                          del tiny_model_summary[base_arch_name]
                          continue
                      tiny_model_summary[base_arch_name][
                          "sha"
                      ] = commit_hash
  
      return tiny_model_summary
  
imports: import argparse
  import collections.abc
  import copy
  import inspect
  import json
  import multiprocessing
  import os
  import shutil
  import tempfile
  import traceback
  from pathlib import Path
  from check_config_docstrings import get_checkpoint_from_config_class
  from datasets import load_dataset
  from get_test_info import get_model_to_tester_mapping, get_tester_classes_for_model
  from huggingface_hub import Repository, create_repo, hf_api, upload_folder
  from transformers import CONFIG_MAPPING, FEATURE_EXTRACTOR_MAPPING, IMAGE_PROCESSOR_MAPPING, PROCESSOR_MAPPING, TOKENIZER_MAPPING, AutoTokenizer, LayoutLMv3TokenizerFast, PreTrainedTokenizer, PreTrainedTokenizerFast, logging
  from transformers.feature_extraction_utils import FeatureExtractionMixin
  from transformers.file_utils import is_tf_available, is_torch_available
  from transformers.image_processing_utils import BaseImageProcessor
  from transformers.models.auto.configuration_auto import AutoConfig, model_type_to_module_name
  from transformers.models.fsmt import configuration_fsmt
  from transformers.processing_utils import ProcessorMixin, transformers_module
  from transformers.tokenization_utils_base import PreTrainedTokenizerBase
label_desc: Use image node_id 17 for calling a global function with example usage: build_tiny_model_summary(results, organization, token) and returns: tiny_model_summary