code: def _quantize_language_model(
      data_dir, arch, extra_flags=None, run_validation=False
  ):
      train_parser = options.get_training_parser()
      train_args = options.parse_args_and_arch(
          train_parser,
          [
              "--task",
              "language_modeling",
              data_dir,
              "--arch",
              arch,
              "--optimizer",
              "adam",
              "--lr",
              "0.0001",
              "--criterion",
              "adaptive_loss",
              "--adaptive-softmax-cutoff",
              "5,10,15",
              "--max-tokens",
              "500",
              "--tokens-per-sample",
              "500",
              "--save-dir",
              data_dir,
              "--max-epoch",
              "1",
              "--no-progress-bar",
              "--distributed-world-size",
              "1",
              "--ddp-backend",
              "no_c10d",
              "--num-workers",
              "0",
          ]
          + (extra_flags or []),
      )
      train.main(train_args)
  
      # try scalar quantization
      scalar_quant_train_parser = options.get_training_parser()
      scalar_quant_train_args = options.parse_args_and_arch(
          scalar_quant_train_parser,
          [
              "--task",
              "language_modeling",
              data_dir,
              "--arch",
              arch,
              "--optimizer",
              "adam",
              "--lr",
              "0.0001",
              "--criterion",
              "adaptive_loss",
              "--adaptive-softmax-cutoff",
              "5,10,15",
              "--max-tokens",
              "500",
              "--tokens-per-sample",
              "500",
              "--save-dir",
              data_dir,
              "--max-update",
              "3",
              "--no-progress-bar",
              "--distributed-world-size",
              "1",
              "--ddp-backend",
              "no_c10d",
              "--num-workers",
              "0",
              "--quant-noise-scalar",
              "0.5",
          ]
          + (extra_flags or []),
      )
      train.main(scalar_quant_train_args)
  
      # try iterative PQ quantization
      quantize_parser = options.get_training_parser()
      quantize_args = options.parse_args_and_arch(
          quantize_parser,
          [
              "--task",
              "language_modeling",
              data_dir,
              "--arch",
              arch,
              "--optimizer",
              "adam",
              "--lr",
              "0.0001",
              "--criterion",
              "adaptive_loss",
              "--adaptive-softmax-cutoff",
              "5,10,15",
              "--max-tokens",
              "50",
              "--tokens-per-sample",
              "50",
              "--max-update",
              "6",
              "--no-progress-bar",
              "--distributed-world-size",
              "1",
              "--ddp-backend",
              "no_c10d",
              "--num-workers",
              "0",
              "--restore-file",
              os.path.join(data_dir, "checkpoint_last.pt"),
              "--reset-optimizer",
              "--quantization-config-path",
              os.path.join(
                  os.path.dirname(__file__),
                  "transformer_quantization_config.yaml",
              ),
          ]
          + (extra_flags or []),
      )
      train.main(quantize_args)
  
imports: import contextlib
  import json
  import logging
  import os
  import tempfile
  import unittest
  from io import StringIO
  import torch
  from fairseq import options
  from fairseq_cli import train
  from tests.utils import create_dummy_data, generate_main, preprocess_lm_data, preprocess_translation_data, train_language_model, train_translation_model
label_desc: Use image node_id 1 for calling a global function with example usage: _quantize_language_model(data_dir, arch, extra_flags, run_validation) without return types