code: def _set_llm_tokenizers(config: "ModelConfig") -> None:
      """Sets the tokenizers for the LLM model to the pretrained model name or path. This ensures that they use the
      correct shared vocabulary from the tokenizer.
  
      This also ensures padding is correctly set to left padding to prevent the LLM from trying to continue to sequence
      based on the right padding tokens, which might exist based on sequence length.
      """
      pretrained_model_name_or_path = config.base_model
      if (
          not isinstance(pretrained_model_name_or_path, str)
          or pretrained_model_name_or_path is None
      ):
          raise ValueError(
              "Must set `base_model` when using the LLM model."
          )
  
      for input_feature in config.input_features:
          if input_feature.type == TEXT:
              input_feature.preprocessing.tokenizer = "hf_tokenizer"
              input_feature.preprocessing.pretrained_model_name_or_path = (
                  pretrained_model_name_or_path
              )
              input_feature.preprocessing.padding = "left"
  
      for output_feature in config.output_features:
          if output_feature.type == TEXT:
              # Add tokenizer parameters to preprocessing so it can be used during post processing
              output_feature.preprocessing.tokenizer = "hf_tokenizer"
              output_feature.preprocessing.pretrained_model_name_or_path = (
                  pretrained_model_name_or_path
              )
              output_feature.preprocessing.padding = "left"
  
              # Add tokenizer parameters to decoder so it can be used during the forward pass
              output_feature.decoder.pretrained_model_name_or_path = (
                  pretrained_model_name_or_path
              )
              output_feature.decoder.max_new_tokens = (
                  config.generation.max_new_tokens
              )
          elif output_feature.type == CATEGORY:
              # Tokenizer parameters
              output_feature.decoder.tokenizer = "hf_tokenizer"
              output_feature.decoder.pretrained_model_name_or_path = (
                  pretrained_model_name_or_path
              )
              # Parameters for building decoder vocabulary
              output_feature.decoder.fallback_label = (
                  output_feature.preprocessing.fallback_label
              )
  
imports: import copy
  import logging
  import sys
  import warnings
  from typing import Any, Dict, List, Mapping, Set, TYPE_CHECKING
  from marshmallow import ValidationError
  from transformers import AutoConfig
  from ludwig.api_annotations import DeveloperAPI
  from ludwig.constants import CATEGORY, COMBINED, DECODER, DEFAULTS, ENCODER, GRID_SEARCH, INPUT_FEATURES, LOSS, MODEL_ECD, MODEL_LLM, OUTPUT_FEATURES, PARAMETERS, PREPROCESSING, SEQUENCE, SPACE, TEXT, TYPE
  from ludwig.features.feature_utils import compute_feature_hash
  from ludwig.schema.features.utils import output_config_registry
  from ludwig.schema.hyperopt.scheduler import BaseHyperbandSchedulerConfig
  from ludwig.schema.llms.generation import LLMGenerationConfig
  from ludwig.schema.trainer import ECDTrainerConfig
  from ludwig.types import HyperoptConfigDict, ModelConfigDict
  from ludwig.utils.data_utils import get_sanitized_feature_name
  from ludwig.utils.llm_utils import get_context_len
label_desc: Use image node_id 13 for calling a global function with example usage: _set_llm_tokenizers(config) without return types