def main(): model = Yolov1(split_size=7, num_boxes=2, num_classes=20).to(DEVICE) optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY) loss_fn = YoloLoss() train_dataset = VOCDataset("data/train.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR) test_dataset = VOCDataset("data/test.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR) train_loader=DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=1, pin_memory=PIN_MEMORY, shuffle=True,drop_last=True) test_loader=DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, num_workers=1, pin_memory=PIN_MEMORY, shuffle=True,drop_last=True) for epoch in range(EPOCHS): pred_boxes, target_boxes = get_bboxes(train_loader, model, iou_threshold=0.5, threshold=0.4) mAP = mean_average_precision(pred_boxes, target_boxes, iou_threshold=0.5) print(f"Train mAP:{mAP}") train_fn(train_loader, model, optimizer, loss_fn) if epoch > 99: for x, y in test_loader: x = x.to(DEVICE) for idx in range(16): bboxes = cellboxes_to_boxes(model(x)) bboxes = non_max_suppression(bboxes[idx], iou_threshold=0.5, threshold=0.4) plot_image(x[idx].permute(1,2,0).to("cpu"), bboxes) if __name__ == "__main__": main()
def _calc_map(self, x, y, pred): self.anchor_boxes = self.anchor_boxes.to(self.device) exist_mask = torch.round(torch.sigmoid(pred[..., 4:5])) cell_idx = torch.arange(13, device=self.device) bx = exist_mask * torch.sigmoid( pred[..., 0:1]) + exist_mask * cell_idx.view([1, 1, -1, 1, 1]) by = exist_mask * torch.sigmoid( pred[..., 1:2]) + exist_mask * cell_idx.view([1, -1, 1, 1, 1]) bw = (exist_mask * self.anchor_boxes[:, 2].view([1, 1, 1, -1, 1]) * exist_mask * torch.exp(pred[..., 2:3])) bh = (exist_mask * self.anchor_boxes[:, 3].view([1, 1, 1, -1, 1]) * exist_mask * torch.exp(pred[..., 3:4])) pred[..., :4] = torch.cat([bx, by, bw, bh], dim=-1) pred_boxes, target_boxes = get_bboxes( x=x, y=y, predictions=pred, iou_threshold=0.45, threshold=0.005, S=self.S, B=self.B, device=self.device, ) mean_avg_prec = mAP(pred_boxes, target_boxes, iou_threshold=0.5) return mean_avg_prec
def _calc_map(self, y, pred): pred_boxes = [] target_boxes = [] small_preprocessed_pred = self._preprocess(pred[0], self.anchor_boxes[6:9] / (416 / 13), S=13) medium_preprocessed_pred = self._preprocess(pred[1], self.anchor_boxes[3:6] / (416 / 26), S=26) large_preprocessed_pred = self._preprocess(pred[2], self.anchor_boxes[:3] / (416 / 52), S=52) pred_boxes, target_boxes = get_bboxes( y=y, predictions=( small_preprocessed_pred, medium_preprocessed_pred, large_preprocessed_pred, ), iou_threshold=0.5, threshold=0.5, S=[13, 26, 52], B=3, device=self.device, ) mean_avg_prec = mAP(pred_boxes, target_boxes, iou_threshold=0.5) return mean_avg_prec
def main(): model = Yolov1(split_size=7, num_boxes=2, num_classes=20).to(DEVICE) optimizer = optim.Adam( model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY ) loss_fn = YoloLoss() if LOAD_MODEL: load_checkpoint(torch.load(LOAD_MODEL_FILE), model, optimizer) train_dataset = VOCDataset( "data/100examples.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR ) test_dataset = VOCDataset( "data/test.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR ) train_loader = DataLoader( dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=True ) test_loader = DataLoader( dataset=test_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=True ) for epoch in range(EPOCHS): pred_boxes, target_boxes = get_bboxes( train_loader, model, iou_threshold=0.5, threshold=0.4 ) mean_avg_prec = mean_average_precision( pred_boxes, target_boxes, iou_threshold=0.5, box_format="midpoint" ) print(f"Train mAP in {epoch}: {mean_avg_prec}") train_fn(train_loader, model, optimizer, loss_fn)
def _calc_map(self, x, y, pred): pred_boxes, target_boxes = get_bboxes( x=x, y=y, predictions=pred, iou_threshold=0.5, threshold=0.4, S=self.S, device=self.device, ) mean_avg_prec = mAP(pred_boxes, target_boxes, iou_threshold=0.5) return mean_avg_prec
def main(): model = YOLOv2_lite(grid_size=GRID_SIZE, num_boxes=NUM_BOXES, num_classes=NUM_CLASSES).to(DEVICE) model.load_state_dict(torch.load(MODEL_PATH)) model.eval() test_dataset = YOLOVOCDataset( DATA_CSV, transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR, S=GRID_SIZE, B=NUM_BOXES, C=NUM_CLASSES, hflip_prob=0.5, ) test_loader = DataLoader( dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=False, ) images, predictions, labels = get_bboxes( test_loader, model, iou_threshold=0.5, prob_threshold=0.4, S=GRID_SIZE, C=NUM_CLASSES, mode="all", return_images=True, ) mAP = mean_average_precision(predictions, labels, num_classes=NUM_CLASSES) print("Mean Average Precision: %.3f" % (mAP)) img_to_plot = np.random.randint(0, len(images)) image = images[img_to_plot] img_preds = [pred[1:] for pred in predictions if pred[0] == img_to_plot] img_labels = [label[1:] for label in labels if label[0] == img_to_plot] #plot_detections(image, img_preds) plot_detections(image, img_labels)
def main(): model = YOLOv1(split_size=7, num_boxes=2, num_classes=20).to(device) optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=wd) loss_fn = YoloLoss() if load_model: load_checkpoint(torch.load(load_model_file), model, optimizer) train_dataset = VOCDataset("data/8examples.csv", transform=transform, img_dir=img_dir, label_dir=label_dir) test_dataset = VOCDataset("data/test.csv", transform=transform, img_dir=img_dir, label_dir=label_dir) train_loader = DataLoader(dataset=train_dataset, batch_size=bs, num_workers=num_workers, pin_memory=pin_mem, shuffle=True, drop_last=False) test_loader = DataLoader(dataset=test_dataset, batch_size=bs, num_workers=num_workers, pin_memory=pin_mem, shuffle=True, drop_last=True) for epoch in range(epochs): pred_boxes, target_boxes = get_bboxes(train_loader, model, iou_threshold=0.5, threshold=0.4) mean_avg_prec = mean_average_precision(pred_boxes, target_boxes, iou_threshold=0.5, box_format="midpoint") print(f"Train mAP: {mean_avg_prec}") train_fn(train_loader, model, optimizer, loss_fn)
joblib.load(model_fname + '_svc.pickle') file_list = sorted(glob.glob('test_images/*.jpg')) output_dir = 'output_images/' for f in file_list: time_start = time.time() fname = f[f.rindex('/') + 1:] print('Processing', fname) img = cv2.imread(f) boxes = utils.detect_vehicles_parallel(img, scaler, clf) cv2.imwrite(output_dir + 'raw_boxes_' + fname, \ utils.draw_boxes(img, boxes)) heatmap = utils.get_heatmap(img.shape, boxes, 1) cv2.imwrite(output_dir + 'hm_no_thresh_' + fname, \ (heatmap * 255).astype(np.uint8)) heatmap = utils.get_heatmap(img.shape, boxes, 3) cv2.imwrite(output_dir + 'hm_thresh_' + fname, \ (255*heatmap).astype(np.uint8)) hmlbl, lbls = utils.get_labels(heatmap) if lbls: cv2.imwrite(output_dir + 'labeled_hm_' + fname, \ (hmlbl*(255//lbls)).astype(np.uint8)) else: cv2.imwrite(output_dir + 'labeled_hm_' + fname, \ hmlbl.astype(np.uint8)) bboxes = utils.get_bboxes(hmlbl, lbls) img_final = utils.draw_boxes(img, bboxes) cv2.imwrite(output_dir + 'final_' + fname, img_final) time_end = time.time() print(-time_start + time_end)
def train_loop(cfg_path, gpu_n='0'): # get configs with open(cfg_path, 'r') as stream: config = yaml.safe_load(stream) device = torch.device('cuda:{}'.format(gpu_n) if config['GPU'] and torch.cuda.is_available else 'cpu') dtype = torch.float32 # TODO: find out how it affects speed and accuracy MODEL = config['MODEL'] LOAD_MODEL = config['LOAD_MODEL'] LOAD_MODEL_FILE = config['LOAD_MODEL_FILE'] SAVE_MODEL = config['SAVE_MODEL'] SAVE_MODEL_N = config['SAVE_MODEL_N'] SAVE_MODEL_DIR = config['SAVE_MODEL_DIR'] DATASET_DIR = config['DATASET_DIR'] L_RATE = config['LEARNING_RATE'] DECAY_RATE = config['DECAY_RATE'] DECAY_EPOCHS = config['DECAY_EPOCHS'] WEIGHT_DECAY = config['WEIGHT_DECAY'] EPOCHS = config['EPOCHS'] BATCH_SIZE = config['BATCH_SIZE'] NUM_WORKERS = config['NUM_WORKERS'] PIN_MEMORY = config['PIN_MEMORY'] CSV_TRAIN = config['CSV_TRAIN'] CSV_VAL = config['CSV_VAL'] # set up model if MODEL == 'Darknet': model = YoloV1(grid_size=7, num_boxes=2, num_classes=20).to(DEVICE) elif MODEL == 'VGG': pass # add here VGG backbone if LOAD_MODEL: # TODO: load backbone # cfg_cp, start_epoch = load_checkpoint(LOAD_MODEL_FILE, model) val = input( 'Do you want to use config from checkpoint? Answer "yes" or "no": ' ) # if 'val' == 'yes': # L_RATE = cfg_cp['LEARNING_RATE'] # DECAY_RATE = cfg_cp['DECAY_RATE'] # DECAY_EPOCHS = cfg_cp['DECAY_EPOCHS'] # WEIGHT_DECAY = cfg_cp['WEIGHT_DECAY'] # BALANCED = cfg_cp['BALANCED_DATASET'] # BATCH_SIZE = cfg_cp['BATCH_SIZE'] # NUM_WORKERS = cfg_cp['NUM_WORKERS'] # PIN_MEMORY = cfg_cp['PIN_MEMORY'] # MIN_IMAGES = cfg_cp['MIN_IMAGES'] # LOSS = cfg_cp['LOSS'] else: model = init_weights(model) start_epoch = 0 optimizer = optim.Adam(model.parameters(), lr=L_RATE, weight_decay=WEIGHT_DECAY) loss_fn = YoloLoss() loader_params = BATCH_SIZE, NUM_WORKERS, PIN_MEMORY, DATASET_DIR, CSV_TRAIN, CSV_VAL loader = get_dataloader(loader_params) # create folder to save models if SAVE_MODEL: if not os.path.exists('{}/{}'.format(SAVE_MODEL_DIR, MODEL)): os.makedirs('{}/{}'.format(SAVE_MODEL_DIR, MODEL)) losses, accuracies = { 'train': [], 'validate': [] }, { 'train': [], 'validate': [] } for epoch in range(start_epoch, EPOCHS + start_epoch): t = time() if (epoch + 1) % DECAY_EPOCHS == 0: L_RATE *= (1 - DECAY_RATE) optimizer = optim.Adam(model.parameters(), lr=L_RATE, weight_decay=WEIGHT_DECAY) # print epoch number print_report(part='start', epoch=epoch) # train loop train_epoch(loader['train'], model, optimizer, device, loss_fn) # print metrics pred_bb, target_bb = get_bboxes(loader['train'], model, iou_threshold=0.5, threshold=0.4) train_map = mean_average_precision(pred_bb, target_bb, iou_threshold=0.5, box_format='midpoint') v_pred_bb, v_target_bb = get_bboxes(loader['val'], model, iou_threshold=0.5, threshold=0.4) val_map = mean_average_precision(v_pred_bb, v_target_bb, iou_threshold=0.5, box_format='midpoint') metrics = -1, -1, train_map, val_map print_report(part='accuracy', metrics=metrics) # collect metrics # losses['train'].append(train_loss) # losses['validate'].append(val_loss) # accuracies['train'].append(train_acc) # accuracies['validate'].append(val_acc) # save models # if SAVE_MODEL: # save_checkpoint(model=model, cfg=cfg, epoch=epoch, loss=round(val_loss, 3)) # print time print_report(part='end', t=int(time() - t))
def main(): model = Yolov1(split_size=S, num_boxes=B, num_classes=C).to(DEVICE) optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY) loss_fn = YoloLoss(S=S, B=B, C=C) if LOAD_MODEL: load_checkpoint(torch.load(LOAD_MODEL_FILE), model, optimizer) train_dataset = VOCDataset( training_path= '/home/mt/Desktop/For_github/computer_vision_projects/face_recognition/data', S=3, C=2, transform=transform) # test_dataset = VOCDataset( # "data/test.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR, # ) train_loader = DataLoader( dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=True, ) # test_loader = DataLoader( # dataset=test_dataset, # batch_size=BATCH_SIZE, # num_workers=NUM_WORKERS, # pin_memory=PIN_MEMORY, # shuffle=True, # drop_last=True, # ) for epoch in range(EPOCHS): # for x, y in train_loader: # x = x.to(DEVICE) # for idx in range(8): # bboxes = cellboxes_to_boxes(model(x)) # bboxes = non_max_suppression(bboxes[idx], iou_threshold=0.5, threshold=0.4, box_format="midpoint") # plot_image(x[idx].permute(1,2,0).to("cpu"), bboxes) # import sys # sys.exit() pred_boxes, target_boxes = get_bboxes(train_loader, model, iou_threshold=0.5, threshold=0.4) mean_avg_prec = mean_average_precision(pred_boxes, target_boxes, iou_threshold=0.5, box_format="midpoint") print(f"Train mAP: {mean_avg_prec}") #if mean_avg_prec > 0.9: # checkpoint = { # "state_dict": model.state_dict(), # "optimizer": optimizer.state_dict(), # } # save_checkpoint(checkpoint, filename=LOAD_MODEL_FILE) # import time # time.sleep(10) train_fn(train_loader, model, optimizer, loss_fn)
def main(): model = Yolov1(split_size=7, num_boxes=2, num_classes=20).to(DEVICE) optimizer = optim.Adam( model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY ) loss_fn = YoloLoss() if LOAD_MODEL: load_checkpoint(torch.load(LOAD_MODEL_FILE), model, optimizer) train_dataset = VOCDataset( # test.csv, 8examples.csv, 100examples.csv "data/8examples.csv", transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR, ) test_dataset = VOCDataset( "data/test.csv" , transform = transform, img_dir = IMG_DIR, label_dir = LABEL_DIR ) train_loader = DataLoader( dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False, ) test_loader = DataLoader( dataset=test_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False, ) for epoch in range(EPOCHS): # for x, y in train_loader: # x = x.to(DEVICE) # for idx in range(8): # bboxes = cellboxes_to_boxes(model(x)) # bboxes = non_max_suppression(bboxes[idx], iou_threshold=0.5, threshold=0.4, box_format="midpoint") # plot_image(x[idx].permute(1,2,0).to("cpu"), bboxes) # import sys # sys.exit() pred_boxes, target_boxes = get_bboxes( train_loader, model, iou_threshold=0.5, threshold=0.4 , device= DEVICE, ) mean_avg_prec = mean_average_precision( pred_boxes, target_boxes, iou_threshold=0.5, box_format="midpoint" ) if mean_avg_prec > 0.9: checkpoint = { "state_dict": model.state_dict(), "optimizer": optimizer.state_dict(), } save_checkpoint(checkpoint, filename=LOAD_MODEL_FILE) import time time.sleep(10) print(f"Train mAP: {mean_avg_prec}") train_fn(train_loader, model, optimizer, loss_fn)
def main(): model = YOLOv1(grid_size=GRID_SIZE, num_boxes=NUM_BOXES, num_classes=NUM_CLASSES).to(DEVICE) optimizer = optim.Adam( model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY ) loss_fn = YoloLoss(S=GRID_SIZE, B=NUM_BOXES, C=NUM_CLASSES) epochs_passed = 0 if LOAD_CHECKPOINT: checkpoint = torch.load(LOAD_CHECKPOINT_PATH) model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) for param_group in optimizer.param_groups: param_group['lr'] = 2e-6 epochs_passed = checkpoint['epoch'] mask_dataset = YOLOVOCDataset( TRAINING_DATA, transform=train_transform, img_dir=IMG_DIR, label_dir=LABEL_DIR, S=GRID_SIZE, B=NUM_BOXES, C=NUM_CLASSES, hflip_prob = 0.5, random_crops=0.25, ) train_dataset, val_dataset = random_split ( mask_dataset, [TRAIN_SIZE, VAL_SIZE], generator=torch.Generator().manual_seed(42), ) if torch.cuda.is_available(): train_loader = DataLoader( dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=DROP_LAST, ) val_loader = DataLoader( dataset=val_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=False, ) else: train_loader = DataLoader( dataset=train_dataset, batch_size=BATCH_SIZE, #num_workers=NUM_WORKERS, #pin_memory=PIN_MEMORY, shuffle=True, drop_last=DROP_LAST, ) val_loader = DataLoader( dataset=val_dataset, batch_size=BATCH_SIZE, #num_workers=NUM_WORKERS, #pin_memory=PIN_MEMORY, shuffle=True, drop_last=False, ) for epoch in range(EPOCHS): if epochs_passed%2 == 0: train_pred_boxes, train_target_boxes = get_bboxes( train_loader, model, iou_threshold=0.35, prob_threshold=0.4, S=GRID_SIZE, C=NUM_CLASSES, mode = "batch", device=DEVICE, ) val_pred_boxes, val_target_boxes = get_bboxes( val_loader, model, iou_threshold=0.35, prob_threshold=0.4, S=GRID_SIZE, C=NUM_CLASSES, mode = "batch", device=DEVICE, ) # map function takes predicted boxes and ground truth # boxes in form [[],[],[],...] where each sublist is a bounding box # of form [image_index, class_pred, x_mid, y_mid, w, h, prob] train_mAP = single_map( train_pred_boxes, train_target_boxes, box_format="midpoint", num_classes=NUM_CLASSES, iou_threshold=0.35, ) val_mAP = single_map( val_pred_boxes, val_target_boxes, box_format="midpoint", num_classes=NUM_CLASSES, iou_threshold=0.35, ) train_mAPs.append(train_mAP) val_mAPs.append(val_mAP) epochs_recorded.append(epochs_passed) print("Train mAP: %f"%(train_mAP)) print("Val mAP: %f"%(val_mAP)) if epochs_passed%10 == 0: save_path = SAVE_CHECKPOINT_PATH + ("checkpoint_%de"%(epochs_passed))+".pt" checkpoint = { 'epoch': epochs_passed, 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), } torch.save(checkpoint,save_path) print("Trained for %d epochs"%(epochs_passed)) train_fn(train_loader, model, optimizer, loss_fn) epochs_passed += 1
def main(): IMG_DIR = "../datasets/voc/images" LABEL_DIR = "../datasets/voc/labels" MAPPING_FILE = "../datasets/voc/100examples.csv" BATCH_SIZE = 8 NUM_WORKERS = 2 PIN_MEMORY = True DEVICE = "cuda" if torch.cuda.is_available() else "cpu" LEARNING_RATE = 4e-4 WEIGHT_DECAY = 0.0 EPOCHS = 100 LOAD_MODEL_FILE = "retrained_grad_true.pth.tar" S = 7 C = 20 B = 2 PRETRAINED = True print("Using Device:", DEVICE) class Compose(object): def __init__(self, transforms): self.transforms = transforms def __call__(self, image, bboxes): for t in self.transforms: image = t(image) return image, bboxes # Types of preprocessing transforms we want to apply convert_transform = transforms.ToTensor() resize_transform = transforms.Resize((448, 448)) # normalize_transform = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = Compose([convert_transform, resize_transform]) train_dataset = VOCDataset(MAPPING_FILE, S=S, C=C, B=B, transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR) train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=True) val_dataset = VOCDataset(MAPPING_FILE, S=S, C=C, B=B, transform=transform, img_dir=IMG_DIR, label_dir=LABEL_DIR) val_loader = DataLoader(dataset=val_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY, shuffle=True, drop_last=True) model = YoloV1(S=S, B=B, C=C, pretrained=PRETRAINED).to(DEVICE) for counter, param in enumerate(model.resnet.parameters()): param.requires_grad = True model.resnet.fc.requires_grad = True for counter, param in enumerate(model.parameters()): print(counter, param.requires_grad) parameters = [param.numel() for param in model.parameters()] print("Number of model parameters", sum(parameters)) parameters = [param.numel() for param in model.resnet.parameters()] print("Number of resnet parameters", sum(parameters)) parameter_list = filter(lambda p: p.requires_grad, model.parameters()) optimizer = optim.Adam(parameter_list, lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY) yolo_loss = YoloLoss(S=S, C=C, B=B) writer = SummaryWriter() current_time = time.time() mean_loss_list = [] for epoch in range(EPOCHS): mean_loss = [] pred_boxes, target_boxes = get_bboxes(train_loader, model, iou_threshold=0.5, threshold=0.4, device=DEVICE) mean_avg_prec = mean_average_precision(pred_boxes, target_boxes, iou_threshold=0.5, box_format="midpoint") # Save the model if mean_avg_prec > 0.99 or epoch == (EPOCHS - 1): checkpoint = { "state_dict": model.state_dict(), "optimizer": optimizer.state_dict(), } print("=> Saving checkpoint") torch.save(checkpoint, LOAD_MODEL_FILE) time.sleep(10) for batch_idx, (x, y) in enumerate(train_loader): x, y = x.to(DEVICE), y.to(DEVICE) y_p = model(x) # y = torch.flatten(y, start_dim=1, end_dim=3) y_p = torch.reshape(y_p, (BATCH_SIZE, S, S, C + 5 * B)) loss = yolo_loss(y_p, y) mean_loss.append(loss.item()) optimizer.zero_grad() loss.backward() optimizer.step() # Calculate average loss mean_loss = sum(mean_loss)/len(mean_loss) delta_time = time.time() - current_time current_time = time.time() writer.add_scalar("Average Loss: ", mean_loss, epoch) writer.add_scalar("Mean Average Precision: ", mean_avg_prec, epoch) writer.add_scalar("Epoch Duration [s]", delta_time, epoch) print("Epoch:", epoch) mean_loss_list.append(mean_loss) writer.close()