Deep-Learning-吴恩达-作业（三）

2018-06-20 2018-06-20 view times

hdf5文件

PS：第一次接触这种文件格式，可以参考下面两篇博文快速知道其存储形式 ~

https://blog.csdn.net/yudf2010/article/details/50353292

http://docs.h5py.org/en/latest/quick.html#quick

h5py文件是存放两类对象的容器

数据集(dataset)：像数组类的数据集合，和numpy的数组差不多。

组(group)：像文件夹一样的容器，类似python中的 dict，有键(key)和值(value)。group中可以存放dataset或者其他的group。

1. 查看h5文件中的key

#h5文件的读取  
f_train = h5py.File('D:/机器学习/深度学习神经网络/作业三/datasets/train_catvnoncat.h5','r')   #打开h5文件  
# 可以查看所有的主键  
for key in f_train.keys():  
    print(f_train[key].name)   #名字
    print(f_train[key].shape)  #大小
    print(f_train[key].value)  #数据

2. key的打印结果

train_catvnoncat.h5 和 test_catvnoncat.h5 中key的打印结果一样，train中样本209，test中样本50

/list_classes
(2,)
[b'non-cat' b'cat']
/train_set_x
(209, 64, 64, 3)
[[[[ 17  31  56]
   [ 22  33  59]
   [ 25  35  62]
   ...
   [  0   0   0]
   [  0   0   0]
   [  0   0   0]]]]
/train_set_y
(209,)
[0 0 1 0 0 0 0 1 0 0 0 1 0 1 1 0 0 0 0 1 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0
 0 1 0 0 1 1 0 0 0 0 1 0 0 1 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 0
 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 1 0 0 1 0 0 0 0 1 0 1 0 1 1 1 1 1
 1 0 0 0 0 0 1 0 0 0 1 0 0 1 0 1 0 1 1 0 0 0 1 1 1 1 1 0 0 0 0 1 0 1 1 1 0
 1 1 0 0 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0 1 0 0 0 0 0
 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0]

3. 查看key的数据类型

f_train = h5py.File('D:/机器学习/深度学习神经网络/作业三/datasets/train_catvnoncat.h5','r')   
train_x_orig = f_train['train_set_x']
train_y = f_train['train_set_y']
classes = f_train['list_classes']
print(train_x_orig.dtype)
print(train_y.dtype)

list_classes ：uint8
train_set_x ：int64 应该是64* 64* 3大小的图片
train_set_y ：|S7 好像是Matlab里的v7.3格式，不知道啊 ~

PS：下面是两个两个编程作业~

两层的神经网络

###########两层的神经网络 LINEAR->RELU->LINEAR->SIGMOID 识别是否有猫
import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils import *

###########加载数据
train_x_orig, train_y, test_x_orig, test_y, classes = load_data() #dnn_app_utils中的函数

#将三个通道合为一列，标准化至0~1
# Reshape the training and test examples
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T  # The "-1" makes reshape flatten the remaining dimensions 
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# Standardize data to have feature values between 0 and 1.
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.
print ("train_x's shape: " + str(train_x.shape)) 
print ("test_x's shape: " + str(test_x.shape))
###########加载数据


###########两层的神经网络参数训练 LINEAR->RELU->LINEAR->SIGMOID
n_x = 12288     # num_px * num_px * 3
n_h = 7         # 隐藏层神经元个数
n_y = 1
layers_dims = (n_x, n_h, n_y)

def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
    """
    Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.
    
    Arguments:
    X -- input data, of shape (n_x, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    layers_dims -- dimensions of the layers (n_x, n_h, n_y)
    num_iterations -- number of iterations of the optimization loop
    learning_rate -- learning rate of the gradient descent update rule
    print_cost -- If set to True, this will print the cost every 100 iterations 
    
    Returns:
    parameters -- a dictionary containing W1, W2, b1, and b2
    """

    grads = {}
    costs = []                              # to keep track of the cost
    m = X.shape[1]                           # number of examples
    (n_x, n_h, n_y) = layers_dims
    
    # Initialize parameters dictionary, by calling one of the functions you'd previously implemented
    ### START CODE HERE ### (≈ 1 line of code)
    parameters = initialize_parameters(n_x, n_h, n_y) #初始化参数
    ### END CODE HERE ###
    
    # Get W1, b1, W2 and b2 from the dictionary parameters.
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    
    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1, W2, b2". Output: "A1, cache1, A2, cache2".
        A1, cache1 = linear_activation_forward(X, W1, b1, 'relu')
        A2, cache2 = linear_activation_forward(A1, W2, b2, 'sigmoid')
        
        # Compute cost
        cost = compute_cost(A2, Y)
        
        # Initializing backward propagation
        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
        
        # Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1".
        dA1, dW2, db2 = linear_activation_backward(dA2, cache2, 'sigmoid')
        dA0, dW1, db1 = linear_activation_backward(dA1, cache1, 'relu')
        
        # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2
        grads['dW1'] = dW1
        grads['db1'] = db1
        grads['dW2'] = dW2
        grads['db2'] = db2
        
        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)

        # Retrieve W1, b1, W2, b2 from parameters
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        
        # Print the cost every 100 training example
        if print_cost and i % 100 == 0:
            print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))
        if print_cost and i % 100 == 0: #每迭代100次记录cost的值
            costs.append(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()
    
    return parameters
###########两层的神经网络

#计算样本准确率
predictions_train = predict(train_x, train_y, parameters) #训练集准确率为1
predictions_test = predict(test_x, test_y, parameters) #测试集准确率为0.72

训练过程中cost function的值的下降

四层的神经网络

###########四层的神经网络 LINEAR->RELU->LINEAR->SIGMOID 识别是否有猫
import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils import *

###########加载数据
train_x_orig, train_y, test_x_orig, test_y, classes = load_data() #dnn_app_utils中的函数

#将三个通道合为一列，标准化至0~1
# Reshape the training and test examples
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T  # The "-1" makes reshape flatten the remaining dimensions 
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# Standardize data to have feature values between 0 and 1.
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.
#print ("train_x's shape: " + str(train_x.shape)) 
#print ("test_x's shape: " + str(test_x.shape))
###########加载数据


###########四层神经网络参数训练，每层的神经元个数 LINEAR->RELU]*(L-1)->LINEAR->SIGMOID
layers_dims = [12288, 20, 7, 5, 1] #  4-layer model

def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009
    """
    Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
    
    Arguments:
    X -- data, numpy array of shape (number of examples, num_px * num_px * 3)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
    learning_rate -- learning rate of the gradient descent update rule
    num_iterations -- number of iterations of the optimization loop
    print_cost -- if True, it prints the cost every 100 steps
    
    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """

    costs = []                         # keep track of cost
    
    # Parameters initialization. (≈ 1 line of code)
    ### START CODE HERE ###
    parameters = initialize_parameters_deep(layers_dims)
    ### END CODE HERE ###
    
    # Loop (gradient descent)
    for i in range(0, num_iterations):

        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
        AL, caches =  L_model_forward(X, parameters)

        
        # Compute cost.
        cost = compute_cost(AL, Y)
    
        # Backward propagation.

        grads = L_model_backward(AL, Y, caches)
 
        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)
                
        # Print the cost every 100 training example
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))
        if print_cost and i % 100 == 0:
            costs.append(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() #这里要注意的一个问题是：程序会一直show这张图而不往下执行
    
    return parameters
###########四层神经网络

#计算样本准确率
parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)
predictions_train = predict(train_x, train_y, parameters) #训练集准确率为0.98
predictions_test = predict(test_x, test_y, parameters) #测试集准确率为0.8

#打印分类错误的图片
print_mislabeled_images(classes, test_x, test_y, pred_test)

''' 测试自己的图片
my_image = "cat1.jpg" 
my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)

fname = "images/" + my_image
image = np.array(ndimage.imread(fname, flatten=False))
my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))
my_image = my_image/255.
my_predicted_image = predict(my_image, my_label_y, parameters)

plt.imshow(image)
print ("y = " + str(np.squeeze(my_predicted_image)) + ", your L-layer model predicts a \""
       + classes[int(np.squeeze(my_predicted_image)),].decode("utf-8") +  "\" picture.")
'''

训练过程中cost function的值的下降

看了一下资源消耗，用的是CPU和内存，可能用不同的框架，用的资源不一样。可以将数据从硬盘读进内存，输入CPU计算。或者将数据从硬盘读入显存，用GPU计算。

待解决的问题

我现在最大的疑惑就是，怎么把训练好的网络参数储存起来，以什么格式储存？后面要检测图片中是否有猫的时候，直接将参数取来用，不需要从头再计算一遍参数。