def __init__(self,device):
self.nz = 100
self.beta1 = 0.5
self.real_label = 1
self.fake_label = 0
self.L = 100
self.device = device
self.iters = 0
self.netG = Generator(self.nz).to(self.device)
self.netD = Discriminator().to(self.device)
self.netTarget = VGG('VGG16').to(self.device)
self.netTarget.load_state_dict(torch.load('BestClassifierModel.pth',map_location=self.device))
# fixed_noise -> stores fixed generator seed for inference
self.fixed_noise = torch.randn(64, self.nz, 1, 1, device=self.device)
self.netG.apply(self.weights_init)
self.netD.apply(self.weights_init)
self.optimizerG = optim.Adam(self.netG.parameters(), lr=2e-4, betas=(self.beta1,0.999))
self.optimizerD = optim.Adam(self.netD.parameters(), lr=2e-4, betas=(self.beta1,0.999))
self.criterion = nn.BCELoss()
self.criterionTarget = nn.CrossEntropyLoss()
# criterionPerturbation -> norm of the generated noise
self.criterionPerturbation = nn.MSELoss()
def __init__(self, channel=32):
super(model_VGG, self).__init__()
self.vgg = VGG()
self.score = nn.Conv2d(128, 1, 1, 1)
self.lspm = LSPM(512)
self.aggregation_4 = aggregation_OWN(512, 512)
self.aggregation_3 = aggregation_OWN(512, 256)
self.aggregation_2 = aggregation_OWN(256, 128)
self.aggregation_1 = aggregation_OWN_Single(128)
self.out_planes = [512, 256, 128]
infos = []
for ii in self.out_planes:
infos.append(
nn.Sequential(nn.Conv2d(512, ii, 3, 1, 1, bias=False),
nn.ReLU(inplace=True)))
self.infos = nn.ModuleList(infos)
self.upsample_2 = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=True)
self.upsample_4 = nn.Upsample(scale_factor=4,
mode='bilinear',
align_corners=True)
self.upsample_8 = nn.Upsample(scale_factor=8,
mode='bilinear',
align_corners=True)
def __init__(self, config):
self._config = config
self._kernel_size = 3
self._cnn = VGG(self._config.nr_feat_maps, self._config.tensor_names,
self._config.image_size)
self._grcu_list = []
for L, hidden_layer_size in enumerate(self._config.hidden_sizes):
kernel = self._kernel_size if self._config.input_sizes[L][
0] > self._kernel_size else self._config.input_sizes[L][0]
if self._config.stacked:
if L == 0:
self._grcu_list.append(
StackedGRCUCell(hidden_layer_size, -1,
self._config.input_sizes[L][0],
self._config.input_sizes[L][1],
self._config.input_sizes[L][2],
kernel))
else:
self._grcu_list.append(
StackedGRCUCell(hidden_layer_size,
self._config.hidden_sizes[L - 1],
self._config.input_sizes[L][0],
self._config.input_sizes[L][1],
self._config.input_sizes[L][2],
kernel))
else:
self._grcu_list.append(
GRCUCell(hidden_layer_size, self._config.input_sizes[L][0],
self._config.input_sizes[L][1],
self._config.input_sizes[L][2], kernel))
def test(self, test_file_path, num_classes, batch_size, model):
'''
@description: 构建VGG-Net16网络结构，加载训练好的网络模型，对测试样本进行分类，输出测试准确率
@params:
- test_file_path: 测试样本集对应的txt文件所在的路径
- num_classes: 分类数目
- batch_size: 测试过程中的每次输入网络中的样本数
- model: 已经训练好的模型
@return: None
'''
test_file_name = test_file_path + 'test_list.txt'
vgg = VGG(weight_decay=0.0, keep_prob=1.0, num_classes=num_classes)
with tf.Graph().as_default(), tf.device('/gpu:0'):
with tf.name_scope('input'):
#队列读取训练数据
num_examples = np.loadtxt(test_file_name,
dtype=np.str).shape[0]
test_image,test_label = get_batch(test_file_name,self._image_H,\
self._image_W,batch_size,\
is_train=False)
x = tf.placeholder(tf.float32,[None,self._image_H,self._image_W,\
self._image_channels],name='x')
_, prob = vgg.vgg16(x)
correct_top_1 = tf.nn.top_k(prob, k=1)
correct_top_5 = tf.nn.top_k(prob, k=5)
saver = tf.train.Saver()
with tf.Session(
config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=True)) as sess:
saver.restore(sess, model)
start_time = time.time()
num_epoch = int(np.ceil(num_examples / batch_size))
num_examples = num_epoch * batch_size
index_top_1 = np.zeros(num_examples)
index_top_5 = np.zeros((num_examples, 5))
label = np.zeros(num_examples)
for i in range(num_epoch):
image,label[i*batch_size:(i+1)*batch_size] = \
sess.run([test_image,test_label])
index_top_1[i*batch_size:(i+1)*batch_size],\
index_top_5[i*batch_size:(i+1)*batch_size] = \
sess.run(correct_top_1[1],correct_top_5,feed_dict={x:image})
duration = time.time() - start_time
top_1 = 0
top_5 = 0
for i in range(num_examples):
top_1 += label[i] in index_top_1[i]
top_5 += label[i] in index_top_5[i]
top_1 = top_1 / num_examples
top_5 = top_5 / num_examples
print('top_1 accuracy: %.3f%%, top_5 accuracy: %.3f%%\t%.3fsec)'%\
(top_1,top_5,duration))
class model_VGG(nn.Module):
def __init__(self, channel=32):
super(model_VGG, self).__init__()
self.vgg = VGG()
self.score = nn.Conv2d(128, 1, 1, 1)
self.lspm = LSPM(512)
self.aggregation_4 = aggregation_OWN(512, 512)
self.aggregation_3 = aggregation_OWN(512, 256)
self.aggregation_2 = aggregation_OWN(256, 128)
self.aggregation_1 = aggregation_OWN_Single(128)
self.out_planes = [512, 256, 128]
infos = []
for ii in self.out_planes:
infos.append(
nn.Sequential(nn.Conv2d(512, ii, 3, 1, 1, bias=False),
nn.ReLU(inplace=True)))
self.infos = nn.ModuleList(infos)
self.upsample_2 = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=True)
self.upsample_4 = nn.Upsample(scale_factor=4,
mode='bilinear',
align_corners=True)
self.upsample_8 = nn.Upsample(scale_factor=8,
mode='bilinear',
align_corners=True)
def forward(self, x):
x1 = self.vgg.conv1(x)
x2 = self.vgg.conv2(x1)
x3 = self.vgg.conv3(x2)
x4 = self.vgg.conv4(x3)
x5 = self.vgg.conv5(x4)
lspm = self.lspm(x5)
GG = []
GG.append(self.infos[0](self.upsample_2(lspm)))
GG.append(self.infos[1](self.upsample_4(lspm)))
GG.append(self.infos[2](self.upsample_8(lspm)))
merge = self.aggregation_4(x4, x5, GG[0])
merge = self.aggregation_3(x3, merge, GG[1])
merge = self.aggregation_2(x2, merge, GG[2])
merge = self.aggregation_1(merge)
merge = self.score(merge)
result = F.interpolate(merge,
x1.size()[2],
mode='bilinear',
align_corners=True)
return result
def test_vgg11(batch_size, batch_norm, num_classes, model_name):
input = torch.randn(batch_size, 3, 32, 32)
model = VGG(
config={
"name": model_name,
"params": VGG_CONFIG[model_name],
},
batch_norm=batch_norm,
num_classes=num_classes
)
output = model(input)
assert model.name() == model_name
assert list(output.size()) == [batch_size, num_classes]
def test(test_model_dir,
batch_size,
mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
model=None):
transform = transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
test_dataset = torchvision.datasets.CIFAR100("../../datasets/",
download=True,
train=False,
transform=transform)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True)
if model is None:
state_dict = torch.load(test_model_dir)
model = VGG(state_dict['model_type'], True).cuda()
model.load_state_dict(state_dict["model_state_dict"])
classes = []
accuracy = 0.0
with torch.no_grad():
tot = 0
correct = 0
for idx, (x, y) in enumerate(test_loader):
x = x.cuda()
y = y.cuda()
out = model(x)
_, predicted = torch.max(out.data, 1)
for j in range(len(predicted)):
tot = tot + 1
if predicted[j] == y.cpu()[j]:
correct = correct + 1
print("Test Percent Finished: {}%.".format(idx * 100 /
len(test_loader)))
print(
"{} th Picture Predicted: Correct Predict: {}. Correct Percentage: {:.2f}%"
.format(tot, correct, correct * 100 / tot))
accuracy = correct / tot * 100
return accuracy
def style_transfer(content_image_path, style_image_path, mixed_image_path,
content_weight, style_weight, variation_weight, pooling,
learning_rate, beta1, beta2, epsilon, max_iteration,
check_point):
# set the time point
time_start = time.time()
# load image
content_image = load_image(content_image_path)
style_image = load_image(style_image_path, shape=content_image.shape[:2])
# initialize object
vgg = VGG(VGG_MAT_PATH, pooling)
nn = NeuralNetwork(content_image, style_image, vgg, content_weight,
style_weight, variation_weight)
# train the model
for i, mixed_image in nn.train_model(learning_rate, beta1, beta2, epsilon,
max_iteration, check_point):
save_image(mixed_image_path + '\\v1_{}.jpeg'.format(i + 1),
mixed_image)
# print time
time_end = time.time()
print('Time elapsed: {} seconds'.format(round(time_end - time_start)))
return
def get_model(model_name, pho_size=299, num_classes=110):
if model_name == "vgg16":
model = VGG(num_classes=num_classes, pho_size=299)
elif model_name == "resnet101":
model = resnet101(num_classes=num_classes)
elif model_name == "densenet":
model = DenseNet(growth_rate=12,
block_config=[(100 - 4) // 6 for _ in range(3)],
num_classes=num_classes,
small_inputs=False,
efficient=True,
pho_size=pho_size)
elif model_name == "InceptionResNetV2":
model = InceptionResNetV2(num_classes=num_classes)
elif model_name == "InceptionV4":
model = InceptionV4(num_classes=num_classes)
elif model_name == "Inception3":
model = Inception3(num_classes=num_classes)
elif model_name == "denoise":
model = get_denoise()
elif model_name == "Mymodel":
model = Mymodel()
elif model_name == 'Comdefend':
model = ComDefend()
elif model_name == 'Rectifi':
model = Rectifi()
return model
def main():
args = parser()
if args is None:
exit()
if args.verbose:
print('Arguments parsed....')
# Model instance
vgg = VGG(args.model_path, args.pool_type, args.lalpha)
if args.verbose:
print('Model created....')
# Content and Style Images
content_image = load_image(os.path.join(args.content_path,
args.content_image),
max_size=args.max_size)
style_images = [
load_image(os.path.join(args.style_path, image),
shape=(content_image.shape[1], content_image.shape[0]))
for image in args.style_images
]
if args.verbose:
print('Content and style images loaded....')
if args.initial_type == 'content':
init_gen_image = content_image
elif args.initial_type == 'style':
init_gen_image = style_images[0]
elif args.initial_type == 'random':
init_gen_image = get_content_image(content_image, args.noise_ratio,
args.seed)
if args.verbose:
print('Generated image initialized....')
# Stylize instance
stylize = Stylize(vgg, content_image, style_images, init_gen_image, args)
if args.verbose:
print('Style-model created....')
print('Generating image....')
# Transfer style
gen_image = stylize.transfer_style()
if args.verbose:
print('Image generated....')
# Saving the image to destination path
save_image(args.out_filepath, gen_image)
if args.verbose:
print('Generated image saved....')
print('Completed!!!! :)')
def get_model(device):
model_path = config.PATH_PTHS + config.MODEL
model = VGG(pretrained=False).to(device)
model.load_state_dict(
torch.load(model_path,
map_location=None if torch.cuda.is_available() else "cpu"))
model.eval()
return model
def get_model(path='pretrained/ckpt.t7'):
#model = nn.DataParallel(VGG('VGG16'))
model = VGG('VGG16')
#if True:
# print(model._modules['features']._modules)
#checkpoint=torch.load(path, map_location='cpu')
#checkpoint=torch.load(path, map_location=lambda storage, loc:storage)
#model was trained on GPU
state_dict = torch.load(path)['net']
if False:
print(state_dict.keys())
if False:
print(list(model._modules.keys()))
if use_gpu:
print(model._modules['module']._modules['features']._modules)
else:
print(model._modules['features']._modules)
if use_gpu:
model = nn.DataParallel(VGG('VGG16'))
else:
model = VGG('VGG16')
new_dict = OrderedDict()
for key, val in state_dict.items():
key = key[7:] #since 'module.' has len 7
new_dict[key] = val.to('cpu')
state_dict = new_dict
if False:
print(state_dict.keys())
model.load_state_dict(state_dict)
return model
def main():
model = VGG(depth=16, init_weights=True, cfg=None)
# model = VGG_shaokai("vgg16")
# model = ConvNet()
# model = ResNet18()
# model = torch.nn.DataParallel(model)
model.load_state_dict(torch.load("./model_pruned/2019-04-09 11:14:52.016169/column-filter-fivelabels-masked_retrain/cifar10_vgg16_retrained_acc_93.960_4rhos_config_vgg16_v2.yaml.pt"))
model.cuda()
criterion = F.cross_entropy
# criterion = CrossEntropyLossMaybeSmooth(smooth_eps=0).cuda()
validate(test_loader, criterion, model)
# test(model, criterion, test_loader)
print("\n------------------------------\n")
print('here')
for name, weight in model.named_parameters():
if (len(weight.size()) == 4 and "shortcut" not in name):
print(name, weight.size())
print('here now')
test_column_sparsity(model)
# test_chanel_sparsity(model)
test_filter_sparsity(model)
def main(args):
# 数据加载
(x_train, y_train), (x_test, y_test) = load_cifar(args.cifar_root)
# 随机选择训练样本
train_num = x_train.shape[0]
def next_batch(batch_size):
idx = np.random.choice(train_num, batch_size)
return x_train[idx], y_train[idx]
# 网络
vgg = VGG(image_size=32, name='vgg11')
opt = RmsProp(vgg.weights, lr=args.lr, decay=1e-3)
# 加载权重
if args.checkpoint:
weights = load_weights(args.checkpoint)
vgg.load_weights(weights)
print("load weights done")
# 评估
if args.eval_only:
indices = np.random.choice(len(x_test), args.eval_num, replace=False)
print('{} start evaluate'.format(
time.asctime(time.localtime(time.time()))))
acc = get_accuracy(vgg, x_test[indices], ys=y_test[indices])
print('{} acc on test dataset is :{:.3f}'.format(
time.asctime(time.localtime(time.time())), acc))
return
# 训练
num_steps = args.steps
for step in range(num_steps):
x, y_true = next_batch(args.batch_size)
# 前向传播
y_predict = vgg.forward(x.astype(np.float))
# print('y_pred: min{},max{},mean:{}'.format(np.min(y_predict, axis=-1),
# np.max(y_predict, axis=-1),
# np.mean(y_predict, axis=-1)))
# print('y_pred: {}'.format(y_predict))
acc = np.mean(
np.argmax(y_predict, axis=1) == np.argmax(y_true, axis=1))
# 计算loss
loss, gradient = cross_entropy_loss(y_predict, y_true)
# 反向传播
vgg.backward(gradient)
# 更新梯度
opt.iterate(vgg)
# 打印信息
print('{} step:{},loss:{:.4f},acc:{:.4f}'.format(
time.asctime(time.localtime(time.time())), step, loss, acc))
# 保存权重
if step % 100 == 0:
save_weights(
os.path.join(args.save_dir, 'weights-{:03d}.pkl'.format(step)),
vgg.weights)
def get_vgg_net(model_folder, out_keys=['r11', 'r21', 'r31', 'r41', 'r51']):
vgg_net = VGG(pool='avg', out_keys=out_keys)
vgg_net.load_state_dict(torch.load(model_folder + 'vgg_conv.pth'))
vgg_net.cuda()
for param in vgg_net.parameters():
param.requires_grad = False
return vgg_net
def feature_visual(image_path,
feature_image_path,
pooling,
learning_rate,
beta1,
beta2,
epsilon,
max_iteration,
check_point,
init_image='random',
feature_image_name='feat_vis',
type='filter'):
# set the time point
time_start = time.time()
# load image
image = load_image(image_path)
# initialize object
vgg = VGG(VGG_MAT_PATH, pooling)
nn = NeuralNetwork(image, vgg, type=type)
# train the model
for feature_image, losses in nn.train_model(learning_rate, beta1, beta2,
epsilon, max_iteration,
check_point, init_image):
if len(losses) > 200:
plt.plot(
np.arange(start=len(losses) - 150, stop=len(losses), step=1),
losses[len(losses) - 150:len(losses)])
plt.savefig(feature_image_path + r'/' + feature_image_name +
'_loss.jpeg')
plt.close()
elif losses[len(losses) - 1] == 0:
plt.plot(losses)
plt.savefig(feature_image_path + r'/' + feature_image_name +
'_loss.jpeg')
plt.close()
save_image(
feature_image_path + r'/' + feature_image_name + '_image.jpeg',
feature_image)
break
else:
plt.plot(losses)
plt.savefig(feature_image_path + r'/' + feature_image_name +
'_loss.jpeg')
plt.close()
save_image(
feature_image_path + r'/' + feature_image_name + '_image.jpeg',
feature_image)
# print time
time_end = time.time()
print('Time elapsed: {} seconds'.format(round(time_end - time_start)))
return
def test(path):
(x_train, y_train), (x_test, y_test) = load_cifar(path)
print(x_train[0][0])
print(y_train[0])
vgg = VGG(name='vgg11')
import utils
utils.save_weights('./w.pkl', vgg.weights)
w = utils.load_weights('./w.pkl')
print(type(w))
print(w.keys())
def __init__(self, in_size, num_classes, visualize=False):
super(FasterRCNN, self).__init__()
self.in_size = in_size
self.num_classes = num_classes
self.visualize = visualize
self.device = torch.device(
'cuda:0' if torch.cuda.is_available() else 'cpu')
# self.backbone = self.build_backbone()
self.backbone = VGG('A', self.num_classes).to(self.device)
self.rpn = RPN(512, 512, self.in_size, 9).to(self.device)
def getNetwork(args):
if args.net_type == 'resnet':
net = ResNet18(100)
file_name = 'resnet18'
elif args.net_type == 'vgg':
net = VGG('VGG16', 100)
file_name = 'vgg'
else:
assert False
file_name += '_' + str(args.seed) + '_' + args.exp_name
return net, file_name
def get_features(image):
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
model = VGG().to(device)
image = transform(image).to(device)
image = image.view((1, *image.size()))
return model(image)
def main(_):
pp.pprint(flags.FLAGS.__flags)
#gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
run_config = tf.ConfigProto()
#run_config.gpu_options.allow_growth=True
# Data initialisation
data_path = os.path.join(FLAGS.data_dir, FLAGS.dataset,
FLAGS.input_fname_pattern)
data = ImageDataset(regex_file=data_path,
input_height=FLAGS.input_height,
input_width=FLAGS.input_width,
as_line=False)
y_pred = label_processing(data.getData())
labels = Label(y_pred)
dataset = LabeledDataset(data, labels)
with tf.Session() as sess:
#net = NN(FLAGS.input_height*FLAGS.input_width*3, 2, hidden_layers = [60,10, 30],
# learning_rate = FLAGS.learning_rate, build = True, name = 'FCNeuralNet')
net = VGG([FLAGS.input_height, FLAGS.input_width, 3],
2,
learning_rate=FLAGS.learning_rate,
build=True,
name='VGGNeuralNet')
model = Classifier1D(sess, [net],
dataset,
checkpoint_dir=FLAGS.checkpoint_dir,
model_name=FLAGS.model_name)
old, step = model.load(FLAGS.checkpoint_dir)
print("(*) Already train : {} {}".format(
old, ("--> step " + str(step) if old else "")))
if FLAGS.train:
model.train(FLAGS)
else:
if not model.load(FLAGS.checkpoint_dir)[0]:
raise Exception("(!) Train a model first, then run test mode")
else:
model.test(FLAGS)
def main(args):
if args.model == 'lenet5':
from net import Net
net = Net()
elif args.model == 'cnn':
from cnn_net import Net
net = Net()
elif args.model == 'gap':
from net_gap import Net
net = Net()
elif args.model == 'vgg':
from vgg import VGG
net = VGG()
# device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')
# print(device)
net.to(device)
trainloader, testloader = load_data_cifar()
train(net, trainloader, testloader, args.num_epoch)
# PATH = './cifar_net.pth'
torch.save(net.state_dict(), './cifar_net_{}.pth'.format(args.model))
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
inputs = inputs.to(device)
labels = labels.to(device)
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
def build_backbone(self):
in_h, in_w = self.in_size[0], self.in_size[1]
model = VGG('A', self.num_classes).to(self.device)
# model = models.vgg16(pretrained=True).to(self.device)
# features = list(model.features)
#
# dummy_img = torch.zeros((1, 3, in_h, in_w)).float()
# req_features = []
# dummy = dummy_img.clone().to(self.device)
#
# for feature in features:
# dummy = feature(dummy)
#
# if dummy.size()[2] < 800 // 16:
# break
# req_features.append(feature)
# out_dim = dummy.size()[1]
# return nn.Sequential(*req_features)
return model
def run():
classes = ('Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise',
'Neutral')
crop_size = 44
trained_model = torch.load("C:/Users/Admin/Downloads/model_state.pth.tar")
model = VGG("VGG19")
model.load_state_dict(trained_model["model_weights"])
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
model.eval()
st.title("Facial expression recognition")
img_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
if img_file is None:
st.write('** Please upload an image **')
original_image = Image.open(img_file, mode='r')
st.image(original_image, use_column_width=True)
model = 1
if st.button('Predict'):
predict_image = detect(model, original_image)
image = Image.fromarray(cv2.cvtColor(predict_image, cv2.COLOR_BGR2RGB))
st.image(image, use_column_width=True)
def main():
if FLAGS.cnn_type == 'inception':
cnn = Inception()
else:
cnn = VGG(FLAGS.nr_feat_maps, FLAGS.tensor_names, FLAGS.image_size)
# cnn.printTensors()
dict_test = {}
dict_test["video_path"] = []
dict_test["label"] = []
with open(FLAGS.test_list) as f:
for line in f:
video_path, label = line.split()
dict_test["video_path"].append(video_path)
dict_test["label"].append(label)
test_data = pd.DataFrame(data=dict_test, columns=['video_path', 'label'])
if not os.path.exists(FLAGS.test_data_file):
test_data.to_csv(FLAGS.test_data_file, sep=',')
dict = {}
dict["video_path"] = []
dict["label"] = []
dict["feat_path"] = []
with open(FLAGS.train_list) as f:
for line in f:
video_path, label = line.split()
dict["video_path"].append(video_path)
dict["label"].append(label)
dict["feat_path"].append(video_path.split("/")[-1] + ".pkl")
train_data = pd.DataFrame(data=dict,
columns=['video_path', 'label', "feat_path"])
if not os.path.exists(FLAGS.train_data_file):
train_data.to_csv(FLAGS.train_data_file, sep=',')
train_data.apply(lambda row: process_record(cnn, row), axis=1)
from vgg import VGG
import os
model = VGG()
print(model.summary())
weights = './model/emotion_best_weights.h5'
if os.path.exists(weights):
print("Loading weight")
model.load_weights(weights)
print("Saving model")
model.save("./model/emotion_recognition.h5")
styleImg = styleImg.unsqueeze(0)
contentImg = contentImg.unsqueeze(0)
styleImg, contentImg, content_iq = util.luminance_transfer(
styleImg.numpy(), contentImg.numpy())
styleImg = Variable(torch.from_numpy(styleImg))
contentImg = Variable(torch.from_numpy(contentImg))
else:
styleImg = load_image(opt.style_image) # 1x3x512x512
contentImg = load_image(opt.content_image) # 1x3x512x512
if (opt.cuda):
styleImg = styleImg.cuda()
contentImg = contentImg.cuda()
############### MODEL ####################
vgg = VGG()
vgg.load_state_dict(torch.load(opt.vgg_dir))
for param in vgg.parameters():
param.requires_grad = False
if (opt.cuda):
vgg.cuda()
########### LOSS & OPTIMIZER ##########
class GramMatrix(nn.Module):
def forward(self, input):
b, c, h, w = input.size()
f = input.view(b, c, h * w) # bxcx(hxw)
# torch.bmm(batch1, batch2, out=None) #
# batch1: bxmxp, batch2: bxpxn -> bxmxn #
G = torch.bmm(f, f.transpose(
img = img.clamp_(0, 1)
tutils.save_image(img, '%s/transfer2.png' % ("./images"), normalize=True)
return
style_img = "./QiBashi.jpg"
content_img = "./2.jpg"
styleImg = load_img(style_img)
contentImg = load_img(content_img)
#for running on cuda
styleImg = styleImg.cuda()
contentImg = contentImg.cuda()
vgg_directory = "./vgg_conv.pth" #path to pretrained vgg vgg_directory
vgg = VGG()
#print(vgg.state_dict())
vgg.load_state_dict(torch.load(vgg_directory))
for param in vgg.parameters():
param.requires_grad = False
vgg.cuda() # Putting model on cuda
class GramMatrix(nn.Module):
def forward(self, input):
b, c, h, w = input.size()
f = input.view(b, c, h * w) #bxcx(hxw)
# torch.bmm(batch1, batch2, out=None)
# batch1 : bxmxp, batch2 : bxpxn -> bxmxn
G = torch.bmm(f, f.transpose(
def train():
transform_train = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(size=32),
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,
download=False,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=False,
transform=transform_test)
testloader = torch.utils.data.DataLoader(testset,
batch_size=args.batch_size,
shuffle=True,
num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
model = VGG(vars(args))
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lrate,
momentum=0.9,
weight_decay=5e-4)
if args.use_cuda:
model = model.cuda()
if args.eval:
model.load_state_dict(torch.load(args.model_dir))
model.eval()
accuracy = model.evaluate(testloader)
exit()
total_size = len(trainloader)
lrate = args.lrate
best_score = 0.0
scores = []
for epoch in range(1, args.epochs + 1):
model.train()
for i, (image, label) in enumerate(trainloader):
loss = model(image, label)
model.zero_grad()
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i % 100 == 0:
print('Epoch = %d, step = %d / %d, loss = %.5f lrate = %.5f' %
(epoch, i, total_size, loss, lrate))
model.eval()
accuracy = model.evaluate(testloader)
scores.append(accuracy)
with open(args.model_dir + "_scores.pkl", "wb") as f:
pkl.dump(scores, f)
if best_score < accuracy:
best_score = accuracy
print('saving %s ...' % args.model_dir)
torch.save(model.state_dict(), args.model_dir)
if epoch % args.decay_period == 0:
lrate *= args.decay
for param_group in optimizer.param_groups:
param_group['lr'] = lrate
def main():
date = str(datetime.datetime.now())
torch.cuda.set_device(0)
train_loader, test_loader = getData(args.no_Of_Labels)
if args.depth == 16:
model = VGG(depth=16, init_weights=True, cfg=None)
if args.depth == 19:
model = VGG(depth=19, init_weights=True, cfg=None)
admm = False
masked_retrain = False
if args.admm:
admm = True
if args.masked_retrain:
masked_retrain = True
else:
print("no sparsity type specified")
return
config = args.config_file
prune_ratios = []
if not isinstance(config, str):
raise Exception("filename must be a str")
with open(config, "r") as stream:
try:
raw_dict = yaml.load(stream)
prune_ratios = raw_dict['prune_ratios'] #this should be a list of dictionaries
except yaml.YAMLError as exc:
print(exc)
masks = []
base_model_path = args.base_model_path
pruned_path = "./model_pruned/"+date+"/"
if not os.path.exists(pruned_path):
os.makedirs(pruned_path)
copyfile(config, pruned_path+config)
for i in range(len(prune_ratios)):
prune_ratio = prune_ratios[i]
print(prune_ratio)
sparsity_type = prune_ratio['prune_ratio_'+str(i+1)]['type']
prune_values = prune_ratio['prune_ratio_'+str(i+1)]['values']
pruned_path = "./model_pruned/"+date+"/"
for j in range(i+1):
pruned_path += prune_ratios[j]['prune_ratio_'+str(j+1)]['type']
pruned_path += '-'
if args.no_Of_Labels == 2:
pruned_path += 'twolabels-'
if args.no_Of_Labels == 5:
pruned_path += 'fivelabels-'
if args.no_Of_Labels == 10:
pruned_path += 'tenlabels-'
admm_path = pruned_path +'admm'
masked_path = pruned_path + 'masked_retrain'
if not os.path.exists(admm_path):
os.makedirs(admm_path)
if not os.path.exists(masked_path):
os.makedirs(masked_path)
if args.admm and args.masked_retrain:
saved_model = do_admmtrain(args,model,train_loader,test_loader,sparsity_type,prune_values, masks,base_model_path,admm_path)
masked_model, mask = do_masked_retrain(args,model,train_loader,test_loader,sparsity_type,prune_values,masks,saved_model,masked_path)
#masks.append(mask)
base_model_path = masked_model
elif args.admm:
do_admmtrain(args,model,train_loader,test_loader,sparsity_type,prune_values,masks, base_model, admm_path)
elif args.masked_retrain:
do_masked_retrain(args,model, trained_loader, test_loader, sparsity_type, prune_values ,masks,saved_model,masked_path)
else:
print('error')
contentImg = transform(util.open_and_resize_image(opt.content_image,256)) # 1x3x512x512
styleImg = styleImg.unsqueeze(0)
contentImg = contentImg.unsqueeze(0)
styleImg,contentImg,content_iq = util.luminance_transfer(styleImg.numpy(),contentImg.numpy())
styleImg = Variable(torch.from_numpy(styleImg))
contentImg = Variable(torch.from_numpy(contentImg))
else:
styleImg = load_image(opt.style_image) # 1x3x512x512
contentImg = load_image(opt.content_image) # 1x3x512x512
if(opt.cuda):
styleImg = styleImg.cuda()
contentImg = contentImg.cuda()
############### MODEL ####################
vgg = VGG()
vgg.load_state_dict(torch.load(opt.vgg_dir))
for param in vgg.parameters():
param.requires_grad = False
if(opt.cuda):
vgg.cuda()
########### LOSS & OPTIMIZER ##########
class GramMatrix(nn.Module):
def forward(self,input):
b, c, h, w = input.size()
f = input.view(b,c,h*w) # bxcx(hxw)
# torch.bmm(batch1, batch2, out=None) #
# batch1: bxmxp, batch2: bxpxn -> bxmxn #
G = torch.bmm(f,f.transpose(1,2)) # f: bxcx(hxw), f.transpose: bx(hxw)xc -> bxcxc
return G.div_(h*w)
