code: def train(train_path, val_path, test_path):
      # Initialize the net with pretrained model
      finetune_net = get_model(model_name, pretrained=True)
      with finetune_net.name_scope():
          finetune_net.output = nn.Dense(classes)
      finetune_net.output.initialize(init.Xavier(), ctx=ctx)
      finetune_net.collect_params().reset_ctx(ctx)
      finetune_net.hybridize()
  
      # Define DataLoader
      train_data = gluon.data.DataLoader(
          gluon.data.vision.ImageFolderDataset(
              train_path
          ).transform_first(transform_train),
          batch_size=batch_size,
          shuffle=True,
          num_workers=num_workers,
      )
  
      val_data = gluon.data.DataLoader(
          gluon.data.vision.ImageFolderDataset(
              val_path
          ).transform_first(transform_test),
          batch_size=batch_size,
          shuffle=False,
          num_workers=num_workers,
      )
  
      test_data = gluon.data.DataLoader(
          gluon.data.vision.ImageFolderDataset(
              test_path
          ).transform_first(transform_test),
          batch_size=batch_size,
          shuffle=False,
          num_workers=num_workers,
      )
  
      # Define Trainer
      trainer = gluon.Trainer(
          finetune_net.collect_params(),
          "sgd",
          {"learning_rate": lr, "momentum": momentum, "wd": wd},
      )
      metric = mx.metric.Accuracy()
      L = gluon.loss.SoftmaxCrossEntropyLoss()
      lr_counter = 0
      num_batch = len(train_data)
  
      # Start Training
      for epoch in range(epochs):
          if epoch == lr_steps[lr_counter]:
              trainer.set_learning_rate(
                  trainer.learning_rate * lr_factor
              )
              lr_counter += 1
  
          tic = time.time()
          train_loss = 0
          metric.reset()
  
          for i, batch in enumerate(train_data):
              data = gluon.utils.split_and_load(
                  batch[0], ctx_list=ctx, batch_axis=0, even_split=False
              )
              label = gluon.utils.split_and_load(
                  batch[1], ctx_list=ctx, batch_axis=0, even_split=False
              )
              with ag.record():
                  outputs = [finetune_net(X) for X in data]
                  loss = [L(yhat, y) for yhat, y in zip(outputs, label)]
              for l in loss:
                  l.backward()
  
              trainer.step(batch_size)
              train_loss += sum(
                  [l.mean().asscalar() for l in loss]
              ) / len(loss)
  
              metric.update(label, outputs)
  
          _, train_acc = metric.get()
          train_loss /= num_batch
  
          _, val_acc = test(finetune_net, val_data, ctx)
  
          logging.info(
              "[Epoch %d] Train-acc: %.3f, loss: %.3f | Val-acc: %.3f | time: %.1f"
              % (
                  epoch,
                  train_acc,
                  train_loss,
                  val_acc,
                  time.time() - tic,
              )
          )
  
      _, test_acc = test(finetune_net, test_data, ctx)
      logging.info("[Finished] Test-acc: %.3f" % (test_acc))
  
file_path: gluon-cv/scripts/classification/finetune/finetune_minc.py
imports: import mxnet
  import numpy
  import os, time, logging, argparse, shutil
  from mxnet import gluon, image, init, nd
  from mxnet import autograd
  from mxnet.gluon import nn
  from mxnet.gluon.data.vision import transforms
  import gluoncv
  from gluoncv.utils import makedirs
  from gluoncv.model_zoo import get_model
label_desc: Use image node_id 3 for calling a global function with example usage: train(train_path, val_path, test_path) without return types