def train_step(image_data, target): with tf.GradientTape() as tape: pred_result = model(image_data, training=True) giou_loss=conf_loss=prob_loss=0 # optimizing process for i in range(3): conv, pred = pred_result[i*2], pred_result[i*2+1] loss_items = compute_loss(pred, conv, *target[i], i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) tf.print("=> STEP %4d lr: %.6f giou_loss: %4.2f conf_loss: %4.2f " "prob_loss: %4.2f total_loss: %4.2f" %(global_steps, optimizer.lr.numpy(), giou_loss, conf_loss, prob_loss, total_loss)) # update learning rate global_steps.assign_add(1) if global_steps < warmup_steps: lr = global_steps / warmup_steps *cfg.TRAIN.LR_INIT else: lr = cfg.TRAIN.LR_END + 0.5 * (cfg.TRAIN.LR_INIT - cfg.TRAIN.LR_END) * ( (1 + tf.cos((global_steps - warmup_steps) / (total_steps - warmup_steps) * np.pi)) ) tf.keras.optimizer.lr.assign(lr.numpy())
def yolo_loss(target, output): """计算损失,for循环计算三个采样率下的损失,注意:此处取三种采样率下的总损失而不是平均损失""" giou_loss=conf_loss=prob_loss=0 for i in range(3): # pred.shape (8, 52, 52, 3, 25) ----- output[i].shape (8, 52, 52, 75) pred = yolov3.decode(output[i], i) loss_items = yolov3.compute_loss(pred, output[i], *target[i], i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] return [giou_loss, conf_loss, prob_loss]
def train_step(image_data, target): with tf.GradientTape() as tape: pred_result = model(image_data, training=True) giou_loss = conf_loss = prob_loss = 0 for i in range(3): """ The output is order of conv, pred since output_tensors appended in the following order output_tensors.append(conv_tensor) output_tensors.append(pred_tensor) """ conv, pred = pred_result[i * 2], pred_result[i * 2 + 1] loss_items = compute_loss(pred, conv, *target[i], i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) tf.print("=> STEP %4d lr: %.6f giou_loss: %4.2f conf_loss: %4.2f "\ "prob_loss: %4.2f total_loss: %4.2f" % (global_steps, optimizer.lr.numpy(), giou_loss, conf_loss, prob_loss, total_loss)) # update the learning rate global_steps.assign_add(1) if global_steps < warmup_steps: lr = global_steps / warmup_steps * cfg.TRAIN.LR_INIT else: lr = cfg.TRAIN.LR_END + 0.5 * ( cfg.TRAIN.LR_INIT - cfg.TRAIN.LR_END) * ((1 + tf.cos( (global_steps - warmup_steps) / (total_steps - warmup_steps) * np.pi))) optimizer.lr.assign(lr.numpy()) # it writes the summary with writer.as_default(): tf.summary.scalar("lr", optimizer.lr, step=global_steps) tf.summary.scalar("loss/total_loss", total_loss, step=global_steps) tf.summary.scalar("loss/giou_loss", giou_loss, step=global_steps) tf.summary.scalar("loss/conf_loss", conf_loss, step=global_steps) tf.summary.scalar("loss/prob_loss", prob_loss, step=global_steps) # it forces summary writer to send any buffered data to storage writer.flush()
def __train_step(self, image_data, target, model, global_steps, writer, optimizer, warmup_steps, total_steps): with tf.GradientTape() as tape: pred_result = model(image_data, training=True) giou_loss = conf_loss = prob_loss = 0 for i in range(3): conv, pred = pred_result[i * 2], pred_result[i * 2 + 1] loss_items = compute_loss(pred, conv, *target[i], i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) tf.print( "=> STEP %4d lr: %.6f giou_loss: %4.2f conf_loss: %4.2f " "prob_loss: %4.2f total_loss: %4.2f" % (global_steps, optimizer.lr.numpy(), giou_loss, conf_loss, prob_loss, total_loss)) global_steps.assign_add(1) if global_steps < warmup_steps: lr = global_steps / warmup_steps * cfg.TRAIN.LR_INIT else: lr = cfg.TRAIN.LR_END + 0.5 * ( cfg.TRAIN.LR_INIT - cfg.TRAIN.LR_END) * ((1 + tf.cos( (global_steps - warmup_steps) / (total_steps - warmup_steps) * np.pi))) optimizer.lr.assign(lr.numpy()) with writer.as_default(): tf.summary.scalar("lr", optimizer.lr, step=global_steps) tf.summary.scalar("loss/total_loss", total_loss, step=global_steps) tf.summary.scalar("loss/giou_loss", giou_loss, step=global_steps) tf.summary.scalar("loss/conf_loss", conf_loss, step=global_steps) tf.summary.scalar("loss/prob_loss", prob_loss, step=global_steps) writer.flush()
def yolo_loss(args): pred_result = args[:6] target = args[6] giou_loss = conf_loss = prob_loss = 0 for i in range(3): conv, pred = pred_result[i * 2], pred_result[i * 2 + 1] target1, target2 = target[i * 2], target[i * 2 + 1] loss_items = compute_loss(pred, conv, target1, target2, i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss total_loss = tf.convert_to_tensor([total_loss]) return total_loss
def train_step(image, target): # 需要将前向传播放在tape里 with tf.GradientTape() as tape: output_layers = model(image, training=True) giou_loss = conf_loss = prob_loss = 0 # optimizing process for i in range(3): conv, pred = output_layers[2 * i], output_layers[2 * i + 1] # 给这个函数定义多个同类的形参,在使用时,带一个*号的在方法中会被存储为元组 # https://blog.csdn.net/wangjvv/article/details/79703509 loss_items = compute_loss(pred, conv, *target[i], i) giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) tf.print( "=> STEP %4d lr: %.6f giou_loss: %4.2f conf_loss: %4.2f " "prob_loss: %4.2f total_loss: %4.2f" % (global_steps.numpy(), optimizer.lr.numpy(), giou_loss, conf_loss, prob_loss, total_loss)) # update learning rate global_steps.assign_add(1) if global_steps < warmup_steps: lr = global_steps / warmup_steps * cfg.TRAIN.LR_INIT else: lr = cfg.TRAIN.LR_END + 0.5 * ( cfg.TRAIN.LR_INIT - cfg.TRAIN.LR_END) * ((1 + tf.cos( (global_steps - warmup_steps) / (total_steps - warmup_steps) * np.pi))) # global_steps是tensor optimizer.lr.assign(lr.numpy()) # writing summary data with writer.as_default(): tf.summary.scalar("lr", optimizer.lr, step=global_steps) tf.summary.scalar("loss/total_loss", total_loss, step=global_steps) tf.summary.scalar("loss/giou_loss", giou_loss, step=global_steps) tf.summary.scalar("loss/conf_loss", conf_loss, step=global_steps) tf.summary.scalar("loss/prob_loss", prob_loss, step=global_steps) writer.flush()
def train_step(image_data, target): with tf.GradientTape() as tape: pred_result = model(image_data, training=True) ''' print('train.py/train_step') pred_result is list print(np.array(pred_result).shape) : (6, 4) print(pred_result[0].shape) : (4, 52, 52, 255) => conv print(pred_result[1].shape) : (4, 52, 52, 3, 85) => pred print(pred_result[2].shape) : (4, 26, 26, 255) => conv print(pred_result[3].shape) : (4, 26, 26, 3, 85) => pred print(pred_result[4].shape) : (4, 13, 13, 255) => conv print(pred_result[5].shape) : (4, 13, 13, 3, 85) => pred ''' giou_loss=conf_loss=prob_loss=0 # optimizing process for i in range(3): # Iterating through each scale levels (small/medium/large) conv, pred = pred_result[i*2], pred_result[i*2+1] ''' print('train.py/train_step') print(conv.shape) : (4, 52, 52, 255) (4, 26, 26, 255) (4, 13, 13, 255) print(pred.shape) : (4, 52, 52, 3, 85) (4, 26, 26, 3, 85) (4, 13, 13, 3, 85) ''' loss_items = compute_loss(pred, conv, *target[i], i) # loss_items => [giou_loss, conf_loss, prob_loss] ''' List of (batch_smaller_target, batch_medium_target, batch_larger_target) print(len(target)) => 3 | select (batch_smaller_target, batch_medium_target, batch_larger_target) print(len(target[0])) => 2 | select (batch_label_sbbox, batch_sbboxes) ----- (for batch_label_sbbox) print(len(target[0][0])) => 4 | batch size print(len(target[0][0][0])) => 52 | cell size print(len(target[0][0][0][0])) => 52 | cell size print(len(target[0][0][0][0][0])) => 3 | 3 anchors per each level print(len(target[0][0][0][0][0][0])) => 85 | xywh(4), conf(1), prob(80) ----- (for batch_sbboxes) print(len(target[0][1])) => 4 (Batch size) print(len(target[0][1][0])) => 150 (Each image contains maximum 150 bboxes) print(len(target[0][1][1])) => 150 print(len(target[0][1][2])) => 150 print(len(target[0][1][3])) => 150 print(len(target[0][1][0][120])) => 4 (Each bbox has xywh info) ''' giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss gradients = tape.gradient(total_loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) tf.print("=> STEP %4d lr: %.6f giou_loss: %4.2f conf_loss: %4.2f " "prob_loss: %4.2f total_loss: %4.2f" %(global_steps, optimizer.lr.numpy(), giou_loss, conf_loss, prob_loss, total_loss)) # update learning rate global_steps.assign_add(1) if global_steps < warmup_steps: lr = global_steps / warmup_steps *cfg.TRAIN.LR_INIT else: lr = cfg.TRAIN.LR_END + 0.5 * (cfg.TRAIN.LR_INIT - cfg.TRAIN.LR_END) * ( (1 + tf.cos((global_steps - warmup_steps) / (total_steps - warmup_steps) * np.pi)) ) optimizer.lr.assign(lr.numpy()) # writing summary data with writer.as_default(): tf.summary.scalar("lr", optimizer.lr, step=global_steps) tf.summary.scalar("loss/total_loss", total_loss, step=global_steps) tf.summary.scalar("loss/giou_loss", giou_loss, step=global_steps) tf.summary.scalar("loss/conf_loss", conf_loss, step=global_steps) tf.summary.scalar("loss/prob_loss", prob_loss, step=global_steps) writer.flush()
testset = Dataset('test') sum_giou_loss = 0 sum_conf_loss = 0 sum_prob_loss = 0 sum_total_loss = 0 n = 0 for image_data, target in testset: # for every batch test_result = model(image_data, training=False) giou_loss = 0 conf_loss = 0 prob_loss = 0 # sum up loss over 3 scales for i in range(3): conv, pred = test_result[i * 2], test_result[i * 2 + 1] # get output and decoded ouput(pred) simultanuously loss_items = compute_loss(pred, conv, *target[i], i) # compare decoded output and label for loss computation giou_loss += loss_items[0] conf_loss += loss_items[1] prob_loss += loss_items[2] total_loss = giou_loss + conf_loss + prob_loss sum_giou_loss += giou_loss sum_conf_loss += conf_loss sum_prob_loss += prob_loss sum_total_loss += total_loss n += 1 tf.print("val_giou_loss: %4.2f val_conf_loss: %4.2f " "val_prob_loss: %4.2f val_total_loss: %4.2f" % (giou_loss, conf_loss, prob_loss, total_loss)) # average loss among of all validation set