code: def train_new_models(
      dir,
      iter,
      srand,
      num_jobs,
      num_archives_processed,
      num_archives,
      raw_model_string,
      egs_dir,
      apply_deriv_weights,
      min_deriv_time,
      max_deriv_time_relative,
      l2_regularize,
      xent_regularize,
      leaky_hmm_coefficient,
      momentum,
      max_param_change,
      shuffle_buffer_size,
      num_chunk_per_minibatch_str,
      frame_subsampling_factor,
      run_opts,
      train_opts,
      backstitch_training_scale=0.0,
      backstitch_training_interval=1,
      use_multitask_egs=False,
      chain_opts="",
  ):
      """
      Called from train_one_iteration(), this method trains new models
      with 'num_jobs' jobs, and
      writes files like exp/tdnn_a/24.{1,2,3,..<num_jobs>}.raw
  
      We cannot easily use a single parallel SGE job to do the main training,
      because the computation of which archive and which --frame option
      to use for each job is a little complex, so we spawn each one separately.
      this is no longer true for RNNs as we use do not use the --frame option
      but we use the same script for consistency with FF-DNN code
  
      use_multitask_egs : True, if different examples used to train multiple
                          tasks or outputs, e.g.multilingual training.
                          multilingual egs can be generated using get_egs.sh and
                          steps/nnet3/multilingual/allocate_multilingual_examples.py,
                          those are the top-level scripts.
      """
  
      deriv_time_opts = []
      if min_deriv_time is not None:
          deriv_time_opts.append(
              "--optimization.min-deriv-time={0}".format(min_deriv_time)
          )
      if max_deriv_time_relative is not None:
          deriv_time_opts.append(
              "--optimization.max-deriv-time-relative={0}".format(
                  int(max_deriv_time_relative)
              )
          )
  
      threads = []
      # the GPU timing info is only printed if we use the --verbose=1 flag; this
      # slows down the computation slightly, so don't accumulate it on every
      # iteration.  Don't do it on iteration 0 either, because we use a smaller
      # than normal minibatch size, and people may get confused thinking it's
      # slower for iteration 0 because of the verbose option.
      verbose_opt = "--verbose=1" if iter % 20 == 0 and iter > 0 else ""
      for job in range(1, num_jobs + 1):
          # k is a zero-based index that we will derive the other indexes from.
          k = num_archives_processed + job - 1
          # work out the 1-based archive index.
          archive_index = (k % num_archives) + 1
          # previous : frame_shift = (k/num_archives) % frame_subsampling_factor
          frame_shift = (
              archive_index + k // num_archives
          ) % frame_subsampling_factor
  
          multitask_egs_opts = common_train_lib.get_multitask_egs_opts(
              egs_dir,
              egs_prefix="cegs.",
              archive_index=archive_index,
              use_multitask_egs=use_multitask_egs,
          )
          scp_or_ark = "scp" if use_multitask_egs else "ark"
          cache_io_opts = (
              "--read-cache={dir}/cache.{iter}".format(
                  dir=dir, iter=iter
              )
              if iter > 0
              else ""
          ) + (
              " --write-cache={0}/cache.{1}".format(dir, iter + 1)
              if job == 1
              else ""
          )
          thread = common_lib.background_command(
              """{command} {train_queue_opt} {dir}/log/train.{iter}.{job}.log \
                      nnet3-chain-train {parallel_train_opts} {verbose_opt} \
                      --apply-deriv-weights={app_deriv_wts} \
                      --l2-regularize={l2} --leaky-hmm-coefficient={leaky} \
                      {cache_io_opts}  --xent-regularize={xent_reg} \
                      {deriv_time_opts} \
                      --print-interval=10 --momentum={momentum} \
                      --max-param-change={max_param_change} \
                      --backstitch-training-scale={backstitch_training_scale} \
                      --backstitch-training-interval={backstitch_training_interval} \
                      --l2-regularize-factor={l2_regularize_factor} {train_opts} {chain_opts} \
                      --srand={srand} \
                      "{raw_model}" {dir}/den.fst \
                      "ark,bg:nnet3-chain-copy-egs {multitask_egs_opts} \
                          --frame-shift={fr_shft} \
                          {scp_or_ark}:{egs_dir}/cegs.{archive_index}.{scp_or_ark} ark:- | \
                          nnet3-chain-shuffle-egs --buffer-size={buf_size} \
                          --srand={srand} ark:- ark:- | nnet3-chain-merge-egs \
                          --minibatch-size={num_chunk_per_mb} ark:- ark:- |" \
                      {dir}/{next_iter}.{job}.raw""".format(
                  command=run_opts.command,
                  train_queue_opt=run_opts.train_queue_opt,
                  dir=dir,
                  iter=iter,
                  srand=iter + srand,
                  next_iter=iter + 1,
                  job=job,
                  deriv_time_opts=" ".join(deriv_time_opts),
                  app_deriv_wts=apply_deriv_weights,
                  fr_shft=frame_shift,
                  l2=l2_regularize,
                  train_opts=train_opts,
                  chain_opts=chain_opts,
                  xent_reg=xent_regularize,
                  leaky=leaky_hmm_coefficient,
                  cache_io_opts=cache_io_opts,
                  parallel_train_opts=run_opts.parallel_train_opts,
                  verbose_opt=verbose_opt,
                  momentum=momentum,
                  max_param_change=max_param_change,
                  backstitch_training_scale=backstitch_training_scale,
                  backstitch_training_interval=backstitch_training_interval,
                  l2_regularize_factor=1.0 / num_jobs,
                  raw_model=raw_model_string,
                  egs_dir=egs_dir,
                  archive_index=archive_index,
                  buf_size=shuffle_buffer_size,
                  num_chunk_per_mb=num_chunk_per_minibatch_str,
                  multitask_egs_opts=multitask_egs_opts,
                  scp_or_ark=scp_or_ark,
              ),
              require_zero_status=True,
          )
  
          threads.append(thread)
  
      for thread in threads:
          thread.join()
  
file_path: espnet/egs2/fsc_challenge/slu1/steps/libs/nnet3/train/chain_objf/acoustic_model.py
imports: from __future__ import division
  from __future__ import print_function
  import logging
  import math
  import os
  import sys
  import libs.common
  import libs.nnet3.train.common
label_desc: Use image node_id 4 for calling a global function with example usage: train_new_models(dir, iter, srand, num_jobs, num_archives_processed, num_archives, raw_model_string, egs_dir, apply_deriv_weights, min_deriv_time, max_deriv_time_relative, l2_regularize, xent_regularize, leaky_hmm_coefficient, momentum, max_param_change, shuffle_buffer_size, num_chunk_per_minibatch_str, frame_subsampling_factor, run_opts, train_opts, backstitch_training_scale, backstitch_training_interval, use_multitask_egs, chain_opts) without return types