Hi, motokimura,
I'm sorry, I have to ask you again, the question is about Maxpool Layer in darknet.py file of "_make_conv_layers", is about "nn.MaxPool2d(2)", the function nn.MaxPool2d(2), you didn't use the "stride" parameter, but the author paper has to stride, so i have confusion, could you give a more explain?

thank you very much!

hi, motokimura,
i have a question about "_make_fc_layers" in "darknet.py", the yolo author is training darknet in Imagenet, the data classes is about 1000, but we are training in voc data set, the classes is about 20, so, the below picture red box wether change to 20?

in voc.py

def random_scale(self, img, boxes):

WHY
img = cv2.resize(img, dsize=(int(w * scale), h), interpolation=cv2.INTER_LINEAR)

I suggest
img = cv2.resize(img, dsize=(int(w * scale), int(h * scale)), interpolation=cv2.INTER_LINEAR)

@motokimura, I have trained this network and during training I found out that the size of weights are so big. Do you remember what was the weight size of your model? Mine is 1.1Gb

• What was the mAP?

pred_xyxy[:, :2] = pred[:, 2]/float(S) - 0.5 * pred[:, 2:4]
pred_xyxy[:, 2:4] = pred[:, 2]/float(S) + 0.5 * pred[:, 2:4]

should be changed to
pred_xyxy[:, :2] = pred[:, :2]/float(S) - 0.5 * pred[:, 2:4]
pred_xyxy[:, 2:4] = pred[:, :2]/float(S) + 0.5 * pred[:, 2:4]

and also for target_xyxy

hi, when I run your code, I counter the problem, as follows the show, could you give me help?:

def compute_iou(self,bbox1,bbox2):
# 获取box1的第一个维度
N = bbox1.size(0)
# 获取box2的第一个维度
M = bbox2.size(0)
# Compute left-top coordinate of the intersections
#
lt = torch.max(
# [N, 2] -> [N, 1, 2] -> [N, M, 2]
bbox1[:,:2].unsqueeze(1).expand(N,M,2),
# [M, 2] -> [1, M, 2] -> [N, M, 2]
bbox2[:,:2].unsqueeze(0).expand(N,M,2)
)
rb = torch.min(
# [N, 2] -> [N, 1, 2] -> [N, M, 2]
bbox1[:, 2:].unsqueeze(1).expand(N, M, 2),
# [M, 2] -> [1, M, 2] -> [N, M, 2]
bbox2[:, 2:].unsqueeze(0).expand(N, M, 2)
)
pass

after torch.max(bbox1,bbox2),the point may be right top instead of left top
after torch.min(bbox1,bbox2),the point may be left bottom instead of right bottom

As stated in the title.

In voc.py module (l. 120) you normalize coordinates such as :

xy, wh, label = boxes_xy[b], boxes_wh[b], int(labels[b])
ij = (xy / cell_size).ceil() - 1.0
i, j = int(ij[0]), int(ij[1]) # y & x index which represents its location on the grid.
x0y0 = ij * cell_size # x & y of the cell left-top corner.
xy_normalized = (xy - x0y0) / cell_size # x & y of the box on the cell, normalized from 0.0 to 1.0.

Predicted coordinates will converge to a such normalize form. So, why do you rescale your pred_xyxy in that way in the loss.py module (l. 114) ?

pred_xyxy = Variable(torch.FloatTensor(pred.size())) # [B, 5=len([x1, y1, x2, y2, conf])]
# Because (center_x,center_y)=pred[:, 2] and (w,h)=pred[:,2:4] are normalized for cell-size and image-size respectively,
# rescale (center_x,center_y) for the image-size to compute IoU correctly.
pred_xyxy[:,  :2] = pred[:, :2]/float(S) - 0.5 * pred[:, 2:4]
pred_xyxy[:, 2:4] = pred[:, :2]/float(S) + 0.5 * pred[:, 2:4]

If I understand correctly this block, you normalized by S your grid number (here, 7 I suppose) a value which is already normalized in a certain form (normalized by the grid cell here). Can't that be an issue ?