def inversion_balanced_FGSM(X, Y, model, T=10, epsilon=16, mu=0.5):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
alpha = epsilon / T
g = torch.zeros_like(X).to(device)
X_star = torch.zeros_like(X, requires_grad=True).to(device)
with torch.no_grad():
X_star.add_(X)
for t in range(T):
# compute gradient of the model w.r.t input
outputs = model(X_star)
loss = torch.zeros(1).to(device)
for o in outputs:
#cost = torch.nn.functional.binary_cross_entropy_with_logits(o.float(), Y.float(), reduction='none')
cost = cross_entropy_loss(o, Y)
loss = loss + cost
model.zero_grad()
if X_star.grad is not None:
X_star.grad = None
loss.backward()
# update g and X
with torch.no_grad():
g.copy_(mu * g + X_star.grad / (torch.norm(X_star.grad,p=1)))
X_star.add_(torch.sign(g), alpha=-1*alpha)
# TODO do we need clipping?
return X_star
def train(train_loader, model, optimizer, epoch, save_dir):
batch_time = Averagvalue()
losses = Averagvalue()
# switch to train mode
model.train()
end = time.time()
epoch_loss = []
counter = 0
#params = list(model.parameters())
for i, (image, label) in enumerate(train_loader):
# check whether data is valid
if not isdir(save_dir):
os.makedirs(save_dir)
if image.shape[2] == 100:
# measure data loading time
image, label = image.cuda(), label.cuda()
outputs = model(image)
loss = torch.zeros(1).cuda()
for o in outputs:
loss = loss + cross_entropy_loss(o, label)
counter += 1
loss = loss / args.itersize
loss.backward()
if counter == args.itersize:
optimizer.step()
optimizer.zero_grad()
counter = 0
# measure accuracy and record loss
losses.update(loss.item(), image.size(0))
epoch_loss.append(loss.item())
batch_time.update(time.time() - end)
end = time.time()
# display and logging
if i % args.print_freq == 0:
info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, i, len(train_loader)) + \
'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \
'Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses)
print(info)
outputs.append(label)
_, _, H, W = outputs[0].shape
all_results = torch.zeros((len(outputs), 1, H, W))
for j in range(len(outputs)):
all_results[j, 0, :, :] = outputs[j][0, 0, :, :]
torchvision.utils.save_image(all_results,
join(save_dir, "iter-%d.jpg" % i))
# save checkpoint
save_checkpoint(
{
'epoch': epoch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
filename=join(save_dir, "epoch-%d-checkpoint.pth" % epoch))
return losses.avg, epoch_loss
def train(self, inputs, labels, func_list):
print("train")
for epoch in range(0, self.epochs): # training başlangıcı
iteration = 0
while iteration < len(inputs):
inputs_batch = inputs[iteration:iteration + self.batch_size]
#print("input batch: " + str(inputs_batch))
labels_batch = labels[iteration:iteration + self.batch_size]
print("labels_batch:" + str(labels_batch))
z = []
activations = []
i = 0
for func in func_list:
if self.index == 0:
self.z = np.dot(
self.weights[self.index],
inputs_batch.T) + self.biases[self.index]
print("merve")
else:
self.z = np.dot(self.weights[self.index], activations[
self.index - 1]) + self.biases[self.index]
i += 1
print("domino")
z.append(self.z)
#print("Z: " + str(self.z))
print("z's shape: " + str(self.z.shape))
self.y = self.functions[func](self.z)
activations.append(self.y)
#print("act shape: " + str(activations[i]))
print(i)
self.index += 1
#print("y' : " + str(self.activation))
#print("y' 's shape: " + str(self.y.shape))
print("index = " + str(self.index))
#print(self.functions[func])
self.dongu += 1
print("döngü= " + str(self.dongu))
# print(activation.shape)
#print("hellö")
print("acti: " + str(activations[self.index - 1]))
# self.index = 0
a = 0
print("merveeee")
loss = functions.cross_entropy_loss(
activations[self.index - 1], labels_batch)
#loss = functions.mean_square_loss(activations[self.index-1], labels_batch)
loss += functions.L2_regularization(
0.01, self.weights[a], self.weights[a + 1]) # lambda
self.loss.append(loss)
self.index = 0
#print('<<<<==== Epoch: {:d}/{:d} -- Iteration:{:d} -- Loss: {:.2f} ====>>>>'.format(epoch+1, self.epochs, iteration+1, loss))
iteration += self.batch_size
import numpy as np
import functions as func
# Download images
X = func.load_images("train-images-idx3-ubyte.gz")
# Download labels
Y = func.download("train-labels-idx1-ubyte.gz")
# Transform to one hot vector
Y_one_hot = func.get_one_hot(Y)
# Get mini batch
X = func.get_mini_batch(X)
X = func.forward(X)
Y_one_hot = func.get_mini_batch(Y_one_hot)
# Calculate cross entropy loss
e = func.cross_entropy_loss(X, Y_one_hot)
print(f"Cross entropy loss: {e}")
def train(self, inputs, labels, func_list):
print("train")
for epoch in range(0, self.epochs): # training başlangıcı
iteration = 0
while iteration < len(inputs):
inputs_batch = inputs[iteration:iteration + self.batch_size]
#print("input batch: " + str(inputs_batch))
labels_batch = labels[iteration:iteration + self.batch_size]
#print("labels_batch:" + str(labels_batch))
a = 0
z = []
activations = []
for func in func_list:
if self.index == 0:
self.z = np.dot(inputs_batch, self.weights[self.index]) + self.biases[self.index]
else:
self.z = np.dot(self.z, self.weights[self.index]) + self.biases[self.index]
z.append(self.z)
#print("Z: " + str(self.z))
#print("z's shape: " + str(self.z.shape))
self.y = self.functions[func](self.z)
activations.append(self.y)
self.index += 1
#print("y' : " + str(self.activation))
#print("y' 's shape: " + str(self.y.shape))
#print("index = " +str(self.index))
#print(self.functions[func])
self.dongu +=1
#print("döngü= " + str(self.dongu))
# print(activation.shape)
#print("hellö")
self.index = 0
loss = functions.cross_entropy_loss(self.y, labels_batch)
loss += functions.L2_regularization(0.01, self.weights[a],self.weights[a+1]) # lambda
self.loss.append(loss)
#print("loss: " + str(self.loss))
i = 0
delta_y = (self.y - labels_batch) / self.y.shape[0]
#print("delta y" + str(delta_y.shape))
# print("delta_y:" + str(delta_y))
#print("len:" + str(len(self.weights)))
m = len(self.weights)
#print(m)
merve = 0
delta_hl = []
for a in range(m-1):
delta_h = np.dot(delta_y, self.weights[m-1].T)
m -= 1
merve += 1
delta_hl.append(delta_h)
#print("delta_h:" + str(delta_h.shape))
# burada relu varsa bunu yap yaz
#if 'relu' in func_list:
# delta_h[activations[i] <= 0] = 0 # derivative relu garanti olsun
# print("delta_h:" + str(delta_h))
#m -= 1
#if m-1 != 0:
# delta_h = np.dot(delta_y, weights[m - 1].T)
# delta_h[activations[i] <= 0] = 0
#else:
# backpropagation
k = len(self.weights)
if len(self.layer_nodes)-1 == k:
weight_gradient = np.dot(activations[m-1].T, delta_y) # forward * backward m-1 çünkü m=len(weights)
#print(weight_gradient)
bias_gradient = np.sum(delta_y, axis=0, keepdims=True)
#print("weights gradient: " + str(weight_gradient.shape))
#print("weights (k-1): " + str(self.weights[k-1].shape))
weight_gradient += 0.01 * self.weights[k-2]
self.weights[k-2] -= self.learning_rate * weight_gradient # weight ve bias güncelleme
self.biases[k-2] -= self.learning_rate * bias_gradient
k -= 1
# burayı halledersek tamamdır
elif k == 1:
weight_gradient = np.dot(inputs_batch.T, delta_hl[merve])
bias_gradient = np.sum(delta_hl[merve], axis=0, keepdims = True)
weight_gradient += 0.01 * self.weights[k - 1]
self.weights[k - 1] -= self.learning_rate * weight_gradient
self.bias[k - 1] -= self.learning_rate * bias_gradient
merve -= 1
else:
weight_gradient = np.dot(delta_hl[merve].T, delta_hl[merve-1])
bias_gradient = np.sum(delta_hl[merve-1], axis=0, keepdims = True)
weight_gradient += 0.01 * self.weights[k - 1]
self.weights[k - 1] -= self.learning_rate * weight_gradient
self.biases[k - 1] -= self.learning_rate * bias_gradient
merve -=1
print('<----=== Epoch: {:d}/{:d} -- Iteration:{:d} -- Loss: {:.2f} ===---->'.format(epoch+1, self.epochs, iteration+1, loss))
iteration += self.batch_size
def test(model1, model2, dataParser, epoch):
# 读取数据的迭代器
test_epoch = len(dataParser)
# 变量保存
batch_time = Averagvalue()
data_time = Averagvalue()
losses = Averagvalue()
loss_stage1 = Averagvalue()
loss_stage2 = Averagvalue()
f1_value_stage1 = Averagvalue()
acc_value_stage1 = Averagvalue()
recall_value_stage1 = Averagvalue()
precision_value_stage1 = Averagvalue()
f1_value_stage2 = Averagvalue()
acc_value_stage2 = Averagvalue()
recall_value_stage2 = Averagvalue()
precision_value_stage2 = Averagvalue()
map8_loss_value = Averagvalue()
# switch to train mode
model1.eval()
model2.eval()
end = time.time()
for batch_index, input_data in enumerate(dataParser):
# 读取数据的时间
data_time.update(time.time() - end)
# check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band'])
# 准备输入数据
images = input_data['tamper_image'].cuda()
labels_band = input_data['gt_band'].cuda()
labels_dou_edge = input_data['gt_dou_edge'].cuda()
relation_map = input_data['relation_map']
if torch.cuda.is_available():
loss = torch.zeros(1).cuda()
loss_8t = torch.zeros(()).cuda()
else:
loss = torch.zeros(1)
loss_8t = torch.zeros(())
with torch.set_grad_enabled(False):
images.requires_grad = False
# 网络输出
one_stage_outputs = model1(images)
zero = torch.zeros_like(one_stage_outputs[0])
one = torch.ones_like(one_stage_outputs[0])
rgb_pred = images * torch.where(one_stage_outputs[0] > 0.1, one,
zero)
rgb_pred_rgb = torch.cat((rgb_pred, images), 1)
two_stage_outputs = model2(rgb_pred_rgb, one_stage_outputs[9],
one_stage_outputs[10],
one_stage_outputs[11])
"""""" """""" """""" """""" """"""
" Loss 函数 "
"""""" """""" """""" """""" """"""
##########################################
# deal with one stage issue
# 建立loss
_loss_stage_1 = wce_dice_huber_loss(one_stage_outputs[0],
labels_band)
loss_stage_1 = _loss_stage_1
##############################################
# deal with two stage issues
_loss_stage_2 = wce_dice_huber_loss(two_stage_outputs[0],
labels_dou_edge) * 12
for c_index, c in enumerate(two_stage_outputs[1:9]):
one_loss_t = cross_entropy_loss(c,
relation_map[c_index].cuda())
loss_8t += one_loss_t
writer.add_scalar('stage2_%d_map_loss' % (c_index),
one_loss_t.item(),
global_step=epoch * test_epoch + batch_index)
_loss_stage_2 += loss_8t
loss_stage_2 = _loss_stage_2 / 20
loss = (loss_stage_1 + loss_stage_2) / 2
#######################################
# 总的LOSS
writer.add_scalar('test_stage_one_loss',
loss_stage_1.item(),
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_stage_two_pred_loss',
_loss_stage_2.item(),
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_stage_two_fuse_loss',
loss_stage_2.item(),
global_step=epoch * test_epoch + batch_index)
z = torch.cat((one_stage_outputs[0], two_stage_outputs[0]), 0)
writer.add_image('one&two_stage_image_batch:%d' % (batch_index),
make_grid(z, nrow=2),
global_step=epoch)
# writer.add_images('test_image_batch:%d_stage1' % (batch_index), one_stage_outputs[0], global_step=epoch)
# writer.add_images('test_image_batch:%d_stage2' % (batch_index), two_stage_outputs[0], global_step=epoch)
writer.add_scalar('test_fuse_loss_per_epoch',
loss.item(),
global_step=epoch * test_epoch + batch_index)
##########################################
# 将各种数据记录到专门的对象中
losses.update(loss.item())
loss_stage1.update(loss_stage_1.item())
loss_stage2.update(loss_stage_2.item())
map8_loss_value.update(loss_8t.item())
batch_time.update(time.time() - end)
end = time.time()
# 评价指标
f1score_stage2 = my_f1_score(two_stage_outputs[0], labels_dou_edge)
precisionscore_stage2 = my_precision_score(two_stage_outputs[0],
labels_dou_edge)
accscore_stage2 = my_acc_score(two_stage_outputs[0], labels_dou_edge)
recallscore_stage2 = my_recall_score(two_stage_outputs[0],
labels_dou_edge)
f1score_stage1 = my_f1_score(one_stage_outputs[0], labels_band)
precisionscore_stage1 = my_precision_score(one_stage_outputs[0],
labels_band)
accscore_stage1 = my_acc_score(one_stage_outputs[0], labels_band)
recallscore_stage1 = my_recall_score(one_stage_outputs[0], labels_band)
writer.add_scalar('test_f1_score_stage1',
f1score_stage1,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_precision_score_stage1',
precisionscore_stage1,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_acc_score_stage1',
accscore_stage1,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_recall_score_stage1',
recallscore_stage1,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_f1_score_stage2',
f1score_stage2,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_precision_score_stage2',
precisionscore_stage2,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_acc_score_stage2',
accscore_stage2,
global_step=epoch * test_epoch + batch_index)
writer.add_scalar('test_recall_score_stage2',
recallscore_stage2,
global_step=epoch * test_epoch + batch_index)
################################
f1_value_stage1.update(f1score_stage1)
precision_value_stage1.update(precisionscore_stage1)
acc_value_stage1.update(accscore_stage1)
recall_value_stage1.update(recallscore_stage1)
f1_value_stage2.update(f1score_stage2)
precision_value_stage2.update(precisionscore_stage2)
acc_value_stage2.update(accscore_stage2)
recall_value_stage2.update(recallscore_stage2)
if batch_index % args.print_freq == 0:
info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, test_epoch) + \
'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \
'两阶段总Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \
'第一阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage1) + \
'第二阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage2) + \
'第一阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage1) + \
'第一阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(
precision=precision_value_stage1) + \
'第一阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage1) + \
'第一阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage1) + \
'第二阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage2) + \
'第二阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(
precision=precision_value_stage2) + \
'第二阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage2) + \
'第二阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage2)
print(info)
if batch_index >= test_epoch:
break
return {
'loss_avg': losses.avg,
'f1_avg_stage1': f1_value_stage1.avg,
'precision_avg_stage1': precision_value_stage1.avg,
'accuracy_avg_stage1': acc_value_stage1.avg,
'recall_avg_stage1': recall_value_stage1.avg,
'f1_avg_stage2': f1_value_stage2.avg,
'precision_avg_stage2': precision_value_stage2.avg,
'accuracy_avg_stage2': acc_value_stage2.avg,
'recall_avg_stage2': recall_value_stage2.avg
}
def train(model1, model2, optimizer1, optimizer2, dataParser, epoch):
# 读取数据的迭代器
train_epoch = len(dataParser)
# 变量保存
batch_time = Averagvalue()
data_time = Averagvalue()
losses = Averagvalue()
loss_stage1 = Averagvalue()
loss_stage2 = Averagvalue()
f1_value_stage1 = Averagvalue()
acc_value_stage1 = Averagvalue()
recall_value_stage1 = Averagvalue()
precision_value_stage1 = Averagvalue()
f1_value_stage2 = Averagvalue()
acc_value_stage2 = Averagvalue()
recall_value_stage2 = Averagvalue()
precision_value_stage2 = Averagvalue()
map8_loss_value = Averagvalue()
# switch to train mode
model1.train()
model2.train()
end = time.time()
for batch_index, input_data in enumerate(dataParser):
# 读取数据的时间
data_time.update(time.time() - end)
# check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band'])
# 准备输入数据
images = input_data['tamper_image'].cuda()
labels_band = input_data['gt_band'].cuda()
labels_dou_edge = input_data['gt_dou_edge'].cuda()
relation_map = input_data['relation_map']
image_path = input_data['path']
if torch.cuda.is_available():
loss = torch.zeros(1).cuda()
loss_8t = torch.zeros(()).cuda()
else:
loss = torch.zeros(1)
loss_8t = torch.zeros(())
with torch.set_grad_enabled(True):
images.requires_grad = True
optimizer1.zero_grad()
optimizer2.zero_grad()
if images.shape[1] != 3 or images.shape[2] != 320:
continue
# 网络输出
try:
one_stage_outputs = model1(images)
except:
print(images)
continue
zero = torch.zeros_like(one_stage_outputs[0])
one = torch.ones_like(one_stage_outputs[0])
rgb_pred = images * torch.where(one_stage_outputs[0] > 0.1, one,
zero)
rgb_pred_rgb = torch.cat((rgb_pred, images), 1)
two_stage_outputs = model2(rgb_pred_rgb, one_stage_outputs[9],
one_stage_outputs[10],
one_stage_outputs[11])
"""""" """""" """""" """""" """"""
" Loss 函数 "
"""""" """""" """""" """""" """"""
##########################################
# deal with one stage issue
# 建立loss
_loss_stage_1 = wce_dice_huber_loss(one_stage_outputs[0],
labels_band)
loss_stage_1 = _loss_stage_1
##############################################
# deal with two stage issues
_loss_stage_2 = wce_dice_huber_loss(two_stage_outputs[0],
labels_dou_edge) * 12
for c_index, c in enumerate(two_stage_outputs[1:9]):
one_loss_t = cross_entropy_loss(c,
relation_map[c_index].cuda())
loss_8t += one_loss_t
writer.add_scalar('stage2_%d_map_loss' % (c_index),
one_loss_t.item(),
global_step=epoch * train_epoch +
batch_index)
_loss_stage_2 += loss_8t
loss_stage_2 = _loss_stage_2 / 20
loss = loss_stage_2
#######################################
# 总的LOSS
# print(type(loss_stage_2.item()))
writer.add_scalars('loss_gather', {
'stage_one_loss': loss_stage_1.item(),
'stage_two_pred_loss': _loss_stage_2.item(),
'stage_two_fuse_loss': loss_stage_2.item(),
'fuse_loss_per_epoch': loss.item()
},
global_step=epoch * train_epoch + batch_index)
##########################################
loss.backward()
optimizer1.step()
optimizer2.step()
# 将各种数据记录到专门的对象中
losses.update(loss.item())
loss_stage1.update(loss_stage_1.item())
loss_stage2.update(loss_stage_2.item())
map8_loss_value.update(loss_8t.item())
batch_time.update(time.time() - end)
end = time.time()
# 评价指标
f1score_stage2 = my_f1_score(two_stage_outputs[0], labels_dou_edge)
precisionscore_stage2 = my_precision_score(two_stage_outputs[0],
labels_dou_edge)
accscore_stage2 = my_acc_score(two_stage_outputs[0], labels_dou_edge)
recallscore_stage2 = my_recall_score(two_stage_outputs[0],
labels_dou_edge)
f1score_stage1 = my_f1_score(one_stage_outputs[0], labels_band)
precisionscore_stage1 = my_precision_score(one_stage_outputs[0],
labels_band)
accscore_stage1 = my_acc_score(one_stage_outputs[0], labels_band)
recallscore_stage1 = my_recall_score(one_stage_outputs[0], labels_band)
writer.add_scalars('f1_score_stage', {
'stage1': f1score_stage1,
'stage2': f1score_stage2
},
global_step=epoch * train_epoch + batch_index)
writer.add_scalars('precision_score_stage', {
'stage1': precisionscore_stage1,
'stage2': precisionscore_stage2
},
global_step=epoch * train_epoch + batch_index)
writer.add_scalars('acc_score_stage', {
'stage1': accscore_stage1,
'stage2': accscore_stage2
},
global_step=epoch * train_epoch + batch_index)
writer.add_scalars('recall_score_stage', {
'stage1': recallscore_stage1,
'stage2': recallscore_stage2
},
global_step=epoch * train_epoch + batch_index)
################################
f1_value_stage1.update(f1score_stage1)
precision_value_stage1.update(precisionscore_stage1)
acc_value_stage1.update(accscore_stage1)
recall_value_stage1.update(recallscore_stage1)
f1_value_stage2.update(f1score_stage2)
precision_value_stage2.update(precisionscore_stage2)
acc_value_stage2.update(accscore_stage2)
recall_value_stage2.update(recallscore_stage2)
if batch_index % args.print_freq == 0:
info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, train_epoch) + \
'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \
'两阶段总Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \
'第一阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage1) + \
'第二阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage2) + \
'第一阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage1) + \
'第一阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(
precision=precision_value_stage1) + \
'第一阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage1) + \
'第一阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage1) + \
'第二阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage2) + \
'第二阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(
precision=precision_value_stage2) + \
'第二阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage2) + \
'第二阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage2)
print(info)
if batch_index >= train_epoch:
break
return {
'loss_avg': losses.avg,
'f1_avg_stage1': f1_value_stage1.avg,
'precision_avg_stage1': precision_value_stage1.avg,
'accuracy_avg_stage1': acc_value_stage1.avg,
'recall_avg_stage1': recall_value_stage1.avg,
'f1_avg_stage2': f1_value_stage2.avg,
'precision_avg_stage2': precision_value_stage2.avg,
'accuracy_avg_stage2': acc_value_stage2.avg,
'recall_avg_stage2': recall_value_stage2.avg
}
def forward(self, x, t):
self.t = t
self.y = F.soft_max(x)
self.loss = F.cross_entropy_loss(self.y, self.t)
return self.loss
tf.greater(mask, threshold), 'float'
) # [batch_size, patch_size, patch_size]. Each elt (pixel) of the matrice is 0 or 1, the class of the pixel
mask_hard_true_resh = tf.reshape(mask, [
-1
]) # [batch_size*patch_size*patch_size]. Each row is 0 or 1 for the pixel
# Predictions
mask_hard_pred = tf.cast(
tf.greater(output, threshold), 'float'
) # [batch_size, patch_size, patch_size] Each elt of the matrice (pixel) corresponds the predicted class 0 or 1
mask_soft_pred_resh = tf.reshape(
output, [-1]
) # [batch_size*patch_size*patch_size] Each elt of the vector (pixel) corresponds the calculated logit
# Loss
entropy_loss = cross_entropy_loss(mask_hard_true_resh, mask_soft_pred_resh,
classes)
iou_loss = soft_intersection_union(mask_hard_true_resh, mask_soft_pred_resh,
classes)
alpha = 0.6
loss = alpha * entropy_loss + (1 - alpha) * iou_loss
print(
'--------------------------------------------------------------------------- ** Saved variables to Disk *****************************'
)
# Metrics
accuracy = accuracy_metric(mask_hard_true, mask_hard_pred)
IoU = iou_metric(mask_hard_true, mask_hard_pred)
# Static Optimizer
#optimizer = tf.train.AdamOptimizer(le------ arning_rate=0.01).minimize(entropy)
#optimizer = tf.train.RMSPropOptimizer(0.001, decay = 0.95, momentum = 0.9, epsilon = 1e-10).minimize(loss)
optimizer = tf.train.AdamOptimizer(learning_rate=0.0002).minimize(loss)
# for AI training project # sample for making 3 layer NN import numpy as np import functions as F # 2 input, 3 hidden layer nodes, 2 output a = np.array([1, 2, 3]) t = np.array([1, 2, 3]) print(a.ndim) print(a.reshape(1, a.size).ndim) print(F.cross_entropy_loss(a,t)) # class Three_Layer_NN: # # def __init__(self, input_size, hidden_size, output_size): # self.W1 = np.random.randn(input_size, hidden_size) # self.B1 = np.random.randn(hidden_size) # self.W2 = np.random.randn(hidden_size, output_size) # self.B2 = np.random.randn(output_size) # # # def forward(self, x): # z1 = np.dot(x, self.W1) + self.B1 # h1 = relu(z1) # z2 = np.dot(h1, self.W2) + self.B2 # out = soft_max(z2) #
def train(model,optimizer,epoch,save_dir):
dataParser = DataParser(args.batch_size)
batch_time = Averagvalue()
data_time = Averagvalue()
losses = Averagvalue()
# switch to train mode
model.train()
end = time.time()
epoch_loss = []
counter = 0
for batch_index ,(images,labels_numpy) in enumerate(generate_minibatches(dataParser,True)):
# measure data loading time
data_time.update(time.time()-end)
labels = []
if torch.cuda.is_available():
images = torch.from_numpy(images).cuda()
for item in labels_numpy:
labels.append(torch.from_numpy(item).cuda())
else:
images = torch.from_numpy(images)
for item in labels_numpy:
labels.append(torch.from_numpy(item))
if torch.cuda.is_available():
loss =torch.zeros(1).cuda()
else:
loss = torch.zeros(1)
optimizer.zero_grad()
outputs = model(images)
# 四张GT监督
for o in outputs[9:]: # o2 o3 o4
t_loss = cross_entropy_loss(o, labels[-1])
loss = loss +t_loss
counter +=1
for c_index,c in enumerate(outputs[:8]):
loss = loss + cross_entropy_loss(c, labels[c_index])
loss = loss/11
loss.backward()
acc_scroe = my_accuracy_score(outputs[9].cpu().detach().numpy(),labels[-1].cpu().detach().numpy())
print('the acc is :',acc_scroe)
# 下面应该是用来解决batch size 过下的问题
# if counter == args.itersize:
# optimizer.step()
# optimizer.zero_grad()
# counter = 0
optimizer.step()
optimizer.zero_grad()
# measure the accuracy and record loss
losses.update(loss.item(),images.size(0))
epoch_loss.append(loss.item())
batch_time.update(time.time()-end)
end = time.time()
# display and logging
if not isdir(save_dir):
os.makedirs(save_dir)
if batch_index % args.print_freq ==0:
info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, dataParser.steps_per_epoch) + \
'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \
'Loss {loss.val:f} (avg:{loss.avg:f}) '.format(
loss=losses)
print(info)
# torch.save(model,join(save_dir,"checkpoint.pth"))
# 每一轮保存一次参数
save_checkpoint({'epoch': epoch,'state_dict':model.state_dict(), 'optimizer': optimizer.state_dict()},filename=join(save_dir,"epooch-%d-checkpoint.pth" %epoch))
return losses.avg,epoch_loss
