code: def train_sequence_classifier():
      input_dim = 2000
      hidden_dim = 25
      embedding_dim = 50
      num_classes = 5
  
      # Input variables denoting the features and label data
      features = C.sequence.input_variable(
          shape=input_dim, is_sparse=True
      )
      label = C.input_variable(num_classes)
  
      # Instantiate the sequence classification model
      classifier_output = lstm_sequence_classifier(
          features, num_classes, embedding_dim, hidden_dim
      )
  
      ce = C.cross_entropy_with_softmax(classifier_output, label)
      pe = C.classification_error(classifier_output, label)
  
      rel_path = r"../../../../Tests/EndToEndTests/Text/SequenceClassification/Data/Train.ctf"
      path = os.path.join(
          os.path.dirname(os.path.abspath(__file__)), rel_path
      )
  
      reader = create_reader(path, True, input_dim, num_classes)
  
      input_map = {
          features: reader.streams.features,
          label: reader.streams.labels,
      }
  
      lr_per_sample = C.learning_parameter_schedule_per_sample(0.1)
  
      # Instantiate the trainer object to drive the model training
      progress_printer = C.logging.ProgressPrinter(0)
      trainer = C.Trainer(
          classifier_output,
          (ce, pe),
          C.sgd(classifier_output.parameters, lr=lr_per_sample),
          progress_printer,
      )
  
      # Get minibatches of sequences to train with and perform model training
      minibatch_size = 200
  
      for i in range(251):
          mb = reader.next_minibatch(
              minibatch_size, input_map=input_map
          )
          trainer.train_minibatch(mb)
  
      evaluation_average = copy.copy(
          trainer.previous_minibatch_evaluation_average
      )
      loss_average = copy.copy(trainer.previous_minibatch_loss_average)
  
      return evaluation_average, loss_average
  
imports: import os
  import cntk
  import copy
label_desc: Use image node_id 3 for calling a global function with example usage: train_sequence_classifier() and returns: evaluation_average,  loss_average