机器视觉 on 好冷の小窝

Tensorflow入门

Mon, 17 Jul 2023 10:50:29 +0800

Gentoo Linux 系统下 Tenosorflow-gpu 的安装

安装 nvidia 驱动

可以参考我的这篇文章

使用 nvidia-smi命令验证安装是否成功

我的电脑输出如下：

Mon Jul 17 10:54:53 2023
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.125.06   Driver Version: 525.125.06   CUDA Version: 12.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0 Off |                  N/A |
| N/A   37C    P0    N/A /  80W |      6MiB /  6144MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|    0   N/A  N/A      3640      G   /usr/bin/X                          4MiB |
+-----------------------------------------------------------------------------+

安装cuda

安装软件包

sudo emerge --ask dev-util/nvidia-cuda-toolkit

下载cudnn

将下载后的文件解压缩并复制到指定位置

tar xvzf cudnn-linux-x86_64-8.9.3.28_cuda12-archive.tar.xz

cd cudnn-linux-x86_64-8.9.3.28_cuda12-archive
sudo cp include/cudnn.h /opt/cuda/include
sudo cp lib/libcudnn* /opt/cuda/lib64
sudo chmod a+r /opt/cuda/include/cudnn.h
sudo chmod a+r /opt/cuda/lib64/libcudnn*

安装Anaconda

下载安装脚本Download

给予执行权限chomd +x Anaconda3-*.sh

执行./Download/Anaconda3-*.sh

然后配置安装目录，是否在当前shell环境中激活，建议是。

安装Tensorflow

创建虚拟环境

conda create --name tensorflow python=3.10

激活虚拟环境

conda activate tensorflow

安装软件包

# conda环境下的cuda和cudnn
conda install -c conda-forge cudatoolkit=11.8.0 cudnn=8.9.2.26

# conda虚拟环境的环境变量配置
# 临时设置
export LD_LIBRARY_PATH=$CONDA_PREFIX/lib/:$CUDNN_PATH/lib:$LD_LIBRARY_PATH
export XLA_FLAGS=--xla_gpu_cuda_data_dir=/opt/cuda

# 永久配置（建议临时设置测试tensorflow环境，成功之后再进行永久性配置）
mkdir -p $CONDA_PREFIX/etc/conda/activate.d
echo 'export LD_LIBRARY_PATH=$CONDA_PREFIX/lib/:$CUDNN_PATH/lib:$LD_LIBRARY_PATH' >> $CONDA_PREFIX/etc/conda/activate.d/env_vars.sh
echo 'export XLA_FLAGS=--xla_gpu_cuda_data_dir=/opt/cuda' >> $CONDA_PREFIX/etc/conda/activate.d/env_vars.sh

# pip安装tensorflow
pip install --upgrade pip
pip install tensorflow

验证

`1`	`python3 -c "import tensorflow as tf; print('GPU', tf.test.is_gpu_available())"`

本人电脑上输出如下：

****
2023-07-17 11:14:12.266188: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /device:GPU:0 with 4069 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3060 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6
GPU True
****

至此，Tensorflow安装完毕。

Tensorflow Object Detection API 安装

安装教程参考 tensorflow2 od install

克隆tensorflow模型存储库

`1`	`git clone https://github.com/tensorflow/models.git`

pip安装

cd models/research
# 需要安装 protos 在环境当中
protoc object_detection/protos/*.proto --python_out=.
# 安装 TensorFlow Object Detection API
cp object_detection/packages/tf2/setup.py .
pip install .

测试

1
2

# Test the installation.
python object_detection/builders/model_builder_tf2_test.py

恭喜您，已经完成了安装，下来试试一个小例子吧。

一个浣熊检测小模型

视觉导航综述

Mon, 17 Jul 2023 10:50:29 +0800

视觉导航

室内导航

关键技术：

传感器信息采集分析

SLAM建图的准确性、及时性，均取决于传感器获得数据的完备性。
视觉里程计与回环检测分析

传统VO框架搭配回环检测消除误差。
3D建图

传统的ORB-SLAM只能构建稀疏云点地图，无法应用与导航任务，需要构建立体视觉惯性SLAM，生成三维语义拓扑图，最后生成路径规划地图，实现自主导航。

基于深度视觉感知的SLAM导航

深度视觉的SLAM工作原理图：

stateDiagram-v2 direction LR [*] --> operation state operation{ direction LR 传感器数据 --> （前端）视觉里程计（前端）视觉里程计 -->（后端）非线性优化（后端）非线性优化 --> 建图 } 传感器数据 --> 回环检测回环检测 --> （后端）非线性优化建图 --> [*]

视觉处理主要前端处理算法：

graph LR A([前端处理]) --> BB[特征法] & C[直接法] BB --> B1(关键点提取) B1 --> b11(["ORB(具有良好的平移旋转不变性，提取时间快)"]) B1 --> b12(["SIFT(鲁棒性强,光照,旋转等均不敏感)"]) B1 --> b13(["FAST(Fast角点，噪声敏感，速度快)"]) B1 --> b14(["SURF(计算量比SIFT显著降低,同时鲁棒性也降低)"]) BB --> B2(描述子) B2 --> b21([梯度计算HOG描述子]) B2 --> b22([二进制BRISK描述子]) BB --> B3(特征匹配-FLANN算法) BB --> B4(数据关联) B4 --> b41("2D-2D(多视图几何)") B4 --> b42("2D-3D(线性化(PNP)、非线性求解(BA))") B4 --> b43("3D-3D") C --> C1["半直接法(光流)"] C --> C2[直接法] C1 & C2 --> c("(使用最小化光度误差，非线性优化求解)")

特征法： 特征法视觉里程计，将数据关联和位姿估计问题分开考虑、独立解决，但是特征计算和特征匹配非常耗时，在特征缺失、纹理重复的环境中容易跟踪丢失，并且稀疏的点云地图只能用于定位，而无法提供导航、避障等诸多功能。

直接法： 直接法视觉里程计以一种更整体、更优雅的方式，处理数据关联和位姿估计问题，仅使用像素的灰度信息，计算效率高，并且在特征缺失的环境中，也有很好的表现。其不足在于，对光照变化非常敏感，所建立的地图无特征描述子，导致难以进行地图的复用。因此，直接法更擅长端到端的解决连续缓慢的定位问题，而特征法更适合重定位与回环检测。

视觉处理主要后端处理算法：

graph LR A([后端优化]) --> B(基于滤波的方法) & C(基于优化的方法) & D(回环检测) B --> B1(["EKF算法(扩展卡尔曼滤波)"]) B --> B2(["PKF算法(粒子滤波算法)"]) B --> B3(["MSCKF算法(多状态约束卡尔曼)"]) C --> C1(BA优化) C1 --> c11(["PTAM"]) C1 --> c12(["ORB-SLAM"]) C --> C2(位姿图优化,舍弃对于路标点的优化) C2 --> c21([Vins-Mono]) C2 --> c22([OKVIS]) C --> C3(因子图优化) C3 --> c31([ISAM以及其对应的gtsam算法库]) D --> D1(基于深度学习) D --> D2(基于词袋模型)

**滤波器法：**虽然滤波器的全局优化假设了状态量之间的马尔可夫性，存在较大的线性误差，但相比非线性优化法在计算资源受限平台或结构化场景中，仍然是一种非常有效的方法。

**优化算法：**非线性优化法是利用约束条件构造目标函数，通过最优化的算法寻找位姿和地图点的最优解。集束调整和图优化都是非线性优化法，但是比较难以求解。

**回环检测：**基于子地图与子地图间的匹配、基于图像与子地图间的匹配、基于图像与图像间匹配（目前主流）、基于卷积神经网络的回环检测。

室外导航

关键技术：

构建特定区域先验数据库
匹配算法

匹配算法直接关乎无人机定位的准确度，对于 SIFT 算法而言，计算复杂度较高，内部运算的数据量巨大，难以符合无人机定位导航的实时性需求，同样也会降低让无人机的工作效率。
搜索目标特征提取、目标确认分析

搜索前需要得到目标的特征，目标特征点太少会导致识别率降低，目标特征不够明确会导致识别错误率增加，目标特征过于精细由于传感器精度不够，会难以匹配成功。

无人机巡查工作原理：
stateDiagram direction LR 特定区域先验数据库 --> 匹配算法实测环境特征数据 --> 匹配算法匹配算法 --> 无人机无人机 --> 定位与导航定位与导航 --> 巡查工作
特殊目标搜索识别原理：

stateDiagram-v2 direction LR [*] --> operation 搜索目标特征 --> 目标确认搜索目标特征 --> 无人机 state operation { direction LR 目标搜索 --> 目标确认目标确认 --> 无人机无人机 --> 定位与跟踪 } 定位与跟踪 --> [*]

Pytorch入门

Sat, 20 May 2023 05:59:13 +0800

引言

安装相关

安装Anaconda

通过链接Anaconda下载安装包并根据提示安装到自己的目标目录下。国内网络环境不友好，可以更换国内镜像源。

然后在当前环境下创建一个新的环境命名为 pytorch(可随意确定) 并切换到新环境(pytorch)下，再安装pytorch所需的环境

(base)$ conda create -n pytorch python=3.10
(base)$ conda activate pytorch

# GPU版本的
(pytorch)$ conda install pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia
# CPU版本的
(pytorch)$ conda install pytorch torchvision torchaudio cpuonly -c pytorch

安装完成之后进行验证

(pytorch)$ python
Python 3.10.11 (main, Apr 20 2023, 19:02:41) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
# 没有报错说明 pytorch 安装成功
>>> torch.cuda.is_available()
# True说明 GPU 可用,我这里 linux 系统并没有装 nvidia 显卡驱动，所以是 False
False
>>> x = torch.rand(5, 3)
>>> print(x)
tensor([[0.7296, 0.8000, 0.3431],
        [0.9990, 0.2202, 0.0889],
        [0.1130, 0.9352, 0.8562],
        [0.4942, 0.4214, 0.4962],
        [0.3023, 0.7504, 0.6801]])
>>>

Tensorboard使用举一个简单的画三角函数图像的例子：

import numpy as np
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("./test_logs")    # 可自定义输出位置，默认为./runs
r = 5
for i in range(100):
    writer.add_scalars('trigonometric function', 
                       {'xsinx':i*np.sin(i/r),
                       'xcosx':i*np.cos(i/r),
                       'tanx': np.tan(i/r)}, i)
writer.close()

然后通过命令 tensorboard --logdir=test_logs，根据提示可以打开网页看到结果，如下图所示。

Transforms图像变换

from torchvision import transforms
transforms.CenterCrop() #对图片中心进行裁剪 
transforms.FiveCrop()  #对图像四个角和中心进行裁剪得到五分图像
transforms.Grayscale()  #对图像进行灰度变换
transforms.Pad()  #使用固定值进行像素填充
transforms.RandomResizedCrop()	#随即裁剪为不同大小和宽高比，然后缩放为特定大小
transforms.RandomCrop()  #随机区域裁剪
transforms.RandomRotation()  #随机旋转
transforms.RandomHorizontalFlip()  #随机水平翻转
transforms.Normalize()	#归一化处理
...

transforms.Compose组合实现各种变化

transform = transforms.Compose([
    			transforms.Random
    			transforms.ToTensor(),
     			transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

torchvision、DataLoader

nn.Module

卷积层

激活层

池化层

全连接层

损失函数

L1Loss && MSELoss

假设预期结果为 [1, 2, 8]，但实际结果为 [1, 2, 3]

定义：

$$ ℓ(x,y)=\begin{cases} mean(L),\quad reduction=mean; \\\\ sum(L),\quad reduction=sum \end{cases} $$

loss_l1 = nn.L1loss(reduction='mean'或者'sum')

L1Loss的结果：

$$ ℓ(x,y)=\begin{cases} \frac {(1 - 1) + (2 - 2) + (8 - 3)}{3} = 1.67 \quad reduction = mean \\\ (1 - 1) + (2 - 2) + (8 - 3) = 5 \quad reduction = sum \end{cases} $$

loss_mse = nn.MSELoss()

MSELoss的结果：

$$ ℓ(x,y)=\begin{cases} \frac {(1 - 1)^2 + (2 - 2)^2 + (8 - 3)^2}{3} = 8.33 \quad reduction = mean \\\ (1 - 1)^2 + (2 - 2)^2 + (8 - 3)^2 = 25 \quad reduction = sum \end{cases} $$

CrossEntropyLoss

torch.nn.CrossEntropyLoss(weight=None, ignore_index=- 100, reduction='mean', label_smoothing=0.0)

定义：

$$ loss(x, class) = -ln(\frac{e^{x[class]}}{\sum_j e^{x[j]}}) \\\ =-x[class] + ln(\sum_j e^{x[j]}) $$

import torch
from torch import nn
## target	[person, dog, cat]
## intputs	[0.1, 	 0.2, 0.3]
inputs = torch.tensor([0.1, 0.2, 0.3])
target = torch.tensor([1])	# 1代表dog
inputs = torch.reshape(inputs, (1, 3))

loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(inputs, target)
print(result_cross)
## 输出
## tensor(1.1019)

CrossEntropyLoss的结果：

$$ loss(x, class) = -0.2 + ln(e^{0.1} + e^{0.2} + e^{0.3}) = 1.1019 $$

一个简单的例子（Cifar-10分类任务）

# -*- coding: utf-8 -*-
# 导入包
import torch
import torchvision
from torch.utils.tensorboard import SummaryWriter
from torch import nn
from torch.utils.data import DataLoader

# 导入数据集
train_data = torchvision.datasets.CIFAR10(root="./data", train=True,
                                          transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10(root="./data", train=False,
                                          transform=torchvision.transforms.ToTensor(), download=True)

# 输出训练和测试总量
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练集的大小: {}".format(train_data_size))
print("测试集的大小: {}".format(test_data_size))

batch_size = 64
train_dataloader = DataLoader(train_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64*4*4, 64),
            nn.Linear(64, 10)
        )
    def forward(self, x):
        x = self.model(x)
        return x

# 实例一个model
my_model = MyModel()

# GPU
if torch.cuda.is_available():
    my_model = my_model.cuda()

# 损失函数
loss_fn = nn.CrossEntropyLoss() # 交叉熵
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()

# 优化器
learning_rate = 0.01    # 学习率
optimizer = torch.optim.SGD(my_model.parameters(), lr=learning_rate)

# 训练参数
total_train_step = 0
total_test_step = 0
epoch = 16

# tensorboard
writer = SummaryWriter("./taining_logs")

for i in range(epoch):
    print("----开始第 {} 轮训练----".format(i+1))

    my_model.train()
    for data in train_dataloader:
        imgs, labels = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            labels = labels.cuda()
        outputs = my_model(imgs)
        loss = loss_fn(outputs, labels)
        # 优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step = total_train_step + 1
        # 每100次显示一次
        if total_train_step % 100 == 0:
            print("第 {} 次训练的loss值: {}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    # 测试步骤开始
    my_model.eval()
    total_test_loss = 0
    total_accuracy = 0
    # 测试集不需要梯度
    with torch.no_grad():
        for data in test_dataloader:
            imgs, labels = data
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                labels = labels.cuda()
            outputs = my_model(imgs)
            loss = loss_fn(outputs, labels)
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == labels).sum()
            total_accuracy = total_accuracy + accuracy

        print("整体测试集上的Loss: {}".format(total_test_loss))
        print("整体测试集上的正确率: {}".format(total_accuracy / test_data_size))
        writer.add_scalar("test_loss", total_test_loss, total_test_step)
        writer.add_scalar("test_accuracy", total_accuracy / test_data_size, total_test_step)
        total_test_step = total_test_step + 1
      
torch.save(my_model, "my_cifar10.pth")
print("模型已保存")
writer.close()

Pytorch 各种模型的格式

格式	说明	适用场景	对应后缀
`.pt或.pth`	pytorch默认的模型文件	需要保存和加载完整Pytorch模型的场景	`.pt或.pth`
`.bin`	通用的二进制格式	需要将Pytorch模型转化为通用的二进制格式的场景	`.bin`
`.onnx`	通用的交叉模型格式	需要将Pytorch模型转化为其他深度学习框架或硬件平台可用的格式的场景	`.onnx`
TorchScript	Pytorch提供的一种序列化和优化模型的方法	需要将Pytorch模型序列化和优化，并在没有Pytorch环境的情况下运行模型的场景	`.pt或.pth`

目标检测数据集

VOC数据集

Annotations：包含了xml文件，描述了图片的各种信息，特别是目标的坐标位置
ImagesSets：主要关注Main文件夹的内容，里面的文件包含了不同类别目标的训练/验证数据集的图片名称
JPEGImages：图片原文件
SegentationClass/Object：用于语义分割

COCO数据集

创建自己的coco数据集：

目录结构：
.........
my_dataset
    ├───imgs
    │  ├───1.jpg
    │  ├───1.json
    │  ├───2.jpg
    │  ├───2.json
    │  │...........
    │  └───nnn.json
 	└───coco
labelme2coco.py
labels.txt
.........

安装labelme,然后在当前目录执行命令：

`1`	`python labelme2coco.py --labels labels.txt my_data/imgs/ my_data/coco/`

其中文件链接labelme2coco.py和labels.txt文件示例如下(本演示只有一个标签raccoon):

1
2
3

__ignore__
_background_
raccoon

之后会在coco目录下生成可用的coco数据集文件。

加载该数据集并可视化显示的代码如下：

import torchvision
from PIL import ImageDraw

# torch官方的Coco API加载数据集
coco_dataset = torchvision.datasets.CocoDetection(root=r"./my_data/coco/",                                       annFile=r"./my_data/coco/annotations.json")
# 读取第一张图片并显示
image, info = coco_dataset[0]
image_handler = ImageDraw.ImageDraw(image)
# 在该图片上画上标注框
for annotation in info:
    x_min, y_min, width, height = annotation['bbox']
    image_handler.rectangle(((x_min, y_min), (x_min+width, y_min+height)),
                            fill=None, outline='red', width=2)
# 显示
image.show()

To be contuine

神经网络视觉基础

Thu, 11 May 2023 05:59:13 +0800

神经网络视觉基础

基础知识

神经网络的基本原理

神经网络的训练，主要目的就是通过学习算法得到各层神经元之间的连接权重和偏置参数等，然后通过参数计算出输入值的输出。

卷积神经网络包括输入层、中间层、输出层。而中间层可以细化为卷积层、激活层、池化层和全连接层。

卷积层（局部感知、权值共享）–（图像特征提取）

卷积层中，卷积操作由一个或者多个卷积核(filter)在前层图像上选择相应的区域做卷积运算，然后按一定的步长作滑动运算，依次提取图像区域的像素级特征，图像特征综合后经过激活函数激活，完成一次输入到输出的特征提取过程，卷积后的特征图反映了前层图像的融合特征。

卷积操作

经卷积后的矩阵尺寸大小计算公式为(输入图片大小WxW，卷积核FxF，步长S，padding = P) $$ N = (W - F + 2P) / S + 1 $$

激活层 (通过函数把特征保留并映射到输出端)

卷积神经网络在卷积操作后作用非线性激活函数，可以实现对输入信息的非线性变化，从而使网络的输入和输出产生非线性映射关系，激活层对卷积后的逐元素作用激活函数，实现输入和输出信息的同维。引入激活函数的目的是为了增加神经网络的非线性拟合能力。

“为什么一定要非线性？”

因为神经网络的每一次输入和输出都是线性求和过程，下一层输出承接了上一层输入函数的线性变换，如果没有非线性激活函数，那么无论神经网络有多少层，最后的输出都是输入的线性组合。这样的线性组合并不能解决复杂的问题。

激活函数

Sigmoid（又称“逻辑函数”）

$$ f(x) = \frac {1} {1 + e^{-x}} $$

$$ y = \begin{cases} 1, 当S(x) \ge 0.5 \\\ 0, 当S(x) < 0.5 \end{cases} $$

$$ S(x)’ = \frac{e^{-x}}{(1+e^{-x})^2} $$

优点：

值域为[0,1]，他对每个神经元的输出进行了归一化，适合用于将预测概率作为输出的模型
梯度平滑，避免了跳跃式 的输出

缺点：

接近0或1的神经元梯度趋近于0，容易引起梯度消失，即无法反向传播更新权重。
计算量大，需要更高的算力

ReLU（目前主流的激活函数）

$$ f(x) = Max(0, x) $$

$$ f’(x) = Sgn(x) $$

相比sigmoid函数，其计算速度快，收敛速度快（因为输入为负值时，神经元不会被激活，所以网络很稀疏，能更好的提取相关特征，拟合训练数据）。ReLU函数能够最大化发挥神经元的筛选能力。

不足：很容易训练过程中使部分kernel废掉，且无法再次被激活。
“ReLU是分段线性函数，它是怎么实现非线性的？”

ReLU在整个定义域内并不是线性的，组合多个（线性操作+ReLU）就可以任意划分空间，对于层数比较少的神经网络，用ReLU作为激活函数，那非线性肯定没有那么强，但是当层数多达几十甚至上千，虽然，单独的隐藏层是线性的，但是很多的隐藏层表现出来的就是非线性的。（即用很多小的直线可以拟合出曲线效果一样）。

Leaky ReLU

$$ f(x) = max(\alpha x, x) $$ 其中$\alpha$为(0,1)的系数，可以有效解决*ReLU*函数神经元死亡的现象。

Softmax (所有输出概率和为1)

$$ o_i = \frac {e^{y_i}} {\sum_je^{y_j}} $$

用于多分类问题的激活函数
在零点不可微，负输入的梯度为零会产生“死亡神经元”

对于二分类问题，理论上使用sigmoid和softmax没有区别，因为数学表达式的形式是一样的。对于多分类非互斥问题（多标签分类）如人和女人，使用sigmoid更合适。对于多分类互斥问题（单标签分类），使用softmax更合适。

池化层（对特征图进行稀疏处理）

降低信息冗余，提升模型的尺度不变性、旋转不变性、防止过拟合。

MaxPooling（最大值池化）

全连接层（特征空间–>样本标记空间)

卷积层提取了各种特征，但很多物体可能拥有同一类特征，全连接层相当于组合了这些特征起到了分类器的功能。

损失函数

损失函数是用来衡量模型预测值$f(x)$与真实值$Y$的差异程度的运算函数，他是一个非负实数值函数，通常表示为$L(Y|f(x))$。

损失函数使用主要是在模型的训练阶段，每批训练数据送入模型后，通过前向传播输出预测值，然后损失函数会计算出预测值和真实值之间的差异值，也就是损失值。得到损失值之后，模型通过反向传播去更新各个参数，来降低真实值与预测值之间的损失，使模型越来越准确。

“反向传播过程” $$ \omega_{11} = \omega_{11} - \eta \frac{\partial \delta}{\partial \omega_{11}} $$ 通过链式求导法则和梯度下降，逐步修改权重参数$\omega$。其中 $\eta$ 为学习率，$\delta$为损失值。

基于距离度量的损失函数：

均方误差损失函数（MSE） $$ L(Y|f(x)) = \frac{1}{n} \sum_{i=1}^N(Y_i - f(x_i))^2 $$
L2损失函数(欧氏距离) $$ L(Y|f(x)) = \sqrt{\frac{1}{n} \sum_{i=1}^N (Y_i - f(x_i))^2} $$
L2损失函数(曼哈顿距离) $$ L(Y|f(x)) = \sum_{i=1}^N |Y_i - f(x_i)| $$
Smooth L1损失函数(主要用在目标检测中防止梯度爆炸) $$ L(Y|f(x)) = \begin{cases} \frac{1}{2}(Y-f(x))^2 \qquad \quad |Y-f(x)| < 1 \\\ |Y-f(x)|- \frac{1}{2} \qquad |Y-f(x)| \ge 1 \end{cases} $$
huber损失函数(平方损失+绝对损失) $$ L(Y|f(x)) = \begin{cases} \frac{1}{2}(Y-f(x))^2 \qquad \qquad |Y-f(x)| \le \delta \\\ \delta |Y-f(x)|- \frac{1}{2} \delta^2 \qquad |Y-f(x)| > \delta \end{cases} $$

基于概率分布度量的损失函数：(涉及概率分布或预测类别出现的概率的问题中应用广泛)

KL散度函数(相对熵) $$ L(Y|f(x)) = \sum_{i=1}^n Y_i \times log(\frac{Y_i}{f(x_i)}) $$
交叉熵损失 $$ L(Y|f(x)) = - \sum_{i=1}^n Y_i \times logf(x_i) $$ 交叉熵损失函数刻画了实际输出概率与期望输出概率之间的相似度，交叉熵的值越小，两个概率分布就越接近，特别是在正负样本不均衡的分类问题中，常用交叉熵作为损失函数。

目前，交叉熵损失函数是卷积神经网络中最常使用的分类损失函数，它可以有效避免梯度消散。在二分类情况下也叫做对数损失函数。
softmax损失函数 $$ L(Y|f(x)) = -\frac{1}{n} \sum_{i=1}^n Y_i \times log \frac{e^{f_{Y_i}}}{\sum_{j=1}^c e^{f_j}} $$
Focal loss $$ FE = \begin{cases} -\alpha(1-p)^\gamma log(p) \qquad \quad y = 1 \\\ -(1 - \alpha)p^\gamma log(1-p) \quad y = 0 \end{cases} $$

优化器

优化器就是在深度学习反向传播过程中，指引损失函数（目标函数）的各个参数往正确的方向更新合适的大小，使得更新后的各个参数让损失函数（目标函数）值不断逼近全局最小。

SGD优化器（随机梯度下降法，易受噪声影响，可能陷入局部最优解）

$$ \omega_{t+1} = \omega_t - \alpha \cdot g(\omega_t) $$

$\alpha$为学习率，$g(\omega_t)$ 为$t$ 时刻对参数$\omega_t$ 的损失梯度。

优点：

每次只用一个样本更新参数，训练速度快
随机梯度下降所带来的波动有利于优化的方向从当前的局部极小值点跳到另一个更好的局部极小值点，这样对于非凸函数，最终收敛于一个较好的局部极值点，甚至全局极值点。

缺点：

当遇到局部最优点或鞍点时，梯度为0，无法继续更新参数
沿陡峭方向震荡，而沿平缓维度进展缓慢，难以迅速收敛

SGD+Momentum优化器（引入动量，抑制样本噪声的干扰）

$$ v_t = \eta \cdot v_{t-1} + \alpha \cdot g(\omega_t) \\\ \omega_{t+1} = \omega_t - v_t $$

$\alpha$为学习率，$g(\omega_t)$ 为$t$ 时刻对参数$\omega_t$ 的损失梯度，$\eta(0.9)$ 为动量系数。

加入了动量因素，缓解了SGD在局部最优点无法持续更新的问题和震荡幅度过大的问题，但并没有完全解决，当局部沟壑比较深，动量加持用完了，依然会困在局部最优里来回振荡。

Adagrad优化器（自适应学习率，二阶动量）

$$ s_t = s_{t-1} + g(\omega_t) \cdot g(\omega_t) \\\ \omega_{t+1} = \omega_t - \frac{\alpha} {\sqrt{s_t + \varepsilon}} \cdot g(\omega_t) $$

$\alpha$为学习率，$g(\omega_t)$ 为$t$ 时刻对参数$\omega_t$ 的损失梯度，$\varepsilon(10^{-7})$ 为防止分母为零的小数。学习率下降过快容易未收敛就停止训练

RMSProp优化器（自适应学习率）

$$ s_t = \eta \cdot s_{t-1} + (1-\eta) \cdot g(\omega_t) \cdot g(\omega_t) \\\ \omega_{t+1} = \omega_t - \frac{\alpha} {\sqrt{s_t + \varepsilon}} \cdot g(\omega_t) $$

$\alpha$为学习率，$g(\omega_t)$ 为$t$ 时刻对参数$\omega_t$ 的损失梯度，$\eta(0.9)$ 控制衰减速度，$\varepsilon(10^{-7})$ 为防止分母为零的小数。

Adam优化器（自适应学习率）

$$ m_t = \beta_1 \cdot m_{t-1} + (1 - \beta_1) \cdot g(\omega_t) \qquad一阶动量 \\\ v_t = \beta_2 \cdot v_{t-1} + (1 - \beta_2) \cdot g(\omega_t) \cdot g(\omega_t) \quad二阶动量 \\\ \hat{m_t} = \frac{m_t}{1 - \beta^t_1} \quad \hat{\frac{v_t} {1 - \beta^t_2}} \\\ \omega_{t + 1} = \omega_t - \frac{\alpha} {\sqrt{\hat{v_t} + \varepsilon}} \hat{m_t} $$

$\alpha$为学习率，$g(\omega_t)$ 为$t$ 时刻对参数$\omega_t$ 的损失梯度，$\beta_1(0.9)$、$\beta_2(0.999)$ 控制衰减速度，$\varepsilon(10^{-7})$ 为防止分母为零的小数。

通过一阶动量和二阶动量，有效控制学习率和梯度方向，防止梯度的振荡和在鞍点的静止。
可能错过全局最优解。自适应学习率算法可能会对前期出现的特征过拟合，后期才出现的特征很难纠正前期的拟合效果。后期Adam的学习率太低，影响了有效的收敛。

评估指标–F1分数

二分类：

阳性样本的真实数量：$TP + FN$

阴性样本的真实数量：$FP + TN$

$Precision$ （精确率，又称查准率）（值越高表示误诊数越低）： $$ Precision = \frac {TP} {TP + FP} $$ $Recall$ （召回率，又称查全率）（值越高表示漏掉的病人越少）： $$ Recall = \frac {TP} {TP + FN} $$ $Accuracy$ （准确率）（正确的样本占样本总数的比例）： $$ Accuracy = \frac {TP + TN} {TP + FN + FP + TN} $$ $F1分数$ （综合考虑了精确率和召回率，认为他们同等重要）： $$ F1 = 2 \times \frac {Precision \times Recall} {Precision + Recall} $$ 多分类问题：

微观： $$ (查准率) \quad microP = \frac {TP_1 + TP_2} {TP_1 + FP_1 + TP_2 + FP_2} $$

$$ (查全率) \quad microR = \frac {TP_1 + TP_2} {TP_1 + FN_1 + TP_2 + FN_2} $$

$$ microF1 = 2 \times \frac {microP \times microR} {microP + microR} $$
宏观： $$ (查准率) \quad macroP = \frac {Precision1 + Precision2} {2} $$

$$ (查全率) \quad macroR = \frac {Recall1 + Recall2} {2} $$

$$ macroF1 = 2 \times \frac {macroP \times macroR} {macroP + macroR} $$
“评估指标的选择”

当类别的分布相似时，可以使用准确率，当类别的分布不平衡时，F1分数是更好的评估指标。

图像处理中的卷积神经网络

LeNet模型（1998）

由Yann Le Cun于1998年提出，奠定了卷积神经网络的基础，由两个卷积层、两个全连接层和一个输出层组成。激活函数采用softmax，池化层采用平均池化。该模型早期主要用于手写字符的识别和分类。

ALexNet模型（2012）

首次利用GPU进行网络加速训练
使用了ReLu激活函数，使用最大池化方法
使用了LRN局部相应归一化
在全连接层的前两层使用了Dropout随机失活神经元，减少过拟合

过拟合根本原因是特征维度过多，模型假设过于复杂，参数过多而训练数据过少，噪声多，导致拟合的函数完美的预测了训练集而对测试集预测结果差。

卷积计算公式：

$$ N = \frac {(W - F + 2P)} {S} + 1 $$

AlexNet 网络的具体实现

原图输入224x224 实际上进行了随机裁剪，实际大小为227x227

from keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, deserialize
from keras.models import Model

def ALexNet(input_shape=None, num_classes=100):
    img_input = Input(shape=input_shape)

    # Block 1
    # (227, 227, 3) --> (27, 27, 96)
    x = Conv2D(96, (11, 11), 
                    activation='relu',
                    padding='valid',
                    strides=(4, 4),
                    name='conv1')(img_input)
    # (55, 55, 96)
    x = MaxPooling2D((3, 3), strides=(2, 2), name='maxpool1')(x)

    # Block 2
    # (27, 27, 96) --> (13, 13, 256)
    x = Conv2D(256, (5, 5),
                    activation='relu',
                    padding='same',
                    strides=(1, 1),
                    name='conv2')(x)
    # (27, 27, 256)
    x = MaxPooling2D((3, 3), strides=(2, 2), name='maxpool2')(x)

    # Block 3
    # (13, 13, 256) --> (13, 13, 384)
    x = Conv2D(384, (3, 3),
                    activation='relu',
                    padding='same',
                    strides=(1, 1),
                    name='conv3')(x)

    # Block 4
    # (13, 13, 384) --> (13, 13, 384)
    x = Conv2D(384, (3, 3),
                    activation='relu',
                    padding='same',
                    strides=(1, 1),
                    name='conv4')(x)

    # Block 5
    # (13, 13, 384) --> (6, 6, 256)

    x = Conv2D(256, (3, 3),
                    activation='relu',
                    padding='same',
                    strides=(1, 1),
                    name='conv5')(x)
    # (13, 13, 256)
    x = MaxPooling2D((3, 3), strides=(2, 2), name='maxpool3')(x)

    # Block 6
    # (6, 6, 256) --> (1, 4096)
    x = Flatten(name='flatten')(x)
    x = Dense(num_classes, activation='softmax', name='predictions')(x)

    inputs = img_input
    model = Model(inputs, x, name='alexnet')
    return model

if __name__ == '__main__':
    model = ALexNet(input_shape=(227, 227, 3))
    model.summary()

GoogleNet模型（2014）

通过引入Inception模块来增加网络宽度
引入1x1的卷积层来压缩通道数量，降低计算量，从而进一步增加网络深度
添加两个softmax辅助分类器，缓解梯度消失现象

Inception就是把多个卷积或池化操作放在一起组装成一个网络模块。

VGGNet模型（2014）

使用多个3x3小尺寸卷积核和池化层构造深度卷积
在最后使用三层全连接层，用最后一层全连接层的输出作为分类的预测
成功证明了增加网络的深度，可以更好的学习图像中的特征模式

VGG16 网络的具体结构

from keras.models import Model
from keras.layers import Input,Activation,Dropout,Reshape,Conv2D,MaxPooling2D,Dense,Flatten

def VGG16(input_shape=None, classes=1000):
    img_input = Input(shape=input_shape)

    # Block 1
    # (224, 224, 3) --> (112, 112, 64)
    x = Conv2D(64, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block1_conv1')(img_input)
    x = Conv2D(64, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block1_conv2')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)

    # Block 2
    # (112, 112, 64) --> (56, 56, 128)
    x = Conv2D(128, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block2_conv1')(x)
    x = Conv2D(128, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block2_conv2')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)

    # Block 3
    # (56, 56, 128) --> (28, 28, 256)
    x = Conv2D(256, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block3_conv1')(x)
    x = Conv2D(256, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block3_conv2')(x)
    x = Conv2D(256, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block3_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)

    # Block 4
    # (28, 28, 256) --> (14, 14, 512)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block4_conv1')(x)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block4_conv2')(x)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block4_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)

    # Block 5
    # (14, 14, 512) --> (7, 7, 512)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block5_conv1')(x)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block5_conv2')(x)
    x = Conv2D(512, (3, 3),
                      activation='relu',
                      padding='same',
                      name='block5_conv3')(x)
    x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)

    # 对结果进行平铺
    x = Flatten(name='flatten')(x)

    # 两次神经元为4096的全连接层
    x = Dense(4096, activation='relu', name='fc1')(x)
    x = Dense(4096, activation='relu', name='fc2')(x)

    # 再全连接到1000维，用以分类任务
    x = Dense(classes, activation='softmax', name='predictions')(x)

    inputs = img_input

    model = Model(inputs, x, name='vgg16')
    return model

if __name__ == '__main__':
    model = VGG16(intput_shape=(224, 224, 3))
    model.summary()

SSD模型（2016）

SSD是基于一个前向传播反馈的CNN网络，属于one-stage类型。

对多尺度特征图进行检测
设置不同长宽比的先验框

基本的SSD模型是在VGG网络模型的基础上构建的，通过融合不同卷积层的特征图来增强网络对特征的表达能力，采用多尺度卷积检测的方法来进行目标检测其结构如图所示：

该模型基于VGG模型(改进版)来提取特征，将各级的卷积特征图作为该一级的特征表示，不同卷积级别的图像卷积特征描述了不同的语义，卷积层越深表达的图像特征信息级别越高。SSD模型中特征的提取采用的是逐层提取并抽象化的思想，低层的特征主要对应于占比较小的目标，高层的特征主要对应于占比较大的目标的抽象化的信息。 基本的SSD模型通过金字塔特征层进行特征提取，且各特征层之间相互独立，没有目标信息的相互补充，低特征层仅有Conv4_3层用于检测占比小的目标因而在缺乏充足的特征信息的情况下存在特征提取不充分的问题，因而导致对小型目标的识别效果一般。

SSD 网络的具体结构：

import keras.backend as K
import numpy as np
from keras.engine.topology import InputSpec, Layer
from keras.layers import (Activation, Concatenate, Conv2D, Flatten, Input, Reshape)
from keras.models import Model

from vgg import VGG16

class Normalize(Layer):
    def __init__(self, scale, **kwargs):
        self.axis = 3
        self.scale = scale
        super(Normalize, self).__init__(**kwargs)

    def build(self, input_shape):
        self.input_spec = [InputSpec(shape=input_shape)]
        shape = (input_shape[self.axis],)
        init_gamma = self.scale * np.ones(shape)
        self.gamma = K.variable(init_gamma, name='{}_gamma'.format(self.name))
        self.trainable_weights = [self.gamma]

    def call(self, x, mask=None):
        output = K.l2_normalize(x, self.axis)
        output *= self.gamma
        return output

def SSD300(input_shape, num_classes=21):

    # ------ 输入尺寸(300, 300, 3) ------ #
    input_tensor = Input(shape=input_shape)
    
    net = VGG16(input_tensor)
    
    # ------- 对主干网络提取到的有效特征进行处理 ------- #

    # 对conv4_3的通道进行l2标准化处理 
    # (38, 38, 512)
    net['conv4_3_norm'] = Normalize(20, name='conv4_3_norm')(net['conv4_3'])
    num_anchors = 4

    # 对预测框的处理
    # num_anchors表示每个网格点先验框的数量
    # 4 是x,y(框中心偏移),h,w(框的高和宽)的调整
    net['conv4_3_norm_mbox_loc']        = Conv2D(num_anchors * 4, kernel_size=(3,3), padding='same', name='conv4_3_norm_mbox_loc')(net['conv4_3_norm'])
    net['conv4_3_norm_mbox_loc_flat']   = Flatten(name='conv4_3_norm_mbox_loc_flat')(net['conv4_3_norm_mbox_loc'])
    # num_classes是所分的类
    net['conv4_3_norm_mbox_conf']       = Conv2D(num_anchors * num_classes, kernel_size=(3,3), padding='same',name='conv4_3_norm_mbox_conf')(net['conv4_3_norm'])
    net['conv4_3_norm_mbox_conf_flat']  = Flatten(name='conv4_3_norm_mbox_conf_flat')(net['conv4_3_norm_mbox_conf'])

    # 对fc7层进行处理
    # (19, 19, 1024)
    num_anchors = 6
    # 预测框的处理
    # 4 是x,y,h,w的调整
    net['fc7_mbox_loc']         = Conv2D(num_anchors * 4, kernel_size=(3,3),padding='same',name='fc7_mbox_loc')(net['fc7'])
    net['fc7_mbox_loc_flat']    = Flatten(name='fc7_mbox_loc_flat')(net['fc7_mbox_loc'])
    # num_classes是所分的类
    net['fc7_mbox_conf']        = Conv2D(num_anchors * num_classes, kernel_size=(3,3),padding='same',name='fc7_mbox_conf')(net['fc7'])
    net['fc7_mbox_conf_flat']   = Flatten(name='fc7_mbox_conf_flat')(net['fc7_mbox_conf'])

    # 对conv6_2进行处理
    # (10, 10, 512)
    num_anchors = 6
    # 预测框的处理
    # 4 是x,y,h,w的调整
    net['conv6_2_mbox_loc']         = Conv2D(num_anchors * 4, kernel_size=(3,3), padding='same',name='conv6_2_mbox_loc')(net['conv6_2'])
    net['conv6_2_mbox_loc_flat']    = Flatten(name='conv6_2_mbox_loc_flat')(net['conv6_2_mbox_loc'])
    # num_classes是所分的类
    net['conv6_2_mbox_conf']        = Conv2D(num_anchors * num_classes, kernel_size=(3,3), padding='same',name='conv6_2_mbox_conf')(net['conv6_2'])
    net['conv6_2_mbox_conf_flat']   = Flatten(name='conv6_2_mbox_conf_flat')(net['conv6_2_mbox_conf'])

    # 对conv7_2进行处理
    # (5, 5, 256)
    num_anchors = 6
    # 预测框的处理
    # 4 是x,y,h,w的调整
    net['conv7_2_mbox_loc']         = Conv2D(num_anchors * 4, kernel_size=(3,3), padding='same',name='conv7_2_mbox_loc')(net['conv7_2'])
    net['conv7_2_mbox_loc_flat']    = Flatten(name='conv7_2_mbox_loc_flat')(net['conv7_2_mbox_loc'])
    # num_classes是所分的类
    net['conv7_2_mbox_conf']        = Conv2D(num_anchors * num_classes, kernel_size=(3,3), padding='same',name='conv7_2_mbox_conf')(net['conv7_2'])
    net['conv7_2_mbox_conf_flat']   = Flatten(name='conv7_2_mbox_conf_flat')(net['conv7_2_mbox_conf'])

    # 对conv8_2进行处理
    # (3, 3, 256)
    num_anchors = 4
    # 预测框的处理
    # 4是x,y,h,w的调整
    net['conv8_2_mbox_loc']         = Conv2D(num_anchors * 4, kernel_size=(3,3), padding='same',name='conv8_2_mbox_loc')(net['conv8_2'])
    net['conv8_2_mbox_loc_flat']    = Flatten(name='conv8_2_mbox_loc_flat')(net['conv8_2_mbox_loc'])
    # num_classes是所分的类
    net['conv8_2_mbox_conf']        = Conv2D(num_anchors * num_classes, kernel_size=(3,3), padding='same',name='conv8_2_mbox_conf')(net['conv8_2'])
    net['conv8_2_mbox_conf_flat']   = Flatten(name='conv8_2_mbox_conf_flat')(net['conv8_2_mbox_conf'])

    # 对conv9_2进行处理
    # (1, 1, 256)
    num_anchors = 4
    # 预测框的处理
    # 4是x,y,h,w的调整
    net['conv9_2_mbox_loc']         = Conv2D(num_anchors * 4, kernel_size=(3,3), padding='same',name='conv9_2_mbox_loc')(net['conv9_2'])
    net['conv9_2_mbox_loc_flat']    = Flatten(name='conv9_2_mbox_loc_flat')(net['conv9_2_mbox_loc'])
    # num_classes是所分的类
    net['conv9_2_mbox_conf']        = Conv2D(num_anchors * num_classes, kernel_size=(3,3), padding='same',name='conv9_2_mbox_conf')(net['conv9_2'])
    net['conv9_2_mbox_conf_flat']   = Flatten(name='conv9_2_mbox_conf_flat')(net['conv9_2_mbox_conf'])
    
    # ------- 将所有结果进行堆叠 ------- #
    net['mbox_loc'] = Concatenate(axis=1, name='mbox_loc')([net['conv4_3_norm_mbox_loc_flat'],
                                                            net['fc7_mbox_loc_flat'],
                                                            net['conv6_2_mbox_loc_flat'],
                                                            net['conv7_2_mbox_loc_flat'],
                                                            net['conv8_2_mbox_loc_flat'],
                                                            net['conv9_2_mbox_loc_flat']])
                                    
    net['mbox_conf'] = Concatenate(axis=1, name='mbox_conf')([net['conv4_3_norm_mbox_conf_flat'],
                                                            net['fc7_mbox_conf_flat'],
                                                            net['conv6_2_mbox_conf_flat'],
                                                            net['conv7_2_mbox_conf_flat'],
                                                            net['conv8_2_mbox_conf_flat'],
                                                            net['conv9_2_mbox_conf_flat']])
    # (8732, 4)
    net['mbox_loc']     = Reshape((-1, 4), name='mbox_loc_final')(net['mbox_loc'])
    # (8732, 21)
    net['mbox_conf']    = Reshape((-1, num_classes), name='mbox_conf_logits')(net['mbox_conf'])
    net['mbox_conf']    = Activation('softmax', name='mbox_conf_final')(net['mbox_conf'])
    # (8732, 25)
    net['predictions']  = Concatenate(axis =-1, name='predictions')([net['mbox_loc'], net['mbox_conf']])

    model = Model(net['input'], net['predictions'])
    return model

总结而言，SSD是把一张图片划分为不同的网格，当某一物体的中心点落在这个区域，这个物体就由这个网格来确定。

MobileNet（2017）

MobileNetV1

Deptwise Convolution(深度可分离卷积)(大大减少运算量和参数数量)

标准的卷积网络结构：

深度可分离卷积网络结构：

当输入特征图的 shape 是$D_F \times D_F \times M$，其中 $M$ 为通道数，输出特征图的 shape 为$D_G \times D_G \times N$，通道数为 $N$ ，标准卷积核的尺寸为$D_k \times D_k \times M$时，卷积核的参与个数为 $D_k \cdot D_k \cdot M \cdot N$ 。深度可分离卷积一共分为两个步骤的卷积，其中 Depthwise Convolution 的卷积核为$D_k \times D_k \times 1$， Pointwise Convolution 的卷积核为$1 \times 1 \times M$。那么可以得出如下结论：

标准卷积的运算量： $$ D_k \cdot D_k \cdot M \cdot N \cdot D_F \cdot D_F = D_F \cdot D_F \cdot M \cdot (D^2_K \cdot N) $$ 深度可分离卷积的运算量： $$ D_k \cdot D_k \cdot M \cdot D_F \cdot D_F + M \cdot N \cdot D_F \cdot D_F = D_F \cdot D_F \cdot M \cdot (D^2_K + N) $$ 运算量对比： $$ \frac {D_F \cdot D_F \cdot M \cdot (D^2_K + N)} {D_F \cdot D_F \cdot M \cdot (D^2_k \cdot N)} = \frac {1} {N} + \frac {1} {D^2_K} $$

深度可分离卷积的tensorflow代码实现：

from keras import layers
from keras import backend

"""
DepthwiseConv2D的原函数定义:
tf.keras.layers.DepthwiseConv2D(
    kernel_size,
    strides=(1, 1),
    padding="valid",
    depth_multiplier=1,
    data_format=None,
    dilation_rate=(1, 1),   # 膨胀率
    activation=None,
    use_bias=True,  # 是否使用偏置向量
    depthwise_initializer="glorot_uniform",
    bias_initializer="zeros",   # 偏置向量的初始值
    depthwise_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    depthwise_constraint=None,
    bias_constraint=None,
    **kwargs
)
"""

def _depthwise_conv_block(
        inputs,
        pointwise_conv_filters,
        alpha,
        depth_multiplier=1,
        strides=(1, 1),
        block_id=1):

    """通道的处理channel"""
    channel_axis = 1 if backend.image_data_format() == "channels_first" else -1
    """alpha超参数"""
    pointwise_conv_filters = int(pointwise_conv_filters * alpha)

    """步长的处理padding"""
    if strides == (1, 1):
        x = inputs
    else:
        x = layers.ZeroPadding2D(((0, 1), (0, 1)), name="conv_pad_%d" % block_id)(inputs)

    """逐通道卷积"""
    x = layers.DepthwiseConv2D(
            (3, 3),
            padding="same" if strides == (1, 1) else "valid",
            depth_multiplier=depth_multiplier,
            strides=strides,
            use_bias=False,
            name="conv_dw_%d" % block_id
            )(x)
    x = layers.BatchNormalization(axis=channel_axis, name="conv_dw_%d_bn" % block_id)(x)
    x = layers.ReLU(6.0, name="conv_dw_%d_relu" % block_id)(x)

    """逐点卷积"""
    x = layers.Conv2D(
            pointwise_conv_filters,
            (1, 1),
            padding="same",
            use_bias=False,
            strides=(1, 1),
            name="conv_pw_%d" % block_id
            )(x)
    """Batch Normalization是2015年一篇论文中提出的数据归一化方法，往往用在深度神经网络中激活层之前。
    其作用可以加快模型训练时的收敛速度，使得模型训练过程更加稳定，避免梯度爆炸或者梯度消失。并且起到一定的正则化作用，几乎代替了Dropout。"""
    x = layers.BatchNormalization(axis=channel_axis, name="conv_pw_%d_bn" % block_id)(x)

    return layers.ReLU(6.0, name="conv_pw_%d_relu" % block_id)(x)

“Conv2D 和 Depthwise_conv2D的区别”

Conv2d在每个通道上卷积，然后求和，Depthwise_conv2D卷积，不求和。
Depthwise_conv2D的输出维度和输入维度始终是一致的。

	标准卷积	深度可分离卷积
运算特点	每个卷积核的通道与输入通道相同，每个通道单独做卷积运算然后相加	DW卷积：一个卷积核只有一个通道，单独负责一个通道 PW卷积：将上一步的特征图在通道方向上进行扩展

超参数 $\alpha$ $\rho$

$\alpha$ 宽度系数，对网络中每一层卷积的通道数乘以 $\alpha$ 取值范围[0,1]，比较典型的值为1、0.75、0.5、0.35

$$ 计算量: \qquad D_k \cdot D_k \cdot \alpha M \cdot D_F \cdot D_F + \alpha M \cdot \alpha N \cdot D_F \cdot D_F $$

$\rho$ 分辨率系数，只改变网络的计算量而不影响网络的参数量

$$ 计算量: \qquad D_k \cdot D_k \cdot \alpha M \cdot \rho D_F \cdot \rho D_F + \alpha M \cdot \alpha N \cdot \rho D_F \cdot \rho D_F $$

DepthWise部分的卷积核容易废掉，即卷积核参数大部分为零。（很重要的一个原因是因为 ReLU 激活函数对0值的梯度是0，后续无论怎么迭代这个节点都不会恢复，即“废掉了”）

“你知道吗？”

深度可分离卷积将一个标准卷积分割成了两个卷积（逐深度，逐点），因此减小了参数量，对应也减小了总计算量。 深度可分离卷积总计算量变小了，但是深度可分离卷积的层数变多了。

GPU是并行处理大规模数据(矩阵内积)运算的平台，而CPU则更倾向于对数据串行计算。

因此影响GPU总运算时间的主导因素一般是网络的层数。

而影响CPU总运算时间的主导因素是总计算量。

所以才会出现MobileNet在某些计算能力有限的CPU平台上速度竟然高于某些GPU平台上的速度。

MobileNet的tensorflow代码实现：

from keras import backend
from keras import layers
from keras.models import Model
from keras.applications import imagenet_utils
from keras.applications.efficientnet import block

def MobileNet(input_shape, alpha=1.0, depth_multiplier=1, dropout=None, classes=1000):

    img_input = layers.Input(shape=input_shape)
    # (224, 224, 3)
    x = _conv_block(img_input, 32, alpha, strides=(2, 2))
    # (112, 112, 32)
    x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1)
    # (112, 112, 64)
    x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, strides=(2, 2), block_id=2)
    # (56, 56, 64)
    x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, block_id=3)
    # (56, 56 ,128)
    x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, strides=(2, 2), block_id=4)
    # (28, 28, 256)
    x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=5)
    # (28, 28, 256)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, strides=(2, 2), block_id=6)
    # (14, 14, 512)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=7)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=8)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=9)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=10)
    x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=11)

    # (14, 14, 512)
    x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, strides=(2, 2), block_id=12)
    # (7, 7, 1024)
    x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, block_id=13)

    # (7, 7, 1024)
    x = layers.GlobalAveragePooling2D(keepdims=True)(x)
    x = layers.Dropout(dropout, name="drpout")(x)
    x = layers.Conv2D(classes, (1, 1), padding="same", name="conv_preds")(x)
    x = layers.Reshape((classes,), name="reshape_2")(x)
    x = layers.Activation(activation="softmax", name="predictions")(x)

    model = Model(img_input, x, name="mobilenet")
    return model

def _conv_block(inputs, filters, alpha, kernel=(3, 3), strides=(1, 1)):
    filters = int(filters * alpha)
    x = layers.Conv2D(
            filters,
            kernel,
            padding="same",
            use_bias=False,
            strides=strides,
            name="conv1"
        )(inputs)
    x = layers.BatchNormalization(name="conv1_bn")(x)
    return layers.ReLU(6.0, name="conv1_relu")(x)

def _depthwise_conv_block(
        inputs,
        pointwise_conv_filters,
        alpha,
        depth_multiplier=1,
        strides=(1, 1),
        block_id=1):

    """通道的处理channel"""
    channel_axis = 1 if backend.image_data_format() == "channels_first" else -1
    """alpha超参数"""
    pointwise_conv_filters = int(pointwise_conv_filters * alpha)

    """步长的处理padding"""
    if strides == (1, 1):
        x = inputs
    else:
        x = layers.ZeroPadding2D(((0, 1), (0, 1)), name="conv_pad_%d" % block_id)(inputs)

    """逐通道卷积（处理长宽方向的信息）"""
    x = layers.DepthwiseConv2D(
            (3, 3),
            padding="same" if strides == (1, 1) else "valid",
            depth_multiplier=depth_multiplier,
            strides=strides,
            use_bias=False,
            name="conv_dw_%d" % block_id
            )(x)
    x = layers.BatchNormalization(axis=channel_axis, name="conv_dw_%d_bn" % block_id)(x)
    x = layers.ReLU(6.0, name="conv_dw_%d_relu" % block_id)(x)

    """逐点卷积（处理跨通道方向的信息）"""
    x = layers.Conv2D(
            pointwise_conv_filters,
            (1, 1),
            padding="same",
            use_bias=False,
            strides=(1, 1),
            name="conv_pw_%d" % block_id
            )(x)
    x = layers.BatchNormalization(axis=channel_axis, name="conv_pw_%d_bn" % block_id)(x)

    return layers.ReLU(6.0, name="conv_pw_%d_relu" % block_id)(x)

if __name__ == '__main__':
    model = MobileNet(input_shape=(224, 224, 3))
    model.summary()

MobileNet v2

Inverted Residuals(倒残差结构)

倒残差结构是从ResNet中的残差结构而来的。ResNet中Residuals结构中，先用1x1的卷积实现了降维，然后通过3x3卷积，最后通过1x1卷积实现升维，即两头大中间小。

而在MobileNetV2中，先用1x1的卷积升维，然后将3x3卷积换为3x3DW卷积，再用1x1的卷积实现降维，即两头小中间大。

MobileNetV2的倒残差结构示意图：

stateDiagram Direction LR [*] --> Conv1x1,ReLU6 :升维 Conv1x1,ReLU6 --> Dwise3x3,ReLU6 Dwise3x3,ReLU6 --> conv1x1,Linear conv1x1,Linear --> Add :降维，线性激活 [*] --> Add :残差连接 Add --> [*]

ReLU6激活函数: $$ y = ReLU6(x) = min(max(x, 0), 6) $$

Linear Bottlenecks(线性瓶颈层)

作者发现当信息从高维空间经过非线性映射到低维空间时，会发生信息坍塌，所以在倒残差结构进行降维操作的时候，使用了线性激活函数（实现方式就是不使用激活函数）。

“思考”

之所以使用倒残差结构，和线性瓶颈层，是因为作者通过数学证明的方式，得出了在降维过度时，ReLU会造成大量的信息丢失，即升维之后更容易保持可逆

MobileNetV2的tensorflow实现：

from keras import backend
from keras import layers
from keras.models import Model
from keras.applications import imagenet_utils

def MobileNetV2(input_shape=None, alpha=1.0, classes=1000):

    img_input = layers.Input(shape=input_shape)

    channel_axis = 1 if backend.image_data_format() == "channels_first" else -1

    first_block_filters = _make_divisible(32 * alpha, 8)

    # 输入(224, 224, 3)
    x = layers.Conv2D(
        first_block_filters,
        kernel_size=3,
        strides=(2, 2),
        padding="same",
        use_bias=False,
        name="Conv1",
    )(img_input)
    x = layers.BatchNormalization(
        axis=channel_axis, epsilon=1e-3, momentum=0.999, name="bn_Conv1"
    )(x)
    x = layers.ReLU(6.0, name="Conv1_relu")(x)

    # (112, 112, 32)
    x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1, expansion=1, block_id=0)

    # (112, 112, 16)
    x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2, expansion=6, block_id=1)
    x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1, expansion=6, block_id=2)

    # (56, 56, 24)
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2, expansion=6, block_id=3)
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=4)
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=5)

    # (28, 28, 32)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=2, expansion=6, block_id=6)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=7)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=8)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=9)

    # (14, 14, 64)
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=10)
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=11)
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=12)

    # (14, 14, 96)
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=2, expansion=6, block_id=13)
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=14)
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=15)

    # (7, 7, 160)
    x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, expansion=6, block_id=16)

    # 宽度因子α
    if alpha > 1.0:
        last_block_filters = _make_divisible(1280 * alpha, 8)
    else:
        last_block_filters = 1280

    # (7, 7, 320)
    x = layers.Conv2D(
        last_block_filters, kernel_size=1, use_bias=False, name="Conv_1"
    )(x)
    x = layers.BatchNormalization(
        axis=channel_axis, epsilon=1e-3, momentum=0.999, name="Conv_1_bn"
    )(x)
    x = layers.ReLU(6.0, name="out_relu")(x)

    # (7, 7, 1280)
    x = layers.GlobalAveragePooling2D()(x)
    imagenet_utils.validate_activation("softmax", "imagenet")
    x = layers.Dense(
            classes, activation="softmax", name="predictions"
    )(x)
    # 预测层(1, 1, classes)

    # 返回模型实例
    return Model(img_input, x, name=f"mobilenetv2")


def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id):
    """倒残差结构"""
    channel_axis = 1 if backend.image_data_format() == "channels_first" else -1

    in_channels = backend.int_shape(inputs)[channel_axis] # 返回张量或变量的shape，作为int或者None条目的元组
    pointwise_conv_filters = int(filters * alpha)
    # 确保最后一个1x1卷积上的滤波器个数可以被8整除
    pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
    x = inputs
    prefix = f"block_{block_id}_"

    if block_id:
        # 点卷积升维
        x = layers.Conv2D(
            expansion * in_channels,
            kernel_size=1,
            padding="same",
            use_bias=False,
            activation=None,
            name=prefix + "expand",
        )(x)
        x = layers.BatchNormalization(
            axis=channel_axis,
            epsilon=1e-3,
            momentum=0.999,
            name=prefix + "expand_BN",
        )(x)
        x = layers.ReLU(6.0, name=prefix + "expand_relu")(x)
    else:
        prefix = "expanded_conv_"

    # Dw卷积
    if stride == 2:
        x = layers.ZeroPadding2D(
            padding=imagenet_utils.correct_pad(x, 3), name=prefix + "pad"
        )(x)
    x = layers.DepthwiseConv2D(
        kernel_size=3,
        strides=stride,
        activation=None,
        use_bias=False,
        padding="same" if stride == 1 else "valid",
        name=prefix + "depthwise",
    )(x)
    x = layers.BatchNormalization(
        axis=channel_axis,
        epsilon=1e-3,
        momentum=0.999,
        name=prefix + "depthwise_BN",
    )(x)

    x = layers.ReLU(6.0, name=prefix + "depthwise_relu")(x)

    # 点卷积降维，线性激活函数（即None）
    x = layers.Conv2D(
        pointwise_filters,
        kernel_size=1,
        padding="same",
        use_bias=False,
        activation=None,
        name=prefix + "project",
    )(x)
    x = layers.BatchNormalization(
        axis=channel_axis,
        epsilon=1e-3,
        momentum=0.999,
        name=prefix + "project_BN",
    )(x)

    if in_channels == pointwise_filters and stride == 1:
        return layers.Add(name=prefix + "add")([inputs, x])
    return x


def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    # 确保向下舍入不会下降超过10%
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

if __name__ == '__main__':
    model = MobileNetV2(input_shape=(224, 224, 3))
    model.summary()

待续未完。。。

传统机器视觉基础

Sat, 06 May 2023 03:20:13 +0800

传统机器视觉基础

传统计算机视觉

FAST特征点检测算法

FAST只是一种特征点检测算法，并不涉及特征点的特征描述。

FAST的提出者Rosten等将 FAST角点 定义为：若某像素与其周围邻域内足够多的像素点相差较大，则该像素可能是角点。
算法流程
1. 以像素$p$为中心，半径为3的圆上，有16个像素点
2. 定义一个阈值，计算$p1$、$p5$、$p9$、$p13$与中心$p$的像素差，若它们的绝对值至少有三个超过阈值，则当作候选角点，否则不可能是角点
3. 若$p$是候选点，则计算$p1$到$p16$这16个点与中心$p$点的像素差，若它们至少有连续9个超过阈值，则为角点，否则不可能是角点
4. 对图像进行非极大值抑制（nms）：判断以特征点$p$为中心的一个邻域（如3x3或5x5）内，计算若有多个特征点，则判断每个特征点的$s$值（16个点与中心差值的绝对值总和），若$p$是邻域所有特征点中响应值最大的，则保留；否则，抑制。若邻域内只有一个特征点（角点），则保留。得分计算公式如下（公式中用$V$表示得分，$t$表示阈值）：
$$ V = max \begin{cases} \sum{pixel values - p}, & \text{if (value - p) > t} \\\ \sum{p - pixel values}, & \text{if (p- value) > t} \end{cases} $$

BRIEF特征点描述算法

BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度直方图描述特征点的传统方法，大大的加快了特征描述符建立的速度，同时也极大的降低了特征匹配的时间，是一种非常快速，很有潜力的算法。 由于BRIEF仅仅是特征描述子，所以事先要得到特征点的位置
算法流程
1. 为减少噪声干扰，需对图像先进行滤波（如高斯滤波）
2. 以特征点为中心，取$S \times S$的邻域窗口。在窗口内随机选取一对（两个）点，比较二者像素的大小，进行如下二进制赋值。 $$ \iota(p;x,y):=\begin{cases} 1,& \text{$if p(x)<p(y)$ } \\\ 0,& \text{$otherwise$} \end{cases} $$ 其中，$p(x)$，$p(y)$分别是随机点$x=(u1,v1)$, $y=(u2,v2)$的像素值。
3. 在窗口中随机选取$N$对随机点，重复步骤2的二进制赋值，形成一个二进制编码，这个编码就是对特征点的描述，即特征描述子。（一般$N=256$）
利用BPIEF特征进行配准

经过特征点提取，对于一幅图中的每一个特征点，都得到了一个256bit的二进制编码。接下来对有相似或重叠部分的两幅图像进行配准。
- 特征配对是利用汉明距离进行判决的：
  1. 两个特征编码对应bit位上相同元素的个数小于128的，一定不是配对的。
  2. 一幅图上特征点与另一幅图上特征编码对应bit位上相同元素的个数最多的特征点配成一对。

ORB算法（快速特征点提取和描述算法）

ORB算法分为两部分，分别是特征点提取和特征点描述。特征提取是由FAST算法（前面已经学过）发展来的，特征点描述是根据BRIEF特征描述算法改进的。

算法流程

ORB对FAST的改进或者拓展，主要是为其增加了其尺度不变性以及旋转不变性。接下里来看一看怎么实现的。

关键点提取
1. 通过FAST算法提取特征点
2. 建立金字塔设置一个比例因子$scale$（opencv默认取1.2）和金字塔层数$n$（通常取8），将原图像按比例因子缩小为$n$幅图像（ $I’ = I/scale^k$ ） $k=1、2、3 \dots n$幅不同比例的图像提取特征点总和作为原图的FAST特征点
3. 定义特征点方向
  
  ORB的论文中提出了一种利用灰度质心法来解决这个问题，通过计算一个矩来计算特征点以$r$为半径范围内的质心，特征点坐标到质心形成一个向量作为该特征点的方向。我们来看看具体怎么实现灰度质心法。一个图像块（比如5x5的图像块），对应2x2的矩的元素表达为：
$$ m_{pq} = \sum_{x,y} \ x^p y^q I(x,y) $$
- $x,y$ 分别为坐标值，$I(x,y)$为像素值而该图像的窗口质心为：
$$ C = (\frac{m_{10}}{m_{00}},\frac{m_{01}}{m_{00}}) $$

那么特征点与质心的夹角定义为FAST特征点的方向：

$$ \theta = arctan(m_{01},m_{10}) $$

有了特征点的方向，继而实现旋转不变性。
关键点描述

ORB选择了BRIEF作为特征描述方法，并对其进行改进使其加上旋转不变性并增加其可区分性。

BRIEF描述子

BRIEF算法计算出来的是一个二进制串的特征描述符。 它是在每一个特征点的邻域内，选择n对像素点$8pi、qi（i=1,2,…,n）$。然后比较每个点对的灰度值的大小。如果$I(pi)> I(qi)$，则生成二进制串中的1，否则为0。所有的点对都进行比较，则生成长度为$n$的二进制串。一般$n$取128、256或512，通常取256。 为了增强抗噪性，一般会先对图像进行高斯平滑。ORB算子采用5x5的子窗口进行平滑。

$n$个点对的选取方法
1. 在点周围选取点对$（p,q）$的方法
2. $p$和$q$都符合$(0,S2/25)$的高斯分布；
  1. $p$符合$(0,S2/25)$的高斯分布，而$q$符合$(0,S2/100)$的高斯分布；
3. 在空间量化极坐标下的离散位置随机采样；
4. 把$p$固定为$(0,0)$，$q$在周围平均采样。
BRIEF算法改进

增加其旋转不变性，选点方式改进
- steered BRIEF增加其旋转不变性
  
  所谓steered BRIEF就是对挑选出的点对加上一个旋转角度$θ$。对于任何一个特征点来说，它的BRIEF描述子是一个长度为𝑛的二值码串，这个二值码串是由特征点邻域𝑛个点对生成的，我们现在讲这2𝑛个点(𝑥𝑖,𝑦𝑖),𝑖=1,2,…..,2𝑛组成一个矩阵𝑆: $$ S = \left[ \begin{matrix} x_1 & x_2 & … & x_{2n}\\\ y_1 & y_2 & … & y_{2n} \end{matrix} \right] $$
  
  使用邻域方向$\theta$和对应的旋转矩阵$R_\theta$，构建$S$的一个校正版本$S_\theta$： $$ S_\theta = R_\theta S $$ 其中
  
  $$ R_\theta = \left[ \begin{matrix} \cos\theta & sin\theta \\\ -sin\theta & cos\theta \end{matrix} \right] $$
  - steered BRIEF加入了旋转不变性，但同时特征描述量的可区分行就下降了,所以就有了ORB作者提出的rBRIEF
  - rBRIEF增加其可区分性 ORB使用统计学习的方法来重新选择点对集合，目的是增大其特征描述量的可区分行。

OpenCV大致思路：

一个就是将提取的角点信息进行格式化，输出为numpy数组：

## 提取图像ORB特征并转化为numpy数组
def extraORBfromImg(ORB, img):
keypoints, desc = ORB.detectAndCompute(img, mask=None) # 关键点检测
## 特征点信息
axis = np.array([kp.pt for kp in keypoints]) # 特征点图像坐标
scale = np.array([kp.octave+1 for kp in keypoints])# 特征点尺度(在哪一层金字塔)
direct = np.array([kp.angle*np.pi/180 for kp in keypoints]) # 特征点方向(弧度)
## 拼接
infos = np.array([scale,direct]).T
cors_info = np.hstack([axis,infos])
return cors_info, desc

另一个就是进行图像间的角点匹配函数：

## ORB特征BRIEF描述子匹配
def ORBMatch(BF, desc1, desc2):
matches = BF.match(desc1, desc2)
dist = np.array([mc.distance for mc in matches])
idx1 = np.array([mc.trainIdx for mc in matches])
idx0 = np.array([mc.queryIdx for mc in matches])
idx = np.array([idx0,idx1]).T
## 匹配点筛选，当描述子之间的距离大于两倍的最小距离时，认为匹配有误
min_dist = min(dist)
filte_idx = np.where(dist <= max(2 * min_dist, 30))[0]
return dist[filte_idx], idx[filte_idx,:]

由于ORBMatch函数返回的是所有点的匹配距离和匹配索引，因此必要时我们还需要一个函数计算匹配点对的坐标：

## 获取图像对匹配点的坐标(一对)
def findMatchCord(match_idx, cors1, cors2):
left = cors1[match_idx[:,0], :2]
right = cors2[match_idx[:,1], :2]
return np.hstack([left, right])

结果示例：

NMS算法（非极大值抑制）

目标检测过程中在同一目标的位置上会产生大量的候选框，这些候选框相互之间可能会有重叠，此时我们需要利用非极大值抑制找到最佳的目标边界框，消除冗余的边界框。

流程一般如下：

前提：目标边界框列表及其对应的置信度得分列表，设定阈值，阈值用来删除重叠较大的边界框。

IOU ：intersection-over-union，即两个边界框的交集部分除以它们的并集。
1. 根据置信度得分进行排序
2. 选择置信度最高的边界框添加到最终的传输列表中，将其从边界框列表中删除
3. 计算所有边界框的面积
4. 计算置信度最高的边界框与其他候选框的loU
5. 删除loU大于阈值的边界框
6. 重复上述过程，直至边界框列表为空

RANSAC算法()

随机抽样一致算法 ，采用迭代的方式从一组包含离群的被观测数据中估算出数学模型的参数，RANSAC算法假设数据中包含正确数据和异常数据（或者噪声）。正确数据记为内点（inliers），异常数据记为外点（outliers）。同时RANSAC也假设，给定一组正确的数据，存在可以计算出符合这些数据的模型参数的方法。该算法核心思想就是随机性和假设性， 随机性 是根据正确数据出现概率去随机选取抽样数据，根据大数定律，随机性模拟可以近似得到正确结果。 假设性 是假设选取出的抽样数据都是正确数据，然后用这些正确数据通过问题满足的模型，去计算其他点，然后对这次结果进行一个评分。

RANSAC的基本就假设是：
1. 数据由“局内点”组成，例如：数据的分布可以用一些模型来解释;
2. “局外点”是不能是适应模型的数据;
3. 除此之外的数据属于噪声。
RANSAC也做出了以下假设：给定一组（通常很小的）局内点，存在一个可以估计模型参数的过程；而该模型能够解释或者适用于局内点。

算法流程：

选择出可以估计出模型的最小数据集；(对于直线拟合来说就是两个点，对于计算Homography矩阵就是4个点)
使用这个数据集来计算出数据模型；
将所有数据带入这个模型，计算出“内点”的数目；(累加在一定误差范围内的适合当前迭代推出模型的数据)
比较当前模型和之前推出的最好的模型的“内点“的数量，记录最大“内点”数的模型参数和“内点”数；
重复1-4步，直到迭代结束或者当前模型已经足够好了(“内点数目大于一定数量”)。

RANSAC算法的输入是一组观测数据，一个可以解释或者适应于观测数据的参数化模型，一些可信的参数。

输入

	data	// 一组观测数据
	model	// 适应于数据的模型
	n	// 适应于模型的最少数据个数，如果是直线的话，n=2
	k	// 算法的迭代次数
	t	// 用于决定数据是否应用于模型的阈值
	d	// 判定模型是否适用于数据集的数据个数，人为设定

输出

1
2
3

best_model	 // 跟数据最匹配的模型参数（如果没有好的模型，返回null）
best_consensus_set	 // 估计出模型的数据点
best_error	 // 跟数据相关的估计出的模型错误

Kmeans算法

聚类与KMeans

聚类是在事先并不知道任何样本标签的情况下，通过数据之间的内在关系把样本划分为若干类别，使得同类别样本之间的相似度高，不同类别之间的样本相似度低（即增大类内聚，减少类间距）。

K均值聚类是最基础常用的聚类算法。它的基本思想是：通过迭代寻找K个簇（Cluster）的一种划分方案，使得聚类结果对应的损失函数最小。其中，损失函数可以定义为各个样本距离所属簇中心点的误差平方和： $$ J(c, \mu) = \sum _{i=1} ^{M} \parallel x_i - \mu _{c_i} \parallel ^2 $$

其中 $x_i$ 代表第 $i$ 个样本，$c_i$ 是 $x_i$ 所属的簇，$\mu_{c_i}$ 代表簇对应的中心点，$M$是样本总数

算法流程

KMeans的核心目标是将给定的数据集划分成K个簇（K是超参），并给出每个样本数据对应的中心点。具体步骤非常简单，可以分为4步：
1. 数据预处理。主要是标准化、异常点过滤。
2. 随机选取K个中心，记为 $\mu_1^{(0)}$ , $\mu_2^{(0)}$ ,……, $\mu_k^{(0)}$
3. 定义损失函数:
$$ J(c, \mu) = \sum _{i=1} ^{M} \parallel x_i -\mu _{c_i} \parallel ^2 $$
1. 令 t = 0, 1, 2,……为迭代步数，重复如下过程直到 $J$ 收敛:
  1. 对于每一个样本 $x_i$ ,将其分配到距离最近的中心 $$ c_i^t < - argmin_k \parallel x_i - \mu_k^t \parallel ^2 $$

对于每一个类中心k，重新计算该类的中心

$$ \mu_k^{t+1} < -argmin_{\mu} \sum _{i:c_i^t = k} ^b \parallel x_i - \mu \parallel ^2 $$

KMeans最核心的部分就是先固定中心点，调整每个样本所属的类别来减少 $J$ ；再固定每个样本的类别，调整中心点继续减小$J$ 。两个过程交替循环， $J$ 单调递减直到最（极）小值，中心点和样本划分的类别同时收敛。

KMeans 迭代示意图：

KMeans算法步骤：
1. 随机初始化k个点作为簇质心；
2. 将样本集中的每个点分配到一个簇中；计算每个点与质心之间的距离（常用欧式距离和余弦距离），并将其分配给距离最近的质心所对应的簇中；
3. 更新簇的质心。每个簇的质心更新为该簇所有点的平均值；
4. 反复迭代2 - 3 步骤，直到达到某个终止条件；（a. 达到指定的迭代次数；b. 簇心不再发生明显的变化，即收敛；c. 最小误差平方和SSE；）
SSE(Sum of Square Error, 误差平方和)，SSE值越小表示数据点越接近于它们的质心，聚类效果也越好。

$$ SSE = \sum_{i = 1} ^ k \sum_{x\in C_i} (x-\mu_i) ^2 $$

$$ \mu_i = \frac{1}{|C_i|} \sum_{x\in{C_i}} x $$

算法过程：

点 $x = (x_1,x_2,……,x_n)$ 和点 $y = (y_1,y_2,……,y_n)$ 之间的欧氏距离为：

$$ d(x,y) = \sqrt{(x_1-y_1)^2 + (x_2-y_2)^2 +……+ (x_n-y_n)^2} $$

两个向量 A 和 B，其余弦距离（即两向量夹角的余弦）由点积和向量长度给出，计算公式如下：

$$ cos\theta = \frac{A * B}{|A|*|B|} = \frac{\sum_{i=1}^n A_i B_i} {\sqrt{\sum_{i=1}^n (A_i)^2} \sqrt{\sum_{i=1}^n (B_i)^2}} $$

$$ dist(A,B) = 1 - cos(A,B) = \frac{|A| _2 |B|_2 - A * B}{|A| |B|} $$

式子中， $A_i$ 和 $B_i$ 分别代表向量A和B的各分量。

算法优缺点

优点：容易实现

缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢

适用数据类型：数值型数据

机器视觉 on 好冷の小窝

Tensorflow入门

Gentoo Linux 系统下 Tenosorflow-gpu 的安装

安装 nvidia 驱动

安装cuda

安装Anaconda

安装Tensorflow

Tensorflow Object Detection API 安装

视觉导航综述

视觉导航

室内导航

基于深度视觉感知的SLAM导航

室外导航

相关技术与设备

视觉感知单元

单目摄像头

双目摄像头

姿态感知单元

惯性导航系统

多源融合视觉处理

视觉+惯性融合

视觉+无线电融合

多源融合

多传感器融合层次（级别）

多传感器融合体系结构

Pytorch入门

引言

安装相关

卷积层

激活层

池化层

全连接层

损失函数

L1Loss && MSELoss

CrossEntropyLoss

一个简单的例子（Cifar-10分类任务）

Pytorch 各种模型的格式

目标检测数据集

VOC数据集

COCO数据集

神经网络视觉基础

神经网络视觉基础

基础知识

神经网络的基本原理

卷积层（局部感知、权值共享）–（图像特征提取）

卷积操作

激活层 (通过函数把特征保留并映射到输出端)

激活函数

池化层（对特征图进行稀疏处理）

全连接层（特征空间–>样本标记空间)

损失函数

优化器

评估指标–F1分数

图像处理中的卷积神经网络

LeNet模型（1998）

ALexNet模型（2012）

GoogleNet模型（2014）

VGGNet模型（2014）

SSD模型（2016）

MobileNet（2017）

MobileNetV1

MobileNet v2

传统机器视觉基础

传统机器视觉基础

传统计算机视觉

FAST特征点检测算法

BRIEF特征点描述算法

ORB算法（快速特征点提取和描述算法）

NMS算法（非极大值抑制）

RANSAC算法()

Kmeans算法