def text(times=300):
net = ConvolutionalNetwork()
net.reload_from_dict(pickle.load(open('save/save2', 'rb')))
# 准备数据
if not os.path.exists('save'):
os.mkdir('save')
if not os.path.exists('save/train.tfrecords'):
encode_to_tfrecords(record_file='save/train.tfrecords')
if not os.path.exists('save/text.tfrecords'):
encode_to_tfrecords(record_file='save/text.tfrecords')
images, labels = decode_from_tfrecords(filename='save/text.tfrecords')
batch_image, batch_label = get_batch(images, labels, batch_size=BATCH_SIZE)
inf = net.inference(batch_image, init=False)
correct_prediction = tf.equal(
tf.cast(tf.argmax(inf, axis=1), tf.int32, name='prediction'),
batch_label)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
with tf.Session() as session:
session.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
accuracy_total = 0
with sys.stdout as file:
for i in range(times): # train 350
accuracy_np = session.run([accuracy])[0]
print(accuracy_np)
accuracy_total += accuracy_np
print(accuracy_total / times)
coord.request_stop() # queue需要关闭，否则报错
coord.join(threads)
def train():
encoder = Encoder(vocab_size=en_total_words, embed_dim=EMBED_DIM, encoder_hidden_dim=ENCODER_HIDDEN_DIM,\
decoder_hidden_dim=DECODER_HIDDEN_DIM, pad_idx=en_word_to_index['<PAD>'])
decoder = Decoder(vocab_size=ch_total_words, embed_dim=EMBED_DIM, encoder_hidden_dim=ENCODER_HIDDEN_DIM,\
decoder_hidden_dim=DECODER_HIDDEN_DIM, pad_idx=ch_word_to_index['<PAD>'])
model = Seq2Seq(encoder, decoder)
model.to(device)
# print(model)
criterion = nn.CrossEntropyLoss(ignore_index=ch_word_to_index['<PAD>'])
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
for epoch in range(EPOCHS):
model.train()
total_loss = 0.
batch_num = len(encoder_inputs_train) // BATCH_SIZE
batch = get_batch(encoder_inputs_train, decoder_inputs_train,
decoder_targets_trian, BATCH_SIZE)
for i in range(batch_num):
encoder_inputs_batch, decoder_inputs_batch, decoder_targets_batch, encoder_batch_length, decoder_batch_length = next(
batch)
encoder_inputs_batch = torch.from_numpy(encoder_inputs_batch).to(
device).long()
encoder_batch_length = torch.from_numpy(encoder_batch_length).to(
device).long()
decoder_inputs_batch = torch.from_numpy(decoder_inputs_batch).to(
device).long()
decoder_targets_batch = torch.from_numpy(decoder_targets_batch).to(
device).long()
decoder_batch_length = torch.from_numpy(decoder_batch_length).to(
device).long()
outputs = model(encoder_inputs_batch, encoder_batch_length,
decoder_inputs_batch, decoder_batch_length)
# print(outputs.shape)
# print(decoder_targets_batch.shape)
outputs = outputs.view(
-1, outputs.shape[-1]) # [batch_size*seq_length, vocab_size]
# print(decoder_targets_batch.view(-1).size())
decoder_targets_batch = decoder_targets_batch.view(
-1) # [batch_size*seq_length]
# outputs = torch.Tensor(outputs)
loss = criterion(outputs, decoder_targets_batch)
total_loss += loss.cpu().item()
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 5.)
optimizer.step()
if (epoch + 1) % 20 == 0:
acc = evaluate(model,
encoder_inputs_train,
decoder_inputs_train,
decoder_targets_trian,
criterion,
batch_size=BATCH_SIZE)
print('epoch %d, loss %.4f, accuracy %.6f' %
(epoch + 1, total_loss / batch_num, acc))
else:
print('epoch %d, loss %.4f' % (epoch + 1, total_loss / batch_num))
torch.save(model.state_dict(), MODEL_PATH)
def evaluate(model,
encoder_inputs_test,
decoder_inputs_test,
decoder_targets_test,
criterion,
batch_size=BATCH_SIZE):
candidates = []
batch_num = len(encoder_inputs_train) // BATCH_SIZE
batch = get_batch(encoder_inputs_test, decoder_inputs_test,
decoder_targets_test, BATCH_SIZE)
model.eval()
with torch.no_grad():
for i in range(batch_num):
encoder_inputs_batch, _, decoder_targets_batch, encoder_batch_length, decoder_batch_length = next(
batch)
encoder_inputs_batch = torch.from_numpy(encoder_inputs_batch).to(
device).long()
encoder_batch_length = torch.from_numpy(encoder_batch_length).to(
device).long()
encoder_inputs_batch = encoder_inputs_batch.unsqueeze(0)
encoder_batch_length = encoder_batch_length.unsqueeze(0)
for j in range(batch_size):
predict = model.translate(encoder_inputs_batch[:, 1, :],
encoder_batch_length[:, 1])
candidates.append(predict)
return calculate_bleu(decoder_targets_test, candidates)
def evaluate(model, encoder_inputs_test, decoder_inputs_test,
decoder_targets_test, criterion, batch_size):
total_loss = 0.
batch_num = len(encoder_inputs_test) // BATCH_SIZE
batch = get_batch(encoder_inputs_test, decoder_inputs_test,
decoder_targets_test, batch_size)
model.eval()
with torch.no_grad():
for i in range(batch_num):
encoder_inputs_batch, decoder_inputs_batch, decoder_targets_batch, encoder_batch_length, decoder_batch_length = next(
batch)
encoder_inputs_batch = sequence_padding(
encoder_inputs_batch,
encoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
decoder_inputs_batch = sequence_padding(
decoder_inputs_batch,
decoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
decoder_targets_batch = sequence_padding(
decoder_targets_batch,
decoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
outputs = model(encoder_inputs_batch, encoder_batch_length,
decoder_inputs_batch, decoder_batch_length)
outputs = outputs.view(
-1, outputs.shape[-1]) # [batch_size*seq_length, vocab_size]
decoder_targets_batch = decoder_targets_batch.view(
-1) # [batch_size*seq_length]
loss = criterion(outputs, decoder_targets_batch)
total_loss += loss.cpu().item()
return total_loss / batch_num
def run_mse():
img_generator = d.get_batch(num_workers=8, input_size=33, batch_size=16)
x = tf.placeholder(tf.float32,
shape=[None, None, None, 3],
name='input_images')
y = tf.placeholder(tf.float32,
shape=[None, None, None, 3],
name='input_labels')
# x = mean_image_subtraction(x)
# y = mean_image_subtraction(y)
# x = tf.image.per_image_standardization(x)
# y = tf.image.per_image_standardization(y)
a = tf.square(x - y)
# print(x.shape)
# x = tf.reshape(x, [3, -1])
# y = tf.reshape(y, [3, -1])
#
mse = tf.reduce_mean(tf.square(x - y))
with tf.Session() as sess:
while True:
data = next(img_generator)
# b = sess.run(a, feed_dict={x: data[0], y: data[1]})
# print(b)
# print(data[0].shape)
m = sess.run(mse, feed_dict={x: data[0], y: data[1]})
print(m)
def train():
model = Transformer(en_total_words,
MAX_SEQ_LENGTH,
ch_total_words,
MAX_SEQ_LENGTH,
encoder_pad_idx=en_word_to_index['<PAD>'],
decoder_pad_idx=ch_word_to_index['<PAD>'])
model.to(device)
# print(model)
criterion = nn.CrossEntropyLoss(ignore_index=ch_word_to_index['<PAD>'])
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
start = time.time()
for epoch in range(EPOCHS):
model.train()
total_loss = 0.
batch_num = len(encoder_inputs_train) // BATCH_SIZE
batch = get_batch(encoder_inputs_train, decoder_inputs_train,
decoder_targets_trian, BATCH_SIZE)
for i in range(batch_num):
encoder_inputs_batch, decoder_inputs_batch, decoder_targets_batch, encoder_batch_length, decoder_batch_length = next(
batch)
encoder_inputs_batch = sequence_padding(
encoder_inputs_batch,
encoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
decoder_inputs_batch = sequence_padding(
decoder_inputs_batch,
decoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
decoder_targets_batch = sequence_padding(
decoder_targets_batch,
decoder_batch_length,
max_seq_lenth=MAX_SEQ_LENGTH)
outputs = model(encoder_inputs_batch, encoder_batch_length,
decoder_inputs_batch, decoder_batch_length)
outputs = outputs.view(
-1, outputs.shape[-1]) # [batch_size*seq_length, vocab_size]
decoder_targets_batch = decoder_targets_batch.view(
-1) # [batch_size*seq_length]
optimizer.zero_grad()
loss = criterion(outputs, decoder_targets_batch)
total_loss += loss.cpu().item()
loss.backward()
optimizer.step()
eval = evaluate(model, encoder_inputs_test, decoder_inputs_test,
decoder_targets_test, criterion, BATCH_SIZE)
print('epoch %d, loss %.4f, eval %.4f, time %.2fmin' %
(epoch + 1, total_loss / batch_num, eval,
(time.time() - start) / 60))
torch.save(model.state_dict(), MODEL_PATH)
def train(times=3000, continue_train=False, learn_rate=LEARN_RATE):
global LEARN_RATE
LEARN_RATE = learn_rate
# 加载模型
net = ConvolutionalNetwork()
if continue_train:
net.reload_from_dict(pickle.load(open('save/save1', 'rb')))
else:
for i in range(2):
net.addLayer(CONV_LAYER, 'conv' + str(i), 8**(i + 1))
net.addLayer(FC_LAYER, 'fc1', 1024)
net.addLayer(DROP_LAYER, 'drop0', 0.5)
net.addLayer(FC_LAYER, 'fc2', CHAR_CLASS)
# 准备数据
if not os.path.exists('save'):
os.mkdir('save')
if not os.path.exists('save/train.tfrecords'):
encode_to_tfrecords(record_file='save/train.tfrecords')
if not os.path.exists('save/text.tfrecords'):
encode_to_tfrecords(record_file='save/text.tfrecords')
images, labels = decode_from_tfrecords(filename='save/train.tfrecords')
batch_image, batch_label = get_batch(images, labels, batch_size=BATCH_SIZE)
text_images, text_labels = decode_from_tfrecords(
filename='save/text.tfrecords')
text_batch_image, text_batch_label = get_batch(text_images,
text_labels,
batch_size=50)
# 训练用节点
inf = net.inference(batch_image, init=not continue_train)
loss = net.sorfmax_loss(inf, batch_label)
opti = net.optimer(loss)
correct_prediction = tf.equal(
tf.cast(tf.argmax(inf, axis=1), tf.int32, name='prediction'),
batch_label)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 验证用节点
text_inf = net.inference(text_batch_image, init=False)
text_correct_prediction = tf.equal(
tf.cast(tf.argmax(text_inf, axis=1), tf.int32, name='prediction'),
text_batch_label)
text_accuracy = tf.reduce_mean(tf.cast(text_correct_prediction,
tf.float32))
with tf.Session() as session:
session.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
with sys.stdout as file:
for i in range(times): # train 350
loss_np, _, label_np, image_np, inf_np = session.run(
[loss, opti, batch_label, batch_image, inf])
if i % 100 == 0:
print('step : %d trainloss:' % (i), loss_np, file=file)
print('train accuracy:',
session.run([accuracy]),
file=file)
print('text accuracy:',
session.run([text_accuracy]),
file=file)
# 存储模型
pickle.dump(net.obj_to_dict(session), open('save/save2', 'wb'))
coord.request_stop() # queue需要关闭，否则报错
coord.join(threads)
def train():
model_params = Params()
GPU_Option = tf.GPUOptions(per_process_gpu_memory_fraction=model_params.per_process_gpu_memory_fraction)
session_conf = tf.ConfigProto(
allow_soft_placement = True,
log_device_placement = False,
gpu_options = GPU_Option,
)
train_data, test_data = load_processed_data(model_params.processed_data_path)
print("Test data 's size:{}".format(test_data[0].shape[0]))
model = Transformer(model_params)
model.train()
with tf.device('/gpu:0'):
with tf.Session(config=session_conf) as sess:
if not os.path.exists(model_params.summary_path):
os.mkdir(model_params.summary_path)
summary_writer = tf.summary.FileWriter(model_params.summary_path,sess.graph)
if not os.path.exists(model_params.model_save):
os.mkdir(model_params.model_save)
saver = tf.train.Saver(max_to_keep=4)
latest_ckpt = tf.train.latest_checkpoint(model_params.model_save)
if not latest_ckpt:
sess.run(tf.global_variables_initializer())
print('Initial the model .')
else:
saver.restore(sess,latest_ckpt)
print('Restore the model from better_checkpoint .')
last_loss = 10000
for xs, decode_inputs, ys, epoch_i in get_batch(train_data,epoch=model_params.epochs,batch_size=model_params.batch_size):
feed_dict = {model.xs : xs, model.decode_inputs : decode_inputs, model.ys : ys,
model.dropout_rate:model_params.dropout_rate}
_, loss, global_step, y_hat, summary_ = sess.run([model.train_op, model.loss, model.global_step, model.y_hat, model.summary],
feed_dict=feed_dict)
summary_writer.add_summary(summary_,global_step)
if global_step % model_params.print_per_steps == 0:
print('{} Epoch: {}, global_step: {}, loss: {}'.format(datetime.datetime.now().strftime('%Y-%m-%d %X'),
epoch_i + 1, global_step, loss))
if global_step % model_params.test_per_steps == 0:
temp_loss = 0
count = 0
for xs, decode_inputs, ys, _ in get_batch(test_data,epoch=1,batch_size=model_params.batch_size,shuffle=False):
feed_dict = {model.xs : xs, model.decode_inputs : decode_inputs, model.ys : ys,
model.dropout_rate:0}
loss = sess.run(model.loss,
feed_dict=feed_dict)
temp_loss += loss
count += 1
loss = temp_loss / count
if loss < last_loss:
last_loss = loss
saver.save(sess,model_params.model_save + '/{}'.format(int(time.time())))
print('{} Save model with lower loss :{}.'.format(datetime.datetime.now().strftime('%Y-%m-%d %X'),
loss))
# 预览test效果
print(decode_inputs[:3])
print(ys[:3])
print(y_hat[:3])
summary_writer.close()
def train():
with tf.device('/cpu:0'):
coord = tf.train.Coordinator()
global_step = tf.get_variable('global_step', [],
initializer=tf.constant_initializer(0),
trainable=False)
# num_batches_per_epoch = (num_examples_per_epoch_for_train / args.batch_size)
# decay_steps = int(num_batches_per_epoch * num_batches_per_epoch)
#
# lr = tf.train.exponential_decay(init_learning_rate,
# global_step,
# decay_steps,
# staircase=True)
# signals, labels = read_and_decode(args.data_dir)
data1 = pd.read_csv('/home/msmal/object_type/train_scale.csv', header=0)
print("data1 read over!")
data2 = pd.read_csv('/home/msmal/float_type/train.csv', header=0)
data2[np.isinf(data2)] = -1
data2[np.isnan(data2)] = -2
print("data2 read over!")
y = pd.read_csv('/home/msmal/label.csv', header=0)
scaler = preprocessing.StandardScaler()
data2_scaled = scaler.fit_transform(data2)
X = pd.concat([data1.iloc[:, 1:], pd.DataFrame(data2_scaled)], axis=1)
signals = tf.cast(X,tf.float64)
labels = tf.cast(y, tf.int32)
signals_batch, labels_batch = get_batch(signals, labels, args.batch_size)
with tf.device('/gpu:0'):
with slim.arg_scope(resnet_arg_scope()):
net, end_points = resnet_v2_34(signals_batch, num_classes=args.num_classes)
# restore_var = tf.global_variables()
var_list = tf.trainable_variables()
g_list = tf.global_variables()
bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
var_list += bn_moving_vars
# saver = tf.train.Saver(var_list=var_list, max_to_keep=5)
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=net,
labels=labels_batch,
name='cross_entropy_loss')
reduce_loss = tf.reduce_mean(loss, name='mean_loss')
# update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
# with tf.control_dependencies(update_ops):
# train_op = tf.train.AdamOptimizer(args.learning_rate).minimize(reduce_loss, global_step=global_step)
optimizer = tf.train.AdamOptimizer(args.learning_rate)
train_step = slim.learning.create_train_op(reduce_loss, optimizer, global_step=global_step)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
if update_ops:
updates = tf.group(*update_ops)
reduce_loss = control_flow_ops.with_dependencies([updates], reduce_loss)
correct_prediction = tf.equal(tf.cast(tf.argmax(net, 1), tf.int32), labels_batch)
accury = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
with tf.device('/cpu:0'):
# for var in tf.trainable_variables():
# tf.summary.histogram(var.op.name, var)
tf.summary.scalar('loss', reduce_loss)
tf.summary.scalar('acuury', accury)
merged = tf.summary.merge_all()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
init = tf.global_variables_initializer()
train_writer = tf.summary.FileWriter(tensorboard_path, sess.graph)
sess.run(init)
with tf.device('cpu:0'):
# saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=20)
# Saver for storing checkpoints of the model.
saver = tf.train.Saver(var_list=var_list, max_to_keep=20)
# Load variables if the checkpoint is provided.
if restore_from is not None:
loader = tf.train.Saver(var_list=var_list)
load(loader, sess, restore_from)
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
signals_bt = sess.run(signals_batch)
print(signals_bt.shape)
start_epoch_time = 0
total_loss, accuy, n_batch = 0, 0, 0
for step in range(args.max_steps):
start_time = time.time()
if (step + 1) % 1000 == 0:
loss_value, acc, _ = sess.run([reduce_loss, accury, train_step])
total_loss += loss_value
accuy += acc
n_batch += 1
save(saver, sess, args.checkpoints_path, step)
else:
loss_value, acc, _ = sess.run([reduce_loss, accury, train_step])
total_loss += loss_value
accuy += acc
n_batch += 1
# print(step, ll)
duration = time.time() - start_time
print(
'step {:d}\t loss = {:.3f}, accury = {:.3f}, ({:.3f} sec/step)'.format(step, loss_value, acc, duration))
if step % 100 == 0:
summary_all = sess.run(merged)
train_writer.add_summary(summary_all, step)
print(' ** train_loss: %f acc: %f took %fs (2d with distortion)' %
(total_loss / n_batch, accuy / n_batch, time.time() - start_epoch_time))
start_epoch_time = time.time()
total_loss, accuy, n_batch = 0, 0, 0
train_writer.close()
coord.request_stop()
coord.join(threads=threads)
merged = tf.summary.merge_all()
saver = tf.train.Saver()
with tf.Session() as sess:
tf.global_variables_initializer().run()
writer = tf.summary.FileWriter('../aerial_cactus_identification/logs/',
graph=sess.graph)
image_list = []
label_list = []
images = train_data['id'].values
for image_id in images:
image_list.append(train_dir + image_id)
label_list.append(
train_data[train_data['id'] == image_id]['has_cactus'].values[0])
image_train, label_train = data_process.get_batch(image_list[:15001],
label_list[:15001], w, h,
batch_size, capacity)
image_valid, label_valid = data_process.get_batch(image_list[15000:],
label_list[15000:], w, h,
batch_size, capacity)
learning_rate = model.learning_rate_schedule(max_steps)
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(max_steps):
train_image, train_label = sess.run([image_train, label_train])
_, loss, steps = sess.run(
[train_op, sum_loss, global_step],
feed_dict={
input_image: train_image,
output: train_label,
lr: learning_rate,
is_training: True
