def main(args):
crossVal = 5
maxEpoch = [80, 80, 80, 80, 80]
mIOUList = []
avgmIOU = 0
for i in range(crossVal):
dataLoad = ld.LoadData(args.data_dir, args.classes)
data = dataLoad.processData(i, args.data_name)
mean = data['mean'] #np.array([0.485, 0.456, 0.406], dtype=np.float32)
std = data['std'] #np.array([0.229, 0.224, 0.225], dtype=np.float32)
print('Data statistics:')
print(mean, std)
pthName = 'model_' + args.model_name + '_crossVal' + str(
i + 1) + '_' + str(maxEpoch[i]) + '.pth'
pretrainedModel = args.pretrained + args.data_name + '/' + args.model_name + '/' + pthName
mIOU = "{:.4f}".format(main_te(args, i, pretrainedModel, mean, std))
mIOU = float(mIOU)
mIOUList.append(mIOU)
avgmIOU = avgmIOU + mIOU / 5
print(mIOUList)
print(args.model_name, args.data_name, "{:.4f}".format(avgmIOU))
"sneaker", "bag", "ankle boot"
]
image_size = [28, 28]
image_depth = 1
num_classes = 10
EPOCHS = 5
BATCH_SIZE = 32
image_height = image_size[0]
print("image_height = ", image_height)
image_width = image_size[1]
print("image_width = ", image_width)
#load training data
load_data = loadData.LoadData(image_size)
train_data = pd.read_csv(train_data_path)
x_train, y_train = load_data.load_formatted_data(data=train_data)
test_data = pd.read_csv(test_data_path)
x_test, y_test = load_data.load_formatted_data(data=test_data)
num_train_samples = x_train.shape[0]
num_test_samples = x_test.shape[0]
x_train = x_train.reshape(
(num_train_samples, image_height, image_width, image_depth))
x_test = x_test.reshape(
(num_test_samples, image_height, image_width, image_depth))
input_shape = (image_height, image_width, image_depth)
def trainValidateSegmentation(args):
'''
Main function for trainign and validation
:param args: global arguments
:return: None
'''
# check if processed data file exists or not
if not os.path.isfile(args.cached_data_file):
dataLoad = ld.LoadData(args.data_dir, args.classes, args.cached_data_file)
data = dataLoad.processData()
if data is None:
print('Error while pickling data. Please check.')
exit(-1)
else:
data = pickle.load(open(args.cached_data_file, "rb"))
q = args.q
p = args.p
# load the model
if not args.decoder:
model = net.ESPNet_Encoder(args.classes, p=p, q=q)
args.savedir = args.savedir + '_enc_' + str(p) + '_' + str(q) + '/'
else:
model = net.ESPNet(args.classes, p=p, q=q, encoderFile=args.pretrained)
args.savedir = args.savedir + '_dec_' + str(p) + '_' + str(q) + '/'
if args.onGPU:
model = model.cuda()
# create the directory if not exist
if not os.path.exists(args.savedir):
os.mkdir(args.savedir)
if args.visualizeNet:
x = Variable(torch.randn(1, 3, args.inWidth, args.inHeight))
if args.onGPU:
x = x.cuda()
y = model.forward(x)
g = viz.make_dot(y)
g.render(args.savedir + 'model.png', view=False)
total_paramters = netParams(model)
print('Total network parameters: ' + str(total_paramters))
# define optimization criteria
weight = torch.from_numpy(data['classWeights']) # convert the numpy array to torch
if args.onGPU:
weight = weight.cuda()
criteria = CrossEntropyLoss2d(weight) #weight
if args.onGPU:
criteria = criteria.cuda()
print('Data statistics')
print(data['mean'], data['std'])
print(data['classWeights'])
#compose the data with transforms
trainDataset_main = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(1024, 512),
myTransforms.RandomCropResize(32),
myTransforms.RandomFlip(),
#myTransforms.RandomCrop(64).
myTransforms.ToTensor(args.scaleIn),
#
])
trainDataset_scale1 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(1536, 768), # 1536, 768
myTransforms.RandomCropResize(100),
myTransforms.RandomFlip(),
#myTransforms.RandomCrop(64),
myTransforms.ToTensor(args.scaleIn),
#
])
trainDataset_scale2 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(1280, 720), # 1536, 768
myTransforms.RandomCropResize(100),
myTransforms.RandomFlip(),
#myTransforms.RandomCrop(64),
myTransforms.ToTensor(args.scaleIn),
#
])
trainDataset_scale3 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(768, 384),
myTransforms.RandomCropResize(32),
myTransforms.RandomFlip(),
#myTransforms.RandomCrop(64),
myTransforms.ToTensor(args.scaleIn),
#
])
trainDataset_scale4 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(512, 256),
#myTransforms.RandomCropResize(20),
myTransforms.RandomFlip(),
#myTransforms.RandomCrop(64).
myTransforms.ToTensor(args.scaleIn),
#
])
valDataset = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(1024, 512),
myTransforms.ToTensor(args.scaleIn),
#
])
# since we training from scratch, we create data loaders at different scales
# so that we can generate more augmented data and prevent the network from overfitting
trainLoader = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'], data['trainAnnot'], transform=trainDataset_main),
batch_size=args.batch_size + 2, shuffle=True, num_workers=args.num_workers, pin_memory=True)
trainLoader_scale1 = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'], data['trainAnnot'], transform=trainDataset_scale1),
batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True)
trainLoader_scale2 = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'], data['trainAnnot'], transform=trainDataset_scale2),
batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, pin_memory=True)
trainLoader_scale3 = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'], data['trainAnnot'], transform=trainDataset_scale3),
batch_size=args.batch_size + 4, shuffle=True, num_workers=args.num_workers, pin_memory=True)
trainLoader_scale4 = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'], data['trainAnnot'], transform=trainDataset_scale4),
batch_size=args.batch_size + 4, shuffle=True, num_workers=args.num_workers, pin_memory=True)
valLoader = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['valIm'], data['valAnnot'], transform=valDataset),
batch_size=args.batch_size + 4, shuffle=False, num_workers=args.num_workers, pin_memory=True)
if args.onGPU:
cudnn.benchmark = True
start_epoch = 0
if args.resume:
if os.path.isfile(args.resumeLoc):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resumeLoc)
start_epoch = checkpoint['epoch']
#args.lr = checkpoint['lr']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
logFileLoc = args.savedir + args.logFile
if os.path.isfile(logFileLoc):
logger = open(logFileLoc, 'a')
else:
logger = open(logFileLoc, 'w')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write("\n%s\t%s\t%s\t%s\t%s\t" % ('Epoch', 'Loss(Tr)', 'Loss(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
optimizer = torch.optim.Adam(model.parameters(), args.lr, (0.9, 0.999), eps=1e-08, weight_decay=5e-4)
# we step the loss by 2 after step size is reached
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.step_loss, gamma=0.5)
for epoch in range(start_epoch, args.max_epochs):
scheduler.step(epoch)
lr = 0
for param_group in optimizer.param_groups:
lr = param_group['lr']
print("Learning rate: " + str(lr))
# train for one epoch
# We consider 1 epoch with all the training data (at different scales)
train(args, trainLoader_scale1, model, criteria, optimizer, epoch)
train(args, trainLoader_scale2, model, criteria, optimizer, epoch)
train(args, trainLoader_scale4, model, criteria, optimizer, epoch)
train(args, trainLoader_scale3, model, criteria, optimizer, epoch)
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr = train(args, trainLoader, model, criteria, optimizer, epoch)
# evaluate on validation set
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = val(args, valLoader, model, criteria)
save_checkpoint({
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
'lr': lr
}, args.savedir + 'checkpoint.pth.tar')
#save the model also
model_file_name = args.savedir + '/model_' + str(epoch + 1) + '.pth'
torch.save(model.state_dict(), model_file_name)
with open(args.savedir + 'acc_' + str(epoch) + '.txt', 'w') as log:
log.write("\nEpoch: %d\t Overall Acc (Tr): %.4f\t Overall Acc (Val): %.4f\t mIOU (Tr): %.4f\t mIOU (Val): %.4f" % (epoch, overall_acc_tr, overall_acc_val, mIOU_tr, mIOU_val))
log.write('\n')
log.write('Per Class Training Acc: ' + str(per_class_acc_tr))
log.write('\n')
log.write('Per Class Validation Acc: ' + str(per_class_acc_val))
log.write('\n')
log.write('Per Class Training mIOU: ' + str(per_class_iu_tr))
log.write('\n')
log.write('Per Class Validation mIOU: ' + str(per_class_iu_val))
logger.write("\n%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.7f" % (epoch, lossTr, lossVal, mIOU_tr, mIOU_val, lr))
logger.flush()
print("Epoch : " + str(epoch) + ' Details')
print("\nEpoch No.: %d\tTrain Loss = %.4f\tVal Loss = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f" % (epoch, lossTr, lossVal, mIOU_tr, mIOU_val))
logger.close()
def run(args):
#load configuration
config = Config(args)
#load data
dataset = ld.LoadData(args.input)
data = dataset.data
label = dataset.label
anomaly_num = dataset.anomaly_num
feature_index = dataset.feature_index
feature_item_num = np.sum(dataset.feature_item_num)
instance_num = len(data)
#for training
training_data = data[:instance_num - 2 * anomaly_num]
training_data = ld.get_shaped_data(training_data, config.batch_size,
config.block_size, len(data[0]))
instance_dim = len(training_data[0][0][0])
#for testing
testing_data = data[instance_num - 2 * anomaly_num:]
testing_label = label[instance_num - 2 * anomaly_num:]
#shuffle testing data,to ensure testing data and label are shuffled in the same way
randnum = config.seed
random.seed(randnum)
random.shuffle(testing_data)
random.seed(randnum)
random.shuffle(testing_label)
testing_data = ld.get_shaped_data(testing_data, config.batch_size,
config.block_size, len(data[0]))
testing_data_num = len(testing_label) - len(testing_label) % (
config.block_size * config.batch_size)
testing_label = testing_label[:
testing_data_num] # testing data instance level ground truth
print("instance_dim", training_data.shape, instance_dim)
print("feature_item_num", feature_item_num)
with tf.Graph().as_default(), tf.Session() as sess:
#graph settings
FM_weight_dim = config.FM_weight_dim
batch_size = config.batch_size
block_size = config.block_size
attention_dim = config.attention_dim
autoencoder_hidden_dim = config.autoencoder_hidden_dim
lstm_dropout_keep_prob = config.lstm_dropout_keep_prob
lstm_layer_num = config.lstm_layer_num
lstm_hidden_size = config.lstm_hidden_size
is_training = config.is_training
gan_hidden_dim = config.gan_hidden_dim
alpha = config.alpha
beta = config.beta
learning_rate = config.learning_rate
model = AnomalyNet(feature_index, FM_weight_dim, feature_item_num,
batch_size, block_size, instance_dim, attention_dim,
autoencoder_hidden_dim, lstm_dropout_keep_prob,
lstm_layer_num, lstm_hidden_size, is_training,
gan_hidden_dim, alpha, beta, learning_rate)
saver = tf.train.Saver(
max_to_keep=10
) #saver for checkpoints, add var_list because of batching training
init = tf.global_variables_initializer()
sess.run(init)
for epoch in range(config.epoch):
# training
for i in range(len(training_data)):
curr_batch = training_data[i]
feed_dict = {model.data: curr_batch}
result = sess.run(
(model.D_train, model.G_train, model.test1, model.test2),
feed_dict=feed_dict)
instance_loss = np.mean(result[2])
block_loss = np.mean(result[3])
print(
"current epoch %d, in batch %d, instance average loss %.4f, block average loss %.4f"
% (epoch, i, instance_loss, block_loss), result[2].shape,
result[3].shape)
model_path = "saved_model/epoch_%s.ckpt" % (epoch)
saver.save(sess, model_path)
'''
#####
testing
#####
'''
#instance output
instance_loss_list = []
block_loss_list = []
for i in range(len(testing_data)):
curr_batch = testing_data[i]
feed_dict = {model.data: curr_batch}
instance_loss, block_loss = sess.run(
(model.instance_loss, model.block_loss),
feed_dict=feed_dict)
for i in range(len(instance_loss)):
instance_loss_list.append(instance_loss[i][0])
for i in range(len(block_loss)):
block_loss_list.append(block_loss[i][0])
bw = open(args.instance_output + '_%d' % (epoch), 'w') #by dingfu
bw.write("true pred\n")
for i in range(len(instance_loss_list)):
bw.write(
str(testing_label[i]) + " " + str(instance_loss_list[i]) +
"\n")
bw.close()
#block output
testing_block_num = testing_data_num // config.block_size
block_true = []
for i in range(testing_block_num):
true_sum = np.sum(testing_label[i * config.block_size:(i + 1) *
config.block_size])
# generate ground truth
if true_sum < config.block_size * config.block_ratio:
block_true.append(0)
else:
block_true.append(1)
bw = open(args.block_output + '_%d' % (epoch), 'w') #by dingfu
bw.write("true pred\n")
for i in range(testing_block_num):
bw.write(
str(block_true[i]) + " " + str(block_loss_list[i]) + "\n")
bw.close()
# print(true_block,pred_block)
instance_auc, _, _, _ = newmetrics.roc(
testing_label,
instance_loss_list,
pos_label=0,
output_path=args.instance_output + '_%d' % (epoch)) #by dingfu
block_auc, _, _, _ = newmetrics.roc(block_true,
block_loss_list,
pos_label=0,
output_path=args.block_output +
'_%d' % (epoch)) #by dingfu
#print("instance level evaluation: ",instance_eval)
print('epoch:', epoch, " instance level auc: ", instance_auc)
#print("block level evaluation: ",block_eval)
print('epoch:', epoch, " block level auc: ", block_auc)
random.seed(args.seed)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
os.environ['PYTHONHASHSEED'] = str(args.seed)
# create the directory if not exist
if not exists(args.savedir):
os.mkdir(args.savedir)
for (key, value) in vars(args).items():
print("{0:16} | {1}".format(key, value))
# check if processed data file exists or not
if not isfile(args.cached_data_file):
dataLoad = ld.LoadData(args.data_dir, args.cached_data_file)
data = dataLoad.processData()
if data is None:
print('Error while pickling data. Please check.')
exit(-1)
else:
data = pickle.load(open(args.cached_data_file, "rb"))
data['mean'] = np.array([0.485 * 255., 0.456 * 255., 0.406 * 255.],
dtype=np.float32)
data['std'] = np.array([0.229 * 255., 0.224 * 255., 0.225 * 255.],
dtype=np.float32)
# load the model
model = BiSalNet()
model.eval()
import loadData
class RemoveStopWord():
def __init__(self, textData):
self._stopWords = nltk.corpus.stopwords.words("english")
self._result = None
self._text = textData
def removeStopWord(self):
self._stopWords.append('OMG')
self._stopWords.append(':-)')
for index in range(0, len(self._text)):
for word in self._text[index].split():
#print(word)
if word not in self._stopWords:
self._result = ''.join(word)
instanceLoadData = loadData.LoadData('../../ExtractReviews/')
instanceLoadData.openFile('HospitalReviews.txt')
instanceLoadData.readText()
instanceLoadData.closeFile()
instanceRemveStopWord = RemoveStopWord(instanceLoadData._text)
instanceRemveStopWord.removeStopWord()
#pprint.pprint(instanceRemveStopWord._stopWords)
#pprint.pprint(instanceRemveStopWord._result)
#print(instanceRemveStopWord._stopWords)
#print(instanceRemveStopWord._result)
def run(args):
#load configuration
config = Config(args)
#load data
dataset = ld.LoadData(args.input)
data = dataset.data
label = dataset.label
anomaly_num = dataset.anomaly_num
feature_index = dataset.feature_index
feature_item_num = np.sum(dataset.feature_item_num)
instance_num = len(data)
#for training
training_data = data[:instance_num - 2 * anomaly_num]
training_data = ld.get_shaped_data(training_data, config.batch_size,
config.block_size, len(data[0]))
instance_dim = len(training_data[0][0][0])
#for testing
testing_data = data[instance_num - 2 * anomaly_num:]
testing_label = label[instance_num - 2 * anomaly_num:]
#shuffle testing data,to ensure testing data and label are shuffled in the same way
randnum = config.seed
random.seed(randnum)
random.shuffle(testing_data)
random.seed(randnum)
random.shuffle(testing_label)
testing_data = ld.get_shaped_data(testing_data, config.batch_size,
config.block_size, len(data[0]))
testing_data_num = len(testing_label) - len(testing_label) % (
config.block_size * config.batch_size)
testing_label = testing_label[:
testing_data_num] # testing data instance level ground truth
print("instance_dim", training_data.shape, instance_dim)
print("feature_item_num", feature_item_num)
with tf.Graph().as_default(), tf.Session() as sess:
#graph settings
FM_weight_dim = config.FM_weight_dim
batch_size = config.batch_size
block_size = config.block_size
attention_dim = config.attention_dim
autoencoder_hidden_dim = config.autoencoder_hidden_dim
lstm_dropout_keep_prob = config.lstm_dropout_keep_prob
lstm_layer_num = config.lstm_layer_num
lstm_hidden_size = config.lstm_hidden_size
is_training = config.is_training
gan_hidden_dim = config.gan_hidden_dim
alpha = config.alpha
beta = config.beta
learning_rate = config.learning_rate
model = AnomalyNet(feature_index, FM_weight_dim, feature_item_num,
batch_size, block_size, instance_dim, attention_dim,
autoencoder_hidden_dim, lstm_dropout_keep_prob,
lstm_layer_num, lstm_hidden_size, is_training,
gan_hidden_dim, alpha, beta, learning_rate)
saver = tf.train.Saver(
max_to_keep=10
) #saver for checkpoints, add var_list because of batching training
init = tf.global_variables_initializer()
sess.run(init)
for epoch in range(config.epoch):
# training
for i in range(len(training_data)):
curr_batch = training_data[i]
feed_dict = {model.data: curr_batch}
result = sess.run(
(model.D_train, model.G_train, model.test1, model.test2),
feed_dict=feed_dict)
instance_loss_threshold = np.mean(result[2])
block_loss_threshold = np.mean(result[3])
print(
"current epoch %d, in batch %d, instance average loss %.4f, block average loss %.4f"
%
(epoch, i, instance_loss_threshold, block_loss_threshold),
result[2].shape, result[3].shape)
model_path = "saved_model/epoch_%s.ckpt" % (epoch)
saver.save(sess, model_path)
'''
#####
testing
#####
'''
instance_loss_threshold = instance_loss_threshold * config.threshold_scale
block_loss_threshold = block_loss_threshold * config.threshold_scale
instance_pred = []
block_pred = []
for i in range(len(testing_data)):
curr_batch = testing_data[i]
feed_dict = {model.data: curr_batch}
instance_loss, block_loss = sess.run(
(model.instance_loss, model.block_loss),
feed_dict=feed_dict)
for j in range(len(instance_loss)):
if np.mean(instance_loss[j]) < instance_loss_threshold:
instance_pred.append(1)
else:
instance_pred.append(0)
for j in range(len(block_loss)):
if np.mean(block_loss[j]) < block_loss_threshold:
block_pred.append(1)
else:
block_pred.append(0)
# print("every batch instance/block:",instance_loss.shape,block_loss.shape)
testing_block_num = testing_data_num // config.block_size
block_true = []
#block anomaly detection from instance level. which means instances can also judge
block_pred_from_instance = []
for i in range(testing_block_num):
pred_sum = np.sum(instance_pred[i * config.block_size:(i + 1) *
config.block_size])
true_sum = np.sum(testing_label[i * config.block_size:(i + 1) *
config.block_size])
#instance prediction judges block. If instance prediction very ensure
# the block is anomaly or nomal, we use its result. Otherwise use our prediction result
if pred_sum > config.block_size * config.instance_confidence:
block_pred_from_instance.append(1)
elif pred_sum < config.block_size * (
1 - config.instance_confidence):
block_pred_from_instance.append(0)
else:
block_pred_from_instance.append(-1)
# generate ground truth
if true_sum < config.block_size * config.block_ratio:
block_true.append(0)
else:
block_true.append(1)
block_pred_mixure = []
for i in range(len(block_pred)):
if block_pred_from_instance[i] == 0:
block_pred_mixure.append(0)
elif block_pred_from_instance[i] == 1:
block_pred_mixure.append(1)
else:
block_pred_mixure.append(block_pred[i])
#instance level evaluation
print("testing_block_num", testing_data_num, testing_block_num,
config.block_size)
instance_eval = eval(testing_label, instance_pred)
#block level evaluation
block_eval = eval(block_true, block_pred_mixure)
# print(block_true,block_pred)
print("instance level evaluation: ", instance_eval)
print("block level evaluation: ", block_eval)
def main(args):
if args.apex:
if sys.version_info < (3, 0):
raise RuntimeError("Apex currently only supports Python 3. Aborting.")
if amp is None:
raise RuntimeError("Failed to import apex. Please install apex from https://www.github.com/nvidia/apex "
"to enable mixed-precision training.")
if args.output_dir:
utils.mkdir(args.output_dir)
utils.init_distributed_mode(args)
print(args)
# device = torch.device(args.device)
device = torch.device('cuda:{}'.format(args.gpu) if torch.cuda.is_available() else 'cpu')
torch.backends.cudnn.benchmark = True
# Data loading code
print("Loading data")
if not os.path.isfile(args.cached_data_file):
dataLoader = ld.LoadData(args.data_dir, args.classes, args.cached_data_file)
if dataLoader is None:
print('Error while processing the data. Please check')
exit(-1)
data = dataLoader.processData()
else:
data = pickle.load(open(args.cached_data_file, "rb"))
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
trainDataset = transforms.Compose([
transforms.ColorJitter(),
transforms.RandomHorizontalFlip(),
transforms.Resize(224),
transforms.ToTensor(),
normalize,
])
valDataset = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
normalize,
])
dataset = myDataLoader.MyDataset(data['trainIm'], data['trainClass'], transform=trainDataset)
dataset_test = myDataLoader.MyDataset(data['valIm'], data['valClass'], transform=valDataset)
print("Creating data loaders")
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(dataset)
test_sampler = torch.utils.data.distributed.DistributedSampler(dataset_test)
else:
train_sampler = torch.utils.data.RandomSampler(dataset)
test_sampler = torch.utils.data.SequentialSampler(dataset_test)
data_loader = torch.utils.data.DataLoader(
dataset, batch_size=args.batch_size,
sampler=train_sampler, num_workers=args.workers, pin_memory=True)
data_loader_test = torch.utils.data.DataLoader(
dataset_test, batch_size=args.batch_size,
sampler=test_sampler, num_workers=args.workers, pin_memory=True)
print("Creating model")
# import pdb
# pdb.set_trace()
model = torchvision.models.__dict__[args.model](pretrained=args.pretrained)
# googlenet
# num_ftrs = model.fc.in_features
# model.fc = nn.Linear(num_ftrs, args.classes)
##densenet161
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, args.classes)
##resnet101
# num_ftrs = model.fc.in_features
# model.fc = nn.Linear(num_ftrs, args.classes)
model.to(device)
if args.distributed and args.sync_bn:
model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(
model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
if args.apex:
model, optimizer = amp.initialize(model, optimizer,
opt_level=args.apex_opt_level
)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma)
model_without_ddp = model
if args.distributed:
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
model_without_ddp = model.module
# 修改了resume参数的规则
if args.resume and os.path.exists(args.resume):
print('Loading resume data from file: {}'.format(args.resume))
checkpoint = torch.load(args.resume, map_location='cpu')
model_without_ddp.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
args.start_epoch = checkpoint['epoch'] + 1
else:
print('Not load resume data.')
if args.test_only:
evaluate(model, criterion, data_loader_test, device=device)
return
print("Start training")
start_time = time.time()
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
train_one_epoch(model, criterion, optimizer, data_loader, device, epoch, args.print_freq, args.apex)
lr_scheduler.step()
evaluate(model, criterion, data_loader_test, device=device)
if args.output_dir:
checkpoint = {
'model': model_without_ddp.state_dict(),
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict(),
'epoch': epoch,
'args': args}
utils.save_on_master(
checkpoint,
os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
utils.save_on_master(
checkpoint,
os.path.join(args.output_dir, 'checkpoint.pth'))
total_time = time.time() - start_time
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
print('Training time {}'.format(total_time_str))
def trainValSegmentation(args):
if not os.path.isfile(args.cached_data_file):
dataLoader = ld.LoadData(args.data_dir, args.classes, args.attrClasses,
args.cached_data_file)
if dataLoader is None:
print("Error while cacheing the data.")
exit(-1)
data = dataLoader.processData()
else:
print("load cacheing data.")
data = pickle.load(open(args.cached_data_file, 'rb'))
# only unet for segmentation now.
# model= unet.UNet(args.classes)
# model = r18unet.ResNetUNet(args.classes)
model = mobileunet.MobileUNet(args.classes)
print("UNet done...")
# if args.onGPU == True:
model = model.cuda()
# devices_ids=[2,3], device_ids=range(2)
# device = torch.device('cuda:' + str(devices_ids[0]))
# model = model.to(device)
if args.visNet == True:
x = Variable(torch.randn(1, 3, args.inwidth, args.inheight))
if args.onGPU == True:
x = x.cuda()
print("before forward...")
y = model.forward(x)
print("after forward...")
g = viz.make_dot(y)
# g1 = viz.make_dot(y1)
g.render(args.save_dir + '/model', view=False)
model = torch.nn.DataParallel(model)
n_param = sum([np.prod(param.size()) for param in model.parameters()])
print('network parameters: ' + str(n_param))
#define optimization criteria
weight = torch.from_numpy(data['classWeights'])
print(weight)
if args.onGPU == True:
weight = weight.cuda()
criteria = CrossEntropyLoss2d(weight)
# if args.onGPU == True:
# criteria = criteria.cuda()
trainDatasetNoZoom = myTransforms.Compose([
myTransforms.RandomCropResize(args.inwidth, args.inheight),
# myTransforms.RandomHorizontalFlip(),
myTransforms.ToTensor(args.scaleIn)
])
trainDatasetWithZoom = myTransforms.Compose([
# myTransforms.Zoom(512,512),
myTransforms.RandomCropResize(args.inwidth, args.inheight),
myTransforms.RandomHorizontalFlip(),
myTransforms.ToTensor(args.scaleIn)
])
valDataset = myTransforms.Compose([
myTransforms.RandomCropResize(args.inwidth, args.inheight),
myTransforms.ToTensor(args.scaleIn)
])
trainLoaderNoZoom = torch.utils.data.DataLoader(
ld.MyDataset(data['trainIm'],
data['trainAnnot'],
transform=trainDatasetNoZoom),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True)
trainLoaderWithZoom = torch.utils.data.DataLoader(
ld.MyDataset(data['trainIm'],
data['trainAnnot'],
transform=trainDatasetWithZoom),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True)
valLoader = torch.utils.data.DataLoader(ld.MyDataset(data['valIm'],
data['valAnnot'],
transform=valDataset),
batch_size=args.batch_size_val,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True)
#define the optimizer
optimizer = torch.optim.Adam(model.parameters(),
args.lr, (0.9, 0.999),
eps=1e-08,
weight_decay=2e-4)
# optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.99, weight_decay=5e-4)
# optimizer = torch.optim.SGD([
# {'params': [param for name, param in model.named_parameters() if name[-4:] == 'bias'],
# 'lr': 2 * args.lr},
# {'params': [param for name, param in model.named_parameters() if name[-4:] != 'bias'],
# 'lr': args.lr, 'weight_decay': 5e-4}
# ], momentum=0.99)
if args.onGPU == True:
cudnn.benchmark = True
start_epoch = 0
if args.resume:
if os.path.isfile(args.resumeLoc):
print("=> loading checkpoint '{}'".format(args.resumeLoc))
checkpoint = torch.load(args.resumeLoc)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch{})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resumeLoc))
logfileLoc = args.save_dir + os.sep + args.logFile
print(logfileLoc)
if os.path.isfile(logfileLoc):
logger = open(logfileLoc, 'a')
logger.write("parameters: %s" % (str(n_param)))
logger.write("\n%s\t%s\t%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'Overall acc(Tr)',
'Overall acc(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
else:
logger = open(logfileLoc, 'w')
logger.write("Parameters: %s" % (str(n_param)))
logger.write("\n%s\t%s\t%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'Overall acc(Tr)',
'Overall acc(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
#lr scheduler
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[30, 60, 90],
gamma=0.1)
best_model_acc = 0
for epoch in range(start_epoch, args.max_epochs):
scheduler.step(epoch)
lr = 0
for param_group in optimizer.param_groups:
lr = param_group['lr']
# train(args,trainLoaderWithZoom,model,criteria,optimizer,epoch)
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr = train(
args, trainLoaderNoZoom, model, criteria, optimizer, epoch)
# print(per_class_acc_tr,per_class_iu_tr)
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = val(
args, valLoader, model, criteria)
#save_checkpoint
torch.save(
{
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
}, args.save_dir + '/checkpoint.pth.tar')
#save model also
# if overall_acc_val > best_model_acc:
# best_model_acc = overall_acc_val
model_file_name = args.save_dir + '/model_' + str(epoch + 1) + '.pth'
torch.save(model.state_dict(), model_file_name)
with open('../acc/acc_' + str(epoch) + '.txt', 'w') as log:
log.write(
"\nEpoch: %d\t Overall Acc (Tr): %.4f\t Overall Acc (Val): %.4f\t mIOU (Tr): %.4f\t mIOU (Val): %.4f"
% (epoch, overall_acc_tr, overall_acc_val, mIOU_tr, mIOU_val))
log.write('\n')
log.write('Per Class Training Acc: ' + str(per_class_acc_tr))
log.write('\n')
log.write('Per Class Validation Acc: ' + str(per_class_acc_val))
log.write('\n')
log.write('Per Class Training mIOU: ' + str(per_class_iu_tr))
log.write('\n')
log.write('Per Class Validation mIOU: ' + str(per_class_iu_val))
logger.write(
"\n%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.6f" %
(epoch, lossTr, lossVal, overall_acc_tr, overall_acc_val, mIOU_tr,
mIOU_val, lr))
logger.flush()
print("Epoch : " + str(epoch) + ' Details')
print(
"\nEpoch No.: %d\tTrain Loss = %.4f\tVal Loss = %.4f\t Train acc = %.4f\t Val acc = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f"
% (epoch, lossTr, lossVal, overall_acc_tr, overall_acc_val,
mIOU_tr, mIOU_val))
logger.close()
def trainValidateSegmentation(args):
# check if processed data file exists or not
if not os.path.isfile(args.cached_data_file):
dataLoader = ld.LoadData(args.data_dir, args.classes,
args.cached_data_file)
if dataLoader is None:
print('Error while processing the data. Please check')
exit(-1)
data = dataLoader.processData()
else:
data = pickle.load(open(args.cached_data_file, "rb"))
if args.modelType == 'C1':
model = net.ResNetC1(args.classes)
elif args.modelType == 'D1':
model = net.ResNetD1(args.classes)
else:
print('Please select the correct model. Exiting!!')
exit(-1)
args.savedir = args.savedir + args.modelType + '/'
if args.onGPU == True:
model = model.cuda()
# create the directory if not exist
if not os.path.exists(args.savedir):
os.mkdir(args.savedir)
if args.onGPU == True:
model = model.cuda()
if args.visualizeNet == True:
x = Variable(torch.randn(1, 3, args.inWidth, args.inHeight))
if args.onGPU == True:
x = x.cuda()
y = model.forward(x)
g = viz.make_dot(y)
g.render(args.savedir + '/model.png', view=False)
n_param = sum([np.prod(param.size()) for param in model.parameters()])
print('Network parameters: ' + str(n_param))
# define optimization criteria
print('Weights to handle class-imbalance')
weight = torch.from_numpy(
data['classWeights']) # convert the numpy array to torch
print(weight)
if args.onGPU == True:
weight = weight.cuda()
criteria = CrossEntropyLoss2d(weight) # weight
if args.onGPU == True:
criteria = criteria.cuda()
trainDatasetNoZoom = myTransforms.Compose([
# myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.RandomCropResize(20),
myTransforms.RandomHorizontalFlip(),
myTransforms.ToTensor(args.scaleIn)
])
trainDatasetWithZoom = myTransforms.Compose([
# myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Zoom(512, 512),
myTransforms.RandomCropResize(20),
myTransforms.RandomHorizontalFlip(),
myTransforms.ToTensor(args.scaleIn)
])
valDataset = myTransforms.Compose([
# myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.ToTensor(args.scaleIn)
])
trainLoaderNoZoom = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'],
data['trainAnnot'],
transform=trainDatasetNoZoom),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True)
trainLoaderWithZoom = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'],
data['trainAnnot'],
transform=trainDatasetWithZoom),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True)
valLoader = torch.utils.data.DataLoader(myDataLoader.MyDataset(
data['valIm'], data['valAnnot'], transform=valDataset),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
pin_memory=True)
# define the optimizer
# optimizer = torch.optim.Adam(model.parameters(), args.lr, (0.9, 0.999), eps=1e-08, weight_decay=2e-4)
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
if args.onGPU == True:
cudnn.benchmark = True
start_epoch = 0
if args.resume:
if os.path.isfile(args.resumeLoc):
print("=> loading checkpoint '{}'".format(args.resumeLoc))
checkpoint = torch.load(args.resumeLoc)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
logFileLoc = args.savedir + os.sep + args.logFile
if os.path.isfile(logFileLoc):
logger = open(logFileLoc, 'a')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write(
"\n%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
else:
logger = open(logFileLoc, 'w')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write(
"\n%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
#lr scheduler
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=args.step_loss,
gamma=0.1)
for epoch in range(start_epoch, args.max_epochs):
scheduler.step(epoch)
lr = 0
for param_group in optimizer.param_groups:
lr = param_group['lr']
# run at zoomed images first
train(args, trainLoaderWithZoom, model, criteria, optimizer, epoch)
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr = train(
args, trainLoaderNoZoom, model, criteria, optimizer, epoch)
# evaluate on validation set
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = val(
args, valLoader, model, criteria)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
}, args.savedir + '/checkpoint.pth.tar')
# save the model also
model_file_name = args.savedir + '/model_' + str(epoch + 1) + '.pth'
torch.save(model.state_dict(), model_file_name)
with open(args.savedir + 'acc_' + str(epoch) + '.txt', 'w') as log:
log.write(
"\nEpoch: %d\t Overall Acc (Tr): %.4f\t Overall Acc (Val): %.4f\t mIOU (Tr): %.4f\t mIOU (Val): %.4f"
% (epoch, overall_acc_tr, overall_acc_val, mIOU_tr, mIOU_val))
log.write('\n')
log.write('Per Class Training Acc: ' + str(per_class_acc_tr))
log.write('\n')
log.write('Per Class Validation Acc: ' + str(per_class_acc_val))
log.write('\n')
log.write('Per Class Training mIOU: ' + str(per_class_iu_tr))
log.write('\n')
log.write('Per Class Validation mIOU: ' + str(per_class_iu_val))
logger.write("\n%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f" %
(epoch, lossTr, lossVal, mIOU_tr, mIOU_val, lr))
logger.flush()
print("Epoch : " + str(epoch) + ' Details')
print(
"\nEpoch No.: %d\tTrain Loss = %.4f\tVal Loss = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f"
% (epoch, lossTr, lossVal, mIOU_tr, mIOU_val))
logger.close()
def main_tr(args, crossVal):
dataLoad = ld.LoadData(args.data_dir, args.classes)
data = dataLoad.processData(crossVal, args.data_name)
# load the model
model = net.MiniSeg(args.classes, aux=True)
if not osp.isdir(osp.join(args.savedir + '_mod' + str(args.max_epochs))):
os.mkdir(args.savedir + '_mod' + str(args.max_epochs))
if not osp.isdir(
osp.join(args.savedir + '_mod' + str(args.max_epochs),
args.data_name)):
os.mkdir(
osp.join(args.savedir + '_mod' + str(args.max_epochs),
args.data_name))
saveDir = args.savedir + '_mod' + str(
args.max_epochs) + '/' + args.data_name + '/' + args.model_name
# create the directory if not exist
if not osp.exists(saveDir):
os.mkdir(saveDir)
if args.gpu and torch.cuda.device_count() > 1:
#model = torch.nn.DataParallel(model)
model = DataParallelModel(model)
if args.gpu:
model = model.cuda()
total_paramters = sum([np.prod(p.size()) for p in model.parameters()])
print('Total network parameters: ' + str(total_paramters))
# define optimization criteria
weight = torch.from_numpy(
data['classWeights']) # convert the numpy array to torch
if args.gpu:
weight = weight.cuda()
criteria = CrossEntropyLoss2d(weight, args.ignore_label) #weight
if args.gpu and torch.cuda.device_count() > 1:
criteria = DataParallelCriterion(criteria)
if args.gpu:
criteria = criteria.cuda()
# compose the data with transforms
trainDataset_main = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(args.width, args.height),
myTransforms.RandomCropResize(int(32. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale1 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 1.5), int(args.height * 1.5)),
myTransforms.RandomCropResize(int(100. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale2 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 1.25), int(args.height * 1.25)),
myTransforms.RandomCropResize(int(100. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
trainDataset_scale3 = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(int(args.width * 0.75), int(args.height * 0.75)),
myTransforms.RandomCropResize(int(32. / 1024. * args.width)),
myTransforms.RandomFlip(),
myTransforms.ToTensor()
])
valDataset = myTransforms.Compose([
myTransforms.Normalize(mean=data['mean'], std=data['std']),
myTransforms.Scale(args.width, args.height),
myTransforms.ToTensor()
])
# since we training from scratch, we create data loaders at different scales
# so that we can generate more augmented data and prevent the network from overfitting
trainLoader = torch.utils.data.DataLoader(myDataLoader.Dataset(
data['trainIm'], data['trainAnnot'], transform=trainDataset_main),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale1 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale1),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale2 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale2),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
trainLoader_scale3 = torch.utils.data.DataLoader(
myDataLoader.Dataset(data['trainIm'],
data['trainAnnot'],
transform=trainDataset_scale3),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=True,
drop_last=True)
valLoader = torch.utils.data.DataLoader(myDataLoader.Dataset(
data['valIm'], data['valAnnot'], transform=valDataset),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
pin_memory=True)
max_batches = len(trainLoader) + len(trainLoader_scale1) + len(
trainLoader_scale2) + len(trainLoader_scale3)
if args.gpu:
cudnn.benchmark = True
start_epoch = 0
if args.pretrained is not None:
state_dict = torch.load(args.pretrained)
new_keys = []
new_values = []
for idx, key in enumerate(state_dict.keys()):
if 'pred' not in key:
new_keys.append(key)
new_values.append(list(state_dict.values())[idx])
new_dict = OrderedDict(list(zip(new_keys, new_values)))
model.load_state_dict(new_dict, strict=False)
print('pretrained model loaded')
if args.resume is not None:
if osp.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
args.lr = checkpoint['lr']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
log_file = osp.join(saveDir, 'trainValLog_' + args.model_name + '.txt')
if osp.isfile(log_file):
logger = open(log_file, 'a')
else:
logger = open(log_file, 'w')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write("\n%s\t%s\t\t%s\t%s\t%s\t%s\tlr" %
('CrossVal', 'Epoch', 'Loss(Tr)', 'Loss(val)',
'mIOU (tr)', 'mIOU (val)'))
logger.flush()
optimizer = torch.optim.Adam(model.parameters(),
args.lr, (0.9, 0.999),
eps=1e-08,
weight_decay=1e-4)
maxmIOU = 0
maxEpoch = 0
print(args.model_name + '-CrossVal: ' + str(crossVal + 1))
for epoch in range(start_epoch, args.max_epochs):
# train for one epoch
cur_iter = 0
train(args, trainLoader_scale1, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale1)
train(args, trainLoader_scale2, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale2)
train(args, trainLoader_scale3, model, criteria, optimizer, epoch,
max_batches, cur_iter)
cur_iter += len(trainLoader_scale3)
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr, lr = \
train(args, trainLoader, model, criteria, optimizer, epoch, max_batches, cur_iter)
# evaluate on validation set
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = \
val(args, valLoader, model, criteria)
torch.save(
{
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
'lr': lr
},
osp.join(
saveDir, 'checkpoint_' + args.model_name + '_crossVal' +
str(crossVal + 1) + '.pth.tar'))
# save the model also
model_file_name = osp.join(
saveDir, 'model_' + args.model_name + '_crossVal' +
str(crossVal + 1) + '_' + str(epoch + 1) + '.pth')
torch.save(model.state_dict(), model_file_name)
logger.write(
"\n%d\t\t%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.7f" %
(crossVal + 1, epoch + 1, lossTr, lossVal, mIOU_tr, mIOU_val, lr))
logger.flush()
print("\nEpoch No. %d:\tTrain Loss = %.4f\tVal Loss = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f\n" \
% (epoch + 1, lossTr, lossVal, mIOU_tr, mIOU_val))
if mIOU_val >= maxmIOU:
maxmIOU = mIOU_val
maxEpoch = epoch + 1
torch.cuda.empty_cache()
logger.flush()
logger.close()
return maxEpoch, maxmIOU
import aspectOpinion
CONSTANT_DIRECTORY = '../../ExtractReviews/Reviews/'
CONSTANT_FILENAME = 'reviews.txt'
if __name__ == '__main__':
instanceReadDirectory = readAllDirectory.ReadDirectory(CONSTANT_DIRECTORY)
instanceReadDirectory.readDirectory()
#pprint.pprint(instanceReadDirectory._dirList)
for index in range(0, len(instanceReadDirectory._dirList)):
print("Process : ", index)
pprint.pprint(CONSTANT_DIRECTORY +
instanceReadDirectory._dirList[index])
#Loading Review File
instanceLoadData = loadData.LoadData(
CONSTANT_DIRECTORY + instanceReadDirectory._dirList[index])
instanceLoadData.openFile(CONSTANT_FILENAME)
instanceLoadData.readText()
instanceLoadData.readNegativeWord()
#pprint.pprint(instanceLoadData._text)
#pprint.pprint(instanceLoadData._negWord)
instanceLoadData.closeFile()
#Removing Stop Words
instanceRemveStopWord = removeStopWord.RemoveStopWord(
instanceLoadData._text)
instanceRemveStopWord.removeStopWord()
#print(instanceRemveStopWord._stopWords)
#print(instanceRemveStopWord._result)
#Tokenizing Data
def trainValidateSegmentation(args):
print('Data file: ' + str(args.cached_data_file))
print(args)
# check if processed data file exists or not
if not os.path.isfile(args.cached_data_file):
dataLoader = ld.LoadData(args.data_dir, args.data_dir_val,
args.classes, args.cached_data_file)
data = dataLoader.processData()
if data is None:
print('Error while pickling data. Please check.')
exit(-1)
else:
data = pickle.load(open(args.cached_data_file, "rb"))
print('=> Loading the model')
model = net.ESPNet(classes=args.classes, channels=args.channels)
args.savedir = args.savedir + os.sep
if args.onGPU:
model = model.cuda()
# create the directory if not exist
if not os.path.exists(args.savedir):
os.mkdir(args.savedir)
if args.onGPU:
model = model.cuda()
if args.visualizeNet:
import VisualizeGraph as viz
x = Variable(
torch.randn(1, args.channels, args.inDepth, args.inWidth,
args.inHeight))
if args.onGPU:
x = x.cuda()
y = model(x, (128, 128, 128)) #, _, _
g = viz.make_dot(y)
g.render(args.savedir + os.sep + 'model', view=False)
total_paramters = 0
for parameter in model.parameters():
i = len(parameter.size())
p = 1
for j in range(i):
p *= parameter.size(j)
total_paramters += p
print('Parameters: ' + str(total_paramters))
# define optimization criteria
weight = torch.from_numpy(
data['classWeights']) # convert the numpy array to torch <- Sachin
print('Class Imbalance Weights')
print(weight)
criteria = torch.nn.CrossEntropyLoss(weight)
if args.onGPU:
criteria = criteria.cuda()
# We train at three different resolutions (144x144x144, 96x96x96 and 128x128x128)
# and validate at one resolution (128x128x128)
trainDatasetA = myTransforms.Compose([
myTransforms.MinMaxNormalize(),
myTransforms.ScaleToFixed(dimA=144, dimB=144, dimC=144),
myTransforms.RandomFlip(),
myTransforms.ToTensor(args.scaleIn),
])
trainDatasetB = myTransforms.Compose([
myTransforms.MinMaxNormalize(),
myTransforms.ScaleToFixed(dimA=96, dimB=96, dimC=96),
myTransforms.RandomFlip(),
myTransforms.ToTensor(args.scaleIn),
])
trainDatasetC = myTransforms.Compose([
myTransforms.MinMaxNormalize(),
myTransforms.ScaleToFixed(dimA=args.inWidth,
dimB=args.inHeight,
dimC=args.inDepth),
myTransforms.RandomFlip(),
myTransforms.ToTensor(args.scaleIn),
])
valDataset = myTransforms.Compose([
myTransforms.MinMaxNormalize(),
myTransforms.ScaleToFixed(dimA=args.inWidth,
dimB=args.inHeight,
dimC=args.inDepth),
myTransforms.ToTensor(args.scaleIn),
#
])
trainLoaderA = torch.utils.data.DataLoader(
myDataLoader.MyDataset(data['trainIm'],
data['trainAnnot'],
transform=trainDatasetA),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=False) #disabling pin memory because swap usage is high
trainLoaderB = torch.utils.data.DataLoader(myDataLoader.MyDataset(
data['trainIm'], data['trainAnnot'], transform=trainDatasetB),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=False)
trainLoaderC = torch.utils.data.DataLoader(myDataLoader.MyDataset(
data['trainIm'], data['trainAnnot'], transform=trainDatasetC),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
pin_memory=False)
valLoader = torch.utils.data.DataLoader(myDataLoader.MyDataset(
data['valIm'], data['valAnnot'], transform=valDataset),
batch_size=1,
shuffle=False,
num_workers=args.num_workers,
pin_memory=False)
# define the optimizer
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
model.parameters()),
args.lr, (0.9, 0.999),
eps=1e-08,
weight_decay=2e-4)
if args.onGPU == True:
cudnn.benchmark = True
start_epoch = 0
stored_loss = 100000000.0
if args.resume:
if os.path.isfile(args.resumeLoc):
print("=> loading checkpoint '{}'".format(args.resumeLoc))
checkpoint = torch.load(args.resumeLoc)
start_epoch = checkpoint['epoch']
stored_loss = checkpoint['stored_loss']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
logFileLoc = args.savedir + args.logFile
if os.path.isfile(logFileLoc):
logger = open(logFileLoc, 'a')
logger.write("Parameters: %s" % (str(total_paramters)))
logger.write(
"\n%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
else:
logger = open(logFileLoc, 'w')
logger.write("Arguments: %s" % (str(args)))
logger.write("\n Parameters: %s" % (str(total_paramters)))
logger.write(
"\n%s\t%s\t%s\t%s\t%s\t" %
('Epoch', 'Loss(Tr)', 'Loss(val)', 'mIOU (tr)', 'mIOU (val'))
logger.flush()
# reduce the learning rate by 0.5 after every 100 epochs
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=args.step_loss,
gamma=0.5) #40
best_val_acc = 0
loader_idxs = [
0, 1, 2
] # Three loaders at different resolutions are mapped to three indexes
for epoch in range(start_epoch, args.max_epochs):
# step the learning rate
scheduler.step(epoch)
lr = 0
for param_group in optimizer.param_groups:
lr = param_group['lr']
print('Running epoch {} with learning rate {:.5f}'.format(epoch, lr))
if epoch > 0:
# shuffle the loaders
np.random.shuffle(loader_idxs)
for l_id in loader_idxs:
if l_id == 0:
train(args, trainLoaderA, model, criteria, optimizer, epoch)
elif l_id == 1:
train(args, trainLoaderB, model, criteria, optimizer, epoch)
else:
lossTr, overall_acc_tr, per_class_acc_tr, per_class_iu_tr, mIOU_tr = \
train(args, trainLoaderC, model, criteria, optimizer, epoch)
# evaluate on validation set
lossVal, overall_acc_val, per_class_acc_val, per_class_iu_val, mIOU_val = val(
args, valLoader, model, criteria)
print('saving checkpoint') ## added
save_checkpoint(
{
'epoch': epoch + 1,
'arch': str(model),
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lossTr': lossTr,
'lossVal': lossVal,
'iouTr': mIOU_tr,
'iouVal': mIOU_val,
'stored_loss': stored_loss,
}, args.savedir + '/checkpoint.pth.tar')
# save the model also
if mIOU_val >= best_val_acc:
best_val_acc = mIOU_val
torch.save(model.state_dict(), args.savedir + '/best_model.pth')
with open(args.savedir + 'acc_' + str(epoch) + '.txt', 'w') as log:
log.write(
"\nEpoch: %d\t Overall Acc (Tr): %.4f\t Overall Acc (Val): %.4f\t mIOU (Tr): %.4f\t mIOU (Val): %.4f"
% (epoch, overall_acc_tr, overall_acc_val, mIOU_tr, mIOU_val))
log.write('\n')
log.write('Per Class Training Acc: ' + str(per_class_acc_tr))
log.write('\n')
log.write('Per Class Validation Acc: ' + str(per_class_acc_val))
log.write('\n')
log.write('Per Class Training mIOU: ' + str(per_class_iu_tr))
log.write('\n')
log.write('Per Class Validation mIOU: ' + str(per_class_iu_val))
logger.write("\n%d\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.4f\t\t%.6f" %
(epoch, lossTr, lossVal, mIOU_tr, mIOU_val, lr))
logger.flush()
print("Epoch : " + str(epoch) + ' Details')
print(
"\nEpoch No.: %d\tTrain Loss = %.4f\tVal Loss = %.4f\t mIOU(tr) = %.4f\t mIOU(val) = %.4f"
% (epoch, lossTr, lossVal, mIOU_tr, mIOU_val))
logger.close()
