text: import os
  import sys
  import numpy as np
  import torch
  import utils
  import glob
  import random
  import logging
  import argparse
  import torch.nn as nn
  import genotypes
  import torch.utils
  import torchvision.datasets as dset
  import torchvision.transforms as transforms
  import torch.backends.cudnn as cudnn
  
  from torch.autograd import Variable
  from model import NetworkImageNet as Network
  
  parser = argparse.ArgumentParser("imagenet")
  parser.add_argument('--data', type=str, default='../data/imagenet/', help='location of the data corpus')
  parser.add_argument('--batch_size', type=int, default=128, help='batch size')
  parser.add_argument('--report_freq', type=float, default=100, help='report frequency')
  parser.add_argument('--gpu', type=int, default=0, help='gpu device id')
  parser.add_argument('--init_channels', type=int, default=48, help='num of init channels')
  parser.add_argument('--layers', type=int, default=14, help='total number of layers')
  parser.add_argument('--model_path', type=str, default='EXP/model.pt', help='path of pretrained model')
  parser.add_argument('--auxiliary', action='store_true', default=False, help='use auxiliary tower')
  parser.add_argument('--drop_path_prob', type=float, default=0, help='drop path probability')
  parser.add_argument('--seed', type=int, default=0, help='random seed')
  parser.add_argument('--arch', type=str, default='DARTS', help='which architecture to use')
  args = parser.parse_args()
  
  log_format = '%(asctime)s %(message)s'
  logging.basicConfig(stream=sys.stdout, level=logging.INFO,
                      format=log_format, datefmt='%m/%d %I:%M:%S %p')
  
  CLASSES = 1000
  
  
  def main():
      if not torch.cuda.is_available():
          logging.info('no gpu device available')
          sys.exit(1)
  
      np.random.seed(args.seed)
      torch.cuda.set_device(args.gpu)
      cudnn.benchmark = True
      torch.manual_seed(args.seed)
      cudnn.enabled = True
      torch.cuda.manual_seed(args.seed)
      logging.info('gpu device = %d' % args.gpu)
      logging.info("args = %s", args)
  
      genotype = eval("genotypes.%s" % args.arch)
      model = Network(args.init_channels, CLASSES, args.layers, args.auxiliary, genotype)
      model = model.cuda()
      model.load_state_dict(torch.load(args.model_path)['state_dict'])
  
      logging.info("param size = %fMB", utils.count_parameters_in_MB(model))
  
      criterion = nn.CrossEntropyLoss()
      criterion = criterion.cuda()
  
      validdir = os.path.join(args.data, 'val')
      normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
      valid_data = dset.ImageFolder(
          validdir,
          transforms.Compose([
              transforms.Resize(256),
              transforms.CenterCrop(224),
              transforms.ToTensor(),
              normalize,
          ]))
  
      valid_queue = torch.utils.data.DataLoader(
          valid_data, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=4)
  
      model.drop_path_prob = args.drop_path_prob
      valid_acc_top1, valid_acc_top5, valid_obj = infer(valid_queue, model, criterion)
      logging.info('valid_acc_top1 %f', valid_acc_top1)
      logging.info('valid_acc_top5 %f', valid_acc_top5)
  
  
  def infer(valid_queue, model, criterion):
      objs = utils.AvgrageMeter()
      top1 = utils.AvgrageMeter()
      top5 = utils.AvgrageMeter()
      model.eval()
  
      for step, (input, target) in enumerate(valid_queue):
          input = Variable(input, volatile=True).cuda()
          target = Variable(target, volatile=True).cuda(async=True)
  
          logits, _ = model(input)
          loss = criterion(logits, target)
  
          prec1, prec5 = utils.accuracy(logits, target, topk=(1, 5))
          n = input.size(0)
          objs.update(loss.data[0], n)
          top1.update(prec1.data[0], n)
          top5.update(prec5.data[0], n)
  
          if step % args.report_freq == 0:
              logging.info('valid %03d %e %f %f', step, objs.avg, top1.avg, top5.avg)
  
      return top1.avg, top5.avg, objs.avg
  
  
  if __name__ == '__main__':
      main()
  