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()
