HI guys I’ve been doing Object detection using Retinanet net ,I would like to see if my network is learning well ,So i intentionally use training set data for predictions ,However,the result turns out totally terrible,The prediction of my output have way too many boxes ,In fact,it covers the whole images,I suspect that the way that I save or load state_dict was wrong …

Here’s what I do…

```
training_iterations = 0
avg_loss = 0.
model = Retina_Net(args.num_class)
#load resnet50 weights and some initializations
weights = torch.load(join("weights","retinet.pth"))
model.load_state_dict(weights)
model.cuda()
loss_function = Focal_loss(args.num_class)
optimizer = optim.AdamW(model.parameters(),lr = args.lr,weight_decay=args.weight_decay)
def train(epoch,mode=True,beta=0.99):
model.train(mode)
global training_iterations
global avg_loss
for num_batch,(inputs,loc_targets,cls_targets) in enumerate(training_set_loader):
inputs = inputs.cuda()
loc_targets = loc_targets.cuda()
cls_targets = cls_targets.cuda()
optimizer.zero_grad()
#I use cosine form warmup and annealing for momentum and lr
optimizer.param_groups[0]["lr"] = lr_distr[training_iterations]
optimizer.param_groups[0]["betas"] = (mom_distr[training_iterations].item(),0.999)
loc_preds,cls_preds = model(inputs)
loss = loss_function(loc_preds, loc_targets, cls_preds, cls_targets)
#back prop
loss.backward()
#update parameters
optimizer.step()
avg_loss = loss.item()*(1-beta)+avg_loss*beta
smooth_loss = avg_loss/(1-(beta**(training_iterations+1)))
training_iterations+=1
training_loss.append(smooth_loss)
global best_loss
model.eval()
if smooth_loss<best_loss:
weight_dir = join("weights",args.files.split(".")[0])
if not exists(weight_dir):
mkdir(weight_dir)
torch.save(model.state_dict(),join(weight_dir,"Epoch_{
}_{:.3f}.pth".format(epoch,smooth_loss)))
best_loss = smooth_loss
for epoch in range(1,args.epochs+1):
train(epoch)
```

And predicting:

```
model = Retina_Net()
losses=[]
#sort and use the one with lowest loss
for weight in weights:
losses.append((weight,float(weight.split("/")[-1].split("_")[-1].split(".pth")[0])))
losses.sort(key= lambda x:x[1])
model.load_state_dict(torch.load(losses[0][0]))
#turn the model into test mode
model.eval()
#then predict
```

I would like to know if there’s anything I do wrong or missing.

Thanks in advance!!!