def connect(self): self.ip = str( self.ipInput.text()) if self.ipInput.text() else '127.0.0.1' self.port = int(self.portInput.text()) if self.portInput.text() else 21 self.username = str( self.userInput.text()) if self.userInput.text() else 'anonymous' self.password = str(self.passInput.text()) self.q_info.put( utils.colorful( 'Connecting to ' + self.ip + ':' + str(self.port) + '...', 'black')) self.q_cmd.put('connect') self.q_cmd.put(self.ip) self.q_cmd.put(self.port) if not self.parentPipe.recv() == 'connected': self.q_info.put(utils.colorful('connect error.', 'red')) return self.connected = True self.q_info.put(utils.colorful('Log in as ' + self.username, 'black')) self.q_cmd.put('login') self.q_cmd.put(self.username) self.q_cmd.put(self.password) if not self.parentPipe.recv() == 'ok': return self.q_cmd.put('list')
def get_instance_dataloader(args): minimum_crop = 0.2 logging.info(colorful('ResizedCrop from {} to 1'.format(minimum_crop))) if args.blur: train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(minimum_crop, 1.)), transforms.RandomApply( [ transforms.ColorJitter(0.4, 0.4, 0.4, 0.1) # not strengthened ], p=0.8), transforms.RandomGrayscale(p=0.2), transforms.RandomApply([GaussianBlur([.1, 2.])], p=0.5), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) else: train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(minimum_crop, 1.)), transforms.RandomGrayscale(p=0.2), transforms.ColorJitter(0.4, 0.4, 0.4, 0.4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) val_transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) train_dataset = ImageNetInstance(train=True, image_transforms=train_transforms, imagenet_dir=IMAGENET_DIR if args.dataset == 'imagenet' else HUN_IMAGENET_DIR) val_dataset = ImageNetInstance(train=False, image_transforms=val_transforms, imagenet_dir=IMAGENET_DIR if args.dataset == 'imagenet' else HUN_IMAGENET_DIR) train_samples = train_dataset.dataset.samples train_labels = [train_samples[i][1] for i in range(len(train_samples))] train_ordered_labels = np.array(train_labels) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, pin_memory=True, num_workers=args.n_workers) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=args.n_workers) return train_loader, val_loader, train_ordered_labels, train_dataset, val_dataset
def disconnect(self): if not self.connected: return self.q_info.put( utils.colorful( 'Disonnected from ' + self.ip + ':' + str(self.port), 'black')) self.q_cmd.put('quit') self.connected = False
def __init__(self, block, num_blocks, low_dim=128, dropout=False, non_linear_head=False, mlpbn=False, bnaffine=True): super(ResNet, self).__init__() self.in_planes = 64 self.dropout = dropout self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) # self.linear = nn.Linear(512*block.expansion, 128) if not non_linear_head: self.linear = nn.Linear(512 * block.expansion, low_dim) else: logging.info(colorful('Using Non Linear Head')) if mlpbn: logging.info('Using BatchNorm in MLP head projection') self.linear = nn.Sequential( nn.Linear(512 * block.expansion, 512 * block.expansion), nn.BatchNorm1d(512 * block.expansion, affine=bnaffine), nn.ReLU(inplace=True), nn.Linear(512 * block.expansion, low_dim), ) else: logging.info('Not Using BatchNorm in MLP head projection') self.linear = nn.Sequential( nn.Linear(512 * block.expansion, 512 * block.expansion), nn.ReLU(inplace=True), nn.Linear(512 * block.expansion, low_dim), ) if self.dropout: self.dropout_layer = nn.Dropout(p=0.5) for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, nn.Linear): nn.init.xavier_uniform_(m.weight) nn.init.constant_(m.bias, 0) elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0)
def login(self, username='******', password=''): if self.q_info: self.q_info.put(utils.colorful('USER ' + username, 'purple')) self.sock.send(('USER ' + username + '\r\n').encode()) res = self.__recv() if res.startswith('331'): if self.q_info: self.q_info.put(utils.colorful('PASS ' + password, 'purple')) self.sock.send(('PASS ' + password + '\r\n').encode()) res = self.__recv() if self.pipe and res.startswith('230'): self.pipe.send('ok') elif self.pipe: self.pipe.send('error') else: if self.pipe: self.pipe.send('error') return res
def __send_port(self): self.ip = '127.0.0.1' self.port = random.randint(20000, 65536) portstring = ','.join(self.ip.split('.')) + ',' + str(self.port // 256) + ',' + str(self.port % 256) if self.q_info: self.q_info.put(utils.colorful('PORT ' + portstring, 'purple')) self.sock.send(('PORT ' + portstring + '\r\n').encode()) res = self.__recv() return res
def __send_pasv(self): if self.q_info: self.q_info.put(utils.colorful('PASV', 'purple')) self.sock.send(('PASV' + '\r\n').encode()) res = self.__recv() if res.startswith('227 '): raw = re.search('([0-9]{1,3},){5}[0-9]{1,3}', res) raw = raw.group(0) numl = raw.split(',') self.ip = '.'.join(numl[:4]) self.port = int(numl[4]) * 256 + int(numl[5]) return res
def __init__(self, block, num_blocks, low_dim=128, dropout=False, non_linear_head=False, mlpbn=False): super(ResNet, self).__init__() self.in_planes = 64 self.dropout = dropout self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) # self.linear = nn.Linear(512*block.expansion, 128) if not non_linear_head: self.linear = nn.Linear(512 * block.expansion, low_dim) else: logging.info(colorful('Using Non Linear Head')) if mlpbn: self.linear = nn.Sequential( nn.Linear(512 * block.expansion, 512 * block.expansion), nn.BatchNorm1d(512 * block.expansion), nn.ReLU(inplace=True), nn.Linear(512 * block.expansion, low_dim), ) else: self.linear = nn.Sequential( nn.Linear(512 * block.expansion, 512 * block.expansion), nn.ReLU(inplace=True), nn.Linear(512 * block.expansion, low_dim), ) if self.dropout: self.dropout_layer = nn.Dropout(p=0.5)
def __send_stor(self, filename, currentDir, currentNumber): if self.q_info: self.q_info.put(utils.colorful('STOR ' + filename, 'purple')) self.sock.send(('STOR ' + filename + '\r\n').encode()) sockf = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self.pasv: sockf.connect((self.ip, self.port)) res = self.__recv() if not res.startswith('150'): return th = threading.Thread(target=self.__storfile, args=(currentDir, filename, currentNumber, sockf)) th.start() else: sockf.bind(('0.0.0.0', self.port)) sockf.listen(1) self.__recv() if not res.startswith('150'): return conn, addr = sockf.accept() th = threading.Thread(target=self.__storfile, args=(currentDir, filename, currentDir, conn, sockf)) th.start()
def __send_list(self): if self.q_info: self.q_info.put(utils.colorful('LIST', 'purple')) self.sock.send(('LIST' + '\r\n').encode()) sockf = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self.pasv: sockf.connect((self.ip, self.port)) res = self.__recv() if not res.startswith('150'): return dirinfo = '' while True: res = sockf.recv(self.size).decode() if not res: break dirinfo = dirinfo + res else: sockf.bind(('0.0.0.0', self.port)) sockf.listen(1) res = self.__recv() if not res.startswith('150'): return conn, addr = sockf.accept() dirinfo = '' with conn: while True: res = conn.recv(self.size) if not res: break dirinfo = dirinfo + res if self.q_dir2: self.q_dir2.put(dirinfo) res = self.__recv() sockf.close() return res
def get_semi_dataloader(args): minimum_crop = 0.08 logging.info(colorful('ResizedCrop from {} to 1'.format(minimum_crop))) train_transforms = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(minimum_crop, 1.)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) val_transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) train_dataset = listData.ListData(os.path.join(IMAGENET_DIR, 'train'), args.list, transforms=train_transforms) val_dataset = datasets.ImageFolder(os.path.join(IMAGENET_DIR, 'val'), val_transforms) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, pin_memory=True, num_workers=args.n_workers) val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=args.n_workers) return train_loader, val_loader
# 定义推理输出路径 output_dir = "test_output_20190221_2" inference_out_path = os.path.join(inference_output_path_base,output_dir) if not os.path.exists(inference_out_path): os.makedirs(inference_out_path) for i in range(len(names)): name = names[i] image_path = os.path.join(img_path_test, name) image_bgr = cv2.imread(image_path,1) image_bgr = cv2.resize(image_bgr,(img_cols,img_rows),interpolation=cv2.INTER_CUBIC) image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) x_test = np.empty((1, img_rows, img_cols, 3), dtype=np.float32) x_test[0, :, :, 0:3] = image_bgr/255.0 out = pspnet50_model.predict(x_test) out = np.reshape(out, (img_rows, img_cols, num_classes)) out = np.argmax(out, axis=2) result_rgb = colorful(out) # 同时展示原图/预测结果/预测结果叠加原图,并保存 vis_seg_save_path = os.path.join(inference_out_path,name.split('.')[0]+"_predict_compare.png") vis_segmentation(image_rgb,result_rgb,vis_seg_save_path) print("generating: {}".format(vis_seg_save_path)) K.clear_session()
def __init__(self, block, layers, low_dim=128, in_channel=3, width=1, non_linear_head=False, mlpbn=False): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(in_channel, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.base = int(64 * width) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, self.base, layers[0]) self.layer2 = self._make_layer(block, self.base * 2, layers[1], stride=2) self.layer3 = self._make_layer(block, self.base * 4, layers[2], stride=2) self.layer4 = self._make_layer(block, self.base * 8, layers[3], stride=2) self.avgpool = nn.AvgPool2d(7, stride=1) print(non_linear_head) if not non_linear_head: self.fc = nn.Linear(self.base * 8 * block.expansion, low_dim) else: logging.info(colorful('Using Non Linear Head')) if mlpbn: self.fc = nn.Sequential( nn.Linear(self.base * 8 * block.expansion, self.base * 8 * block.expansion), nn.BatchNorm1d(self.base * 8 * block.expansion), nn.ReLU(inplace=True), nn.Linear(self.base * 8 * block.expansion, low_dim), ) else: self.fc = nn.Sequential( nn.Linear(self.base * 8 * block.expansion, self.base * 8 * block.expansion), nn.ReLU(inplace=True), nn.Linear(self.base * 8 * block.expansion, low_dim), ) for m in self.modules(): #if isinstance(m, nn.Conv2d): #n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels #m.weight.data.normal_(0, math.sqrt(2. / n)) #elif isinstance(m, nn.BatchNorm2d): #m.weight.data.fill_(1) #m.bias.data.zero_() if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, nn.Linear): nn.init.xavier_uniform_(m.weight) nn.init.constant_(m.bias, 0) elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0)
if 19968 <= ord(char) <= 40869: return 'en' return 'zh' headers = [ ['google', '谷歌'], ['youdao', '有道'], ['baidu', '百度'], ['deepl', 'deepl'], ['tencent', '腾讯'], ['alibaba', '阿里巴巴'], ['sogou', '搜狗'], ] word = ' '.join(argv[1:]).strip() lang = to_language(word) width = max([wcswidth(e[1]) for e in headers]) print() print(colorful(word, 'magenta')) print() for [k, col] in headers: Thread(target=lambda col: print( colorful(col.ljust(width - wcswidth(col) + len(col)), 'green') + ': ' + colorful( silence(lambda: getattr(translators, k) (word, to_language=lang), ''), 'red')), args=(col, )).start()
def __send_quit(self): if self.q_info: self.q_info.put(utils.colorful('QUIT', 'purple')) self.sock.send(('QUIT' + '\r\n').encode()) res = self.__recv() return res
def __send_rnto(self, name_new): if self.q_info: self.q_info.put(utils.colorful('RNTO ' + name_new, 'purple')) self.sock.send(('RNTO ' + name_new + '\r\n').encode()) res = self.__recv() return res
def __send_rnfr(self, name_old): if self.q_info: self.q_info.put(utils.colorful('RNFR ' + name_old, 'purple')) self.sock.send(('RNFR ' + name_old + '\r\n').encode()) res = self.__recv() return res
def __send_type(self, t='I'): if self.q_info: self.q_info.put(utils.colorful('TYPE ' + t, 'purple')) self.sock.send(('TYPE ' + t + '\r\n').encode()) res = self.__recv() return res
'summary': e.get('summary', ''), }) return (rows, cfg) if __name__ == '__main__': from sys import argv type = None query = None opts = {} opts['filters'] = [] if '-h' in argv: print('打开文档:doc.py :{type} [::{opt}...] [@{filter}...]') print(f' {colorful("type", "red")}: ') for type in Query.get_types(): print(' ' + colorful(type, 'green')) print(' Example: doc.py :mdn ::zh @http headers') exit(0) for arg in argv[1:]: if arg.startswith('::'): opts[arg[2:]] = True elif arg.startswith(':'): type = arg[1:] elif arg.startswith('@'): opts['filters'].append(arg[1:]) else: query = arg q = Query() q.query(type, query, opts)
def main(): global best_acc1 best_acc1 = 0 args = parse_option() if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) # set the data loader train_folder = os.path.join(args.data_folder, 'train') val_folder = os.path.join(args.data_folder, 'val') logger = getLogger(args.save_folder) if args.dataset.startswith('imagenet') or args.dataset.startswith( 'places'): image_size = 224 crop_padding = 32 mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] normalize = transforms.Normalize(mean=mean, std=std) if args.aug == 'NULL': train_transform = transforms.Compose([ transforms.RandomResizedCrop(image_size, scale=(args.crop, 1.)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) elif args.aug == 'CJ': train_transform = transforms.Compose([ transforms.RandomResizedCrop(image_size, scale=(args.crop, 1.)), transforms.RandomGrayscale(p=0.2), transforms.ColorJitter(0.4, 0.4, 0.4, 0.4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) else: raise NotImplemented('augmentation not supported: {}'.format( args.aug)) val_transform = transforms.Compose([ transforms.Resize(image_size + crop_padding), transforms.CenterCrop(image_size), transforms.ToTensor(), normalize, ]) if args.dataset.startswith('imagenet'): train_dataset = datasets.ImageFolder(train_folder, train_transform) val_dataset = datasets.ImageFolder( val_folder, val_transform, ) if args.dataset.startswith('places'): train_dataset = ImageList( '/data/trainvalsplit_places205/train_places205.csv', '/data/data/vision/torralba/deeplearning/images256', transform=train_transform, symbol_split=' ') val_dataset = ImageList( '/data/trainvalsplit_places205/val_places205.csv', '/data/data/vision/torralba/deeplearning/images256', transform=val_transform, symbol_split=' ') print(len(train_dataset)) train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.n_workers, pin_memory=False, sampler=train_sampler) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.n_workers, pin_memory=False) elif args.dataset.startswith('cifar'): train_loader, val_loader = cifar.get_linear_dataloader(args) elif args.dataset.startswith('svhn'): train_loader, val_loader = svhn.get_linear_dataloader(args) # create model and optimizer if args.model == 'alexnet': if args.layer == 6: args.layer = 5 model = AlexNet(128) model = nn.DataParallel(model) classifier = LinearClassifierAlexNet(args.layer, args.n_label, 'avg') elif args.model == 'alexnet_cifar': if args.layer == 6: args.layer = 5 model = AlexNet_cifar(128) model = nn.DataParallel(model) classifier = LinearClassifierAlexNet(args.layer, args.n_label, 'avg', cifar=True) elif args.model == 'resnet50': model = resnet50(non_linear_head=False) model = nn.DataParallel(model) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 1) elif args.model == 'resnet18': model = resnet18() model = nn.DataParallel(model) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 1, bottleneck=False) elif args.model == 'resnet18_cifar': model = resnet18_cifar() model = nn.DataParallel(model) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 1, bottleneck=False) elif args.model == 'resnet50_cifar': model = resnet50_cifar() model = nn.DataParallel(model) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 1) elif args.model == 'resnet50x2': model = InsResNet50(width=2) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 2) elif args.model == 'resnet50x4': model = InsResNet50(width=4) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 4) elif args.model == 'shufflenet': model = shufflenet_v2_x1_0(num_classes=128, non_linear_head=False) model = nn.DataParallel(model) classifier = LinearClassifierResNet(args.layer, args.n_label, 'avg', 0.5) else: raise NotImplementedError('model not supported {}'.format(args.model)) print('==> loading pre-trained model') ckpt = torch.load(args.model_path) if not args.moco: model.load_state_dict(ckpt['state_dict']) else: try: state_dict = ckpt['state_dict'] for k in list(state_dict.keys()): # retain only encoder_q up to before the embedding layer if k.startswith('module.encoder_q' ) and not k.startswith('module.encoder_q.fc'): # remove prefix state_dict['module.' + k[len("module.encoder_q."):]] = state_dict[k] # delete renamed or unused k del state_dict[k] model.load_state_dict(state_dict) except: pass print("==> loaded checkpoint '{}' (epoch {})".format( args.model_path, ckpt['epoch'])) print('==> done') model = model.cuda() classifier = classifier.cuda() criterion = torch.nn.CrossEntropyLoss().cuda(args.gpu) if not args.adam: optimizer = torch.optim.SGD(classifier.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam(classifier.parameters(), lr=args.learning_rate, betas=(args.beta1, args.beta2), weight_decay=args.weight_decay, eps=1e-8) model.eval() cudnn.benchmark = True # optionally resume from a checkpoint args.start_epoch = 1 if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume, map_location='cpu') # checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] + 1 classifier.load_state_dict(checkpoint['classifier']) optimizer.load_state_dict(checkpoint['optimizer']) best_acc1 = checkpoint['best_acc1'] print(best_acc1.item()) best_acc1 = best_acc1.cuda() print("=> loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) if 'opt' in checkpoint.keys(): # resume optimization hyper-parameters print('=> resume hyper parameters') if 'bn' in vars(checkpoint['opt']): print('using bn: ', checkpoint['opt'].bn) if 'adam' in vars(checkpoint['opt']): print('using adam: ', checkpoint['opt'].adam) #args.learning_rate = checkpoint['opt'].learning_rate # args.lr_decay_epochs = checkpoint['opt'].lr_decay_epochs args.lr_decay_rate = checkpoint['opt'].lr_decay_rate args.momentum = checkpoint['opt'].momentum args.weight_decay = checkpoint['opt'].weight_decay args.beta1 = checkpoint['opt'].beta1 args.beta2 = checkpoint['opt'].beta2 del checkpoint torch.cuda.empty_cache() else: print("=> no checkpoint found at '{}'".format(args.resume)) # tensorboard tblogger = tb_logger.Logger(logdir=args.tb_folder, flush_secs=2) # routine best_acc = 0.0 for epoch in range(args.start_epoch, args.epochs + 1): adjust_learning_rate(epoch, args, optimizer) print("==> training...") time1 = time.time() train_acc, train_acc5, train_loss = train(epoch, train_loader, model, classifier, criterion, optimizer, args) time2 = time.time() logging.info('train epoch {}, total time {:.2f}'.format( epoch, time2 - time1)) logging.info( 'Epoch: {}, lr:{} , train_loss: {:.4f}, train_acc: {:.4f}/{:.4f}'. format(epoch, optimizer.param_groups[0]['lr'], train_loss, train_acc, train_acc5)) tblogger.log_value('train_acc', train_acc, epoch) tblogger.log_value('train_acc5', train_acc5, epoch) tblogger.log_value('train_loss', train_loss, epoch) tblogger.log_value('learning_rate', optimizer.param_groups[0]['lr'], epoch) test_acc, test_acc5, test_loss = validate(val_loader, model, classifier, criterion, args) if test_acc >= best_acc: best_acc = test_acc logging.info( colorful( 'Epoch: {}, val_loss: {:.4f}, val_acc: {:.4f}/{:.4f}, best_acc: {:.4f}' .format(epoch, test_loss, test_acc, test_acc5, best_acc))) tblogger.log_value('test_acc', test_acc, epoch) tblogger.log_value('test_acc5', test_acc5, epoch) tblogger.log_value('test_loss', test_loss, epoch) # save the best model if test_acc > best_acc1: best_acc1 = test_acc state = { 'opt': args, 'epoch': epoch, 'classifier': classifier.state_dict(), 'best_acc1': best_acc1, 'optimizer': optimizer.state_dict(), } save_name = '{}_layer{}.pth'.format(args.model, args.layer) save_name = os.path.join(args.save_folder, save_name) print('saving best model!') torch.save(state, save_name) # save model if epoch % args.save_freq == 0: print('==> Saving...') state = { 'opt': args, 'epoch': epoch, 'classifier': classifier.state_dict(), 'best_acc1': test_acc, 'optimizer': optimizer.state_dict(), } save_name = 'ckpt_epoch_{epoch}.pth'.format(epoch=epoch) save_name = os.path.join(args.save_folder, save_name) print('saving regular model!') torch.save(state, save_name) # tensorboard logger pass
def __send_rmd(self, dirname): if self.q_info: self.q_info.put(utils.colorful('RMD ' + dirname, 'purple')) self.sock.send(('RMD ' + dirname + '\r\n').encode()) res = self.__recv() return res