def run(train_sets, valid_sets, idx, save_dr):
batch_size = 8
imagenet_data = ImageFolder(train_sets, transform=data_transforms['train'])
test_data = ImageFolder(valid_sets, transform=data_transforms['val'])
data_loader = DataLoader(imagenet_data,
batch_size=batch_size,
shuffle=True)
test_data_loader = DataLoader(test_data, batch_size=1, shuffle=True)
cls_num = len(imagenet_data.class_to_idx)
model = inceptionresnetv2(num_classes=1001, pretrained=None)
model.load_state_dict(
torch.load('/home/dsl/all_check/inceptionresnetv2-520b38e4.pth'),
strict=True)
model.last_linear = nn.Linear(1536, cls_num)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
#optimizer = torch.optim.SGD(model.parameters(), state['learning_rate'], momentum=state['momentum'],
#weight_decay=state['decay'], nesterov=True)
optimizer = torch.optim.Adam(model.parameters(),
state['learning_rate'],
weight_decay=state['decay'],
amsgrad=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = idx
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
factor=0.9,
patience=3)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
loss = focal_loss(output, target)
loss.backward()
optimizer.step()
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, len(data_loader.dataset), loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
state['train_loss'] = loss_avg
def test():
with torch.no_grad():
model.eval()
loss_avg = 0.0
correct = 0
for (data, target) in test_data_loader:
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
output = model(data)
loss = F.cross_entropy(output, target)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
loss_avg += float(loss)
state['test_loss'] = loss_avg / len(test_data_loader.dataset)
state['test_accuracy'] = correct / len(
test_data_loader.dataset)
print(state['test_accuracy'])
best_accuracy = 0.0
for epoch in range(40):
state['epoch'] = epoch
train()
test()
sch.step(state['train_accuracy'])
best_accuracy = (state['train_accuracy'] + state['test_accuracy']) / 2
if best_accuracy > state['best_accuracy']:
state['best_accuracy'] = best_accuracy
torch.save(model.state_dict(), os.path.join(save_dr, idx + '.pth'))
with open(os.path.join(save_dr, idx + '.json'), 'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if state['test_accuracy'] == 1 and epoch > 10:
break
def run(trainr, testdr, name, cls_num, idx):
imagenet_data = ImageFolder(trainr, transform=data_transforms['train'])
test_data = ImageFolder(testdr, transform=data_transforms['val'])
data_loader = DataLoader(imagenet_data, batch_size=8, shuffle=True)
test_data_loader = DataLoader(test_data, batch_size=1, shuffle=True)
model = se_resnext50_32x4d(num_classes=1000, pretrained=None)
model.load_state_dict(
torch.load('/home/dsl/all_check/se_resnext50_32x4d-a260b3a4.pth'),
strict=False)
model.last_linear = nn.Linear(2048, cls_num)
#model.fc2 = nn.Linear(4, cls_num)
#model.load_state_dict(torch.load('log/1006_iv_other.pth'), strict=False)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(),
state['learning_rate'],
momentum=state['momentum'],
weight_decay=state['decay'],
nesterov=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = name
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
factor=0.5,
patience=5)
ll = len(data_loader.dataset)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data.detach().numpy()
if data.size(0) != 8:
break
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
loss = focal_loss(output, target)
loss.backward()
optimizer.step()
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
state['train_loss'] = loss_avg
def test():
with torch.no_grad():
model.eval()
loss_avg = 0.0
correct = 0
for batch_idx, (data, target) in enumerate(test_data_loader):
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
output = model(data)
loss = F.cross_entropy(output, target)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
loss_avg += float(loss)
state['test_loss'] = loss_avg / len(test_data_loader)
state['test_accuracy'] = correct / len(
test_data_loader.dataset)
print(state['test_accuracy'])
best_accuracy = 0.0
for epoch in range(100):
state['epoch'] = epoch
train()
test()
sch.step(state['train_accuracy'])
if best_accuracy < state['test_accuracy']:
state['best_accuracy'] = state['test_accuracy']
torch.save(
model.state_dict(),
os.path.join(
'/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/dsl/check',
idx + '.pth'))
with open(
os.path.join(
'/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/dsl/check',
idx + '.json'), 'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if best_accuracy == 1.0:
break
def train(batch_size=2, learning_rate=1e-2, train_epoch=100):
# Normalizer(), Augmenter(), Resizer() 各转换时按顺序进行的
transform = transforms.Compose([Normalizer(), Augmenter(), Resizer()])
dataset = CocoDataset('./data/coco/', 'train2017', transform)
data_loader = Data.DataLoader(dataset, 2, num_workers=2, shuffle=True, \
collate_fn=collater, pin_memory=True)
dataset_size = len(dataset)
print('sample number:', dataset_size)
print('epoch size:', dataset_size / batch_size)
retinanet = RetinaNet()
anchor = Anchor()
focal_loss = FocalLoss()
if cuda:
retinanet = torch.nn.DataParallel(retinanet).cuda()
anchor = anchor.cuda()
focal_loss = focal_loss.cuda()
retinanet.module.freeze_bn()
optimizer = torch.optim.SGD(retinanet.parameters(),
lr=learning_rate,
momentum=0.9,
weight_decay=1e-4)
'''
class torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min',
factor=0.1, patience=10, verbose=False, threshold=0.0001,
threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
:param optimer: 指的是网络的优化器
:param mode: (str), 可选择‘min’或者‘max’，min表示当监控量停止下降的时候，学习率将减小，
max表示当监控量停止上升的时候，学习率将减小。默认值为‘min’
:param factor: 学习率每次降低多少，new_lr = old_lr * factor
:param patience=10: 容忍网路的性能不提升的次数，高于这个次数就降低学习率
:param verbose: (bool), 如果为True，则为每次更新向stdout输出一条消息。 默认值：False
:param threshold: (float), 测量新最佳值的阈值，仅关注重大变化。 默认值：1e-4
:param cooldown: 减少lr后恢复正常操作之前要等待的时期数。 默认值：0。
:param min_lr: 学习率的下限
:param eps: 适用于lr的最小衰减。 如果新旧lr之间的差异小于eps，则忽略更新。 默认值：1e-8。
————————————————
版权声明：本文为CSDN博主「张叫张大卫」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_40100431/article/details/84311430
'''
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
patience=3,
verbose=True)
for epoch_num in range(train_epoch):
epoch_loss = []
for iter_num, data in enumerate(data_loader):
iter_time = time.time()
images, annots, scales = data
if cuda:
images = images.cuda()
annots = annots.cuda()
scales = scales.cuda()
total_anchors = anchor(data['img'])
classification, localization = retinanet(images)
cls_loss, loc_loss = \
focal_loss(classification, localization, total_anchors, annots)
loss = cls_loss + loc_loss
epoch_loss.append(float(loss))
optimizer.zero_grad()
loss.backward()
'''
关于torch.nn.utils.clip_grad_norm_():
In some cases you may find that each layer of your net amplifies the
gradient it receives. This causes a problem because the lower layers of
the net then get huge gradients and their updates will be far too large
to allow the model to learn anything.
This function ‘clips’ the norm of the gradients by scaling the gradients
down by the same amount in order to reduce the norm to an acceptable
level. In practice this places a limit on the size of the parameter
updates.
The hope is that this will ensure that your model gets reasonably
sized gradients and that the corresponding updates will allow the
model to learn.
引用自https://discuss.pytorch.org/t/about-torch-nn-utils-clip-grad-norm/13873
感受一下来自 PyTorch 讨论社区的窒息攻防，2333。。
'''
torch.nn.utils.clip_grad_norm_(retinanet.parameters(), 0.1)
optimizer.step()
print('|', 'Epoch:', epoch_num + 1, '|', 'Iter:', iter_num + 1,
'|', 'cls loss:', float(cls_loss), '|', 'loc loss:',
float(loc_loss), '|', 'loss:', float(loss), '|', 'lr:',
float(optimizer.learning_rate), '|', 'time:',
time.time() - iter_time)
scheduler.step(np.mean(epoch_loss))
print('Saving parameters in model on epoch', epoch_num + 1)
torch.save(
retinanet.state_dict(),
'./param/param_epoch' + str(epoch_num + 1).zfill(3) + '.pkl')
os.makedirs(opt.outf)
except OSError:
pass
blue = lambda x: '\033[94m' + x + '\033[0m'
classifier = PointNetReg(num_points=opt.npoints)
if opt.model != '':
classifier.load_state_dict(torch.load(opt.model))
optimizer = optim.SGD(classifier.parameters(), lr=0.0001, momentum=0.9)
classifier.cuda()
focal_loss = FocalLoss(opt.gamma)
focal_loss = focal_loss.cuda()
num_batch = len(dataset) / opt.batchSize
for epoch in range(opt.nepoch):
for i, data in enumerate(dataloader, 0):
points, _, target, _ = data
points, target = Variable(points), Variable(target)
points = points.transpose(2, 1)
points, target = points.cuda(), target.cuda()
optimizer.zero_grad()
pred, _ = classifier(points)
#pred = pred.view(-1, 3)
#target = target.view(-1, 3)
loss = F.mse_loss(pred, target)
def run(trainr,testdr, name,cls_num,idx):
batch_size = 8
data_loader, imagenet_data,new_lbs = load_dat(batch_size, trainr)
model = se_resnext50_32x4d(num_classes=1000,pretrained=None)
model.load_state_dict(torch.load('/home/dsl/all_check/se_resnext50_32x4d-a260b3a4.pth'), strict=False)
model.fc1 = nn.Linear(2048, 4)
model.fc2 = nn.Linear(4, cls_num)
#model.load_state_dict(torch.load('/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/dsl/check/1009_res_total.pth'), strict=False)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(), state['learning_rate'], momentum=state['momentum'],
weight_decay=state['decay'], nesterov=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = name
centerloss = CenterLoss(cls_num, 4)
centerloss.cuda()
optimzer_center = torch.optim.SGD(centerloss.parameters(), lr=0.3)
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, factor=0.5, patience=5)
ll = len(data_loader.dataset)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
state['train_accuracy'] =0
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data.detach().numpy()
if data.size(0) != batch_size:
break
data, target = torch.autograd.Variable(data.cuda()), torch.autograd.Variable(target.cuda())
f1, output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
optimzer_center.zero_grad()
loss = focal_loss(output, target)+ centerloss(target, f1)*0.3
loss.backward()
optimizer.step()
optimzer_center.step()
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
state['train_loss'] = loss_avg
def test():
with torch.no_grad():
model.eval()
loss_avg = 0.0
correct = 0
for k in glob.glob(os.path.join(testdr,'*.jpg')):
imag = Image.open(k)
ig = data_transforms['val'](imag)
ig = ig.unsqueeze(0)
ig = torch.autograd.Variable(ig.cuda())
f1, output = model(ig)
output = F.softmax(output, dim=1)
pred = output.data.squeeze(dim=0).cpu().numpy()
score = np.asarray(pred)
score = np.sum(score, axis=0)
pred_lb = np.argmax(score)
sc = np.max(score)
print(k)
lbs = new_lbs[pred_lb]
if sc>0.66:
shutil.copy(k,os.path.join(train_dr, lbs))
else:
try:
nn_name = k.split('/')[-1]
os.remove(os.path.join(train_dr, lbs, nn_name))
except:
pass
best_accuracy = 0.0
for epoch in range(100):
state['epoch'] = epoch
train()
test()
data_loader, imagenet_data, new_lbs = load_dat(batch_size, trainr)
sch.step(state['train_accuracy'])
if best_accuracy < state['train_accuracy']:
state['best_accuracy'] = state['train_accuracy']
torch.save(model.state_dict(), os.path.join('/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/dsl/check', idx+'.pth'))
with open(os.path.join('/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/dsl/check', idx+'.json'),'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if best_accuracy == 1.0:
break
def do_train(model_name,
model,
train_loader,
val_loader,
device,
lr=0.0001,
n_ep=40,
num_classes=3,
save_path='/tmp'):
# Classifier = layer.MarginCosineProduct(1664, num_classes)
# Classifier = Classifier.cuda()
optimizer = torch.optim.Adam(model.parameters(),
weight_decay=1e-5,
lr=0.00001)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
verbose=True,
patience=2)
criterion = nn.CrossEntropyLoss().cuda()
focal_loss = FocalLoss(class_num=num_classes)
focal_loss = focal_loss.cuda()
grad_loss = Grad_loss().cuda()
best_acc = 0.0
# do training
for i_ep in range(n_ep):
model.train()
train_losses = []
widgets = [
'train :',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' ',
FileTransferSpeed()
]
pbar = ProgressBar(widgets=widgets)
for batch_data in pbar(train_loader):
image = batch_data['image'].type(torch.FloatTensor).to(device)
label = batch_data['label_idx'].to(device)
x = Variable(image, requires_grad=True)
optimizer.zero_grad()
logits = model(x)
# logits = Classifier(logits,label)
# loss = focal_loss(logits, label)#F.cross_entropy
loss = criterion(logits, label)
loss.backward()
if np.random.randint(2):
pertubation(x, image)
model.zero_grad()
logits = model(x)
loss = criterion(logits, label)
# loss += loss2
loss.backward()
optimizer.step()
train_losses += [loss.detach().cpu().numpy().reshape(-1)]
train_losses = np.concatenate(train_losses).reshape(-1).mean()
model.eval()
val_losses = []
preds = []
true_labels = []
widgets = [
'val:',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' ',
FileTransferSpeed()
]
pbar = ProgressBar(widgets=widgets)
for batch_data in pbar(val_loader):
image = batch_data['image'].type(torch.FloatTensor).to(device)
label = batch_data['label_idx'].to(device)
# image = Variable(image, requires_grad=True)
with torch.no_grad():
logits = model(image)
# logits = Classifier(logits,label)
loss = criterion(logits, label).detach().cpu().numpy().reshape(-1)
# loss2 = grad_loss(image)
# loss += loss2.detach().cpu().numpy().reshape(-1)
# loss = focal_loss(logits, label).detach().cpu().numpy().reshape(-1)
val_losses += [loss]
true_labels += [label.detach().cpu().numpy()]
preds += [(logits.max(1)[1].detach().cpu().numpy())]
preds = np.concatenate(preds, 0).reshape(-1)
true_labels = np.concatenate(true_labels, 0).reshape(-1)
acc = accuracy_score(true_labels, preds)
val_losses = np.concatenate(val_losses).reshape(-1).mean()
scheduler.step(val_losses)
# need python3.6
print(
f'Epoch : {i_ep} val_acc : {acc:.5%} ||| train_loss : {train_losses:.5f} val_loss : {val_losses:.5f} |||'
)
if acc > best_acc:
best_acc = acc
files2remove = glob.glob(os.path.join(save_path, 'ep_*'))
for _i in files2remove:
os.remove(_i)
torch.save(
model.cpu().state_dict(),
os.path.join(save_path,
f'ep_{i_ep}_{model_name}_val_acc_{acc:.4f}.pth'))
torch.save(
model,
os.path.join(save_path,
f'ep_{i_ep}_{model_name}_val_acc_{acc:.4f}.pkl'))
model.to(device)
elif i_ep % 10 == 9:
torch.save(
model.cpu().state_dict(),
os.path.join(save_path,
f'ep_{i_ep}_{model_name}_val_acc_{acc:.4f}.pth'))
torch.save(
model,
os.path.join(save_path,
f'ep_{i_ep}_{model_name}_val_acc_{acc:.4f}.pkl'))
model.to(device)
def run(train_sets,valid_sets, cls_num,idx):
batch_size = 16
train_gen = get_batch(batch_size= batch_size,data_set=train_sets, image_size=train_sets.image_size)
valid_gen = get_batch(batch_size= 1,data_set=valid_sets, image_size=train_sets.image_size)
model = resnet18(num_classes=1000,pretrained=None)
model.load_state_dict(torch.load('/home/dsl/all_check/resnet18-5c106cde.pth'), strict=False)
model.fc = nn.Linear(512,1)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(), state['learning_rate'], momentum=state['momentum'],
weight_decay=state['decay'], nesterov=True)
state['label_ix'] = train_sets.cls_map
state['cls_name'] = idx
centerloss = CenterLoss(cls_num,2)
centerloss.cuda()
optimzer_center = torch.optim.SGD(centerloss.parameters(), lr=0.3)
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, factor=0.5, patience=5)
ll = train_sets.len()
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
bc_loss = nn.BCEWithLogitsLoss()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for b in range(int(train_sets.len()/batch_size)):
images, labels = next(train_gen)
images = np.transpose(images,[0,3,1,2])
images = torch.from_numpy(images)
labels = torch.from_numpy(labels).float()
data, target = torch.autograd.Variable(images.cuda()), torch.autograd.Variable(labels.cuda())
output = model(data)
output = output.squeeze()
ot = F.sigmoid(output)
pred = ot.ge(0.5).float()
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
loss = bc_loss(output, target)
loss.backward()
optimizer.step()
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / train_sets.len()
state['train_loss'] = loss_avg
def test():
with torch.no_grad():
model.eval()
loss_avg = 0.0
correct = 0
for i in range(valid_sets.len()):
images, labels = next(valid_gen)
images = np.transpose(images, [0,3,1,2])
images = torch.from_numpy(images)
labels = torch.from_numpy(labels).float()
data, target = torch.autograd.Variable(images.cuda()), torch.autograd.Variable(labels.cuda())
output = model(data)
output = output.squeeze()
ot = F.sigmoid(output)
pred = ot.ge(0.5).float()
correct += float(pred.eq(target.data).sum())
state['test_accuracy'] = correct / valid_sets.len()
print(state['test_accuracy'])
best_accuracy = 0.0
for epoch in range(40):
state['epoch'] = epoch
train()
test()
sch.step(state['train_accuracy'])
best_accuracy = (state['train_accuracy']+state['test_accuracy'])/2
if best_accuracy > state['best_accuracy']:
state['best_accuracy'] = best_accuracy
torch.save(model.state_dict(), os.path.join('/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/AIChallenger2018/zuixin/be', idx+'.pth'))
with open(os.path.join('/media/dsl/20d6b919-92e1-4489-b2be-a092290668e4/AIChallenger2018/zuixin/be', idx+'.json'),'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if state['train_accuracy']-state['test_accuracy']>0.06 and epoch>30:
break
def run(trainr, name, cls_num, idx):
imagenet_data = ImageFolder(trainr, transform=data_transforms['train'])
data_loader = DataLoader(imagenet_data, batch_size=6, shuffle=True)
model = inception_v3(num_classes=1000, pretrained=None, aux_logits=False)
model.load_state_dict(torch.load(
'D:/deep_learn_data/check/inception_v3_google-1a9a5a14.pth'),
strict=False)
model.fc1 = nn.Linear(2048, 4)
model.fc2 = nn.Linear(4, 12)
#model.load_state_dict(torch.load('D:/deep_learn_data/luntai/check/1.pth'), strict=False)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(),
state['learning_rate'],
momentum=state['momentum'],
weight_decay=state['decay'],
nesterov=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = name
centerloss = CenterLoss(cls_num, 4)
centerloss.cuda()
optimzer_center = torch.optim.SGD(centerloss.parameters(), lr=0.3)
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
factor=0.5,
patience=5)
ll = len(data_loader.dataset)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data.detach().numpy()
if data.size(0) != 6:
break
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
f1, output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
optimzer_center.zero_grad()
loss = focal_loss(output, target) + centerloss(target, f1) * 0.3
loss.backward()
optimizer.step()
optimzer_center.step()
ip1_loader.append(f1)
idx_loader.append((target))
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
feat = torch.cat(ip1_loader, 0)
labels = torch.cat(idx_loader, 0)
visualize(feat.data.cpu().numpy(),
labels.data.cpu().numpy(), epoch, cls_num)
state['train_loss'] = loss_avg
best_accuracy = 0.0
for epoch in range(100):
state['epoch'] = epoch
train()
sch.step(state['train_accuracy'])
if best_accuracy < state['train_accuracy']:
state['best_accuracy'] = state['train_accuracy']
torch.save(model.state_dict(), os.path.join('./log', idx + '.pth'))
with open(os.path.join('./log', idx + '.json'), 'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if best_accuracy == 1.0 or state['train_accuracy'] > 0.99:
break
def run(trainr, name, cls_num, idx):
imagenet_data = ImageFolder(trainr, transform=data_transforms['train'])
data_loader = DataLoader(imagenet_data, batch_size=6, shuffle=True)
model = inceptionv4(num_classes=1000, pretrained=None)
model.avg_pool = nn.AvgPool2d(13, count_include_pad=False)
model.load_state_dict(
torch.load('D:/deep_learn_data/check/se_resnext50_32x4d-a260b3a4.pth'),
strict=False)
model.last_linear = nn.Linear(1536, cls_num)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(),
state['learning_rate'],
momentum=state['momentum'],
weight_decay=state['decay'],
nesterov=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = name
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
factor=0.5,
patience=5)
ll = len(data_loader.dataset)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data.detach().numpy()
if data.size(0) != 6:
break
data, target = torch.autograd.Variable(
data.cuda()), torch.autograd.Variable(target.cuda())
output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
loss = focal_loss(output, target)
loss.backward()
optimizer.step()
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
state['train_loss'] = loss_avg
best_accuracy = 0.0
for epoch in range(100):
state['epoch'] = epoch
train()
sch.step(state['train_accuracy'])
if best_accuracy < state['train_accuracy']:
state['best_accuracy'] = state['train_accuracy']
torch.save(model.state_dict(), os.path.join('./log', idx + '.pth'))
with open(os.path.join('./log', idx + '.json'), 'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if best_accuracy == 1.0 or state['train_accuracy'] > 0.98:
break
def run(trainr,test_dr, name,svdr):
print(test_dr)
batch_size = 16
imagenet_data = ImageFolder(trainr,
transform=data_transforms['train'])
test_data = ImageFolder(test_dr,transform=data_transforms['val'])
cls_num = len(imagenet_data.class_to_idx)
data_loader = DataLoader(imagenet_data, batch_size=batch_size, shuffle=True)
test_data_loader = DataLoader(test_data, batch_size=1, shuffle=True)
model = se_resnext50_32x4d(num_classes=1000,pretrained=None)
model.load_state_dict(torch.load('/home/dsl/all_check/se_resnext50_32x4d-a260b3a4.pth'), strict=False)
model.fc1 = nn.Linear(2048, 2)
model.fc2 = nn.Linear(2, cls_num)
model.cuda()
state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005}
optimizer = torch.optim.SGD(model.parameters(), state['learning_rate'], momentum=state['momentum'],
weight_decay=state['decay'], nesterov=True)
state['label_ix'] = imagenet_data.class_to_idx
state['cls_name'] = name
centerloss = CenterLoss(cls_num,2)
centerloss.cuda()
optimzer_center = torch.optim.SGD(centerloss.parameters(), lr=0.3)
state['best_accuracy'] = 0
sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, factor=0.5, patience=5)
ll = len(data_loader.dataset)
focal_loss = FocalLoss(gamma=2)
focal_loss.cuda()
def train():
model.train()
loss_avg = 0.0
progress = ProgressBar()
ip1_loader = []
idx_loader = []
correct = 0
for (data, target) in progress(data_loader):
data, target = torch.autograd.Variable(data.cuda()), torch.autograd.Variable(target.cuda())
f1, output = model(data)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
optimizer.zero_grad()
optimzer_center.zero_grad()
loss = focal_loss(output, target)+ centerloss(target, f1)*0.4
loss.backward()
optimizer.step()
optimzer_center.step()
ip1_loader.append(f1)
idx_loader.append((target))
loss_avg = loss_avg * 0.2 + float(loss) * 0.8
print(correct, ll, loss_avg)
state['train_accuracy'] = correct / len(data_loader.dataset)
feat = torch.cat(ip1_loader, 0)
labels = torch.cat(idx_loader, 0)
state['train_loss'] = loss_avg
def test():
with torch.no_grad():
model.eval()
loss_avg = 0.0
correct = 0
print(test_data_loader)
for batch_idx, (data, target) in enumerate(test_data_loader):
data, target = torch.autograd.Variable(data.cuda()), torch.autograd.Variable(target.cuda())
f1, output = model(data)
loss = F.cross_entropy(output, target)
pred = output.data.max(1)[1]
correct += float(pred.eq(target.data).sum())
loss_avg += float(loss)
state['test_loss'] = loss_avg / len(test_data_loader)
state['test_accuracy'] = correct / len(test_data_loader.dataset)
print(state['test_accuracy'])
best_accuracy = 0.0
for epoch in range(50):
state['epoch'] = epoch
train()
test()
sch.step(state['train_accuracy'])
best_accuracy = (state['train_accuracy'] + state['test_accuracy']) / 2
if best_accuracy > state['best_accuracy']:
state['best_accuracy'] = best_accuracy
torch.save(model.state_dict(), os.path.join(svdr, name + '.pth'))
with open(os.path.join(svdr, name + '.json'), 'w') as f:
f.write(json.dumps(state))
f.flush()
print(state)
print("Best accuracy: %f" % state['best_accuracy'])
if best_accuracy == 1.0:
break