code: def train_fast_rcnn(cfg):
      # Train only if no model exists yet
      model_path = cfg["MODEL_PATH"]
      if os.path.exists(model_path) and cfg["CNTK"].MAKE_MODE:
          print("Loading existing model from %s" % model_path)
          return load_model(model_path)
      else:
          # Input variables denoting features and labeled ground truth rois (as 5-tuples per roi)
          image_input = input_variable(
              shape=(
                  cfg.NUM_CHANNELS,
                  cfg.IMAGE_HEIGHT,
                  cfg.IMAGE_WIDTH,
              ),
              dynamic_axes=[Axis.default_batch_axis()],
              name=cfg["MODEL"].FEATURE_NODE_NAME,
          )
          roi_proposals = input_variable(
              (cfg.NUM_ROI_PROPOSALS, 4),
              dynamic_axes=[Axis.default_batch_axis()],
              name="roi_proposals",
          )
          label_targets = input_variable(
              (cfg.NUM_ROI_PROPOSALS, cfg["DATA"].NUM_CLASSES),
              dynamic_axes=[Axis.default_batch_axis()],
          )
          bbox_targets = input_variable(
              (cfg.NUM_ROI_PROPOSALS, 4 * cfg["DATA"].NUM_CLASSES),
              dynamic_axes=[Axis.default_batch_axis()],
          )
          bbox_inside_weights = input_variable(
              (cfg.NUM_ROI_PROPOSALS, 4 * cfg["DATA"].NUM_CLASSES),
              dynamic_axes=[Axis.default_batch_axis()],
          )
  
          # Instantiate the Fast R-CNN prediction model and loss function
          loss, pred_error = create_fast_rcnn_model(
              image_input,
              roi_proposals,
              label_targets,
              bbox_targets,
              bbox_inside_weights,
              cfg,
          )
          if isinstance(loss, cntk.Variable):
              loss = combine([loss])
  
          if cfg["CNTK"].DEBUG_OUTPUT:
              print(
                  "Storing graphs and models to %s." % cfg.OUTPUT_PATH
              )
              plot(
                  loss,
                  os.path.join(
                      cfg.OUTPUT_PATH,
                      "graph_frcn_train." + cfg["CNTK"].GRAPH_TYPE,
                  ),
              )
  
          # Set learning parameters
          lr_factor = cfg["CNTK"].LR_FACTOR
          lr_per_sample_scaled = [
              x * lr_factor for x in cfg["CNTK"].LR_PER_SAMPLE
          ]
          mm_schedule = momentum_schedule(cfg["CNTK"].MOMENTUM_PER_MB)
          l2_reg_weight = cfg["CNTK"].L2_REG_WEIGHT
          epochs_to_train = cfg["CNTK"].MAX_EPOCHS
  
          print(
              "Using base model:   {}".format(cfg["MODEL"].BASE_MODEL)
          )
          print("lr_per_sample:      {}".format(lr_per_sample_scaled))
  
          # --- train ---
          # Instantiate the learners and the trainer object
          params = loss.parameters
          biases = [
              p for p in params if ".b" in p.name or "b" == p.name
          ]
          others = [p for p in params if not p in biases]
          bias_lr_mult = cfg["CNTK"].BIAS_LR_MULT
          lr_schedule = learning_parameter_schedule_per_sample(
              lr_per_sample_scaled
          )
          learner = momentum_sgd(
              others,
              lr_schedule,
              mm_schedule,
              l2_regularization_weight=l2_reg_weight,
              unit_gain=False,
              use_mean_gradient=True,
          )
  
          bias_lr_per_sample = [
              v * bias_lr_mult for v in cfg["CNTK"].LR_PER_SAMPLE
          ]
          bias_lr_schedule = learning_parameter_schedule_per_sample(
              bias_lr_per_sample
          )
          bias_learner = momentum_sgd(
              biases,
              bias_lr_schedule,
              mm_schedule,
              l2_regularization_weight=l2_reg_weight,
              unit_gain=False,
              use_mean_gradient=True,
          )
          trainer = Trainer(
              None, (loss, pred_error), [learner, bias_learner]
          )
  
          # Get minibatches of images and perform model training
          print("Training model for %s epochs." % epochs_to_train)
          log_number_of_parameters(loss)
  
          # Create the minibatch source
          if cfg.USE_PRECOMPUTED_PROPOSALS:
              proposal_provider = ProposalProvider.fromfile(
                  cfg["DATA"].TRAIN_PRECOMPUTED_PROPOSALS_FILE,
                  cfg.NUM_ROI_PROPOSALS,
              )
          else:
              proposal_provider = ProposalProvider.fromconfig(cfg)
  
          od_minibatch_source = ObjectDetectionMinibatchSource(
              cfg["DATA"].TRAIN_MAP_FILE,
              cfg["DATA"].TRAIN_ROI_FILE,
              max_annotations_per_image=cfg.INPUT_ROIS_PER_IMAGE,
              pad_width=cfg.IMAGE_WIDTH,
              pad_height=cfg.IMAGE_HEIGHT,
              pad_value=cfg["MODEL"].IMG_PAD_COLOR,
              randomize=True,
              use_flipping=cfg["TRAIN"].USE_FLIPPED,
              max_images=cfg["DATA"].NUM_TRAIN_IMAGES,
              num_classes=cfg["DATA"].NUM_CLASSES,
              proposal_provider=proposal_provider,
              provide_targets=True,
              proposal_iou_threshold=cfg.BBOX_THRESH,
              normalize_means=None
              if not cfg.BBOX_NORMALIZE_TARGETS
              else cfg.BBOX_NORMALIZE_MEANS,
              normalize_stds=None
              if not cfg.BBOX_NORMALIZE_TARGETS
              else cfg.BBOX_NORMALIZE_STDS,
          )
  
          # define mapping from reader streams to network inputs
          input_map = {
              od_minibatch_source.image_si: image_input,
              od_minibatch_source.proposals_si: roi_proposals,
              od_minibatch_source.label_targets_si: label_targets,
              od_minibatch_source.bbox_targets_si: bbox_targets,
              od_minibatch_source.bbiw_si: bbox_inside_weights,
          }
  
          progress_printer = ProgressPrinter(
              tag="Training",
              num_epochs=epochs_to_train,
              gen_heartbeat=True,
          )
          for epoch in range(epochs_to_train):  # loop over epochs
              sample_count = 0
              while (
                  sample_count < cfg["DATA"].NUM_TRAIN_IMAGES
              ):  # loop over minibatches in the epoch
                  data = od_minibatch_source.next_minibatch(
                      min(
                          cfg.MB_SIZE,
                          cfg["DATA"].NUM_TRAIN_IMAGES - sample_count,
                      ),
                      input_map=input_map,
                  )
  
                  trainer.train_minibatch(data)  # update model with it
                  sample_count += (
                      trainer.previous_minibatch_sample_count
                  )  # count samples processed so far
                  progress_printer.update_with_trainer(
                      trainer, with_metric=True
                  )  # log progress
                  if sample_count % 100 == 0:
                      print("Processed {} samples".format(sample_count))
  
              progress_printer.epoch_summary(with_metric=True)
  
          eval_model = create_fast_rcnn_eval_model(
              loss, image_input, roi_proposals, cfg
          )
          eval_model.save(cfg["MODEL_PATH"])
          return eval_model
  
imports: from __future__ import print_function
  import numpy
  import os, sys
  import argparse
  import easydict
  import cntk
  from cntk import Trainer, load_model, Axis, input_variable, parameter, times, combine, softmax, roipooling, plus, element_times, CloneMethod, alias, Communicator, reduce_sum
  from cntk.core import Value
  from cntk.initializer import normal
  from cntk.layers import placeholder, Constant, Sequential
  from cntk.learners import momentum_sgd, learning_parameter_schedule_per_sample, momentum_schedule
  from cntk.logging import log_number_of_parameters, ProgressPrinter
  from cntk.logging.graph import find_by_name, plot
  from cntk.losses import cross_entropy_with_softmax
  from cntk.metrics import classification_error
  from _cntk_py import force_deterministic_algorithms
  from utils.rpn.cntk_smoothL1_loss import SmoothL1Loss
  from utils.annotations.annotations_helper import parse_class_map_file
  from utils.od_mb_source import ObjectDetectionMinibatchSource
  from utils.proposal_helpers import ProposalProvider
label_desc: Use image node_id 9 for calling a global function with example usage: train_fast_rcnn(cfg) and returns: load_model, eval_model