numpy 常用api（一）

Inside_Zhang發表於2015-11-27
API

numpy 常用api（二）

numpy 常用api（三）

clip

兩個版本：

  • np.clip

  • 作為成員函式，x.clip

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

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

  1. 法1，布林索引

    >>> x<0
array([ True,  True,  True,  True,  True, False, False, False, False, False], dtype=bool)
>>> x[x<0] = 0
>>> x
array([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的第一個參數列示目標區間最小值，第二個參數列示最大值，原始序列凡小於這個最小值的被這個最小值所替換，凡大於這個最大值的被這個最大值替換，必須指定一個引數，則另一個引數預設為∞

\infty
。如果使用位置引數（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
>>> x
array([  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))
>>> y
array([[ 1.],
       [ 1.],
       [ 1.]])
>>> y.shape
(3, 1)

# 下述的運算對x=x.reshape((1, 3))也是成立的。
# (1, 3)op(3, 1)還是(3, 1)op(1, 3)最運算的結果都是以笛卡爾積的形式排列
>>> x+y
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.],
       [ 2.,  2.,  2.]])
>>> y+x
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.],
       [ 2.,  2.,  2.]])  
>>> x==y
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]], dtype=bool)

再來看這樣一種情況：

>>> w = np.ones(3)
>>> w.shape
(3,)
>>> X = np.ones((5, 3))
>>> X
array([[ 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*w
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])    # 逐行再element-wise相乘

如果這時：

>>> w = w.reshape((3, 1))
>>> w
array([[ 1.],
       [ 1.],
       [ 1.]])
>>> np.dot(X, w) 
array([[ 3.],
       [ 3.],
       [ 3.],
       [ 3.],
       [ 3.]])           # 標準的矩陣乘法
>>> X*w
ValueError: operands could not be broadcast together with shapes (5,3) (3,1)

np.nan_to_num

>>> x = np.nan
>>> x
nan
>>> math.isnan(x)
True
>>> np.isnan(x)
True

>>> np.nan_to_num(x)
0.0

>>> x = np.inf
>>> x
inf
>>> 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)

y\times \ln(a)+(1-y)\times \ln(1-a)
），以及變數會隨著程式的執行其值會發生一些變化，這種情況下就很難避免了nan的出現了。而我們有知道

>>> np.nan + 10
nan

對nan進行運算最終的結果仍是nan，故我們需要對這樣的情況進行轉換，這時就需要np.nan_to_num進行轉換，避免干擾。

我們引入交叉熵（cross-entropy）作為代價函式，也即：

C=−∑jyjlnaLj+(1−yj)ln(1−aLj)
C=-\sum_jy_j\ln{a_j^L}+(1-y_j)\ln (1-a_j^L)

列項求和相加，第一個反應是使用更為便捷的內積運算，也即：
C=−(y⋅lnaL+(1−y)⋅ln(1−aL))
C=-(y\cdot \ln{a^L}+(1-y)\cdot\ln(1-a^L))

使用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\times \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表示在列的方向進行累積相加。

相關文章