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