def closure():
# correct the values of updated input image
input_img.data.clamp_(0, 1)
optimizer.zero_grad()
model(input_img)
style_score = 0
content_score = 0
for sl in style_losses:
style_score += sl.loss
for cl in content_losses:
content_score += cl.loss
style_score *= style_weight
content_score *= content_weight
loss = style_score + content_score
loss.backward()
run[0] += 1
if run[0] % 50 == 0:
print("run {}:".format(run))
print('Style Loss : {:4f} Content Loss: {:4f}'.format(
style_score.item(), content_score.item()))
print()
return style_score + content_score
def test_model(model, test_loader, title):
# switch to evaluate mode
#self.eval()
running_corrects = 0
y_pred = []
y_true = []
for i, data in enumerate(test_loader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
if use_gpu:
inputs = Variable(inputs.cuda())
labels = Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)
# forward
outputs = model(inputs)
_, preds = torch.max(outputs.data, 1)
running_corrects += torch.sum(preds == labels.data)
y_pred += list(preds)
y_true += list(labels.data)
test_acc = running_corrects * 1.0 / test_dataset_sizes
print('Test_Acc: {:.4f}'.format(test_acc))
plt.figure()
plot_confusion_matrix(y_pred, y_true, title)
return y_pred
def test(model, last_layer_input, clf):
print(len(test_loader.dataset))
# put features and targets into tensor variables
features = torch.Tensor(len(test_loader.dataset), last_layer_input)
targets = torch.Tensor(len(test_loader.dataset))
# use for loop to extract the features and target from the test loader
for i, (in_data, target) in enumerate(test_loader):
print("iteration")
print(i)
from_ = int(i)
till_ = int(from_ + 1)
input_var = torch.autograd.Variable(in_data, volatile=True)
feature_batch = model(input_var)
features[from_:till_] = feature_batch.data.cpu()
targets[from_:till_] = target
features = features.numpy()
targets = targets.numpy()
prediction = clf.predict(features)
print(clf)
print(prediction)
print(targets)
count = 0
for i in range(len(prediction)):
if prediction[i] == targets[i]:
count += 1
accuracy = count * 1.0 / len(prediction)
print("classification accuracy is:")
print(accuracy)
return targets, prediction
def get_model(cfg):
model_dict = cfg["model"]
name = model_dict["arch"]
model = _get_model_instance(name)
param_dict = copy.deepcopy(model_dict)
param_dict.pop("arch")
if name == "fcn":
model = model(n_classes=cfg["data"]["n_classes"])
model.apply(weights_init)
elif name == "drcn":
model = model(cfg)
model.apply(weights_init)
elif name == "unet":
model = model(cfg)
model.apply(weights_init)
return model
def train(model, last_layer_input):
# pipeline: for loop, split train_loader into image and target, feed into modified model and get output, combine all features and target, fit SVM model.
# define features variables in tensor form
print(len(train_loader.dataset))
features = torch.Tensor(len(train_loader.dataset), last_layer_input)
targets = torch.Tensor(len(train_loader.dataset))
clf = svm.SVC(decision_function_shape='ovo')
for i, (in_data, target) in enumerate(train_loader):
print(i)
from_ = int(i * 4)
till_ = int(from_ + 4)
input_var = torch.autograd.Variable(in_data, volatile=True)
feature_batch = model(input_var)
features[from_:till_] = feature_batch.data.cpu()
targets[from_:till_] = target
# convert features and target to numpy form
features = features.numpy()
targets = targets.numpy()
# then fit SVM on the entire features
clf.fit(features, targets)
return clf
def test(model):
img_list=[]
tag_list=[]
seg_list=[]
with torch.no_grad():
model.to(device)
model.eval()
# img,tag=next(iter(test_loader))
for img,tag in test_loader:
img=img.to(device)
img_list.append(img)
tag_list.append(tag)
output=model(img)
label=output.argmax(dim=1)
tmp=label.cpu()
img_final=torch.from_numpy(label2image(tmp))
seg_list.append(img_final)
img=torch.cat(img_list,dim=0)
tag=torch.cat(tag_list,dim=0)
seg=torch.cat(seg_list,dim=0)
score=iou(seg,tag)
pic_pred(img[0:4].numpy(),tag[0:4].numpy(),seg[0:4].numpy())
def test_model(model, test_loader):
correct_num = 0.0
y_predict = []
y_actual = []
for iter, data in enumerate(test_loader, 0):
# get the inputs
inputs, labels = data
# make them variables
# if use GPU
inputs = Variable(inputs)
labels = Variable(labels)
# forward
outputs = model(inputs)
_, preds = torch.max(outputs.data, 1)
correct_num += (preds == labels.data).sum()
y_predict += list(preds)
y_actual += list(labels.data)
test_accuracy = correct_num * 100.0 / testset_size
print("test accuracy: {:.4f}".format(test_accuracy))
plot_confusion_matrix(y_predict, y_actual, "VGG16_fintuned")
return y_predict
def get_style_model_and_losses(cnn,
normalization_mean,
normalization_std,
style_img,
content_img,
content_layers=content_layers_default,
style_layers=style_layers_default):
cnn = copy.deepcopy(cnn)
# normalization module
normalization = Normalization(normalization_mean,
normalization_std).to(device)
# just in order to have an iterable access to or list of content/syle
# losses
content_losses = []
style_losses = []
# assuming that cnn is a nn.Sequential, so we make a new nn.Sequential
# to put in modules that are supposed to be activated sequentially
model = nn.Sequential(normalization)
i = 0 # increment every time we see a conv
for layer in cnn.children():
if isinstance(layer, nn.Conv2d):
i += 1
name = 'conv_{}'.format(i)
elif isinstance(layer, nn.ReLU):
name = 'relu_{}'.format(i)
# The in-place version doesn't play very nicely with the ContentLoss
# and StyleLoss we insert below. So we replace with out-of-place
# ones here.
layer = nn.ReLU(inplace=False)
elif isinstance(layer, nn.MaxPool2d):
name = 'pool_{}'.format(i)
elif isinstance(layer, nn.BatchNorm2d):
name = 'bn_{}'.format(i)
else:
raise RuntimeError('Unrecognized layer: {}'.format(
layer.__class__.__name__))
model.add_module(name, layer)
if name in content_layers:
# add content loss:
target = model(content_img).detach()
content_loss = ContentLoss(target)
model.add_module("content_loss_{}".format(i), content_loss)
content_losses.append(content_loss)
if name in style_layers:
# add style loss:
target_feature = model(style_img).detach()
style_loss = StyleLoss(target_feature)
model.add_module("style_loss_{}".format(i), style_loss)
style_losses.append(style_loss)
# now we trim off the layers after the last content and style losses
for i in range(len(model) - 1, -1, -1):
if isinstance(model[i], ContentLoss) or isinstance(
model[i], StyleLoss):
break
model = model[:(i + 1)]
return model, style_losses, content_losses
def train_model(model,
criterion,
optimizer,
train_loader,
scheduler,
num_epochs=9):
since = time.time()
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
running_loss = 0.0
running_corrects = 0
# Iterate over data.
for i, data in enumerate(train_loader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
if use_gpu:
inputs = Variable(inputs.cuda())
labels = Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)
# zero the parameter gradients
optimizer.zero_grad()
# forward
outputs = model(inputs)
_, preds = torch.max(outputs.data, 1)
loss = criterion(outputs, labels)
# backward + optimize only if in training phase
loss.backward()
optimizer.step()
# statistics
running_loss += loss.data[0] * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / dataset_sizes
epoch_acc = running_corrects * 1.0 / dataset_sizes
print('Loss: {:.4f} Acc: {:.4f}'.format(epoch_loss, epoch_acc))
# deep copy the model
if epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = copy.deepcopy(model.state_dict())
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val Acc: {:4f}'.format(best_acc))
# load best model weights
model.load_state_dict(best_model_wts)
return model
