Convolution model by吴恩达

 # GRADED FUNCTION: model

 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.
     """

     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()       #初始化filter
     ### 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) # softmax -> average cost
     ### END CODE HERE ###

     # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.
     ### START CODE HERE ### (1 line)
     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()

         # 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

流程：placeholder for X and Y,    parameters(weight of conv layer) initialization,  forward_prop(X, parameters),  compute_cost(Z, Y), backprop optimizer, global_variables.initializer, run init and optimizer, print the cost every epoch, caculate the crorrect predictions, caculate accuracy on the test set.

初始化：只需要初始conv layer的 weight，不用初始conv layer的 bias，不用初始fully connecyed layer的  weight 和 bias

完整版参见：https://www.cnblogs.com/CZiFan/p/9481110.html