神经网络搭建“八股”

一、基本概念

     1.张量

张量就是多维数组,“阶”表示张量的维度

0阶张量是一个单独的数,称为标量,如:S = 123

1阶张量是一个一维数组,称为向量,如:V = [1, 2, 3]

2阶张量是一个二维数组,称为矩阵,如:M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

.......

n阶张量,如:t = [[[[·····]]]···]]] ,右边有n个方括号即为n阶张量

     2.数据类型

Tensorflow  的数据类型有  tf.float32 、tf.int32等

     3.计算图

搭建神经网络的计算过程,是承载一个或多个计算节点的一张图,只搭建网络,不运算。如:

                                 

x1、x2表示输入, w1、w2分别是 x1 到 y 和 x2 到 y 的权重, y = x1*w1+x2*w2

实现上述计算图: 

import tensorflow as tf              #引入模块
x = tf.constant([[1.0, 2.0]])        #定义一个 2 阶张量等于[[1.0,2.0]]
w = tf.constant([[3.0], [4.0]])      #定义一个 2 阶张量等于[[3.0],[4.0]]
y = tf.matmul(x, w)                  #实现 x w 矩阵乘法
print y                              #打印出结果

 执行上述代码后可以得到如下结果,结果显示y是一个张量,没有实际运算,只是搭建承载计算过程的
     计算图,如果要得到运算结果,需要使用“会话(Session)”。

Tensor(“matmul:0”, shape(1,1), dtype=float32)

     3.会话(Session)

执行计算图中的节点运算,使用with结构实现,如下:

import tensorflow as tf                  #引入模块
x = tf.constant([[1.0, 2.0]])            #定义一个 2 阶张量等于[[1.0,2.0]]
w = tf.constant([[3.0], [4.0]])          #定义一个 2 阶张量等于[[3.0],[4.0]]
y = tf.matmul(x, w)                      #实现 xw 矩阵乘法
print y                                  #打印出结果
with tf.Session() as sess:
    print sess.run(y)                    #执行会话并打印出执行后的结果

 执行上述代码后可以得到如下结果,运行Session()会话前只打印出y是个张量的提示,运行Session()
     会话后打印出了 y 的结果 1.0 * 3.0 + 2.0 * 4.0 = 11.0。

Tensor(“matmul:0”, shape(1,1), dtype=float32)
[[11.]] 

二、神经网络的参数

神经网络的参数是指神经元线上的权重w,用变量表示,一般会先随机生成这些参数。生成参数的方法如下:

函数作用举例
tf.random_normal( )生成正态分布随机数w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))表示生成形状两行三列矩阵,标准差是 2,均值是 0,随机种子是 1
tf.truncated_normal()生成去掉过大偏离点的正态分布随机数w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))表示去掉偏离过大的正态分布,也就是如果随机出来的数据偏离平均值超过两个标准差,这个数据将重新生成
tf.random_uniform()生成均匀分布随机数w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32,seed=1)表示从一个均匀分布[minval maxval)中随机采样,注意定义域是左闭右开
tf.zeros表示生成全0数组tf.zeros([3,2],int32)表示生成[[0,0],[0,0],[0,0]]
tf.ones表示生成全1数组tf.ones([3,2],int32)表示生成[[1,1],[1,1],[1,1]
tf.fill表示生成全定值数组tf.fill([3,2],6)表示生成[[6,6],[6,6],[6,6]]
tf.constant表示生成直接给定值的数组tf.constant([3,2,1])表示生成[3,2,1]

三、神经网络的搭建

       基于神经网络的机器学习主要分为两个过程,即训练过程(前三步)和使用过程(第四步)。训练过程循环迭代,使用过程一旦参数优化完成就可以固定这些参数,实现特定应用了。

  •  准备数据集,提取特征,作为输入喂给神经网络
  • 搭建 N NN  结构,从输入到输出(先搭建计算图,再用会话执行)

NN  前向传播算法  -----> 计算输出

  • 大量特征数据喂给  NN ,迭代优化 N NN 

NN  反向传播算法 -----> 优化参数训练模型

  • 使用训练好的模型预测和分类

四、前向传播

       前向传播就是搭建模型的计算过程,让模型具有推理能力,可以针对一组输入给出相应的输出。

     1. 举例

       假如生产一批零件,体积为 x1,重量为 x2,体积和重量就是我们选择的特征,把它们喂入神经网络,当体积和重量这组数据走过神经网络后会得到一个输出。假如输入的特征值是:体积 0.7 重量 0.5

             

       由搭建的神经网络可得,隐藏层节点 a11 = x1 *  w11 + x2 * w21 = 0.14 + 0.15 = 0.29,同理算得节点 a12 = 0.32,

a13 = 0.38,最终计算得到输出层 Y = -0.015,这便实现了前向传播过程。

     2. 推导

    第一层:

  • X是输入为1 × 2的矩阵

       用 X表示输入,是一个 1 行 2 列矩阵,表示一次输入一组特征,这组特征包含了体积和重量两个元素。

  • W_{m,n}^{l}为待优化参数

       对于第一层的 w 前面有两个节点,后面有三个节点 w 应该是个两行三列矩阵,我们这样表示:

                                                                          W^{^{(1)}}=\begin{bmatrix} W_{1,1}^{(1)} & W_{1,2}^{(1)}& W_{1,3}^{(1)}\\ W_{2,1}^{(1)}& W_{2,2}^{(1)}&W_{2,3}^{(1)} \end{bmatrix}

  • 神经网络的层数知道是计算层,输入不是计算层,所以a为 第一层网络,a是一个一行三列矩阵。

                                                                          a(1)=[a_{11}, a_{12}, a_{13}]=XW^{(1)}

    第二层:

       参数要满足前面三个节点 ,后面一个节点 ,所以 W^{(2)}是三行一列矩阵 。

                                                                           W^{(2)}=\begin{bmatrix} W_{1,1}^{(2)}\\ W_{2,1}^{(2)}\\ W_{3,1}^{(2)} \end{bmatrix}

    计算:

       用每层输入乘以线上的权重W就可以计算出输出 y 。

     3.  前向传播过程的tensorflow描述

  • 用 placeholder 实现输入定义(sess.run 中喂入一组数据)的情况
# 两层简单的神经网络
import tensorflow as tf

# 定义输入和参数
# 用placeholder实现输入定义(sess.run中喂入一组数据)
x = tf.placeholder(tf.float32, shape=(1, 2))
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

# 定义前向传播
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 用会话计算结果
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print('y is :', sess.run(y, feed_dict={x: [[0.7, 0.5]]}))

执行上述代码后可以得到如下结果:

y is : [[3.0904665]]
  • 用 placeholder 实现输入定义(sess.run 中喂入多组数据)的情况
# 两层简单的神经网络
import tensorflow as tf

# 定义输入和参数
# 用placeholder定义输入(sess.run喂多组数据)
x = tf.placeholder(tf.float32, shape=(None, 2))
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev= 1, seed=1))

# 定义前向传播过程
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 调用会话计算结果
with tf.Session() as sess:
    int_op = tf.global_variables_initializer()
    sess.run(int_op)
    print('the result is: ', sess.run(y, feed_dict={x : [[0.7, 0.5],
                                                        [0.2, 0.3],
                                                        [0.3, 0.4],
                                                        [0.4, 0.5]]}))
    print('w1: ', sess.run(w1))
    print('w2: ', sess.run(w2))

执行上述代码后可以得到如下结果:

the result is:  
[[3.0904665]
 [1.2236414]
 [1.7270732]
 [2.2305048]]
w1:  [[-0.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
w2:  [[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]

五、反向传播

     1. 反向传播

训练模型参数 ,在所有参数上用梯度下降,使神经网络模型在训练数据上的损失函数最小。

     2. 损失函数

计算得到的预测值y与已知答案y_的差距。

     3. 均方误差ESE

均方误差 MSE 是比较常用的方法之一,计算方法如下:

                                      

     4. 反向传播训练方法

以减小loss值为优化目标,有梯度下降、momentum优化器、adam优化器等优化方法。

     5. 学习率

学习率决定每次参数更新的幅度。如果学习率选择过大会出现震荡不收敛的情况,如果学习率选择过小,会出现收敛速度慢的情况。我们可以选个比较小的值填入,比如 0.01、0.001。

六、搭建神经网络的八股

     1. 步骤

  • 模块导入,生成数据集
  • 前向传播,定义输入、参数和输出
  • 反向传播:定义损失函数、反向传播方法
  • 生成会话,训练STEPS 

     2. 具体实现

     随机产生32组生产出的零件的体积和重量,训练5000 轮,每500 轮输出一次损失函数。源代码如下:

# 0导入模块,生成模拟数据集
import tensorflow as tf
import numpy as np

BATCH_SIZE = 8
seed = 23455

# 基于seed产生随机数
rng = np.random.RandomState(seed)
# 随机数返回32行2列的矩阵 表示32组 体积和重量 作为输入数据集
X = rng.rand(32, 2)
# 从X这个32行2列的矩阵中 取出一行 判断如果和小于1 给Y赋值1 如果和不小于1 给Y赋值0
# 作为输入数据集的标签(正确答案)
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print('X: ', X)
print('Y', Y)

# 1定义神经网络的输入、参数和输出,定义前向传播过程
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))

a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

# 2定义损失函数及单向传播方法
loss = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
# train_step = tf.train.MomentumOptimizer(0.001, 0.9).minimize(loss)
# train_step = tf.train.AdadeltaOptimizer(0.001).minimize(loss)

# 3生成会话,训练step轮
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    # 输出目前(未经训练)的参数取值
    print('w1: ', sess.run(w1))
    print('w2: ', sess.run(w2))
    print('\n')

    # 训练模型
    STEPS = 5000
    for i in range(STEPS):
        start = (i * BATCH_SIZE) % 32
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
        if i % 500 == 0:
            total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
            print('After %d training step(s), loss on all data is %g' %(i, total_loss))

    # 输出训练后的参数取值
    print('\n')
    print('w1: ', sess.run(w1))
    print('w2: ', sess.run(w2))

执行上述代码后可以得到如下结果:

X:  [[0.83494319 0.11482951]
 [0.66899751 0.46594987]
 [0.60181666 0.58838408]
 [0.31836656 0.20502072]
 [0.87043944 0.02679395]
 [0.41539811 0.43938369]
 [0.68635684 0.24833404]
 [0.97315228 0.68541849]
 [0.03081617 0.89479913]
 [0.24665715 0.28584862]
 [0.31375667 0.47718349]
 [0.56689254 0.77079148]
 [0.7321604  0.35828963]
 [0.15724842 0.94294584]
 [0.34933722 0.84634483]
 [0.50304053 0.81299619]
 [0.23869886 0.9895604 ]
 [0.4636501  0.32531094]
 [0.36510487 0.97365522]
 [0.73350238 0.83833013]
 [0.61810158 0.12580353]
 [0.59274817 0.18779828]
 [0.87150299 0.34679501]
 [0.25883219 0.50002932]
 [0.75690948 0.83429824]
 [0.29316649 0.05646578]
 [0.10409134 0.88235166]
 [0.06727785 0.57784761]
 [0.38492705 0.48384792]
 [0.69234428 0.19687348]
 [0.42783492 0.73416985]
 [0.09696069 0.04883936]]
Y [[1], [0], [0], [1], [1], [1], [1], [0], [1], [1], [1], [0], [0], [0], [0], [0], [0], [1], [0], [0], [1], [1], [0], [1], [0], [1], [1], [1], [1], [1], [0], [1]]、
w1:  [[-0.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
w2:  [[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]


After 0 training step(s), loss on all data is 5.13118
After 500 training step(s), loss on all data is 0.429111
After 1000 training step(s), loss on all data is 0.409789
After 1500 training step(s), loss on all data is 0.399923
After 2000 training step(s), loss on all data is 0.394146
After 2500 training step(s), loss on all data is 0.390597
After 3000 training step(s), loss on all data is 0.388336
After 3500 training step(s), loss on all data is 0.386855
After 4000 training step(s), loss on all data is 0.385863
After 4500 training step(s), loss on all data is 0.385186


w1:  [[-0.69597054  0.85992473  0.09337731]
 [-2.3418374  -0.12466972  0.5866561 ]]
w2:  [[-0.07531643]
 [ 0.8627887 ]
 [-0.05937824]]

中国大学MOOC《人工智能实践:Tensorflow笔记》笔记

### 深度学习中的卷积神经网络基础 #### 卷积神经网络(CNN)原理 卷积神经网络是一种专门用于处理具有网格状拓扑数据的前馈神经网络,最常应用于图像识别和分类任务。其核心思想在于通过局部感知野和权值共享来减少计算复杂度并提取空间特征[^1]。 - **卷积层**:这是 CNN 的基本构建模块之一,负责从输入数据中提取特征。卷积操作通过对输入矩阵应用一组可学习的滤波器实现,这些滤波器可以检测边缘、纹理或其他视觉模式。 - **池化层**:通常紧跟在卷积层之后,用于降低特征图的空间维度,从而减少参数数量和计算量。常用的池化方式包括最大池化和平均池化[^2]。 - **全连接层**:位于网络的最后一部分,将前面提取到的高维特征映射到类别标签上。这一层的作用类似于传统神经网络的功能。 - **激活函数**:ReLU 是目前广泛使用的非线性激活函数,它能够有效缓解梯度消失问题,并加速收敛过程[^3]。 #### 常见的应用场景 卷积神经网络因其强大的特征提取能力,在多个领域得到了广泛应用: - 图像分类与目标检测:如 AlexNet, VGG, ResNet 等经典架构均基于 CNN 设计而成; - 自然语言处理:尽管 RNN 和 Transformer 更为主流,但在某些特定任务中仍可见到 CNN 的身影; - 医疗影像分析:利用 CNN 对 X 光片、MRI 扫描结果进行疾病诊断等[^4]; #### 面试可能涉及的经典题目 以下是围绕卷积神经网络的一些典型面试考察点及其解答思路: 1. **什么是感受野?如何增大它的范围而不增加额外开销** - 受感野定义为单个像素位置处所覆盖的实际区域大小。可以通过堆叠更多层数或者采用膨胀卷积技术间接扩大受感野而无需显著提升资源消耗。 2. **解释一下 Inception 结构的设计理念是什么样的?** - Google 提出的 Inception Module 主要目的是探索最优尺度组合的同时保持高效运算效率。具体做法是在同一层内部平行设置多种尺寸核大小的操作选项供选择使用。 3. **Batch Normalization 起到了哪些作用呢 ?** - BN 技术不仅可以加快训练速度还能起到一定正则效果防止过拟合现象发生 。另外也有助于缓解 Internal Covariate Shift 问题改善优化性能表现. ```python import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() self.conv_layer = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=(3, 3)) self.pooling_layer = nn.MaxPool2d(kernel_size=(2, 2), stride=2) self.fc_layer = nn.Linear(64 * (image_height//2) * (image_width//2), num_classes) def forward(self, x): x = self.conv_layer(x) x = nn.functional.relu(x) x = self.pooling_layer(x) x = x.view(-1, 64 * (image_height//2) * (image_width//2)) # Flatten the tensor output = self.fc_layer(x) return output ```
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值