2022-11-03人工智能42

一、数组的组合

参数：

a1, a2, ...：sequence of array_like，除了将被对应的轴之外，数组必须是相同的形状；
axis：int, optional，将被组合的轴，默认为0，如果为None，将被展开为一维数组；
out：ndarray, optional，如果给定，将存放结果，尺寸必须匹配；
dtype：str or dtype，给定输出的数据类型，不能和参数 out 一起出现；
casting：{'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional，控制可能发生的数据转换类型。默认为 'same_kind'；

结果：

res：组合后的数组；


>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> print(a, b)
[[1 2]
 [3 4]] [[5 6]]

>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>>  np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])

参数：

arrays：sequence of array_like，数组必须是相同的形状；
axis：int, optional，数组组合的轴；
out：ndarray, optional，如果给定，将存放结果，尺寸必须匹配；

结果：

stacked：ndarray，使用新轴连接数组；

>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)
>>> np.stack(arrays, axis=1).shape
(3, 10, 4)

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
        [4, 5, 6]])
>>> np.stack((a, b), axis=1)
array([[1, 4],
        [2, 5],
        [3, 6]])
>>> np.stack((a, b), axis=-1)
array([[1, 4],
        [2, 5],
        [3, 6]])

参数：

tup：sequence of 1-D or 2-D arrays，数组不信有相同尺寸的第一维；

结果：

stacked：2-D array，将给定的数组按列连接为二维数组；

>>> a = np.array([(1,2,3),(1,2,3)])
>>> b = np.array((3,4))
>>> np.column_stack((a,b))
array([[1, 2, 3, 3],
       [1, 2, 3, 4]])

参数：

tup：sequence of arrays，数组除第三维外，形状相同；

结果：

stacked：ndarray，将给定的数组连接为三维数组；

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],
        [2, 3],
        [3, 4]]])

参数：

tup：sequence of arrays，数组除第二维外，形状相同；

结果：

stacked：ndarray，水平（按列）顺序堆叠数组，将给定的数组连接的数组；

>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
       [2, 5],
       [3, 6]])

参数：

tup：sequence of arrays，数组除第一维外，形状相同；

结果：

stacked：ndarray，垂直（行）顺序堆叠数组，将给定的数组连接的数组；

>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([[1, 2, 3],
       [4, 5, 6]])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

参数：

arrays：nested list of array_like or scalars，如果传递了单个ndarray或scalar（深度为0的嵌套列表），则返回时不会修改（也不会复制），元素形状必须沿适当的轴匹配（无需广播），但将根据需要在形状前面加上前导1，以使尺寸匹配；

结果：

block_array：ndarray，块组装的数组；


>>> A = np.eye(2) * 2
>>> B = np.eye(3) * 3
>>> np.block([
        [A,               np.zeros((2, 3))],
        [np.ones((3, 2)), B               ]
    ])
array([[2., 0., 0., 0., 0.],
       [0., 2., 0., 0., 0.],
       [1., 1., 3., 0., 0.],
       [1., 1., 0., 3., 0.],
       [1., 1., 0., 0., 3.]])

二、数组的拆分

参数：

ary：ndarray，被划分的数组；
indices_or_sections：int or 1-D array，如果是 int，将被划分为N个对应维度等长的数组，如果是 1-D array，表示数组的拆分位置；
axis：int, optional，拆分的维度，默认0；

返回：

sub-arrays：list of ndarrays，数组 ary 的子数组视图的列表；

>>> x = np.arange(20.0).reshape(10, 2)
>>> np.split(x, 5)
[array([[0., 1.],
        [2., 3.]]),
 array([[4., 5.],
        [6., 7.]]),
 array([[ 8.,  9.],
        [10., 11.]]),
 array([[12., 13.],
        [14., 15.]]),
 array([[16., 17.],
        [18., 19.]])]

>>> np.split(x, [2, 5, 7])
[array([[0., 1.],
        [2., 3.]]),
 array([[4., 5.],
        [6., 7.],
        [8., 9.]]),
 array([[10., 11.],
        [12., 13.]]),
 array([[14., 15.],
        [16., 17.],
        [18., 19.]])]

几乎等同于 numpy.split。

Original: https://blog.csdn.net/weixin_43276033/article/details/123836581
Author: 峡谷的小鱼
Title: NumPy 数组的组合和拆分操作

Title: 睿智的目标检测61——Tensorflow2 Focal loss详解与在YoloV4当中的实现

睿智的目标检测60——Tensorflow2 Focal loss详解与在YoloV4当中的实现

学习前言
什么是Focal Loss
*
一、控制正负样本的权重
二、控制容易分类和难分类样本的权重
三、两种权重控制方法合并
实现方式

学习前言

TF2的也补上咯。其实和Keras的一摸一样0 0。
NumPy 数组的组合和拆分操作

; 什么是Focal Loss

Focal Loss是一种Loss计算方案。其具有两个重要的特点。

1、 控制正负样本的权重
2、 控制容易分类和难分类样本的权重

正负样本的概念如下：
目标检测本质上是进行密集采样，在一张图像生成成千上万的先验框（或者特征点），将真实框与部分先验框匹配，匹配上的先验框就是正样本，没有匹配上的就是负样本。

容易分类和难分类样本的概念如下：
假设存在一个二分类问题，样本1和样本2均为类别1。网络的预测结果中，样本1属于类别1的概率=0.9，样本2属于类别1的概率=0.6，前者预测的比较准确，是容易分类的样本；后者预测的不够准确，是难分类的样本。

如何实现权重控制呢，请往下看：

一、控制正负样本的权重

如下是常用的交叉熵loss，以二分类为例：
NumPy 数组的组合和拆分操作
我们可以利用如下Pt简化交叉熵loss。

此时：

想要降低负样本的影响，可以在常规的损失函数前增加一个系数αt。与Pt类似：
当label=1的时候，αt=α；
当label=otherwise的时候，αt=1 - α。
a的范围是0到1。此时我们便可以通过设置α实现控制正负样本对loss的贡献。 NumPy 数组的组合和拆分操作
分解开就是：

; 二、控制容易分类和难分类样本的权重

样本属于某个类，且预测结果中该类的概率越大，其越容易分类 ，在二分类问题中，正样本的标签为1，负样本的标签为0，p代表样本为1类的概率。

对于正样本而言，1-p的值越大，样本越难分类。
对于负样本而言，p的值越大，样本越难分类。

Pt的定义如下：
NumPy 数组的组合和拆分操作
所以利用1-Pt就可以计算出每个样本属于容易分类或者难分类。

具体实现方式如下。
NumPy 数组的组合和拆分操作
其中：
( 1 − p t ) γ (1-p_{t})^{γ}(1 −p t )γ
就是每个样本的容易区分程度，γ γγ称为调制系数

1、当pt趋于0的时候，调制系数趋于1，对于总的loss的贡献很大。当pt趋于1的时候，调制系数趋于0，也就是对于总的loss的贡献很小。
2、当γ=0的时候，focal loss就是传统的交叉熵损失，可以通过调整γ实现调制系数的改变。

三、两种权重控制方法合并

通过如下公式就可以实现 控制正负样本的权重和 控制容易分类和难分类样本的权重。
NumPy 数组的组合和拆分操作

; 实现方式

本文以Keras版本的YoloV4为例，给大家进行解析，YoloV4的坐标如下：
https://github.com/bubbliiiing/yolov4-tf2

首先定位YoloV4中， 正负样本区分的损失部分，YoloV4的损失由三部分组成，分别为：
location_loss（回归损失）
confidence_loss（目标置信度损失）
class_loss（种类损失）
正负样本区分的损失部分是confidence_loss（目标置信度损失），因此我们在这一部分添加Focal Loss。

首先定位公式中的概率p。raw_pred代表每个特征点的预测结果，取出其中属于置信度的部分，取sigmoid，就是概率p

tf.sigmoid(raw_pred[...,4:5])

首先进行正负样本的平衡，设立参数alpha。

alpha
1-alpha

然后进行难易分类样本的平衡，设立参数gamma。

(tf.ones_like(raw_pred[...,4:5]) - tf.sigmoid(raw_pred[...,4:5])) ** gamma
tf.sigmoid(raw_pred[...,4:5]) ** gamma

乘上原来的交叉熵损失即可。

confidence_loss = object_mask * (tf.ones_like(raw_pred[...,4:5]) - tf.sigmoid(raw_pred[...,4:5])) ** gamma * alpha * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) + \
            (1 - object_mask) * ignore_mask * tf.sigmoid(raw_pred[...,4:5]) ** gamma * (1 - alpha) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)