人工智能与深度学习实例——DDN神经网络

从网上找的训练集和测试集,代码如下:

import numpy as np
import h5py
from scipy.misc import imread

# ------------------------DDN神经网络框架------------------------

# sigmoid 正向激活函数
def sigmoid(Z):
    
    # 由线性单元导入参数 Z
    # 导出 cache 存储Z值
    
    A = 1.0 / (1 + np.exp(-Z))
    cache = Z
    
    return A, cache


# ReLu(Z) 正向激活函数
def ReLU(Z):
    A = np.maximum(0,Z)
    
    assert(A.shape == Z.shape)
    cache = Z
    
    return A, cache


# sigmoid 反向激活函数
def sigmoid_backward(dA, cache):
    
    # dZ[l] = dA[l] * g[l]'( Z[l] )
    
    Z = cache
    
    f = 1.0 / (1 + np.exp(-Z))
    
    dZ = dA * f * (1-f)
    
    assert(dZ.shape == Z.shape)
    
    return dZ
    

# ReLU 反向激活函数
def ReLU_backward(dA, cache):
    Z = cache
    
    dZ = np.array(dA,copy = True)
    dZ[Z <= 0] = 0
    
    assert(dZ.shape == Z.shape)
    
    return dZ

# ------------------------正向传播------------------------

# 初始化隐藏层至输出层参数
def initialize_parameters(layer):
    # layer -- 神经网络各层层数
    
    L = len(layer)
    parameters = {}
    
    # 当前矩阵 W 的维度:  行 -- 当前神经元数目   列 -- 上层神经元数目
    # 当前矩阵 b 的维度:  行 -- 当前神经元数目   列 -- 始终为 1
    for i in range(1, L):
        parameters["W" + str(i)] = np.random.randn(layer[i], layer[i-1])/np.sqrt(layer[i-1])
        parameters["b" + str(i)] = np.zeros((layer[i], 1))
        
        assert (parameters["W" + str(i)].shape == (layer[i], layer[i-1]))
        assert (parameters["b" + str(i)].shape == (layer[i], 1))
        
    return parameters


# 测试代码   
'''
initialize_parameters([3,4,1])
'''


# 正向传播过程线性
def linear_forward(A_prev, W, b):
    
    # A_prev -- 上一层的传递参数 A
    # W,b -- 当前层的参数
    
    # Z = W*A + b
    Z = np.dot(W, A_prev) + b
    assert (Z.shape == (W.shape[0], A_prev.shape[1]))
    
    # 存储 A_prev W b
    cache = (A_prev, W, b)
    
    return Z, cache


# 测试代码
'''
A_prev = np.array([[1], [2], [3]])
parameters = initialize_parameters([3, 4, 1])
Z, cache = linear_forward(A_prev, parameters["W1"], parameters["b1"])
'''

# 正向传播 -- 线性->激活
def linear_forward_activation(A_prev, W, b, activation_function):
    
    # linear_cache -- 存储 A_prev, W, b
    # activation_cache -- 存储 Z
    
    if activation_function == "sigmoid":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = sigmoid(Z)
    elif activation_function == "relu":
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = ReLU(Z)
    
    # 当前层 A 的维度: 行 -- W矩阵行   列 -- A_prev矩阵列
    assert (A.shape == (W.shape[0], A_prev.shape[1]))
    
    cache = (linear_cache, activation_cache)
    
    return A, cache


# 正向总体传播
def deep_forward(X, parameters):
    
    # caches -- 存储隐藏层、输出层 A_prev, W, b
    # AL -- 输出层输出 A
    
    caches = []
    A = X
    L = len(parameters) // 2
    
    # 隐藏层:对应激活函数 -- ReLU
    for i in range(1, L):
        A_prev = A
        A, cache = linear_forward_activation(A_prev, parameters["W" + str(i)], parameters["b" + str(i)], "relu")
        caches.append(cache)
        
    # 输出层:对应激活函数 -- sigmoid
    # W = parameters["W"+str(length)]
    # b = parameters["b"+str(length)]
    AL, cache = linear_forward_activation(A, parameters["W" + str(L)], parameters["b" + str(L)], "sigmoid")
    caches.append(cache)
    
    assert(AL.shape == (1,X.shape[1]))
    
    return AL, caches


# 成本函数(cost function)
def compute_cost(AL, Y):
    
    # Y -- 测试集真实值
    # AL -- 正向传播所得预测值 Y(hat)
    
    m = Y.shape[1]
    cost = (1./m) * (-np.dot(Y,np.log(AL).T) - np.dot(1-Y,np.log(1-AL).T))  
    cost = np.squeeze(cost)
    assert (cost.shape == ())
    
    return cost


Y = np.asarray([[1,1,1]])  
AL = np.asarray([[.8,.9,0.4]])  
cost = compute_cost(AL,Y)

# 测试代码
'''
X = np.array([[1],[2],[3],[4],[5]])
parameters = initialize_parameters([5,4,3,1])
AL, caches = deep_forward(X, parameters)
Y = np.array([[2]])
print(compute_cost(AL, Y))
'''

# ------------------------反向传播------------------------


# 反向传播线性传播
def linear_backward(dZ, cache):
    
    A_prev, W, b = cache
    
    # 原理
    '''
    dW[l] = dZ[l]*A_prev
    db[l] = dZ[l
    dA[l-1] = W[l].T * dZ[l]
    '''
    
    #  m -- 样本数目
    m = A_prev.shape[1]
    
    # dW -- 损失函数对当前层 W 梯度
    # db -- 损失函数对当前层 b 梯度
    # dA_prev -- 损失函数对l-1层 A 梯度
    
    dW = np.dot(dZ, A_prev.T) / m
    
    # 保证数组的二维性
    db = np.sum(dZ, axis = 1, keepdims = True) / m
    
    dA_prev = np.dot(W.T, dZ)
    
    assert (dW.shape == W.shape)
    assert (db.shape == b.shape)
    assert (dA_prev.shape == A_prev.shape)
    
    return dA_prev, dW , db


# 测试代码
# 当前层数为 3,上层层数为 1
'''np.random.seed(3)
dZ = np.random.randn(3,1)
A_prev = np.random.randn(1,1)
W = np.random.randn(3,1)
b = np.random.randn(3,1)
linear_cache = (A_prev, W, b)
dA_prev, dW, db = linear_backward(dZ, linear_cache)
'''

# 反向传播 -- 线性->激活
def linear_activation_backward(dA, cache, activation):
    
    # linear_cache -- 存储了A_prev, W, b
    
    linear_cache, activation_cache = cache
    
    if activation == "sigmoid":
        dZ = sigmoid_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
    elif activation == "relu":
        dZ = ReLU_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
    
    return dA_prev, dW, db

# 测试代码
'''
np.random.seed(2)
dA = np.random.randn(1,2)
A = np.random.randn(3,2)
W = np.random.randn(1,3)
b = np.random.randn(1,1)
Z = np.random.randn(1,2)
linear_cache = (A,W,b)
activation_cache = Z
cache = (linear_cache,activation_cache)
dA_prev,dW,db = linear_activation_backward(dA, cache, "relu")
'''

# 反向总体传播
def deep_backward(AL, Y, caches):
    
    # AL -- 正向传播输出函数值(预测值)  组成向量
    # Y -- 测试集真实值 组成向量
    grads = {}
    
    #递归神经网络深度
    L = len(caches)
    
    # 统一 Y与 AL维度
    Y = Y.reshape(AL.shape)
    
    # 求解 dA[l]
    dAL = -(np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    
    # sigmoid -> ReLU 反向传播
    current_cache = caches[L - 1]
    grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, "sigmoid")
    
    # 隐藏层间的反向传播, 同时记录各梯度数据以供参数更新使用
    for i in reversed(range(L - 1)):
        current_cache = caches[i]
        dA_prev, dW, db = linear_activation_backward(grads["dA" + str(i + 2)], current_cache, "relu") 
        grads["dA" + str(i+1)] = dA_prev
        grads["dW" + str(i+1)] = dW
        grads["db" + str(i+1)] = db
    
    return grads

# 测试代码
'''
np.random.seed(3)
AL = np.random.randn(1, 2)
Y = np.array([[1, 0]])
A1 = np.random.randn(4,2)
W1 = np.random.randn(3,4)
b1 = np.random.randn(3,1)
Z1 = np.random.randn(3,2)
linear_cache_activation_1 = ((A1, W1, b1), Z1)
A2 = np.random.randn(3,2)
W2 = np.random.randn(1,3)
b2 = np.random.randn(1,1)
Z2 = np.random.randn(1,2)
linear_cache_activation_2 = ( (A2, W2, b2), Z2)
caches = (linear_cache_activation_1, linear_cache_activation_2)
grads = deep_backward(AL, Y, caches)
print(grads)
'''

# 参数更新
def update_parameters(parameters, grads, learning_rate):
    
    # learning_rate: 学习率
    
    L = len(parameters) // 2    #深层神经网络的层数
    
    # 循环更新 parameters 参数
    for i in range(L):  
        parameters["W"+str(i + 1)] = parameters["W" + str(i + 1)] - learning_rate * grads["dW"+str(i + 1)]  
        parameters["b"+str(i + 1)] = parameters["b" + str(i + 1)] - learning_rate * grads["db"+str(i + 1)]  
  
    return parameters


# 总体传播测试代码
'''
X = np.array([[1],[2],[3],[4],[5]])
parameters = initialize_parameters([5,4,3,1])
print("parameters:{}".format(parameters))
AL, caches = deep_forward(X, parameters)
Y = np.array([[2]])
grads = deep_backward(AL, Y, caches)
learning_rate = 0.05
parameters_update = update_parameters(parameters, grads, 2)
print("parameters_update:{}".format(parameters_update))
'''

#------------------------实际应用------------------------

# 加载数据集
def load_dataset():  
    train_dataset = h5py.File('train_catvnoncat.h5', "r")
    
    # 训练集像素矩阵  
    train_set_x_orig = np.array(train_dataset["train_set_x"][:])
    
    # 训练集标签
    train_set_y_orig = np.array(train_dataset["train_set_y"][:])  
  
    test_dataset = h5py.File('test_catvnoncat.h5', "r")
    # 测试像素矩阵  
    test_set_x_orig = np.array(test_dataset["test_set_x"][:])
    
    #测试集标签
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) 
  
    # 类型列表
    classes = np.array(test_dataset["list_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  


# 预测神经网络结果
def predict(X, y, parameters):
    
    # X -- 输入数据集
    # y -- 真实值组成向量
    
    # 样本数目集
    number = X.shape[1]
    
    # 神经网络层数
    
    p = np.zeros((1,number))
    
    AL, caches = deep_forward(X, parameters)
    
    # 循环对预测值进行评估:
    for i in range(0, AL.shape[1]):
        if AL[0, i] > 0.5:
            p[0, i] = 1
        else:
            p[0, i] = 0
    
    # 计算预测正确所占比例        
    print("Accuracy: " + str(np.sum((p == y) /number )))
    
    return p

def L_layer_model(X, Y, layer, iterations = 1000, learning_rate = 0.0075):
    costs = []
    
    parameters = initialize_parameters(layer)
    
    # 一次传播过程
    for i in range(0,iterations):
        AL, caches = deep_forward(X, parameters)
        
        cost = compute_cost(AL, Y)
        
        grads = deep_backward(AL, Y, caches)
        
        parameters = update_parameters(parameters, grads, learning_rate)
        
        # 每循环50次记录
        if  i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))
        if  i % 100 == 0:
            costs.append(cost)
    return parameters
    
# ---------main函数---------

train_x_orig, train_y, test_x_orig, test_y, classes = load_dataset()

# 存储数据集信息
m_train = train_x_orig.shape[0]  
num_px = train_x_orig.shape[1]  
m_test = test_x_orig.shape[0]

# 打印数据集信息
print("Number of training examples:" + str(m_train))  
print("Number of testing examples:" + str(m_test))  
print("Each image of size:(" + str(num_px) + "," + str(num_px) + ",3)")  
print("train_x_orig shape:" + str(train_x_orig.shape))  
print("train_y shape:" + str(train_y.shape))  
print("test_x_orig shape:" + str(test_x_orig.shape))  
print("test_y shape:" + str(test_y.shape))


# 测试集图片矩阵转换成向量形式
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T

# 数据集标准化(使数据集中在 0-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)) 


# 神经网络层数
layer = [12288, 20, 7, 5, 1]

parameters = L_layer_model(train_x, train_y, layer , iterations = 2500)

# 训练集正确率
print("train:")
predictions_train = predict(train_x,train_y,parameters)

# 测试集正确率
print("test:")
predictions_test = predict(test_x,test_y,parameters)

# 应用阶段图片测试
image =  np.array(imread("image.jpg"))
my_image = image.reshape([-1,1])

# 图片真实分类[0 or 1]
my_label_y = [0]

# 图片信息预测并打印
print("my_image:")
my_predicted_image = predict(my_image, my_label_y, parameters)
print("result:")
print ("y = " + str(np.squeeze(my_predicted_image)) + " " +classes[int(np.squeeze(my_predicted_image)),].decode("utf-8")) 

阅读更多
版权声明:本篇博客仅供本人参考学习使用 https://blog.csdn.net/adorkable_thief/article/details/80333351
个人分类: 人工智能学习笔记
想对作者说点什么? 我来说一句

神经网络深度学习.pdf

2017年06月03日 2.49MB 下载

没有更多推荐了,返回首页

不良信息举报

人工智能与深度学习实例——DDN神经网络

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭