code: def main():
      # Training settings
      parser = argparse.ArgumentParser(
          description="PyTorch MNIST Example"
      )
      parser.add_argument(
          "--batch-size",
          type=int,
          default=64,
          metavar="N",
          help="input batch size for training (default: 64)",
      )
      parser.add_argument(
          "--test-batch-size",
          type=int,
          default=1000,
          metavar="N",
          help="input batch size for testing (default: 1000)",
      )
      parser.add_argument(
          "--epochs",
          type=int,
          default=5,
          metavar="N",
          help="number of epochs to train (default: 5)",
      )
      parser.add_argument(
          "--lr",
          type=float,
          default=0.01,
          metavar="LR",
          help="learning rate (default: 0.01)",
      )
      parser.add_argument(
          "--momentum",
          type=float,
          default=0.5,
          metavar="M",
          help="SGD momentum (default: 0.5)",
      )
      parser.add_argument(
          "--no-cuda",
          action="store_true",
          default=False,
          help="disables CUDA training",
      )
      parser.add_argument(
          "--seed",
          type=int,
          default=1,
          metavar="S",
          help="random seed (default: 1)",
      )
      parser.add_argument(
          "--log-interval",
          type=int,
          default=10,
          metavar="N",
          help="how many batches to wait before logging training status",
      )
      parser.add_argument("--output-dir", type=str, default="outputs")
      args = parser.parse_args()
      use_cuda = not args.no_cuda and torch.cuda.is_available()
  
      torch.manual_seed(args.seed)
  
      device = torch.device("cuda" if use_cuda else "cpu")
  
      output_dir = args.output_dir
      os.makedirs(output_dir, exist_ok=True)
  
      kwargs = (
          {"num_workers": 1, "pin_memory": True} if use_cuda else {}
      )
      # Use Azure Open Datasets for MNIST dataset
      datasets.MNIST.resources = [
          (
              "https://azureopendatastorage.azurefd.net/mnist/train-images-idx3-ubyte.gz",
              "f68b3c2dcbeaaa9fbdd348bbdeb94873",
          ),
          (
              "https://azureopendatastorage.azurefd.net/mnist/train-labels-idx1-ubyte.gz",
              "d53e105ee54ea40749a09fcbcd1e9432",
          ),
          (
              "https://azureopendatastorage.azurefd.net/mnist/t10k-images-idx3-ubyte.gz",
              "9fb629c4189551a2d022fa330f9573f3",
          ),
          (
              "https://azureopendatastorage.azurefd.net/mnist/t10k-labels-idx1-ubyte.gz",
              "ec29112dd5afa0611ce80d1b7f02629c",
          ),
      ]
      train_loader = torch.utils.data.DataLoader(
          datasets.MNIST(
              "data",
              train=True,
              download=True,
              transform=transforms.Compose(
                  [
                      transforms.ToTensor(),
                      transforms.Normalize((0.1307,), (0.3081,)),
                  ]
              ),
          ),
          batch_size=args.batch_size,
          shuffle=True,
          **kwargs,
      )
      test_loader = torch.utils.data.DataLoader(
          datasets.MNIST(
              "data",
              train=False,
              transform=transforms.Compose(
                  [
                      transforms.ToTensor(),
                      transforms.Normalize((0.1307,), (0.3081,)),
                  ]
              ),
          ),
          batch_size=args.test_batch_size,
          shuffle=True,
          **kwargs,
      )
  
      model = Net().to(device)
      optimizer = optim.SGD(
          model.parameters(), lr=args.lr, momentum=args.momentum
      )
  
      for epoch in range(1, args.epochs + 1):
          train(
              args,
              model,
              device,
              train_loader,
              optimizer,
              epoch,
              output_dir,
          )
          test(args, model, device, test_loader)
  
      # save model
      dummy_input = torch.randn(1, 1, 28, 28, device=device)
      model_path = os.path.join(output_dir, "mnist.onnx")
      torch.onnx.export(model, dummy_input, model_path)
  
file_path: MachineLearningNotebooks/how-to-use-azureml/deployment/onnx/mnist.py
imports: from __future__ import print_function
  import argparse
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from torchvision import datasets, transforms
  import os
label_desc: Use image node_id 3 for calling a global function with example usage: main() without return types