def __init__(self, model, resume_path='', consistency_iter=3): super(Generator, self).__init__() self.consistency_iter = consistency_iter self.model = model # # VGG Perceptual model # self.p_model = PerceptualModel(resume_path) # self.p_model.eval() # # Mobilefacenet Perceptual model # self.p_model = mobifacenet.MobileFaceNet(1) # pretrained_dict = torch.load('/home/yy/FSGAN/mobilefacenet/model_mobilefacenet.pth') # model_dict = self.p_model.state_dict() # pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} # model_dict.update(pretrained_dict) # self.p_model.load_state_dict(model_dict) # self.p_model.eval() # New VGG arcface self.p_model = vgg.VGG() pretrained_dict = torch.load( './vggface.pth') # Pretrained VGG model is needed here model_dict = self.p_model.state_dict() pretrained_dict = { k: v for k, v in pretrained_dict.items() if k in model_dict } model_dict.update(pretrained_dict) self.p_model.load_state_dict(model_dict) self.p_model.eval()
def make_model(self, is_mask=False): model_list_f, model_list_c, bn, model_list_w = self.make_model_list() print(len(model_list_c)) features = vgg.make_layers(model_list_f, bn, is_mask=is_mask) model_out = vgg.VGG(features, num_classes=10, init_weights=False, cl_n1=model_list_f[-2], cl_n2=model_list_c[0], cl_n3=model_list_c[1], is_mask=is_mask) ii = 0 for name1, pa1 in model_out.named_parameters(): spn1 = name1.split(".") for name2, pa2 in self.vggnet.named_parameters(): spn2 = name2.split(".") if (spn1[0] == spn2[0] and spn1[1] == spn2[1] and spn1[-1] == spn2[-1]): if (len(pa2.size()) > 1): pa1.data.copy_( torch.ones(pa2.data.size()).copy_( pa2.data)[model_list_w[ii + 1]][:, model_list_w[ii]]) else: pa1.data.copy_( torch.ones(pa2.data.size()).copy_( pa2.data)[model_list_w[ii + 1]]) ii += 1 print(pa1.size()) print(pa2.size()) print(name1) return model_out
def __init__(self): super(left_neural_net_dn, self).__init__() for i in range(Config.expert_num): m_name = "dn" + str(i + 1) self.add_module(m_name, nn.Linear(512, Config.num_classes)) self.vgg = vgg.VGG('VGG16') self.features = self.vgg.features self.classifier = self.vgg.classifier
def load_vgg(): vgg = v.VGG() vgg.load_state_dict(torch.load(model_dir + 'vgg_conv.pth')) for param in vgg.parameters(): param.requires_grad = False if torch.cuda.is_available(): vgg.cuda() return vgg
def get_model(args): if args.model == 'resnet18': model = resnet.ResNet18(num_classes=10) elif args.model == 'resnet50': model = resnet.ResNet50(num_classes=10) elif args.model == 'densenet40': model = densenet.DenseNet3(depth=40, num_classes=10) elif args.model == 'vgg16': model = vgg.VGG('VGG16') return model
def main(): """record training process""" global train_writer, validate_writer train_writer = SummaryWriter( comment='_train' + '-dr=' + str(params['dropout_rate']) + '-fc=' + str(params['FC_size']) + '-lr=' + str(params['learning_rate'])) validate_writer = SummaryWriter( comment='_validate' + '-dr=' + str(params['dropout_rate']) + '-fc=' + str(params['FC_size']) + '-lr=' + str(params['learning_rate'])) "load and normalize HCL2000-100 dataset" trans = transforms.Compose([ # transforms.ToPILImage('L'), # 转变成PIL image(灰度图), pixels: 28*28, shape: H*W*C # transforms.Resize((224, 224), Image.ANTIALIAS), # pixels: 224*224, range: [0, 225], shape: H*W*C transforms.ToTensor(), # 转变成Tensor, range: [0, 1.0], shape: C*H*W transforms.Lambda(lambda x: x.sub(0.5).div(0.5)) ]) # 归一化, range: [-1, 1] target_trans = transforms.Lambda(lambda x: x.long()) train_set = ds.HCL(images_path="./HCL2000-100/HCL2000_100_train.npz", labels_path="./HCL2000-100/HCL2000_100_train_label.npz", transform=trans, target_transform=target_trans) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) test_set = ds.HCL(images_path="./HCL2000-100/HCL2000_100_test.npz", labels_path="./HCL2000-100/HCL2000_100_test_label.npz", transform=trans, target_transform=target_trans) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=True) "define the network" net = vgg.VGG('VGG16', 100, params['dropout_rate'], params['FC_size']) # allow parallel compute on multiple GPUs net = nn.DataParallel(net) "define loss function and optimizer" criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=params['learning_rate'], momentum=params['momentum']) "train and validate" for epoch in range(1, epochs + 1): train(log_interval, net, device, train_loader, test_loader, optimizer, criterion, epoch) # validate(net, device, test_loader, criterion, epoch) "test"
def load_vgg(self): ''' Load the saved model parameters of VGG-19, using the input_img as the input to compute the output at each layer of vgg. During training, VGG-19 mean-centered all images and found the mean pixels to be [123.68, 116.779, 103.939] along RGB dimensions. We have to subtract this mean from our images. ''' self.vgg = vgg.VGG(self.input_img) self.vgg.load() self.content_img -= self.vgg.mean_pixels self.style_img -= self.vgg.mean_pixels
def __init__(self): super(left_neural_net_mw, self).__init__() for i in range(Config.expert_num): m_name = "mw" + str(i + 1) self.add_module( m_name, nn.Linear(Config.num_classes, Config.num_classes, bias=False)) self.weights_init() self.vgg = vgg.VGG('VGG16') self.features = self.vgg.features self.classifier = self.vgg.classifier
def vgg19(vgg_path, pretrained=True, **kwargs): """VGG 19-layer model (configuration "E") Args: pretrained (bool): If True, returns a model pre-trained on ImageNet """ if pretrained: kwargs['init_weights'] = False model = vgg.VGG(vgg.make_layers(vgg.cfg['E']), **kwargs) if pretrained: state_dict = torch.load(vgg_path) state_dict = {k:v for k, v in state_dict.items() if 'class' not in k} model.load_state_dict(state_dict) return model
def main(): """load NNI for automated machine learning experiments""" params = nni.get_next_parameter() "record training process" global writer writer = SummaryWriter( comment='-dr=' + str(params['dropout_rate']) + '-fc=' + str(params['FC_size']) + '-bs=' + str(params['batch_size']) + '-lr=' + str(params['learning_rate']) + '-mo=' + str(params['momentum'])) "load and normalize HCL2000-100 dataset" trans = transforms.Compose([ transforms.ToTensor(), # 转变成Tensor, range: [0, 1.0], shape: C*H*W transforms.Lambda(lambda x: x.sub(0.5).div(0.5)) ]) # 归一化, range: [-1, 1] target_trans = transforms.Lambda(lambda x: x.long()) train_set = ds.HCL(images_path="./HCL2000-100/HCL2000_100_train.npz", labels_path="./HCL2000-100/HCL2000_100_train_label.npz", transform=trans, target_transform=target_trans) train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) test_set = ds.HCL(images_path="./HCL2000-100/HCL2000_100_test.npz", labels_path="./HCL2000-100/HCL2000_100_test_label.npz", transform=trans, target_transform=target_trans) test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=True) "define the network" net = vgg.VGG('VGG16', 100, params['dropout_rate'], params['FC_size']) # allow parallel compute on multiple GPUs net = nn.DataParallel(net) "define loss function and optimizer" criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=params['learning_rate'], momentum=params['momentum']) "train and validate" for epoch in range(1, epochs + 1): train(log_interval, net, device, train_loader, test_loader, optimizer, criterion, epoch) nni.report_final_result(best_accuracy)
def __init__(self, confdir='.'): self.label = Labels(join(confdir, 'channels.map'), self.layout[-1]) attr_i = 'x'.join([str(l) for l in self.layout[0]]) attr_c = '_'.join([str(l[0]) for l in self.layout[1]]) attr_f = '_'.join([str(l) for l in self.layout[2]]) attr = '-'.join([ s for s in (attr_i, attr_c, attr_f, str(self.layout[-1])) if len(s) > 0 ]) model_param_path = join(confdir, 'pretrained', 'tvlogo-vgg-%s.npy' % attr) self.model = vgg.VGG(self.layout, model_param_path)
def build_base_model(self): """ @brief builds CNN base model for IIC model @remark ResNet is pretrained ResNet model trained on imageNet """ if self._cnn_base.lower() == 'vgg': return vgg.VGG(vgg.cfg['F'], self._input_shape).model elif self._cnn_base.lower() == 'resnet': assert self._input_shape >= (200, 200, 3), error_msg['ResNetShape'] base_model = keras.applications.ResNet50( weights="imagenet", include_top=False, input_shape=self._input_shape) # only train conv5 block for layer in base_model.layers: if "conv5_" in layer.name: break layer.trainable = False return base_model elif self._cnn_base.lower() == 'test': model = keras.models.Sequential() model.add( keras.layers.Conv2D(32, kernel_size=(5, 5), activation='relu', input_shape=self._input_shape)) model.add(keras.layers.Conv2D(64, (3, 3), activation='relu')) model.add(keras.layers.MaxPooling2D(pool_size=(2, 2))) model.add(keras.layers.Dropout(0.25)) model.add(keras.layers.Conv2D(128, (3, 3), activation='relu')) model.add(keras.layers.MaxPooling2D(pool_size=(2, 2))) model.add(keras.layers.Dropout(0.25)) return model elif self._cnn_base.lower() == 'mini': assert self._input_shape >= (200, 200, 3), error_msg['MiniNet'] base_model = keras.applications.mobilenet.MobileNet( input_shape=self._input_shape, alpha=1.0, depth_multiplier=1, dropout=1e-3, include_top=False, weights='imagenet') for layer in base_model.layers: if "conv_dw_9" in layer.name: break layer.trainable = False return base_model else: raise NameError('Unknown CNN model')
def load_vgg(model_path, pretrained=True, **kwargs): if pretrained: kwargs['init_weights'] = False model = vgg.VGG(vgg.make_layers(vgg.cfg['D'], batch_norm=True), **kwargs) if pretrained: state_dict = torch.load(model_path) # remove classifier layers state_dict = { k: v for k, v in state_dict.items() if 'class' not in k } model.load_state_dict(state_dict) return model.features
def vgg19(vgg_path=None, pretrained=True, **kwargs): """VGG 19-layer model Args: pretrained (bool): If True, returns a model pre-trained on ImageNet If False, return a randomly initialized model """ print('xxxxCreating VGG19 model...') if pretrained: kwargs['init_weights'] = False model = vgg.VGG(vgg.make_layers(vgg.cfg['E']), **kwargs) if pretrained: state_dict = torch.load(vgg_path) state_dict = {k: v for k, v in state_dict.items() if 'class' not in k} model.load_state_dict(state_dict) return model
def make_model(self, is_mask=True): model_list_f, model_list_c, bn, model_list_f_w, model_list_c_w, model_list_b_w = self.make_model_list( ) print(len(model_list_c)) features = vgg.make_layers(model_list_f, bn, is_mask=is_mask) model_out = vgg.VGG(features, num_classes=10, init_weights=False, cl_n1=model_list_f[-2], cl_n2=model_list_c[0], cl_n3=model_list_c[1], is_mask=is_mask) ii = 0 iiii = 0 for layer in model_out.features: if is_mask and isinstance(layer, vgg.Conv2d_Mask): layer.Conv2d.weight.data.copy_(model_list_f_w[ii][0]) layer.Conv2d.bias.data.copy_(model_list_f_w[ii][1]) ii += 1 if is_mask == False and isinstance(layer, nn.Conv2d): layer.weight.data.copy_(model_list_f_w[ii][0]) layer.bias.data.copy_(model_list_f_w[ii][1]) ii += 1 if isinstance(layer, nn.BatchNorm2d): layer.weight.data.copy_(model_list_b_w[iiii][0]) layer.bias.data.copy_(model_list_b_w[iiii][1]) iiii += 1 ii = 0 for layer in model_out.classifier: if is_mask and isinstance(layer, vgg.Linear_Mask): layer.Linear.weight.data.copy_(model_list_c_w[ii][0]) layer.Linear.bias.data.copy_(model_list_c_w[ii][1]) ii += 1 if is_mask and isinstance(layer, nn.Linear): layer.weight.data.copy_(model_list_c_w[ii][0]) layer.bias.data.copy_(model_list_c_w[ii][1]) ii += 1 if is_mask == False and isinstance(layer, nn.Linear): layer.weight.data.copy_(model_list_c_w[ii][0]) layer.bias.data.copy_(model_list_c_w[ii][1]) ii += 1 if is_mask == False and isinstance(layer, nn.BatchNorm2d): layer.weight.data.copy_(model_list_b_w[iiii][0]) layer.bias.data.copy_(model_list_b_w[iiii][1]) iiii += 1 return model_out
def main(): """load default parameters""" params = train.params "load and normalize HCL2000-100 dataset" trans = transforms.Compose([ # transforms.ToPILImage('L'), # 转变成PIL image(灰度图), pixels: 28*28, shape: H*W*C # transforms.Resize((224, 224), Image.ANTIALIAS), # pixels: 224*224, range: [0, 225], shape: H*W*C transforms.ToTensor(), # 转变成Tensor, range: [0, 1.0], shape: C*H*W transforms.Lambda(lambda x: x.sub(0.5).div(0.5))]) # 归一化, range: [-1, 1] target_trans = transforms.Lambda(lambda x: x.long()) test_set = ds.HCL(images_path="./HCL2000-100/HCL2000_100_test.npz", labels_path="./HCL2000-100/HCL2000_100_test_label.npz", transform=trans, target_transform=target_trans) "define the network" net = vgg.VGG('VGG16', 100, params['dropout_rate'], params['FC_size']) "test one of the 30000 images" test(net, PATH, device, test_set, 20000)
def train(): model = vgg.VGG(config.CONTENT_PATH, config.STYLE_PATH) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) cost = total_loss(sess, model) optimizer = tf.train.AdamOptimizer(1.0).minimize(cost) sess.run(tf.global_variables_initializer()) sess.run(tf.assign(model.model['input'], model.noise_image)) for step in range(config.EPOCHES): sess.run(optimizer) if step % 50 == 0: print('step {} is down.'.format(step)) img = sess.run(model.model['input']) img += config.MEAN_PIXELS img = img[0] img = np.clip(img, 0, 255).astype(np.uint8) scipy.misc.imsave( '{}output-{}.jpg'.format(config.OUTPUT_PATH, step), img) img = sess.run(model.model['input']) img += config.MEAN_PIXELS img = img[0] img = np.clip(img, 0, 255).astype(np.uint8) scipy.misc.imsave('{}output.jpg'.format(config.OUTPUT_PATH), img)
default=False, action='store_true', help='Evaluate a pre trained model. Must indicate weights file.') parser.add_argument('--crop', type=int, default=4, help='Pixels to crop from the image') parser.add_argument('--plot-model', default=False, action='store_true', help='Plot all network models') args = parser.parse_args() # build backbone backbone = vgg.VGG(vgg.cfg['F']) backbone.model.summary() # instantiate IIC object iic = IIC(args, backbone.model) if args.plot_model: plot_model(backbone.model, to_file="model-vgg.png", show_shapes=True) plot_model(iic.model, to_file="model-iic.png", show_shapes=True) if args.eval: iic.load_weights() iic.eval() elif args.train: iic.train()
test_loss += criterion(output, target).item() pred = output.argmax(dim=1, keepdim=True) correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print( '\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset))) if __name__ == "__main__": epochs = 5 use_cuda = True device = torch.device("cuda" if use_cuda else "cpu") model = vgg.VGG().to(device) save_model = True optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) for epoch in range(epochs): # 训练 train(model, device, train_loader, optimizer, epoch) # 测试代码 test(model, device, test_loader) # 如果设置保存模型,就开始保存模型,保存为 mnist_cnn.pt if save_model: torch.save(model.state_dict(), "vgg.pt")
"c029": 12, "c030": 13, "c031": 14, "c032": 15 } # In[16]: #fps_dict = { l.strip().split(' ')[0] : float( l.strip().split(' ')[1] ) for l in open( "video_fps.txt" ) } # In[17]: #X = tf.placeholder( "float", [None, crop_size*crop_size*3] ) Y = tf.placeholder("float", [None, C]) vgg16 = vgg.VGG() vgg16.build() fc1 = util.fc(vgg16.pool5, C, "fc1") pre = tf.nn.softmax_cross_entropy_with_logits(logits=fc1, labels=Y) loss = tf.reduce_mean(pre) # In[19]: train_op = tf.train.AdamOptimizer(learning_rate=LR, epsilon=1e-8).minimize(loss) # In[20]: conf = tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True), device_count={'GPU': 1})
return out if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--gpu_id', type=int, default=-1) parser.add_argument('--img_fn', type=str, default='sample.jpg') parser.add_argument('--out_fn', type=str, default='result.jpg') parser.add_argument('--min_size', type=int, default=500) parser.add_argument('--nms_thresh', type=float, default=0.2) parser.add_argument('--conf', type=float, default=0.75) args = parser.parse_args() print vgg_model=vgg.VGG() serializers.load_npz('fast_rcnn_vgg_voc.model', vgg_model) #Gpu Setting if args.gpu_id >= 0: xp = cuda.cupy cuda.get_device(args.gpu_id).use() vgg_model.to_gpu() else: xp=np orig_image = cv.imread(args.img_fn) img, im_scale = img_preprocessing(orig_image, PIXEL_MEANS) orig_rects = get_bboxes(orig_image, im_scale, min_size=args.min_size) img = xp.asarray(img)
# Hyperparameters total_steps = 6000 log_freq = 200 learning_rate = 1e-3 alpha = 1 # content loss beta = 1e-2 # how much style # Style Model device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') transform = transforms.Compose([ transforms.Resize((356, 356)) , transforms.ToTensor() # , transforms.Normalize(0.5, 0.5) ]) model = vgg.VGG().to(device).eval() def apply_style_on_painting(painting, style): painting = ski.img_as_ubyte(painting) ski_io.imsave('test_painting.png', painting) painting, painting_orig_shape = utils.load_img('test_painting.png', transform, device, True) style = ski.img_as_ubyte(style) ski_io.imsave('test_style.png', style) style = utils.load_img('test_style.png', transform, device) gen_painting = painting.clone().requires_grad_(True) optimizer = optim.Adam([gen_painting], lr=learning_rate)
except Exception as e: pass finally: with open(os.path.join(rdir, 'args.json'), 'w') as arg_log: json.dump(vars(args), arg_log) # Set the random seeds random.seed(args.seed) np.random.seed(args.seed) train, valid = cifar.get_cifar10(scale=255.) if args.model == 'wrn': net = wrn.WideResNet(widen_factor=10, depth=28, n_classes=10) elif args.model == 'densenet': net = densenet.DenseNet(10) elif args.model == 'vgg': net = vgg.VGG(10) elif args.model == 'vgg_vd': net = vgg_vd.VGG16VD(10, warm_up=0.0001) #net.__class__.__bases__ = (vgg_vd.VariationalDropoutChain,) + net.__class__.__bases__ if args.load: serializers.load_npz(args.load, net) else: serializers.save_npz(os.path.join(rdir, 'cifar10_init.model'), net) if args.model == 'vgg_vd': net(train[0][0][None, ]) # for setting in_channels automatically net.to_variational_dropout() if args.gpu >= 0: net.to_gpu() import cupy as cp
os.chdir(basedir) old_labels = Labels(sys.argv[1]) new_labels = Labels(sys.argv[2]) remap = [0] * new_labels.count for i in range(new_labels.count): ch = new_labels.db[i][0] if ch in old_labels.lut: remap[i] = old_labels.lut[ch] else: remap[i] = old_labels.empty[0] if len(old_labels.empty) > 1: old_labels.empty = old_labels.empty[1:] print(remap) layout[0] = (160, 160, 3) layout[-1] = old_labels.count attr_i = 'x'.join([str(l) for l in layout[0]]) attr_c = '_'.join([str(l[0]) for l in layout[1]]) attr_f = '_'.join([str(l) for l in layout[2]]) attr = '-'.join( [s for s in (attr_i, attr_c, attr_f, str(layout[-1])) if len(s) > 0]) model_param_path = join(basedir, 'pretrained', 'tvlogo-vgg-%s.npy' % attr) model = vgg.VGG(layout, model_param_path) model.save(model_param_path.replace('.npy', '-new.npy'), remap=remap)
def main(): # torch.backends.cudnn.enabled = False random.seed(3423432) torch.cuda.manual_seed_all torch.manual_seed(1) torch.cuda.manual_seed(1) global args, best_acc, suffix datasize = [1000, 2000, 4000, 8000, 16000, 32000, 50000] args = parser.parse_args() if args.tensorboard: configure("runs/%s"%(args.name)) normalize = transforms.Normalize(mean=[x/255.0 for x in [125.3, 123.0, 113.9]], std=[x/255.0 for x in [63.0, 62.1, 66.7]]) if args.augment: transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) else: transform_train = transforms.Compose([ transforms.ToTensor(), normalize, ]) transform_test = transforms.Compose([ transforms.ToTensor(), normalize ]) dataset_train = datasets.CIFAR10('/home/gh349/bicheng/data', train=True, download=True, transform=transform_train) dataset_test = datasets.CIFAR10('/home/gh349/bicheng/data/', train=False, transform=transform_test) for size in datasize: suffix = " - " + str(size) tmp_train = random.sample(dataset_train, size) tmp_test = dataset_test kwargs = {'num_workers': 12, 'pin_memory': True} train_loader = torch.utils.data.DataLoader( tmp_train, batch_size=args.batch_size, shuffle=False, **kwargs) val_loader = torch.utils.data.DataLoader( tmp_test, batch_size=args.batch_size, shuffle=False, **kwargs) # create model # model = dn.DenseNet3(args.layers, 10, args.growth, reduction=args.reduce, # bottleneck=args.bottleneck, dropRate=args.droprate) model = vgg.VGG('VGG19') # get the number of model parameters print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) #intialize weights # model.apply(weights_init) # for training on multiple GPUs. # Use CUDA_VISIBLE_DEVICES=0,1 to specify which GPUs to use model = model.cuda() cudnn.benchmark = True # define loss function (criterion) and pptimizer criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) best_acc = 0 best_train = 0 for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch acc_train = train(train_loader, model, criterion, optimizer, epoch) # evaluate on validation set acc_val = validate(val_loader, model, criterion, epoch) if args.tensorboard: log_value("generalization error" + suffix, acc_train - acc_val, epoch) # remember best precision and save checkpoint is_best = acc_val > best_acc best_acc = max(acc_val, best_acc) is_best_train = acc_train > best_train best_train = max(acc_train,best_train) print('Best accuracy' + suffix + ': ', best_acc) if args.tensorboard: log_value('dataset accuracy', best_acc, size) log_value('data training accuracy',best_train,size)
def main(args): writer = SummaryWriter('./logs/{0}'.format(args.output_folder)) save_filename = './models/{0}'.format(args.output_folder) if args.dataset in ['mnist', 'fashion-mnist', 'cifar10']: transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) if args.dataset == 'mnist': # Define the train & test datasets train_dataset = datasets.MNIST(args.data_folder, train=True, download=True, transform=transform) test_dataset = datasets.MNIST(args.data_folder, train=False, transform=transform) num_channels = 1 elif args.dataset == 'fashion-mnist': # Define the train & test datasets train_dataset = datasets.FashionMNIST(args.data_folder, train=True, download=True, transform=transform) test_dataset = datasets.FashionMNIST(args.data_folder, train=False, transform=transform) num_channels = 1 elif args.dataset == 'cifar10': # Define the train & test datasets train_dataset = datasets.CIFAR10(args.data_folder, train=True, download=True, transform=transform) test_dataset = datasets.CIFAR10(args.data_folder, train=False, transform=transform) num_channels = 3 valid_dataset = test_dataset elif args.dataset == 'miniimagenet': transform = transforms.Compose([ transforms.RandomResizedCrop(32), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # Define the train, valid & test datasets train_dataset = MiniImagenet(args.data_folder, train=True, download=True, transform=transform) valid_dataset = MiniImagenet(args.data_folder, valid=True, download=True, transform=transform) test_dataset = MiniImagenet(args.data_folder, test=True, download=True, transform=transform) num_channels = 3 # Define the data loaders train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, pin_memory=True) valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=args.batch_size, shuffle=False, drop_last=True, num_workers=args.num_workers, pin_memory=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=16, shuffle=True) # Fixed images for Tensorboard fixed_images, _ = next(iter(test_loader)) fixed_grid = make_grid(fixed_images, nrow=8, range=(-1, 1), normalize=True) writer.add_image('original', fixed_grid, 0) model = VectorQuantizedVAE(num_channels, args.hidden_size, args.k).to(args.device) if args.ckp != "": model.load_state_dict(torch.load(args.ckp)) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) if args.tmodel != '': net = vgg.VGG('VGG19') net = net.to(args.device) net = torch.nn.DataParallel(net) checkpoint = torch.load(args.tmodel) net.load_state_dict(checkpoint['net']) target_model = net # Generate the samples first once reconstruction = generate_samples(fixed_images, model, args) grid = make_grid(reconstruction.cpu(), nrow=8, range=(-1, 1), normalize=True) writer.add_image('reconstruction', grid, 0) best_loss = -1. for epoch in range(args.num_epochs): print(epoch) # if epoch<100: # args.lr = 1e-5 # if epoch>100 and epoch< 400: # args.lr = 2e-5 train(train_loader, model, target_model, optimizer, args, writer) loss, _ = test(valid_loader, model, args, writer) print("test loss:", loss) reconstruction = generate_samples(fixed_images, model, args) grid = make_grid(reconstruction.cpu(), nrow=8, range=(-1, 1), normalize=True) writer.add_image('reconstruction', grid, epoch + 1) if (epoch == 0) or (loss < best_loss): best_loss = loss with open('{0}/best.pt'.format(save_filename), 'wb') as f: torch.save(model.state_dict(), f) with open('{0}/model_{1}.pt'.format(save_filename, epoch + 1), 'wb') as f: torch.save(model.state_dict(), f)
batch_size=args.batch, shuffle=False, num_workers=args.workers) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') wandb.init(name=timestamp, project='Energy Modulated Dropout', group='cifar') global_conf['wandb'] = wandb # Model global_conf['topk'] = args.topk global_conf['topk_ratio'] = args.topk_ratio print('==> Building model..') net = vgg.VGG(args.model, normal=args.normal, consensus=args.consensus, dropout=args.dropout) print('Num of parameters: ', sum(p.numel() for p in net.parameters() if p.requires_grad)) net = net.to(device) wandb.config.update(args) criterion = nn.CrossEntropyLoss() wandb.watch(models=net, criterion=criterion, log='all') if args.optim == 'sgd': optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.mom, weight_decay=args.decay) elif args.optim == 'adam':
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2, pin_memory=True) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # Model print('==> Building model..') net1 = vgg.VGG('VGG16', nclass=10, keep_ratio=1.) net2 = vgg.VGG('VGG16', nclass=10, keep_ratio=1.) net3 = vgg.VGG('VGG16', nclass=10, keep_ratio=1.) net1 = nn.Sequential(NormalizeLayer(), net1) net2 = nn.Sequential(NormalizeLayer(), net2) net3 = nn.Sequential(NormalizeLayer(), net3) cudamodel(net1, device) cudamodel(net2, device) cudamodel(net3, device) if device == 'cuda': cudnn.benchmark = True if args.resume: # Load checkpoint.
print('==> Resuming from checkpoint..') assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!' checkpoint = torch.load('./checkpoint/vgg16') net = checkpoint['net'] best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch'] else: print('==> Building model..') # net = VGG('VGG19') # net = ResNet18() # net = PreActResNet18() # net = GoogLeNet() # net = DenseNet121() # net = ResNeXt29_2x64d() # net = MobileNet() net = vgg.VGG('VGG16') # net = DPN92() # net = ShuffleNetG2() # net = SENet18() if cuda_available: net.cuda() net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count())) cudnn.benchmark = True criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LR_0, momentum=0.9, weight_decay=5e-4)
'-b', type=int, default=None, help='batchsize. If None, ' 'batchsize is architecture-specific batchsize is used.') args = parser.parse_args() if args.model == 'alex': import alex model = alex.Alex(args.batchsize, args.cudnn) elif args.model == 'overfeat': import overfeat model = overfeat.Overfeat(args.batchsize, args.cudnn) elif args.model == 'vgg': import vgg model = vgg.VGG(args.batchsize, args.cudnn) elif args.model.startswith('conv'): import conv number = args.model[4:] model = getattr(conv, 'Conv{}'.format(number))(args.batchsize, args.cudnn) else: raise ValueError('Invalid model name') print('Architecture\t{}'.format(args.model)) print('Iteration\t{}'.format(args.iteration)) print('cuDNN\t{}'.format(cuda.cudnn_enabled and model.use_cudnn)) print('batchsize\t{}'.format(model.batchsize)) if args.gpu >= 0: cuda.get_device(args.gpu).use() model.to_gpu()