def forward(self, y_true, y_pred):
"""
- y_pred to bbox_abs
- get pred_xy_rel and pred_wh_rel
"""
pred_box_abs, pred_obj, pred_landmark, pred_box_rel = get_absolute_yolo_box(
y_pred, self.valid_anchors_wh, self.num_landmarks)
# print(self.valid_anchors_wh)
# print('=' * 20, 'get_abs_pred', '*' * 20)
# print(pred_box_abs.shape)
# print(pred_obj.shape)
# print(pred_landmark.shape)
# print(pred_box_rel.shape)
pred_box_abs = xywh_to_x1x2y1y2(pred_box_abs)
pred_xy_rel = pred_box_rel[..., 0:2]
pred_wh_rel = pred_box_rel[..., 2:4]
"""
- y_true to bbox_rel
- get true_xy_rel and true_wh_rel
"""
true_box_rel, true_obj, true_landmark, true_box_abs = get_relative_yolo_box(
y_true, self.valid_anchors_wh, self.num_landmarks)
# print(true_obj)
# print('=' * 20, 'get_rel_pred', '*' * 20)
# print(true_box_rel.shape)
# print(true_obj.shape)
# print(true_landmark.shape)
# print(true_box_abs.shape)
true_box_abs = xywh_to_x1x2y1y2(true_box_abs)
true_xy_rel = true_box_rel[..., 0:2]
true_wh_rel = true_box_rel[..., 2:4]
true_wh_abs = true_box_abs[..., 2:4]
weight = 2 - true_wh_abs[..., 0] * true_wh_abs[..., 1]
# print('=' * 20, 'calc_loss', '*' * 20)
xy_loss = self.calc_xy_loss(true_xy_rel, pred_xy_rel, true_obj, weight)
wh_loss = self.calc_xy_loss(true_wh_rel, pred_wh_rel, true_obj, weight)
landmark_loss = self.calc_xy_loss(true_landmark, pred_landmark,
true_obj, weight)
ignore_mask = self.calc_ignore_mask(true_box_abs, pred_box_abs,
true_obj)
# print('=' * 10, 'xy_loss', '=' * 10)
# print(xy_loss)
# print('=' * 10, 'wh_loss', '=' * 10)
# print(wh_loss)
# print('=' * 10, 'landmark_loss', '=' * 10)
# print(landmark_loss)
# print('-' * 10, 'obj_loss', '-' * 10)
obj_loss = self.calc_obj_loss(true_obj, pred_obj, ignore_mask)
return xy_loss + wh_loss + landmark_loss + obj_loss, (xy_loss, wh_loss,
landmark_loss,
obj_loss)
def forward(self, inputs, training):
# y0, y1, y2
x_s, x_m, x_l = self.backbone(inputs)
x = self.large_5dbl(x_l)
y_large = self.large_feature(x)
x = self.large_upsampling(x)
x = torch.cat((x, x_m), 1)
x = self.medium_5dbl(x)
y_medium = self.medium_feature(x)
x = self.medium_upsampling(x)
x = torch.cat((x, x_s), 1)
x = self.small_5dbl(x)
y_small = self.small_feature(x)
# (batch, 3(anchor box) x (5 + num_classes), grid, grid) 형태
y_small_shape = y_small.shape
y_medium_shape = y_medium.shape
y_large_shape = y_large.shape
# (batch, grid, grid, 3, 5 + num_classes)로 변환환
y_small = y_small.view(y_small_shape[0], -1, 3, y_small_shape[-2],
y_small_shape[-1]).permute(0, -1, -2, 2, 1)
y_medium = y_medium.view(y_medium_shape[0], -1, 3, y_medium_shape[-2],
y_medium_shape[-1]).permute(0, -1, -2, 2, 1)
y_large = y_large.view(y_large_shape[0], -1, 3, y_large_shape[-2],
y_large_shape[-1]).permute(0, -1, -2, 2, 1)
if training:
return y_small, y_medium, y_large
box_small = get_absolute_yolo_box(y_small, anchors_wh[0:3],
self.num_classes)
box_medium = get_absolute_yolo_box(y_medium, anchors_wh[3:6],
self.num_classes)
box_large = get_absolute_yolo_box(y_large, anchors_wh[6:9],
self.num_classes)
return box_small, box_medium, box_large
def forward(self, inputs, training):
x_small, x_medium, x_large = self.backbone(inputs)
x = self.large_scale_dbl5(x_large)
y_large = self.large_scale_detection(x)
x = self.large_scale_upsampling(x)
x = torch.cat((x, x_medium), 1)
x = self.medium_scale_block(x)
y_medium = self.medium_scale_detection(x)
x = self.medium_scale_upsampling(x)
x = torch.cat((x, x_small), 1)
x = self.small_scale_block(x)
y_small = self.small_scale_detection(x)
y_large_shape = y_large.shape
y_medium_shape = y_medium.shape
y_small_shape = y_small.shape
y_large = y_large.view(y_large_shape[0], -1, 3, y_large_shape[-2],
y_large_shape[-1]).permute(0, -1, -2, 2, 1)
y_medium = y_medium.view(y_medium_shape[0], -1, 3, y_medium_shape[-2],
y_medium_shape[-1]).permute(0, -1, -2, 2, 1)
y_small = y_small.view(y_small_shape[0], -1, 3, y_small_shape[-2],
y_small_shape[-1]).permute(0, -1, -2, 2, 1)
if training:
return y_small, y_medium, y_large
box_small = get_absolute_yolo_box(y_small, anchors_wh[0:3],
self.num_landmarks)
box_medium = get_absolute_yolo_box(y_medium, anchors_wh[3:6],
self.num_landmarks)
box_large = get_absolute_yolo_box(y_large, anchors_wh[6:9],
self.num_landmarks)
return box_small, box_medium, box_large
def forward(self, y_true, y_pred):
# iou, ignore_mask 계산에 필요
pred_box_abs, pred_obj, pred_class, pred_box_rel = get_absolute_yolo_box(
y_pred, self.valid_anchors_wh, self.num_classes)
pred_box_abs = xywh_to_x1x2y1y2(pred_box_abs)
pred_xy_rel = pred_box_rel[..., 0:2]
pred_wh_rel = pred_box_rel[..., 2:4]
# print(f'pred_box_abs: {pred_box_abs.shape}')
# print(f'pred_xy_rel: {pred_xy_rel.shape}')
# print(f'pred_wh_rel: {pred_wh_rel.shape}')
# loss 계산에 필요
true_box_rel, true_obj, true_class, true_box_abs = get_relative_yolo_box(
y_true, self.valid_anchors_wh, self.num_classes)
true_box_abs = xywh_to_x1x2y1y2(true_box_abs)
true_xy_rel = true_box_rel[..., 0:2]
true_wh_rel = true_box_rel[..., 2:4]
true_wh_abs = true_box_abs[..., 2:4]
# print(f'true_box_abs: {true_box_abs.shape}')
# print(f'true_box_rel: {true_box_rel.shape}')
# print(f'true_obj_rel: {true_obj.shape}')
# w, h를 통해 작은 box detect를 위한 조정
weight = 2 - true_wh_abs[..., 0] * true_wh_abs[..., 1]
xy_loss = self.calc_xywh_loss(true_xy_rel, pred_xy_rel, true_obj,
weight)
wh_loss = self.calc_xywh_loss(true_wh_rel, pred_wh_rel, true_obj,
weight)
class_loss = self.calc_class_loss(true_obj, true_class, pred_class)
ignore_mask = self.calc_ignore_mask(true_box_abs, pred_box_abs,
true_obj)
# print(f'ignore_mask: {ignore_mask.shape}')
obj_loss = self.calc_obj_loss(true_obj, pred_obj, ignore_mask)
# print(f'xy_loss : {xy_loss}')
# print(f'wh_loss : {wh_loss}')
# print(f'class_loss : {class_loss}')
# print(f'ignore_mask : {ignore_mask}')
# print(f'obj_loss : {obj_loss}')
return xy_loss + wh_loss + class_loss + obj_loss, (xy_loss, wh_loss,
class_loss,
obj_loss)
def forward(self, y_true, y_pred):
# print(y_true[0][idx[0]][idx[1]][idx[2]][:5])
# print(y_pred[0][idx[0]][idx[1]][idx[2]][:5])
# iou, ignore_mask 계산에 필요
pred_box_abs, pred_obj, pred_class, pred_box_rel = get_absolute_yolo_box(
y_pred, self.valid_anchors_wh, self.num_classes)
pred_box_abs = xywh_to_x1x2y1y2(pred_box_abs)
pred_xy_rel = pred_box_rel[..., 0:2]
pred_wh_rel = pred_box_rel[..., 2:4]
# loss 계산에 필요
# print('======', y_true[0][idx[0]][idx[1]][idx[2]][:5])
true_box_rel, true_obj, true_class, true_box_abs = get_relative_yolo_box(
y_true, self.valid_anchors_wh, self.num_classes)
# print(true_box_rel)
# print(true_box_rel[0][9][4][2])
# print(true_obj[0][9][4][2])
true_box_abs = xywh_to_x1x2y1y2(true_box_abs)
true_xy_rel = true_box_rel[..., 0:2]
true_wh_rel = true_box_rel[..., 2:4]
true_wh_abs = true_box_abs[..., 2:4]
# w, h를 통해 작은 box detect를 위한 조정
weight = 2 - true_wh_abs[..., 0] * true_wh_abs[..., 1]
xy_loss = self.calc_xywh_loss(true_xy_rel, pred_xy_rel, true_obj,
weight)
wh_loss = self.calc_xywh_loss(true_wh_rel, pred_wh_rel, true_obj,
weight)
class_loss = self.calc_class_loss(true_obj, true_class, pred_class)
ignore_mask = self.calc_ignore_mask(true_box_abs, pred_box_abs,
true_obj)
obj_loss = self.calc_obj_loss(true_obj, pred_obj, ignore_mask)
return xy_loss + wh_loss + class_loss + obj_loss, (xy_loss, wh_loss,
class_loss,
obj_loss)
def main():
# DB_path = './data/VOC2007_trainval/'
# csv_file = '2007_train.csv'
DB_path = './data/ex'
csv_file = 'ex_train.csv'
pth_dir = './models/'
# # 학습했던 모델 불러오기
saved_pth_dir = './models'
pth_file = '999_0.8255.pth'
use_cuda = torch.cuda.is_available()
device = torch.device(
'cuda' if torch.cuda.is_available() else torch.device('cpu'))
num_classes = 20
lr_rate = 0.001
dataset = CustomDataset(DB_path, csv_file, num_classes)
dataloader = DataLoader(dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=0)
model = YoloV3(num_classes).to(device)
# loss_object = [Yololoss(num_classes, valid_anchors_wh) for valid_anchors_wh in anchors_wh_mask]
optimizer = torch.optim.Adam(model.parameters(), lr=lr_rate)
loss1 = Yololoss(num_classes, anchors_wh_mask[2]).cuda()
# EPOCH = 1
true_idxs = [[9, 4, 2], [9, 10, 1], [8, 1, 1], [4, 2, 1], [6, 4, 2],
[6, 10, 1]]
for epoch in range(EPOCH):
model.train()
for image, label in dataloader:
optimizer.zero_grad()
if use_cuda:
image = image.cuda()
# label[0] = label[0].cuda()
# label[1] = label[1].cuda()
label[2] = label[2].cuda()
outputs = model(image, training=True)
y_small, y_medium, y_large = outputs
total_loss, each_loss = loss1(label[2], y_large)
total_loss.backward()
optimizer.step()
print(f'Epoch : {epoch} - loss : {total_loss}')
print(f'obj_loss : {each_loss[3]}')
bbox_abs, objectness, classes, bbox_rel = get_absolute_yolo_box(
y_large, anchors_wh[6:9], num_classes)
for true_idx in true_idxs[:1]:
print(true_idx)
print('Label : ',
label[2][0][true_idx[0]][true_idx[1]][true_idx[2]][5:])
print('Predic: ',
y_large[0][true_idx[0]][true_idx[1]][true_idx[2]][5:])
# print(f'Predict : {bbox_abs[0][9][4][2]} - {objectness[0][9][4][2]}')
print()