def train(self, ts, cm, batchsz=1):
self.model.train()
start_time = time.time()
steps = int(math.floor(len(ts) / float(batchsz)))
shuffle = np.random.permutation(np.arange(steps))
pg = ProgressBar(steps)
cm.reset()
total_loss = 0
for i in range(steps):
self.optimizer.zero_grad()
si = shuffle[i]
x, y = self._batch(ts, si, batchsz)
pred = self.model(x)
loss = self.crit(pred, y)
total_loss += loss.data[0]
loss.backward()
self._add_to_cm(cm, y, pred)
self.optimizer.step()
pg.update()
pg.done()
duration = time.time() - start_time
total_corr = cm.get_correct()
total = cm.get_total()
print('Train (Loss %.4f) (Acc %d/%d = %.4f) (%.3f sec)' %
(float(total_loss) / total, total_corr, total,
float(total_corr) / total, duration))
print(cm)
def train(self, ts):
self.model.train()
start_time = time.time()
steps = int(len(ts))
shuffle = np.random.permutation(np.arange(steps))
total_loss = total_corr = total = 0
pg = ProgressBar(steps)
for i in range(steps):
self.optimizer.zero_grad()
si = shuffle[i]
src, dst, tgt = self._wrap(ts[si])
pred = self.model((src, dst))
loss = self.crit(pred, tgt)
total_loss += loss.data[0]
loss.backward()
total_corr += self._right(pred, tgt)
total += self._total(tgt)
self.optimizer.step()
pg.update()
pg.done()
duration = time.time() - start_time
avg_loss = float(total_loss) / total
print(
'Train (Loss %.4f) (Perplexity %.4f) (Acc %d/%d = %.4f) (%.3f sec)'
% (avg_loss, np.exp(avg_loss), total_corr, total,
float(total_corr) / total, duration))
def make_pdb(self, bar_msg=''):
"""
Returns a pdb-like formatted string. bar_msg is a string with message to show at ProgressBar initialization.
bar_msg = '' disables the bar.
:param bar_msg: str
:return: str
"""
models = self.models()
if bar_msg:
bar = ProgressBar(len(models), bar_msg)
else:
bar = None
if len(models) == 1:
s = self.__repr__()
else:
s = ''
for m in models:
s += 'MODEL%9i\n' % m[0].model
s += m.__repr__()
s += '\nENDMDL\n'
if bar:
bar.update()
if bar:
bar.done(False)
return s
def train(self, ts, batchsz):
self.model.train()
start_time = time.time()
steps = int(math.floor(len(ts) / float(batchsz)))
shuffle = np.random.permutation(np.arange(steps))
total_loss = total = 0
pg = ProgressBar(steps)
for i in range(steps):
self.optimizer.zero_grad()
si = shuffle[i]
ts_i = data.batch(ts, si, batchsz, long_tensor_alloc, tensor_shape,
tensor_max)
src, dst, tgt = self._wrap(ts_i)
pred = self.model((src, dst))
loss = self.crit(pred, tgt)
total_loss += loss.data[0]
loss.backward()
torch.nn.utils.clip_grad_norm(self.model.parameters(), self.clip)
total += self._total(tgt)
self.optimizer.step()
pg.update()
pg.done()
duration = time.time() - start_time
avg_loss = float(total_loss) / total
print('Train (Loss %.4f) (Perplexity %.4f) (%.3f sec)' %
(avg_loss, np.exp(avg_loss), duration))
def evaluate(epoch, model, val_loader, criterion, log_path):
model.eval()
val_progressor = ProgressBar(log_path,
mode="Val ",
epoch=epoch,
total_epoch=config.epochs,
model_name=config.model_name,
total=len(val_loader))
losses = AverageMeter()
top1 = AverageMeter()
with torch.no_grad():
for index, (data, label) in enumerate(val_loader):
val_progressor.current = index
data = Variable(data).cuda()
label = Variable(torch.from_numpy(np.asarray(label))).cuda()
output = model(data)
loss = criterion(output, label)
p_top1, p_top2 = accuracy(output, label, topk=(1, 2))
losses.update(loss.item(), data.size(0))
top1.update(p_top1[0], data.size(0))
val_progressor.current_loss = losses.avg
val_progressor.current_top1 = top1.avg
val_progressor()
#print('epoch %d validate iteration %d: loss: %.3f' % (epoch + 1, index + 1, it_loss.data))
#correct += (output == label).sum()
val_progressor.done()
return losses.avg, top1.avg
def rmsd_matrix(self, msg=''):
"""
Calculates rmsd matrix with no fitting for all pairs od models in trajectory.
:return: np.array
"""
def rmsd(m1, m2, ml):
return np.sqrt(np.sum((m1 - m2)**2) / ml)
model_length = len(self.template)
models = self.coordinates.reshape(-1, model_length, 3)
dim = len(models)
result = np.zeros((dim, dim))
if msg:
bar = ProgressBar((dim * dim - dim) / 2, msg=msg)
else:
bar = None
for i in range(dim):
for j in range(i + 1, dim):
if bar:
bar.update()
result[i, j] = result[j, i] = rmsd(models[i], models[j],
model_length)
if bar:
bar.done(True)
return result
def train(self, ts, cm, dropout, batchsz=1):
total_loss = 0
start_time = time.time()
steps = int(math.floor(len(ts)/float(batchsz)))
shuffle = np.random.permutation(np.arange(steps))
pg = ProgressBar(steps)
cm.reset()
for i in range(steps):
si = shuffle[i]
ts_i = data.batch(ts, si, batchsz)
feed_dict = self.model.ex2dict(ts_i, 1.0-dropout)
_, step, summary_str, lossv, guess = self.sess.run([self.train_op, self.global_step, self.summary_op, self.loss, self.model.best], feed_dict=feed_dict)
self.train_writer.add_summary(summary_str, step)
total_loss += lossv
cm.add_batch(ts_i.y, guess)
pg.update()
pg.done()
total = cm.get_total()
total_corr = cm.get_correct()
duration = time.time() - start_time
print('Train (Loss %.4f) (Acc %d/%d = %.4f) (%.3f sec)' % (float(total_loss)/total, total_corr, total, float(total_corr)/total, duration))
print(cm)
def main(argv=None):
with tf.Session() as sess:
data_dir = FLAGS.data_dir
files = [os.path.join(data_dir, item) for item in os.listdir(data_dir)]
# files = random.sample(files, 800)
images = tf.placeholder(tf.float32,
[None, RESIZE_FINAL, RESIZE_FINAL, 3])
logits = inference(
images,
False,
num_classes=2,
num_blocks=[3, 4, 6, 3], # defaults to 50-layer network
use_bias=False, # defaults to using batch norm
bottleneck=True)
init = tf.global_variables_initializer()
resnet_variables = tf.global_variables()
saver = tf.train.Saver(resnet_variables)
saver.restore(sess, os.path.join(FLAGS.model_dir, FLAGS.ckpt_file))
softmax_output = tf.nn.softmax(logits)
if FLAGS.target:
print('Creating output file %s' % FLAGS.target)
output = open(os.path.join(FLAGS.data_dir, FLAGS.target), 'w')
writer = csv.writer(output)
writer.writerow(('file', 'label', 'score'))
num_batches = int(math.ceil(len(files)) / MAX_BATCH_SZ)
pg = ProgressBar(num_batches)
# try:
for j in range(num_batches):
start_offset = j * MAX_BATCH_SZ
end_offset = min((j + 1) * MAX_BATCH_SZ, len(files))
batch_image_files = files[start_offset:end_offset]
images_ = []
for file in batch_image_files:
print file
image_buffer = tf.read_file(file)
bbox = []
image = image_preprocessing(image_buffer, [], False)
images_.append(image)
image_batch = tf.stack(images_)
batch_results = sess.run(softmax_output,
feed_dict={images: image_batch.eval()})
batch_sz = batch_results.shape[0]
for i in range(batch_sz):
output_i = batch_results[i]
best_i = np.argmax(output_i)
best_choice = (label_list[best_i], output_i[best_i])
if writer is not None:
f = batch_image_files[i]
writer.writerow(
(f, best_choice[0], '%.2f' % best_choice[1]))
pg.update()
pg.done()
def train(self, ts, sess, summary_writer, dropout, batchsz):
total_loss = 0
steps = int(math.floor(len(ts)/float(batchsz)))
shuffle = np.random.permutation(np.arange(steps))
start_time = time.time()
pg = ProgressBar(steps)
for i in range(steps):
si = shuffle[i]
ts_i = batch(ts, si, batchsz)
feed_dict = self.model.ex2dict(ts_i, 1.0-dropout)
_, step, summary_str, lossv = sess.run([self.train_op, self.global_step, self.summary_op, self.loss], feed_dict=feed_dict)
summary_writer.add_summary(summary_str, step)
#print(lossv, errv, totv)
total_loss += lossv
pg.update()
pg.done()
duration = time.time() - start_time
print('Train (Loss %.4f) (%.3f sec)' % (total_loss/steps, duration))
def main():
weight_path = config.weights + config.model_name + os.sep + config.description + os.sep + str(
config.fold) + os.sep
if not os.path.exists(weight_path):
os.makedirs(weight_path)
log_path = config.logs + config.model_name + os.sep + config.description + os.sep + str(
config.fold) + os.sep
if not os.path.exists(log_path):
os.makedirs(log_path)
submit_path = config.submit + config.model_name + os.sep + config.description + os.sep + str(
config.fold) + os.sep
if not os.path.exists(submit_path):
os.makedirs(submit_path)
config.write_to_log(log_path + os.sep + 'log.txt')
#dataset preparing
train_dataset = customDataset(config.train_data, train=True)
val_dataset = customDataset(config.test_data, train=True)
train_loader = DataLoader(train_dataset,
batch_size=config.batch_size,
shuffle=True,
pin_memory=True)
val_loader = DataLoader(val_dataset,
batch_size=config.batch_size * 2,
shuffle=False,
pin_memory=False)
#model preparing
model = get_net(config.num_classes)
model = DataParallel(model.cuda(), device_ids=config.gpus)
model.train()
#optimizer preparing
optimizer = optim.Adam(model.parameters(),
lr=config.lr,
amsgrad=True,
weight_decay=config.weight_decay)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
#loss preparing
#criterion = nn.CrossEntropyLoss().cuda()
criterion = FocalLoss(config.num_classes).cuda()
train_loss = AverageMeter()
train_top1 = AverageMeter()
valid_loss = [np.inf, 0, 0]
best_precision = 0
for epoch in range(config.epochs):
scheduler.step(epoch)
train_progressor = ProgressBar(log_path,
mode="Train",
epoch=epoch,
total_epoch=config.epochs,
model_name=config.model_name,
total=len(train_loader))
for index, (data, label) in enumerate(train_loader):
train_progressor.current = index
data = Variable(data).cuda()
label = Variable(torch.from_numpy(np.asarray(label))).cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, label)
loss.backward()
optimizer.step()
precision1_train, precision2_train = accuracy(output,
label,
topk=(1, 2))
train_loss.update(loss.item(), data.size(0))
train_top1.update(precision1_train[0], data.size(0))
train_progressor.current_loss = train_loss.avg
train_progressor.current_top1 = train_top1.avg
train_progressor()
#print('train epoch %d iteration %d: loss: %.3f' % (epoch + 1, index + 1, loss.data))
train_progressor.done()
val_loss, val_top1 = evaluate(epoch, model, val_loader, criterion,
log_path)
is_best = val_top1 > best_precision
#print(bool(is_best))
best_precision = max(val_top1, best_precision)
save_checkpoint(
{
"epoch": epoch + 1,
"model_name": config.model_name,
"state_dict": model.state_dict(),
"best_precision1": best_precision,
"optimizer": optimizer.state_dict(),
"fold": config.fold,
"valid_loss": valid_loss,
}, is_best, weight_path, log_path, epoch)
