文章目录

声明
前言
一、卷积神经网络

1.1、导入库
1.2、边界填充
1.3、单步卷积
1.4、卷积层前向传播
1.5、池化层前向传播
1.6、卷积层的反向传播

1.6.1、计算dA
1.6.2、计算dW
1.6.2、计算db

1.7、池化层的反向传播

1.7.1、最大值池化层的反向传播
1.7.2、均值池化层的反向传播
1.7.3、池化层反向传播

二、基于tensorflow的卷积神经网络

2.0、导入库
2.1、创建placeholders
2.2、初始化参数
2.3、前向传播
2.4、计算成本
2.5、构建模型

声明

本文参考何宽

前言

本文的结构：
首先从底层搭建一个完整的卷积神经网络的模块，之后再用tensorflow来实现。

模型结构如下：
在这里插入图片描述
要实现的模块的函数功能：

卷积模块，包含以下函数：
- 使用0扩充边界
- 卷积窗口
- 前向卷积
- 反向卷积
池化模块，包含以下函数：
- 前向池化
- 创建掩码
- 值分配
- 反向池化

一、卷积神经网络

1.1、导入库

import numpy as np
import h5py
import matplotlib.pyplot as pltplt.rcParams['figure.figsize'] = (5.0,4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'np.random.seed(1)

1.2、边界填充

用np.pad进行边界填充。

def zero_pad(X,pad):"""把数据集x的图像边界全部使用0来扩充pad个宽度和高度。参数：X - 图像数据集，维度为（样本数，图像高度，图像宽度，图像通道数）pad - 整数，每个图像在垂直和水平维度上的填充量返回：X_paded - 扩充后的图像数据集，维度为（样本数，图像高度 + 2*pad，图像宽度 + 2*pad，图像通道数）"""X_paded = np.pad(X,((0,0),(pad,pad),(pad,pad),(0,0)),'constant')return X_paded

测试：

np.random.seed(1)
x = np.random.randn(4,3,3,2)
x_paded = zero_pad(x,2)print(x.shape,x_paded.shape,x[1,1],x_paded[1,1])fig,axarr = plt.subplots(1,2)
axarr[0].set_title('x')
axarr[0].imshow(x[0,:,:,0])
axarr[1].set_title('x_paded')
axarr[1].imshow(x_paded[0,:,:,0])

结果：

(4, 3, 3, 2) (4, 7, 7, 2) [[ 0.90085595 -0.68372786][-0.12289023 -0.93576943][-0.26788808  0.53035547]] [[0. 0.][0. 0.][0. 0.][0. 0.][0. 0.][0. 0.][0. 0.]]

在这里插入图片描述

1.3、单步卷积

过滤器大小f=3，步伐s=1，填充pad=2。

def conv_single_step(a_slice_prev,W,b):"""在前一层的激活输出的一个片段上应用一个由参数W定义的过滤器。这里切片大小和过滤器大小相同。参数：a_slice_prev - 输入数据的一个片段，维度为（过滤器大小，过滤器大小，上一通道数）W - 权重参数，包含在了一个矩阵中，维度为（过滤器大小，过滤器大小，上一通道数）b - 偏置参数，包含在了一个矩阵中，维度为（1,1,1）返回：Z - 在输入数据的片x上卷积滑动窗口（W,b）的结果。"""s = a_slice_prev*W+bZ = np.sum(s)return Z

测试：

np.random.seed(1)
a_slice_prev = np.random.randn(4,4,3)
W = np.random.randn(4,4,3)
b = np.random.randn(1,1,1)Z = conv_single_step(a_slice_prev,W,b)
print(Z)

结果：

-23.16021220252078

1.4、卷积层前向传播

def conv_forward(A_prev,W,b,hparameters):"""实现卷积函数的前向传播参数：A_prev - 上一层的激活输出矩阵，维度为（m，n_H_prev,n_C_prev),(样本数量，上一层图像的高度，上一层图像的宽度，上一层过滤器数量)W - 权重矩阵，维度为（f，f,n_C_prev,n_c）,(过滤器大小，过滤器大小，上一层的过滤器数量，这一层的过滤器数量)b - 偏置矩阵，维度为（1，1，1，n_C），（1，1，1，这一层的过滤器数量）hparameters - 包含了“stride”与“pad”的超参数字典。返回：Z - 卷积输出，维度为（m,n_H,n_W,n_C）,(样本数，图像的高度，图像的宽带，过滤器数量)cache - 缓存了一些反向传播函数conv_backward()需要的一些数据"""(m,n_H_prev,n_W_rev,n_C_prev) = A_prev.shape(f,f,n_C_prev,n_C) = W.shapestride = hparameters['stride']pad = hparameters['pad']n_H = int((n_H_prev+2*pad-f)/stride)+1n_W = int((n_W_rev+2*pad-f)/stride)+1Z = np.zeros((m,n_H,n_W,n_C))A_prev_pad = zero_pad(A_prev,pad)for i in range(m):a_prev_pad = A_prev_pad[i]for h in range(n_H):for w in range(n_W):for c in range(n_C):vert_start = h*stridevert_end = vert_start+fhoriz_start = w*stridehoriz_end = horiz_start+fa_slip_prev = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]Z[i,h,w,c] = conv_single_step(a_slip_prev,W[:,:,:,c],b[0,0,0,c])cache = (A_prev,W,b,hparameters)return (Z,cache)

测试：

np.random.seed(1)A_prev = np.random.randn(10,4,4,3)
W = np.random.randn(2,2,3,8)
b = np.random.randn(1,1,1,8)hparameters = {'pad':2,'stride':1}Z,cache_conv = conv_forward(A_prev,W,b,hparameters)print(np.mean(Z))
print(cache_conv[0][1][2][3])

结果：

0.15585932488906465
[-0.20075807  0.18656139  0.41005165]

1.5、池化层前向传播

def pool_forward(A_prev,hparameters,mode='max'):"""实现池化层的前向传播参数：A_prev - 输入数据，维度为（m,n_H_prev,n_W_prev,n_C_prev）hparameters - 包含了‘f'和’stride‘的超参数字典mode - 模式选择【’max‘|‘average’】返回：A - 池化层的输出，维度为（m,n_H,n_W,n_C）cache - 存储了一些反向传播需要用到的值，包含了输入和超参数的字典。"""(m,n_H_prev,n_W_prev,n_C_prev)=A_prev.shapef = hparameters['f']stride = hparameters['stride']n_H = int((n_H_prev-f)/stride)+1n_W = int((n_W_prev-f)/stride)+1n_C = n_C_prevA = np.zeros((m,n_H,n_W,n_C))for i in range(m):a_prev = A_prev[i]for h in range(n_H):for w in range(n_W):for c in range(n_C):vert_start = h*stridevert_end = vert_start+fhoriz_start = w*stridehoriz_end = horiz_start+fa_slice_prev = a_prev[vert_start:vert_end,horiz_start:horiz_end,c]if mode=='max':A[i,h,w,c] = np.max(a_slice_prev)elif mode=='average':A[i,h,w,c] = np.mean(a_slice_prev)cache = (A_prev,hparameters)return A,cache

测试：

np.random.seed(1)A_prev = np.random.randn(2,4,4,3)hparameters = {'f':4,'stride':1}A,cache = pool_forward(A_prev,hparameters,mode='max')
print(A)
A,cache = pool_forward(A_prev,hparameters,mode='average')
print(A)

结果：

[[[[1.74481176 1.6924546  2.10025514]]][[[1.19891788 1.51981682 2.18557541]]]]
[[[[-0.09498456  0.11180064 -0.14263511]]][[[-0.09525108  0.28325018  0.33035185]]]]

1.6、卷积层的反向传播

1.6.1、计算dA

$dA+=\sum_{h=0}^{n_H} \sum_{w=0}^{n_W} W_C \times dZ_{hw}$
其中， $W_c$ 是过滤器， $Z_hw$ 是一个标量， $Z_hw$ 是卷积层第h行第w列的使用点乘计算后的输出Z的梯度。需要注意的是在每次更新dA的时候，都会用相同的过滤器 $W_c$ 乘以不同的dZ，因为在前向传播的时候，每个过滤器都与a_slice进行了点乘相加，所以在计算dA的时候，需要把a_slice的梯度也加进来，可以在循环中加一句代码：

da_perv_pad[vert_start:vert_end,horiz_start:horiz_end,:] += W[:,:,:,c] * dZ[i,h,w,c]

1.6.2、计算dW

$dW_c+=\sum_{h=0}^{n_H} \sum_{w=0}^{n_W} a_{slice} \times dZ_{hw}$
其中， $a_{slice}$ 对应着 $Z_{ij}$ 的激活值，由此，可以推导W的梯度，因为使用了过滤器来对数据进行窗口滑动，在这里实际上是切出了和过滤器一样大小的切片，切了多少次就产生了多少个梯度，所以需要把它们加起来得到这个数据集的整体dW。

dW[:,:,:, c] += a_slice * dZ[i , h , w , c]

1.6.2、计算db

$db+=\sum_{h=0}^{n_H} \sum_{w=0}^{n_W} dZ_{hw}$

db[:,:,:,c] += dZ[ i, h, w, c]

def conv_backward(dZ,cache):"""实现卷积层的反向传播参数：dZ - 卷积层的输出z的梯度，维度为（m,n_H,n_W,n_C)cache - 反向传播所需要的参数，conv_forward()的输出之一返回：dA_prev - 卷积层的输入(A_prev)的梯度值，维度为（m,n_H_prev,n_W_prev,n_C_prev）dW - 卷积层的权值的梯度，维度为（f,f,n_C_prev,n_C）db - 卷积层的偏置的梯度，维度为（1，1，1，n_C）"""(A_prev,W,b,hparameters) = cache(m,n_H_prev,n_W_prev,n_C_prev) = A_prev.shape(m,n_H,n_W,n_C) = dZ.shape(f,f,n_C_prev,n_C) = W.shapepad = hparameters['pad']stride = hparameters['stride']dA_prev = np.zeros((m,n_H_prev,n_W_prev,n_C_prev))dW = np.zeros((f,f,n_C_prev,n_C))db = np.zeros((1,1,1,n_C))A_prev_pad = zero_pad(A_prev,pad)dA_prev_pad = zero_pad(dA_prev,pad)for i in range(m):a_prev_pad = A_prev_pad[i]da_prev_pad = dA_prev_pad[i]for h in range(n_H):for w in range(n_W):for c in range(n_C):vert_start = hvert_end = vert_start+fhoriz_start = whoriz_end = horiz_start+fa_slice = a_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]da_prev_pad[vert_start:vert_end,horiz_start:horiz_end,:]+=W[:,:,:,c]*dZ[i,h,w,c]dW[:,:,:,c] += a_slice*dZ[i,h,w,c]db[:,:,:,c] += dZ[i,h,w,c]dA_prev[i,:,:,:] = da_prev_pad[pad:-pad,pad:-pad,:]assert(dA_prev.shape==(m,n_H_prev,n_W_prev,n_C_prev))return dA_prev,dW,db

测试：

np.random.seed(1)A_prev = np.random.randn(10,4,4,3)
W = np.random.randn(2,2,3,8)
b = np.random.randn(1,1,1,8)
hparameters = {'pad':2,'stride':1}Z,cache_conv = conv_forward(A_prev,W,b,hparameters)
dA_prev,dW,db = conv_backward(Z,cache_conv)print(np.mean(dA_prev),np.mean(dW),np.mean(db))

结果：

9.608990675868995 10.581741275547566 76.37106919563735

1.7、池化层的反向传播

1.7.1、最大值池化层的反向传播

首先，我们需要创建一个create_mask_from_window()的函数，这个函数创建一个掩码矩阵，以保存最大值的位置，当为1的时候表示最大值的位置，其他的为0，这个是最大值池化层。
为什么要创建这个掩码矩阵呢？因为我们需要记录最大值的位置，这样才能反向传播到卷积层。
在这里插入图片描述

def create_mask_from_window(x):"""从输入矩阵中创建掩码，以保存最大值的矩阵的位置。参数：x - 一个维度为（f，f）的矩阵返回：mask - 包含x的最大值的位置的矩阵"""mask = x == np.max(x)return mask

测试：

np.random.seed(1)x = np.random.randn(2,3)
mask = create_mask_from_window(x)
print(x,mask)

结果：

[[ 1.62434536 -0.61175641 -0.52817175][-1.07296862  0.86540763 -2.3015387 ]] [[ True False False][False False False]]

1.7.2、均值池化层的反向传播

和最大值池化层不同，均值池化层取过滤器的均值。

def distribute_value(dz,shape):"""给定一个值，为按矩阵大小平均分配到每一个矩阵位置中。参数：dz - 输入的实数shape - 元组，两个值，分别为n_H,n_W返回：a - 已经分配好了值的矩阵，里面的值全部一样。"""(n_H,n_W) = shapeaverage = dz/(n_H*n_W)a = np.ones(shape)*averagereturn a

测试：

dz = 2
shape = (2,2)a = distribute_value(dz,shape)
print(a)

结果：

[[0.5 0.5][0.5 0.5]]

1.7.3、池化层反向传播

def pool_backward(dA,cache,mode="max"):"""实现池化层的反向传播参数：dA - 池化层的输出的梯度，和池化层的输出的维度一样cache - 池化层前向传播时所存储的参数mode - 模式选择，【‘max’|‘average’】返回：dA_prev - 池化层的输入的梯度，和A_prev的维度相同"""(A_prev,hparameters) = cachef = hparameters['f']stride = hparameters['stride'](m,n_H_prev,n_W_prev,n_C_prev) = A_prev.shape(m,n_H,n_W,n_C) = dA.shapedA_prev = np.zeros_like(A_prev)for i in range(m):a_prev = A_prev[i]for h in range(n_H):for w in range(n_W):for c in range(n_C):vert_start = hvert_end = vert_start + fhoriz_start = whoriz_end = horiz_start + fif mode == 'max':a_prev_slice = a_prev[vert_start:vert_end,horiz_start:horiz_end,c]mask = create_mask_from_window(a_prev_slice)dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]+=np.multiply(mask,dA[i,h,w,c])elif mode == 'average':da = dA[i,h,w,c]shape = (f,f)dA_prev[i,vert_start:vert_end,horiz_start:horiz_end,c]+=distribute_value(da,shape)assert(dA_prev.shape == A_prev.shape)return dA_prev

测试：

np.random.seed(1)A_prev = np.random.randn(5,5,3,2)
W = np.random.randn(2,2,3,8)
b = np.random.randn(1,1,1,8)
hparameters = {'f':2,'stride':1}
A,cache = pool_forward(A_prev,hparameters)
dA = np.random.randn(5,4,2,2)dA_prev = pool_backward(dA,cache,mode='max')
print(np.mean(dA),dA_prev[1,1])dA_prev = pool_backward(dA,cache,mode='average')
print(np.mean(dA),dA_prev[1,1])

结果：

0.14026942447888846 [[ 0.          0.        ][-0.72334716  2.42826793][ 0.          0.        ]]
0.14026942447888846 [[-0.0103192   0.16889297][-0.18083679  0.69818344][-0.17051759  0.52929047]]

二、基于tensorflow的卷积神经网络

situation：使用tensorflow来实现卷积神经网络，然后应用到手势识别中。

2.0、导入库

import math
import numpy as np
import h5py
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import tensorflow as tf
from tensorflow.python.framework import opsimport cnn_utils
import tf_utilsnp.random.seed(1)

在这里插入图片描述
看里面的内容：

X_train_orig , Y_train_orig , X_test_orig , Y_test_orig , classes = tf_utils.load_dataset()
index = 6
plt.imshow(X_train_orig[index])
print(str(np.squeeze(Y_train_orig[:,index])))

结果：

在这里插入图片描述
调整数据，看数据的维度：

X_train = X_train_orig/255
X_test = X_test_orig/255
Y_train = cnn_utils.convert_to_one_hot(Y_train_orig,6).T
Y_test = cnn_utils.convert_to_one_hot(Y_test_orig,6).Tprint(X_train.shape[0],X_test.shape[0],X_train.shape,Y_train.shape,X_test.shape,Y_test.shape)

结果：

1080 120 (1080, 64, 64, 3) (1080, 6) (120, 64, 64, 3) (120, 6)

2.1、创建placeholders

tensorflow要求为会话时将输入到模型中的输入数据创建占位符。因为我们使用的是小批量数据块，输入的样本数量可能不固定，所以在数量那里我们要使用None作为可变数量，输入X的维度为[None,n_H0,n_W0,n_c0]，对应的Y是[None,n_y]。

def create_placeholders(n_H0,n_W0,n_C0,n_y):"""为session创建占位符参数：n_H0 - 实数，输入图像的高度n_W0 - 实数，输入图像的宽度n_C0 - 实数，输入的通道数n_y - 实数，分类数返回：X - 输入数据的占位符，维度为[None,n_H0,n_W0,n_C0]，类型为‘float’Y - 输入数据的标签的占位符，维度为[None,n_y]，类型为‘float’"""X = tf.placeholder(tf.float32,[None,n_H0,n_W0,n_C0])Y = tf.placeholder(tf.float32,[None,n_y])return X,Y

测试：

X,Y = create_placeholders(64,64,3,6)
print(X,Y)

结果：

Tensor("Placeholder:0", shape=(?, 64, 64, 3), dtype=float32) Tensor("Placeholder_1:0", shape=(?, 6), dtype=float32)

2.2、初始化参数

def initialize_parameters():"""初始化权值矩阵，这里我们把权值矩阵硬编码W1:[4,4,3,8]W2:[2,2,8,16]返回：包含了tensor类型的W1、W2的字典"""tf.set_random_seed(1)W1 = tf.get_variable('W1',[4,4,3,8],initializer=tf.contrib.layers.xavier_initializer(seed=0))W2 = tf.get_variable('W2',[2,2,8,16],initializer=tf.contrib.layers.xavier_initializer(seed=0))parameters = {'W1':W1,'W2':W2}return parameters

测试：

tf.reset_default_graph()
with tf.Session() as sess_test:parameters = initialize_parameters()init = tf.global_variables_initializer()sess_test.run(init)print(parameters['W1'].eval()[1,1,1])print(parameters['W2'].eval()[1,1,1])sess_test.close()

结果：

[ 0.00131723  0.1417614  -0.04434952  0.09197326  0.14984085 -0.03514394-0.06847463  0.05245192]
[-0.08566415  0.17750949  0.11974221  0.16773748 -0.0830943  -0.08058-0.00577033 -0.14643836  0.24162132 -0.05857408 -0.19055021  0.1345228-0.22779644 -0.1601823  -0.16117483 -0.10286498]

2.3、前向传播

模型的结构：
conv2d->relu->maxpool->conv2d->relu->maxpool->fullconnected
步骤和参数：

Conv2d：步伐：1，填充方式：‘SAME’
Relu
Max pool：过滤器大小：8x8，步伐：8x8，填充方式：‘SAME’
Conv2d：步伐：1，填充方式：‘SAME’
Relu
Max pool：过滤器大小：4x4，步伐：4x4，填充方式：‘SAME’
一维化上一层的输出
全连接层（FC）：使用没有非线性激活函数的全连接层。这里不用调用SoftMax，这将导致输出层中有6个神经元，然后再传递到softmax。

def forward_propagation(X,parameters):"""实现前向传播：conv2d->relu->maxpool->conv2d->relu->maxpool->flatten->fullyconnected参数：X - 输入数据的placeholder，维度为（输入节点数量，样本数量）parameters - 包含了’W1‘和’W2‘的python字典返回：Z3 - 最后一个linear节点的输出"""W1 = parameters['W1']W2 = parameters['W2']# Conv2d：步伐：1，填充方式：’SAME'Z1 = tf.nn.conv2d(X,W1,strides=[1,1,1,1],padding='SAME')# ReluA1 = tf.nn.relu(Z1)# Max pool：窗口大小：8x8，步伐：8X8，填充方式：’SAME'P1 = tf.nn.max_pool(A1,ksize=[1,8,8,1],strides=[1,8,8,1],padding='SAME')# Conv2d：步伐：1，填充方式：’SAME'Z2 = tf.nn.conv2d(P1,W2,strides=[1,1,1,1],padding='SAME')# ReluA2 = tf.nn.relu(Z2)# Max pool：窗口大小：4x4，步伐：4X4，填充方式：’SAME'P2 = tf.nn.max_pool(A2,ksize=[1,4,4,1],strides=[1,4,4,1],padding='SAME')# 一维化上一层的输出P = tf.contrib.layers.flatten(P2)# 全连接层（FC）：使用没有非线性激活函数的全连接层Z3 = tf.contrib.layers.fully_connected(P,6,activation_fn = None)return Z3

测试：

tf.reset_default_graph()
np.random.seed(1)with tf.Session() as sess_test:X,Y = create_placeholders(64,64,3,6)parameters = initialize_parameters()Z3 = forward_propagation(X,parameters)init = tf.global_variables_initializer()sess_test.run(init)a = sess_test.run(Z3,{X:np.random.randn(2,64,64,3),Y:np.random.randn(2,6)})print(a)sess_test.close()

结果：

[[-0.44670227 -1.5720876  -1.5304923  -2.3101304  -1.2910438   0.46852064][-0.17601591 -1.5797201  -1.4737016  -2.616721   -1.0081065   0.5747785 ]]

2.4、计算成本

def compute_cost(Z3,Y):"""计算成本参数：Z3 - 正向传播最后一个linear节点的输出，维度为（6，样本数）Y - 标签向量的placeholder，和Z3的维度相同返回：cost - 计算后的成本"""cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3,labels=Y))return cost

测试：

tf.reset_default_graph()
with tf.Session() as sess_test:np.random.seed(1)X,Y = create_placeholders(64,64,3,6)parameters = initialize_parameters()Z3 = forward_propagation(X,parameters)cost = compute_cost(Z3,Y)init = tf.global_variables_initializer()sess_test.run(init)a = sess_test.run(cost,{X:np.random.randn(4,64,64,3),Y:np.random.randn(4,6)})print(a)sess_test.close()

结果：

2.9103398

2.5、构建模型

步骤：

创建占位符
初始化参数
前向传播
计算成本
反向传播
创建优化器
最后将创建一个session来运行模型。

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.set_random_seed(1)seed = 3(m,n_H0,n_W0,n_C0) = X_train.shapen_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 = 0num_minibatches = int(m/minibatch_size)seed = seed + 1minibatches = 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_minibatchesif print_cost:if epoch%5==0:print('epoch=',epoch,',minibatch_cost=',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(accuracy)train_accurary = accuracy.eval({X:X_train,Y:Y_train})test_accuary = accuracy.eval({X:X_test,Y:Y_test})print(train_accurary)print(test_accuary)return (train_accurary,test_accuary,parameters)

测试：

_,_,parameters = model(X_train,Y_train,X_test,Y_test,num_epochs=100)

结果：

epoch= 0 ,minibatch_cost= 1.9179195687174797
epoch= 5 ,minibatch_cost= 1.5324752107262611
epoch= 10 ,minibatch_cost= 1.0148038603365421
epoch= 15 ,minibatch_cost= 0.8851366713643074
epoch= 20 ,minibatch_cost= 0.7669634483754635
epoch= 25 ,minibatch_cost= 0.651207884773612
epoch= 30 ,minibatch_cost= 0.6133557204157114
epoch= 35 ,minibatch_cost= 0.6059311926364899
epoch= 40 ,minibatch_cost= 0.5347129087895155
epoch= 45 ,minibatch_cost= 0.5514022018760443
epoch= 50 ,minibatch_cost= 0.49697646126151085
epoch= 55 ,minibatch_cost= 0.4544383566826582
epoch= 60 ,minibatch_cost= 0.45549566112458706
epoch= 65 ,minibatch_cost= 0.4583591800183058
epoch= 70 ,minibatch_cost= 0.4500396177172661
epoch= 75 ,minibatch_cost= 0.4106866829097271
epoch= 80 ,minibatch_cost= 0.46900513023138046
epoch= 85 ,minibatch_cost= 0.389252956956625
epoch= 90 ,minibatch_cost= 0.3638075301423669
epoch= 95 ,minibatch_cost= 0.3761322880163789
Tensor("Mean_1:0", shape=(), dtype=float32)
0.86851853
0.73333335