基于TensorFlow和Python的机器学习（笔记）

池化层

Pooling Layer

用一个数代表一个感受野中的很多数

可以减少参数量

最大池化Max Pooling：池中的最大值代表该池子

平均池化Average Pooling：池中的平均值代表该池子

激活函数

Activation functions

给神经元引入了非线性因素

使模型可以适配非线性模型

感受野

receptive field

视觉感受的一个范围；

数据矩阵中的一部分；

交叉熵

Cross Entropy

用来描述语言模型的性能

用来描述模型对文本识别的难度

卷积

convolution

卷积的“卷”是指翻转平移操作，“积”是指积分运算

采用权值相乘累加的方式提取特征信息

过拟合

Overfitting

模型在训练集上面表现较好，但是在未见的样本上表现不佳

也就是模型泛化能力偏弱，这种现象叫作过拟合

欠拟合

Underfitting

训练集上表现不佳，同时在未见的样本上表现也不佳

模型不能够很好地学习到训练集数据的模态，这种现象叫作欠拟合

泛化能力

机器学习的主要目的是从训练集上学习到数据的真实模型， 从而能够在未见过的测试
集上也能够表现良好，我们把这种能力叫做泛化能力。通常来说，训练集和测试集都采样
自某个相同的数据分布。 采样到的样本是相互独立的，但是又来自于相同的分布，我
们把这种假设叫做独立同分布假设(Independent Identical Distribution assumption，简称
i.i.d.)。 

数据增强

除了上述介绍的方式可以有效检测和抑制过拟合现象之外，增加数据集规模是解决过
拟合最重要的途径。 但是收集样本数据和标签往往是代价昂贵的， 在有限的数据集上，通
过数据增强技术可以增加训练的样本数量， 获得一定程度上的性能提升。 数据增强(Data
Augmentation)是指在维持样本标签不变的条件下，根据先验知识改变样本的特征， 使得新
产生的样本也符合或者近似符合数据的真实分布。 

表达能力

前面已经提到了模型的表达能力，也称之为模型的容量(Capacity)。当模型的表达能力
偏弱时，比如单一线性层， 它只能学习到线性模型，无法良好地逼近非线性模型；但模型
的表达能力过强时， 它就有可能把训练集的噪声模态也学到，导致在测试集上面表现不佳
的现象(泛化能力偏弱)。 因此针对不同的任务，设计合适容量的模型算法才能取得较好的
泛化性能。 

容量

通俗地讲，模型的容量或表达能力，是指模型拟合复杂函数的能力。 一种体现模型容
量的指标为模型的假设空间(Hypothesis Space)大小， 即模型可以表示的函数集的大小。 假
设空间越大越完备， 从假设空间中搜索出逼近真实模型的函数也就越有可能； 反之，如果
假设空间非常受限，就很难从中找到逼近真实模型的函数。 

过拟合

Overfitting

欠拟合

Underfitting

当模型的容量过大时，网络模型除了学习到训练集数据的模态之外，还把额外的观测
误差也学习进来，导致学习的模型在训练集上面表现较好，但是在未见的样本上表现不
佳，也就是模型泛化能力偏弱，我们把这种现象叫作过拟合(Overfitting)。 当模型的容量过小时，模型不能够很好地学习到训练集数据的模态，导致训练集上表现不佳，同时在未见
的样本上表现也不佳，我们把这种现象叫作欠拟合(Underfitting) 

防止过拟合

提前终止训练、稀疏化参数、添加正则项、减小网络层数、减小每层的参数量、

增加数据规模（数据增强）、

L0正则化/范数

所有非零元素个数

不可导

用的不多

L1正则化/范数

所有元素绝对值之和

连续可导

使用广泛

L2正则化/范数

所有元素平方和

连续可导

使用广泛

L0范数

L0范数是指向量中非0的元素的个数。如果我们用L0范数来规则化一个参数矩阵W的话，就是希望W的大部分元素都是0。这太直观了，太露骨了吧，换句话说，让参数W是稀疏的。OK，看到了”稀疏”二字，大家都应该从当下风风火火的”压缩感知”和”稀疏编码”中醒悟过来，原来用的漫山遍野的”稀疏”就是通过这玩意来实现的。但你又开始怀疑了，是这样吗？看到的papers世界中，稀疏不是都通过L1范数来实现吗？脑海里是不是到处都是||W||1影子呀！几乎是抬头不见低头见。没错，这就是这节的题目把L0和L1放在一起的原因，因为他们有着某种不寻常的关系。那我们再来看看L1范数是什么？它为什么可以实现稀疏？为什么大家都用L1范数去实现稀疏，而不是L0范数呢？

L1范数

L1范数是指向量中各个元素绝对值之和，也有个美称叫”稀疏规则算子”（Lasso regularization）。现在我们来分析下这个价值一个亿的问题：为什么L1范数会使权值稀疏？有人可能会这样给你回答”它是L0范数的最优凸近似”。实际上，还存在一个更美的回答：任何的规则化算子，如果他在Wi=0的地方不可微，并且可以分解为一个”求和”的形式，那么这个规则化算子就可以实现稀疏。这说是这么说，W的L1范数是绝对值，|w|在w=0处是不可微，但这还是不够直观。这里因为我们需要和L2范数进行对比分析。所以关于L1范数的直观理解，请待会看看第二节。

L2范数

除了L1范数，还有一种更受宠幸的规则化范数是L2范数: ||W||2。它也不逊于L1范数，它有两个美称，在回归里面，有人把有它的回归叫”岭回归”（Ridge Regression），有人也叫它”权值衰减weight decay”。这用的很多吧，因为它的强大功效是改善机器学习里面一个非常重要的问题：过拟合。至于过拟合是什么，上面也解释了，就是模型训练时候的误差很小，但在测试的时候误差很大，也就是我们的模型复杂到可以拟合到我们的所有训练样本了，但在实际预测新的样本的时候，糟糕的一塌糊涂。通俗的讲就是应试能力很强，实际应用能力很差。擅长背诵知识，却不懂得灵活利用知识。

核范数

核范数||W||*是指矩阵奇异值的和，英文称呼叫Nuclear Norm。这个相对于上面火热的L1和L2来说，可能大家就会陌生点。那它是干嘛用的呢？霸气登场：约束Low-Rank（低秩）。

正则化

正则化(regularization)，是指在线性代数理论中，不适定问题通常是由一组线性代数方程定义的，而且这组方程组通常来源于有着很大的条件数的不适定反问题。大条件数意味着舍入误差或其它误差会严重地影响问题的结果。

中文名正则化外文名regularization出    处线性代数理论用    途求解不适定问题

不适定问题

经典的数学物理方程定解问题中，人们只研究适定问题。适定问题是指定解满足下面三个要求的问题：① 解是存在的；② 解是唯一的；③ 解连续依赖于定解条件，即解是稳定的。这三个要求中，只要有一个不满足，则称之为不适定问题。

中文名不适定问题外文名ill-posed problem相对概念适定问题属    性数学物理方程定解问题示    例拉普拉斯方程的柯西问题适用领域地球物理、连续介质力学等定    义不满足解是存在的、唯一的、稳定的

监督机器

监督机器学习问题无非就是”minimizeyour error while regularizing your parameters”，也就是在规则化参数的同时最小化误差。最小化误差是为了让我们的模型拟合我们的训练数据，而规则化参数是防止我们的模型过分拟合我们的训练数据。多么简约的哲学啊！因为参数太多，会导致我们的模型复杂度上升，容易过拟合，也就是我们的训练误差会很小。但训练误差小并不是我们的最终目标，我们的目标是希望模型的测试误差小，也就是能准确的预测新的样本。所以，我们需要保证模型”简单”的基础上最小化训练误差，这样得到的参数才具有好的泛化性能（也就是测试误差也小），而模型”简单”就是通过规则函数来实现的。另外，规则项的使用还可以约束我们的模型的特性。这样就可以将人对这个模型的先验知识融入到模型的学习当中，强行地让学习到的模型具有人想要的特性，例如稀疏、低秩、平滑等等。要知道，有时候人的先验是非常重要的。前人的经验会让你少走很多弯路，这就是为什么我们平时学习最好找个大牛带带的原因。一句点拨可以为我们拨开眼前乌云，还我们一片晴空万里，醍醐灌顶。对机器学习也是一样，如果被我们人稍微点拨一下，它肯定能更快的学习相应的任务。只是由于人和机器的交流目前还没有那么直接的方法，目前这个媒介只能由规则项来担当了。

 还有几种角度来看待规则化的。规则化符合奥卡姆剃刀(Occam’s razor)原理。这名字好霸气，razor！不过它的思想很平易近人：在所有可能选择的模型中，我们应该选择能够很好地解释已知数据并且十分简单的模型。从贝叶斯估计的角度来看，规则化项对应于模型的先验概率。民间还有个说法就是，规则化是结构风险最小化策略的实现，是在经验风险上加一个正则化项(regularizer)或惩罚项(penalty term)。

范数

范数(norm)是数学中的一种基本概念。在泛函分析中，它定义在赋范线性空间中，并满足一定的条件，即①非负性；②齐次性；③三角不等式。它常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小。

范数，是具有“长度”概念的函数。在线性代数、泛函分析及相关的数学领域，范数是一个函数，是矢量空间内的所有矢量赋予非零的正长度或大小。半范数可以为非零的矢量赋予零长度。

定义范数的矢量空间是赋范矢量空间；同样，定义半范数的矢量空间就是赋半范矢量空间。

注：在二维的欧氏几何空间 R中定义欧氏范数，在该矢量空间中，元素被画成一个从原点出发的带有箭头的有向线段，每一个矢量的有向线段的长度即为该矢量的欧氏范数。

泛函

泛函就是定义域是一个函数集，而值域是实数集或者实数集的一个子集，推广开来， 泛函就是从任意的向量空间到标量的映射。也就是说，它是从函数空间到数域的映射。

设{y}是给定的函数集，如果对于这个函数集中任一函数y(x) 恒有某个确定的数与之对应，记为П(y(x))，则П(y(x))是定义于集合{y(x)}上的一个泛函。

泛函定义域内的函数为可取函数或容许函数， y(x) 称为泛函П的变量函数。

泛函П(y(x))与可取函数y(x)有明确的对应关系。泛函的值是由一条可取曲线的整体性质决定的。

泛函也是一种“函数”，它的独立变量一般不是通常函数的“自变量”，而是通常函数本身。泛函是函数的函数。由于函数的值是由自变量的选取而确定的，而泛函的值是由自变量函数确定的，故也可以将其理解为函数的函数

泛函的自变量是函数，泛函的自变量称为宗量。

简言之，泛函就是函数的函数。

1

import

导入依赖包

2

datasets

train（x_train、y_train） test

3

class MyModel(Model)

model=Mymodel()

创建模型类 并实例化对象

4

model.compile

拼装

5

model.fit

训练

6

model.summary

描述

1

import

import tensorflow as tf        #创建模型

from sklearn import datasets   #数据集来源

import numpy as np             #计算库

2

datasets

下载数据集

x_train = datasets.load_iris().data   #下载数据

y_train = datasets.load_iris().target #下载标签

seed = 116                            #种子

np.random.seed(seed)                  #设置种子

np.random.shuffle(x_train)            #打乱数据

np.random.seed(seed)                  #设置种子

np.random.shuffle(y_train)            #打乱数据

tf.random.set_seed(seed)

3

model

创建模型

model = tf.keras.Sequential([                    #用Sequential容器创建模型

    tf.keras.layers.Dense(3,                     #全连接层

    activation=tf.keras.activations.softmax,     #激活函数

    kernel_regularizer=tf.keras.regularizers.l2) #正则化器

])

4

compile

装配模型

model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),

          #优化器SGD 学习率0.1

#损失函数

loss=tf.keras.losses.sparse_categorical_crossentropy(from_logits=False),

              metrics=[‘sparse_categorical_accuracy’]

              )

5

fit

训练模型

model.fit(x_train, y_train, batch_size=32,

          epochs=500, validation_split=0.2, validation_freq=20)

#输入数据x_train和标签y_train

#批次大小32 一般取2的幂

#训练次数500次

6

summary

模型概述

model.summary()

path=r’C:\Users\Administrator\Desktop\name.txt’

f=open(path,mode=’r’,encoding=’utf-8′)

lines=f.readlines()

dic=dict()

for line in lines:

   name,sex= line.split(‘\t’)

   name=name[1:]

   for zi in name:

    if zi in dic:#字典中已经存在该键

        if ‘男’ in sex:

            dic[zi]+=1

        else :

            dic[zi] -= 1

    else:#字典不存在该键

        if ‘男’ in sex:

            dic[zi] = 1

        else:

            dic[zi] = -1

print(len(dic))

test_path=r’C:\Users\Administrator\Desktop\testname.txt’

ff=open(test_path,mode=’r’,encoding=’utf-8′)

test=ff.readlines()

print(len(test))

for name in test:

    name=name.replace(‘\n’,”)

    if len(name)==3:

        name2=name[1:]

    elif len(name)==4:

        name2=name[2:]

    score=0

    for zi in name2:

        if zi in dic:

            score+=dic[zi]

    sex=’男’ if score>0 else ‘女’

    print(f’name= {name} ,sex= {sex},score= {score}\n’)

name= 龚尧莞 ,sex= 女,score= -25

name= 齐新燕 ,sex= 女,score= -121

name= 车少飞 ,sex= 男,score= 1038

name= 龙家铸 ,sex= 男,score= 1770

name= 赖鸿华 ,sex= 男,score= 2228

name= 龙宣霖 ,sex= 男,score= 805

name= 连丽英 ,sex= 女,score= -1120

name= 齐晓巍 ,sex= 男,score= 351

name= 连俊勤 ,sex= 男,score= 2408

name= 齐明星 ,sex= 男,score= 2784

name= 黄相杰 ,sex= 男,score= 2019

name= 龚小虎 ,sex= 男,score= 499

name= 连传杰 ,sex= 男,score= 2273

name= 宇文献花 ,sex= 女,score= -83

name= 龙川凤 ,sex= 男,score= 60

name= 黄益泉 ,sex= 男,score= 434

name= 黄益波 ,sex= 男,score= 705

name= 米培燕 ,sex= 女,score= -366

name= 连保健 ,sex= 男,score= 652

name= 齐旺梅 ,sex= 女,score= -205

进程已结束,退出代码0

区别

深度学习

机器学习

特征提取

自动提取

手工设计

应用场景

深度学习主要应用于文字识别、人脸技术、语义分析、智能监控等领域。目前在智能硬件、教育、医疗等行业也在快速布局。

机器学习在指纹识别、特征物体检测等领域的应用基本达到了商业化的要求

数据依赖

如果数据量迅速增加，那么深度学习的效果将更加突出，这是因为深度学习算法需要大量数据才能完美理解。

机器学习能够适应各种数据量，特别是数据量较小的场景。

性能

当数据量很少的时候，深度学习的性能并不好，因为深度学习算法需要大量数据才能很好理解其中蕴含的模式。

执行时间

，由于深度学习中含有非常多的参数，较机器学习而言会耗费更多的时间。

机器学习在训练数据的时候费时较少，同时只需几秒到几小时。

特征1

深度学习与传统模式识别方法的最大不同在于它所采用的特征是从大数据中自动学习得到，而非采用手工设计。好的特征可以提高模式识别系统的性能。

过去几十年，在模式识别的各种应用中，手工设计的特征一直处于统治地位。手工设计主要依靠设计者的先验知识，很难利用大数据的优势。由于依赖手工调参数，因此特征的设计中所允许出现的参数数量十分有限。深度学习可以从大数据中自动学习特征的表示，可以包含成千上万的参数。

特征2

采用手工设计出有效的特征往往需要五到十年时间，而深度学习可以针对新的应用从训练数据中很快学习到新的有效的特征表示。

一个模式识别系统包括特征和分类器两部分。在传统方法中，特征和分类器的优化是分开的。而在神经网络的框架下，特征表示和分类器是联合优化的，可以最大程度地发挥二者联合协作的性能。

解决问题的方法

深度学习则以集中方式解决问题，而不必进行问题拆分。

机器学习算法遵循标准程序以解决问题。它将问题拆分成数个部分，对其进行分别解决，而后再将结果结合起来以获得所需的答案。

结构层次

深度学习模型的“深”字意味着神经网络的结构深，由很多层组成。而支持向量机和Boosting等其他常用的机器学习模型都是浅层结构。三层神经网络模型(包括输入层、输出层和一个隐含层)可以近似任何分类函数。既然如此，为什么需要深层模型呢?

研究表明，针对特定的任务，如果模型的深度不够，其所需要的计算单元会呈指数增加。这意味着虽然浅层模型可以表达相同的分类函数，但其需要的参数和训练样本要多得多。

浅层模型提供的是局部表达。它将高维图像空间分成若干个局部区域，每个局部区域至少存储一个从训练数据中获得的模板，如图1(a)所示。浅层模型将一个测试样本和这些模板逐一匹配，根据匹配的结果预测其类别。随着分类问题复杂度的增加，需要将图像空间划分成越来越多的局部区域，因而需要越来越多的参数和训练样本。尽管目前许多深度模型的参数量已经相当巨大，但如果换成浅层神经网络，其所需要的参数量要大出多个数量级才能达到相同的数据拟合效果，以至于很难实现。

矩阵乘法

tf.matmul=matrix multiply

函数：tf.matmul

表示：将矩阵 a 乘以矩阵 b,生成a * b

numpy.matmul=matrix multiply

原型：numpy.matmul(a,b,out=None)两个numpy数组的矩阵相乘

（1）如果两个参数a,b都是2维的，做普通的矩阵相乘。

(2)如果某个参数是N（N>2）维的，该参数被理解为一些矩阵的stack，计算时会相应的广播。

首先对于a,它会被理解成为两个2*4的矩阵的stack。

对于b,它会被理解成为两个4*2的矩阵的stack。

a=tf.random.uniform([4,3,28,32])

b=tf.random.uniform([4,3,32,22])

c=a@b

print(c)#shape=(4, 3, 28, 22)

a=tf.random.uniform([4,3])

b=tf.random.uniform([3,7])

c=a@b

print(c)#shape=(4, 7)

#a的列数必须等于b的行数,否则报错Matrix size-incompatible

#相乘之后的结果是a的行数和b的列数的矩阵；

a=tf.random.uniform([4,3,22])

b=tf.random.uniform([22,7])

c=a@b#shape=(4, 3, 7)

print(c)#broadcast自动扩展b为[4,22,7]然后再相乘

# 独热码OneHot

y_onehot = tf.one_hot(3, 10)

# 共10个分类（元素），下标3的元素（第4个元素）值为1，其余为0

print(y_onehot)

# tf.Tensor([0. 0. 0. 1. 0. 0. 0. 0. 0. 0.], shape=(10,), dtype=float32)

平均值

tf.reduce_mean()函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的平均值，主要用作降维或者计算tensor（图像）的平均值。

tf.reduce_mean(

input_tensor,

axis=None,

keep_dims=False,

name=None,

reduction_indices=None

)

参数：

input_tensor： 输入的待降维的tensor

axis： 指定的轴，如果不指定，则计算所有元素的均值

keep_dims：是否降维度，默认False。设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度；如果输入是二维，输出也是二维，维度不变

name： 操作的名称

reduction_indices：在以前版本中用来指定轴，已弃用

类似函数还有:

tf.reduce_sum ：计算tensor指定轴方向上的所有元素的累加和;

tf.reduce_max : 计算tensor指定轴方向上的各个元素的最大值;

tf.reduce_all : 计算tensor指定轴方向上的各个元素的逻辑和（and运算）;

tf.reduce_any: 计算tensor指定轴方向上的各个元素的逻辑或（or运算）;

import tensorflow as tf

x = [[1, 2, 3], [4, 5, 6]]  # 二维列表

print(type(x))  # <class ‘list’>

print(x)  # [[1, 2, 3], [4, 5, 6]]

y=tf.cast(x,dtype=tf.float32)#将二维列表转换为张量

#默认keepdims=False 输出结果降维

mean_all=tf.reduce_mean(y)#所有元素平均值

print(mean_all)#tf.Tensor(3.5, shape=(), dtype=float32)

mean_0=tf.reduce_mean(y,axis=0)#同一列上元素求平均

print(mean_0)#tf.Tensor([2.5 3.5 4.5], shape=(3,), dtype=float32)

mean_1=tf.reduce_mean(y,axis=1)#同一行上元素求平均

print(mean_1)#tf.Tensor([2. 5.], shape=(2,), dtype=float32)

#keepdims=True输出结果维度与输入维度相同

mean_all=tf.reduce_mean(y,keepdims=True)

print(mean_all)#tf.Tensor([[3.5]], shape=(1, 1), dtype=float32)

mean_0=tf.reduce_mean(y,axis=0,keepdims=True)

print(mean_0)#tf.Tensor([[2.5 3.5 4.5]], shape=(1, 3), dtype=float32)

mean_1=tf.reduce_mean(y,axis=1,keepdims=True)

print(mean_1)#tf.Tensor([[2.] [5.]], shape=(2, 1), dtype=float32)

求导

tf.GradientTape梯度带/胶带/磁带

定义在tensorflow/python/eager/backprop.py文件中，从文件路径也可以大概看出，GradientTape是eager模式下计算梯度用的，而eager模式（eager模式的具体介绍请参考文末链接）是TensorFlow 2.0的默认模式，因此tf.GradientTape是官方大力推荐的用法。下面就来具体介绍GradientTape的原理和使用。

Tape在英文中是胶带，磁带的含义，用在这里是由于eager模式带来的影响。在TensorFlow 1.x静态图时代，我们知道每个静态图都有两部分，一部分是前向图，另一部分是反向图。反向图就是用来计算梯度的，用在整个训练过程中。而TensorFlow 2.0默认是eager模式，每行代码顺序执行，没有了构建图的过程（也取消了control_dependency的用法）。但也不能每行都计算一下梯度吧？计算量太大，也没必要。因此，需要一个上下文管理器（context manager）来连接需要计算梯度的函数和变量，方便求解同时也提升效率。

默认情况下GradientTape的资源在调用gradient函数后就被释放，再次调用就无法计算了。所以如果需要多次计算梯度，需要开启persistent=True属性

WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.

警告:tensorflow:调用GradientTape。在其上下文中对持久磁带进行梯度操作的效率比在上下文中调用梯度操作的效率要低得多(它导致梯度操作被记录在磁带上，导致CPU和内存使用增加)。

在一个持久胶带（persistent GradientTape）外面求导，效率更高；

一般在网络中使用时，不需要显式调用watch函数，使用默认设置，GradientTape会监控可训练变量；

import tensorflow as tf

x=tf.constant(3.)

print(x)#tf.Tensor(3.0, shape=(), dtype=float32)

#用GradientTape梯度带 求导数

with tf.GradientTape() as g:

    g.watch(x)#看着点X，

    y = x * x#y=x^2

    dy_dx=g.gradient(y,x)# y’ = 2*x = 2*3 = 6

    print(dy_dx) #

# 例子中的watch函数把需要计算梯度的变量x加进来了。

# GradientTape默认只监控由tf.Variable创建的traiable=True属性（默认）的变量。

# 上面例子中的x是constant，因此计算梯度需要增加g.watch(x)函数。

# 当然，也可以设置不自动监控可训练变量，完全由自己指定，

# 设置watch_accessed_variables=False就行了（一般用不到）。

#GradientTape也可以嵌套多层用来计算高阶导数

x=tf.constant(3.)

with tf.GradientTape() as g:

    g.watch(x)

    with tf.GradientTape()as gg:#嵌套 梯度带

        gg.watch(x)#看着点X

        y=x*x*x #y=x^3

        dy_dx=gg.gradient(y,x)#y’=3*x^2=3*3^2=27

        print(dy_dx)#tf.Tensor(27.0, shape=(), dtype=float32)

    d2y_dx2=g.gradient(dy_dx,x)#y”=(3*x^2)’=3*2*x=6*x=18

    print(d2y_dx2)#tf.Tensor(18.0, shape=(), dtype=float32)

# 默认情况下GradientTape的资源在调用gradient函数后就被释放，再次调用就无法计算了。

# 所以如果需要多次计算梯度，需要开启persistent=True属性

#RuntimeError: A non-persistent GradientTape can only be used

# to compute one set of gradients (or jacobians)

#RuntimeError:一个非持久的GradientTape只能用于计算一组梯度(或雅可比矩阵)

x=tf.constant(3.)

#持久性胶带，粘得更牢

with tf.GradientTape(persistent=True) as g:

    g.watch(x)

    y=x*x#y=x^2,

    z=y*y#z=y^2=x^4

dy_dx=g.gradient(y,x)#y’=2*x=2*3=6

print(dy_dx)#tf.Tensor(6.0, shape=(), dtype=float32)

dz_dx=g.gradient(z,x)#z’=4*x^3=4*27=108

print(dz_dx)#tf.Tensor(108.0, shape=(), dtype=float32)

del g #持久性胶带，用完后要删除，非降解材料，不会自动消失

tf.Tensor不需计算梯度

tf.Variable需计算梯度

l 为了区分需要计算梯度信息的张量与不需要计算梯度信息的张量，TensorFlow 增加了一种专门的数据类型来支持梯度信息的记录：tf.Variable。

l tf.Variable 类型在普通的张量类型基础上添加了name，trainable 等属性来支持计算图的构建。

l 由于梯度运算会消耗大量的计算资源，而且会自动更新相关参数，对于不需要的优化的张量，如神经网络的输入，不需要通过 tf.Variable 封装；

l 相反，对于需要计算梯度并优化的张量， 如神经网络层的W和b， 需要通过 tf.Variable 包裹以便 TensorFlow 跟踪相关梯度信息

import tensorflow as tf

t = tf.constant([1, 2, 3])  # 创建常量张量

v = tf.Variable(t)  # 将张量转换为变量Variable（待优化张量、可变张量）

print(t)  # tf.Tensor([1 2 3], shape=(3,), dtype=int32)

print(v)  # <tf.Variable ‘Variable:0’ shape=(3,) dtype=int32, numpy=array([1, 2, 3])>

print(v.name)  # Variable:0 Variable特有属性

print(v.trainable)  # True  Variable特有属性

v = tf.Variable([[1, 2], [3, 4]])  # 直接创建Variable张量

print(v)  # <tf.Variable ‘Variable:0’ shape=(2, 2) dtype=int32, numpy=array([[1, 2],[3, 4]])>

ls = [11, 22, 33]  # 创建list列表

print(type(ls))  # <class ‘list’>

t = tf.convert_to_tensor(ls)  # 将列表转换为张量

print(t)  # tf.Tensor([11 22 33], shape=(3,), dtype=int32)

import numpy as np

arr = np.array([[6.6, 7.7], [100, 200]])#创建一个numpy数组ndarray

print(type(arr))  # <class ‘numpy.ndarray’>

t = tf.convert_to_tensor(arr)#将ndarray转换为张量

print(t)  # tf.Tensor([[  6.6   7.7] [100.  200. ]], shape=(2, 2), dtype=float64)

t=tf.range(5)

print(t)#tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int32)

compile 装配

Dense 全连接层

fit     训练

ReLU  激活函数层

矩阵乘法

tf.matmul=matrix multiply

函数：tf.matmul

表示：将矩阵 a 乘以矩阵 b,生成a * b

numpy.matmul=matrix multiply

原型：numpy.matmul(a,b,out=None)两个numpy数组的矩阵相乘

（1）如果两个参数a,b都是2维的，做普通的矩阵相乘。

(2)如果某个参数是N（N>2）维的，该参数被理解为一些矩阵的stack，计算时会相应的广播。

首先对于a,它会被理解成为两个2*4的矩阵的stack。

对于b,它会被理解成为两个4*2的矩阵的stack。

a=tf.random.uniform([4,3,28,32])

b=tf.random.uniform([4,3,32,22])

c=a@b

print(c)#shape=(4, 3, 28, 22)

a=tf.random.uniform([4,3])

b=tf.random.uniform([3,7])

c=a@b

print(c)#shape=(4, 7)

#a的列数必须等于b的行数,否则报错Matrix size-incompatible

#相乘之后的结果是a的行数和b的列数的矩阵；

a=tf.random.uniform([4,3,22])

b=tf.random.uniform([22,7])

c=a@b#shape=(4, 3, 7)

print(c)#broadcast自动扩展b为[4,22,7]然后再相乘

# 独热码OneHot

y_onehot = tf.one_hot(3, 10)

# 共10个分类（元素），下标3的元素（第4个元素）值为1，其余为0

print(y_onehot)

# tf.Tensor([0. 0. 0. 1. 0. 0. 0. 0. 0. 0.], shape=(10,), dtype=float32)

平均值

tf.reduce_mean()函数用于计算张量tensor沿着指定的数轴（tensor的某一维度）上的平均值，主要用作降维或者计算tensor（图像）的平均值。

tf.reduce_mean(

input_tensor,

axis=None,

keep_dims=False,

name=None,

reduction_indices=None

)

参数：

input_tensor： 输入的待降维的tensor

axis： 指定的轴，如果不指定，则计算所有元素的均值

keep_dims：是否降维度，默认False。设置为True，输出的结果保持输入tensor的形状，设置为False，输出结果会降低维度；如果输入是二维，输出也是二维，维度不变

name： 操作的名称

reduction_indices：在以前版本中用来指定轴，已弃用

类似函数还有:

tf.reduce_sum ：计算tensor指定轴方向上的所有元素的累加和;

tf.reduce_max : 计算tensor指定轴方向上的各个元素的最大值;

tf.reduce_all : 计算tensor指定轴方向上的各个元素的逻辑和（and运算）;

tf.reduce_any: 计算tensor指定轴方向上的各个元素的逻辑或（or运算）;

import tensorflow as tf

x = [[1, 2, 3], [4, 5, 6]]  # 二维列表

print(type(x))  # <class ‘list’>

print(x)  # [[1, 2, 3], [4, 5, 6]]

y=tf.cast(x,dtype=tf.float32)#将二维列表转换为张量

#默认keepdims=False 输出结果降维

mean_all=tf.reduce_mean(y)#所有元素平均值

print(mean_all)#tf.Tensor(3.5, shape=(), dtype=float32)

mean_0=tf.reduce_mean(y,axis=0)#同一列上元素求平均

print(mean_0)#tf.Tensor([2.5 3.5 4.5], shape=(3,), dtype=float32)

mean_1=tf.reduce_mean(y,axis=1)#同一行上元素求平均

print(mean_1)#tf.Tensor([2. 5.], shape=(2,), dtype=float32)

#keepdims=True输出结果维度与输入维度相同

mean_all=tf.reduce_mean(y,keepdims=True)

print(mean_all)#tf.Tensor([[3.5]], shape=(1, 1), dtype=float32)

mean_0=tf.reduce_mean(y,axis=0,keepdims=True)

print(mean_0)#tf.Tensor([[2.5 3.5 4.5]], shape=(1, 3), dtype=float32)

mean_1=tf.reduce_mean(y,axis=1,keepdims=True)

print(mean_1)#tf.Tensor([[2.] [5.]], shape=(2, 1), dtype=float32)

求导

tf.GradientTape梯度带/胶带/磁带

定义在tensorflow/python/eager/backprop.py文件中，从文件路径也可以大概看出，GradientTape是eager模式下计算梯度用的，而eager模式（eager模式的具体介绍请参考文末链接）是TensorFlow 2.0的默认模式，因此tf.GradientTape是官方大力推荐的用法。下面就来具体介绍GradientTape的原理和使用。

Tape在英文中是胶带，磁带的含义，用在这里是由于eager模式带来的影响。在TensorFlow 1.x静态图时代，我们知道每个静态图都有两部分，一部分是前向图，另一部分是反向图。反向图就是用来计算梯度的，用在整个训练过程中。而TensorFlow 2.0默认是eager模式，每行代码顺序执行，没有了构建图的过程（也取消了control_dependency的用法）。但也不能每行都计算一下梯度吧？计算量太大，也没必要。因此，需要一个上下文管理器（context manager）来连接需要计算梯度的函数和变量，方便求解同时也提升效率。

默认情况下GradientTape的资源在调用gradient函数后就被释放，再次调用就无法计算了。所以如果需要多次计算梯度，需要开启persistent=True属性

WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.

警告:tensorflow:调用GradientTape。在其上下文中对持久磁带进行梯度操作的效率比在上下文中调用梯度操作的效率要低得多(它导致梯度操作被记录在磁带上，导致CPU和内存使用增加)。

在一个持久胶带（persistent GradientTape）外面求导，效率更高；

最后，一般在网络中使用时，不需要显式调用watch函数，使用默认设置，GradientTape会监控可训练变量；

import tensorflow as tf

x=tf.constant(3.)

print(x)#tf.Tensor(3.0, shape=(), dtype=float32)

#用GradientTape梯度带 求导数

with tf.GradientTape() as g:

    g.watch(x)#看着点X，

    y = x * x#y=x^2

    dy_dx=g.gradient(y,x)# y’ = 2*x = 2*3 = 6

    print(dy_dx) #

# 例子中的watch函数把需要计算梯度的变量x加进来了。

# GradientTape默认只监控由tf.Variable创建的traiable=True属性（默认）的变量。

# 上面例子中的x是constant，因此计算梯度需要增加g.watch(x)函数。

# 当然，也可以设置不自动监控可训练变量，完全由自己指定，

# 设置watch_accessed_variables=False就行了（一般用不到）。

#GradientTape也可以嵌套多层用来计算高阶导数

x=tf.constant(3.)

with tf.GradientTape() as g:

    g.watch(x)

    with tf.GradientTape()as gg:#嵌套 梯度带

        gg.watch(x)#看着点X

        y=x*x*x #y=x^3

        dy_dx=gg.gradient(y,x)#y’=3*x^2=3*3^2=27

        print(dy_dx)#tf.Tensor(27.0, shape=(), dtype=float32)

    d2y_dx2=g.gradient(dy_dx,x)#y”=(3*x^2)’=3*2*x=6*x=18

    print(d2y_dx2)#tf.Tensor(18.0, shape=(), dtype=float32)

# 默认情况下GradientTape的资源在调用gradient函数后就被释放，再次调用就无法计算了。

# 所以如果需要多次计算梯度，需要开启persistent=True属性

#RuntimeError: A non-persistent GradientTape can only be used

# to compute one set of gradients (or jacobians)

#RuntimeError:一个非持久的GradientTape只能用于计算一组梯度(或雅可比矩阵)

x=tf.constant(3.)

#持久性胶带，粘得更牢

with tf.GradientTape(persistent=True) as g:

    g.watch(x)

    y=x*x#y=x^2,

    z=y*y#z=y^2=x^4

dy_dx=g.gradient(y,x)#y’=2*x=2*3=6

print(dy_dx)#tf.Tensor(6.0, shape=(), dtype=float32)

dz_dx=g.gradient(z,x)#z’=4*x^3=4*27=108

print(dz_dx)#tf.Tensor(108.0, shape=(), dtype=float32)

del g #持久性胶带，用完后要删除，非降解材料，不会自动消失

import keras

import numpy as np

model=keras.Sequential([keras.layers.Dense(units=1,input_shape=[1])])

model.compile(optimizer=’sgd’,loss=’mean_squared_error’)

#输入x（训练集）

xs=np.array([-1.0,0.0,1.0,2.0,3.0,4.0],dtype=float)

#标签y

ys=np.array([-3.0,-1.0,1.0,3.0,5.0,7.0],dtype=float)

#讲数据输入，开始训练，共训练500遍

model.fit(xs,ys,epochs=500)

print(f’当x为10.0时，y的预测值为’)

print(model.predict([10.0]))

print(f’当x为-3.0时，y的预测值为’)

print(model.predict([-3.0]))

”’

Epoch 1/500

1/1 [==============================] – 0s 291ms/step – loss: 28.4334

Epoch 2/500

1/1 [==============================] – 0s 999us/step – loss: 22.6760

Epoch 3/500

1/1 [==============================] – 0s 999us/step – loss: 18.1401

Epoch 4/500

1/1 [==============================] – 0s 1000us/step – loss: 14.5652

Epoch 5/500

1/1 [==============================] – 0s 996us/step – loss: 11.7467

Epoch 6/500

1/1 [==============================] – 0s 1ms/step – loss: 9.5233

Epoch 7/500

1/1 [==============================] – 0s 998us/step – loss: 7.7683

Epoch 8/500

1/1 [==============================] – 0s 998us/step – loss: 6.3818

Epoch 9/500

1/1 [==============================] – 0s 1ms/step – loss: 5.2855

Epoch 10/500

1/1 [==============================] – 0s 999us/step – loss: 4.4175

1/1 [==============================] – 0s 1000us/step – loss: 5.2602e-05

Epoch 499/500

1/1 [==============================] – 0s 999us/step – loss: 5.1522e-05

Epoch 500/500

1/1 [==============================] – 0s 1ms/step – loss: 5.0463e-05

当x为10.0时，y的预测值为

1/1 [==============================] – 0s 87ms/step

[[18.986246]]

当x为-3.0时，y的预测值为

1/1 [==============================] – 0s 33ms/step

[[-6.98784]]

”’

import numpy

import tensorflow as tf

t = tf.ones([2, 3])

print(t)  # 2行3列的张量，每个元素都是1

t = tf.zeros([3, 4])

print(t)  # 3行4列的张量，每个元素都是0

t = tf.fill([3, 6], 99)

print(t)  # 3行6列的张量，每个元素都是99

t = tf.zeros_like(t)

print(t)  # 形状同t，行数列数都相同，每个元素都是0

t = tf.ones_like(t)

print(t)  # 形状同t，行数列数都相同，每个元素都是1

t = tf.one_hot(3, 4)  # 共4个元素，下标3的元素为1，其余为0

print(t)  # 独热码tf.Tensor([0. 0. 0. 1.], shape=(4,), dtype=float32)

t = tf.constant([[1, 2, 3], [9, 8, 7]])

print(t)  # tf.Tensor([[1 2 3] [9 8 7]], shape=(2, 3), dtype=int32)

# 定义常数张量，指定数据的张量

t = tf.linspace(start=0.0, stop=3.0, num=6)

print(t)  # tf.Tensor([0.  0.6 1.2  1.8000001 2.4  3.], shape=(6,), dtype=float32)

# 等距切分张量，0-0.6-1.2-1.8-2.4-3.0,以0为起始元素，以3为结束元素，等分成6份

t = tf.range(start=0, limit=5, delta=1)

print(t)  # tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int32)

# 指定区间为[0,5)前闭后开，相邻元素差值为1

t = tf.range(start=0.5, limit=2, delta=0.3)

print(t)  # tf.Tensor([0.5 0.8 1.1  1.4000001 1.7 ], shape=(5,), dtype=float32)

# 指定区间[0.5,2),相邻元素差值0.3（步距）

t = tf.random.uniform([3, 4], minval=0, maxval=2)

print(t)#随机值下限为0上限为2的均匀分布，3行4列

print(numpy.mean(t)) #0.8071537

t = tf.random.normal([3, 4], mean=10, stddev=1)

print(t)#均值为10 标准差为1的正态分布，3行4列

print(numpy.mean(t))#9.724729

t=tf.random.truncated_normal([3,4],mean=2,stddev=1)

print(t)#均值为2，标准差为1的 截断正态分布，3行4列

print(numpy.mean(t))#2.0792353

”’

截断正态分布的定义可以分为两步，给定一个参数为μ和σ2

 的标准正态分布的概率密度函数。修标准般正态分布相关的概率密度函数，通过将范围外的值设置为零，并标准正态的取值范围均匀缩放到特定范围中，使总积分为1。截断范围可以分为四种情况：

（1）无截断的情况：− ∞ = a , b = + ∞；

（2）下界截断的情况：− ∞ < a , b = + ∞；

（3）上界截断的情况：− ∞ = a , b < + ∞；

（4）上下界截断的情况：− ∞ < a , b < + ∞；

”’