tensorflow实现图像识别

学完了ng深度学习第四课，复习一遍代码。

今天写第一周的作业---用tensorflow框架训练深层网络实现图像识别，代码写完后问题出来啦（问题已找出，用红色字体标出）

ng的准确率：

我的准确率：

代价函数的初始值以及训练过程中的变化情况也很不一样，检查了代码是一样的。应该还是哪部分的代码出了问题，之前写别的代码也出现过类似的情况，当时是因为w的初始化公式不一样造成的。这里是什么问题暂时没检查出来，先放在这里。

import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import tensorflow as tf

def load_dataset():
    train_dataset = h5py.File('datasets/train_signs.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"][:])  # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:])  # your train set labels

    test_dataset = h5py.File('datasets/test_signs.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:])  # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"][:])  # your test set labels

    classes = np.array(test_dataset["list_classes"][:])  # the list of classes

    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))

    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

# create a list of random mini  batches from (X,Y)
def random_mini_batches(X,Y,mini_batch_size = 64):
    # X---(m,Hi,Wi,Ci)
    # Y---(m,n_y) value 0 or 1
    m = X.shape[0]
    mini_batches = []

    # step 1: shuffle (X,Y)
    permutation = list(np.random.permutation(m))
    shuffled_X = X[permutation, :, :, :]
    shuffled_Y = Y[permutation, :]

    # step 2: partition (shuffled_X,shuffled_Y).minus the end case.
    num_complete_minibatchs = math.floor(m/mini_batch_size)

    for k in range(0, num_complete_minibatchs):
        mini_batch_X = shuffled_X[k*mini_batch_size:k*mini_batch_size+mini_batch_size, :, :, :]
        mini_batch_Y = shuffled_Y[k*mini_batch_size:k*mini_batch_size+mini_batch_size, :]

        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
#（原来是这里的缩进失误，按这种写法，只用了训练集的一部分数据，得出的结果对训练集和测试集的准确率当然就很差了。）
        # handling the end case (last mini_batch <mini_batch_size)
        if m % mini_batch_size != 0:
            mini_batch_X = shuffled_X[num_complete_minibatchs*mini_batch_size:m, :, :, :]
            mini_batch_Y = shuffled_Y[num_complete_minibatchs*mini_batch_size:m, :]
            mini_batch = (mini_batch_X, mini_batch_Y)
            mini_batches.append(mini_batch)

        return mini_batches 

# 定义onehot数组
def convert_to_one_hot(Y, C):
    #先将Y转换成一行数，再将数组中指定位置的数置为1
    Y = np.eye(C)[Y.reshape(-1)].T
    return Y


X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()

X_train = X_train_orig/255.
X_test = X_test_orig/255.
Y_train = convert_to_one_hot(Y_train_orig, 6).T
Y_test = convert_to_one_hot(Y_test_orig, 6).T


def create_placeholders(n_H0, n_W0, n_C0, n_y):
    # Creates the placeholders for the tensorflow session
    X = tf.placeholder(tf.float32, shape=[None, n_H0, n_W0, n_C0])
    Y = tf.placeholder(tf.float32, shape=[None, n_y])

    return X, Y


def initialize_parameters():
    W1 = tf.get_variable("W1", shape=[4, 4, 3, 8], initializer=tf.contrib.layers.xavier_initializer(seed=0))
    W2 = tf.get_variable("W2", shape=[2, 2, 8, 16], initializer=tf.contrib.layers.xavier_initializer(seed=0))

    parameters = {"W1": W1, "W2": W2}

    return parameters

# Implements the forward propagation for the model:
# CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED
def forward_propagation(X,parameters):

    W1 = parameters['W1']
    W2 = parameters['W2']

    # CONV2D: stride of 1, padding 'SAME'
    Z1 = tf.nn.conv2d(X, W1, strides=[1, 1, 1, 1], padding='SAME')
    # RELU
    A1 = tf.nn.relu(Z1)
    # MAXPOOL: window 8x8, sride 8, padding 'SAME'
    P1 = tf.nn.max_pool(A1, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME')
    # CONV2D: filters W2, stride 1, padding 'SAME'
    Z2 = tf.nn.conv2d(P1, W2, strides=[1, 1, 1, 1], padding='SAME')
    # RELU
    A2 = tf.nn.relu(Z2)
    # MAXPOOL: window 4x4, stride 4, padding 'SAME'
    P2 = tf.nn.max_pool(A2, ksize=[1, 4, 4, 1], strides=[1, 4, 4, 1], padding='SAME')
    # FLATTEN
    P2 = tf.contrib.layers.flatten(P2)
    # FULLY-CONNECTED without non-linear activation function (not not call softmax).
    # 6 neurons in output layer. Hint: one of the arguments should be "activation_fn=None"
    Z3 = tf.contrib.layers.fully_connected(P2, num_outputs=6, activation_fn=None)

    return Z3


def compute_cost(Z3, Y):

    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3, labels=Y))

    return cost


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
    # 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)

    (m, n_H0, n_W0, n_C0) = X_train.shape
    n_y = Y_train.shape[1]
    costs = []

    # 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
    cost = compute_cost(Z3, Y)

    # backpropagation
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

    # initial all the variables globally
    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)
            minibatches = random_mini_batches(X_train, Y_train, minibatch_size)

            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

            # 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)  # 对Z3矩阵按列计算最大值 （0表示行，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})  # eval运行计算图，类似于run
        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

# test
_, _, parameters = model(X_train, Y_train, X_test, Y_test)