arunm8489

#Let us load the weights for the Convolutional layers
# we are loading weights as common beacuse when batchnormalization is present there is no bias for conv layer
num_weights = conv.weight.numel()
   
#Do the same as above for weights
conv_weights = torch.from_numpy(weights[ptr:ptr+num_weights])
ptr = ptr + num_weights
conv_weights = conv_weights.view_as(conv.weight.data)
conv.weight.data.copy_(conv_weights)
# Note: we dont have bias for conv when batch normalization is there

arunm8489

else:
  #Number of biases
  num_biases = conv.bias.numel()
                
  #Load the weights
  conv_biases = torch.from_numpy(weights[ptr: ptr + num_biases])
  ptr = ptr + num_biases
                    
  #reshape the loaded weights according to the dims of the model weights
  conv_biases = conv_biases.view_as(conv.bias.data)

arunm8489

conv = model[0]
                
if (batch_normalize):
   bn = model[1]
                    
   #Get the number of weights of Batch Norm Layer
   num_bn_biases = bn.bias.numel()
                    
   #Load the weights
   bn_biases = torch.from_numpy(weights[ptr:ptr + num_bn_biases])

arunm8489

for i in range(len(self.module_list)):
    module_type = self.blocks[i + 1]["type"]        
    if module_type == "convolutional":
       model = self.module_list[i]
       try:
          batch_normalize = int(self.blocks[i+1]["batch_normalize"])
       except:
          batch_normalize = 0

arunm8489

fp = open(weightfile, "rb")

#The first 5 values are header information 
# 1. Major version number
# 2. Minor Version Number
# 3. Subversion number 
# 4,5. Images seen by the network (during training)
header = np.fromfile(fp, dtype = np.int32, count = 5)
weights = np.fromfile(fp, dtype = np.float32)

arunm8489

#log space transform height and the width
anchors = torch.FloatTensor(anchors)
if CUDA:
   anchors = anchors.cuda()
anchors = anchors.repeat(grid_size*grid_size, 1).unsqueeze(0)
prediction[:,:,2:4] = torch.exp(prediction[:,:,2:4])*anchors #width and height
prediction[:,:,5: 5 + num_classes] = torch.sigmoid((prediction[:,:, 5 : 5 + num_classes]))    
prediction[:,:,:4] *= stride    
return prediction

arunm8489

#Add the center offsets
grid = np.arange(grid_size)
a,b = np.meshgrid(grid, grid)

x_offset = torch.FloatTensor(a).view(-1,1) #(1,gridsize*gridsize,1)
y_offset = torch.FloatTensor(b).view(-1,1)

if CUDA:
   x_offset = x_offset.cuda()
   y_offset = y_offset.cuda()

arunm8489

# the dimension of anchors is wrt original image.We will make it corresponding to feature map
anchors = [(a[0]/stride, a[1]/stride) for a in anchors]

#Sigmoid the  centre_X, centre_Y. and object confidencce
prediction[:,:,0] = torch.sigmoid(prediction[:,:,0])
prediction[:,:,1] = torch.sigmoid(prediction[:,:,1])
prediction[:,:,4] = torch.sigmoid(prediction[:,:,4])
    

arunm8489

#eg detection input dimension [1, 255, 13, 13]
prediction = x.view(batch_size, bbox_attrs*num_anchors, grid_size*grid_size) # 1x255x169     
prediction = prediction.transpose(1,2).contiguous() #1x169x255
prediction = prediction.view(batch_size, grid_size*grid_size*num_anchors, bbox_attrs) #1x507x85

arunm8489

# x --> 4D feature map
batch_size = x.size(0)
grid_size = x.size(2)
# factor by which current feature map reduced from input
stride =  inp_dim // x.size(2)   
        
bbox_attrs = 5 + num_classes #5 + 80
num_anchors = len(anchors) #3
    
#eg detection input dimension [1, 255, 13, 13]