def main(argv=None):
train_samples = tf.placeholder(tf.float32, [None, IMAGE_SIZE, IMAGE_SIZE, IMAGE_CHANNLES], name='train_sample')
train_labels = tf.placeholder(tf.float32, [None, CLASS_COUNTS], name='train_label')
keep_prob = tf.placeholder(tf.float32, [], name='keep_probability')
logits1 = subnet1(train_samples, keep_prob)
clas1_loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=train_labels, logits=logits1))
clas1_acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(train_labels, 1), tf.argmax(logits1, 1)), tf.float32), name='clas1_acc')
classifier1_loss = clas1_loss
# classifier1_op = tf.train.AdamOptimizer(0.0005).minimize(classifier1_loss)
classifier1_op = tf.train.GradientDescentOptimizer(0.0005).minimize(clas1_loss)
train_data, train_label = data_process.input_data()
Saver = tf.train.Saver()
with tf.Session() as sess:
train_writer = tf.summary.FileWriter('./checkpoint/', sess.graph)
sess.run(tf.global_variables_initializer())
Saver.restore(sess, './checkpoint/')
print('Initialized!')
for step in range(int(RAW_NUM * EPOCH) // BATCH_SIZE):
train_offset = (step * BATCH_SIZE) % (TRAIN_NUM - BATCH_SIZE)
batch_data = train_data[train_offset:(train_offset + BATCH_SIZE)]
batch_label = train_label[train_offset:(train_offset + BATCH_SIZE), :]
np.random.seed(step)
np.random.shuffle(batch_data)
np.random.seed(step)
np.random.shuffle(batch_label)
feed_dict = {train_samples: batch_data, train_labels: batch_label, keep_prob: 0.50}
_, Clas1_loss = sess.run([classifier1_op, classifier1_loss], feed_dict=feed_dict)
Clas1_acc = sess.run(clas1_acc, feed_dict=feed_dict)
print("%d the %s train reslut" % (step, datetime.datetime.now()))
print('the classifier one loss %g' % Clas1_loss)
print('the classifier1 accuracy is %g' % (Clas1_acc))
if step % 500 == 0:
Saver.save(sess, './checkpoint/')
label_positive, label_positive, label_negative
target_data = self.train_data
target_labels = self.train_labels
# print(target_labels)
# c = target_data.shape[3]
# w = target_data.shape[1]
# h = target_data.shape[2]
data_a = np.zeros(shape=(n_triplet, 299, 299, 3), dtype=np.float32)
data_p = np.zeros(shape=(n_triplet, 299, 299, 3), dtype=np.float32)
data_n = np.zeros(shape=(n_triplet, 299, 299, 3), dtype=np.float32)
labels_a = np.zeros(shape=n_triplet, dtype=np.float32)
labels_p = np.zeros(shape=n_triplet, dtype=np.float32)
labels_n = np.zeros(shape=n_triplet, dtype=np.float32)
for i in range(n_triplet):
data_a[i, :, :, :], data_p[i, :, :, :], data_n[i, :, :, :], \
labels_a[i], labels_p[i], labels_n[i] = _get_one_triplet(target_data, target_labels)
return data_a, data_p, data_n, labels_a, labels_p, labels_n
if __name__ == '__main__':
BATCH_SIZE = 32
data, labels = data_process.input_data()
dataShuffle = DataShuffle(data, labels)
batch_anchor, batch_positive, batch_negative, \
batch_labels_anchor, batch_labels_positive, \
batch_labels_negative = dataShuffle.get_triplet(n_labels=30, n_triplet=BATCH_SIZE)
def main(argv=None):
with tf.Graph().as_default() as graph:
margin = 0.25
BATCH_SIZE = 30
ITERATION = 200000
data_num = 16813
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 299, 299, 3],
name='anchor')
train_positive_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 299, 299, 3],
name='anchor')
train_negative_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 299, 299, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_positive = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_negative = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
# keep_prob = tf.placeholder(tf.float32, shape=[], name='keep_probability')
train_data = tf.concat(
[train_anchor_data, train_positive_data, train_negative_data],
axis=0)
# vgg_train_anchor = model.NetworkModel(train_anchor_data, keep_prob=keep_prob)
# vgg_train_positive = model.NetworkModel(train_positive_data, keep_prob=keep_prob, reuse=True)
# vgg_train_negative = model.NetworkModel(train_negative_data, keep_prob=keep_prob, reuse=True)
with slim.arg_scope(inception_resnet_v2_slim_version.
inception_resnet_v2_arg_scope()):
pre_logits, logits = inception_resnet_v2_slim_version.inception_resnet_v2(
train_data, num_classes=512, is_training=True)
pre_logits = tf.nn.l2_normalize(pre_logits,
1,
1e-10,
name='embeddings')
# print(logits.get_shape().as_list())
exclude = ['InceptionResnetV2/Logits', 'InceptionResnetV2/AuxLogits']
variables_to_restore = slim.get_variables_to_restore(exclude=exclude)
vgg_train_anchor, vgg_train_positive, vgg_train_negative = tf.unstack(
tf.reshape(pre_logits, [-1, 3, 512]), 3, 1)
# print(vgg_train_anchor.get_shape().as_list())
# print(vgg_train_positive.get_shape().as_list())
# print(vgg_train_negative.get_shape().as_list())
loss, positives, negatives = utils.compute_triplet_loss(
vgg_train_anchor, vgg_train_positive, vgg_train_negative, margin)
total_loss = tf.losses.get_total_loss() + loss
num_batches_per_epoch = int(data_num / BATCH_SIZE * 3)
num_steps_per_epoch = num_batches_per_epoch # Because one step is one batch processed
decay_steps = int(2 * num_steps_per_epoch)
global_step = tf.Variable(0)
lr = tf.train.exponential_decay(learning_rate=0.001,
global_step=global_step,
decay_steps=decay_steps,
decay_rate=0.7,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
# optimizer_op = tf.train.GradientDescentOptimizer(learning_rate)
train_op = slim.learning.create_train_op(total_loss, optimizer)
Saver = tf.train.Saver(variables_to_restore)
tf.summary.scalar('total_loss', total_loss)
tf.summary.scalar('loss', loss)
tf.summary.scalar('learning_rate', lr)
tf.summary.scalar('positives', positives)
tf.summary.scalar('negatives', negatives)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter('./logs_tensorboard_3/',
sess.graph)
# test_write = tf.summary.FileWriter('./logs_tensorboard/triple/test/', sess.graph)
sess.run(tf.global_variables_initializer())
Saver.restore(sess, 'inception_resnet_v2_2016_08_30.ckpt')
for step in range(ITERATION):
batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive,\
batch_labels_negative = dataShufflu.get_triplet(n_labels=30, n_triplet=BATCH_SIZE)
# print(batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive, batch_labels_negative)
feed_dict = {
train_anchor_data: batch_anchor,
train_positive_data: batch_positive,
train_negative_data: batch_negative,
labels_anchor: batch_labels_anchor,
labels_positive: batch_labels_positive,
labels_negative: batch_labels_negative
}
_, l, ls, summary, Loss = sess.run(
[train_op, total_loss, lr, merged, loss],
feed_dict=feed_dict)
print("%d the %s train reslut" %
(step, datetime.datetime.now()))
print('the triplet loss %g' % Loss)
print('the triplet total loss %g' % l)
train_write.add_summary(summary, step)
if step % 100 == 0:
Saver.save(sess, './logs_tensorboard_3/')
train_write.close()
def main(argv=None):
margin = 0.75
BATCH_SIZE = 40
ITERATION = 200000
data_num = 16813
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
train_positive_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
train_negative_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_positive = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_negative = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
keep_prob = tf.placeholder(tf.float32, shape=[], name='keep_probability')
train_data = tf.concat(
[train_anchor_data, train_positive_data, train_negative_data], axis=0)
# vgg_train_anchor = model.NetworkModel(train_anchor_data, keep_prob=keep_prob)
# vgg_train_positive = model.NetworkModel(train_positive_data, keep_prob=keep_prob, reuse=True)
# vgg_train_negative = model.NetworkModel(train_negative_data, keep_prob=keep_prob, reuse=True)
pre_logits = model.NetworkModel(train_data, keep_prob=keep_prob)
logits = tf.nn.l2_normalize(pre_logits, 1, 1e-10, name='embeddings')
# print(logits.get_shape().as_list())
vgg_train_anchor, vgg_train_positive, vgg_train_negative = tf.unstack(
tf.reshape(logits, [-1, 3, 1024]), 3, 1)
# print(vgg_train_anchor.get_shape().as_list())
# print(vgg_train_positive.get_shape().as_list())
# print(vgg_train_negative.get_shape().as_list())
loss, positives, negatives = utils.compute_triplet_loss(
vgg_train_anchor, vgg_train_positive, vgg_train_negative, margin)
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(0.001, batch * BATCH_SIZE,
data_num, 0.95)
optimizer_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(
loss)
Saver = tf.train.Saver()
tf.summary.scalar('loss', loss)
tf.summary.scalar('positives', positives)
tf.summary.scalar('negatives', negatives)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter('./logs_tensorboard_3/',
sess.graph)
# test_write = tf.summary.FileWriter('./logs_tensorboard/triple/test/', sess.graph)
sess.run(tf.global_variables_initializer())
for step in range(ITERATION):
batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive,\
batch_labels_negative = dataShufflu.get_triplet(n_labels=30, n_triplet=BATCH_SIZE)
# print(batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive, batch_labels_negative)
feed_dict = {
train_anchor_data: batch_anchor,
train_positive_data: batch_positive,
train_negative_data: batch_negative,
labels_anchor: batch_labels_anchor,
labels_positive: batch_labels_positive,
labels_negative: batch_labels_negative,
keep_prob: 0.80
}
_, l, ls, summary = sess.run(
[optimizer_op, loss, learning_rate, merged],
feed_dict=feed_dict)
print("%d the %s train reslut" % (step, datetime.datetime.now()))
print('the triplet loss %g' % l)
train_write.add_summary(summary, step)
if step % 100 == 0:
Saver.save(sess, './logs_tensorboard_3/')
train_write.close()
def main(argv=None):
with tf.Graph().as_default() as graph:
margin = 0.20
BATCH_SIZE = 30
ITERATION = 2000000
data_num = 16640
train_anchor_data = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 224, 224, 3], name='anchor')
train_positive_data = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 224, 224, 3], name='anchor')
train_negative_data = tf.placeholder(tf.float32, shape=[BATCH_SIZE, 224, 224, 3], name='anchor')
labels_anchor = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_positive = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
labels_negative = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
tf.summary.image('input_image', train_anchor_data, 10)
train_data = tf.concat([train_anchor_data, train_positive_data, train_negative_data], axis=0)
# checkpoint_file = tf.train.latest_checkpoint('/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard/')
# print(checkpoint_file)
with slim.arg_scope(inception_resnet_v2_slim_version.inception_resnet_v2_arg_scope()):
pre_logits, logits = inception_resnet_v2_slim_version.inception_resnet_v2(train_data,
num_classes=128, is_training=False)
pre_logits = tf.nn.l2_normalize(pre_logits, 1, 1e-12, name='embeddings')
# print(logits.get_shape().as_list())
# exclude = ['InceptionResnetV2/Logits', 'InceptionResnetV2/AuxLogits']
variables_to_restore = slim.get_variables_to_restore(exclude=)
vgg_train_anchor, vgg_train_positive, vgg_train_negative = tf.unstack(tf.reshape(pre_logits, [-1, 3, 128]), 3, 1)
loss, positives, negatives = utils.compute_triplet_loss(vgg_train_anchor,
vgg_train_positive, vgg_train_negative, margin)
slim.losses.add_loss(loss)
total_loss = slim.losses.get_total_loss()
num_batches_per_epoch = int(data_num / BATCH_SIZE * 3)
num_steps_per_epoch = num_batches_per_epoch # Because one step is one batch processed
decay_steps = int(2 * num_steps_per_epoch)
global_step = tf.Variable(0)
lr = tf.train.exponential_decay(
0.01,
global_step * BATCH_SIZE,
data_num,
0.95
)
train_op = tf.train.GradientDescentOptimizer(learning_rate=lr).minimize(total_loss)
Saver = tf.train.Saver(variables_to_restore)
tf.summary.scalar('total_loss', total_loss)
tf.summary.scalar('loss', loss)
# tf.summary.scalar('learning_rate', lr)
tf.summary.scalar('positives', positives)
tf.summary.scalar('negatives', negatives)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter('/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard/logs_tensorboard', sess.graph)
sess.run(tf.global_variables_initializer())
Saver.restore(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard/logs_tensorboard/model-ckpt-1')
for step in range(ITERATION):
batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive,\
batch_labels_negative = dataShufflu.get_triplet(n_labels=30, n_triplet=BATCH_SIZE)
feed_dict = {
train_anchor_data: batch_anchor,
train_positive_data: batch_positive,
train_negative_data: batch_negative,
labels_anchor: batch_labels_anchor,
labels_positive: batch_labels_positive,
labels_negative: batch_labels_negative
}
l,summary, Loss = sess.run([total_loss, merged, loss], feed_dict=feed_dict)
print("%d the %s train reslut" % (step, datetime.datetime.now()))
print('the triplet loss %g' % Loss)
print('the triplet total loss %g' % l)
train_write.add_summary(summary, step)
# if step % 100 == 0:
# Saver.save(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard/logs_tensorboard/'
# + 'model.ckpt', global_step=step+1)
train_write.close()
def main(argv=None):
with tf.Graph().as_default():
global_step = tf.Variable(0, trainable=False)
CENTER_LOSS_ALPHA = 1.25
BATCH_SIZE = 256
ITERATION = 2000000
data_num = 16640
NUM_CLASSES = 30
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 128, 128, 3],
name='anchor')
labels_anchor = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
tf.summary.image('input_image', train_anchor_data, 10)
features, prelogits, logits = inception_resnet_v1.inference(
train_anchor_data,
keep_probability=0.8,
phase_train=True,
bottleneck_layer_size=30,
weight_decay=0.0005)
print(features, prelogits, logits)
with tf.name_scope('loss'):
with tf.name_scope('center_loss'):
center_loss, centers, centers_update_op = utils.get_center_loss(
features, labels_anchor, CENTER_LOSS_ALPHA, NUM_CLASSES)
with tf.name_scope('softmax_loss'):
softmax_loss = tf.reduce_mean(
tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels_anchor, logits=prelogits))
with tf.name_scope('total_loss'):
total_loss = softmax_loss + center_loss
# global_step = tf.Variable(tf.constant(431, dtype=tf.int64))
lr = tf.train.exponential_decay(learning_rate=0.001,
global_step=global_step,
decay_steps=data_num // BATCH_SIZE,
decay_rate=0.99,
staircase=True)
with tf.control_dependencies([centers_update_op]):
train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize(
total_loss, global_step=global_step)
Saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=3)
tf.summary.scalar('total_loss', total_loss)
tf.summary.scalar('learning_rate', lr)
tf.summary.scalar('softmax_loss', softmax_loss)
tf.summary.scalar('center_loss', center_loss)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter(
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard4/',
sess.graph)
sess.run(tf.global_variables_initializer())
# sess.run(tf.local_variables_initializer())
# Saver.restore(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/')
for step in range(ITERATION):
batch_anchor, batch_labels_anchor = dataShufflu.get_triplet(
n_labels=30, n_triplet=BATCH_SIZE)
feed_dict = {
train_anchor_data: batch_anchor,
labels_anchor: batch_labels_anchor
}
_, l, summary, Loss = sess.run(
[train_op, total_loss, merged, softmax_loss],
feed_dict=feed_dict)
print("%d the %s train reslut" %
(step, datetime.datetime.now()))
print('the softmax loss %g' % Loss)
print('the total loss %g' % l)
train_write.add_summary(summary, step)
if step % 500 == 0:
Saver.save(
sess,
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard4/'
)
train_write.close()
def main(argv=None):
with tf.Graph().as_default() as graph:
Margin = 0.25
BATCH_SIZE = 40
ITERATION = 2000000
data_num = 16640
train_anchor_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
train_positive_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
train_negative_data = tf.placeholder(tf.float32,
shape=[BATCH_SIZE, 224, 224, 3],
name='anchor')
# labels_anchor = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
# labels_positive = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
# labels_negative = tf.placeholder(tf.float32, shape=[BATCH_SIZE])
tf.summary.image('input_image', train_anchor_data, 10)
train_data = tf.concat(
[train_anchor_data, train_positive_data, train_negative_data],
axis=0)
pre_logits1 = model.NetworkModel(train_data, keep_prob=0.80)
# pre_logits2 = model.NetworkModel(train_positive_data, keep_prob=0.80, reuse=True)
# pre_logits3 = model.NetworkModel(train_negative_data, keep_prob=0.80, reuse=True)
pre_logits1 = tf.nn.l2_normalize(pre_logits1,
1,
1e-10,
name='embeddings')
# pre_logits2 = tf.nn.l2_normalize(pre_logits2, 1, 1e-10, name='embeddings')
# pre_logits3 = tf.nn.l2_normalize(pre_logits3, 1, 1e-10, name='embeddings')
# print(logits.get_shape().as_list())
vgg_train_anchor, vgg_train_positive, vgg_train_negative = tf.unstack(
tf.reshape(pre_logits1, [-1, 3, 256]), 3, 1)
loss, positives, negatives = utils.compute_triplet_loss(
vgg_train_anchor, vgg_train_positive, vgg_train_negative, Margin)
regularizer_losses = tf.add_n(tf.get_collection("losses"))
total_loss = loss + regularizer_losses
# print(total_loss)
# num_batches_per_epoch = int(data_num / BATCH_SIZE * 3)
# num_steps_per_epoch = num_batches_per_epoch # Because one step is one batch processed
# decay_steps = int(2 * num_steps_per_epoch)
global_step = tf.Variable(tf.constant(0, dtype=tf.int64))
lr = tf.train.exponential_decay(learning_rate=0.001,
global_step=global_step,
decay_steps=data_num // BATCH_SIZE,
decay_rate=0.96,
staircase=True)
train_op = tf.train.GradientDescentOptimizer(
learning_rate=lr).minimize(total_loss, global_step=global_step)
Saver = tf.train.Saver()
tf.summary.scalar('total_loss', total_loss)
tf.summary.scalar('loss', loss)
tf.summary.scalar('learning_rate', lr)
tf.summary.scalar('positives', positives)
tf.summary.scalar('negatives', negatives)
# tf.summary.scalar('pos', pos)
# tf.summary.scalar('neg', neg)
merged = tf.summary.merge_all()
data, labels = data_process.input_data()
print(data.shape)
print(labels.shape)
dataShufflu = DataShuffle(data, labels)
with tf.Session() as sess:
train_write = tf.summary.FileWriter(
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/',
sess.graph)
sess.run(tf.global_variables_initializer())
# Saver.restore(sess, '/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/')
for step in range(ITERATION):
batch_anchor, batch_positive, batch_negative, batch_labels_anchor, batch_labels_positive,\
batch_labels_negative = dataShufflu.get_triplet(n_labels=30, n_triplet=BATCH_SIZE)
feed_dict = {
train_anchor_data: batch_anchor,
train_positive_data: batch_positive,
train_negative_data: batch_negative
# labels_anchor: batch_labels_anchor,
# labels_positive: batch_labels_positive,
# labels_negative: batch_labels_negative
}
_, l, summary, Loss = sess.run(
[train_op, total_loss, merged, loss], feed_dict=feed_dict)
print("%d the %s train reslut" %
(step, datetime.datetime.now()))
print('the triplet loss %g' % Loss)
# print('the triplet total loss %g' % l)
train_write.add_summary(summary, step)
if step % 200 == 0:
Saver.save(
sess,
'/home/lenovo/yql/pig_data/triplet_model/logs_tensorboard2/'
)
train_write.close()
def main(argv=None):
train_samples = tf.placeholder(tf.float32, [None, IMAGE_SIZE * IMAGE_SIZE * IMAGE_CHANNLES], name='train_sample')
raw_samples = tf.placeholder(tf.float32, [None, IMAGE_SIZE * IMAGE_SIZE * IMAGE_CHANNLES], name='raw_sample')
train_labels = tf.placeholder(tf.float32, [None, CLASS_COUNTS], name='train_label')
raw_labels = tf.placeholder(tf.float32, [None, 2], name='raw_label')
grad_scale = tf.placeholder(tf.float32, name='grad_scale')
keep_prob = tf.placeholder(tf.float32, [], name='keep_probability')
train_feature1 = subnet1(train_samples)
clas1_train_feature1_logits = classifier1(train_feature1, keep_prob)
raw_feature1 = subnet1(raw_samples, reuse=True)
dom1_raw_feature1_logits = Domain1(raw_feature1, grad_scale, keep_prob)
##WGANs loss function about discriminator model
# d_var = [var for var in tf.trainable_variables() if var.name.startswith('Discriminator1')]
# disc_extr1_loss = -1.0 * tf.reduce_mean(disc1_train_feature1_logits)
# disc_extr2_loss = -1.0 * tf.reduce_mean(disc1_train_feature2_logits)
# disc_loss = -1.0 * (tf.reduce_mean(disc1_train_feature1_logits) - tf.reduce_mean(disc1_train_feature2_logits))
# d_clip = [v.assign(tf.clip_by_value(v, -0.01, 0.01)) for v in d_var]
clas1_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=train_labels, logits=clas1_train_feature1_logits))
dom1_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=raw_labels, logits=dom1_raw_feature1_logits))
clas1_acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(train_labels, 1),
tf.argmax(clas1_train_feature1_logits, 1)), tf.float32), name='clas1_acc')
classifier1_loss = clas1_loss + dom1_loss
classifier1_op = tf.train.AdamOptimizer(0.0002).minimize(classifier1_loss)
train_data, train_label, t_test, t_label, raw_data, raw_label = data_process.input_data()
print(np.shape(t_test))
print(np.shape(t_label))
Saver = tf.train.Saver()
with tf.Session() as sess:
train_writer = tf.summary.FileWriter('./checkpoint/', sess.graph)
sess.run(tf.global_variables_initializer())
# Saver.restore(sess, './checkpoint/')
print('Initialized!')
for step in range(int(RAW_NUM * EPOCH) // BATCH_SIZE):
print('begin path classifier train')
train_offset = (step * BATCH_SIZE) % (TRAIN_NUM - BATCH_SIZE)
batch_data = train_data[train_offset:(train_offset + BATCH_SIZE), :]
batch_label = train_label[train_offset:(train_offset + BATCH_SIZE), :]
raw_offset = (step * BATCH_SIZE) % (RAW_NUM - BATCH_SIZE)
raw_batch_data = raw_data[raw_offset:(raw_offset + BATCH_SIZE), :]
raw_batch_label = raw_label[raw_offset:(raw_offset + BATCH_SIZE), :]
feed_dict = {train_samples: batch_data, train_labels: batch_label,
raw_samples: raw_batch_data, raw_labels: raw_batch_label, grad_scale: -1.0, keep_prob: 0.85}
# sess.run(d_clip)
_, Clas1_loss = sess.run([classifier1_op, classifier1_loss], feed_dict=feed_dict)
Clas1_acc, Clas2_acc = sess.run([clas1_acc], feed_dict=feed_dict)
print("%d the %s train reslut" % (step, datetime.datetime.now()))
print('the classifier one loss %g' % Clas1_loss)
print('the classifier1 accuracy is %g, the classifier2 accuracy is %g' % (Clas1_acc, Clas2_acc))
if step % 500 == 0:
Saver.save(sess, './checkpoint/')
def train_neural_network(continune_train=False):
if continune_train is False: # 训练
global_step = tf.Variable(0)
global f
learning_rate = tf.train.exponential_decay(0.0001,
global_step,
decay_steps=500,
decay_rate=0.98,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
epochs = 10001
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
saver = tf.train.Saver()
for epoch in range(epochs):
global_step = epoch
epoch_loss = 0
for _ in range(int(f.train_num / batch_size) + 1):
epoch_x, epoch_y = f.get_train_data()
_, c = sess.run([optimizer, cost],
feed_dict={
x: epoch_x,
y: epoch_y
})
epoch_loss += c
# print epoch_loss
print('Epoch', epoch, 'completed out of', epochs, 'loss:',
epoch_loss)
if epoch % 2000 == 0:
saver.save(sess, 'model2/dnn_' + str(epoch) + '.ckpt',
global_step)
if epoch % 500 == 0:
all_acc = 0
all_acc = accuracy.eval(
{
x: f.get_test_data()[0],
y: f.get_test_data()[1]
},
session=sess)
print "all accuracy=" + str(all_acc)
else:
with tf.Session() as sess:
global_step = tf.Variable(2000)
learning_rate = tf.train.exponential_decay(0.0001,
global_step,
decay_steps=1000,
decay_rate=0.9,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
epochs = 10001
saver = tf.train.Saver()
saver.restore(sess, 'model2/dnn_2000.ckpt-2000') # 恢复保存的模型,继续训练
f = dt.input_data()
for epoch in range(0, epochs):
global_step = epoch
epoch_loss = 0
for _ in range(int(f.train_num / batch_size) + 1):
epoch_x, epoch_y = f.get_train_data()
_, c = sess.run([optimizer, cost],
feed_dict={
x: epoch_x,
y: epoch_y
})
epoch_loss += c
# print epoch_loss
print('Epoch', epoch, 'completed out of', epochs, 'loss:',
epoch_loss)
if epoch % 1000 == 0:
saver.save(sess, 'model2/dnn_' + str(epoch) + '.ckpt',
global_step)
if epoch % 500 == 0:
all_acc = 0
all_acc = accuracy.eval(
{
x: f.get_test_data()[0],
y: f.get_test_data()[1]
},
session=sess)
print "all accuracy=" + str(all_acc)
# -*- coding: UTF-8 -*-
import tensorflow as tf
import numpy as np
import data_process as dt
'''
yxr 4/18/2018
'''
batch_size = 128
# input*data*weights + biases
f = dt.input_data()
def neural_network_model(data, activation, hiddenLayerNodes): # 模型主体
# data输入数据,
# activition激活函数，
# hiddenLayerNodes每层节点数，如[3,10,10], 注意第一个数为输入层，宽为3
a = data
z = 0
for i in range(len(hiddenLayerNodes) - 1): # 前馈传递，通过每个隐含层
z = tf.add(
tf.matmul(
a,
tf.Variable(
tf.random_normal(
[hiddenLayerNodes[i], hiddenLayerNodes[i + 1]],
mean=0))),
tf.Variable(tf.random_normal([hiddenLayerNodes[i + 1]])))
a = activation(z) # rectified
softMax_layer = {