def train_reid_an_iter(config,
loaders,
base,
only_one,
target_loader_iter=None):
if only_one:
source_images, _, source_ids, source_cams = loaders.reid_source_train_iter.next_one(
)
source_images, source_ids = source_images.to(
base.device), source_ids.to(base.device)
_, source_feature_vectors, source_cls_score = base.encoder(
source_images, True, sl_enc=False)
# loss classification loss and triplet loss
source_cls_loss = base.ide_creiteron(source_cls_score, source_ids,
loaders.num_source_pids)
triplet_loss_1 = base.triplet_creiteron(source_feature_vectors,
source_ids)
source_acc = accuracy(source_cls_score, source_ids, [1])[0]
else:
assert target_loader_iter is not None, "The labeled target loader should not be none"
source_images, _, source_ids, source_cams = loaders.reid_source_train_iter.next_one(
)
source_images, source_ids = source_images.to(
base.device), source_ids.to(base.device)
_, source_feature_vectors, source_cls_score = base.encoder(
source_images, True, sl_enc=False)
# loss classification loss and triplet loss
source_cls_loss = base.ide_creiteron(source_cls_score, source_ids,
loaders.num_source_pids)
triplet_loss_1 = base.triplet_creiteron(source_feature_vectors,
source_ids)
source_acc = accuracy(source_cls_score, source_ids, [1])[0]
target_images, _, target_ids, ir_cams = target_loader_iter.next_one()
target_images, target_ids = target_images.to(
base.device), target_ids.to(base.device)
# two losses for generated dataset
_, target_feature_vectors, target_cls_score = base.encoder(
target_images, True, sl_enc=False)
target_cls_loss = base.ide_creiteron(target_cls_score, target_ids)
triplet_loss_2 = base.triplet_creiteron(target_feature_vectors,
target_ids)
triplet_loss = (triplet_loss_1 + triplet_loss_2) / 2.0
cls_loss = (source_cls_loss + target_cls_loss) / 2.0
target_acc = accuracy(target_cls_score, target_ids, [1])[0]
acc = torch.Tensor([source_acc, target_acc])
return cls_loss, triplet_loss, acc
return source_cls_loss, triplet_loss_1, source_acc
def train_an_epoch(config, base, loaders):
base.set_train()
meter = MultiItemAverageMeter()
### we assume 200 iterations as an epoch
for _ in range(200):
### load a batch data
imgs, pids, _ = loaders.train_iter.next_one()
imgs, pids = imgs.to(base.device), pids.to(base.device)
### forward
logits_list, embeddings_list = base.model(imgs)
### loss
ide_loss, avg_logits = base.compute_ide_loss(logits_list, pids)
source_acc = accuracy(avg_logits, pids, [1])[0]
### optimize
base.optimizer.zero_grad()
ide_loss.backward()
base.optimizer.step()
### recored
meter.update({'ide_loss': ide_loss, 'acc': source_acc})
return meter.get_val(), meter.get_str()
def train_an_epoch(config, base, loaders):
base.set_train()
meter = MultiItemAverageMeter()
### we assume 200 iterations as an epoch
for _ in range(200):
### load a batch data
imgs, pids, _ = loaders.train_iter.next_one()
imgs, pids = imgs.to(base.device), pids.to(base.device)
### forward
features, cls_score = base.model(imgs)
### loss
ide_loss = base.ide_creiteron(cls_score, pids)
triplet_loss = base.triplet_creiteron(features, features, features,
pids, pids, pids)
loss = ide_loss + triplet_loss
acc = accuracy(cls_score, pids, [1])[0]
### optimize
base.optimizer.zero_grad()
loss.backward()
base.optimizer.step()
### recored
meter.update({
'ide_loss': ide_loss.data,
'triplet_loss': triplet_loss.data,
'acc': acc
})
return meter.get_val(), meter.get_str()
def train_running():
with tf.name_scope('input'):
train_batch, train_label_batch, _ = input_data.get_batch(train_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
val_batch, val_label_batch, _ = input_data.get_batch(val_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
model = models.model(x, N_CLASSES)
model.AlexNet()
logits = model.fc3
loss = tools.loss(logits, y_)
acc = tools.accuracy(logits, y_)
train_op = tools.optimize(loss, LEARNING_RATE)
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
summary_op = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images, tra_labels = sess.run([train_batch, train_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, acc],
feed_dict={x: tra_images, y_: tra_labels})
if step % 50 == 0:
print('Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc))
summary_str = sess.run(summary_op, feed_dict={x: tra_images, y_: tra_labels})
train_writer.add_summary(summary_str, step)
#
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run([val_batch, val_label_batch])
val_loss, val_acc = sess.run([loss, acc],
feed_dict={x: val_images, y_: val_labels})
print('** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc))
summary_str = sess.run(summary_op, feed_dict={x: val_images, y_: val_labels})
val_writer.add_summary(summary_str, step)
#
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def train(trainloader, model, warmup_scheduler, criterion, criterion1,
optimizer, epoch, use_cuda):
model.train()
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
losses1 = AverageMeter()
losses2 = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
end = time.time()
bar = Bar('Processing', max=len(trainloader))
for batch_index, (images, labels) in enumerate(trainloader):
if epoch <= args.warm:
warmup_scheduler.step()
images = Variable(images)
labels = Variable(labels)
labels = labels.cuda()
images = images.cuda()
optimizer.zero_grad()
outputs, features = model(images)
loss1 = criterion(outputs, labels)
loss = loss1 #+ 0.2*loss2
prec1, prec5 = accuracy(outputs.data, labels.data, topk=(1, 5))
losses.update(loss.item(), images.size(0))
losses1.update(loss1.item(), images.size(0))
losses2.update(loss1.item(), images.size(0))
top1.update(prec1.item(), images.size(0))
top5.update(prec5.item(), images.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
# plot progress
bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Loss_softmax: {loss1:.4f} | Loss_aj: {loss2:.4f} |top1: {top1: .4f} | top5: {top5: .4f}'.format(
batch=batch_index + 1,
size=len(trainloader),
data=data_time.avg,
bt=batch_time.avg,
loss1=losses1.avg,
loss2=losses2.avg,
top1=top1.avg,
top5=top5.avg,
)
bar.next()
bar.finish()
return (losses.avg, top1.avg)
def train_an_epoch(config, base, loaders, epoch=None):
base.set_train()
meter = MultiItemAverageMeter()
### we assume 200 iterations as an epoch
base.lr_scheduler.step(epoch)
for _ in range(config.steps):
### load a batch data
imgs, pids, _ = loaders.train_iter.next_one()
imgs, pids = imgs.to(base.device), pids.to(base.device)
if 'res' in config.cnnbackbone:
### forward
features, cls_score = base.model(imgs)
### loss
ide_loss = base.ide_creiteron(cls_score, pids)
triplet_loss = base.triplet_creiteron(features, features, features, pids, pids, pids)
loss = ide_loss + triplet_loss
acc = accuracy(cls_score, pids, [1])[0]
### optimize
base.optimizer.zero_grad()
loss.backward()
base.optimizer.step()
### recored
meter.update({'ide_loss': ide_loss.data, 'triplet_loss': triplet_loss.data, 'acc': acc})
elif config.cnnbackbone == 'osnetain':
### forward
if epoch < 10:
cls_score = base.model(imgs, fixed_cnn=True)
else:
cls_score = base.model(imgs, fixed_cnn=False)
### loss
ide_loss = base.ide_creiteron(cls_score, pids)
acc = accuracy(cls_score, pids, [1])[0]
### optimize
base.optimizer.zero_grad()
ide_loss.backward()
base.optimizer.step()
### recored
meter.update({'ide_loss': ide_loss.data, 'acc': acc})
return meter.get_val(), meter.get_str()
def test_batch():
with tf.Graph().as_default():
tra_image_batch, tra_label_batch = get_batch(img_batch_list, lab_batch_list)
logits, _ = vgg.vgg_16(tra_image_batch, num_classes=5, is_training=False)
# logits, _ = vgg.vgg_16(tra_image_batch, num_classes=5, is_training=False)
loss = slim.losses.softmax_cross_entropy(logits, tra_label_batch)
accuracy = tools.accuracy(logits, tra_label_batch)
saver = tf.train.Saver()
with tf.Session() as sess:
print("Reading checkpoints...")
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
else:
print('No checkpoint file found')
return
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
print('\nEvaluating......')
num_step = int(math.floor(408 / 32))
num_sample = num_step * 32
step = 0
total_correct = 0
total_loss = 0
while step < num_step and not coord.should_stop():
batch_accuracy = sess.run(accuracy)
batch_loss = sess.run(loss)
total_correct += np.sum(batch_accuracy)
total_loss += np.sum(batch_loss)
step += 1
print(batch_accuracy)
print(batch_loss)
print('Total testing samples: %d' % num_sample)
print('Average accuracy: %.2f%%' % ( total_correct / step))
print('Average loss: %2.f' % (total_loss / step))
except Exception as e:
coord.request_stop(e)
finally:
coord.request_stop()
coord.join(threads)
def train_reid_an_iter(config, loaders, base):
### load data
rgb_images, rgb_ids, rgb_cams, _ = loaders.reid_rgb_train_iter.next_one()
ir_images, ir_ids, ir_cams, _ = loaders.reid_ir_train_iter.next_one()
rgb_images, ir_images = rgb_images.to(base.device), ir_images.to(
base.device)
rgb_ids, ir_ids = rgb_ids.to(base.device), ir_ids.to(base.device)
assert torch.equal(rgb_ids, ir_ids)
### compute feature
_, rgb_feature_vectors, rgb_cls_score = base.encoder(rgb_images,
True,
sl_enc=False)
_, ir_feature_vectors, ir_cls_score = base.encoder(ir_images,
True,
sl_enc=False)
### compute loss
rgb_cls_loss = base.ide_creiteron(rgb_cls_score, rgb_ids)
ir_cls_loss = base.ide_creiteron(ir_cls_score, ir_ids)
cls_loss = (rgb_cls_loss + ir_cls_loss) / 2.0
triplet_loss_1 = base.triplet_creiteron(rgb_feature_vectors,
ir_feature_vectors,
ir_feature_vectors, rgb_ids,
ir_ids, ir_ids)
triplet_loss_2 = base.triplet_creiteron(ir_feature_vectors,
rgb_feature_vectors,
rgb_feature_vectors, ir_ids,
rgb_ids, rgb_ids)
triplet_loss = (triplet_loss_1 + triplet_loss_2) / 2.0
### acc
rgb_acc = accuracy(rgb_cls_score, rgb_ids, [1])[0]
ir_acc = accuracy(ir_cls_score, ir_ids, [1])[0]
acc = torch.Tensor([rgb_acc, ir_acc])
return cls_loss, triplet_loss, acc
def validate(val_loader, backbone, model, acc_prefixes, args):
batch_time = AverageMeter('Time', ':.3f')
# switch to evaluate mode
model.eval()
# TODO: Aniruddha
pred_var_stack, labels_var_stack = [torch.Tensor()]*5, torch.Tensor()
with torch.no_grad():
end = time.time()
for i, (images, target) in enumerate(val_loader):
images = images.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
# compute output
features = backbone(images)
outputs = model(features)
if not i:
acc_meters = [
NoBatchAverageMeter('', ':11.2f')
for i in range(len(outputs))
]
progress = NoTabProgressMeter(
len(val_loader),
[batch_time, *acc_meters],
prefix='Test: ')
# measure accuracy
for output, acc_meter in zip(outputs, acc_meters):
acc1, _ = accuracy(output, target, topk=(1, 5))
acc_meter.update(acc1[0], images.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0 or i == len(val_loader)-1:
line = progress.display(i)
len_prefixes = len(acc_prefixes) * len(acc_prefixes[0])
prefix_line = ' ' * (len(line) - len_prefixes)
prefix_line += ''.join(acc_prefixes)
logger.info(prefix_line)
logger.info(line)
for layer_id in range(5):
pred_var_stack[layer_id] = torch.cat((pred_var_stack[layer_id], outputs[layer_id].cpu()), dim=0)
labels_var_stack = torch.cat((labels_var_stack, target.cpu()), dim=0)
return acc_meters, pred_var_stack, labels_var_stack
def train(train_loader, backbone, model, optimizer, acc_prefixes, epoch, args):
batch_time = AverageMeter('B', ':.2f')
data_time = AverageMeter('D', ':.2f')
# switch to train mode
model.train()
end = time.time()
for i, (images, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
images = images.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
with torch.no_grad():
features = backbone(images)
outputs = model(features)
if not i:
acc_meters = [
NoBatchAverageMeter('', ':>11.2f')
for i in range(len(outputs))
]
progress = NoTabProgressMeter(
len(train_loader),
[batch_time, data_time, *acc_meters],
prefix="Epoch: [{}]".format(epoch))
# measure accuracy
optimizer.zero_grad()
for output, acc_meter in zip(outputs, acc_meters):
loss = F.cross_entropy(output, target)
loss.backward()
acc1, _ = accuracy(output, target, topk=(1, 5))
acc_meter.update(acc1[0], images.size(0))
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
line = progress.display(i)
len_prefixes = len(acc_prefixes) * len(acc_prefixes[0])
prefix_line = ' ' * (len(line) - len_prefixes)
prefix_line += ''.join(acc_prefixes)
logger.info(prefix_line)
logger.info(line)
def NaiveBayesModelMain():
#from tools to create the train,trainlabel,test,testlabel
train, trainLabel, test, testLabel = tl.createDataSet()
#declare the naivebayed model and fit the params of the model with trainSet and trainLabel
NaiveBayesModel = NaiveBayes(train, trainLabel)
#test the model with the testData
predictionLabel = NaiveBayesModel.prediction(test)
#calculate the acc, rec and F between predict result and testLabel from tools
acc = tl.accuracy(predictionLabel, testLabel)
rec = tl.recall(predictionLabel, testLabel)
F = tl.Fvalue(predictionLabel, testLabel)
#print the acc, rec and F
print 'NaiveBayesModel Accuracy : ' + str(acc)
print 'NaiveBayesModel Recall : ' + str(rec)
print 'NaiveBayesModel F-value : ' + str(F)
def eval_training(testloader, model, criterion, epoch, use_cuda):
global best_acc
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
bar = Bar('Processing', max=len(testloader))
for batch_index, (images, labels) in enumerate(testloader):
images = Variable(images)
labels = Variable(labels)
images = images.cuda()
labels = labels.cuda()
outputs, _ = model(images)
loss = criterion(outputs, labels)
prec1, prec5 = accuracy(outputs.data, labels.data, topk=(1, 5))
losses.update(loss.item(), images.size(0))
top1.update(prec1.item(), images.size(0))
top5.update(prec5.item(), images.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
# plot progress
bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | top1: {top1: .4f} | top5: {top5: .4f}'.format(
batch=batch_index + 1,
size=len(testloader),
data=data_time.avg,
bt=batch_time.avg,
total=bar.elapsed_td,
eta=bar.eta_td,
loss=losses.avg,
top1=top1.avg,
top5=top5.avg,
)
bar.next()
bar.finish()
return (losses.avg, top1.avg)
def evaluate(self):
self.model.eval()
Loss = CrossEntropyLoss(weight=torch.Tensor([0.9, 1, 1])).to(
self.device)
loss = 0.0
acc = 0.0
with torch.no_grad():
for i in range(10):
images, labels = next(self.test_generator)
images = images.to(self.device)
labels = labels.to(self.device)
logits = self.model(images)
loss += Loss(logits, labels)
acc += accuracy(logits, labels)
self.model.train()
return loss / 10, acc / 10
def run(batch_size=300, learning_rate=0.01):
#region create network
data, label = CifarInput.read_cifar10(
r"C:\Projects\Programming\CsDiscount\cifar-10-binary", True,
batch_size, True)
logit = CapsNet.CapsNet(data, batch_size)
reconstruction = tools.decoder(logit)
reconstruction_p = tf.placeholder(dtype=tf.float32,
shape=[batch_size, 32, 32, 3])
print("Network Created")
#endregion
#region create optimizer
global_step = tf.Variable(0, trainable=False, name="global_step")
loss = tools.loss(logit, label, data, reconstruction_p, batch_size)
accuracy = tools.accuracy(logit, label)
train_op = tools.optimize(loss, learning_rate, global_step)
print("Optimizer Created")
#endregion
#region create sessions, queues and savers
sess = tf.Session()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
init = tf.global_variables_initializer()
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
train_summary_writer = tf.summary.FileWriter(train_log_dir)
sess.run(init)
print("Sessions, Queues and Savers Created")
#endregion
for x in range(1000):
print(x)
reconstruction_run = sess.run(reconstruction)
sess.run(train_op, feed_dict={reconstruction_p: reconstruction_run})
if x % 5 == 0:
mainwindow.newimg(reconstruction_run[0])
if x % 100 == 0:
print(sess.run(accuracy))
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, save_path=checkpoint_path, global_step=x)
def evaluate(self):
self.model.eval()
loss = 0.0
acc = 0.0
with torch.no_grad():
for i in range(2):
images, Offset, Judge1, Judge2, true_box_coors = next(self.test_generator)
images, Offset, Judge1, Judge2 = images.to(self.device), Offset.to(self.device), Judge1.to(self.device), Judge2.to(self.device)
class_sum, loc_sum = self.model(images)
loss_l, loss_c = self.Loss(class_sum, loc_sum, Offset, Judge1, Judge2)
loss += (10*loss_l + loss_c)
acc += accuracy(class_sum, loc_sum, true_box_coors)
self.model.train()
return loss/2, acc/2
def DecisionTreeModelMain():
#根据fruit.txt抽取训练集、测试集、训练集标签、测试集标签
trainSet, labels, testSet, testLabels = dp.createDataSet()
#最大最小规约
#tl.maxminScalar(trainSet)
#tl.maxminScalar(testSet)
#以Gini函数建树并剪枝
Tree = buildDecisionTree(trainSet, evaluationFunc=tl.gini)
tl.pruneTree(Tree, 0.3, evaluationFunc=tl.gini)
#绘制决策树图像，并保存为fruit.png
res = dp.plot(Tree)
dot_data = dp.dotgraph(Tree)
graph = pydotplus.graph_from_dot_data(dot_data)
#报错提示没有graphViz模块，可以选择./DecisionTreeResultPng/中png图像进行显示
if graph == None or dot_data == None :
fruitPngBackup = cv2.imread("./DecisionTreeResultPng/fruit7.png")
cv2.imshow("fruitPngBackup.png", fruitPngBackup)
cv2.waitKey(4000)
graph.write_png("fruit.png")
#读取fruit.png
#显示fruit.png,设置窗口时间为5秒自动关闭
fruitPng = cv2.imread("./fruit.png")
cv2.imshow('fruitPng.png', fruitPng)
cv2.waitKey(4000)
#测试 Step
accu = tl.accuracy(testSet, testLabels, Tree)
rec = tl.recall(testSet, testLabels, Tree, len(trainSet) + len(testSet))
F = tl.fValue(testSet, testLabels, Tree, len(trainSet) + len(testSet))
#print the acc, rec and F
print 'DecisionTree Accuracy : ' + str(accu)
print 'DecisionTree Recall : ' + str(rec)
print 'DecisionTree F-value : ' + str(F)
def validation(loader, model, writer):
model.eval()
total_loss = cuda.FloatTensor([0.])
total_accu = cuda.FloatTensor([0.])
widgets = [
"processing: ",
progressbar.Percentage(),
" ",
progressbar.ETA(),
" ",
progressbar.FileTransferSpeed(),
]
bar = progressbar.ProgressBar(widgets=widgets,
max_value=len(loader)).start()
for i, batch in enumerate(loader):
bar.update(i)
batch_data, batch_label = batch
batch_data = Variable(batch_data).cuda()
batch_label = Variable(batch_label).cuda()
logits = model(batch_data)
loss = model.criterion(logits, batch_label)
accu = tools.accuracy(logits=logits, targets=batch_label).data
total_accu.add_(accu)
total_loss.add_(loss.data)
mean_loss = total_loss.cpu().numpy() / (i + 1)
mean_accu = total_accu.cpu().numpy() / (i + 1)
writer.add_scalar('val/loss', scalar_value=mean_loss, global_step=EPOCH)
writer.add_scalar('val/accu', scalar_value=mean_accu, global_step=EPOCH)
print('')
print("validation-->epoch:{},mean_loss:{}, mean_accuracy:{}".format(
EPOCH, mean_loss, mean_accu))
bar.finish()
def infer(valid_queue, model, criterion,args):
objs = tools.AvgrageMeter()
top1 = tools.AvgrageMeter()
top5 = tools.AvgrageMeter()
model.eval()
for step, (input, target) in enumerate(valid_queue):
input = Variable(input, volatile=True).cuda()
target = Variable(target, volatile=True).cuda(async=True)
logits = model(input)
loss = criterion(logits, target)
prec1, prec5 = tools.accuracy(logits, target, topk=(1, 5))
n = input.size(0)
objs.update(loss.item(), n)
top1.update(prec1.item(), n)
top5.update(prec5.item(), n)
if step % args.report_freq == 0:
logging.info('valid %03d %e %f %f', step, objs.avg, top1.avg, top5.avg)
return top1.avg, objs.avg
def test_running():
with tf.Graph().as_default():
mnist = input_data.read_data_sets('../MNIST_data/', one_hot=True)
x = tf.placeholder(tf.float32, shape=[None, 784])
x_reshape = tf.reshape(x, [-1, 28, 28, 1])
y_ = tf.placeholder(tf.float32, [None, num_classes])
model = models.Model(x_reshape, num_classes)
model.lenet5()
logits = model.logits
acc = tools.accuracy(logits, y_)
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
print("Reading checkpoints...")
ckpt = tf.train.get_checkpoint_state(model_dir)
if ckpt and ckpt.model_checkpoint_path:
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
saver.restore(sess, ckpt.model_checkpoint_path)
print('Loading success, global_step is %s' % global_step)
else:
print('No checkpoint file found')
return
test_acc = sess.run(acc,
feed_dict={
x: mnist.test.images,
y_: mnist.test.labels
})
print('test accuarcy: %.2f%%' % (test_acc))
def train(train_queue, valid_queue, model, architect, criterion, optimizer, lr,args):
objs = tools.AvgrageMeter()
top1 = tools.AvgrageMeter()
top5 = tools.AvgrageMeter()
for step, (input, target) in enumerate(train_queue):
model.train()
n = input.size(0)
input = Variable(input, requires_grad=False).cuda()
target = Variable(target, requires_grad=False).cuda(async=True)
# get a random minibatch from the search queue with replacement
input_search, target_search = next(iter(valid_queue))
input_search = Variable(input_search, requires_grad=False).cuda()
target_search = Variable(target_search, requires_grad=False).cuda(async=True)
architect.step(input, target, input_search, target_search, lr, optimizer, unrolled=args.unrolled)
optimizer.zero_grad()
logits = model(input)
loss = criterion(logits, target)
loss.backward()
nn.utils.clip_grad_norm_(model.weight_parameters(), args.grad_clip)
optimizer.step()
prec1, prec5 = tools.accuracy(logits, target, topk=(1, 5))
objs.update(loss.item(), n)
top1.update(prec1.item(), n)
top5.update(prec5.item(), n)
if step % args.report_freq == 0:
logging.info('train %03d %e %f %f', step, objs.avg, top1.avg, top5.avg)
return top1.avg, objs.avg
def train():
pre_trained_weights = './/vgg16_pretrain//vgg16.npy'
data_dir = './/data//cifar-10-batches-bin//'
train_log_dir = './/logs//train//'
val_log_dir = './/logs//val//'
with tf.name_scope('input'):
tra_image_batch, tra_label_batch = input_data.read_cifar10(
data_dir=data_dir,
is_train=True,
batch_size=BATCH_SIZE,
shuffle=True)
val_image_batch, val_label_batch = input_data.read_cifar10(
data_dir=data_dir,
is_train=False,
batch_size=BATCH_SIZE,
shuffle=False)
logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN)
loss = tools.loss(logits, tra_label_batch)
accuracy = tools.accuracy(logits, tra_label_batch)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = tools.optimize(loss, learning_rate, my_global_step)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES])
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# load the parameter file, assign the parameters, skip the specific layers
tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images, tra_labels = sess.run(
[tra_image_batch, tra_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={
x: tra_images,
y_: tra_labels
})
if step % 50 == 0 or (step + 1) == MAX_STEP:
print('Step: %d, loss: %.4f, accuracy: %.4f%%' %
(step, tra_loss, tra_acc))
summary_str = sess.run(summary_op)
tra_summary_writer.add_summary(summary_str, step)
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run(
[val_image_batch, val_label_batch])
val_loss, val_acc = sess.run([loss, accuracy],
feed_dict={
x: val_images,
y_: val_labels
})
print(
'** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %
(step, val_loss, val_acc))
summary_str = sess.run(summary_op)
val_summary_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
]
for epoch in range(training_epochs):
model.train()
for meter in [train_accuracy, test_accuracy, train_loss, test_loss]:
meter.reset()
for index, (data_in, label) in enumerate(train_dataloader):
output = model(data_in)
loss = loss_fn(output, label)
train_loss.update_with_weight(loss.item(), label.shape[0])
optimizer.zero_grad()
loss.backward()
optimizer.step()
top1 = accuracy(output, label)[0]
train_accuracy.update_with_weight(top1, label.shape[0])
model.eval()
for data_in, label in test_dataloader:
output = model(data_in)
loss = loss_fn(output, label)
test_loss.update_with_weight(loss.item(), label.shape[0])
top1 = accuracy(output, label)[0]
test_accuracy.update_with_weight(top1, label.shape[0])
logger.info(" | ".join([
f'Epoch[{epoch}/{training_epochs}]',
f'Train Loss:{train_loss.avg: .3f}',
f'Train Accuracy:{train_accuracy.avg: .3f}%',
def train(train_img, given_dataset_labels, noise_ratio, class_no = 0, random_seed=1, dataset='cifar10', batch_size=128, epochs=45,\
test_data='cifar10_data/test_images.npy', test_lb='cifar10_data/test_labels.npy'):
if dataset == 'cifar10':
#synthesize alpha-increments or baseline
noisy_lb = manipulate_labels(given_dataset_labels, dataset,
noise_ratio, class_no, random_seed)
make_determine()
train_data = cifar10_train(train_img, noisy_lb,
no_rc_transform_train(dataset),
transform_target)
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
num_workers=2,
drop_last=False)
data_length = len(train_data)
make_determine()
test_data = cifar10_test(test_data, test_lb, transform_test(dataset),
transform_target)
test_loader = torch.utils.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=False,
num_workers=2,
drop_last=False)
make_determine()
model = cifar_10_CNN()
model.fc_layer_2.train(False)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if (torch.cuda.device_count() > 1):
model = nn.DataParallel(model)
optimizer = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
weight_decay=1e-4)
start_epoch = 0
criterion = nn.CrossEntropyLoss()
model = model.to(device)
N = 1280
no_LID_sequences = 50
LID_file = dataset + '_size_' + str(data_length) + '_indices.csv'
if not os.path.isfile(LID_file):
with open(LID_file, 'a', newline='') as csvFile:
writer = csv.writer(csvFile)
for i in range(no_LID_sequences):
random.seed(i)
idx = random.sample(range(data_length), N)
writer.writerow(np.array(idx))
csvFile.close()
N_indices = pd.read_csv(LID_file, header=None, index_col=None)
if dataset == 'cifar10':
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[40, 80],
gamma=0.1)
data_points = {}
for row in range(len(N_indices.index)):
data_points[row] = np.array(N_indices.iloc[row]).astype(int)
if noise_ratio[class_no] < 100:
record_file = './record/' + str(dataset) + '_' + str(
noise_ratio[class_no]) + '_seed_' + str(
random_seed) + '_record.csv' #for initialization
else:
record_file = './record/' + str(dataset) + '_bl_seed_' + str(
random_seed) + '_record.csv'
header = [
'epoch', 'train loss', 'train acc', 'train time', 'test loss',
'test acc', 'test time'
]
with open(record_file, 'a', newline='') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(header)
csvFile.close()
for epoch in range(start_epoch, epochs):
#print('--------epoch: {}/{}--------'.format(epoch, epochs))
#training
record = [
int(epoch),
]
train_acc = 0.0
train_loss = 0.0
train_data_len = 0
model.train()
tr_start_time = time.time()
for i, (X_train, y_train) in enumerate(train_loader):
X_train = X_train.to(device)
y_train = y_train.to(device)
train_data_len += y_train.size(0)
predictions, _ = model(X_train)
loss = criterion(predictions, y_train)
acc = accuracy(predictions, y_train)
train_acc += acc
train_loss += loss.item()
loss.backward()
optimizer.step()
optimizer.zero_grad()
record.extend([
train_loss / float(train_data_len),
train_acc / float(train_data_len),
time.time() - tr_start_time
])
#test
if epoch % 20 == 0 or epoch == (epochs - 1):
test_acc = 0.0
test_loss = 0.0
test_data_len = 0
test_start_time = time.time()
with torch.no_grad():
model.eval()
for i, (X_test, y_test) in enumerate(test_loader):
X_test = X_test.to(device)
y_test = y_test.to(device)
test_data_len += y_test.size(0)
predictions, _ = model(X_test)
loss = criterion(predictions, y_test)
acc = accuracy(predictions, y_test)
test_acc += acc
test_loss += loss.item()
record.extend([
test_loss / float(test_data_len),
test_acc / float(test_data_len),
time.time() - test_start_time
])
with open(record_file, 'a', newline='') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(np.array(record))
csvFile.close()
scheduler.step()
#at the end of each epoch, compute lid scores
lid_sequences = []
LID_path = os.path.join('./log', str(random_seed))
if not os.path.exists(LID_path):
os.makedirs(LID_path)
final_file_name = LID_path + '/lid_%s_%s_%s.csv' % \
(dataset, random_seed, noise_ratio[0])
for key in data_points:
lids = []
if dataset == 'cifar10':
lid_data = cifar10_LID(train_img, data_points[key],
transform_test(dataset))
lid_loader = torch.utils.data.DataLoader(lid_data,
batch_size=len(
data_points[key]),
shuffle=True,
num_workers=2,
drop_last=False)
model.train()
for i, X_train in enumerate(lid_loader):
X_train = X_train.to(device)
with torch.no_grad():
_, X_act = model(X_train)
X_act = np.asarray(X_act.cpu().detach(),
dtype=np.float32).reshape(
(X_act.shape[0], -1))
s = int(X_train.shape[0] / batch_size)
for ss in range(s):
lid_batch = np.zeros(shape=(batch_size, 1))
lid_batch[:, 0] = mle_batch(
X_act[ss * batch_size:(ss + 1) * batch_size],
X_act[ss * batch_size:(ss + 1) * batch_size])
lids.extend(lid_batch)
lids = np.asarray(lids, dtype=np.float32)
lid_sequences.append(np.mean(lids))
with open(final_file_name, 'a', newline='') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(np.array(lid_sequences))
csvFile.close()
coord.request_stop()
coord.join(threads)
if __name__ == '__main__':
with tf.Graph().as_default():
with tf.device('/cpu:0'):
train_batch, train_label_batch = cifar10_input.read_cifar10(
data_path=data_path,
is_train=True,
batch_size=batch_size,
shuffle=True)
val_batch, val_label_batch = cifar10_input.read_cifar10(
data_path=data_path,
is_train=False,
batch_size=batch_size,
shuffle=False)
xs = tf.placeholder(tf.float32, shape=[batch_size, img_h, img_w, 3])
ys = tf.placeholder(tf.int32, shape=[batch_size, num_classes])
keep_prob = tf.placeholder(tf.float32)
model = VGG16(xs, num_classes, keep_prob)
logits = model.logits
loss = tools.losses(logits, ys)
acc = tools.accuracy(logits, ys)
train_op = tools.optimizer(loss, learning_rate)
train_running()
confusion_matrix.add(output_conf, target_conf)
loss1 = criterion1(output, lbl_batch.long())
loss2 = criterion2(rec, img_batch.float())
loss = tools.to_cuda(0.9 * loss1 + 0.1 * loss2)
loss.backward()
train_losses.append(loss.item())
optimizer.step()
if iter_ % 100 == 0:
pred = np.argmax(output.data.cpu().numpy()[0], axis=0)
gt = lbl_batch.data.cpu().numpy()[0]
print(
'Train (epoch {}/{}) [{}/{} ({:.0f}%)]\tLoss_SEGM: {:.6f}\tLoss_REC: {:.6f}\tAccuracy: {}'
.format(epoch, epochs, i, len(mydataset),
100. * i / len(mydataset), loss1.item(), loss2.item(),
tools.accuracy(pred, gt)))
train_acc = tools.accuracy(pred, gt)
iter_ += 1
del (img_batch, lbl_batch, loss)
train_acc = (np.trace(confusion_matrix.conf) /
float(np.ndarray.sum(confusion_matrix.conf))) * 100
print('TRAIN_LOSS: ', '%.3f' % np.mean(train_losses), 'TRAIN_ACC: ',
'%.3f' % train_acc)
confusion_matrix.reset()
with torch.no_grad():
model.eval()
mydataset_val = DataLoader(val_dataset, batch_size=14, shuffle=True)
val_losses = []
def train():
print('loding data............')
#导入数据
with tf.name_scope('input'):
train, train_label, test, test_label = Process.get_data(
train_path, test_path)
train_batch, train_label_batch = Process.get_batch(
train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
test_batch, test_label_batch = Process.get_batch(
test, test_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
print('loding batch_data complete.......')
#创建placeholder作为输入和标签
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASS])
#定义模型
logits = vgg.VGG16N(x, N_CLASS, IS_PRETRAIN)
#定义损失
loss = tools.loss(logits, y_)
#计算准确率
accuracy = tools.accuracy(logits, y_)
#全局步骤
my_global_step = tf.Variable(0, name='global_step', trainable=False)
#梯度下降
train_op = tools.optimize(loss, learning_rate, my_global_step)
#保存训练步骤
saver = tf.train.Saver(tf.global_variables())
#summary_op = tf.summary.merge_all()
#全局变量初始操作
init = tf.global_variables_initializer()
#创建sess
sess = tf.Session()
#全局变量操作
sess.run(init)
#启动coord
coord = tf.train.Coordinator()
#启动队列
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
#一些tensorboard的可视化操作，由于会出现问题，我先注释掉了
# tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
# val_summary_writer = tf.summary.FileWriter(test_log_dir, sess.graph)
print('all init has been done! start training')
try:
for step in np.arange(MAX_STEP):
print('step + ' + str(step) + 'is now')
if coord.should_stop():
break
#从队列中取batch
tra_images, tra_labels = sess.run([train_batch, train_label_batch])
#计算损失和准确率
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={
x: tra_images,
y_: tra_labels
})
#如果到达10步的倍数，打印在现在的batch_size上的训练准确率
if step % 10 == 0 or (step + 1) == MAX_STEP:
print('Step: %d, loss: %.4f, accuracy: %.4f%%' %
(step, tra_loss, tra_acc))
# summary_str = sess.run(summary_op)
# tra_summary_writer.add_summary(summary_str, step)
#如果步骤达到200的倍数，输入一些训练数据查看在训练集上的准确率
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run(
[test_batch, test_label_batch])
val_loss, val_acc = sess.run([loss, accuracy],
feed_dict={
x: val_images,
y_: val_labels
})
print(
'** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %
(step, val_loss, val_acc))
# summary_str = sess.run(summary_op)
# val_summary_writer.add_summary(summary_str, step)
#如果步骤达到了2000步,保存当前点的数据
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
def train():
pre_trained_weights = './vgg16_pretrain/vgg16.npy'
train_data_dir = './data/train/scene_train_images_20170904/'
train_label_json = './data/train/scene_train_annotations_20170904.json'
val_data_dir = './data/val/scene_validation_images_20170908/'
val_label_json = './data/val/scene_validation_annotations_20170908.json'
train_log_dir = './logs/train/'
val_log_dir = './logs/val/'
with tf.name_scope('input'):
tra_images, tra_labels = input_data.get_files(train_label_json,
train_data_dir)
tra_image_batch, tra_label_batch = input_data.get_batch(
tra_images, tra_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY,
N_CLASSES)
val_images, val_labels = input_data.get_files(val_label_json,
val_data_dir)
val_image_batch, val_label_batch = input_data.get_batch(
val_images, val_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY,
N_CLASSES)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES])
keep_prob = tf.placeholder(tf.float32)
# %%
logits = VGG.VGG16N(x, N_CLASSES, keep_prob, IS_PRETRAIN)
# #%%
# import ResNet
# resnet = ResNet.ResNet()
# _, logits = resnet.build(x, N_CLASSES, last_layer_type="softmax")
# #%%
# import InceptionV4
# inception = InceptionV4.InceptionModel(x, [BATCH_SIZE, IMG_W, IMG_H, 3], [BATCH_SIZE, N_CLASSES], keep_prob,
# ckpt_path='train_model/model', model_path='saved_model/model')
# logits = inception.define_model()
# print('shape{}'.format(logits.shape))
loss = tools.loss(logits, y_)
accuracy = tools.accuracy(logits, y_)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = tools.optimize(loss, learning_rate, my_global_step)
saver = tf.train.Saver(tf.global_variables())
# summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# load the parameter file, assign the parameters, skip the specific layers
# tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
# tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
# val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
train_images, train_labels = sess.run(
[tra_image_batch, tra_label_batch])
# print(str(train_images.get_shape()))
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={
x: train_images,
y_: train_labels,
keep_prob: 0.2
})
if step % 50 == 0 or (step + 1) == MAX_STEP:
# _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
# feed_dict={x: train_images, y_: train_labels})
print('Step: %d, loss: %.3f, accuracy: %.3f%%' %
(step, tra_loss, tra_acc))
# summary_str = sess.run(summary_op)
# tra_summary_writer.add_summary(summary_str, step)
if step % 200 == 0 or (step + 1) == MAX_STEP:
validation_images, validation_labels = sess.run(
[val_image_batch, val_label_batch])
val_loss, val_acc = sess.run([loss, accuracy],
feed_dict={
x: validation_images,
y_: validation_labels,
keep_prob: 1
})
print(
'** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %
(step, val_loss, val_acc))
# summary_str = sess.run(summary_op)
# val_summary_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
def mytrain():
# pre_trained_weights = './VGG16_pretrain/vgg16.npy'
data_dir = '/content/data/'
train_log_dir = './logs2/train/'
val_log_dir = './logs2/val/'
with tf.name_scope('input'):
train_image_batch, train_label_batch = input_data.read_cifar10(
data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True)
val_image_batch, val_label_batch = input_data.read_cifar10(
data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False)
logits = VGG.Myvgg(train_image_batch, N_CLASSES, IS_PRETRAIN)
loss = tools.loss(logits, train_label_batch)
accuracy = tools.accuracy(logits, train_label_batch)
my_global_step = tf.Variable(0, trainable=False, name='global_step')
train_op = tools.optimize(loss, learning_rate, my_global_step)
x = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3])
y_ = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE, N_CLASSES])
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# load pretrain weights
# tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
train_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
train_images, train_labels = sess.run(
[train_image_batch, train_label_batch])
#print(train_images.shape,train_labels)
_, train_loss, train_accuracy = sess.run(
[train_op, loss, accuracy],
feed_dict={
x: train_images,
y_: train_labels
})
if step % 128 == 0 or (step + 1) == MAX_STEP:
print("Step: %d, loss: %.8f, accuracy: %.4f%%" %
(step, train_loss, train_accuracy))
summary_str = sess.run(summary_op)
train_summary_writer.add_summary(summary_str, step)
if step % 128 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run(
[val_image_batch, val_label_batch])
val_loss, val_accuracy = sess.run([loss, accuracy],
feed_dict={
x: val_images,
y_: val_labels
})
print("** Step: %d, loss: %.8f, test_accuracy: %.4f%%" %
(step, val_loss, val_accuracy))
summary_str = sess.run(summary_op)
val_summary_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, save_path=checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limited reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
def test(test_dir, checkpoint_dir='./checkpoint/'):
import json
# predict the result
test_images = os.listdir(test_dir)
features = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
labels = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES])
# one_hot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=80)
# train_step, cross_entropy, logits, keep_prob = network.inference(features, one_hot_labels)
resnet = ResNet.ResNet()
_, logits = resnet.build(features, N_CLASSES, last_layer_type="softmax")
loss = tools.loss(logits, labels)
accuracy = tools.accuracy(logits, labels)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = tools.optimize(loss, learning_rate, my_global_step)
values, indices = tf.nn.top_k(logits, 3)
keep_prob = tf.placeholder(tf.float32)
with tf.Session() as sess:
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
print('Restore the model from checkpoint %s' %
ckpt.model_checkpoint_path)
# Restores from checkpoint
saver.restore(sess, ckpt.model_checkpoint_path)
start_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
else:
raise Exception('no checkpoint find')
result = []
test_imglist = []
for test_image in test_images:
test_imgpath = os.path.join(test_dir, test_image)
test_imglist.append(test_imgpath)
image = tf.cast(test_imglist, tf.string)
# make a input queue
input_queue = tf.train.slice_input_producer([image])
image_contents = tf.read_file(input_queue[0])
image = tf.image.decode_jpeg(image_contents, channels=3)
#################################################
# data agumentation should go to here
#################################################
image = tf.image.resize_image_with_crop_or_pad(image, IMG_W, IMG_H)
image = tf.image.per_image_standardization(image)
# image_batch, label_batch = tf.train.batch([image, label],
# batch_size=batch_size,
# num_threads=64,
# capacity=capacipy)
image_batch = tf.train.shuffle_batch([image],
batch_size=1,
num_threads=64,
capacity=CAPACITY,
min_after_dequeue=200)
image_batch = tf.cast(image_batch, tf.float32)
img = sess.run([image_batch])
for i in range(len(img)):
x = img[i]
temp_dict = {}
# x = scene_input.img_resize(os.path.join(test_dir, test_image), IMG_W)
predictions = np.squeeze(sess.run(indices,
feed_dict={
features:
np.expand_dims(x, axis=0),
keep_prob:
1
}),
axis=0)
temp_dict['image_id'] = test_image
temp_dict['label_id'] = predictions.tolist()
result.append(temp_dict)
print('image %s is %d,%d,%d' %
(test_image, predictions[0], predictions[1], predictions[2]))
with open('submit.json', 'w') as f:
json.dump(result, f)
print('write result json, num is %d' % len(result))
def train():
data_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/JPG/trainval/'
train_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/train/'
val_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/val/'
with tf.name_scope('input'):
train, train_label, val, val_label = input_trainval.get_files(data_dir, 0.2)
train_batch, train_label_batch = input_trainval.get_batch(train, train_label,
IMG_H, IMG_W,
BATCH_SIZE,
CAPACITY)
val_batch, val_label_batch = input_trainval.get_batch(val, val_label,
IMG_W, IMG_H,
BATCH_SIZE,
CAPACITY)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3])
y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
logits = model_structure.AlexNet(x, 5)
loss = tools.loss('loss', y_, logits)
accuracy = tools.accuracy('accuracy', y_, logits)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = tools.optimize('optimize', loss, LEARNING_RATE, my_global_step) #??
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tra_summary_writer = tf.summary.FileWriter(train_log_dir,sess.graph)
val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images, tra_labels = sess.run([train_batch, train_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],feed_dict={x:tra_images, y_:tra_labels})
if step % 10 == 0 or (step + 1) == MAX_STEP:
print('Step: %d, loss: %.4f, accuracy: %.4f' %(step, tra_loss, tra_acc))
#summary_str = sess.run(summary_op)
#tra_summary_writer.add_summary(summary_str, step)
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
if step % 20 == 0 or (step + 1) == MAX_STEP:
valid_images, valid_labels = sess.run([val_batch, val_label_batch])
valid_loss, valid_acc = sess.run([loss, accuracy],
feed_dict={x:valid_images, y_:valid_labels})
print( '** step: %d, loss: %.4f, accuracy: %.4f' %(step, valid_loss, valid_acc))
#summary_str = sess.run(summary_op)
#val_summary_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.error.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def train():
# pre_trained_weights1 = './/vgg16.npy'
pre_trained_weights = './/vgg-face.mat'
data_dir = '/home/hadoop/Desktop/My-TensorFlow-tutorials-master/VGG face segmentation recognition/data/segmentation/training/'
train_log_dir = './/logss/train_shuffle/'
val_log_dir = './/logss/va_shuffle/'
# image_batch, label_batch = notMNIST_input.read_and_decode(tfrecords_file,BATCH_SIZE)
image, label = notMNIST_input.get_file(data_dir)
# image_batch,label_batch=notMNIST_input.get_batch(image, label, IMG_W, IMG_H, BATCH_SIZE, capacity)
X = np.array(image)
Y = np.array(label)
kf = KFold(n_splits=10, shuffle=False)
total_acc = 0
for train, test in kf.split(X, Y):
tf.reset_default_graph()
image_batch, label_batch = notMNIST_input.get_batch(X[train],
Y[train],
IMG_W,
IMG_H,
BATCH_SIZE,
capacity,
shuffle=True)
image_batch_validate, label_batch_validate = notMNIST_input.get_batch(
X[test],
Y[test],
IMG_W,
IMG_H,
BATCH_SIZE,
capacity,
shuffle=False)
# print("dddd")
## print("train_index: , test_index:", (X[train],Y[train],X[test],Y[test]))
print("X[train]/n", len(X[train]))
print("Y[train]/n", len(Y[train]))
print("X[test]", len(X[test]))
print("Y[test]", len(Y[test]))
#cast (1.8,3.4)float32 to (1,3)int64
x = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, IMG_W, IMG_H, 3],
name='place_x')
y_ = tf.placeholder(tf.int64, shape=[
BATCH_SIZE,
], name='place_y')
logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN)
print("****logits shape is ", logits.shape)
loss = tools.loss(logits, y_)
print("label_batch is ", y_.shape)
accuracy = tools.accuracy(logits, y_)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
#learning_rate = tf.train.exponential_decay(starter_learning_rate, my_global_step,
# 2200, 0.96, staircase=True)
train_op = tools.optimize(loss, starter_learning_rate, my_global_step)
# train_op_vali = tools.optimize(loss_vali, learning_rate, my_global_step)
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# load the parameter file, assign the parameters, skip the specific layers
tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8'])
merged_summaries = tf.summary.merge_all()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
val_summary_writer = tf.summary.FileWriter(val_log_dir)
max_acc = 0
total_time = 0
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
start_time = time.time()
# with tf.Session() as sess:
# for train, test in kf.split(X,Y):
# image_batch,label_batch=notMNIST_input.get_batch(X[train], Y[train], IMG_W, IMG_H, BATCH_SIZE, capacity)
# image_batch_validate, label_batch_validate=notMNIST_input.get_batch(X[test], Y[test], IMG_W, IMG_H, BATCH_SIZE, capacity)
# label_batch = tf.cast(label_batch,dtype=tf.int64)
x_train_a, y_train_a = sess.run([image_batch, label_batch])
x_test_a, y_test_a = sess.run(
[image_batch_validate, label_batch_validate])
# _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy])
# tra_images,tra_labels = sess.run([image_batch, label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={
x: x_train_a,
y_: y_train_a
})
if step % 10 == 0 or (step + 1) == MAX_STEP:
feed_dict = {x: x_train_a, y_: y_train_a}
summary_str = sess.run(summary_op, feed_dict=feed_dict)
tra_summary_writer.add_summary(summary_str, step)
time_elapsed = time.time() - start_time
print(
'Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)'
% (step, tra_loss, tra_acc * 100, time_elapsed))
total_time = total_time + time_elapsed
if step % 50 == 0:
print('total time is :%.2f' % (total_time))
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_loss, val_acc = sess.run([loss, accuracy],
feed_dict={
x: x_test_a,
y_: y_test_a
})
feed_dict = {x: x_test_a, y_: y_test_a}
summary_str = sess.run(summary_op, feed_dict=feed_dict)
val_summary_writer.add_summary(summary_str, step)
# if cur_val_loss > max_acc:
# max_acc = cur_val_loss
# best_step = step
# checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
# saver.save(sess, checkpoint_path, global_step=step)
# val_summary_writer.add_summary(summary, step)
# print("Model updated and saved in file: %s" % checkpoint_path)
# print ('*************step %5d: loss %.5f, acc %.5f --- loss val %0.5f, acc val %.5f************'%(best_step,tra_loss, tra_acc, cur_val_loss, cur_val_eval))
#
print(
'************validate result:Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)'
% (step, val_loss, val_acc * 100, time_elapsed))
if val_acc > max_acc:
max_acc = val_acc
checkpoint_path = os.path.join(train_log_dir,
'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
if max_acc > total_acc:
total_acc = max_acc
checkpoint_path = os.path.join(val_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
def train():
pre_trained_weights = './/vgg16_pretrain//vgg16.npy'
data_dir = './/data//cifar-10-batches-bin//'
train_log_dir = './/logs//train//'
val_log_dir = './/logs//val//'
with tf.name_scope('input'):
tra_image_batch, tra_label_batch = input_data.read_cifar10(data_dir=data_dir,
is_train=True,
batch_size= BATCH_SIZE,
shuffle=True)
val_image_batch, val_label_batch = input_data.read_cifar10(data_dir=data_dir,
is_train=False,
batch_size= BATCH_SIZE,
shuffle=False)
logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN)
loss = tools.loss(logits, tra_label_batch)
accuracy = tools.accuracy(logits, tra_label_batch)
my_global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = tools.optimize(loss, learning_rate, my_global_step)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES])
saver = tf.train.Saver(tf.global_variables())
summary_op = tf.summary.merge_all()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# load the parameter file, assign the parameters, skip the specific layers
tools.load_with_skip(pre_trained_weights, sess, ['fc6','fc7','fc8'])
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph)
val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images,tra_labels = sess.run([tra_image_batch, tra_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],
feed_dict={x:tra_images, y_:tra_labels})
if step % 50 == 0 or (step + 1) == MAX_STEP:
print ('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc))
summary_str = sess.run(summary_op)
tra_summary_writer.add_summary(summary_str, step)
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run([val_image_batch, val_label_batch])
val_loss, val_acc = sess.run([loss, accuracy],
feed_dict={x:val_images,y_:val_labels})
print('** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %(step, val_loss, val_acc))
summary_str = sess.run(summary_op)
val_summary_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(train_log_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
sess.close()
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))
# Optimizer.
optimizer = tf.train.GradientDescentOptimizer(0.05).minimize(loss)
# Predictions for the training, validation, and test data.
train_prediction = tf.nn.softmax(logits)
valid_prediction = tf.nn.softmax(model(tf_valid_dataset))
test_prediction = tf.nn.softmax(model(tf_test_dataset))
num_steps = 5001
t0 = time()
with tf.Session(graph=graph) as session:
tf.initialize_all_variables().run()
saver = tf.train.Saver()
print('Initialized')
for step in range(num_steps):
offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
batch_data = train_dataset[offset:(offset + batch_size), :, :, :]
batch_labels = train_labels[offset:(offset + batch_size), :]
feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}
_, l, predictions = session.run([optimizer, loss, train_prediction], feed_dict=feed_dict)
if (step % 50 == 0):
print('Minibatch loss at step %d: %f' % (step, l))
print('Minibatch accuracy: %.1f%%' % tools.accuracy(predictions, batch_labels))
print('Validation accuracy: %.1f%%' % tools.accuracy(valid_prediction.eval(), valid_labels))
print('Test accuracy: %.1f%%' % tools.accuracy(test_prediction.eval(), test_labels))
saver.save(session, 'test-06', global_step=step)
t1 = time()
print('Time: ', (t1 - t0))
