numpy 常用api（一）

numpy 常用api（二）

numpy 常用api（三）

clip

两个版本：

• np.clip

• 作为成员函数，x.clip

将一序列（sequence）中所有小于零的元素置零：

>>> x = np.arange(-5, 5)>>> xarray([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])       

1. 法1，布尔索引

   >>> x<0array([ True,  True,  True,  True,  True, False, False, False, False, False], dtype=bool)>>> x[x<0] = 0>>> xarray([0, 0, 0, 0, 0, 0, 1, 2, 3, 4])

2. 法2：np.where（三目运算），不对原始序列进行修改

   >>> x = np.where(x<0, 0, x)array([0, 0, 0, 0, 0, 0, 1, 2, 3, 4])

3. 法3：使用clip，不对原始序列进行修改

clip的第一个参数表示目标区间最小值，第二个参数表示最大值，原始序列凡小于这个最小值的被这个最小值所替换，凡大于这个最大值的被这个最大值替换，必须指定一个参数，则另一个参数默认为∞。如果使用位置参数（positional argument），第一个位置表示最小值，第二个位置表示最大值，x.clip(0, 5)或者x.clip(0)。那么如何使用一个参数表示最大值呢？这时可以用named argument，即x.clip(max=5)

>>> x.clip(0)array([0, 0, 0, 0, 0, 0, 1, 2, 3, 4])

我们看到，如果将所有小于零的元素置为nan，clip是无能为力的，这时只能使用布尔矩阵，或者np.where函数了：

>>> x = np.array([1., 2., -3., 4, -5.])>>> x[x<0] = np.nan>>> xarray([  1.,   2.,  nan,   4.,  nan])

>>> np.where(x<0, np.nan, x)array([  1.,   2.,  nan,   4.,  nan])

ndarray

>>> x = np.ones(3)>>> x array([1., 1., 1.])>>> x.shape(3,)            # 一个元素的元组>>> y = np.ones((3, 1))>>> yarray([[ 1.],       [ 1.],       [ 1.]])>>> y.shape(3, 1)# 下述的运算对x=x.reshape((1, 3))也是成立的。# (1, 3)op(3, 1)还是(3, 1)op(1, 3)最运算的结果都是以笛卡尔积的形式排列>>> x+yarray([[ 2.,  2.,  2.],       [ 2.,  2.,  2.],       [ 2.,  2.,  2.]])>>> y+xarray([[ 2.,  2.,  2.],       [ 2.,  2.,  2.],       [ 2.,  2.,  2.]])  >>> x==yarray([[ True,  True,  True],       [ True,  True,  True],       [ True,  True,  True]], dtype=bool)         

再来看这样一种情况：

>>> w = np.ones(3)>>> w.shape(3,)>>> X = np.ones((5, 3))>>> Xarray([[ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.]])>>> np.dot(X, w)array([ 3.,  3.,  3.,  3.,  3.])>>> np.dot(X, w).shape(5, )>>>> X*warray([[ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.],       [ 1.,  1.,  1.]])    # 逐行再element-wise相乘    

如果这时：

>>> w = w.reshape((3, 1))>>> warray([[ 1.],       [ 1.],       [ 1.]])>>> np.dot(X, w) array([[ 3.],       [ 3.],       [ 3.],       [ 3.],       [ 3.]])           # 标准的矩阵乘法>>> X*wValueError: operands could not be broadcast together with shapes (5,3) (3,1)     

np.nan_to_num

>>> x = np.nan>>> xnan>>> math.isnan(x)True>>> np.isnan(x)True>>> np.nan_to_num(x)0.0>>> x = np.inf>>> xinf>>> np.isinf(x)True>>> np.nan_to_num(x)1.7976931348623157e+308

场景

>>> np.log(0)-inf>>> 0*(-np.inf)nan>>> 0*np.log(0)nan>>> np.nan_to_num(0*np.log(0))0.0

0*np.log(0)直接这样的情况我们尚可避免，但如果通过变量的形式进行计算（比如y×ln(a)+(1−y)×ln(1−a)），以及变量会随着程序的运行其值会发生一些变化，这种情况下就很难避免了nan的出现了。而我们有知道

>>> np.nan + 10nan 

对nan进行运算最终的结果仍是nan，故我们需要对这样的情况进行转换，这时就需要np.nan_to_num进行转换，避免干扰。

我们引入交叉熵（cross-entropy）作为代价函数，也即：

C=−∑jyjlnaLj+(1−yj)ln(1−aLj)

列项求和相加，第一个反应是使用更为便捷的内积运算，也即：

C=−(y⋅lnaL+(1−y)⋅ln(1−aL))

使用python语言实现：

def fn(a, y):           # a, y都是列向量    return -(np.dot(y.transpose(), np.log(a))+np.dot((1-y), np.log(1-a)))

问题出现在，执行内积运算，对应位相乘有可能出现0×log(0)=nan的情况，在进行相加时会破坏整个内积运算的结果。

>>> 0*np.nan_to_num(np.log(0))0.0

我们或者：

def fn(a, y):    return -(np.dot(y.transpose(), np.nan_to_num(np.log(a)))+np.dot((1-y).transpose(), np.nan_to_num(np.log(1-a))))

或者：

def fn(a, y):    return -np.sum(np.nan_to_num(y*np.log(a)+(1-y)*np.log(1-a)))

np.cumsum()

np.cumsum(a)函数返回一个多维数组，其shape等于a的shape

p = np.random.random(100000)rolls = np.random.random((11, len(p)))Alice_wins = np.cumsum(rolls < p, 0)                                # 0，表示列向Bob_wins = np.cumsum(rolls >= p, 0)                                # 0，表示列向

首先需要说明的是，np.array() < 0，返回的是bool元素类型的多维数组。也即上述代码中的rolls < p，也即np.cumsum()的第一个参数为多维元组类型。np.cumsum(rolls < p, 0)，第二个参数0表示在列的方向进行累积相加。