人工智能专业深度学习课复习笔记

以下复习内容来自深度学习原理与TensorFlow实践 ·黄理灿 编著
以及专业学习通学习内容代码

一. 机器学习相关的相关知识
(1) 微积分（导数部分）
导数公式：

例题1由y=x2+2x+2
得y’=2x+1
其中x2 因为公式y=xu y’=uxu-1得2x
2x 因为公式y=x y’=1 得1
2因为公式y=c y’=0 得0
例题2f(x)=2x2+4x+1 g(x)=2x+1求
(1) f(g(x))’
f(g(x))’先算f(g(x))得2(2x+1)(2x+1)+4·
(2x+1)+1
得(16x2+16x)’
结果为(16x+16)

（2）线性代数（矩阵）

（3）概率论
概率：样本空间S具有有限个基本事件，并且这些基本事件可能发生的情况下，事件A在本事件数占S中的所有基本时间的比例。:
P(A)=A包含基本事件数/S所有基本事件数
条件概率：在某一事件已发生的情况下，另一事件发生的概率。例如A已发生的条件下，B发生的概率:
P(B|A)=P(AB)/P(A)
全概率公式：

贝叶斯公式：

例题：找次品问题：A, B,C 产品占比分布为 1/2， 1/6， 1/3； A, B,C的次品率分布为 0.2， 0.1， 0.3； 求出现次品是A做出来的概率；
P(A)=1/2 , P(B)=1/6 , P©=1/3
P(z)表示损坏设备概率
则P(Z|A)=0.2=1/5 P(Z|B)=0.1=1/10 P(Z|C)=0.3=3/10
P(A|Z)=P(A))P(Z|A)/P(A)P(Z|A)+P(B)·P(Z|B)+P©·P(Z|C)
=1/2 x 1/5 / 1/2 x 1/5 + 1/6 x 1/10 + 1/3 x 3/10
=1/10 / 13/60 = 6/13 ≈ 0.4615

题目引用自： https://blog.csdn.net/qq_36533552/article/details/109542337

二．机器学习方法
1.监督学习的原理：
监督学习假定训练数据和真实预测数据属于同一概率分布并且相互独立。监督学习通过训练学习到数据的概率分布，并应用到真实的预测上。
（1）输入空间，特征空间和输出空间
输入空间与输出空间可以相同，也可以不同，通常输出空间要远小于输入空间。每个具体的输入称为一个实例（Instance），由特征向量（Feature Vector）表示。所有特征向量形成特征空间（Feature Space）。特征空间的每一个维对应一个特征。
输入变量与输出变量均为连续变量的预测问题成为回归问题，输出变量为有限个离散变量的预测问题成为分类问题，输入变量与输出变量均为变量序列的预测问题成为标注问题。
2.KNN算法
欧几里德距离（Euclidean Distance）：欧氏距离

###python 实现欧式距离公式 
from numpy import *
vector1 = np.mat([1,2,3]) ###np.mat将python的列表转换成Numpy的矩阵
vector2 = np.mat([4,5,6])
vector3 = np.mat([8,9,10])
print("向量1到向量3的欧式距离：\n",sqrt((vector1-vector3)*((vector1-vector3).T)))
print("向量1到向量2+向量2到向量3的欧式距离:\n",sqrt((vector1-vector2)*((vector1-vector2).T))+sqrt((vector2-vector3)*((vector2-vector3).T))) 
result:向量1到向量3的欧式距离：
 [[12.12435565]]
向量1到向量2+向量2到向量3的欧式距离:
 [[12.12435565]] 

曼哈顿距离(Manhattan Distance)：来源于城市区块距离，是多个维度上的距离进行求和结果

#python实现曼哈顿距离:
from numpy import *
vector1 = mat(([1,2,3]))
vector2 = mat([4,5,6])
vector3 = mat([8,9,10])
print("向量1到向量3的曼哈顿：\n",sum(abs(vector1-vector3)))
print("向量1到向量2+向量2到向量3的曼哈顿距离:\n",sum(abs(vector1-vector2))+sum(abs(vector2-vector3)))
result：
向量1到向量3的曼哈顿：
 21
向量1到向量2+向量2到向量3的曼哈顿距离:
 21

切比雪夫距离（Chebyshev Distance）：各坐标数值差的绝对值的最大值

#python实现切比雪夫距离:
from numpy import *
vector1 = mat(([1,2,3]))
vector2 = mat([4,7,5])
vector3 = mat([8,9,10])
print("向量1到向量3的切比雪夫距离：\n",abs(vector1-vector3).max)
print("向量1到向量2+向量2到向量3的切比雪夫:\n",abs(vector1-vector2).max()+abs(vector2-vector3).max())
result：
向量1到向量3的切比雪夫距离：
 <bound method matrix.max of matrix([[7, 7, 7]])>
向量1到向量2+向量2到向量3的切比雪夫:
 10

杰卡德距离（Jaccard Distance）：

from numpy import *
import scipy.spatial.distance as dist
matV =mat([[1,1,1,1,0,1,0,1,1],[0,1,1,0,1,0,1,1,1]])
print("杰卡德距离是:\n",dist.pdist(matV,'jaccard'))
result：
杰卡德距离是:
 [0.55555556]

2.1．5决策树算法：
决策树学习是根据数据的属性采用树状结构简称的一种决策模型，可以用此模型解决分类和回归问题。常见的算法包括CART(Classification And Regression Tree)，ID3和C4.5等。决策树算法主要是指对数据特征进行划分的时候选取最优特征的算法，将无序的数据尽可能变得更加有序
2.2.2无监督学习
与监督学习相对的，是无监督学习（Unsupervised learning）。在只有特征没有标签的训练数据中，通过数据之间的内在联系和相似性将它们分割成不同的类，使得同一个类的数据对象之间的相似性尽可能大，同类的数据对下那个之间的差异性可能大，即同一类的数据尽可能聚集到一起，不同类数据尽量分离。
三．神经网络

3.1.1MP模型的训练过程（学习率）：w’=w+б（y-F(·)·x），
·为f（·）sign（w·x+b）

3.1.2 感知机
感知机是线性分类模型，属于监督学习算法。输入为实例的特征向量，输出为实例的类别(取值为+1和-1）。感知机对应输入空间中将实例划分为两类超平面，感知机旨在求出该超平面。

图片引用自：https://www.cnblogs.com/xym4869/p/11282469.html

四．代码解析与复习
创建卷积神经网络

import tensorflow as tf ##导入tensorflow库
class CNN(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(
            filters=6,             # 卷积层神经元（卷积核）数目
            kernel_size=[5, 5],     # 感受野大小
            padding='valid',         # padding策略（vaild 或 same）vaild边缘不填充
            activation=tf.nn.relu   # 激活函数
        )
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2) ###pool_size: 用于指定池窗口的大小strides: 以指定所有空间维度的相同值，移动步长的意思
        self.conv2 = tf.keras.layers.Conv2D(
            filters=16,
            kernel_size=[5, 5],
            padding='valid',
            activation=tf.nn.relu ##relu即 max(features, 0)。将大于0的保持不变，小于0的数置为0
        )
        self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.flatten = tf.keras.layers.Reshape(target_shape=(5 * 5 * 16,))
        self.dense = tf.keras.layers.Dense(units=512,activation='relu')
        self.output = tf.keras.layers.Dense(units=10,activation='softmax')

    def call(self, inputs):
        x = self.conv1(inputs)                 
        x = self.pool1(x)                      
        x = self.conv2(x)                       
        x = self.pool2(x)                      
        x = self.flatten(x)                     
        x = self.dense1(x)                     
        x = self.dense2(x)                    
        output = tf.nn.softmax(x)
        return output
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(6,5,padding="same",activation="relu",input_shape=(32,32,1)),
    tf.keras.layers.MaxPool2D(),
    tf.keras.layers.Conv2D(16,5,padding="same",activation="relu"),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(512,activation='relu'),
    tf.keras.layers.Dense(10,activation='softmax')
])
###模型编译,定义优化函数,损失函数，记录精准率
model.summary()

例题

图像原理：输入层3232 卷积核(55) 第一次卷积后卷积核变为3个通道，卷积核为22 第二次卷积后卷积核变为55
使用padding输入层大小不会改变

class CNN(tf.keras.Model): ###定义一个类CNN（tf.keras Model）:
    def __init__(self): ###定义一个具有返回值的函数self
        super().__init__() ###使用super函数调用父类（超类）
        self.conv1 = tf.keras.layers.Conv2D( ###卷积函数
            filters=64,   # 卷积层神经元（卷积核）数目          
            kernel_size=[5, 5],     # 感受野大小
            padding='valid',       # padding策略（vaild 或 same）vaild边缘不填充
            activation=tf.nn.relu   # 激活函数
        )
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2) 
###使用池化pool池化核为[2,2].2的移动步长
        self.conv2 = tf.keras.layers.Conv2D( ###卷积函数
            filters=64, # 卷积层神经元（卷积核）数目
            kernel_size=[5, 5],	# 感受野大小
            padding='valid', # padding策略（vaild 或 same）vaild边缘不填充
            activation=tf.nn.relu  # 激活函数
        )
        self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2) ###卷积函数池化核[2,2],2的移动步长。
        self.flatten = tf.keras.layers.Reshape(target_shape=(5 * 5 * 64,))###将卷积层重设为32*32池化层为[5,5]
        self.dense1= tf.keras.layers.Dense(units=1024,activation=tf.nn.relu)###全连接层，输出空间的维度为1024，激活函数
        self.dense2= tf.keras.layers.Dense(units=512,activation=tf.nn.relu)###全连接层，输出空间的维度为512，激活函数
        self.output.layers = tf.keras.layers.Dense(units=10,activation=tf.nn.softmax)
###最后一个全连接层，输出空间的维度为10，激活函数

    def call(self, inputs):
        x = self.conv1(inputs)                 
        x = self.pool1(x)                      
        x = self.conv2(x)                       
        x = self.pool2(x)                      
        x = self.flatten(x)                     
        x = self.dense1(x)                     
        x = self.dense2(x)                    
        output = tf.nn.softmax(x)
        return output ###使用def call将以上函数调用，输出结果
###Sequential方法
model = tf.keras.Sequential([ ###Sequential函数
tf.keras.layers.Conv2D(64,5,padding="valid",activation="relu",input_shape=(32,32,3)),###使用卷积函数建议32*32的3通道的，激活函数为relu
    tf.keras.layers.MaxPool2D(), ###默认池化核为2*2
    tf.keras.layers.Conv2D(64,5,padding="valid",activation="relu") ###卷积函数32*32的5通道
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(), ###由立方体变为长条的全连接
    tf.keras.layers.Dense(1024,activation='relu'), ###第一次全连接
    tf.keras.layers.Dense(512,activation='relu'),###第二次全连接
    tf.keras.layers.Dense(10,activation='softmax')###第三次全连接，输出10
])
model.summary() ###输出结果

五.一些问题
1.什么是归一化，它与标准化的区别是什么?
2.如何确定CNN的卷积核通道数和卷积输出层的通道数？
3.什么是卷积？
4.什么是CNN的池化pool层？
5.请简要介绍下tensorflow的计算图

（未完，待更新）