import matplotlib.pyplot as plt
import numpy as np
常用激活函数：
逻辑回归： f(x)=Σak * x^k
分类 sigmoid：f(x) = 1 / (1 + exp(-(Σak* xk +b)))
分类 softmax: f(x) = e^x / Σe^xi 将结果和加起来是1 使用e^x保证概率不是负数 对真是概率有放大作用
分类总结：N分类互斥，且只能选择其一 选择softmax；N分类互斥，可以选择多个类别 选择sigmoid
损失函数：
交叉熵：E = -logE = -logΠtk * pk 交叉熵越小，模型预测效果越好
差值方差/MSELoss函数：E = 1/(2* N)Σ(f(x)-t)^2
MAE函数：E = 1/m * Σ|yi-y’i| y’i表示预测值 y表示真实值
L1Loss函数：E = Σ|yi-y’i| y’i表示预测值 y表示真实值
L2Loss函数：E = Σ(yi-y’i)^2 y’i表示预测值 y表示真实值
smooth L1函数：E = 1/2* Σ(yi-y’i)^2 if |yi-y’i|<1 else |x| - 0.5
鲁棒性：对于异常值可以安全和有效的被忽略
稳定性：对于水平方向一个微小的波动不会产生很大影响（只能单一求解）
优化器:参数更新方法
SGD:随机梯度下降法 根据batch随机抽取样本进行训练，然后更新数据
ASGD：平局随机梯度下降法
Adagrad：将每一个参数的每一次迭代的梯度取平方累加后在开方，用全局学习率除以这个数，作为学习率的动态更新，即对学习率的一种约束
Adadelta：自适应学习率调整
RMSprop：适合处理非平稳目标，对于RNN效果很好
Adam：对内存需求较小，为不同的参数计算不同的自适应学习率，也适用于大多非凸优化，适用于大数据集和高维空间
Adamax：是Adam的优化版
x = np.random.randint(0, 30, 50)
a = np.random.randint(2, 16, 50)
y = a*x+2
plt.scatter(x, y)
plt.xlabel('x_value', size=10)
plt.ylabel('y_value', size=10)
plt.show()
x = np.linspace(-1,5, 30)
y = x**2
plt.plot(n, y)
plt.show()
x = np.linspace(-1,1, 30)
y = 3*x**3+2*x**2+x+1
plt.plot(x,y)
plt.show()
x = np.linspace(-180, 180, 360)
y = np.sin(x /180 * np.pi)
y1 = np.cos(x / 180 * np.pi)
plt.plot(x, y, label='sin')
plt.plot(x, y1, label='cos')
plt.legend()
plt.grid()
plt.show()
1阶张量点积： a = [a1, a2,a3], b=[b1.b2,b3] a.b = a1b1+a2b2+a3b3
2阶张量点积： A = [[a11, a12],[a21,a22]] B=[[b11,b12],[b21,b22]] A.B=[[a11b11+a12b21, a21b11+a22b12],[a11b12+a12b22,a21b12+a22b22]]
范数：L^2 表示向量每个元素的平方和取根号 L 表示向量每个元素的绝对值之和
归纳范数：L^p 表示向量每个元素的绝对值的p次幂之和再取根号p
哈达玛机：矩阵各个对应元素的乘积
n = np.array([1,1,1,-1])
# 取范数L^2
print(np.linalg.norm(n))
# 取范数L
print(np.linalg.norm(n,1))
# 取范数L^3
print(np.linalg.norm(n, 3))
A = np.arange(10).reshape(2,5)
B = np.random.randint(0,10, 10).reshape(5,2)
# 矩阵的点积
print(np.dot(A,B))
C = np.arange(10).reshape(2,5)
D = np.random.randint(0,10,10).reshape(2,5)
# 哈达玛机
print(C*D)
2.0
4.0
1.5874010519681994
[[ 31 54]
[131 164]]
[[ 0 5 6 9 32]
[15 24 0 64 27]]
# 转置
print(A)
print(A.T)
单位矩阵：行数和列数相同，左上角到右下角的值都是1，其余都是0
单位矩阵和其余矩阵的点积后 数据不变
# 创建单位矩阵
n = np.identity(3, np.uint8)
print(n)
n1 = np.eye(3)
print(n1)
A = np.random.rand(9).reshape(3,3)
print(A)
print(np.dot(n,A))
[[1 0 0]
[0 1 0]
[0 0 1]]
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
[[0.14579061 0.3099416 0.00348579]
[0.05330847 0.70692021 0.83504225]
[0.37594654 0.22306725 0.80877986]]
[[0.14579061 0.3099416 0.00348579]
[0.05330847 0.70692021 0.83504225]
[0.37594654 0.22306725 0.80877986]]
逆矩阵：如果A与B的点积是单位矩阵 则B是A的逆矩阵
n = np.array([[1,1],[1,2]])
n1 = np.array([[2,-1],[-1,1]])
print(np.dot(n,n1))
# 获取逆矩阵
print(np.linalg.inv(n))
[[1 0]
[0 1]]
[[ 2. -1.]
[-1. 1.]]
行列式：用来判断矩阵是否存在逆矩阵
A = [[a,b],[c,d]]
如果ad-bc=0表示没有逆矩阵，否则有逆矩阵
# 获取行列式
print(np.linalg.det(n))
1.0
矢量：用带箭头的a=(2/3)表示向量[2,3]
标准基底向量 ex = [[1],[0]] ey=[[0],[1]]
a = 2*ex + 3 * ey
特征值
特征向量
Ax=γx 其中x表示特征向量 γ表示特征值
n = np.array([[3,4], [1,2]])
ev = np.linalg.eig(n)
print(ev) # 前面表示特征值 后面表示特征向量
(array([4.56155281, 0.43844719]), array([[ 0.93153209, -0.84212294],
[ 0.36365914, 0.5392856 ]]))
余弦相似度:表示两个向量的相似程度
cosθ = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
n = np.random.randint(0,10,10).reshape(2,5)
n1 = np.random.randint(0,10,10).reshape(5,2)
print(n, n1)
cosθ = np.dot(n,n1) / (np.linalg.norm(n) * np.linalg.norm(n1))
print(cosθ)
[[1 5 5 0 0]
[5 7 6 6 2]] [[8 4]
[5 7]
[7 0]
[9 9]
[5 6]]
[[0.23238393 0.13327902]
[0.61855133 0.46135044]]
微分：f’(x) = (f(x+dx) - f(x)) / dx
f’(x)是f(x)的导数
只有一个变量x的f’(x)称为常微分
f(x) = x^r f’(x) = rx^(r-1)
d[f(x)+g(x)]/dx = d(f(x))/dx+d(g(x))/dx
d[f(x)g(x)]/dx = d(f(x))/dxg(x) + d(g(x))/dxf(x)
d[kf(x)]/dx = kd(f(x))/ dx
连锁律：允许复合函数进行微分
复合函数：y = (x3+2x2)^3 可以表示成y=u^3 u=x^3 + 2x^2
dy/dx = dy/du * du/dx
偏微分：在多个变量的函数中，用一个变量进行微分 其余变量看着是常量的处理方式称为偏微分
全微分：使用所有变量的微小变化来确定多变量函数的微小变化
z = f(x,y)
dz = 对x进行偏微分*dx + 对y进行偏微分 * dy
多变量复合连锁律
自然常数：e （1+1/n)^n n接近于无穷大
sigmoid函数: y=1/（1+exp(-x))
sigmoid函数的导数为： (1-y)y
softmax函数：f(x) = e^x / Σe^xi
梯度下降法：xi = xi - df(x)/dx* eta
eta表示学习率 为常数
当df(x) / dx为0时， f(x)变成了最小值
局部最小值 全局最小值
概率学：P(A)=a./n 表示A事件发生的概率 a表示A事件发生的数量 n表示所有场景发生的数量
补事件：1-P(A)
依概率收敛：随着次数增加，结果会越来越偏向于概率值
# import numpy as np
# import matplotlib.pyplot as plt
num_5 = 0
total = 0
x = []
y = []
for i in range(5000):
if np.random.randint(6) == 5:
num_5 += 1
total += 1
x.append(i)
y.append(num_5/total)
plt.plot(x, y)
plt.plot(x, np.ones(5000) * 1/6, linestyle='dashed')
plt.show()
概率密度函数：f(x)=1/(np.std * np.sqrt(2 * np.pi)) * np.exp(- (x - np.mean)^2 / (2 * np.std))
np.random.normal(av,std,num) 表示生成符合正太分布的数据
# 正太分布
import numpy as np
import matplotlib.pyplot as plt
def pdf(x,av,std):
return 1/(std * np.sqrt(2 * np.pi))*np.exp(-(x - av)*(x - av) / (2 * std))
x = np.linspace(-10, 10, 1000)
y1 = pdf(x, 0,0.5)
y2 = pdf(x,0,1.0)
y3 = pdf(x,0, 1.5)
plt.plot(x,y1,linestyle='dashed')
plt.plot(x,y2, linestyle='solid')
plt.plot(x,y3, linestyle='dashdot')
plt.grid()
plt.show()
幂律：f(x) = c* x^(-k) c和k都是常数
帕累托分布： f(x) = a * m^a / x^(a+1)
np.random.pareto(a,m,num) 表示生成遵循帕累托分布的随机数
协方差：表示两组数据之间的关系
cov(x,y) = 1/n * sum(xi-x_av)(yi-y_av)
np.random.multivariate_normal(av,cov,num) 根据平均值和协方差生成数据
# 根据协方差生成数据
def show_cov(cov):
av = np.array([0,0])
cov_m = np.array([[1,cov],[cov,1]])
data = np.random.multivariate_normal(av,cov_m,3000)
# print(data.shape)
x = data[:,0]
y = data[:,1]
plt.scatter(x,y)
plt.grid()
plt.show()
show_cov(0.5)
show_cov(0)
show_cov(-0.5)
相关系数：表示两组数据的关系
公式： p = cov(x,y)/(x_std * y_std)
当p为1时表示x,y数据关系很强且为正方向
当p为0时表示x,y数据关系没有关系
当p为1时表示x,y数据关系很强且为负方向
条件概率：P(A|B) 表示B事件发生时，A事件发生的概率 P(A|B) = P(A & B) / P(B)
贝叶斯定律：P(B|A) = P(A|B) * P(B) / P(A)
似然：表示数据的可能性 所有概率的乘积
似然对数
信息量：表示某一事件具有多少信息的尺度
选择信息量：I(E) = -logP(E) 用来衡量事件发生的难易程度 概率越大选择信息量越小
平均信息量：H = -sum(P(E)* log2(P(E)) 用来衡量信息的无序性和不确定性的标准
交叉熵：衡量概率分布和预期值之间的距离的尺度
误差函数/损失函数
交叉熵：E = -logL = -sum(tk * logPk)
x = np.linspace(-np.pi, np.pi)
y = np.sin(x)
t = y + np.random.randn(len(y)) * 0.3
plt.plot(x, y)
plt.scatter(x,t)
plt.grid()
plt.show()
eta = 0.01
w = np.random.rand(len(x))
def update(x, t, w):
# 回归方式计算拟合线性关系
import numpy as np
import matplotlib.pyplot as plt
# f(x) = Σ ak * x^k
# 计算差值平方和
# E = 1/2 * Σ（f(x)-t)^2
# 使用梯度下降法进行求解
# w = w - eta * dE / dw
def func(x,params):
p_len = len(params)
fun = 0
for i in range(p_len):
fun += params[i] * x**i
return fun
# dE / dw = dE / du * du / dw
# u = Σak * x^k - t
# dE / du = Σu
# du / dw = x^k
eta = 0.01
# def grad_params(x,t,params):
# grad_ps = np.zeros(len(params))
# for i in range(len(params)):
# for j in range(len(x)):
# grad_ps[i] += (func(x[j], params) - t[j]) * x[j] ** i
# return grad_ps
def update(x,t,params):
for i in range(len(params)):
u_sum = np.sum((func(x,params)/1000 - t/1000) * x ** i)
# print(u_sum)
params[i] -= eta * u_sum / len(x)
return params
# 采用随机梯度下降法
x = np.linspace(-10,10,500)
t = 2*x**2+3 + np.random.randn(500)*0.1
# print(t)
batch = 50
epochs = 300
params = np.random.randn(3)
for i in range(len(params)):
params[i]*=2**i
for i in range(epochs):
b = np.random.randint(0,100,batch)
x_b = x[b]
t_b = t[b]
params = update(x,t,params)
print(params)
f = func(x, params)
# print(t,f)
# x = np.linspace(0,20,100)
# y = np.sin(x)
# t = y + np.random.randn(100)*0.2
plt.plot(x,f)
plt.scatter(x,t)
plt.show()
[-0.76822672 -1.2492766 2.05760442]
# k-means均值聚类算法
np.random.seed(0)
data = np.random.randn(100).reshape(50, 2)
# print(data)
def distance(x1,x2):
return np.sum((x1-x2)**2)
def fit(data, k, epochs):
m, n = data.shape
init_k=data[np.random.choice(m,k, replace=False), :]
c = np.zeros(m)
epoch = 0
while epoch<=epochs:
epoch+=1
for i in range(m):
p = 0
mini_distance = distance(data[i],init_k[0])
for j in range(k):
if distance(data[i], init_k[j])<=mini_distance:
p=j
mini_distance = distance(data[i], init_k[j])
c[i]=p
new_k = np.zeros((k,n))
c_p = np.zeros(k)
c=c.astype(np.uint8)
for i in range(m):
new_k[c[i]]+=data[i]
c_p[c[i]]+=1
out = np.zeros((k, n))
for i in range(k):
new_k[i] = new_k[i] / c_p[i]
out[i]=new_k[i]
if not np.all(out - new_k):
return out,c
return out,c
k,c = fit(data,3,100)
# print(k,c)
plt.scatter(k[:,0],k[:,1],color='r')
plt.scatter(data[:,0], data[:,1])
for i in range(data.shape[0]):
plt.plot([data[i][0],k[c[i]][0]],[data[i][1],k[c[i]][1]])
plt.show()
梯度
多元函数的偏导数 称为该函数的梯度
y=f(xi)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
