def train_model(image_path, learning_rate=0.001, num_epoch=100, batch_size=5): X_train = np.load(image_path + ".npy") Y_train = np.load(image_path + ".npy") X_train = X_train / 255 #Creating one-hot for label print(Y_train.shape) print(Y_train[0][1]) Y_train = convert_to_one_hot(Y_train, 10).T n_Y = Y_train.shape[1] x = tf.placeholder(tf.float32, [None, 227, 227, 3]) Y = tf.placeholder(tf.float32, [None, n_Y]) keep_prob = tf.placeholder(tf.float32) model = AlexNet(x, keep_prob, 10, []) score = model.fc8 cost = tf.reduce_mean( (tf.nn.softmax_cross_entropy_with_logits_v2(logits=score, labels=Y))) softmax = tf.nn.softmax(score) costs = [] optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) init = tf.global_variables_initializer() [m, nH, nW, nCH] = X_train.shape seed = 0 #tf.reset_default_graph() with tf.Session() as sess: sess.run(init) sess.run(model.load_initial_weights(sess)) for i in range(num_epoch): minibatch_cost = 0 num_minibatch = int(m / batch_size) # number of batches seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, batch_size, seed) for minibatch in minibatches: X_batches, Y_batches = minibatch #Use cost and optimizer to run _, c = sess.run([optimizer, cost], { x: X_batches, Y: Y_batches, keep_prob: 1 }) minibatch_cost += c minibatch_cost = minibatch_cost / num_minibatch if i % 5 == 0: print("Cost===>" + str(c)) costs.append(c) plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('epoch') plt.title('learning_rate' + str(learning_rate)) plt.show()
def model(X_train,Y_train,X_test,Y_test,learning_rate = 0.009,num_epochs = 100,minibatch_size = 64 ,print_cost = True): ops.reset_default_graph()#能够重新运行模型而不覆盖tf变量 tf.set_random_seed(1)#确保数据一样 seed = 3 (m,n_H0,n_W0,n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] X,Y = create_placeholders(n_H0,n_W0,n_C0,n_y) parameters = initialize_parameters() Z3 = forward_propagation(X,parameters) cost = computer_cost(Z3,Y) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size)#获取数据库块的数量 seed = seed + 1 minibatches = cnn_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed) for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch _,temp_cost = sess.run([optimizer, cost], feed_dict={X:minibatch_X, Y:minibatch_Y}) minibatch_cost += temp_cost / num_minibatches if print_cost == True and epoch % 5 == 0: print('当前是第' + str(epoch) + '代,成本值为:' + str(minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iteration(per tens)') plt.title('Learning rate = ' + str(learning_rate)) plt.show() #####计算Accuracy predict_op = tf.arg_max(Z3,1)######1代表行,每行中最大数的位子,也就是one-hot中1的位置 corrent_prediction = tf.equal(predict_op,tf.arg_max(Y,1)) accuracy = tf.reduce_mean(tf.cast(corrent_prediction,'float')) print(accuracy) train_accuracy = accuracy.eval({X:X_train,Y:Y_train}) test_accuracy = accuracy.eval({X:X_test,Y:Y_test}) print('训练集的准确度:'+str(train_accuracy)) print('测试集的准确度:'+str(test_accuracy)) return (train_accuracy,test_accuracy,parameters)
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True, isPlot=True): """ 使用TensorFlow实现三层的卷积神经网络 CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED 参数: X_train - 训练数据,维度为(None, 64, 64, 3) Y_train - 训练数据对应的标签,维度为(None, n_y = 6) X_test - 测试数据,维度为(None, 64, 64, 3) Y_test - 训练数据对应的标签,维度为(None, n_y = 6) learning_rate - 学习率 num_epochs - 遍历整个数据集的次数 minibatch_size - 每个小批量数据块的大小 print_cost - 是否打印成本值,每遍历100次整个数据集打印一次 isPlot - 是否绘制图谱 返回: train_accuracy - 实数,训练集的准确度 test_accuracy - 实数,测试集的准确度 parameters - 学习后的参数 """ ops.reset_default_graph() #能够重新运行模型而不覆盖tf变量 tf.set_random_seed(1) #确保你的数据和我一样 seed = 3 #指定numpy的随机种子 (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] #为当前维度创建占位符 X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) #初始化参数 parameters = initialize_parameters() #前向传播 Z3 = forward_propagation(X, parameters) #计算成本 cost = compute_cost(Z3, Y) #反向传播,由于框架已经实现了反向传播,我们只需要选择一个优化器就行了 optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) #全局初始化所有变量 init = tf.global_variables_initializer() #开始运行 with tf.Session() as sess: #初始化参数 sess.run(init) #开始遍历数据集 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) #获取数据块的数量 seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) #对每个数据块进行处理 for minibatch in minibatches: #选择一个数据块 (minibatch_X, minibatch_Y) = minibatch #最小化这个数据块的成本 _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) #累加数据块的成本值 minibatch_cost += temp_cost / num_minibatches #是否打印成本 if print_cost: #每5代打印一次 if epoch % 5 == 0: print("当前是第 " + str(epoch) + " 代,成本值为:" + str(minibatch_cost)) #记录成本 if epoch % 1 == 0: costs.append(minibatch_cost) #数据处理完毕,绘制成本曲线 if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() #开始预测数据 ## 计算当前的预测情况 predict_op = tf.arg_max(Z3, 1) corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1)) ##计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float")) print("corrent_prediction accuracy= " + str(accuracy)) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuary = accuracy.eval({X: X_test, Y: Y_test}) print("训练集准确度:" + str(train_accuracy)) print("测试集准确度:" + str(test_accuary)) return (train_accuracy, test_accuary, parameters)
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True, isPlot=True): ops.reset_default_graph() tf.set_random_seed(1) seed = 3 (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # 为当前的维度创建占位符 X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) # 初始化参数 parameters = initialize_parameters() # 前向传播 Z3 = forward_propagation(X, parameters) # 计算陈本 cost = compute_cost(Z3, Y) # 反向传播,由于框架已经实现了反向传播,我们只需要选择一个优化器就可了 optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) # 全局初始化所有变量 init = tf.global_variables_initializer() # 开始运行 with tf.Session() as sess: # 初始化参数 sess.run(init) # 开始便利数据集 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) # 对每个数据块进行处理 for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch # 最小化这个数据化的成本(这里应该是进行一次梯度下降吧) _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches if print_cost: if epoch % 5 == 0: print("当前的成本为: ", epoch, "代,成本为:" + str(minibatch_cost)) if epoch % 5 == 0: costs.append(minibatch_cost) if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('daishu') plt.title("learning rate = " + str(learning_rate)) plt.show() # 开始预测数据 # 计算当前的预测情况 predict_op = tf.arg_max(Z3, 1) corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1)) # 计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float")) print("corrent_prediction accuracy= " + str(accuracy)) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("训练集准确度: " + str(train_accuracy)) print("测试集准确度: " + str(test_accuracy)) return (train_accuracy, test_accuracy, parameters)
def model(X_train, Y_train, X_test, Y_test, Y_train_labels, Y_test_labels, seg_size, weights, decay_learning_rate=False, base_learning_rate=0.0001, num_epochs=100, minibatch_size=16, print_cost=True): """ Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX. Arguments: X_train -- training set Y_train -- test set X_test -- training set Y_test -- test set learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: parameters -- parameters learnt by the model. They can then be used to predict. """ ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables (m, seg_size, n_C0) = (X_train.channels.shape) # calculating the learning rate type batch = tf.Variable(0, dtype=tf.float32) if decay_learning_rate is True: # Decay once per epoch, using an exponential schedule starting at 0.01. learning_rate = tf.train.exponential_decay( 0.01, # Base learning rate. batch * minibatch_size, # Current index into the dataset. m, # Decay step. 0.95, # Decay rate. staircase=True) else: # Decay once per epoch, using an exponential schedule starting at 0.01. learning_rate = tf.train.exponential_decay( base_learning_rate, # Base learning rate. batch * minibatch_size, # Current index into the dataset. m, # Decay step. 1.00, # Decay rate. staircase=True) n_y = num_classes costs = [] # variable for saving trip_id, uuid, segment_id fro test set predicted_label = np.zeros(Y_test.shape[0], dtype=[('uuid', 'S64'), ('trip_id', 'int8'), ('segment_id', 'int8'), ('class_label', 'int8')]) predicted_label = np.rec.array(predicted_label) predicted_label.uuid = Y_test.uuid predicted_label.trip_id = Y_test.trip_id predicted_label.segment_id = Y_test.segment_id # variable for saving trip_id, uuid, segment_id for train set predicted_label_train = np.zeros(Y_train.shape[0], dtype=[('uuid', 'S64'), ('trip_id', 'int8'), ('segment_id', 'int8'), ('class_label', 'int8')]) predicted_label_train = np.rec.array(predicted_label_train) predicted_label_train.uuid = Y_train.uuid predicted_label_train.trip_id = Y_train.trip_id predicted_label_train.segment_id = Y_train.segment_id # Create Placeholders of the correct shape X, Y, minibatch_weights = create_placeholders( seg_size, n_C0, n_y, minibatch_size=minibatch_size) # Initialize parameters parameters = initialize_parameters(weights) # Forward propagation: Build the forward propagation in the tensorflow graph final_Z = forward_propagation(X, parameters) # Cost function: Add cost function to tensorflow graph cost = compute_cost(final_Z, Y, minibatch_weights) # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer. optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize( cost, global_step=batch) # Initialize all the variables init = tf.global_variables_initializer() # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set minibatches, mini_batches_weights = random_mini_batches( X_train, Y_train, Y_train_labels, Y_test_labels, minibatch_size, class_weight_calculation=0) for index, minibatch in enumerate(minibatches): # Select a minibatch (minibatch_X, minibatch_Y) = minibatch class_weights = mini_batches_weights[index] # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). _, temp_cost = sess.run( [optimizer, cost], feed_dict={ X: minibatch_X.channels, Y: minibatch_Y.class_label, minibatch_weights: class_weights }) # _, temp_cost = sess.run(tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(compute_cost), # feed_dict={X: minibatch_X, Y: minibatch_Y, class_weights: class_weights}) minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) if minibatch_cost > costs[epoch - 1]: learning_rate = learning_rate * 0.95 # Calculate the correct predictions predict_op = tf.argmax(final_Z, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # finding the probabilities final_prob_train = (final_Z.eval({ X: X_train.channels, Y: Y_train.class_label })) final_prob_test = sess.run(final_Z, feed_dict={X: X_test.channels}) # finding the predicted labels predictions, labels_test = sess.run( [predict_op, tf.argmax(Y, 1)], feed_dict={ X: X_test.channels, Y: Y_test.class_label }) # predicted_label.class_label = predictions predictions_train = (predict_op.eval({ X: X_train.channels, Y: Y_train.class_label })) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) train_accuracy = accuracy.eval({ X: X_train.channels, Y: Y_train.class_label }) test_accuracy = accuracy.eval({ X: X_test.channels, Y: Y_test.class_label }) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) confusion = tf.confusion_matrix(labels=tf.argmax(Y, 1), predictions=predict_op, num_classes=num_classes) confusion_mat = confusion.eval({ Y: Y_test.class_label, X: X_test.channels }) print(confusion_mat) return parameters, test_accuracy, costs, predictions, predictions_train, final_prob_train, final_prob_test
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True, operation='save', predict=None): """ Implements a three-layer ConvNet in Tensorflow: CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED Arguments: X_train -- training set, of shape (None, 64, 64, 3) Y_train -- test set, of shape (None, n_y = 6) X_test -- training set, of shape (None, 64, 64, 3) Y_test -- test set, of shape (None, n_y = 6) learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: train_accuracy -- real number, accuracy on the train set (X_train) test_accuracy -- real number, testing accuracy on the test set (X_test) parameters -- parameters learnt by the model. They can then be used to predict. """ ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) parameters = initialize_parameters() Z3 = forward_propagation(X, parameters) cost = compute_cost(Z3, Y) optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost) init = tf.global_variables_initializer() saver = tf.train.Saver() with tf.Session() as sess: if operation == 'save': sess.run(init) for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) save_path = saver.save(sess, "model.ckpt") print("Model saved in path: %s" % save_path) predict_op = tf.argmax(Z3, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) elif operation == 'restore': saver.restore(sess, "model.ckpt") predict_op = tf.argmax(Z3, 1) result = predict_op.eval({X: predict}) print result
def train_data_with_CNN(X_train, Y_train, X_test, Y_test, minibatch_size): seed = 1 # 初始化权值 def weight_variable(shape, name='weig;ht'): init = tf.truncated_normal(shape, stddev=0.1) var = tf.Variable(initial_value=init, name=name) return var # 初始化偏置 def bias_variable(shape, name='bias'): init = tf.constant(0.1, shape=shape) var = tf.Variable(init, name=name) return var # 卷积 def conv2d(x, W, name='conv2d'): return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME', name=name) # 池化 def max_pool_2X2(x, name='maxpool'): return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', name=name) def max_pool_3X3(x, name='maxpool'): return tf.nn.max_pool(x, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name=name) # 输入层 # 请注意 X 的 name,在测试model时会用到它 # X = tf.placeholder(tf.float32, [None, CAPTCHA_IMAGE_WIDHT * CAPTCHA_IMAGE_HEIGHT], name='data-input') # Y = tf.placeholder(tf.float32, [None, CAPTCHA_LEN * CHAR_SET_LEN], name='label-input') # x_input = tf.reshape(X, [-1, CAPTCHA_IMAGE_HEIGHT, CAPTCHA_IMAGE_WIDHT, 1], name='x-input') #自改X为三层通道的训练数据 x_input = tf.placeholder( tf.float32, [None, CAPTCHA_IMAGE_HEIGHT, CAPTCHA_IMAGE_WIDHT, 1], name='x-input') Y = tf.placeholder(tf.float32, [None, CAPTCHA_LEN * CHAR_SET_LEN], name='label-input') # dropout,防止过拟合 # 请注意 keep_prob 的 name,在测试model时会用到它 keep_prob = tf.placeholder(tf.float32, name='keep-prob') # # 第一层卷积 # W_conv1 = weight_variable([5, 5, 3, 32], 'W_conv1') # B_conv1 = bias_variable([32], 'B_conv1') # conv1 = tf.nn.relu(conv2d(x_input, W_conv1, 'conv1') + B_conv1) # conv1 = max_pool_2X2(conv1, 'conv1-pool') # conv1 = tf.nn.dropout(conv1, keep_prob) # # 第二层卷积 # W_conv2 = weight_variable([5, 5, 32, 64], 'W_conv2') # B_conv2 = bias_variable([64], 'B_conv2') # conv2 = tf.nn.relu(conv2d(conv1, W_conv2, 'conv2') + B_conv2) # conv2 = max_pool_2X2(conv2, 'conv2-pool') # conv2 = tf.nn.dropout(conv2, keep_prob) # # 第三层卷积 # W_conv3 = weight_variable([5, 5, 64, 64], 'W_conv3') # B_conv3 = bias_variable([64], 'B_conv3') # conv3 = tf.nn.relu(conv2d(conv2, W_conv3, 'conv3') + B_conv3) # conv3 = max_pool_2X2(conv3, 'conv3-pool') # conv3 = tf.nn.dropout(conv3, keep_prob) ###############自改#################### #第一层卷积+池化 W_conv1 = weight_variable([5, 5, 1, 16], 'W_conv1') B_conv1 = bias_variable([16], 'B_conv1') conv1 = tf.nn.relu(conv2d(x_input, W_conv1, 'conv1') + B_conv1) conv1 = max_pool_3X3(conv1, 'conv1-pool') #conv1 = tf.nn.dropout(conv1, keep_prob) # 第二层卷积+池化 W_conv2 = weight_variable([5, 5, 16, 32], 'W_conv2') B_conv2 = bias_variable([32], 'B_conv2') conv2 = tf.nn.relu(conv2d(conv1, W_conv2, 'conv2') + B_conv2) conv2 = max_pool_3X3(conv2, 'conv2-pool') #conv2 = tf.nn.dropout(conv2, keep_prob) #第三层卷积 W_conv3 = weight_variable([5, 5, 32, 64], 'W_conv3') B_conv3 = bias_variable([64], 'B_conv3') conv3 = tf.nn.relu(conv2d(conv2, W_conv3, 'conv3') + B_conv3) #conv3 = tf.nn.dropout(conv3, keep_prob) #第四层卷积 W_conv4 = weight_variable([3, 3, 64, 128], 'W_conv4') B_conv4 = bias_variable([128], 'B_conv4') conv4 = tf.nn.relu(conv2d(conv3, W_conv4, 'conv4') + B_conv4) #conv4 = tf.nn.dropout(conv4, keep_prob) #第五层卷积+池化 W_conv5 = weight_variable([3, 3, 128, 256], 'W_conv5') B_conv5 = bias_variable([256], 'B_conv5') conv5 = tf.nn.relu(conv2d(conv4, W_conv5, 'conv5') + B_conv5) conv5 = max_pool_3X3(conv5, 'conv5-pool') #conv5 = tf.nn.dropout(conv5, keep_prob) #第一层全连接 W_fc = weight_variable([5 * 15 * 256, 1024], 'W_fc') B_fc = bias_variable([1], 'B_fc') fc1 = tf.reshape(conv5, [-1, W_fc.get_shape().as_list()[0]]) fc1 = tf.nn.relu(tf.add(tf.matmul(fc1, W_fc), B_fc)) fc1 = tf.nn.dropout(fc1, keep_prob) #第二层全连接 # W_fc1 = weight_variable([1024, 4069], 'W_fc1') # B_fc1 = bias_variable([1], 'B_fc1') # # fc1 = tf.nn.relu(tf.add(tf.matmul(fc, W_fc1), B_fc1)) # fc1 = tf.nn.dropout(fc1, keep_prob) # 全链接层 # 每次池化后,图片的宽度和高度均缩小为原来的一半,进过上面的三次池化,宽度和高度均缩小8倍 # W_fc1 = weight_variable([5 * 15 * 64, 1024], 'W_fc1') # B_fc1 = bias_variable([1024], 'B_fc1') # #fc1 = tf.reshape(conv3, [-1, 20 * 8 * 64]) # fc1 = tf.reshape(conv5, [-1, W_fc1.get_shape().as_list()[0]]) # fc1 = tf.nn.relu(tf.add(tf.matmul(fc1, W_fc1), B_fc1)) # fc1 = tf.nn.dropout(fc1, keep_prob) # 输出层 W_fc2 = weight_variable([1024, CAPTCHA_LEN * CHAR_SET_LEN], 'W_fc2') B_fc2 = bias_variable([CAPTCHA_LEN * CHAR_SET_LEN], 'B_fc2') output = tf.add(tf.matmul(fc1, W_fc2), B_fc2, 'output') loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits(labels=Y, logits=output)) optimizer = tf.train.AdamOptimizer(0.001).minimize(loss) predict = tf.reshape(output, [-1, CAPTCHA_LEN, CHAR_SET_LEN], name='predict') labels = tf.reshape(Y, [-1, CAPTCHA_LEN, CHAR_SET_LEN], name='labels') # 预测结果 # 请注意 predict_max_idx 的 name,在测试model时会用到它 predict_max_idx = tf.argmax(predict, axis=2, name='predict_max_idx') labels_max_idx = tf.argmax(labels, axis=2, name='labels_max_idx') predict_correct_vec = tf.equal(predict_max_idx, labels_max_idx) accuracy = tf.reduce_mean(tf.cast(predict_correct_vec, tf.float32)) saver = tf.train.Saver() config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=True) config.gpu_options.per_process_gpu_memory_fraction = 0.6 with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) steps = 0 for epoch in range(6000): num_minibatches = int(m / minibatch_size) seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, num_minibatches, seed) for minibatch in minibatches: (train_data, train_label) = minibatch op, pre = sess.run([optimizer, labels_max_idx], feed_dict={ x_input: train_data, Y: train_label, keep_prob: 0.75 }) #print(pre) #print(pre.shape) if steps % 1 == 0: acc = sess.run(accuracy, feed_dict={ x_input: X_test, Y: Y_test, keep_prob: 1.0 }) print("steps=%d, accuracy=%f" % (steps, acc)) if acc > 0.925: saver.save(sess, MODEL_SAVE_PATH + "crack_captcha.model", global_step=steps) if acc > 0.939: break steps += 1
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True, isPlot=True): ''' 使用TensorFlow实现三层的卷积神经网络 conv2d->relu->maxpool->>conv2d->relu->maxpool->flatten->fullyconnnected :param X_train: 训练数据,维度为(None,64,64,3) :param Y_train: 训练数据对应的标签,维度为(Nne,n_y=6 :param X_test: 测试数据,维度为(None,64,64,3) :param Y_test: 训练数据对应的标签,维度为(None,n_y=6) :param learning_rate: 学习率 :param num_epochs: 遍历整个数据集的次数 :param minibatch_size: 每个小批量数据块的大小 :param print_cost: 是否打印成本值,每遍历100次整个数据集打印一次 :param isPlot: 是否绘制图谱 :return: train_accuracy-实数,训练集的准确度 test_accuracy-实数,测试集的准确度 parameters-学习后的参数 ''' ops.reset_default_graph() #能后重新运行模型而不覆盖tf变量 tf.set_random_seed(1) #确保你的数据和我的一样 seed = 3 #指定numpy的随机种子 (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] #为当前维度创建占位符 X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) #初始化参数 parameters = initialize_parameters() #前向传播 Z3 = forward_propagation(X, parameters) #计算成本 cost = compute_cost(Z3, Y) #反向传播,由于框架已经实现了反向传播,我们只需要选择一个优化器就行 optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) #全局初始化所有变量 init = tf.global_variables_initializer() #开始运行 with tf.Session() as sess: #初始化参数 sess.run(init) #开始便利数据集 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) #获取数据块数量 seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) #对米格数据块进行处理 for minibatch in minibatches: #选择一个数据块 (minibatch_X, minibatch_Y) = minibatch #最小化这个数据块的成本 _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) #累加数据块的成本值 minibatch_cost += temp_cost / num_minibatches #是否打印成本 if print_cost: #每5代打印一次 if epoch % 5 == 0: print('当前是第' + str(epoch) + '代,成本值为:' + str(minibatch_cost)) #记录成本 if epoch % 1 == 0: costs.append(minibatch_cost) #数据处理完毕,绘制成本曲线 if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterstions(per tens)') plt.title('Learning rate =' + str(learning_rate)) plt.show() #开始预测数据 ##计算当前的预测情况 predict_op = tf.arg_max(Z3, 1) corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1)) ##计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, 'float')) print('corrent_prediction accuary = ' + str(accuracy)) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval(({X: X_test, Y: Y_test})) print('训练及准确度:' + str(train_accuracy)) print('测试集准确度:' + str(test_accuracy)) return (train_accuracy, test_accuracy, parameters)
def model(train_X, train_Y, test_X, test_Y, learning_rate=0.09, num_epochs=100, minibatch_size=64, print_cost=True): ''' 实现一个有两个卷积层的CNN网络 Parameters: train_X - shape=(None, 64, 64, 3) train_Y - shape=(None, n_y=6) Returns: train_accuracy - 训练集上的准确率 test_accuracy - 测试集上的准确率 parameters - 模型学习到的权重参数的字典 ''' ops.reset_default_graph() tf.set_random_seed(1) seed = 3 (m, n_H0, n_W0, n_C0) = train_X.shape n_y = train_Y.shape[1] costs = [] # step1 创建X和Y的占位符 X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) # step2 卷积核初始化 parameters = initialize_parameters() # step3 向前传播 Z3 = forward_propagation(X, parameters) # step4 计算损失函数 cost = compute_cost(Z3, Y) # step5 反向传播 optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) # step6 初始化所有变量 init = tf.global_variables_initializer() # step7开始计算tensorflow计算图 with tf.Session() as sess: sess.run(init) # 开始训练 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) seed = seed + 1 minibatches = cnn_utils.random_mini_batches( train_X, train_Y, minibatch_size, seed) for minibatch in minibatches: # 选取一个minibatch (minibatch_X, minibatch_Y) = minibatch # 开始计算对应的损失 _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches if print_cost and epoch % 5 == 0: print('Cost after epoch %d: %.3f' % (epoch, minibatch_cost)) if print_cost and epoch % 1 == 0: costs.append(minibatch_cost) plt.plot(np.squeeze(costs)) plt.xlabel('iterations (per tens)') plt.ylabel('cost') plt.title('Learning rate =' + str(learning_rate)) plt.show() # 计算预测的正确率 predict_op = tf.argmax(Z3, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # 计算在train_Set 和 test_Set上的准确率 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) print(accuracy) train_accuracy = accuracy.eval({X: train_X, Y: train_Y}) test_accuracy = accuracy.eval({X: train_X, Y: train_Y}) print('Train Accuracy:', train_accuracy) print('Test Accuracy:', test_accuracy) return train_accuracy, test_accuracy, parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True): """ Implements a three-layer ConvNet in Tensorflow: CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED Arguments: X_train -- training set, of shape (None, 64, 64, 3) Y_train -- test set, of shape (None, n_y = 6) X_test -- training set, of shape (None, 64, 64, 3) Y_test -- test set, of shape (None, n_y = 6) learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: train_accuracy -- real number, accuracy on the train set (X_train) test_accuracy -- real number, testing accuracy on the test set (X_test) parameters -- parameters learnt by the model. They can then be used to predict. """ tf.compat.v1.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost with tf.compat.v1.Graph().as_default() as graph: # Create Placeholders of the correct shape X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) # Initialize parameters parameters = None # Forward propagation: Build the forward propagation in the tensorflow graph Z3 = forward_propagation(X, parameters) # Cost function: Add cost function to tensorflow graph cost = compute_cost(Z3, Y) # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost. optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) # Create a saver. saver = tf.compat.v1.train.Saver() # Initialize all the variables globally init = tf.compat.v1.global_variables_initializer() # Calculate the correct predictions predict_op = tf.argmax(input=Z3, axis=1) correct_prediction = tf.equal(predict_op, tf.argmax(input=Y, axis=1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(input_tensor=tf.cast(correct_prediction, "float")) # Start the session to compute the tensorflow graph with tf.compat.v1.Session(graph=graph) as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = cnn_utils.random_mini_batches(X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: # Select a minibatch (minibatch_X, minibatch_Y) = minibatch # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). _, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y}) minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) save_path = saver.save(sess, 'saves\my-model') print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title( "Learning rate = {0}, Train Accuracy: {1}, Test Accuracy: {2}.".format(learning_rate, train_accuracy, test_accuracy)) plt.show() return train_accuracy, test_accuracy, parameters, save_path
def model(X_train, Y_train, X_test, Y_test, learning_rate, num_epochs, minibatch_size, print_cost, isPlot): seed = 3 # X_train = X_train.transpose(0,2,3,1) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] X, Y, keep_prob = create_placeholder(n_H0, n_W0, n_C0, n_y) parameters = init_parameters() Z6 = forward_propagation(X, parameters, keep_prob) cost = compute_loss(Z6, Y) optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost) init = tf.global_variables_initializer() saver = tf.train.Saver() with tf.Session() as sess: sess.run(init) for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) #获取数据块的数量 #seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) #对每个数据块进行处理 for minibatch in minibatches: #选择一个数据块 (minibatch_X, minibatch_Y) = minibatch #最小化这个数据块的成本 _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y, keep_prob: 0.5 }) #累加数据块的成本值 minibatch_cost += temp_cost / num_minibatches #是否打印成本 if print_cost: #每5代打印一次 if epoch % 50 == 0: print("当前是第 " + str(epoch) + " 代,成本值为:" + str(minibatch_cost)) #记录成本 if epoch % 1 == 0: costs.append(minibatch_cost) #数据处理完毕,绘制成本曲线 if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() #保存学习后的参数 parameters = sess.run(parameters) print("参数已经保存到session。") saver.save(sess, "model/save_net.ckpt") # X_test = X_test.transpose(0,2,3,1) #开始预测数据 ## 计算当前的预测情况 predict_op = tf.argmax(Z6, 1) corrent_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) ##计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float")) # print("corrent_prediction accuracy= " + str(accuracy)) train_accuracy = accuracy.eval({ X: X_train, Y: Y_train, keep_prob: 1.0 }) test_accuary = accuracy.eval({X: X_test, Y: Y_test, keep_prob: 1.0}) print("训练集准确度:" + str(train_accuracy)) print("测试集准确度:" + str(test_accuary)) return parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.005, num_epochs=100, minibatch_size=64, print_cost=True, isPlot=True): ops.reset_default_graph() tf.set_random_seed(1) seed = 3 (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) parameters = initialize_parameters() Z3 = forward_propagation(X, parameters) cost = compute_cost(Z3, Y) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m / minibatch_size) # 获取数据块的数量 seed = seed + 1 minibatches = cnn_utils.random_mini_batches( X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: (minibatch_X, minibatch_Y) = minibatch _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches if print_cost: # 每5代打印一次 if epoch % 5 == 0: print("当前是第 " + str(epoch) + " 代,成本值为:" + str(minibatch_cost)) # 记录成本 if epoch % 1 == 0: costs.append(minibatch_cost) # 数据处理完毕,绘制成本曲线 if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() predict_op = tf.arg_max(Z3, 1) corrent_prediction = tf.equal(predict_op, tf.arg_max(Y, 1)) ##计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction, "float")) print("corrent_prediction accuracy= " + str(accuracy)) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuary = accuracy.eval({X: X_test, Y: Y_test}) print("训练集准确度:" + str(train_accuracy)) print("测试集准确度:" + str(test_accuary)) return (train_accuracy, test_accuary, parameters)
def model(X_train,Y_train,X_test,Y_test,learning_rate = 0.009, num_epochs = 100,minibatch_size = 64,print_cost = True,isPlot =True): ''' 使用TensorFlow实现三层的卷积神经网络 conv2d->relu->maxpool->>conv2d->relu->maxpool->flatten->fullyconnnected :param X_train: 训练数据,维度为(None,64,64,3) :param Y_train: 训练数据对应的标签,维度为(Nne,n_y=6 :param X_test: 测试数据,维度为(None,64,64,3) :param Y_test: 训练数据对应的标签,维度为(None,n_y=6) :param learning_rate: 学习率 :param num_epochs: 遍历整个数据集的次数 :param minibatch_size: 每个小批量数据块的大小 :param print_cost: 是否打印成本值,每遍历100次整个数据集打印一次 :param isPlot: 是否绘制图谱 :return: train_accuracy-实数,训练集的准确度 test_accuracy-实数,测试集的准确度 parameters-学习后的参数 ''' ops.reset_default_graph()#能后重新运行模型而不覆盖tf变量 tf.set_random_seed(1)#确保你的数据和我的一样 seed = 3#指定numpy的随机种子 (m,n_H0,n_W0,n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] #为当前维度创建占位符 X, Y = create_placeholders(n_H0,n_W0,n_C0,n_y) #初始化参数 parameters = initialize_parameters() #前向传播 Z3 = forward_propagation(X,parameters) #计算成本 cost = compute_cost(Z3,Y) #反向传播,由于框架已经实现了反向传播,我们只需要选择一个优化器就行 optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) #全局初始化所有变量 init = tf.global_variables_initializer() #开始运行 with tf.Session() as sess: #初始化参数 sess.run(init) #开始便利数据集 for epoch in range(num_epochs): minibatch_cost = 0 num_minibatches = int(m/minibatch_size)#获取数据块数量 seed=seed+1 minibatches = cnn_utils.random_mini_batches(X_train,Y_train,minibatch_size,seed) #对米格数据块进行处理 for minibatch in minibatches: #选择一个数据块 (minibatch_X,minibatch_Y) = minibatch #最小化这个数据块的成本 _ ,temp_cost = sess.run([optimizer,cost],feed_dict={X:minibatch_X,Y:minibatch_Y}) #累加数据块的成本值 minibatch_cost += temp_cost/num_minibatches #是否打印成本 if print_cost: #每5代打印一次 if epoch%5==0: print('当前是第'+str(epoch)+'代,成本值为:'+str(minibatch_cost)) #记录成本 if epoch%1 == 0: costs.append(minibatch_cost) #数据处理完毕,绘制成本曲线 if isPlot: plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterstions(per tens)') plt.title('Learning rate ='+str(learning_rate)) plt.show() #开始预测数据 ##计算当前的预测情况 predict_op = tf.arg_max(Z3,1) corrent_prediction = tf.equal(predict_op,tf.arg_max(Y,1)) ##计算准确度 accuracy = tf.reduce_mean(tf.cast(corrent_prediction,'float')) print('corrent_prediction accuary = '+str(accuracy)) train_accuracy =accuracy.eval({X:X_train,Y:Y_train}) test_accuracy = accuracy.eval(({X:X_test,Y:Y_test})) print('训练及准确度:'+str(train_accuracy)) print('测试集准确度:'+str(test_accuracy)) return(train_accuracy,test_accuracy,parameters)
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.003, num_epochs=50, minibatch_size=64, print_cost=True): ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost # Create Placeholders of the correct shape with tf.name_scope("input"): X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) #tf.summary.scalar('input_X', X) #tf.summary.scalar('input_Y', Y) # Initialize parameters with tf.name_scope('input_image'): image_in = tf.reshape(X, [-1, 64, 64, 3]) tf.summary.image('input_image', [image_in[5, :, :, :]], 5) parameters = initialize_parameters() # Forward propagation: Build the forward propagation in the tensorflow graph Z3 = forward_propagation(X, parameters) # Cost function: Add cost function to tensorflow graph cost = compute_cost(Z3, Y) # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost. with tf.name_scope("optimizer"): optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) #tf.summary.scalar('Adam', optimizer) # Initialize all the variables globally init = tf.global_variables_initializer() merged = tf.summary.merge_all() writer = tf.summary.FileWriter("/anaconda3/dnn/con4", tf.get_default_graph()) # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) iiiii = 0 for minibatch in minibatches: # Select a minibatch (minibatch_X, minibatch_Y) = minibatch # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). iiiii += 1 if iiiii == 10: run_options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() opti, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y}, \ options=run_options, run_metadata=run_metadata) writer.add_run_metadata(run_metadata, str(epoch)) elif iiiii == 20: summary, _ = sess.run([merged, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) writer.add_summary(summary, epoch) else: opti, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) #tf.summary.scalar('opti', opti) tf.summary.scalar('temp_cost', temp_cost) minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True: #and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True: #and epoch % 1 == 0: costs.append(minibatch_cost) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') #plt.title("Learning rate = 0.003" ) plt.title("Learning rate =" + str(learning_rate)) plt.show() # Calculate the correct predictions predict_op = tf.argmax(Z3, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) #print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) #print("Train Accuracy: 0.99647886") #print("Test Accuracy: 0.99") print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) #writer = tf.summary.FileWriter("/anaconda3/dnn/con1", tf.get_default_graph()) writer.close() return train_accuracy, test_accuracy, parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.004, num_epochs=100, minibatch_size=64, print_cost=True): """ Implements a three-layer ConvNet in Tensorflow: CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED Arguments: X_train -- training set, of shape (None, 64, 64, 3) Y_train -- test set, of shape (None, n_y = 6) X_test -- training set, of shape (None, 64, 64, 3) Y_test -- test set, of shape (None, n_y = 6) learning_rate -- learning rate of the optimization num_epochs -- number of epochs of the optimization loop minibatch_size -- size of a minibatch print_cost -- True to print the cost every 100 epochs Returns: train_accuracy -- real number, accuracy on the train set (X_train) test_accuracy -- real number, testing accuracy on the test set (X_test) parameters -- parameters learnt by the model. They can then be used to predict. """ ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost # Create Placeholders of the correct shape ### START CODE HERE ### (1 line) X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) ### END CODE HERE ### # Initialize parameters ### START CODE HERE ### (1 line) parameters = initialize_parameters() ### END CODE HERE ### # Forward propagation: Build the forward propagation in the tensorflow graph ### START CODE HERE ### (1 line) Z3 = forward_propagation(X, parameters) ### END CODE HERE ### # Cost function: Add cost function to tensorflow graph ### START CODE HERE ### (1 line) cost = compute_cost(Z3, Y) ### END CODE HERE ### # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost. ### START CODE HERE ### (1 line) # optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) ### END CODE HERE ### # Initialize all the variables globally init = tf.global_variables_initializer() # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: # Select a minibatch (minibatch_X, minibatch_Y) = minibatch # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). ### START CODE HERE ### (1 line) _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) ### END CODE HERE ### minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(minibatch_cost) # plot the cost # plt.plot(np.squeeze(costs)) # plt.ylabel('cost') # plt.xlabel('iterations (per tens)') # plt.title("Learning rate =" + str(learning_rate)) # # plt.show() # plt.savefig('./totalTuple.png', bbox_inches='tight') # Calculate the correct predictions predict_op = tf.argmax(Z3, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) return train_accuracy, test_accuracy, parameters
def model(X_train, Y_train, X_test, Y_test, learning_rate=0.003, num_epochs=50, minibatch_size=64, print_cost=True): ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) # to keep results consistent (tensorflow seed) seed = 3 # to keep results consistent (numpy seed) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = Y_train.shape[1] costs = [] # To keep track of the cost # Create Placeholders of the correct shape X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y) # Initialize parameters parameters = initialize_parameters() # Forward propagation: Build the forward propagation in the tensorflow graph Z3 = forward_propagation(X, parameters) # Cost function: Add cost function to tensorflow graph cost = compute_cost(Z3, Y) # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost. optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) # Initialize all the variables globally init = tf.global_variables_initializer() # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): minibatch_cost = 0. num_minibatches = int( m / minibatch_size ) # number of minibatches of size minibatch_size in the train set seed = seed + 1 minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed) for minibatch in minibatches: # Select a minibatch (minibatch_X, minibatch_Y) = minibatch # IMPORTANT: The line that runs the graph on a minibatch. # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y). _, temp_cost = sess.run([optimizer, cost], feed_dict={ X: minibatch_X, Y: minibatch_Y }) minibatch_cost += temp_cost / num_minibatches # Print the cost every epoch if print_cost == True: #and epoch % 5 == 0: print("Cost after epoch %i: %f" % (epoch, minibatch_cost)) if print_cost == True: #and epoch % 1 == 0: costs.append(minibatch_cost) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() # Calculate the correct predictions predict_op = tf.argmax(Z3, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) #print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: Y_train}) test_accuracy = accuracy.eval({X: X_test, Y: Y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) return train_accuracy, test_accuracy, parameters
def model(x_train, y_train, x_test, y_test, learning_rate=0.009, num_epochs=10, minibatch_size=128, print_cost=True): ops.reset_default_graph( ) # to be able to rerun the model without overwriting tf variables tf.set_random_seed(1) seed = 3 costs = list() X_train, y_train, X_test, y_test = prepare_data(x_train, y_train, x_test, y_test) (m, n_H0, n_W0, n_C0) = X_train.shape n_y = y_train.shape[1] X, Y = create_placeholder(n_h=n_H0, n_w=n_W0, n_c=n_C0, n_y=n_y) parameters = initialize_parameters() ZL = forward_prop(X=X, parameters=parameters) cost = compute_loss(ZL, Y=Y) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(cost) # Initialize all the variables globally init = tf.global_variables_initializer() # Start the session to compute the tensorflow graph with tf.Session() as sess: # Run the initialization sess.run(init) # Do the training loop for epoch in range(num_epochs): epoch_cost = 0. num_minibatches = m // minibatch_size # nb of full minibatches seed = seed + 1 for mini_batch_X, mini_batch_Y in random_mini_batches( X_train, y_train, minibatch_size, seed): _, minibatch_cost = sess.run([optimizer, cost], { X: mini_batch_X, Y: mini_batch_Y }) epoch_cost += minibatch_cost / num_minibatches # Print the cost every epoch if print_cost == True and epoch % 2 == 0: print("Cost after epoch %i: %f" % (epoch, epoch_cost)) if print_cost == True and epoch % 1 == 0: costs.append(epoch_cost) # plot the cost plt.plot(np.squeeze(costs)) plt.ylabel('cost') plt.xlabel('iterations (per tens)') plt.title("Learning rate =" + str(learning_rate)) plt.show() # Calculate the correct predictions predict_op = tf.argmax(ZL, 1) correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1)) # Calculate accuracy on the test set accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print(accuracy) train_accuracy = accuracy.eval({X: X_train, Y: y_train}) test_accuracy = accuracy.eval({X: X_test, Y: y_test}) print("Train Accuracy:", train_accuracy) print("Test Accuracy:", test_accuracy) return train_accuracy, test_accuracy, parameters