def run_second_net(): cifar = CifarDataManager() x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) rate = tf.placeholder(tf.float32) C1, C2, C3, = 32, 64, 128 F1 = 600 conv1_1 = conv_layer(x, shape=[3, 3, 3, C1]) conv1_2 = conv_layer(conv1_1, shape=[3, 3, C1, C1]) conv1_3 = conv_layer(conv1_2, shape=[3, 3, C1, C1]) conv1_pool = max_pool_2x2(conv1_3) conv1_drop = tf.nn.dropout(conv1_pool, rate=rate) conv2_1 = conv_layer(conv1_drop, shape=[3, 3, C1, C2]) conv2_2 = conv_layer(conv2_1, shape=[3, 3, C2, C2]) conv2_3 = conv_layer(conv2_2, shape=[3, 3, C2, C2]) conv2_pool = max_pool_2x2(conv2_3) conv2_drop = tf.nn.dropout(conv2_pool, rate=rate) conv3_1 = conv_layer(conv2_drop, shape=[3, 3, C2, C3]) conv3_2 = conv_layer(conv3_1, shape=[3, 3, C3, C3]) conv3_3 = conv_layer(conv3_2, shape=[3, 3, C3, C3]) conv3_pool = tf.nn.max_pool(conv3_3, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME') conv3_flat = tf.reshape(conv3_pool, [-1, C3]) conv3_drop = tf.nn.dropout(conv3_flat, rate=rate) full1 = tf.nn.relu(full_layer(conv3_drop, F1)) full1_drop = tf.nn.dropout(full1, rate=rate) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(5e-4).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy =tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([sess.run(accuracy, feed_dict={x: X[i], y_: Y[i], rate: 0.0}) for i in range(10)]) print(f'Accuracy {acc * 100}') with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): batch = cifar.train.next_batch(BATCH_SIZE) sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], rate: 0.5}) if i % 50 == 0: test(sess) test(sess)
def run_simple_net(): cifar = CifarDataManager() x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) conv1 = conv_layer(x, shape=[5, 5, 3, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv3 = conv_layer(conv2_pool, shape=[5, 5, 64, 128]) conv3_pool = max_pool_2x2(conv3) conv3_flat = tf.reshape(conv3_pool, [-1, 4 * 4 * 128]) conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) full_1 = tf.nn.relu(full_layer(conv3_flat, 512)) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(1e-3).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([ sess.run(accuracy, feed_dict={ x: X[i], y_: Y[i], keep_prob: 1.0 }) for i in range(10) ]) print("Accuracy: {:.4}%".format(acc * 100)) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): batch = cifar.train.next_batch(BATCH_SIZE) sess.run(train_step, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) if i % 500 == 0: test(sess) test(sess)
def run_simple_net(bs, lr): # load the data cifar = CifarDataManager() # init variables x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) # 2 conv and 1 max pooling conv1 = conv_layer(x, shape=[3, 3, 3, 64]) conv2 = conv_layer(conv1, shape=[3, 3, 64, 64]) conv2_pool = max_pool_2x2(conv2) # 2 conv and 1 max pooling conv3 = conv_layer(conv2_pool, shape=[3, 3, 64, 128]) conv4 = conv_layer(conv3, shape=[3, 3, 128, 128]) conv4_pool = max_pool_2x2(conv4) # flatten and drop to prevent overfitting conv4_flat = tf.reshape(conv4_pool, [-1, 8 * 8 * 128]) conv4_drop = tf.nn.dropout(conv4_flat, keep_prob=keep_prob) # fully connected nn using relu as activation function full_0 = tf.nn.relu(full_layer(conv4_drop, 512)) full0_drop = tf.nn.dropout(full_0, keep_prob=keep_prob) full_1 = tf.nn.relu(full_layer(full0_drop, 512)) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) # loss function cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) # original: train_step = tf.train.AdamOptimizer(lr).minimize(cross_entropy) # for the table train_step = tf.train.AdamOptimizer(lr).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([sess.run(accuracy, feed_dict={x: X[i], y_: Y[i], keep_prob: 1.0}) for i in range(10)]) print("Accuracy: {:.4}%".format(acc * 100)) return acc*100 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): batch = cifar.train.next_batch(bs) sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) '''if i % 500 == 0: # print(i//500) test(sess)''' result = test(sess) return result
def get_y_predict(x, keep_prob): conv1 = conv_layer(x, shape=[3, 3, 3, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[3, 3, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv2_flat = tf.reshape(conv2_pool, [-1, 8 * 8 * 64]) full_1 = tf.nn.relu(full_layer(conv2_flat, 1024)) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_predict = full_layer(full1_drop, 10) return y_predict
def run_simple_net(): cifar = CifarDataManager() x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) conv1 = conv_layer(x, shape=[5, 5, 3, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv3 = conv_layer(conv2_pool, shape=[5, 5, 64, 128]) conv3_pool = max_pool_2x2(conv3) conv3_flat = tf.reshape(conv3_pool, [-1, 4 * 4 * 128]) conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) full_1 = tf.nn.relu(full_layer(conv3_drop, 512)) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(1e-3).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([sess.run(accuracy, feed_dict={x: X[i], y_: Y[i], keep_prob: 1.0}) for i in range(10)]) print("Accuracy: {:.4}%".format(acc * 100)) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): batch = cifar.train.next_batch(BATCH_SIZE) sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) if i % 500 == 0: test(sess) test(sess)
def create_graph(self): # TODO: get_Variable 써보기? x = tf.placeholder(tf.float32, shape=[None, 28, 28, 1]) conv1 = conv_layer(x, shape=[5, 5, 1, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv2_flat = tf.reshape(conv2_pool, [-1, 7 * 7 * 64]) full_1 = tf.nn.relu(full_layer(conv2_flat, 1024)) keep_prob = tf.placeholder(tf.float32) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) return x, keep_prob, y_conv
def create_graph(self): # TODO: get_Variable 써보기? x = tf.placeholder(tf.float32, shape=[None, 28, 28, 1]) conv1 = conv_layer(x, shape=[5, 5, 1, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv2_flat = tf.reshape(conv2_pool, [-1, 7 * 7 * 64]) full_1 = tf.nn.relu(full_layer(conv2_flat, 1024)) keep_prob = tf.placeholder(tf.float32) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) return x, keep_prob, y_conv
def build_second_net(): x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) C1, C2, C3 = 32, 64, 128 F1 = 600 conv1_1 = conv_layer(x, shape=[3, 3, 3, C1]) conv1_2 = conv_layer(conv1_1, shape=[3, 3, C1, C1]) conv1_3 = conv_layer(conv1_2, shape=[3, 3, C1, C1]) conv1_pool = max_pool_2x2(conv1_3) conv1_drop = tf.nn.dropout(conv1_pool, keep_prob=keep_prob) conv2_1 = conv_layer(conv1_drop, shape=[3, 3, C1, C2]) conv2_2 = conv_layer(conv2_1, shape=[3, 3, C2, C2]) conv2_3 = conv_layer(conv2_2, shape=[3, 3, C2, C2]) conv2_pool = max_pool_2x2(conv2_3) conv2_drop = tf.nn.dropout(conv2_pool, keep_prob=keep_prob) conv3_1 = conv_layer(conv2_drop, shape=[3, 3, C2, C3]) conv3_2 = conv_layer(conv3_1, shape=[3, 3, C3, C3]) conv3_3 = conv_layer(conv3_2, shape=[3, 3, C3, C3]) conv3_pool = tf.nn.max_pool(conv3_3, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME') conv3_flat = tf.reshape(conv3_pool, [-1, C3]) conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) full1 = tf.nn.relu(full_layer(conv3_drop, F1)) full1_drop = tf.nn.dropout(full1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(5e-4).minimize(cross_entropy) # noqa correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # noqa
def build_second_net(): x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) C1, C2, C3 = 32, 64, 128 F1 = 600 conv1_1 = conv_layer(x, shape=[3, 3, 3, C1]) conv1_2 = conv_layer(conv1_1, shape=[3, 3, C1, C1]) conv1_3 = conv_layer(conv1_2, shape=[3, 3, C1, C1]) conv1_pool = max_pool_2x2(conv1_3) conv1_drop = tf.nn.dropout(conv1_pool, keep_prob=keep_prob) conv2_1 = conv_layer(conv1_drop, shape=[3, 3, C1, C2]) conv2_2 = conv_layer(conv2_1, shape=[3, 3, C2, C2]) conv2_3 = conv_layer(conv2_2, shape=[3, 3, C2, C2]) conv2_pool = max_pool_2x2(conv2_3) conv2_drop = tf.nn.dropout(conv2_pool, keep_prob=keep_prob) conv3_1 = conv_layer(conv2_drop, shape=[3, 3, C2, C3]) conv3_2 = conv_layer(conv3_1, shape=[3, 3, C3, C3]) conv3_3 = conv_layer(conv3_2, shape=[3, 3, C3, C3]) conv3_pool = tf.nn.max_pool(conv3_3, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME') conv3_flat = tf.reshape(conv3_pool, [-1, C3]) conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) full1 = tf.nn.relu(full_layer(conv3_drop, F1)) full1_drop = tf.nn.dropout(full1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(5e-4).minimize(cross_entropy) # noqa correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # noqa
def run_simple_net(): dataset = DeepSatData() x = tf.placeholder(tf.float32, shape=[None, 28, 28, 4]) y_ = tf.placeholder(tf.float32, shape=[None, 6]) keep_prob = tf.placeholder(tf.float32) conv1 = conv_layer(x, shape=[3, 3, 4, 16], pad='SAME') conv1_pool = max_pool_2x2(conv1, 2, 2) #28x28x4->14x14x16 conv2 = conv_layer(conv1_pool, shape=[3, 3, 16, 32], pad='SAME') conv2_pool = max_pool_2x2(conv2, 2, 2) #14x14x16->7x7x32 conv3 = conv_layer(conv2_pool, shape=[3, 3, 32, 64], pad='SAME') # conv3_pool = max_pool_2x2(conv3) # 7x7x32 ->7x7x64 conv4 = conv_layer(conv3, shape=[3, 3, 64, 96], pad='SAME') # conv4_pool = max_pool_2x2(conv4) # 7x7x64 -> 7x7x96 conv5 = conv_layer(conv4, shape=[3, 3, 96, 64], pad='SAME') #conv5_pool = max_pool_2x2(conv5, 2, 2) # 7x7x96 ->7x7x64 _flat = tf.reshape(conv5, [-1, 7 * 7 * 64]) _drop1 = tf.nn.dropout(_flat, keep_prob=keep_prob) # full_1 = tf.nn.relu(full_layer(_drop1, 200)) full_1 = tf.nn.relu(full_layer(_drop1, 512)) # -- until here # classifier:add(nn.Threshold(0, 1e-6)) _drop2 = tf.nn.dropout(full_1, keep_prob=keep_prob) full_2 = tf.nn.relu(full_layer(_drop2, 256)) # classifier:add(nn.Threshold(0, 1e-6)) full_3 = full_layer(full_2, 6) predict = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=full_3, labels=y_)) train_step = tf.train.RMSPropOptimizer(lr, decay, momentum).minimize(predict) # train_step = tf.train.AdamOptimizer(lr) correct_prediction = tf.equal(tf.argmax(full_3, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # TENSORBOARD tf.summary.scalar('loss', predict) tf.summary.scalar('accuracy', accuracy) merged_sum = tf.summary.merge_all() def test(sess): X = dataset.test.images.reshape(10, NUM_TEST_SAMPLES, 28, 28, 4) Y = dataset.test.labels.reshape(10, NUM_TEST_SAMPLES, 6) acc = np.mean([ sess.run(accuracy, feed_dict={ x: X[i], y_: Y[i], keep_prob: 1.0 }) for i in range(10) ]) return acc with tf.Session() as sess: sess.run(tf.global_variables_initializer()) sum_writer = tf.summary.FileWriter('logs/' + 'v2_sat6') sum_writer.add_graph(sess.graph) for i in range(STEPS): batch = dataset.train.random_batch(BATCH_SIZE) #batch = dataset.train.next_batch(BATCH_SIZE) batch_x = batch[0] batch_y = batch[1] _, summ = sess.run([train_step, merged_sum], feed_dict={ x: batch_x, y_: batch_y, keep_prob: 0.5 }) sum_writer.add_summary(summ, i) sess.run(train_step, feed_dict={ x: batch_x, y_: batch_y, keep_prob: dropoutProb }) if i % ONE_EPOCH == 0: print("\n*****************EPOCH: %d" % (i / ONE_EPOCH)) if i % TEST_INTERVAL == 0: acc = test(sess) loss = sess.run(predict, feed_dict={ x: batch_x, y_: batch_y, keep_prob: dropoutProb }) print("EPOCH:%d" % (i / ONE_EPOCH) + " Step:" + str(i) + "|| Minibatch Loss= " + "{:.4f}".format(loss) + " Accuracy: {:.4}%".format(acc * 100)) test(sess) sum_writer.close()
def build_second_net(): cifar = CifarDataManager() print('in build_second_net 111') x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) C1, C2, C3 = 32, 64, 128 F1 = 600 conv1_1 = conv_layer(x, shape=[3, 3, 3, C1]) conv1_2 = conv_layer(conv1_1, shape=[3, 3, C1, C1]) conv1_3 = conv_layer(conv1_2, shape=[3, 3, C1, C1]) conv1_pool = max_pool_2x2(conv1_3) conv1_drop = tf.nn.dropout(conv1_pool, keep_prob=keep_prob) print('in build_second_net 222') conv2_1 = conv_layer(conv1_drop, shape=[3, 3, C1, C2]) conv2_2 = conv_layer(conv2_1, shape=[3, 3, C2, C2]) conv2_3 = conv_layer(conv2_2, shape=[3, 3, C2, C2]) conv2_pool = max_pool_2x2(conv2_3) conv2_drop = tf.nn.dropout(conv2_pool, keep_prob=keep_prob) print('in build_second_net 333') conv3_1 = conv_layer(conv2_drop, shape=[3, 3, C2, C3]) conv3_2 = conv_layer(conv3_1, shape=[3, 3, C3, C3]) conv3_3 = conv_layer(conv3_2, shape=[3, 3, C3, C3]) conv3_pool = tf.nn.max_pool(conv3_3, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME') conv3_flat = tf.reshape(conv3_pool, [-1, C3]) conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) full1 = tf.nn.relu(full_layer(conv3_drop, F1)) full1_drop = tf.nn.dropout(full1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(5e-4).minimize(cross_entropy) # noqa correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # noqa # Plug this into the test procedure as above to continue... def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([ sess.run(accuracy, feed_dict={ x: X[i], y_: Y[i], keep_prob: 1.0 }) for i in range(10) ]) #print("Accuracy: {:.4}%".format(acc * 100)) return acc print('get into run_simple_net 333') iter_list, test_accuracy_list, train_accuracy_list = [], [], [] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): #print('i is ', i) #batch = cifar.train.next_batch(BATCH_SIZE) batch = cifar.train.random_batch(BATCH_SIZE) sess.run(train_step, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) if i % 500 == 0 or i == STEPS - 1: iter_list.append(i) train_acc = sess.run(accuracy, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) train_accuracy_list.append(train_acc) test_acc = test(sess) test_accuracy_list.append(test_acc) print( 'step i:{0:7} train_acc: {1:.6f} test_acc: {2:.6f}'.format( i, train_acc, test_acc)) test(sess) plot_accuracy(iter_list, test_accuracy_list, train_accuracy_list)
def run_simple_net(): print('get into run_simple_net') cifar = CifarDataManager() x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) conv1 = conv_layer(x, shape=[5, 5, 3, 32]) conv1_pool = max_pool_2x2(conv1) print('get into run_simple_net 111') conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) # conv3 = conv_layer(conv2_pool, shape=[5, 5, 64, 128]) conv3 = conv_layer(conv2_pool, shape=[5, 5, 64, 100]) conv3_pool = max_pool_2x2(conv3) conv4 = conv_layer(conv3_pool, shape=[5, 5, 100, 256]) conv4_pool = max_pool_2x2(conv4) print('conv4_pool.get_shape() is ', conv4_pool.get_shape()) #conv4_flat = tf.reshape(conv4_pool, [-1, 4 * 4 * 256]) conv4_flat = tf.reshape(conv4_pool, [-1, 2 * 2 * 256]) conv4_drop = tf.nn.dropout(conv4_flat, keep_prob=keep_prob) print('get into run_simple_net 222') full_1 = tf.nn.relu(full_layer(conv4_drop, 512)) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(1e-3).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([ sess.run(accuracy, feed_dict={ x: X[i], y_: Y[i], keep_prob: 1.0 }) for i in range(10) ]) #print("test accuracy: {:.4}%".format(acc * 100)) return acc print('get into run_simple_net 333') iter_list, test_accuracy_list, train_accuracy_list = [], [], [] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): #batch = cifar.train.next_batch(BATCH_SIZE) batch = cifar.train.random_batch(BATCH_SIZE) sess.run(train_step, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) if i % 500 == 0: iter_list.append(i) train_acc = np.mean([ sess.run(accuracy, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 }) for i in range(10) ]) train_accuracy_list.append(train_acc) test_acc = test(sess) test_accuracy_list.append(test_acc) print( 'step i:{0:6} train_acc: {1:.6f} test_acc: {2:.6f}'.format( i, train_acc, test_acc)) test(sess) plot_accuracy(iter_list, test_accuracy_list, train_accuracy_list)
def buildModel(): x = tf.placeholder(tf.float32, shape=[None, 784]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) x_image = tf.reshape(x, [-1, 28, 28, 1]) conv1 = conv_layer(x_image, shape=[5, 5, 1, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv2_flat = tf.reshape(conv2_pool, [-1, 7 * 7 * 64]) full_1 = tf.nn.relu(full_layer(conv2_flat, 1024)) keep_prob = tf.placeholder(tf.float32) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) y_predict = y_conv # y_predict = tf.Print(y_conv, [y_conv, tf.shape(y_conv)], "the result is: ", summarize=50) cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_predict, labels=y_)) train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_predict, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('cross_entropy', cross_entropy) tf.summary.scalar('accuracy', accuracy) # y_predict = tf.Print(y_conv, [y_conv], "this is result: ", summarize=10) start = tf.Variable(0, name="start", dtype=tf.int32) saver = tf.train.Saver() merged = tf.summary.merge_all() # draw graph on tensorboard # with tf.Session() as sess: # tf.summary.FileWriter("./draft", sess.graph); # return bool type tensor # tf.argmax: return index of maximun value in a tenso batchSize = 100 # chkp.print_tensors_in_checkpoint_file("./checkpoint/model.ckpt", tensor_name='start', all_tensors=False) with tf.Session() as sess: train_writer = tf.summary.FileWriter('./draft', sess.graph) if os.path.isdir('./checkpoint'): saver.restore(sess, "./checkpoint/model.ckpt") else: sess.run(tf.global_variables_initializer()) for i in range(start.eval() + 1, int(60000 / batchSize)): x_train, y_train = next_batch(batchSize, i + 1) update_start = start.assign(i) batch = sess.run([x_train, y_train]) if (i + 1) % 10 == 0: sess.run(update_start) summary, train_accuracy = sess.run([merged, accuracy], feed_dict={ x: batch[0], y_: batch[1], keep_prob: 1.0 }) print("step {}, training accuracy {}".format( int((i + 1) / 10), train_accuracy)) train_writer.add_summary(summary, i) saver.save(sess, "./checkpoint/model.ckpt") sess.run(train_step, feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 })
def run_simple_net(): # 图像输入数据 cifar = CifarDataManager() # 定义输入图像占位符 x = tf.placeholder(tf.float32, shape=[None, 32, 32, 3]) # 定义正确的分类标签占位符 y_ = tf.placeholder(tf.float32, shape=[None, 10]) keep_prob = tf.placeholder(tf.float32) # 第一层卷积操作 conv1 = conv_layer(x, shape=[5, 5, 3, 32]) # 将结果池化 conv1_pool = max_pool_2x2(conv1) # 第二层卷积操作 conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) # 将结果池化 conv2_pool = max_pool_2x2(conv2) # 第三层卷积操作 conv3 = conv_layer(conv2_pool, shape=[5, 5, 64, 128]) # 将结果池化 conv3_pool = max_pool_2x2(conv3) # 将图像数据平整为一维向量形式 conv3_flat = tf.reshape(conv3_pool, [-1, 4 * 4 * 128]) # 进行随机丢弃操作 conv3_drop = tf.nn.dropout(conv3_flat, keep_prob=keep_prob) # 进行全连接操作 full_1 = tf.nn.relu(full_layer(conv3_drop, 512)) # 进行随机丢弃操作 full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) # 得到训练结果 y_conv = full_layer(full1_drop, 10) # 定义损失函数 # 使用交叉熵作为损失函数 cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) # 使用梯度下降法定义训练过程 train_step = tf.train.AdamOptimizer(1e-3).minimize(cross_entropy) # 定义评估步骤,用来测试模型的准确率 correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) def test(sess): X = cifar.test.images.reshape(10, 1000, 32, 32, 3) Y = cifar.test.labels.reshape(10, 1000, 10) acc = np.mean([sess.run(accuracy, feed_dict={x: X[i], y_: Y[i], keep_prob: 1.0}) for i in range(10)]) print("Accuracy: {:.4}%".format(acc * 100)) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(STEPS): batch = cifar.train.next_batch(BATCH_SIZE) # 开始训练 sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) if i % 500 == 0: test(sess) test(sess)
from layers import conv_layer, max_pool_2x2, full_layer DATA_DIR = '/tmp/data' MINIBATCH_SIZE = 50 STEPS = 5000 mnist = input_data.read_data_sets(DATA_DIR, one_hot=True) x = tf.placeholder(tf.float32, shape=[None, 784]) y_ = tf.placeholder(tf.float32, shape=[None, 10]) x_image = tf.reshape(x, [-1, 28, 28, 1]) conv1 = conv_layer(x_image, shape=[5, 5, 1, 32]) conv1_pool = max_pool_2x2(conv1) conv2 = conv_layer(conv1_pool, shape=[5, 5, 32, 64]) conv2_pool = max_pool_2x2(conv2) conv2_flat = tf.reshape(conv2_pool, [-1, 7*7*64]) full_1 = tf.nn.relu(full_layer(conv2_flat, 1024)) keep_prob = tf.placeholder(tf.float32) full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob) y_conv = full_layer(full1_drop, 10) cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_)) train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
# initialise DataGetter object test_img = DataGetter(test_path, Gray) train_img = DataGetter(train_path, Gray) val_img = DataGetter(val_path, Gray) ######################################################################################################################## # tensorflow network architecture ######################################################################################################################## # placeholder for images and labels x = tf.placeholder(tf.float32, shape=[None, PIXEL, PIXEL, COLOR]) y_ = tf.placeholder(tf.float32, shape=[None, len(position_dict)]) # 1 convolution layer with max pooling conv1 = conv_layer(x, shape=[CONV, CONV, COLOR, CONV1_DEPTH]) conv1_pool = max_pool_2x2(conv1) # 2 convolution layer with max pooling conv2 = conv_layer(conv1_pool, shape=[CONV, CONV, CONV1_DEPTH, CONV1_DEPTH * 2]) conv2_pool = max_pool_2x2(conv2) new_size = int(PIXEL / 4 * PIXEL / 4 * CONV1_DEPTH * 2) if PIXEL % 2 is not 0: logger.warning('potential issue with the pixel size') # fully connected flatt layer conv3_flat = tf.reshape(conv2_pool, [-1, new_size]) full_1 = tf.nn.relu(full_layer(conv3_flat, 1024))
def inference(x): #conv layer 1 with tf.name_scope('conv1') as scope: w = layers.xavier_weights_variable([3, 3, 3, 128]) b = layers.bias_variable([128]) conv1 = tf.nn.relu(layers.conv2d(x, w) + b, name="activations") #conv layer 2 with tf.name_scope('conv2') as scope: w = layers.xavier_weights_variable([3, 3, 128, 128]) b = layers.bias_variable([128]) conv2 = tf.nn.relu(layers.conv2d(conv1, w) + b, name="activations") #maxpool1, images now 32x32 with tf.name_scope('pool1') as scope: pool1 = layers.max_pool_2x2(conv2) #conv layer 3 with tf.name_scope('conv3') as scope: w = layers.xavier_weights_variable([3, 3, 128, 128]) b = layers.bias_variable([128]) conv3 = layers.tf.nn.relu(layers.conv2d(pool1, w) + b, name="activations") #conv layer 4 with tf.name_scope('conv4') as scope: w = layers.xavier_weights_variable([3, 3, 128, 128]) b = layers.bias_variable([128]) conv4 = tf.nn.relu(layers.conv2d(conv3, w) + b, name="activations") #maxpool2, images now 16x16 with tf.name_scope('pool2') as scope: pool2 = layers.max_pool_2x2(conv4) #conv layer 5 with tf.name_scope('conv5') as scope: w = layers.xavier_weights_variable([3, 3, 128, 128]) b = layers.bias_variable([128]) conv5 = tf.nn.relu(layers.conv2d(pool2, w) + b, name="activations") #maxpool3, imags now 8x8 with tf.name_scope('pool3') as scope: pool3 = layers.max_pool_2x2(conv5) #fully connected layer 1 with tf.name_scope('fully_connected1') as scope: w = layers.xavier_weights_variable([8 * 8 * 128, 400]) b = layers.bias_variable([400]) pool3_flat = tf.reshape(pool3, [-1, 8 * 8 * 128]) fully_connected1 = tf.nn.relu(tf.matmul(pool3_flat, w) + b, name="activations") #fully connected layer 2 with tf.name_scope('fully_connected2') as scope: w = layers.xavier_weights_variable([400, 400]) b = layers.bias_variable([400]) fully_connected2 = tf.nn.relu(tf.matmul(fully_connected1, w) + b, name="activations") #fully connected layer 3 with tf.name_scope('fully_connected3') as scope: w = layers.xavier_weights_variable([400, 200]) b = layers.bias_variable([200]) y_pred = tf.matmul(fully_connected2, w) + b return y_pred