深度学习入门 （3）激活函数+线性代数

须知：使用jupyter notebook食用

阶跃函数

def step_function(x):
    if x > 0:
        return 1
    else:
        return 0

转换成支持Numpy数组的实现

import numpy as np
def step_function_2(x):
    y = x>0
    return y.astype(np.int8)
x = np.array([1.0,-1.0,2.0])
y = x>0
y

y = y.astype(np.int8)
y 

阶跃函数的图形

import numpy as np
import matplotlib.pyplot as plt
x = np.arange(-3,3,0.1)
y = step_function_2(x)
plt.xlabel('x')
plt.ylabel('y')
plt.ylim(-0.1,1.1)
plt.title('Step function')
plt.plot(x,y)
plt.show()

sigmoid 函数的实现

def sigmoid(x):
    return 1/(1+np.exp(-x))
x = np.arange(-10,10,0.1)
y1 = sigmoid(x)
y2 = step_function_2(x)
plt.plot(x,y1,label='sigmoid')
plt.plot(x,y2,'--',label='step function')
plt.legend()
plt.show()

x = np.array([1.0,-1.0,2.0])
y = sigmoid(x)
y

ReLU函数

def ReLU(x):
    return np.maximum(0,x)

x = np.arange(-3,3,0.1)
y = ReLU(x)
plt.plot(x,y)
plt.xlabel('x')
plt.ylabel('y')
plt.show()

多维数组

import numpy as np
A = np.array([[1,2,3],[4,5,6]])
print(A)
print(np.ndim(A))
print(A.shape)
print(A.shape[0])

矩阵相乘

A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
# np.dot(A,B)
print(np.dot(A,B))
# np.dot(B,A)
print(np.dot(B,A))

C = np.array([[1,2,3],[4,5,6]])
np.dot(A,C)

以下通过pytorch实现线性代数的剩余部分

通过指定两个分量 m 和 n 来创建一个 mxn 的矩阵

A = torch.arange(20).reshape(5,4)
A

矩阵转置

A.T

对称矩阵 A等于其转置 A = A.T

B = torch.tensor([[1,2,3],[2,0,4],[3,4,5]])
B

B == B.T

就像向量是标量的推广，矩阵是向量的推广，我们可以构建具有更多轴的数据结构

X = torch.arange(24).reshape(2,3,4)
X

A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone()
A , A + B

两个矩阵按元素乘法称为 哈达玛积

A * B

计算其元素的和

x = torch.arange(4, dtype=torch.float32)
x ,  x.sum()

表示任意形状张量的元素和

A = torch.arange(20*2,dtype=torch.float32).reshape(2,5,4)
A.shape, A.sum()

一个与求和相关的量是平均值（mean或average）

A.mean(), A.sum() / A.numel()

A.mean(axis=0) , A.sum(axis=0)/A.shape[0]

计算总和或均值时候保持轴数不变

sum_A = A.sum(axis=1, keepdims=True)
sum_A

通过广播将A除以sum_A

A / sum_A

点积是相同位置的按元素乘积的和

y = torch.ones(4,dtype=torch.float32)
x ,y , torch.dot(x,y)

我们可以执行按元素乘法，然后进行求和来表示两个向量的点

torch.sum(x*y)


###我们可以将矩阵-矩阵乘法AB看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成一个nxm的矩阵

A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = torch.ones(4,3)
torch.mm(A,B)

L2范数是向量元素平方和的平方根

u = torch.tensor([3.0,-4.0])
torch.norm(u)

矩阵的佛罗贝尼乌斯范数是矩阵元素的平方和的平方根

torch.norm(torch.ones((4,9)))

按特定轴求和

a = torch.ones((2,5,4))
a.shape

a.sum(axis=[0,2]).shape

a.sum(axis=1,keepdims=True).shape

参考资料

《深度学习入门：基于python的理论与实践》
《动手学深度学习（pytorch版）》