def main():
parser = argparse.ArgumentParser(description='PyTorch DCNNs Training')
parser.add_argument('--epochs',
default=200,
type=int,
help='number of total epochs to run')
parser.add_argument('--lr',
'--learning-rate',
default=0.1,
type=float,
help='initial learning rate')
parser.add_argument('--components',
default=None,
type=int,
help='dimensionality reduction')
parser.add_argument('--dataset',
default='IP',
type=str,
help='dataset (options: IP, UP, SV, KSC)')
parser.add_argument('--tr_percent',
default=0.15,
type=float,
help='samples of train set')
parser.add_argument('--tr_bsize',
default=100,
type=int,
help='mini-batch train size (default: 100)')
parser.add_argument('--te_bsize',
default=1000,
type=int,
help='mini-batch test size (default: 1000)')
parser.add_argument('--depth',
default=32,
type=int,
help='depth of the network (default: 32)')
parser.add_argument(
'--alpha',
default=48,
type=int,
help='number of new channel increases per depth (default: 12)')
parser.add_argument('--inplanes',
dest='inplanes',
default=16,
type=int,
help='bands before blocks')
parser.add_argument('--no-bottleneck',
dest='bottleneck',
action='store_false',
help='to use basicblock (default: bottleneck)')
parser.add_argument('--spatialsize',
dest='spatialsize',
default=11,
type=int,
help='spatial-spectral patch dimension')
parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
parser.add_argument('--weight-decay',
'--wd',
default=1e-4,
type=float,
help='weight decay (default: 1e-4)')
parser.set_defaults(bottleneck=True)
best_err1 = 100
args = parser.parse_args()
state = {k: v for k, v in args._get_kwargs()}
train_loader, test_loader, num_classes, n_bands = load_hyper(args)
# Use CUDA
use_cuda = torch.cuda.is_available()
if use_cuda: torch.backends.cudnn.benchmark = True
if args.spatialsize < 9: avgpoosize = 1
elif args.spatialsize <= 11: avgpoosize = 2
elif args.spatialsize == 15: avgpoosize = 3
elif args.spatialsize == 19: avgpoosize = 4
elif args.spatialsize == 21: avgpoosize = 5
elif args.spatialsize == 27: avgpoosize = 6
elif args.spatialsize == 29: avgpoosize = 7
else: print("spatialsize no tested")
model = PYRM.pResNet(args.depth,
args.alpha,
num_classes,
n_bands,
avgpoosize,
args.inplanes,
bottleneck=args.bottleneck) # for PyramidNet
if use_cuda: model = model.cuda()
criterion = torch.nn.CrossEntropyLoss()
#optimizer = torch.optim.Adam(model.parameters())
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
title = 'HYPER-' + args.dataset
best_acc = -1
for epoch in range(args.epochs):
adjust_learning_rate(optimizer, epoch, args)
train_loss, train_acc = train(train_loader, model, criterion,
optimizer, epoch, use_cuda)
test_loss, test_acc = test(test_loader, model, criterion, epoch,
use_cuda)
print("EPOCH",
epoch,
"TRAIN LOSS",
train_loss,
"TRAIN ACCURACY",
train_acc,
end=',')
print("LOSS", test_loss, "ACCURACY", test_acc)
# save model
if test_acc > best_acc:
state = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
}
torch.save(state, "best_model.pth.tar")
best_acc = test_acc
checkpoint = torch.load("best_model.pth.tar")
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
test_loss, test_acc = test(test_loader, model, criterion, epoch, use_cuda)
print("FINAL: LOSS", test_loss, "ACCURACY", test_acc)
classification, confusion, results = auxil.reports(
np.argmax(predict(test_loader, model, criterion, use_cuda), axis=1),
np.array(test_loader.dataset.__labels__()), args.dataset)
print(args.dataset, results)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset',
default='IP',
type=str,
help='the path to your dataset')
parser.add_argument('--learning_rate',
type=float,
default=0.001,
help='learning rate of adam optimizer')
parser.add_argument('--epochs',
default=600,
type=int,
help='number of total epochs')
parser.add_argument('--batch_size',
default=100,
type=int,
help='batch size')
parser.add_argument('--components',
default=1,
type=int,
help='dimensionality reduction')
parser.add_argument('--spatialsize',
default=23,
type=int,
help='windows size')
parser.add_argument('--tr_percent',
default=0.10,
type=float,
metavar='N',
help='train set size')
parser.add_argument('--tr_bsize',
default=100,
type=int,
metavar='N',
help='train batchsize')
parser.add_argument('--te_bsize',
default=5000,
type=int,
metavar='N',
help='test batchsize')
parser.add_argument('--p',
default=0,
type=float,
help='Random Erasing probability')
parser.add_argument('--sh',
default=0.3,
type=float,
help='max erasing area')
parser.add_argument('--r1',
default=0.2,
type=float,
help='aspect of erasing area')
parser.add_argument("--verbose",
action='store_true',
help="Verbose? Default NO")
args = parser.parse_args()
state = {k: v for k, v in args._get_kwargs()}
trainloader, testloader, num_classes, bands = load_hyper(args)
# Use CUDA
use_cuda = torch.cuda.is_available()
if use_cuda: torch.backends.cudnn.benchmark = True
model = models.SimpleCNN(bands, args.spatialsize, num_classes)
if use_cuda: model = model.cuda()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters())
title = 'HYPER-' + args.dataset
best_acc = -1
for epoch in range(args.epochs):
#adjust_learning_rate(optimizer, epoch)
if args.verbose:
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, args.epochs, state['lr']))
train_loss, train_acc = train(trainloader, model, criterion, optimizer,
epoch, use_cuda)
test_loss, test_acc = test(testloader, model, criterion, epoch,
use_cuda)
if args.verbose:
print("EPOCH",
epoch,
"TRAIN LOSS",
train_loss,
"TRAIN ACCURACY",
train_acc,
end=',')
if args.verbose: print("LOSS", test_loss, "ACCURACY", test_acc)
# save model
if test_acc > best_acc:
state = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
}
torch.save(state, "best_model" + str(args.p) + ".pth.tar")
best_acc = test_acc
checkpoint = torch.load("best_model" + str(args.p) + ".pth.tar")
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
test_loss, test_acc = test(testloader, model, criterion, epoch, use_cuda)
if args.verbose: print("FINAL: LOSS", test_loss, "ACCURACY", test_acc)
classification, confusion, results = auxil.reports(
np.argmax(predict(testloader, model, criterion, use_cuda), axis=1),
np.array(testloader.dataset.__labels__()), args.dataset)
print(args.dataset, results)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', default='IP', type=str, help='Dataset')
parser.add_argument('--lr', type=float, default=0.001, help='Learning rate')
parser.add_argument('--epochs', default=600, type=int, help='Number of total epochs')
parser.add_argument('--components', default=1, type=int, help='Dimensionality reduction')
parser.add_argument('--spatialsize', default=23, type=int, help='Patch size')
parser.add_argument('--tr_percent', default=0.10, type=float, metavar='N',
help='Train set size')
parser.add_argument('--val_percent', default=0.1, type=float, metavar='N',
help='Train set size')
parser.add_argument('--tr_bsize', default=100, type=int, metavar='N',
help='Train batch size')
parser.add_argument('--val_bsize', default=5000, type=int, metavar='N',
help='Test batch size')
parser.add_argument('--te_bsize', default=5000, type=int, metavar='N',
help='Test batch size')
parser.add_argument("--verbose", action='store_true', help="Verbose? Default NO")
parser.add_argument("--use_val", action='store_true', help="Validation? Default NO")
parser.add_argument('--p', default=0, type=float, help='Occlusion probability')
parser.add_argument('--sh', default=0.3, type=float, help='Max occlusion area')
parser.add_argument('--r1', default=0.2, type=float, help='Aspect of occlusion area')
args = parser.parse_args()
state = {k: v for k, v in args._get_kwargs()}
trainloader, valloader, testloader, num_classes, bands = load_hyper(args)
# Use CUDA
use_cuda = torch.cuda.is_available()
if use_cuda: torch.backends.cudnn.benchmark = True
model = models.SimpleCNN(bands, args.spatialsize, num_classes)
if use_cuda: model = model.cuda()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[300, 400, 500], gamma=0.5)
best_acc = -1
for epoch in range(args.epochs):
train_loss, train_acc = train(trainloader, model, criterion, optimizer, epoch, use_cuda)
if args.use_val: val_loss, val_acc = test(valloader, model, criterion, epoch, use_cuda)
else: val_loss, val_acc = test(testloader, model, criterion, epoch, use_cuda)
if args.verbose: print("EPOCH ["+str(epoch)+"/"+str(args.epochs)+"] TRAIN LOSS", train_loss, \
"TRAIN ACCURACY", train_acc, \
"LOSS", val_loss, "ACCURACY", val_acc)
# save model
if val_acc > best_acc:
state = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': val_acc,
'best_acc': best_acc,
'optimizer' : optimizer.state_dict(),
}
torch.save(state, "best_model"+str(args.p)+".pth.tar")
best_acc = val_acc
scheduler.step()
checkpoint = torch.load("best_model"+str(args.p)+".pth.tar")
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
test_loss, test_acc = test(testloader, model, criterion, epoch, use_cuda)
if args.verbose: print("FINAL: LOSS", test_loss, "ACCURACY", test_acc)
classification, confusion, results = auxil.reports(np.argmax(predict(testloader, model, criterion, use_cuda), axis=1), np.array(testloader.dataset.__labels__()), args.dataset)
print(args.dataset, results)
def main():
parser = argparse.ArgumentParser(description='PyTorch DCNNs Training')
parser.add_argument('--max_step', default=8000, type=int, help='number of total epochs to run')
parser.add_argument('--idtest', default=0, type=int, help='id of experiment')
parser.add_argument('--lr', '--learning-rate', default=0.1, type=float, help='initial learning rate')
parser.add_argument('--components', default=None, type=int, help='dimensionality reduction')
parser.add_argument('--dataset', default='IP', type=str, help='dataset (options: IP, UP, SV, KSC)')
parser.add_argument('--tr_percent', default=0.10, type=float, help='samples of train set')
parser.add_argument('--tr_bsize', default=100, type=int, help='mini-batch train size (default: 100)')
parser.add_argument('--inplanes', dest='inplanes', default=16, type=int, help='bands before blocks')
parser.add_argument('--no-bottleneck', dest='bottleneck', action='store_false', help='to use basicblock (default: bottleneck)')
parser.add_argument('--spatialsize', dest='spatialsize', default=7, type=int, help='spatial-spectral patch dimension')
parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float, help='weight decay (default: 1e-4)')
parser.add_argument('--random_state', default=None, type=int, help='random seed')
args = parser.parse_args()
state = {k: v for k, v in args._get_kwargs()}
#args.components = 35 if args.dataset == 'IP' else 15
(trainS, labelTr), (testS, labelTs), (pixels, labels), numberofclass, bands = load_hyper(args)
n, m = trainS.shape[0], testS.shape[0]
labelTr, labelTs, c, pInClass, _, newOrder = spp.relabel(labelTr, labelTs)
imbalancedCls, toBalance, imbClsNum, ir=spp.irFind(pInClass, c)
labelsCat = to_categorical(labelTr)
shuffleIndex=np.random.choice(np.arange(n), size=(n,), replace=False)
trainS=trainS[shuffleIndex]
labelTr=labelTr[shuffleIndex]
labelsCat=labelsCat[shuffleIndex]
classMap=list()
for i in range(c):
classMap.append(np.where(labelTr==i)[0])
adamOpt=Adam(0.0002, 0.5)
latDim, modelSamplePd, resSamplePd=100, 8000, 500
# model initialization
mlp=nt.denseMlpCreate(sh=(args.spatialsize, args.spatialsize, bands, 1, ), num_class=numberofclass)
mlp.compile(loss='mean_squared_error', optimizer=adamOpt)
mlp.trainable=False
dis=nt.denseDisCreate((args.spatialsize, args.spatialsize, bands, 1, ), num_class=numberofclass)
dis.compile(loss='mean_squared_error', optimizer=adamOpt)
dis.trainable=False
gen=nt.denseGamoGenCreate(latDim, numberofclass)
gen_processed, genP_mlp, genP_dis=list(), list(), list()
for i in range(imbClsNum):
dataMinor=trainS[classMap[i], :]
numMinor=dataMinor.shape[0]
gen_processed.append(nt.denseGenProcessCreate(numMinor, dataMinor,sh = \
(args.spatialsize, args.spatialsize, bands, 1),mul = args.spatialsize * args.spatialsize * bands))
ip1=Input(shape=(latDim,))
ip2=Input(shape=(c,))
op1=gen([ip1, ip2])
op2=gen_processed[i](op1)
op3=mlp(op2)
genP_mlp.append(Model(inputs=[ip1, ip2], outputs=op3))
genP_mlp[i].compile(loss='mean_squared_error', optimizer=adamOpt)
ip1=Input(shape=(latDim,))
ip2=Input(shape=(c,))
ip3=Input(shape=(c,))
op1=gen([ip1, ip2])
op2=gen_processed[i](op1)
op3=dis([op2, ip3])
genP_dis.append(Model(inputs=[ip1, ip2, ip3], outputs=op3))
genP_dis[i].compile(loss='mean_squared_error', optimizer=adamOpt)
batchDiv, numBatches, bSStore = spp.batchDivision(n, args.tr_bsize)
genClassPoints=int(np.ceil(args.tr_bsize / c))
fileStart = './SavedModel/'
savePath = './SavedModel/'
fileEnd = '_Model.h5'
if not os.path.exists(fileStart):
os.makedirs(fileStart)
picPath=savePath+'Pictures'
if not os.path.exists(picPath):
os.makedirs(picPath)
iter=np.int(np.ceil(args.max_step/resSamplePd)+1)
acsaSaveTr, gmSaveTr, accSaveTr=np.zeros((iter,)), np.zeros((iter,)), np.zeros((iter,))
acsaSaveTs, gmSaveTs, accSaveTs=np.zeros((iter,)), np.zeros((iter,)), np.zeros((iter,))
confMatSaveTr, confMatSaveTs=np.zeros((iter, c, c)), np.zeros((iter, c, c))
tprSaveTr, tprSaveTs=np.zeros((iter, c)), np.zeros((iter, c))
step=0
bestacc = -1
while step < args.max_step:
for j in range(numBatches):
x1, x2=batchDiv[j, 0], batchDiv[j+1, 0]
validR=np.ones((bSStore[j, 0],1))-np.random.uniform(0,0.1, size=(bSStore[j, 0], 1))
mlp.train_on_batch(trainS[x1:x2], labelsCat[x1:x2])
dis.train_on_batch([trainS[x1:x2], labelsCat[x1:x2]], validR)
invalid=np.zeros((bSStore[j, 0], 1))+np.random.uniform(0, 0.1, size=(bSStore[j, 0], 1))
randNoise=np.random.normal(0, 1, (bSStore[j, 0], latDim))
fakeLabel=spp.randomLabelGen(toBalance, bSStore[j, 0], c)
rLPerClass=spp.rearrange(fakeLabel, imbClsNum)
fakePoints=np.zeros((bSStore[j, 0],args.spatialsize, args.spatialsize, bands, 1))
genFinal=gen.predict([randNoise, fakeLabel])
for i1 in range(imbClsNum):
if rLPerClass[i1].shape[0]!=0:
temp=genFinal[rLPerClass[i1]]
fakePoints[rLPerClass[i1]]=gen_processed[i1].predict(temp)
mlp.train_on_batch(fakePoints, fakeLabel)
dis.train_on_batch([fakePoints, fakeLabel], invalid)
for i1 in range(imbClsNum):
validA=np.ones((genClassPoints, 1))
randomLabel=np.zeros((genClassPoints, c))
randomLabel[:, i1]=1
randNoise=np.random.normal(0, 1, (genClassPoints, latDim))
oppositeLabel=np.ones((genClassPoints, c))-randomLabel
genP_mlp[i1].train_on_batch([randNoise, randomLabel], oppositeLabel)
genP_dis[i1].train_on_batch([randNoise, randomLabel, randomLabel], validA)
if step%resSamplePd==0:
saveStep=int(step//resSamplePd)
pLabel=np.argmax(mlp.predict(trainS), axis=1)
acsa, gm, tpr, confMat, acc=spp.indices(pLabel, labelTr)
print('Train: Step: ', step, 'ACSA: ', np.round(acsa, 4), 'GM: ', np.round(gm, 4))
print('TPR: ', np.round(tpr, 2))
acsaSaveTr[saveStep], gmSaveTr[saveStep], accSaveTr[saveStep]=acsa, gm, acc
confMatSaveTr[saveStep]=confMat
tprSaveTr[saveStep]=tpr
pLabel=np.argmax(mlp.predict(testS), axis=1)
acsa, gm, tpr, confMat, acc=spp.indices(pLabel, labelTs)
print('Test: Step: ', step, 'ACSA: ', np.round(acsa, 4), 'GM: ', np.round(gm, 4))
print('TPR: ', np.round(tpr, 2))
acsaSaveTs[saveStep], gmSaveTs[saveStep], accSaveTs[saveStep]=acsa, gm, acc
confMatSaveTs[saveStep]=confMat
tprSaveTs[saveStep]=tpr
results = auxil.reports(pLabel, labelTs)[2]
if bestacc <= results[0]:
bestacc = auxil.reports(pLabel, labelTs)[2][0]
resultsF = auxil.reports(pLabel, labelTs)[2]
if step%modelSamplePd==0 and step!=0:
direcPath=savePath+'gamo_models_'+str(step)
if not os.path.exists(direcPath):
os.makedirs(direcPath)
gen.save(direcPath+'/GEN_'+str(step)+fileEnd)
mlp.save(direcPath+'/MLP_'+str(step)+fileEnd)
dis.save(direcPath+'/DIS_'+str(step)+fileEnd)
for i in range(imbClsNum):
gen_processed[i].save(direcPath+'/GenP_'+str(i)+'_'+str(step)+fileEnd)
step=step+2
if step>=args.max_step: break
print(newOrder)
print(resultsF)