• 语义分割（semantic segmentation）：为图像中的每个像素分配一个类别，但是同一类别之间的对象不会区分。
• 实例分割（Instance segmentation）：把一个类别里具体的一个个对象（具体的一个个实例）分割出来。

语义分割任务评价指标

Pixel Accuracy(Global Acc)

$$\frac{\sum_{i}n_{ii}}{\sum_{i}t_{i}}$$

Mean Accuracy

$$\frac{1}{n_{cls}}\times \sum_{i}\frac{n_{ii}}{t_{i}}$$

Mean IoU

$$\frac{1}{n_{cls}}\times\sum_{i}\frac{n_{ii}}{t_{i}+\sum_{j}n_{ji}-n_{ii}}$$

$n_{ij}$类别i被预测称类别j的像素个数

$n_{cls}$目标类别个数（包含背景）

$t_{i}=\sum_{j}n_{ij}$目标类别i的总像素个数（真实标签）

FCN

Fully Convolutional Networks for Semantic Segmentation

首个端到端的针对像素级预测的全卷积网络

DeepLab

deeplabv1 论文原文：Semantic Image Segmentation with Deep Convolutional Nets and Fully Connected CRFs

deeplabv2 论文原文：DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs

deeplabv3 论文原文：Rethinking Atrous Convolution for semantic image segmentation

deeplabv3+ 论文原文：Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation

##Deeplabv1

语义分割任务DCNNs应用中中存在的问题：

1. 下采样会导致图像分辨率降低
2. 空间不敏感

解决方案：

1. atrous algorithm （空洞卷积/膨胀卷积/扩张卷积）
2. fully-connected CRF(Conditional Random Field) [注：deeplabv3不使用]

Atrous convolution（空洞卷积/膨胀卷积/扩张卷积）

• 增加感受野
• 保持原输入特征图W、H

连续使用膨胀卷积时要注意gridding effect问题。经过多次膨胀卷积后,对于一个像素点来说，它获得对应在原始图像上被卷积的点可能是有间隔的，此时要注意膨胀率$r$的搭配问题。图(a)中出现的为间隔现象，更换膨胀率搭配后如图(b)。

Deeplabv3

文中给出两种模型结构

• cascaded model

• ASPP model（效果较好）

Block都为ResNet原有结构。

U-Net

U-net 论文原文：U-Net: Convolutional Networks for Biomedical Image Segmentation

U-net结构：

文中方法没有使用padding。拼接时进行中心裁剪，再进行拼接。最终输出与输入图片大小不一样，结果是输入图像中心部分。

U²-Net

U²-Net论文原文：U²-Net: Going deeper with nested U-structure for salient object detection

为了salient object detection（SOD）显著性目标检测任务，只有前景和背景两个类别。

论文原文

算法思想

1、划分Gird Cell

将一幅图像分成SxS个网格(grid cell)，如果某个object的中心落在这个网格中，则这个网格就负责预测这个object。

2、Bounding box 预测

每个网格要预测B个bounding box(B取2)，每个bounding box除了要预测位置之外，还要预测一个confidence值。另外每个网格还要预测c个类别的分数。相当于每个bounding box要预测5个值，4个是位置，1个是confidence。

$$ confidence = Pr(Object)*IOU_{pred}^{truth}$$

其中$Pr(Object)$如果网格内没有目标则为0，如果有目标为1。

在最终测试预测时，对于每一个目标最终的概率，会将类别分数与confidence相乘

$$Pr(Class_{i}|Object)*Pr(Object)*IOU_{pred}^{truth}=Pr(Class_{i})*IOU_{pred}^{truth}$$

！！！这里要注意的是，虽然一个grid cell预测两个bounding box，但是其实一个grid cel只预测一个类别，对于预测2个bounding box，最终只选择IOU最高的bounding box作为该类别检测的输。当一个格子中包含多个物体，只检测出一个。

网络最终输出的维度是SxSx(5xB+C)=7x7x(5x2+20)，每个grid cell的输出排列如下图

$x,y$是bounding box中心位置相对于当前格子位置的偏移量，归一化到[0,1]

$w,h$是box的长和宽相对于input的长和宽的比例，归一化到[0,1]

3、网络结构

原文中在 imagenet 分类任务上以一半的分辨率对卷积层进行预训练（224 x 224输入图像），然后将分辨率加倍进行检测。

4、Loss 计算

算法缺陷

1. 对群体性小目标检测很差，由于grid cell的限制。
2. 当目标出现新的尺寸比例或结构，效果会变差。
3. 大多数错误来源于预测位置不准。

SSD: Single Shot Multibox Detector

论文原文

SSD 网络框架

• 输入图像大小为300x300
• 前面使用VGG-16的部分，是从开始到Conv5_3。
• 其中Conv4_3的输出作为预测特征层1
• Conv5_3之后的池化层在VGG16中使用的是2x2-s2（池化核为2x2，步长为2）使特征图宽高减半，在这里使用的是3x3-s1（padding为1），输出的大小保持不变。
• 小的特征图适合检测大目标，大特征图适合检测小目标，在不同特征图分别匹配不同尺度的目标，提升小目标检测效果。

Default Box 的 Scale 和 aspect

如果使用$m$个特征图来进行预测，每个特征图的默认的scale计算如下：

$$s_{k}=s_{min}+\frac{s_{max}-s_{min}}{m-1}(k-1), k\in[1,m]$$

• 其中对VOC数据集的训练中，$s_{min}=0.2,s_{max}=0.9$，这意味着最低层的scale为0.2，即默认宽高比$1:1$的box像素为300x0.2=60，最高层为300x0.9=270。

• aspect比率：对于使用6个box的有五个$a_{r}\in{1,2,3,\frac{1}{2},\frac{1}{3}}$，对于使用4个box的3个$a_{r}\in{1,2,\frac{1}{2}}$。

• 由此每个框的宽度为：$w_{k}^{a}=s_{k}\sqrt{a_{r}}$，高度为$h_{k}^{a}=s_{k}/\sqrt{a_{r}}$。

• 另外每一个特征图都会添加一个box，scale比本层大一些，比下一层小一些，$s_{k}’=\sqrt{s_{k}s_{k+!}}$，这个box的aspect为$1:1$，由此每个box的是本层scale的5或3个aspect加上1个$s_{k}’$的box

• 对于COCO数据集，目标较小，所以最小的default box的scale使用0.15替代0.2，同时conv4_3的default box的scale为0.07（300x300图像中的21个像素）。具体如下表所示。

Default box总数为8732

Predictor的实现

对于$m\times n$的特征图，使用$3\times 3$的卷积核来生成分类概率分数和边界框回归参数，和fasterRCNN的预测器类似。对于特征图上的每个位置会生成$k$个default box，对每个box计算$c$个类别分数（包括背景）和4个回归参数，也就是$(c+4)k$个卷积核（filter），对于一个$m\times n$的特征图会生成$(c+4)kmn$个输出值。

注意：在Fast–RCNN中边界框回归参数是$4\times c\times k$个，而SSD中是$4\times k$个，是不关注边界框回归参数是关于哪个类别的

损失计算

$$L(x,c,l,g)=\frac{1}{N}(L_{conf}(x,c)+\alpha L_{loc}(x,l,g))$$

其中$N$为匹配到的正样本个数，平衡系数$\alpha$为1

YOLO v2 (YOLO9000)

论文原文

性能改进

在YOLO v1的基础上进行一系列改进来提升性能，改进尝试如下：

Batch Normalization

通过添加BN层，对于训练收敛有很大的帮助，减少了一系列正则化操作。可以在移除Dropout操作后不过拟合。

相比YOLO v1的mAP提升了2%

High Resolution Classifier

采用更高分辨率的分类器，使用448x448的分辨率训练ImageNet，提升了4%mAP。

Convolutional with Anchor Boxes

使用基于Anchor的目标边界框预测。相对于直接预测坐标，使用带有偏移的Anchor边界框预测，可以简化目标边界框预测问题，使得网络更好训练。这里会使mAP有0.3%的轻微下降，但是recall增加了8%，这样的结果可以使模型有更大的提升空间。

Dimension Clusters

使用聚类算法提取anchor boxes的宽高。之前的anchor boxes是基于经验设定的，网络微调anchor box到实际位置的难度较大。这里的做法是对训练集合中标注的边界框进行聚类分析，已找到更好的尺寸。

论文中使用k-means作为聚类算法。聚类算法最重要的是选择如何计算边界框间距离，使用欧氏距离会导致大边界框有更大的误差。由于更加关心IOU所以我们定义计算公式为：

$$distance(box,centroid)=1-IOU(box,centroid)$$

其中centroid是聚类时被选作中心的边框，box就是其它anchor boxes。IOU越大，距离越近。

Direct location prediction

在实验中发现如果不进行限制，anchor boxes可能会出现在图像中的任意点，导致anchor偏离ground truth很远。这里对预测公式进行调整，将预测边界框中心约束在grid cell内：

$$b_{x}=\sigma(t_{x})+c_{x}$$

$$b_{y}=\sigma(t_{y})+c_{y}$$

$$b_{w}=p_{w}e^{t_{w}}$$

$$b_{h}=p_{h}e^{t_{h}}$$

$$Pr(Object)*IOU(b,Object)=\sigma(t_{o})$$

其中，$b_{x},b_{y},b_{w},b_{h}$是预测边界框的中心和宽高。

$\sigma$是sigmoid函数，控制边界框中心在网格内。

$t_{x},t_{y},t_{w},t_{h},t_{o}$是要学习的参数，分别用于预测边框中心和宽高以及置信度

$c_{x},c_{y}$是当前网格左上角到图像左上角的距离。

$p_{w},p_{h}$是先验框bounding box prior或者说是预设的框的宽高

Fine-Frained Features

论文提到YOLO使用13x13的特征图进行大物体预测拥有很好的效果，即细粒度特征（Fine-Frained Features），而相对比较小的物体则一般。这里引入一种passthrough层的方法在特征图上保留一些信息。

passthough层如下图

passthrough层是将前面更高分辨率的图作为输入，将其连接到后面的低分辨率特征图上，但是为了使特征图大小一致进行拼接，会将channles增加4倍。以416x416分辨率为例，对于26x26x512的特征图，通过passthrough层后转换为13x13x2048的特征图，可以与后面的13x13x1024的特征图进行拼接。

#####YOLO v2完整网络结构图：

Multi-Scale Training

YOLOv2没有券链接层，所以对网络输入大小没有限制，但是由于缩放因子为32（下采样倍数），需要输入尺寸为32的倍数。为了增加模型的鲁棒性，训练时每10个batch就改变一次输入图像大小从320x320到608x608。

速度改进

#####BackBone：Darknet-19

删除Darknet-19的最后一个卷积层，并用3个3x3卷积层和一个1x1卷积替代。

对于VOC数据集，每个网格中预测5个bounding boxes，每个boundingbox有5个参数(4个边界框回归参数+confidence)和20分类，即1+4+20=25，每个网格为5x25=125个filters。

YOLO v3

报告原文

由于原文是一篇技术报告，所以在很多地方讲解的都是很模糊的。

网络结构

主干网络使用Darknet-53，添加了残差结构

Darknet53：

在使用时移除了FC层。

目标边界框预测

YOLOv3在3个特征图中发的分别通过$(4+1+c)\times k$个大小为1x1的卷积核进行预测，$k$为预设边界框(bounding box prior)的个数（k默认取3）。

根据COCO数据集聚类得到预设边界框尺寸：

正负样本匹配

针对每一个GT分配一个Bounding box prior ，即每一个GT分配一个正样本，一个图片中有几个目标，就有几个正样本。分配原则是：将与GT重合程度最高的bounding box prior作为正样本，对于bounding box与GT重合但是不是最大但是超过阈值(0.5)则忽视，其他的则为负样本。如果bounding box prior没有被分配给GT，则它没有定位损失和类别损失，只有confidence。

损失函数

$$Loss(o,c,O,C,l,g)=\lambda_{1}Loss_{conf}(o,c)+\lambda_{2}Loss_{cla}(O,C)+\lambda_{3}Loss_{loc}(l,g)$$

$\lambda_{1},\lambda_{2},\lambda_{3}$为平衡系数

confidence损失：Binary Cross Entropy

$$Loss_{conf}(o,c)=-\frac{\sum_{i}(o_{i}ln(\hat{c}{i})+(1-o{i})ln(1-\hat{c}_{i}))}{N}$$

$\hat{c}{i}=Sigmoid(c{i})$为预测值c通过Sigmoid函数得到的预测置信度

$o_{i}\in[0,1]$表示一侧，表示预测目标边界框与真实边界框的IOU

原文中$o_{i}$只取0或者1，正样本为1，负样本为0

N为正负样本个数

类别损失

$$Loss_{cla}(O,C)=-\frac{\sum_{i\in pos}\sum_{j\in cla}(O_{ij}ln(\hat{c}{ij})+(1-o{ij})ln(1-\hat{c}{ij}))}{N{pos}}$$

$O_{ij}$取0或1，表示目标框i中是否存在第j类目标

$N_{pos}$是正样本个数

eg：

类别[A, B, C]

真实标签:

Object1:[0, 0, 1]

Object2:[0, 0, 1]

预测概率：经过Sigmoid处理，不是softmax，所以概率和不为1

Object1:[0.1, 0.8, 0.9]

Object2:[0.2, 0.7, 0.8]

定位损失

$$Loss_{loc}(t,g)=\frac{\sum_{i\in pos}(\sigma(t_{x}^{i})-\hat{g}{x}^{i})^{2}+(\sigma(t{y}^{i})-\hat{g}{y}^{i})^{2}+(t{w}^{i}-\hat{g}{w}^{i})^{2}+(t{h}^{i}-\hat{g}{h}^{i})^{2}}{N{pos}}$$

t是网络预测的回归参数，g是GT中心点坐标x，y与宽高（映射在grid cell中）

keras.datasets 常用数据集

keras.datasets下载数据集是在google源下载，需要科学上网。已经下载过一遍的数据集第二次就不需要下载了（有需要科学上网的同学可以到About me邮件联系我）

• boston housing：波士顿房价回归模型
• mnist/fashion minst：手写数字识别
• cifar10/100：小型图片分类，cifar100是cifar10的再分类
• imdb：评语情感分类

MNIST

共70k[28*28]图片，60k来做训练，10k做检测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

In [2]: import  tensorflow as tf
   ...: from tensorflow import keras
In [4]: (x,y),(x_test,y_test) = keras.datasets.mnist.load_data() #返回numpy格式的两个tuple
In [7]: x.shape,y.shape
Out[7]: ((60000, 28, 28), (60000,))
In [9]: x.min(),x.max(),x.mean()#numpy的min、max
Out[9]: (0, 255, 33.318421449829934)
In [10]: x_test.shape,y_test.shape
Out[10]: ((10000, 28, 28), (10000,))

In [13]: y_onehot = tf.one_hot(y, depth=10)#将lable转换为onehot编码

In [15]: y[:2],y_onehot[0:2]
Out[15]:
(array([5, 0], dtype=uint8),
 <tf.Tensor: shape=(2, 10), dtype=float32, numpy=
 array([[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>)

CIFAR10/100

共60k[32*32*3]图片，50k来做训练，10k做检测

1
2
3

In [16]: (x,y),(x_test,y_test) = keras.datasets.cifar10.load_data()
In [17]: x.shape,y.shape,x_test.shape,y_test.shape
Out[17]: ((50000, 32, 32, 3), (50000, 1), (10000, 32, 32, 3), (10000, 1))

tf.data.Dataset

我们需要numpy->tensor->iter，tf.data.Dataset是专门进行数据集迭代的类

from_tensor_slices 直接转换为对象

1
2
3
4
5
6
7
8
9
10
11

In [19]: (x,y),(x_test,y_test) = keras.datasets.cifar10.load_data()

In [20]: db = tf.data.Dataset.from_tensor_slices(x)
In [21]: next(iter(db)).shape #先使用iter生成db的迭代器，在使用next每次调用向后迭代一次
Out[21]: TensorShape([32, 32, 3])

In [28]: db = tf.data.Dataset.from_tensor_slices((x,y))
In [29]: next(iter(db))[0].shape
Out[29]: TensorShape([32, 32, 3])
In [30]: next(iter(db))[1].shape
Out[30]: TensorShape([1])

.shuffle 随机打散

1
2

In [31]: db = tf.data.Dataset.from_tensor_slices((x_test,y_test)) #对应随机打散
In [32]: db = db.shuffle(10000) #这个参数可以给的大一点，10000这个范围内的随机打散

.map 数据预处理

map(a)对db中每一个数据进行a处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

In [33]: def preprocess(x,y):
    ...:     x=tf.cast(x,dtype=tf.float32)/255.
    ...:     y=tf.cast(y,dtype=tf.int32)
    ...:     y=tf.one_hot(y,depth=10)
    ...:     return(x,y)
    ...:

In [34]: db2 = db.map(preprocess)

In [35]: res = next(iter(db2))

In [36]: res[0].shape,res[1].shape
Out[36]: (TensorShape([32, 32, 3]), TensorShape([1, 10]))

In [49]: res[1]
Out[49]: <tf.Tensor: shape=(1, 10), dtype=float32, numpy=array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>

.batch

一般进行数据集读取都是读取多张

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

In [50]: db3 = db2.batch(32)

In [51]: res = next(iter(db3))

In [52]: res[0].shape,res[1].shape
Out[52]: (TensorShape([32, 32, 32, 3]), TensorShape([32, 1, 10])) 
#这里我们不需要[32,1,10]中的1，所以要在前面预处理中使用tf.squeeze将1去掉

In [61]: def preprocess(x,y):
    ...:     x=tf.cast(x,dtype=tf.float32)/255.
    ...:     y=tf.cast(y,dtype=tf.int32)
    ...:     y=tf.one_hot(y,depth=10)
    ...:     y = tf.squeeze(y)
    ...:     return(x,y)
In [62]: db2 = db.map(preprocess)
In [63]: db3 = db2.batch(32)
In [64]: res = next(iter(db3))
In [65]:  res[0].shape,res[1].shape
Out[65]: (TensorShape([32, 32, 32, 3]), TensorShape([32, 10]))

StopIteration

使用

1
2

for x,y in db：
#迭代next

正常

如果使用

1
2

In [54]: while True:
    ...:     next(db_iter)

则会报StopIteration 错误

也就是循环50k次之后继续迭代会报错，如果需要多次迭代，可以使用repeat

.repeat

1

In [66]: db4 = db3.repeat(10)

在使用for迭代db4的时候会迭代10次50k

完整步骤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import  tensorflow as tf
from tensorflow import keras

def prepare_mnist_features_and_labels(x,y):
    x = tf.cast(x, tf.float32) / 255.
    y = tf.cast(y, tf.int64)
    return x,y
def mnist_datasets():
    (x,y),(x_val,y_val) = keras.datasets.fashion_mnist.load_data()
    y = tf.one_hot(y,depth=10)
    y_val = tf.one_hot(y_val,depth=10)

    ds = tf.data.Dataset.from_tensor_slices((x,y))
    ds = ds.map(prepare_mnist_features_and_labels)
    ds = ds.shuffle(60000).batch(100)
    ds_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
    ds_val = ds_val.map(prepare_mnist_features_and_labels)
    ds_val = ds_val.shuffle(60000).batch(100)
    return ds,ds_val

全连接层

Layers

• Input
• Hidden
• Output

1
2
3
4
5
6
7
8
9
10

In [3]: x = tf.random.normal([4,784])

In [4]: net = tf.keras.layers.Dense(512)
In [5]: out = net(x) #自动根据输入的x生成w和b

In [6]: out.shape
Out[6]: TensorShape([4, 512])

In [7]: net.kernel.shape,net.bias.shape
Out[7]: (TensorShape([784, 512]), TensorShape([512]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

In [2]: net = tf.keras.layers.Dense(10)
In [3]: net.bias
AttributeError: 'Dense' object has no attribute 'bias'
#在声明netDense的时候并没有完成对w和b的创建
In [7]: net.get_weights()
Out[7]: []
In [8]: net.weights
Out[8]: []
#可以通过build来实现w和b的创建
In [9]: net.build(input_shape=(None,4))
In [10]: net.kernel.shape,net.bias.shape
Out[10]: (TensorShape([4, 10]), TensorShape([10]))
#可以重复创建kernal的参数
In [11]: net.build(input_shape=(2,4))
In [12]: net.kernel
Out[12]:
<tf.Variable 'kernel:0' shape=(4, 10) dtype=float32, numpy=
array([[ 0.61441875,  0.24404484,  0.46651304,  0.19085598, -0.05145264,
        -0.35335562, -0.10202849, -0.15380013,  0.01670462,  0.41096544],
       [-0.57477844,  0.335864  ,  0.02894145, -0.6324929 ,  0.3016789 ,
         0.38328493,  0.33733964, -0.5588818 ,  0.20204544, -0.15296638],
       [-0.56863743,  0.53329456,  0.38212597, -0.29313013,  0.5511124 ,
         0.22399694, -0.13377267, -0.24024266,  0.6475775 , -0.61608607],
       [ 0.51299465, -0.19775617, -0.0596118 ,  0.13451362,  0.5777488 ,
         0.02472413, -0.5219021 , -0.19751549, -0.62549543,  0.17085516]],
      dtype=float32)>

在前面调用net(x)时会自动调用net.build()

若提前手动设定的输入shape与实际输入shape不同时会报错

每个节点和每个节点都有连接即为全连接

Multi-Layers

• keras.Sequemtial([layer1,layer2,layer3]) 调用容器，多个Dense层组成list交给容器，调用一次forward，就会进行一层数据流动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

In [14]: x = tf.random.normal([2,4])
In [15]: model = keras.Sequential([])

In [16]: model = keras.Sequential([keras.layers.Dense(2,activation='relu'),
keras.layers.Dense(2,activation='relu'),
keras.layers.Dense(2)])

In [17]: model.build(input_shape=[None,4])

In [18]: model.summary() #方便查看网络结构
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
dense_1 (Dense)              multiple                  10
_________________________________________________________________
dense_2 (Dense)              multiple                  6
_________________________________________________________________
dense_3 (Dense)              multiple                  6
=================================================================
Total params: 22
Trainable params: 22
Non-trainable params: 0
_________________________________________________________________

In [19]: for p in model.trainable_variables:
    ...:     print(p.name,p.shape)
    ...:
dense_1/kernel:0 (4, 2)
dense_1/bias:0 (2,)
dense_2/kernel:0 (2, 2)
dense_2/bias:0 (2,)
dense_3/kernel:0 (2, 2)
dense_3/bias:0 (2,)

误差计算

MSE

• loss

• 二范数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [22]: y = tf.constant([1,2,3,0,2])
In [23]: y = tf.one_hot(y,depth=4)
In [24]: y = tf.cast(y,dtype=tf.float32)

In [25]: out = tf.random.normal([5,4])

In [26]: loss1 = tf.reduce_mean(tf.square(y-out))
In [27]: loss2 = tf.square(tf.norm(y-out))/(5*4)
In [28]: loss3 = tf.reduce_mean(tf.losses.MSE(y,out))
#tf.losses.MSE(y,out) 返回的是每个instance的mse [b]
In [29]: loss1,loss2,loss3
Out[29]:
(<tf.Tensor: shape=(), dtype=float32, numpy=0.5689168>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.5689168>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.5689168>)

Cross Entropy Loss

Entropy 熵

信息论中的概念

• 信息不确定性的度量方法
• measure of surprise
• lower entropy -> more certainty

Cross Entropy 交叉熵

交叉熵针对两个值，而后可以推导出 p的熵+pq离散度（衡量pq距离，p=q时离散度为0）

使用交叉熵时，使pq离散度趋于0，也就是y与out的离散度，就是我们需要的状态

1
2
3
4
5
6
7
8

In [30]: tf.losses.categorical_crossentropy([0,1,0,0],[0.25,0.25,0.25,0.25])
Out[30]: <tf.Tensor: shape=(), dtype=float32, numpy=1.3862944>

In [31]: tf.losses.categorical_crossentropy([0,1,0,0],[0.1,0.8,0.05,0.05])
Out[31]: <tf.Tensor: shape=(), dtype=float32, numpy=0.22314353>

In [32]: tf.losses.categorical_crossentropy([0,1,0,0],[0.01,0.97,0.01,0.01])
Out[32]: <tf.Tensor: shape=(), dtype=float32, numpy=0.030459179>

• 对比MSE ，sigmod+MSE可能造成gradient vanish
• Cross Entropy在预测错误较严重时，收敛会相对较快
• 具体问题具体分析 比如meta-learning使用MSE就会比较稳定

logit指的是最后一层没有加激活函数，经过softmax和CE会有数值不稳定的问题，我们将最后两个部分统一合并为一起，作为一个函数，在函数内部已经做好优化

1

In [34]: tf.losses.categorical_crossentropy([0,1,0,0],logits,from_logits=True)

from_logits一定要设定

且传入的是logits，而不是经过softmax函数的

concat 拼接

axis=? 合并某一个维度的数据

要求除了要拼接的维度外的所有维度都相等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

In [2]: a = tf.ones([4,35,8])
In [3]: b = tf.zeros([2,35,8])
In [4]: c = tf.concat([a,b],axis = 0)
TensorShape([6, 35, 8])
In [6]: b = tf.zeros([4,3,8])
In [7]: c = tf.concat([a,b],axis = 1)
TensorShape([4, 38, 8])

In [10]: a = tf.ones([4,3])
In [11]: b = tf.zeros([4,4])
In [13]: c = tf.concat([a,b],axis = 1)
<tf.Tensor: shape=(4, 7), dtype=float32, numpy=
array([[1., 1., 1., 0., 0., 0., 0.],
       [1., 1., 1., 0., 0., 0., 0.],
       [1., 1., 1., 0., 0., 0., 0.],
       [1., 1., 1., 0., 0., 0., 0.]], dtype=float32)>

stack 创建新的维度

所有维度必须完全一致

1
2
3
4
5

In [22]: a = tf.ones([4,35,8])
In [23]: b = tf.zeros([4,35,8])

In [24]: tf.stack([a,b],axis=0).shape
Out[24]: TensorShape([2, 4, 35, 8])

unstack 拆分

维度上有多少就拆分成多少

1
2
3
4
5
6
7
8
9
10
11
12

In [26]: a = tf.ones([4,35,8])
In [27]: b = tf.ones([4,35,8])
In [28]: c = tf.stack([a,b])
TensorShape([2, 4, 35, 8])

In [31]: aa,bb = tf.unstack(c,axis = 0)
In [32]: aa.shape,bb.shape
Out[32]: (TensorShape([4, 35, 8]), TensorShape([4, 35, 8]))

In [33]: res = tf.unstack(c,axis=3)
In [37]: res[0].shape,res[7].shape
Out[37]: (TensorShape([2, 4, 35]), TensorShape([2, 4, 35]))

Split

比unstack灵活性更强

1
2
3
4
5
6
7
8
9
10
11
12

In [39]: res = tf.split(c,axis=3,num_or_size_splits=2)
In [40]: len(res)
Out[40]: 2
In [41]: res[0].shape
Out[41]: TensorShape([2, 4, 35, 4])

In [42]: res = tf.split(c,axis=3,num_or_size_splits=[2,2,4])
In [43]: res[0].shape,res[1].shape,res[2].shape
Out[43]:
(TensorShape([2, 4, 35, 2]),
 TensorShape([2, 4, 35, 2]),
 TensorShape([2, 4, 35, 4]))

数据统计

Vector Norm 向量范数

二范数：平方和开根号

无穷范数：元素中最大值的绝对值

一范数：绝对值的和

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#norm Vector Norm 向量范数 默认为二范数
In [2]: a = tf.ones([2,2])

In [3]: tf.norm(a)
Out[3]: <tf.Tensor: shape=(), dtype=float32, numpy=2.0>
In [4]: tf.sqrt(tf.reduce_sum(tf.square(a)))
Out[4]: <tf.Tensor: shape=(), dtype=float32, numpy=2.0>

In [5]: a = tf.ones([4,28,28,3])

In [6]: tf.norm(a)
Out[6]: <tf.Tensor: shape=(), dtype=float32, numpy=96.99484>
In [7]: tf.sqrt(tf.reduce_sum(tf.square(a)))
Out[7]: <tf.Tensor: shape=(), dtype=float32, numpy=96.99484>

ord指定范数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [23]: a = tf.ones([2])
In [24]: b= tf.fill([2],2.)
In [25]: c = tf.stack([a,b],axis=0)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[1., 1.],
       [2., 2.]], dtype=float32)>

In [27]: tf.norm(c,ord=1)
Out[27]: <tf.Tensor: shape=(), dtype=float32, numpy=6.0>

In [28]: tf.norm(c,ord=1,axis=0)
Out[28]: <tf.Tensor: shape=(2,), dtype=float32, numpy=array([3., 3.], dtype=float32)>

In [29]: tf.norm(c,ord=1,axis=1)
Out[29]: <tf.Tensor: shape=(2,), dtype=float32, numpy=array([2., 4.], dtype=float32)>

reduce_min/max/mean

最小值/最大值/平均值

指定axis后会求某维度的均值，不指定求全均值

1
2
3
4
5
6
7
8

In [33]: tf.reduce_min(c),tf.reduce_max(c),tf.reduce_mean(c)
Out[33]:
(<tf.Tensor: shape=(), dtype=float32, numpy=1.0>,
 <tf.Tensor: shape=(), dtype=float32, numpy=2.0>,
 <tf.Tensor: shape=(), dtype=float32, numpy=1.5>)
 
In [34]: tf.reduce_min(c , axis=1)
Out[34]: <tf.Tensor: shape=(2,), dtype=float32, numpy=array([1., 2.], dtype=float32)>

argmax/argmin

最大值最小值所在的位置,默认axis为0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

In [31]: a = tf.random.normal([4,10])
In [35]: tf.argmax(a)
Out[35]: <tf.Tensor: shape=(10,), dtype=int64, numpy=array([1, 2, 3, 0, 0, 2, 3, 0, 2, 1])>

In [51]: d
Out[51]:
<tf.Tensor: shape=(3, 2), dtype=float32, numpy=
array([[1., 1.],
       [2., 2.],
       [0., 3.]], dtype=float32)>

In [52]: tf.argmax(d)
Out[52]: <tf.Tensor: shape=(2,), dtype=int64, numpy=array([1, 2])>

In [53]: tf.argmin(d)
Out[53]: <tf.Tensor: shape=(2,), dtype=int64, numpy=array([2, 0])>

In [54]: tf.argmax(d,axis=1)
Out[54]: <tf.Tensor: shape=(3,), dtype=int64, numpy=array([0, 0, 1])>

equal

1
2
3
4
5
6
7
8
9

In [56]: b= tf.range(5)
In [58]: a = tf.constant([0,1,3,2,4])

In [59]: tf.equal(a,b)
Out[59]: <tf.Tensor: shape=(5,), dtype=bool, numpy=array([ True,  True, False, False,  True])>

In [60]: res = tf.equal(a,b)
In [62]: tf.reduce_sum(tf.cast(res,dtype=tf.int32)) #cast数据类型转换 得到同样的个数
Out[62]: <tf.Tensor: shape=(), dtype=int32, numpy=3>

Accuary

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [64]: a
Out[64]:
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0.1 , 0.2 , 0.7 ],
       [0.9 , 0.05, 0.05]], dtype=float32)>
       
In [67]: pred = tf.cast(tf.argmax(a,axis=1),dtype=tf.int32)
<tf.Tensor: shape=(2,), dtype=int32, numpy=array([2, 0], dtype=int32)>

In [72]: y
Out[72]: <tf.Tensor: shape=(2,), dtype=int32, numpy=array([2, 1], dtype=int32)>

In [82]: correct = tf.reduce_mean(tf.cast(tf.equal(y,pred),dtype = tf.float32))
In [83]: correct
Out[83]: <tf.Tensor: shape=(), dtype=float32, numpy=0.5>

unique

1
2
3
4
5
6
7
8
9
10

In [84]: a = tf.constant([4,2,2,4,3])
In [87]: unique,idx = tf.unique(a)
In [88]: unique
Out[88]: <tf.Tensor: shape=(3,), dtype=int32, numpy=array([4, 2, 3], dtype=int32)>

In [89]: idx
Out[89]: <tf.Tensor: shape=(5,), dtype=int32, numpy=array([0, 1, 1, 0, 2], dtype=int32)>

In [90]: tf.gather(unique,idx) #前按后中存储索引排列
Out[90]: <tf.Tensor: shape=(5,), dtype=int32, numpy=array([4, 2, 2, 4, 3], dtype=int32)>

张量排序

• Sort,argsort

一维

1
2
3
4
5
6
7
8
9
10
11
12
13

In [3]: a = tf.random.shuffle(tf.range(5))
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([2, 3, 0, 4, 1], dtype=int32)>

In [5]: tf.sort(a,direction = 'DESCENDING')#降序
Out[5]: <tf.Tensor: shape=(5,), dtype=int32, numpy=array([4, 3, 2, 1, 0], dtype=int32)>
In [6]: tf.argsort(a,direction = 'DESCENDING')#降序排序后原所在位置
Out[6]: <tf.Tensor: shape=(5,), dtype=int32, numpy=array([3, 1, 0, 4, 2], dtype=int32)>

In [7]: idx = tf.argsort(a,direction = 'DESCENDING')
In [8]: tf.gather(a,idx)
Out[8]: <tf.Tensor: shape=(5,), dtype=int32, numpy=array([4, 3, 2, 1, 0], dtype=int32)>

高维，对最后一个维度排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

In [9]: a = tf.random.uniform([3,3],maxval=10,dtype=tf.int32)
<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[8, 0, 8],
       [9, 2, 8],
       [2, 4, 9]], dtype=int32)>
       
In [11]: tf.sort(a)
Out[11]:
<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[0, 8, 8],
       [2, 8, 9],
       [2, 4, 9]], dtype=int32)>
       
In [12]: tf.argsort(a)
Out[12]:
<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[1, 0, 2],
       [1, 2, 0],
       [0, 1, 2]], dtype=int32)>

• top_k

最大的或最小的前几个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

In [13]: a
Out[13]:
<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[8, 0, 8],
       [9, 2, 8],
       [2, 4, 9]], dtype=int32)>

In [14]: res = tf.math.top_k(a,2)#返回一个tuple

In [15]: res.indices#argsort 前2个
Out[15]:
<tf.Tensor: shape=(3, 2), dtype=int32, numpy=
array([[0, 2],
       [0, 2],
       [2, 1]], dtype=int32)>
In [16]: res.values#sort 前2个
Out[16]:
<tf.Tensor: shape=(3, 2), dtype=int32, numpy=
array([[8, 8],
       [9, 8],
       [9, 4]], dtype=int32)>

• Top-k Accuracy

在前k中有匹配的就算为正确，也可以检验模型的好坏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#topk=(1,2,3) 返回top1,2,3这三个的topAccuracy output[b,N],target[b]
def accuracy(output,target,topk=(1,)):
maxk = max (topk)
batch_size = target.shape[0]

pred = tf.math.top_k(output,maxk).indices
pred = tf.transpose(pred,prem=[1,0])# 转置
target_ = tf.broadcast_to(target,pred.shape)
correct = tf.equal(pred, target_)

res = []
for k in topk:
correct_k = tf.cast(tf.reshape(correct[:k],[-1]),dtype = tf.float32)
correct_k = tf.reduce_sum(correct_k)
acc = float(correct_k/batch_size)
res.append(acc)
return res

数据填充、复制

填充 pad

• 一维 [3] ->前补充1位，后补充2位->一维[6]（[[1,2]]意思为：一维前补1后补2）
• 二维[2,2]->行：前不补，后补1行；列：前补1列，后补1列->[3,4]（[[0,1],[1,1]]意思为：二维，第一维前补0后补1，第二维前补1后补1）
• 默认补0

1
2
3
4
5
6
7
8

In [21]: a = tf.reshape(tf.range(4),[2,2])

In [22]: tf.pad(a,[[0,1],[1,1]])
Out[22]:
<tf.Tensor: shape=(3, 4), dtype=int32, numpy=
array([[0, 0, 1, 0],
       [0, 2, 3, 0],
       [0, 0, 0, 0]], dtype=int32)>

复制 tile

• [a,b] 代表第一个维度复制a次，第二个维度复制b次

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

In [24]: tf.tile(a,[1,2])
Out[24]:
<tf.Tensor: shape=(2, 4), dtype=int32, numpy=
array([[0, 1, 0, 1],
       [2, 3, 2, 3]], dtype=int32)>

In [25]: tf.tile(a,[2,2])
Out[25]:
<tf.Tensor: shape=(4, 4), dtype=int32, numpy=
array([[0, 1, 0, 1],
       [2, 3, 2, 3],
       [0, 1, 0, 1],
       [2, 3, 2, 3]], dtype=int32)>

In [26]: tf.tile(a,[3,2])
Out[26]:
<tf.Tensor: shape=(6, 4), dtype=int32, numpy=
array([[0, 1, 0, 1],
       [2, 3, 2, 3],
       [0, 1, 0, 1],
       [2, 3, 2, 3],
       [0, 1, 0, 1],
       [2, 3, 2, 3]], dtype=int32)>
       
In [27]: tf.tile(a,[1,1])
Out[27]:
<tf.Tensor: shape=(2, 2), dtype=int32, numpy=
array([[0, 1],
       [2, 3]], dtype=int32)>

张量限幅

• maximum 若值小于a 则使该值=a
• minimum 若值大于b 则使该值=b
• clip_by_value 若值小于a 则使该值=a,若值大于b 则使该值=b(限制数据在a与b之间)

1
2
3
4
5
6
7
8
9
10
11

In [3]: a
Out[3]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>

In [4]: tf.maximum(a,2)  
Out[4]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([2, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>

In [5]: tf.minimum(a,8)
Out[5]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([0, 1, 2, 3, 4, 5, 6, 7, 8, 8], dtype=int32)>

In [6]: tf.clip_by_value(a,2,8) #同tf.minimum(tf.maximum(a,2),8)
Out[6]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([2, 2, 2, 3, 4, 5, 6, 7, 8, 8], dtype=int32)>

relu函数max(0,x)

1
2
3
4
5
6
7
8
9

In [9]: a
Out[9]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4], dtype=int32)>

In [10]: tf.nn.relu(a)
Out[10]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([0, 0, 0, 0, 0, 0, 1, 2, 3, 4], dtype=int32)>

In [11]: tf.maximum(a,0)
Out[11]: <tf.Tensor: shape=(10,), dtype=int32, numpy=array([0, 0, 0, 0, 0, 0, 1, 2, 3, 4], dtype=int32)>

• clip_by_norm

在clipping时，如果只根据值裁剪的话gradient的方向会发生变化，不利于找到最优解，使用范数限幅可以进行等比例放缩解决这样的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [14]: a = tf.random.normal([2,2],mean=10)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[12.561244,  9.496627],
       [10.774074, 10.137045]], dtype=float32)>
       
In [16]: tf.norm(a)
Out[16]: <tf.Tensor: shape=(), dtype=float32, numpy=21.605812>

In [17]: aa = tf.clip_by_norm(a,15)
<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[8.720739, 6.593106],
       [7.479983, 7.037721]], dtype=float32)>
       
In [20]: tf.norm(aa)
Out[20]: <tf.Tensor: shape=(), dtype=float32, numpy=15.0>

• Grandient clipping

new_grads,total_norm = tf.clip_by_global_norm(grad,25) 一组grad的范数裁剪，返回裁剪后的grad和原始总范数

其他操作

where

• where(tensor) 只接受一个参数是一个bool型的tensor，会返回一系列坐标 (True)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

In [23]: a
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[ 1.7502894 ,  0.42312455, -0.05275195],
       [-1.2338606 ,  0.21349485,  1.2465866 ],
       [ 0.11755344, -0.45547193,  1.792042  ]], dtype=float32)>

In [24]: mask = a > 0
<tf.Tensor: shape=(3, 3), dtype=bool, numpy=
array([[ True,  True, False],
       [False,  True,  True],
       [ True, False,  True]])>

In [26]: tf.boolean_mask(a,mask)
Out[26]:
<tf.Tensor: shape=(6,), dtype=float32, numpy=
array([1.7502894 , 0.42312455, 0.21349485, 1.2465866 , 0.11755344,
       1.792042  ], dtype=float32)>

In [27]: indices = tf.where(mask)
<tf.Tensor: shape=(6, 2), dtype=int64, numpy=
array([[0, 0],
       [0, 1],
       [1, 1],
       [1, 2],
       [2, 0],
       [2, 2]])>

In [29]: tf.gather_nd(a,indices)
Out[29]:
<tf.Tensor: shape=(6,), dtype=float32, numpy=
array([1.7502894 , 0.42312455, 0.21349485, 1.2465866 , 0.11755344,
       1.792042  ], dtype=float32)>

• where(cond,A,B) cond 为True的地方取A cond为False的地方取B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17