def test():
input_data = tf.placeholder(tf.int32, [batchSize, maxSeqLength])
labels = tf.placeholder(tf.int32, [batchSize])
data = tf.nn.embedding_lookup(wordVectors, input_data)
data = tf.reshape(data, [batchSize, maxSeqLength, numDimensions, 1])
train_logits = CNN_model.inference1(data, batchSize, N_CLASSES)
train_loss = CNN_model.losses(train_logits, labels)
train_acc = CNN_model.evaluation(train_logits, labels)
all_accuracy = 0
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
saver.restore(sess, './models/pretrained_CNN.ckpt-20000')
for i in range(2000):
train_batch, train_label_batch = input_text_data.get_allTest(i)
tra_loss, tra_acc = sess.run([train_loss, train_acc], {
input_data: train_batch,
labels: train_label_batch
})
all_accuracy = all_accuracy + tra_acc
print('All_accuracy:')
print(all_accuracy / 2000)
def training():
input_data = tf.placeholder(tf.int32, [batchSize, maxSeqLength])
labels = tf.placeholder(tf.int32, [batchSize])
data = tf.nn.embedding_lookup(wordVectors, input_data)
data = tf.reshape(data, [batchSize, maxSeqLength, numDimensions, 1])
train_logits = CNN_model.inference1(data, batchSize, N_CLASSES)
train_loss = CNN_model.losses(train_logits, labels)
train_op = CNN_model.trainning(train_loss, learning_rate)
train_acc = CNN_model.evaluation(train_logits, labels)
sess = tf.InteractiveSession()
tf.summary.scalar('Loss', train_loss)
tf.summary.scalar('Accuracy', train_acc)
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1)
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)
with tf.Session(config=config) as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
for i in range(MAX_STEP):
train_batch, train_label_batch = input_text_data.getTrainBatch()
_, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc],
{
input_data: train_batch,
labels: train_label_batch
})
# 汇总到Tensorboard
if i % 1000 == 0:
print("Step %d, train loss = %.2f, train accuracy = %.2f%%" %
(i, tra_loss, tra_acc))
test_batch, test_label_batch = input_text_data.getTestBatch()
summary = sess.run(merged, {
input_data: test_batch,
labels: test_label_batch
})
writer.add_summary(summary, i)
test_loss, test_acc = sess.run([train_loss, train_acc], {
input_data: test_batch,
labels: test_label_batch
})
print(
"*************, test loss = %.2f, test accuracy = %.2f%%" %
(test_loss, test_acc))
if i % 2000 == 0 or (i + 1) == MAX_STEP:
save_path = saver.save(sess,
"./models/pretrained_CNN.ckpt",
global_step=i)
print("saved to %s" % save_path)
writer.close()
def run_training():
#目录
train_dir="./image/"
logs_train_dir ="./log"
train,train_label=image_P.get_files(train_dir)
train_batch,train_label_batch=image_P.get_batch(train,
train_label,
IMG_W,
IMG_H,
BATCH_SIZE,
CAPACITY)
train_logits=model.inference(train_batch,BATCH_SIZE,N_CLASSES)
train_loss=model.losses(train_logits,train_label_batch)
train_op=model.trainning(train_loss,learning_rate)
train_acc=model.evaluation(train_logits,train_label_batch)
summary_op=tf.summary.merge_all()
sess=tf.Session()
train_writer=tf.summary.FileWriter(logs_train_dir,sess.graph)
#保存模型
saver=tf.train.Saver()
#初始化
sess.run(tf.global_variables_initializer())
#使用多线程
coord=tf.train.Coordinator()
threads=tf.train.start_queue_runners(sess=sess,coord=coord)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break#线程停止
_,temp_loss,temp_acc=sess.run([train_op,train_loss,train_acc])
#每迭代50次打印一次结果
if step%50 == 0:
print('Step %d,train loss = %.2f,train accuracy = %.2f'%(step,temp_loss,temp_acc))
summary_str=sess.run(summary_op)
train_writer.add_summary(summary_str,step)
#每迭代200次或到达最后一次保存一次模型
if step%200 == 0 or (step+1) == MAX_STEP:
checkpoint_path=os.path.join(logs_train_dir,'model.ckpt')
saver.save(sess,checkpoint_path,global_step=step)
except tf.errors.OutOfRangeError:
print('Failed!')
finally:
coord.request_stop()
#结束线程
coord.join(threads)
sess.close()
def CreateModel(model_name, bit, use_gpu):
if model_name == 'vgg11':
vgg11 = models.vgg11(pretrained=True)
cnn_model = CNN_model.cnn_model(vgg11, model_name, bit)
if model_name == 'alexnet':
alexnet = models.alexnet(pretrained=True)
cnn_model = CNN_model.cnn_model(alexnet, model_name, bit)
if use_gpu:
cnn_model = cnn_model.cuda()
return cnn_model
def train(): with (tf.Graph().as_default()): global_step = tf.contrib.framework.get_or_create_global_step() images, display_images, labels = CNN_input.construct_inputs(False, True) logits = CNN_model.inference(True, images) loss = CNN_model.loss(logits, labels) train_op = CNN_model.train(loss, global_step) # Logs loss and runtime class _LoggerHook(tf.train.SessionRunHook): def begin(self): self._step = -1 self._estimated_time_array = [] for i in range(EST_TIME_SMOOTHING): self._estimated_time_array.append(0) def before_run(self, run_context): self._step += 1 self._start_time = time.time() return tf.train.SessionRunArgs(loss) def get_estimated_completion(self): total = 0 for i in range(EST_TIME_SMOOTHING): total += self._estimated_time_array[i] return (total / EST_TIME_SMOOTHING) def after_run(self, run_context, run_values): duration = time.time() - self._start_time loss_value = run_values.results self._estimated_time_array[self._step % EST_TIME_SMOOTHING] = float(duration * (FLAGS.max_steps - self._step)) / (60.0 * 60.0) if (self._step % LOGGING_STEP_INTERVAL == 0): log_value = '%s: step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch; %.2f est. hours to completion)' \ % (datetime.now(), self._step, loss_value, FLAGS.batch_size / duration, float(duration), self.get_estimated_completion()) print(log_value) return (log_value) with tf.train.MonitoredTrainingSession( checkpoint_dir=FLAGS.train_dir, hooks=[tf.train.StopAtStepHook(last_step=FLAGS.max_steps), tf.train.NanTensorHook(loss), _LoggerHook()], config=tf.ConfigProto( log_device_placement=FLAGS.log_device_placement)) as mon_sess: while (not mon_sess.should_stop()): mon_sess.run(train_op)
def get_cnn_model(model_name, bits):
if model_name == 'vgg11':
vgg11 = models.vgg11(pretrained=True)
cnn_model = CNN_model.cnn_model(vgg11, model_name, bits)
if model_name == 'alexnet':
alexnet = models.alexnet(pretrained=True)
cnn_model = CNN_model.cnn_model(alexnet, model_name, bits)
if model_name == 'resnet':
cnn_model = CNN_model.getResnetModel(bits)
if torch.cuda.is_available():
cnn_model = cnn_model.cuda()
return cnn_model
def run_training():
# log dir
logs_train_dir = logs_dir
# read data
test, train, validate, test_label, train_label, validate_label = rd.read_file(
)
# get batch
train_batch, train_label_batch = rd.get_batch(train, train_label, IMG_W,
IMG_H, BATCH_SIZE, CAPACITY)
train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
train_loss = model.losses(train_logits, train_label_batch)
train_op = model.trainning(train_loss, learning_rate)
train__acc = model.evaluation(train_logits, train_label_batch)
summary_op = tf.summary.merge_all()
sess = tf.Session()
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
_, tra_loss, tra_acc = sess.run([train_op, train_loss, train__acc])
if step % 50 == 0:
print('Step %d, train loss = %.2f, train accuracy = %.2f%%' %
(step, tra_loss, tra_acc * 100.0))
summary_str = sess.run(summary_op)
train_writer.add_summary(summary_str, step)
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(logs_train_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 evaluate_all_image():
'''
Test all image against the saved models and parameters.
Return global accuracy of test_image_set
##############################################
##Notice that test image must has label to compare the prediction and real
##############################################
'''
# you need to change the directories to yours.
# test_dir = '/home/kevin/tensorflow/cats_vs_dogs/data/test/'
# N_CLASSES = 2
print('-------------------------')
test, train, validate, test_label, train_label, validate_label = rd.read_file(
)
BATCH_SIZE = len(test)
print('There are %d test images totally..' % BATCH_SIZE)
print('-------------------------')
test_batch, test_label_batch = rd.get_batch(test, test_label, IMG_W, IMG_H,
BATCH_SIZE, CAPACITY)
logits = model.inference(test_batch, BATCH_SIZE, N_CLASSES)
testloss = model.losses(logits, test_label_batch)
testacc = model.evaluation(logits, test_label_batch)
logs_train_dir = logs_dir
saver = tf.train.Saver()
with tf.Session() as sess:
print("Reading checkpoints...")
ckpt = tf.train.get_checkpoint_state(logs_train_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')
print('-------------------------')
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
test_loss, test_acc = sess.run([testloss, testacc])
print('The model\'s loss is %.2f' % test_loss)
correct = int(BATCH_SIZE * test_acc)
print('Correct : %d' % correct)
print('Wrong : %d' % (BATCH_SIZE - correct))
print('The accuracy in test images are %.2f%%' % (test_acc * 100.0))
coord.request_stop()
coord.join(threads)
sess.close()
def find_model(args):
if args["model"] == "cnn":
model = CNN_model.CNN_Sentence(args)
elif args["model"] == "gru":
model = GRU_model.GRU_Sentence(args)
elif args["model"] == "gru_attention":
model = GRU_att_model.AttentionWordRNN(args)
elif args["model"] == "gru_domain":
model = GRU_domain_att_model.GRU_Attention_Sentence(args)
elif args["model"] == "gru_random":
model = GRU_ramdom_att_model.GRU_random_att_Sentence(args)
elif args["model"] == "cnn_attention":
model = CNN_Attention_model.CNN_Attention_Sentence(args)
elif args["model"] == "cnn_att_pool":
model = CNN_Att_Pool_model.CNN_Att_Pool_Sentence(args)
elif args["model"] == "dam":
model = DAM_model.DAM_Sentence(args)
elif args["model"] == "gs":
model = GS_model.GS_Sentence(args)
else:
print("No such model!")
exit()
if torch.cuda.is_available():
os.environ["CUDA_VISIBLE_DEVICES"] = str(args["GPU"])
model = model.cuda(args["GPU"])
return model
def test():
images_dir='./image/image/'
log_dir='./log/'
images_cat=open("imagelist.txt")
#保存所有图像经过模型计算之后的数组
images_tested=[]
with tf.Graph().as_default():
#重载模型
x=tf.placeholder(tf.float32,shape=[1,300,400,3])
p=model.inference(x,1,10)
logits=tf.nn.softmax(p)
sess=tf.Session()
tf.get_variable_scope().reuse_variables()
ckpt=tf.train.get_checkpoint_state(log_dir)
saver=tf.train.Saver()
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!')
else:
print('Loading failed!')
for line in images_cat.readlines():
image_name=line.strip('\n')
image_array=get_one_image(images_dir+image_name)
image_array=np.reshape(image_array,[1,300,400,3])
prediction=sess.run(logits,feed_dict={x:image_array})
prediction=np.array(prediction,dtype='float32')
images_tested.append([image_name,prediction])
print(image_name)
print(prediction)
#测试单张图片
while (True):
test_file=input('输入测试图片:')
if(test_file=='z'):
break
image_name=test_file
image_array=get_one_image(images_dir+image_name)
image_array=np.reshape(image_array,[1,300,400,3])
prediction=sess.run(logits,feed_dict={x:image_array})
prediction=np.array(prediction,dtype='float32')
test_result=[]
for sample in images_tested:
distance=np.sqrt(np.sum(np.square(sample[1]-prediction)));
distance.astype('float32')
test_result.append([sample[0],distance])
#将结果排序
test_result=np.array(test_result)
test_result=test_result[np.lexsort(test_result.T)]
for i in range(10):
print(test_result[i][0])
images_show(test_result)
def CreateModel(model_name, bit, use_gpu):
if model_name == 'vgg11':
vgg11 = models.vgg16(pretrained=True)
cnn_model = CNN_model.cnn_model(vgg11, model_name, bit)
if model_name == 'alexnet':
alexnet = models.alexnet(pretrained=True)
cnn_model = CNN_model.cnn_model(alexnet, model_name, bit)
if model_name == 'resnet34':
resnet = models.resnet34(pretrained=True)
cnn_model = CNN_model.cnn_model(resnet, model_name, bit)
if model_name == 'resnet50':
resnet = models.resnet50(pretrained=True)
cnn_model = CNN_model.cnn_model(resnet, model_name, bit)
if model_name == 'resnet34resnet34':
resnet = models.resnet34(pretrained=True)
cnn_model = CNN_model.cnn_model(resnet, model_name, bit)
return cnn_model
def grab_image():
image_base64 = request.values['imageBase64']
image_data = base64.decodebytes(re.sub('^data:image/.+;base64,', '', image_base64).encode())
image = Image.open(io.BytesIO(image_data))
# resize to 28x28, remove transparency and convert to grayscale
#image = image.resize((28,28))
image = remove_transparency(image).convert('L')
image = np.asarray(image)
#mnist dataset contains white numbers with dark backgrounds, so an inversion is necessary
image = np.invert(image)
image = cv2.resize(image, dsize=(28, 28), interpolation=cv2.INTER_CUBIC)
image = image.reshape(28,28,1)
image = np.expand_dims(image, axis=0) #(1,28,28,1) to match model's input
image = image.astype('float32')
prediction = CNN_model.predict(image)
CNN_model.clear_session()
# im = Image.fromarray(image)
# im.save("image.png")
return str(prediction)
def CreateModel(model_name, bit, use_gpu):
if model_name == 'vgg16':
vgg16 = models.vgg16(pretrained=True)
#vgg16 = torch.load('/home/zhangjingyi/Rescode/vgg16_caffe2pytorch/vgg16_20M.pkl')
cnn_model = CNN_model.cnn_model(vgg16, model_name, bit)
print('**********************************')
print('Def of poo4~poo5:')
for i in [23, 24, 26, 28, 30]:
print(cnn_model.features[i])
print('**********************************')
if use_gpu:
cnn_model = torch.nn.DataParallel(cnn_model).cuda()
#cnn_model = cnn_model.cuda()
return cnn_model
def main(argv=None):
CNN_input.extract()
images, display_images, labels = CNN_input.construct_inputs(True, True)
logits = CNN_model.inference(False, images)
variable_averages = tf.train.ExponentialMovingAverage(
CNN_model.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
with tf.Session() as sess:
check_point = tf.train.get_checkpoint_state(FLAGS.train_dir)
if check_point and check_point.model_checkpoint_path:
saver.restore(
sess,
os.path.join(
FLAGS.train_dir,
list(
reversed(
check_point.model_checkpoint_path.split('\\',
-1)))[0]))
else:
raise IOError("No Checkpoint file found!")
coord = tf.train.Coordinator()
threads = []
try:
for queue_runner in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
threads.extend(
queue_runner.create_threads(sess,
coord=coord,
daemon=True,
start=True))
session_result = sess.run(
[tf.nn.softmax(logits), labels, display_images])
ResultsPlot(session_result[2], session_result[1],
session_result[0])
coord.request_stop()
coord.join(threads, stop_grace_period_secs=10)
except Exception as e:
print(e)
coord.request_stop()
def __init__(self):
'''
Initialize
'''
self.fname = None
self.imgs = None
self.model = CNN_model.CNN()
self.patch_size = (32, 32)
self.app = QtWidgets.QApplication(sys.argv)
self.MainWindow = QtWidgets.QMainWindow()
self.ui = mainwindow.Ui_MainWindow()
self.ui.setupUi(self.MainWindow)
self.MainWindow.setFixedSize(self.MainWindow.width(), self.MainWindow.height())
self.ui.image_label.setScaledContents(True)
self.ui.image_label.setMargin(5)
self.ui.path_button.clicked.connect(self.path_button_click)
self.ui.patch_button.clicked.connect(self.patch_button_click)
#self.ui.patch_button.clicked.connect(self.simple_patch_button_click)
self.ui.go_button.clicked.connect(self.go_button_click)
def load_test_pred(video_path,gt_path,model_path):
feature_size = 512 * 7 * 7
CNN_pre_model = torchvision.models.vgg16(pretrained=True).features
model = CNN_model.CNN_model(feature_size)
# GPU enable
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print('Device used:', device)
if torch.cuda.is_available():
CNN_pre_model = CNN_pre_model.to(device)
model = model.to(device)
load_checkpoint(model_path,model)
CNN_pre_model.eval()
# -> label loading
test_label = pd.read_csv(gt_path)["Action_labels"]
test_features = []
category_path = sorted(os.listdir(video_path))
with torch.no_grad():
for category in category_path:
mask = pd.read_csv(gt_path)["Video_category"] == category
test_name = pd.read_csv(gt_path)[mask]["Video_name"]
for i,video_name in enumerate(test_name):
print("\r%d/%d" %(i,len(test_name)),end="")
frames = readShortVideo(video_path,category, video_name,downsample_factor=12, rescale_factor=1)
frames = Variable(torch.from_numpy(frames)).to(device)
tmp = CNN_pre_model(frames).cpu().view(-1, feature_size)
test_features.append(torch.mean(tmp,0).numpy())
print("")
print("Processing [%s] finished!"%(category))
print("Pre-train finished!")
test_features = torch.Tensor(test_features)
model.eval()
feature = Variable(test_features).to(device)
output = model(feature)
pred = torch.argmax(output,1).cpu()
print(pred.shape)
return test_features,pred ,test_label
def transfer(input_image, CNN_path, output_image, batchsize=1):
input_image = cv2.resize(input_image, (256, 256))
input_image = np.array(input_image)
with tf.Session() as sess:
batch_shape = (batchsize, ) + input_image.shape
img_placeholder = tf.placeholder(tf.float32,
shape=batch_shape,
name='img_placeholder')
preds = CNN_model.net(img_placeholder)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(CNN_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise Exception('No such CNN_path')
input_image = input_image[np.newaxis, ...]
output = sess.run(preds, feed_dict={img_placeholder: input_image})
cv2.imwrite(output_image, output[0].astype(np.int))
def evaluate(run_once):
with tf.Graph().as_default() as graph:
images, display_images, labels = CNN_input.construct_inputs(
True, False)
logits = CNN_model.inference(False, images)
top_k_op = tf.nn.in_top_k(logits, labels, 3)
variable_averages = tf.train.ExponentialMovingAverage(
CNN_model.MOVING_AVERAGE_DECAY)
variables_to_restore = variable_averages.variables_to_restore()
saver = tf.train.Saver(variables_to_restore)
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(FLAGS.eval_dir, graph)
while True:
eval_once(saver, summary_writer, top_k_op, summary_op)
if run_once:
break
time.sleep(FLAGS.eval_interval_secs)
def transfer(input_image, CNN_path):
input_image = np.array(input_image) / 255.0
tf.reset_default_graph()
with tf.Session() as sess:
batch_shape = (1, ) + input_image.shape
img_placeholder = tf.placeholder(tf.float32,
shape=batch_shape,
name='img_placeholder')
preds = CNN_model.net(img_placeholder)
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(CNN_path)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
else:
raise Exception('No such CNN_path')
input_image_4d = input_image[np.newaxis, ...]
output = sess.run(preds, feed_dict={img_placeholder: input_image_4d})
out_img = np.clip(output[0], 0, 255).astype(np.int)
return out_img[0:input_image.shape[0], 0:input_image.shape[1], ...]
epoch_num = 90
batch_size = 16
max_length = 64
best_a_ccc = 0
best_v_ccc = 0
best_ccc = 0
best_epoch = 0
best_a_epoch = 0
best_v_epoch = 0
# parameter
hidden_size = 256
timesteps = 64
attention_size = 32
filters = 64
model = CN.model(timesteps, 512, hidden_size, filters, ac='sigmoid+tanh')
# model=R.model(timesteps,512,hidden_size)
# optimizer = Adam(lr=0.005, beta_1=0.5, beta_2=0.95, epsilon=1e-08)
optimizer = SGD(lr=0.005, momentum=0.5, nesterov=True, decay=0.001)
model.compile(loss='mae', optimizer=optimizer)
# # circle training
# model.load_weights('models/CNN_weights12.h5')
n_batch = int(len(X_train) / batch_size)
for epoch in range(epoch_num):
# training step
index = np.arange(len(X_train))
np.random.shuffle(index)
X_train = X_train[index]
y_train = y_train[index, :]
DataParams = collections.namedtuple('DataParams', [
'image_height', 'image_width', 'image_channel', 'char_length',
'num_char_class', 'batch_size'
])
data_params = DataParams(image_height=60,
image_width=160,
image_channel=1,
char_length=5,
num_char_class=10,
batch_size=50)
tf.reset_default_graph()
mymodel = CNN_model.ConvModel(data_params=data_params)
mymodel.build_model()
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter('./log/train', sess.graph)
for i in range(500):
imgs, lbs = giter.next_batch()
myfeed_dict = {mymodel.inputs: imgs, mymodel.labels: lbs}
_, loss, char_acc, str_acc, summary = sess.run([
mymodel.train_op, mymodel.loss, mymodel.char_acc, mymodel.str_acc,
from __future__ import print_function
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# 导入CNN模块
import CNN_model
model = CNN_model.CNNmodel()
xs = model.xs
keep_prob = model.keep_prob
# 加载保存的训练模型
import global_variable
saver = tf.train.Saver()
sess = tf.Session()
saver.restore(sess, global_variable.save_path)
# 测试精度
TestSize = 2
accuracyTotal = np.zeros((TestSize, 1), dtype=np.float32)
for j in range(TestSize):
batch_xs, batch_ys = mnist.test.next_batch(int(10000 / TestSize))
accuracyTotal[j] = sess.run(model.compute_accuracy(batch_ys),
feed_dict={
xs: batch_xs,
keep_prob: 1
})
def test(log_dir):
images_dir = './image/'
images_cat = open("imagelist.txt")
#保存所有图像经过模型计算之后的数组
images_tested = []
with tf.Graph().as_default():
#重载模型
x = tf.placeholder(tf.float32, shape=[1, 300, 400, 3])
p = model.inference(x, 1, 10)
logits = tf.nn.softmax(p)
sess = tf.Session()
tf.get_variable_scope().reuse_variables()
ckpt = tf.train.get_checkpoint_state(log_dir)
saver = tf.train.Saver()
num_photos = 0
outfile = open("test.txt", "w")
for line in images_cat.readlines():
image_name = line.strip('\n')
image_array = get_one_image(images_dir + image_name)
image_array = np.reshape(image_array, [1, 300, 400, 3])
prediction = sess.run(logits, feed_dict={x: image_array})
prediction = np.array(prediction, dtype='float32')
images_tested.append([image_name, prediction])
num_photos += 1
print(num_photos)
outfile.writelines(image_name)
t = str(prediction)
outfile.writelines(t)
#测试单张图片
while (True):
test_file = input('输入测试图片:')
if (test_file == 'z'):
break
image_name = test_file
image_array = get_one_image(images_dir + image_name)
image_array = np.reshape(image_array, [1, 300, 400, 3])
prediction = sess.run(logits, feed_dict={x: image_array})
prediction = np.array(prediction, dtype='float32')
test_result = []
for sample in images_tested:
distance = np.sqrt(np.sum(np.square(sample[1] - prediction)))
distance.astype('float32')
test_result.append([sample[0], distance])
#将结果排序
test_result = np.array(test_result)
test_result = test_result[np.lexsort(test_result.T)]
for i in range(11):
print(test_result[i][0])
images_show(test_result)
if not os.path.exists(root_dir): os.makedirs(root_dir)
checkpoint_dir = os.path.join(root_dir, version +
'_train') #os.path.dirname(checkpoint_path)
if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir)
checkpoint_path = os.path.join(checkpoint_dir, 'cp-{epoch:04d}.ckpt')
cp_callback = [
tf.keras.callbacks.ModelCheckpoint(checkpoint_path,
verbose=0,
save_weights_only=True,
period=5),
tf.keras.callbacks.EarlyStopping(patience=5, monitor="val_acc")
]
model, model_archi = CNN_model.CNN(width, height, depth, len(genres))
model.save_weights(checkpoint_path.format(epoch=0))
history = model.fit(
train_images,
train_labels,
epochs=epochs,
callbacks=cp_callback,
validation_data=(test_images, test_labels),
#validation_split=0.2,
shuffle=True,
batch_size=batch_size,
verbose=1)
#latest = tf.train.latest_checkpoint(checkpoint_dir)
# Save the weights
@author: Administrator
"""
import tensorflow as tf
import random
import numpy as np
import DataManager as dm, Logger, CNN_model
log = Logger.get_logger("Model_1", "./log/Model_1.log")
weight_path = './weight/Model_1/Model_1.ckpt'
# tf Graph input
X = tf.compat.v1.placeholder("float", [None, 64 * 64])
Y = tf.compat.v1.placeholder("float", [None, 150])
#use convolutional neural network to extract features
feature_layer = CNN_model.CNN(X, Y)
#use fully connected neural network to classify
classification_layer = CNN_model.full_connected_layer(feature_layer)
# loss_softmax is the only loss function used in model 1
loss_softmax = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=classification_layer,
labels=Y))
optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001, epsilon=1)
train_op = optimizer.minimize(loss_softmax)
# TensorBoard
tf.compat.v1.summary.scalar("loss", loss_softmax)
merged_summary_op = tf.compat.v1.summary.merge_all()
def main():
# Initialize Model
model = CNN_model.fnBuildModel()
#If user passes a single image to check if the model works
if args.test is not None:
print("---------- In Testing mode")
image = cv2.imread(args.test)
image = fu.preprocessing(image)
image = np.expand_dims(image, axis=0)
y = np.expand_dims(np.asarray([0]), axis=0)
BatchSize = 1
model.fit(image, y, epochs=400, \
batch_size=BatchSize, \
validation_split=0.1, \
shuffle=True, verbose=0)
return
X_filename = 'X_train.npy'
Y_filename = 'Y_train.npy'
X_train = np.load(X_filename)
Y_train = np.load(Y_filename)
print(X_train.shape)
print(Y_train.shape)
print("Training started...........")
arrCallbacks = []
earlystop_callback = EarlyStopping(monitor='val_loss',
patience=5,
verbose=0)
batch_print_callback = LambdaCallback(
on_batch_begin=lambda batch, logs: batch)
epoch_print_callback = LambdaCallback(
on_epoch_end=lambda epoch, logs: epoch)
tensorboard = TensorBoard(log_dir='./Graphfinal2',
histogram_freq=0,
write_graph=True,
write_images=True)
arrCallbacks.append(earlystop_callback)
arrCallbacks.append(batch_print_callback)
arrCallbacks.append(epoch_print_callback)
arrCallbacks.append(tensorboard)
BatchSize = 50
hist = model.fit(X_train, Y_train, epochs=500, \
batch_size=BatchSize, \
validation_split=0.3, \
shuffle=True, verbose=0, \
callbacks=arrCallbacks)
model.save_weights('my_model_weights.h5')
#scores = model.evaluate(X_train, Y_train, verbose=0)
# model result:
train_val_accuracy = hist.history
# Get and print training accuracy
train_accuracy = train_val_accuracy['acc']
# Get and print validation accuracy
val_accuracy = train_val_accuracy['val_acc']
print("Done!")
print("Train acc: %.3f" % train_accuracy[-1])
print("Validation acc: %.3f" % val_accuracy[-1])
#print ("Train loss : %.3f" % scores[0])
#print ("Train accuracy : %.3f" % scores[1])
print("Training finished")
valid_data_lbls = [item[1] for item in valid_data]
# create arrays for us in models
X_train = np.array(train_data_imgs).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
Y_train = train_data_lbls
x_valid = np.array(valid_data_imgs).reshape(-1, IMG_SIZE, IMG_SIZE, 1)
y_valid = valid_data_lbls
# Image Augmentation (flip along vertical axis and random rotations (max 25 degrees)
img_aug = ImageAugmentation()
img_aug.add_random_flip_leftright()
img_aug.add_random_rotation(max_angle=25.)
''' Model execution (training or loading) '''
# model = CNN_model.cnn(img_size=IMG_SIZE, lr=lr) # basic CNN
# model = CNN_model.resnet(img_size=IMG_SIZE, lr=lr, n=2) # simple resnet
model = CNN_model.conv_res_integrated(
img_size=IMG_SIZE, lr=lr, n=1,
img_aug=img_aug) # integrated CNN with res layers
# Ask user to load or train new model
# For first time need to process but subsequently can load old model
# UNLESS any parameters are changed
print(
'Would you like to load pre-existing trained model (L) or train a new one (T)?'
)
decision2 = input()
if decision2 == 'T':
model.fit(X_train,
Y_train,
n_epoch=epochs,
validation_set=(x_valid, y_valid),
snapshot_step=500,
def main():
# parameters
feature_size = 512 * 7 * 7
learning_rate = 0.0001
num_epochs = 51
batch_size = 64
# create the save log file
print("Create the directory")
if not os.path.exists("./save"):
os.makedirs("./save")
if not os.path.exists("./logfile"):
os.makedirs("./logfile")
if not os.path.exists("./logfile/CNN"):
os.makedirs("./logfile/CNN")
# load my Dataset
train_dataset = CNN_Dataset.CNN_Dataset(mode="train")
test_dataset = CNN_Dataset.CNN_Dataset(mode="valid")
print('the train_dataset has %d size.' % (len(train_dataset.data)))
print('the valid_dataset has %d size.' % (len(test_dataset.data)))
# Pre-train models
CNN_pre_model = torchvision.models.vgg16(pretrained=True).features
model = CNN_model.CNN_model(feature_size)
# GPU enable
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print('Device used:', device)
if torch.cuda.is_available():
CNN_pre_model = CNN_pre_model.to(device)
model = model.to(device)
##################################################################
######### pre-train model vgg16
##################################################################
# train_dataset = (num of data ,data/label ,frames ,3 ,224 ,224)
CNN_pre_model.eval()
train_features = []
with torch.no_grad():
for i in range(len(train_dataset.data)):
print("\r%d/%d" % (i, len(train_dataset.data)), end="")
input = train_dataset[i][0]
input = input.to(device)
tmp = CNN_pre_model(input).cpu().view(-1, feature_size)
train_features.append(torch.mean(tmp, 0).numpy())
print(" Pre-train train_data finished!")
test_features = []
with torch.no_grad():
for i in range(len(test_dataset.data)):
print("\r%d/%d" % (i, len(test_dataset.data)), end="")
input = test_dataset[i][0]
input = input.to(device)
tmp = CNN_pre_model(input).cpu().view(-1, feature_size)
test_features.append(torch.mean(tmp, 0).numpy())
print(" Pre-train test_data finished!")
# update dataset
train_features = torch.Tensor(train_features)
train_label = torch.LongTensor(train_dataset.label)
train_features_dataset = data.TensorDataset(train_features, train_label)
test_features = torch.Tensor(test_features)
test_label = torch.LongTensor(test_dataset.label)
test_features_dataset = data.TensorDataset(test_features, test_label)
train_loader = DataLoader(train_features_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
test_loader = DataLoader(test_features_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=8)
# setup optimizer
optimizer = optim.Adam(model.parameters(),
lr=learning_rate,
betas=(0.5, 0.999))
criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_acc_list = []
test_loss_list = []
test_acc_list = []
print("Starting training...")
best_accuracy = -np.inf
for epoch in range(num_epochs):
start = time.time()
model.train()
print("Epoch:", epoch + 1)
epoch_train_loss = 0.0
train_acc = 0.0
if (epoch + 1) == 11:
optimizer.param_groups[0]['lr'] /= 2
if (epoch + 1) == 20:
optimizer.param_groups[0]['lr'] /= 2
for i, (feature, label) in enumerate(train_loader):
feature = Variable(feature).to(device)
label = Variable(label).to(device)
optimizer.zero_grad()
output = model(feature)
train_loss = criterion(output, label)
train_loss.backward()
optimizer.step()
epoch_train_loss += train_loss.item()
# Accuracy
output_label = torch.argmax(output, 1).cpu()
acc = np.mean((output_label == label.cpu()).numpy())
train_acc += acc
print('Epoch [%d/%d], Iter [%d/%d] loss %.4f,Acc %.4f, LR = %.6f' %
(epoch, num_epochs, i + 1, len(train_loader),
train_loss.item(), acc, optimizer.param_groups[0]['lr']))
if (epoch) % 10 == 0:
save_checkpoint('./save/CNN-%03i.pth' % (epoch), model, optimizer)
# testing
with torch.no_grad():
model.eval()
epoch_test_loss = 0.0
test_acc = 0.
for i, (feature, label) in enumerate(test_loader):
feature = Variable(feature).to(device)
label = Variable(label).to(device)
output = model(feature)
test_loss = criterion(output, label)
predict = torch.argmax(output, 1).cpu()
acc = np.mean((predict == label.cpu()).numpy())
epoch_test_loss += test_loss.item()
test_acc += acc
print(
'\n============\nEpoch [%d/%d] ,Train: Loss: %.4f | Acc: %.4f ,Validation: loss: %.4f | Acc: %.4f'
% (epoch, num_epochs, epoch_train_loss / len(train_loader),
train_acc / len(train_loader), epoch_test_loss /
len(test_loader), test_acc / len(test_loader)))
# save loss data
train_loss_list.append(epoch_train_loss / len(train_loader))
train_acc_list.append(train_acc / len(train_loader))
test_loss_list.append(epoch_test_loss / len(test_loader))
test_acc_list.append(test_acc / len(test_loader))
if (test_acc / len(test_loader) > best_accuracy):
best_accuracy = test_acc / len(test_loader)
save_checkpoint('./save/CNN-%03i.pth' % (epoch), model, optimizer)
print('Save best model , test_acc = %.6f)...' % (best_accuracy))
print('-' * 88)
with open('./logfile/CNN/train_loss.pkl', 'wb') as f:
pickle.dump(train_loss_list, f)
with open('./logfile/CNN/train_acc.pkl', 'wb') as f:
pickle.dump(train_acc_list, f)
with open('./logfile/CNN/test_loss.pkl', 'wb') as f:
pickle.dump(test_loss_list, f)
with open('./logfile/CNN/test_acc.pkl', 'wb') as f:
pickle.dump(test_acc_list, f)
# test_file_name = "../MSdata/MGF/artificialData3"
test_spectra_loc = data.inspect_file_location("mgf", test_file_name)
with open(test_file_name, "r") as test_file:
test_data, _ = data.read_random_stack_cnn(
test_file, "mgf", test_spectra_loc, data_utils.test_stack_size)
# test_bucket_sizes =
# Training Data
# file_name = "../MSdata/MGF/peaks.db.10k.yeast.mgf"
# file_name = "../MSdata/MGF/excludeYeast_cross.cat.mgf.train.repeat"
file_name = "../MSdata/MGF/artificialData2sorted"
spectra_locations = data.inspect_file_location("mgf", file_name)
file_handle = open(file_name, "r")
# Model
my_model = CNN_model.cnnModel(test_sess)
test_sess.run(tf.global_variables_initializer())
# epochs
epochs = 50 #200
epoch_loss = []
for epoch in range(epochs):
dataset, dataset_len = data.read_random_stack_cnn(
file_handle, "mgf", spectra_locations,
data_utils.train_stack_size)
training_set_size = dataset_len
spectra_used = 0
def run_training():
train_dir = "./image/"
logs_train_dir = "./log_" + str(MAX_STEP) + "_cap_" + str(CAPACITY)
train, train_label = image_P.get_files(train_dir)
train_batch, train_label_batch = image_P.get_batch(train, train_label,
IMG_W, IMG_H,
BATCH_SIZE, CAPACITY)
train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
train_loss = model.losses(train_logits, train_label_batch)
train_op = model.trainning(train_loss, learning_rate)
train_acc = model.evaluation(train_logits, train_label_batch)
summary_op = tf.summary.merge_all()
config = tf.ConfigProto(allow_soft_placement=True,
gpu_options=tf.GPUOptions(
per_process_gpu_memory_fraction=0.7,
allow_growth=True))
sess = tf.Session(config=config)
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
tf.train.start_queue_runners(sess=sess)
for step in np.arange(9999999):
sess.run([train_op, train_loss, train_acc])
print(step)
if step == MAX_STEP:
print("Finished")
break
log_dir = train_dir
images_dir = './image/'
images_cat = open("imagelist.txt")
#保存所有图像经过模型计算之后的数组
images_tested = []
num_photos = 0
outfile = open("test-new-" + str(MAX_STEP) + "-" + str(CAPACITY) + ".txt",
"w")
filelines = images_cat.readlines()
for line in filelines:
image_name = line.strip('\n')
image_array = get_one_image(images_dir + image_name)
image_array = np.reshape(image_array, [1, 300, 400, 3])
xName = tf.placeholder(tf.float32, shape=[1, 300, 400, 3])
prediction = sess.run(train_logits, feed_dict={xName: image_array})
prediction = np.array(prediction, dtype='float32')
images_tested.append([image_name, prediction])
num_photos += 1
print("Test:" + str(num_photos))
outfile.writelines(image_name)
t = str(prediction)
outfile.writelines(t)
outfile.close()
outfile = open(
"test-new-" + str(MAX_STEP) + "-" + str(CAPACITY) + ".txt", "a")
outfile.close()
outfile2 = open(
"nearesttest-" + str(MAX_STEP) + "-" + str(CAPACITY) + ".txt", "w")
outfile2.write("result = {\n")
outfile2.close()
num_photos = 0
for line in filelines:
num_photos += 1
print("Find Near:" + str(num_photos))
image_name = line.strip('\n')
image_array = get_one_image(images_dir + image_name)
image_array = np.reshape(image_array, [1, 300, 400, 3])
outfile2 = open(
"nearesttest-" + str(MAX_STEP) + "-" + str(CAPACITY) + ".txt", "a")
outfile2.write("'" + image_name + "': [\n")
xName = tf.placeholder(tf.float32, shape=[1, 300, 400, 3])
prediction = sess.run(train_logits, feed_dict={xName: image_array})
prediction = np.array(prediction, dtype='float32')
test_result = []
for sample in images_tested:
distance = np.sqrt(np.sum(np.square(sample[1] - prediction)))
distance.astype('float32')
test_result.append([sample[0], distance])
#将结果排序
test_result = np.array(test_result)
test_result = test_result[np.lexsort(test_result.T)]
for i in range(11):
outfile2.write("'" + test_result[i][0] + "', ")
outfile2.write("],\n")
outfile2.close()
outfile2 = open(
"nearesttest-" + str(MAX_STEP) + "-" + str(CAPACITY) + ".txt", "a")
outfile2.write("}\n")
outfile2.close()
sess.close()