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=10,
          metavar="N",
          help="number of epochs to train (default: 10)",
      )
      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",
      )
      args = parser.parse_args()
  
      # Connecting ClearML with the current process,
      # from here on everything is logged automatically
      task = Task.init(
          project_name="examples", task_name="PyTorch with TensorBoard"
      )  # noqa: F841
  
      writer = SummaryWriter("runs")
      writer.add_text("TEXT", "This is some text", 0)
      args.cuda = not args.no_cuda and torch.cuda.is_available()
  
      torch.manual_seed(args.seed)
      if args.cuda:
          torch.cuda.manual_seed(args.seed)
  
      kwargs = (
          {"num_workers": 4, "pin_memory": True} if args.cuda else {}
      )
      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()
      if args.cuda:
          model.cuda()
      optimizer = optim.SGD(
          model.parameters(), lr=args.lr, momentum=args.momentum
      )
  
      for epoch in range(1, args.epochs + 1):
          train(model, epoch, train_loader, args, optimizer, writer)
          m = torch.jit.script(model)
          m.save(os.path.join(gettempdir(), "model{}".format(epoch)))
          # torch.save(model, os.path.join(gettempdir(), 'model{}'.format(epoch)))
      test(model, test_loader, args, optimizer, writer)
  
file_path: clearml/examples/frameworks/pytorch/pytorch_tensorboard.py
imports: from __future__ import print_function
  import argparse
  import os
  from tempfile import gettempdir
  import torch
  import torch.nn
  import torch.nn.functional
  import torch.optim
  from torchvision import datasets, transforms
  from torch.autograd import Variable
  from torch.utils.tensorboard import SummaryWriter
  from clearml import Task
label_desc: Use image node_id 3 for calling a global function with example usage: main() without return types