text: import argparse
  import os
  
  import torch
  import torchvision
  import torchvision.transforms as transforms
  import torch.optim as optim
  from models_cliu import *
  from models import *
  from utils import progress_bar
  import matplotlib.pyplot as plt
  
  parser = argparse.ArgumentParser(description='Pytorch CIFAR10 Training - cliu implementation')
  parser.add_argument('--lr', default=0.1, type=float, help='learning rate')
  parser.add_argument('--resume', '-r', action = 'store_true')
  args = parser.parse_args()
  
  device = 'cuda' if torch.cuda.is_available() else 'cpu'
  best_acc = 0
  start_epoch = 0
  
  #
  print('==> Preparing data..')
  transforms_train = transforms.Compose([
      transforms.RandomCrop(32, padding=4),
      transforms.RandomHorizontalFlip(),
      transforms.ToTensor(),
      transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
                                        ]
  )
  
  transform_test = transforms.Compose([
      transforms.ToTensor(),
      transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
  ])
  
  
  
  trainset = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transforms_train, download=True)
  testset = torchvision.datasets.CIFAR10(root='./data', train=False, transform=transform_test, download=True)
  trainloader = torch.utils.data.DataLoader(
      trainset, batch_size=128, shuffle=True, num_workers=2)
  testloader = torch.utils.data.DataLoader(
      testset, batch_size=100, shuffle=False, num_workers=2)
  classes = ('plane', 'car', 'bird', 'cat', 'deer',
             'dog', 'frog', 'horse', 'ship', 'truck')
  
  #net = LeNetReimpl()
  #net = VGG_reimpl(vgg_name='VGG11')
  #net = VGG(vgg_name='VGG19')
  #net = GoogleNetReimpl()
  #net = ResNet50Reimpl()
  net = MobileNetReimpl()
  
  net = net.to(device)
  pytorch_total_params = sum(p.numel() for p in net.parameters())
  print('Number of Parameters: ' + str(pytorch_total_params))
  
  if args.resume:
      # Load checkpoint.
      print('==> Resuming from checkpoint..')
      assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'
      checkpoint = torch.load('./checkpoint/ckpt_vgg_reimpl.pth')
      net.load_state_dict(checkpoint['net'])
      best_acc = checkpoint['acc']
      start_epoch = checkpoint['epoch']
  
  criterion = nn.CrossEntropyLoss()
  optimizer = optim.SGD(net.parameters(), lr=args.lr)
  scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
  
  
  # Training
  def train(epoch):
      print('\nEpoch: %d' % epoch)
      net.train()
      train_loss = 0
      correct = 0
      total = 0
      for batch_idx, (inputs, targets) in enumerate(trainloader):
          inputs, targets = inputs.to(device), targets.to(device)
          optimizer.zero_grad()
          outputs = net(inputs)
          loss = criterion(outputs, targets)
          loss.backward()
          optimizer.step()
          train_loss += loss.item()
          _, predicted = outputs.max(1)
          total += targets.size(0)
          correct += predicted.eq(targets).sum().item()
  
          progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
                       % (train_loss / (batch_idx + 1), 100. * correct / total, correct, total))
  
  # test/eval
  def test(epoch):
      net.eval()
      global best_acc
      net.eval()
      test_loss = 0
      correct = 0
      total = 0
      with torch.no_grad():
          for batch_idx, (inputs, targets) in enumerate(testloader):
              inputs, targets = inputs.to(device), targets.to(device)
              outputs = net(inputs)
              loss = criterion(outputs, targets)
  
              test_loss += loss.item()
              _, predicted = outputs.max(1)
              total += targets.size(0)
              correct += predicted.eq(targets).sum().item()
  
              progress_bar(batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
                           % (test_loss/(batch_idx+1), 100.*correct/total, correct, total))
  
      # Save checkpoint.
      acc = 100.*correct/total
      if acc > best_acc:
          print('Saving..')
          state = {
              'net': net.state_dict(),
              'acc': acc,
              'epoch': epoch,
          }
          if not os.path.isdir('checkpoint'):
              os.mkdir('checkpoint')
          torch.save(state, './checkpoint/ckpt_vgg_reimpl.pth')
          best_acc = acc
  
  lrs = []
  for epoch in range(start_epoch, start_epoch+300):
      train(epoch)
      test(epoch)
      scheduler.step()
      lrs.append(optimizer.param_groups[0]["lr"])
  
  plt.plot(lrs)
  plt.savefig('./checkpoint/lr_scheduler.png')