numpy函数小节

import numpy as np
np.cumsum
np.tile
np.expand_dims
np.stack
np.argmax

**

np.cumsum函数原型：累加

**

np.cumsum(a, axis=None, dtype=None, out=None)

axis=0，沿着axis=0轴累加，即按行累加。
axis=1，沿着axis=1轴累加，按照列累加。
axis不给定具体值，就把numpy数组当成一个一维数组。
例子：

a = np.array([[1,2,3], [4,5,6]])
b = np.cumsum(a)
b = [ 1,  3,  6, 10, 15, 21]

b = np.cumsum(a,axis=0)
b = array([[1, 2, 3],
       [5, 7, 9]])    
 [1, 2, 3]------>     |1     |2     |3    |
 [4, 5, 6]------>     |5=1+4 |7=2+5 |9=3+6|  

b = np.cumsum(a,axis=1) 
b = array([[ 1,  3,  6],
               [ 4,  9, 15]])
[1, 2, 3]------>     |1     |2+1    |3+2+1|   
[4, 5, 6]------>     |4     |4+5    |4+5+6| 

np.tile原型：按照指定的reshape进行复制

np.tile(A,reshape)

A的类型众多，几乎所有类型都可以：array, list, tuple, dict, matrix以及基本数据类型int, string, float以及bool类型。
reshape的类型也很多，可以是tuple，list, dict, array, int, bool.但不可以是float, string, matrix类型

np.expand_dims：扩展数组的维数

原型：

np.expand_dims(a, axis)

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

np.expand_dims(a, axis=0)表示在0位置添加数据，结果如下：

b = np.expand_dims(a, axis=0)
b = array([[[[1, 2, 3],
         [4, 5, 6]]]])
b.shape
(1, 1, 2, 3)

np.expand_dims(a, axis=1)表示在1位置添加数据,转换结果如下：

In [15]:
c = np.expand_dims(a, axis=1)
c = array([[[[1, 2, 3],
         [4, 5, 6]]]])
c.shape
(1, 1, 2, 3)

np.expand_dims(a, axis=2)表示在2位置添加数据,转换结果如下：

In [17]:
d = np.expand_dims(a, axis=2)
d = array([[[[1, 2, 3]],
        [[4, 5, 6]]]])
d.shape
(1, 2, 1, 3)

np.expand_dims(a, axis=3)表示在3位置添加数据,转换结果如下：

In [19]:
e = np.expand_dims(a, axis=3)
e.shape
(1, 2, 3, 1)

能在(1,2,3)中插入的位置总共为4个，再添加就会出现以下的警告，要不然也会在后面某一处提示AxisError。

np.stack:按照指定轴堆叠数组，要求被堆叠的数组形状维度必须相等

np.stack(arrays, axis=0, out=None)

a = np.arange(1, 10).reshape((3, 3))
b = np.arange(11, 20).reshape((3, 3))
c = np.arange(101, 110).reshape((3, 3))

np.stack((a,b,c),axis=0)
# axis=0可以认为只是将原数组上下堆叠，增加了0维的个数
array([[[  1,   2,   3],
        [  4,   5,   6],
        [  7,   8,   9]],

       [[ 11,  12,  13],
        [ 14,  15,  16],
        [ 17,  18,  19]],

       [[101, 102, 103],
        [104, 105, 106],
        [107, 108, 109]]])


np.stack((a,b,c),axis=1)
#axis=1，可以看出第一个3*3的数组是由是a,b,c中每个数组的第一行堆叠而成
array([[[  1,   2,   3],
        [ 11,  12,  13],
        [101, 102, 103]],

       [[  4,   5,   6],
        [ 14,  15,  16],
        [104, 105, 106]],

       [[  7,   8,   9],
        [ 17,  18,  19],
        [107, 108, 109]]])

np.stack((a,b,c),axis=2)
#axis=2，可以看到第一个3*3的数组是由a,b,c中的第一列向量组合而成
array([[[  1,  11, 101],
        [  2,  12, 102],
        [  3,  13, 103]],

       [[  4,  14, 104],
        [  5,  15, 105],
        [  6,  16, 106]],

       [[  7,  17, 107],
        [  8,  18, 108],
        [  9,  19, 109]]])

np.argmax:返回沿轴axis最大值的索引

numpy.argmax(a, axis=None, out=None)

a = np.array([[1, 6, 5, 2],
              [9, 6, 2, 9],
              [3, 7, 9, 1]])
print(np.argmax(a, axis=0))
[1,2,2,1]

计算两个数据样本的二维直方图

1。一维直方图
numpy.histogram(a, bins=10, range=None, normed=False, weights=None, density=None)[source]
计算一组数据的直方图。

参数：	
	a：array_like
	
	输入数据。在扁平数组上计算直方图。
	
	bins：int或标量序列或str，可选
	
	如果bins是一个int，它定义了在给定范围（默认为10）中等宽单元格的数量。如果bin是序列，则它定义了块边缘，包括最右边缘，允许非均匀的块宽度。
	
	版本1.11.0中的新功能。
	
	如果bins是以下列表中的字符串，则histogram将使用所选方法来计算最佳bin宽度，因此计算bin数（参见t4>关于估计器的更多细节）从落入请求范围内的数据。尽管区间宽度对于该范围中的实际数据将是最佳的，但是将计算区间的数目以填充整个范围，包括空白部分。为了可视化，建议使用'auto'选项。不支持自动bin大小选择的加权数据。
	
	'汽车'
	最大的“sturges”和“fd”估计。提供良好的全方位性能
	
	'fd'（Freedman Diaconis Estimator）
	鲁棒（弹性到异常值）估计器，考虑数据变异性和数据大小。
	
	'doane'
	Sturges估计器的改进版本，与非正态数据集更好地工作。
	
	'scott'
	较不鲁棒的估计器，其考虑到数据变异性和数据大小。
	
	'白饭'
	估计器不考虑变化性，只考虑数据大小。通常高估需要的箱数。
	
	'sturges'
	R的默认方法，只考虑数据大小。只对高斯数据最优，低估了大型非高斯数据集的二进制数。
	
	'sqrt'
	平方根（数据大小）估计器，由Excel和其他程序使用它的速度和简单性。
	
	范围：（float，float），可选
	
	仓的下限和上限。如果不提供，范围只是（a.min()， a.max()）。忽略范围之外的值。范围的第一个元素必须小于或等于第二个元素。范围也会影响自动bin计算。虽然基于范围内的实际数据计算bin宽度是最优的，但是bin计数将填充整个范围，包括不包含数据的部分。
	
	normed：bool，可选
	
	此关键字在Numpy 1.6中已被弃用，原因是混乱/错误行为。它将在Numpy 2.0中删除。请改用density关键字。如果False，结果将包含每个bin中的样本数。如果True，则结果是在bin处的概率密度函数的值，被归一化，使得在该范围上的积分是1。注意，后一种行为被认为是具有不相等的bin宽度的bug；请改用density。
	
	权重：array_like，可选
	
	一个权重数组，形状与a相同。a中的每个值仅将其关联的权重贡献给bin计数（而不是1）。如果density为True，则权重被归一化，使得该范围上的密度的积分保持为1。
	
	密度：bool，可选
	
	如果False，结果将包含每个bin中的样本数。如果True，则结果是在bin处的概率密度函数的值，被归一化，使得在该范围上的积分是1。注意，直方图值的总和不会等于1，除非选择单位宽度的二进制位；它不是概率质量函数。
	
	覆盖normed关键字（如果给定）。
	
	返回：	
	hist：数组
	
	直方图的值。有关可能的语义的描述，请参见密度和权重。
	
	bin_edges：dtype float的数组
	
	返回bin边(length(hist)+1)。
2.二维直方图
np.histogram2d(x, y, bins=10, range=None, normed=False, weights=None)

参数：	
	x：array_like，shape（N，）
	
	包含要被直方图化的点的x坐标的数组。
	
	y：array_like，shape（N，）
	
	包含要被直方图化的点的y坐标的数组。
	
	bins：int或array_like或[int，int]或[数组，数组]，可选
	
	bin规范：
	
	如果int，两个维度的仓的数量（nx = ny = bin）。
	如果array_like，二维的二进制边（x_edges = y_edges = bins）。
	如果[int，int]，每个维度中的块数（nx，ny = bin）。
	如果[数组，数组]，每个维度中的bin边（x_edges，y_edges = bins）。
	组合[int，数组]或[数组，int]，其中int是二进制数的数字，数组是二进制边。
	范围：array_like，shape（2,2），可选
	
	沿着每个维度的仓的最左边缘和最右边缘（如果未在bin参数中明确指定）：[[xmin， xmax] / t3> [ymin， ymax]]。超出此范围的所有值将被视为离群值，而不在直方图中计算。
	
	normed：bool，可选
	
	如果为False，则返回每个bin中的样本数。如果为True，则返回bin密度bin_count / sample_count / bin_area 。
	
	权限：array_like，shape（N，），可选
	
	对每个样本（x_i， y_i）加权的数组w_i。如果normed为True，则权重被归一化为1。如果normed为False，则返回的直方图的值等于属于落入每个仓中的样本的权重的和。
	
	返回：	
	H：ndarray，shape（nx，ny）
	
	样本的二维直方图x和y。x中的值沿第一个维度进行直方图，y中的值沿第二个维度进行直方图。
	
	xedges：ndarray，shape（nx，）
	
	仓沿第一维的边。
	
	yedges：ndarray，shape（ny）
	
	bin沿着第二维度。
3.多维直方图
numpy.histogramdd(sample, bins=10, range=None, normed=False, weights=None)[source]
计算一些数据的多维直方图。

参数：	
	sample：array_like
	
	要进行直方图处理的数据。它必须是（N，D）数组或可以转换为这样的数据。结果数组的行是D维多面体中的点的坐标。
	
	bin：sequence或int，可选
	
	bin规范：
	
	描述沿着每个维度的块边缘的数组序列。
	每个维度的块数（nx，ny，... = bin）
	所有维度的箱数（nx = ny = ... =箱柜）。
	范围：sequence，可选
	
	如果在bin中未明确给出边，则使用下边框和上边框边缘的序列。默认为每个维度的最小值和最大值。
	
	normed：bool，可选
	
	如果为False，则返回每个bin中的样本数。如果为True，返回bin密度bin_count / sample_count / bin_volume 。
	
	权重：（N，）array_like，可选
	
	对每个样本（x_i，y_i，z_i，...）进行加权的值w_i的数组。如果normed为True，则权重归一化为1。如果normed为False，则返回的直方图的值等于属于落入每个仓中的样本的权重的和。
	
	返回：	
	H：ndarray
	
	样本x的多维直方图。请参阅不同可能语义的规范和权重。
	
	edges：list
	
	描述每个维度的块边缘的D数组的列表。

把heatmap翻一转：imshow的origin和extent
实例
以下代码我们可以直接从np.histogram2d()来看，相当于输入两个(5,5)的数组，然后返回他们的二维直方图。结果为包含3个array的tuple，我们通常看第一个array，后两个array为细分的刻度情况，数组中最大值为2，都分三个刻度，就如后两个数组所示。
第一个数组对角线处表示两个输入对应位置相同的个数，例如两个输入对应位置都为0的个数为17，两个输入对应位置都为1的个数为2。而对角线上下两侧则表示两个输入的相同值不在同一位置的个数，例如1在两个输入中，有一个不在同一位置，有两个在同一位置。同理可以验证一下2。
11100 00000 00000 02220 00000
11000 00000 00000 00000 22000

from skimage.morphology import label
import numpy as np
x = np.zeros((5,5))
y = np.zeros((5,5))
x[0,0] = 1
x[0,1] = 1
x[0,2] = 1
x[3,2] = 1
x[3,3] = 1
x[3,1] = 1
y[0,0] = 1
y[0,1] = 1
y[4,0] = 1
y[4,1] = 1
labels = label(x)
y_pred = label(y)
print(labels,'\n',y_pred)
true_objects = len(np.unique(labels))
pred_objects = len(np.unique(y_pred))
print(true_objects,pred_objects)
intersection = np.histogram2d(labels.flatten(), y_pred.flatten(), bins=(true_objects, pred_objects))
print(intersection)
output:
[[1 1 1 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 2 2 2 0]
 [0 0 0 0 0]] 
 [[1 1 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [2 2 0 0 0]]
3 3
(array([[17.,  0.,  2.],
       [ 1.,  2.,  0.],
       [ 3.,  0.,  0.]]), array([0.        , 0.66666667, 1.33333333, 2.        ]), array([0.        , 0.66666667, 1.33333333, 2.        ]))

python中np.multiply（）、np.dot（）和星号（*）三种乘法运算的区别

tensor.chunk()按维度等分
tensor.cat()按维度拼接，不增加维度
torch.stack()堆叠，增加一个维度
split()按维度拆分