Numpy的高级应用
import numpy as npimport numpy as np
import pandas as pd
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
import pandas as pd
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
%config InlineBackend.figure_format = 'svg'
# 常用函数
array1 = np.arange(1, 10).reshape(3, 3)
array1
array2 = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])
array2
# 水平方向拼接
np.hstack((array1, array2))
# 垂直方向拼接
np.vstack((array1, array2))
# 沿着指定的轴拼接
np.concatenate((array1, array2))
np.concatenate((array1, array2), axis=1)
# 垂直方向拆分
np.vsplit(array2, 3)
# 水平方向拆分
np.hsplit(array2, 3)
# 在末尾追加元素
np.append(array1, 10)
# 在指定位置插入元素
np.insert(array1, 0, 0)
array1[array1 % 3 == 0]
# 根据条件筛选数据
np.extract(array1 % 3 == 0, array1)
# 根据条件和公式获取数据
x = np.arange(10)
condlist = [x < 3, x > 5]
choicelist = [x, x ** 2]
np.select(condlist, choicelist, default=np.nan)
# 根据条件和公式获取数据
np.where(x < 5, x, 10 * x)
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
gen = fib(20)
# 通过迭代器（生成器）创建数组对象
array3 = np.fromiter(gen, dtype=np.int64, count=10)
array3
# 调整数组的大小
np.resize(array1, (4, 4))
向量
点积运算
A
⋅
B
=
a
1
b
1
+
a
2
b
2
=
∣
A
∣
∣
B
∣
c
o
s
θ
A \cdot B = a_1b_1 + a_2b_2 = \lvert A \rvert \lvert B \rvert cos \theta
A⋅B=a1b1+a2b2=∣A∣∣B∣cosθ
A ⋅ B = ∑ i = 1 n a i b i = ∣ A ∣ ∣ B ∣ c o s θ A \cdot B = \sum_{i=1}^{n} a_ib_i = \lvert A \rvert \lvert B \rvert cos \theta A⋅B=i=1∑naibi=∣A∣∣B∣cosθ
v1 = np.array([3, 5])
v2 = np.array([1, 3])
# inner_prod = np.dot(v1, v2)
inner_prod = np.inner(v1, v2)
print('向量点积:', inner_prod)
> 说明：在欧几里得几何中，两个笛卡尔坐标向量的点积也称为内积（inner product），但是内积的含义要高于点积，点积相当于是内积在欧几里得空间 $ \mathbb{R}^n $ 的特例，而内积可以推广到赋范向量空间。
v1_norm = np.linalg.norm(v1)
v2_norm = np.linalg.norm(v2)
print('v1的模:', np.round(v1_norm, 6))
print('v2的模:', np.round(v2_norm, 6))
cos_theta = inner_prod / (v1_norm * v2_norm)
print('向量夹角余弦值:', cos_theta)
print('夹角:', np.arccos(cos_theta) * 180 / np.pi)
行列式
d
e
t
(
A
)
=
∑
n
!
±
a
1
α
a
2
β
a
3
γ
⋯
a
n
ω
det(A) = \sum_{n!} \pm a_{1\alpha}a_{2\beta}a_{3\gamma} \cdots a_{n\omega}
det(A)=n!∑±a1αa2βa3γ⋯anω
array4 = np.stack((v1, v2))
array4
d e t ∣ 3 5 1 3 ∣ = 4 det \begin{vmatrix} 3 & 5 \\ 1 & 3 \end{vmatrix} = 4 det∣∣∣∣3153∣∣∣∣=4
d e t ∣ 3 5 1 3 ∣ = 4 det \begin{vmatrix} 3 & 5 \\ 1 & 3 \end{vmatrix} = 4 det∣∣∣∣3153∣∣∣∣=4
# 计算行列式的值
np.round(np.linalg.det(array4), 2)
d e t ∣ 1 2 3 4 5 6 7 8 9 ∣ = 0 det \begin{vmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{vmatrix} = 0 det∣∣∣∣∣∣147258369∣∣∣∣∣∣=0
d e t ∣ 1 2 3 4 5 6 7 8 9 ∣ = 0 det \begin{vmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{vmatrix} = 0 det∣∣∣∣∣∣147258369∣∣∣∣∣∣=0
np.linalg.det(array1)
# 矩阵
array1 = np.arange(1, 10).reshape((3, 3))
array1
对上面的array1做一组线性变换，就知道为什么它的秩是2了。
∣ 1 2 3 4 5 6 7 8 9 ∣ → ∣ 1 2 3 0 − 3 − 6 0 − 6 − 12 ∣ \begin{vmatrix} 1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9 \end{vmatrix} \quad \to \quad \begin{vmatrix} 1 & 2 & 3\\ 0 & -3 & -6\\ 0 & -6 & -12 \end{vmatrix} ∣∣∣∣∣∣147258369∣∣∣∣∣∣→∣∣∣∣∣∣1002−3−63−6−12∣∣∣∣∣∣
# 求逆矩阵
# LinAlgError ---> Singluar matrix ---> 奇异矩阵不能求逆
# np.linalg.inv(array1)
array2 = np.array([[1, 2], [3, 4]])
array2
array3 = np.linalg.inv(array2)
array3
A ⋅ A − 1 = I A \cdot A^{-1} = I A⋅A−1=I
np.round(array2 @ array3, 2)
# 求矩阵的秩
np.linalg.matrix_rank(array1)
array1[2, 2] = 8
array1
np.linalg.matrix_rank(array1)
解线性方程：
$$
\begin{cases}
3x + y = 9 \\
x + 2y = 8
\end{cases}
$$
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8]).reshape(-1, 1)
np.linalg.solve(A, b)
$$
Ax = b\\
A^{-1}Ax = A^{-1}b\\
Ix = A^{-1}b
$$
A_1 = np.linalg.inv(A)
A_1
A_1 @ b
#### 最小二乘解
!pip install scikit-learn
from sklearn.datasets import load_boston
# 获取波士顿房价数据
dataset = load_boston()
print(dataset.DESCR)
dataset.data.shape
dataset.feature_names
# 用波士顿房价数据创建DataFrame对象
df = pd.DataFrame(data=dataset.data, columns=dataset.feature_names)
df
# 计算协方差
df.cov()
# 计算皮尔逊相关系数
np.round(df.corr(), 2)
rooms = df['RM'].values
prices = df['PRICE'].values
history_data = {room: price for room, price in zip(rooms, prices)}
history_data
通过计算皮尔逊相关系数，发现房间数和房价存在正相关，接下来我们通过学习历史数据，最终实现用房间数预测房价的目标。
import heapq
nums = [35, 98, 76, 12, 55, 68, 47, 92]
print(heapq.nlargest(3, nums))
print(heapq.nsmallest(3, nums))
import heapq
# kNN算法
def predict_price_by_knn(history_data, room, k=5):
# keys = sorted(history_data, key=lambda x: (x - room) ** 2)[:k]
keys = heapq.nsmallest(k, history_data, key=lambda x: (x - room) ** 2)
return np.mean([history_data[key] for key in keys])
# 预测房价
np.round(predict_price_by_knn(history_data, 6.25), 2)
np.round(predict_price_by_knn(history_data, 5.125), 2)
# 通过散点图研究变量的关系
plt.scatter(rooms, prices)
plt.show()
通过上面的图，我们发现房间数和房价呈现出线性关系，接下来我们尝试用一个线性函数来实现对房价的预测。
#### 损失函数
回归方程：$x$ 代表房间数，$y$ 就是要预测的房价。
$$
y = ax + b
$$
现在我们的问题是找到一组`a`和`b`，让预测达到最佳的效果（误差最小就是最佳）。
均方误差：让均方误差最小的 $a$ 和 $b$ 就是最佳拟合。
$$
MSE = \frac{1} {N} \sum (\hat{y_i} - y_i)^2
$$
def get_loss(x, y, a, b):
"""损失函数"""
y_hat = a * x + b
return np.mean((y_hat - y) ** 2)
# 通过蒙特卡罗模拟找到实现最佳拟合的a和b的值
import random
best_a, best_b = None, None
min_loss = np.inf
for _ in range(1000):
# 随机产生a和b的值
a = random.random() * 200 - 100
b = random.random() * 200 - 100
# 计算损失（MSE）
curr_loss = get_loss(rooms, prices, a, b)
# 让损失更小的a和b就是更好的拟合
if curr_loss < min_loss:
min_loss = curr_loss
best_a, best_b = a, b
print(best_a, best_b)
print(min_loss)
#### 梯度下降
损失函数是凹函数，找到使函数最小的`a`和`b`的值，可以用下面的方法：
$$ a^\prime = a + (-1) \times \frac {\partial loss(a, b)} {\partial a} \times \Delta $$
$$ b^\prime = b + (-1) \times \frac {\partial loss(a, b)} {\partial b} \times \Delta $$
对于求MSE的损失函数来说，可以用下面的公式计算偏导数：
$$ f(a, b) = \frac {1} {N} \sum_{i=1}^{N}(y_i - (ax_i + b))^2 $$
$$ \frac {\partial {f(a, b)}} {\partial {a}} = \frac {2} {N} \sum_{i=1}^{N}(-x_iy_i + x_i^2a + x_ib) $$
$$ \frac {\partial {f(a, b)}} {\partial {b}} = \frac {2} {N} \sum_{i=1}^{N}(-y_i + x_ia + b) $$
# 求a的偏导数
def partial_a(x, y, a, b):
return 2 * np.mean((y - a * x - b) * (-x))
# 求b的偏导数
def partial_b(x, y, a, b):
return 2 * np.mean(-y + a * x + b)
# 通过梯度下降的方式向拐点逼近
# 这种方式能够更快的找到最佳拟合的a和b
# a和b的初始值可以随意设定，delta的值要足够小
a, b = 35, -35
delta = 0.01
for _ in range(100):
a = a - partial_a(rooms, prices, a, b) * delta
b = b - partial_b(rooms, prices, a, b) * delta
print(a, b)
print(get_loss(rooms, prices, a, b))
# 通过线性回归方程预测房价
def predict_price_by_regression(a, b, x):
return a * x + b
# 预测房价
print(np.round(predict_price_by_regression(best_a, best_b, 6.25), 2))
print(np.round(predict_price_by_regression(a, b, 6.25), 2))
print(np.round(predict_price_by_regression(best_a, best_b, 5.12), 2))
print(np.round(predict_price_by_regression(a, b, 5.12), 2))
# 比较两条拟合曲线
y_hat1 = best_a * rooms + best_b
y_hat2 = a * rooms + b
plt.scatter(rooms, prices)
plt.plot(rooms, y_hat1, color='red', linewidth=4)
plt.plot(rooms, y_hat2, color='green', linewidth=4)
plt.show()
最小二乘解就是用已经得到的历史数据（`x`和`y`的值）找到能够最佳拟合这些历史数据的`a`和`b`。
$$
y = ax + b
$$
对于上面的方程，相当于`x`是变量`a`的系数，`1`是变量`b`的系数。
#### `lstsq`函数参数说明
`lstsq`函数的第一个参数是$ \begin{bmatrix} x \\ 1 \\ \end{bmatrix} ^T $，第二个参数就是`y`，`rcond`参数暂时不管，直接设置为`None`。
# lstsq函数的第一个参数
param1 = np.vstack([rooms, np.ones(rooms.size)]).T
param1
# lstsq函数的第二个参数
param2 = prices
param2
#### `lstsq`函数返回值说明
`lstsq`函数返回的是一个四元组，四元组中的第一个元素就是要求解的方程的系数，四元组中的第二个元素是误差平方和。
# rcond参数直接设置为None（暂不解释）
result = np.linalg.lstsq(param1, param2, rcond=None)
result
a, b = result[0]
mse = result[1][0] / rooms.size
print(a, b)
print(mse)
# 比较两条拟合曲线
plt.scatter(rooms, prices)
# 梯度下降法给出的a和b预测出的房价
plt.plot(rooms, y_hat2, color='red', linewidth=4)
# lstsq函数给出的a和b预测出的房价
y_hat3 = a * rooms + b
plt.plot(rooms, y_hat3, color='green', linewidth=4)
plt.show()
6826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
