[人工智能]python 算法基础

基础算法

需要先掌握 numpy 库、pandas 库、matplotlib 库的基础知识。部分内容需要使用到 scipy 库和 sklearn 库。

一元回归算法

当需要对一组离散的数据（y, t) ，预测两个变量间的线性或非线性关系时，可以使用回归算法预测 y、t 之间的关系。

多项式回归

np.polyfit(x, y, deg) 函数可以对形如 $y(t)=t^n+t^{n?1}+...+t+c$ 的多项式关系进行最小二乘回归分析。x、y为需要拟合的横纵坐标，deg 代表拟合多项式的最高维度。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

t = np.arange(1,21,1)
y = t*t*(1+0.1*np.random.randn(20))
model = np.polyfit(t,y,deg=2)
tt = np.arange(1,22,0.05)
yy = model[0]*tt*tt+model[1]*tt+model[2]
print(model)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(t,y)
ax.plot(tt,yy)
plt.show()

结果为：

[ 0.76591722 4.56328739 -14.08452626]

返回值是一个数组，包含从最高次到常数项的系数。

预测

实际使用过程中，可以不需要自己手动输入拟合后的多项式。
np.polyval(p,x) 传入两个参数，p 为多项式从最高次到常数项参数值的列表，x 因变量的值或数组。返回结果值或数组。

>>> np.polyval(model,[5,10])
array([ 27.87984111, 108.14006926])

任意函数回归

当需要拟合指数函数、三角函数或其他复杂函数时，需要导入 scipy.optimize 库的 curve_fit 函数进行回归拟合。
curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, bounds=(-inf, inf), method=None, jac=None, **kwargs)

• 对自定义函数的要求

def fun(x,a,b,...):
	'''
	传入的参数，第一个为自变量，后面均为需要拟合参数变量。
	'''
	pass

• curve_fit() 函数部分参数含义

• 返回值为 （popt,pcov）格式的二维元组，其中 popt 是一维数组，pcov 是二维数组
  popt 为参数估计值
  pcov 为参数协方差矩阵估计值

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

def fun(x,a,b,c):
    return a*x*x+b*x+c

t = np.arange(1,21,1)
y = t*t*(1+0.1*np.random.randn(20))
model = curve_fit(fun,t,y)
tt = np.arange(1,22,0.05)
yy = model[0][0]*tt*tt+model[0][1]*tt+model[0][2]
print(model)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(t,y)
ax.plot(tt,yy)
plt.show()

结果为：

(array([ 0.9790701 , 0.55588744, -1.73852326]), array([[ 1.86627193e-02, -3.91917018e-01, 1.43702902e+00],
[-3.91917018e-01, 8.72295050e+00, -3.53509004e+01],
[ 1.43702902e+00, -3.53509004e+01, 1.81352985e+02]]))

分类算法

我们已经有一些样本数据，并且知道这些样本分别属于哪一类（即知道样本的标签值）。现在有一些新的不知道标签的样本，我们需要用分类算法对其进行分类。

kNN k最邻近算法

参考：
Python_机器学习_算法篇（K-近邻算法） by 魔法 ? 革

原理是，找距离待分类样本最近的 k 个已知分类的样本，根据这些样本的标签进行投票，决定新样本属于哪一类。
使用该方法前，需要先将样本数据分为训练集和测试集，且应将样本特征数据和样本标签数据分开。即分为 X_train, Y_train, X_test, Y_test 四个部分，并将最后测试集的预测分类结果保存至 Y_predict，和 Y_test 中的数据进行比较，得到分类模型的准确率。
可以使用 sklearn 库下 neighbors 模块的 KNeighborsClassifier 类，传入一些模型设定参数后得到 kNN分类模型对象。

KNeighborsClassifier(n_neighbors=5, weights=‘uniform’, algorithm=‘auto’, leaf_size=30, p=2, metric=‘minkowski’, metric_params=None, n_jobs=None, **kwargs)

几个重要参数：

model = KNeighborsClassifier()

使用数据集前，一般要对数据进行标准化处理，可以利用 sklearn 库 preprocessing 模块的 StandardScaler 类生成标准化处理对象。
此外，还可以利用 sklearn 库 model_selection 模块的 train_test_split 函数将数据集随机划分为训练集和测试集。

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

x_train, x_test, y_train, y_test = train_test_split(data, target,
	test_size=0.2, random_state=22)

transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

之后使用这个对象的 .fit() 方法，输入训练集的数据和标签，训练模型。再使用 .predict() 方法，输入测试集的数据，返回预测的结果。也可以使用 .score() 方法，输入测试集的数据和标签，返回测试的准确率。

model.fit(X_train,Y_train)
Y_predict = model.predict(X_test)
score = model.score(X_test,Y_test)

聚类算法

有一堆样本，需要被分为几个类，此时需要用聚类算法来将其归类。
注意，聚类算法与分类算法不同之处在于，事先不知道任何样本的标签，而是由机器提取样本的特征后将其分为一些类别，之后如若需要，再由人去给这些类别分配标签。因此，聚类算法一般不用作预测。
聚类后的各类别，在 .labels_ 属性里会用 0、1、2……的标签区分，预测后的返回值会用 1、2、3……的标签区分。如果算法舍弃部分点，则分类标签为 -1 代表离散点。
如果要画聚类后的分类图，建议用 .labels_ 属性直接得到预测值，否则需要将 .predict() 返回值 -1。

k-means

参考：
Python_机器学习_算法篇（聚类算法） by 魔法 ? 革

k均值聚类的原理如下：

1. 随机设置K个特征空间内的点作为初始的聚类中心
2. 对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别
3. 接着对着标记的聚类中心之后，重新计算出每个簇的新中心点（平均值）
4. 如果计算得出的新中心点与原中心点一样（质心不再移动），那么结束，否则重新进行第二步过程

使用 k均值聚类算法前，先从 sklearn 库的 cluster 模块导入 KMeans 类。

from sklearn.cluster import KMeans

KMeans(n_clusters=8, init=‘k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=‘auto’, verbose=0, random_state=None, copy_x=True, n_jobs=None, algorithm=‘auto’)

主要参数：

将 KMeans() 函数返回值赋值给 model，生成 KMeans 聚类模型对象。

model = KMeans()

该对象有如下常用方法：

其中 K-均值目标指样本到其最近的聚类中心的距离的平方之和，即J平方误差函数。可以用 model.inertia_ 属性查看。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
from sklearn.cluster import KMeans

X = pd.DataFrame([[1,2],[1,3],[2,1],[4,6],[5,5]])
model = KMeans(2)
model.fit(X)
X_n = model.transform(X)
Y = model.predict(X)
print(model.score(X))
print(model.inertia_)
print(X_n)
print(Y)

结果为

-3.6666666666666687
3.666666666666667
[[4.94974747 0.33333333]
[4.30116263 1.05409255]
[5.14781507 1.20185043]
[0.70710678 4.8074017 ]
[0.70710678 4.7375568 ]]
[1 1 1 0 0]

DBSCAN

k-means 由于其聚类的原理，导致其只能对呈现球形聚集的数据进行聚类，而无法对于环状、条状数据进行聚类。
其原理为：

1. 在样本中随机选择一个未被分类的点，作为一个新簇的第一个点。
2. 以这个点为半径，取距离在这个范围内且离当前点距离最近的几个点加入当前簇。
3. 对新加入的点重复 2 的步骤。
4. 直到没有新点加入时，重复 1~3 的步骤。若当前簇点数少于设定最小簇长度，代表这些点为离散点，不作分类。
5. 所有点都被分类或只剩下离散点时，聚类结束。

使用 DBSCAN 聚类算法前，先从 sklearn 库的 cluster 模块导入 DBSCAN 类。

from sklearn.cluster import DBSCAN

DBSCAN(eps=0.5, min_samples=5, metric=‘euclidean’, metric_params=None, algorithm=‘auto’, leaf_size=30, p=None, n_jobs=None)

主要参数：

需要注意，DBSCAN 类的方法只有 .fit() 和 .fit_predict() ，用法同 k-means 算法。

推荐算法（暂时不写）

目前有一堆用户和一堆项目，已知每个用户关注的项目，要为所有用户推荐其可能喜欢的项目时，需要用到推荐算法。推荐算法有两种：一种需要根据项目寻找相似用户，即先观察每个用户关注的项目，再算出相似的用户，最后为每个用户推荐其相似用户关注的项目（基于用户的协同过滤）；另一种需要根据用户寻找相似项目，即先观察每个项目被关注的用户，再算出相似的项目，最后将每个项目推荐给其相似项目被关注的用户（基于项目的协同过滤）。

（具体以后再记）

降维算法

降维算法可以将高维数据变为低维数据，且保留其原始数据的全部信息。
使用降维算法前，需要对原始数据进行标准化处理。

数据预处理

python 机器学习库有专门的数据处理模块 sklearn.preprocessing，有以下常用类：

生成对应对象后，调用对象的 .fit_transform() 方法传入数据集，即可返回归一化后的数据。
具体不同归一化方法的效果，修改自（已标出处）代码如下：

作者：thothsun
链接：https://www.zhihu.com/question/20467170/answer/839255695
来源：知乎

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import preprocessing

def plot(data, title,subid):
    global fig
    sns.set_style('dark')
    ax = fig.add_subplot(subid)
    ax.set(ylabel='frequency')
    ax.set(xlabel='height(blue) / weight(green)')
    ax.set(title=title)
    sns.distplot(data[:, 0:1], color='blue')
    sns.distplot(data[:, 1:2], color='green')


np.random.seed(42)
height = np.random.normal(loc=168, scale=5, size=1000).reshape(-1, 1)
weight = np.random.normal(loc=70, scale=10, size=1000).reshape(-1, 1)
fig = plt.figure(figsize=(12,10))

original_data = np.concatenate((height, weight), axis=1)
plot(original_data, 'Original',231)

standard_scaler_data = preprocessing.StandardScaler().fit_transform(original_data)
plot(standard_scaler_data, 'StandardScaler',232)

min_max_scaler_data = preprocessing.MinMaxScaler().fit_transform(original_data)
plot(min_max_scaler_data, 'MinMaxScaler',233)

max_abs_scaler_data = preprocessing.MaxAbsScaler().fit_transform(original_data)
plot(max_abs_scaler_data, 'MaxAbsScaler',234)

normalizer_data = preprocessing.Normalizer().fit_transform(original_data)
plot(normalizer_data, 'Normalizer',235)

robust_scaler_data = preprocessing.RobustScaler().fit_transform(original_data)
plot(robust_scaler_data, 'RobustScaler',236)

plt.savefig('scalter.png')
plt.show()

提一下Normalizer 中的 p-范数。

主成分分析 PCA

原理见《多元统计分析》，使用 PCA 需要从 sklearn 库的 decomposition 模块导入 PCA 类。

from sklearn.decomposition import PCA

PCA(n_components=None, copy=True, whiten=False, svd_solver=‘auto’, tol=0.0, iterated_power=‘auto’, random_state=None)
常用参数含义为：

常用方法为：

常用属性为：

因子分析 FactorAnalysis

由于 sklearn 库 decomposition 模块的 FactorAnalysis 类实现的功能实在是太太太少了，主要以 factor_analyzer 里的 FactorAnalyzer 类为例。

sklearn.decomposition.FactorAnalysis

from sklearn.decomposition import FactorAnalysis

FactorAnalysis(n_components=None, tol=0.01, copy=True, max_iter=1000, noise_variance_init=None, svd_method=‘randomized’, iterated_power=3, random_state=0)

常用参数如下：

常用方法如下：

常用属性如下：

没错，这个库既没实现因子旋转，甚至连因子的贡献率都需要自己写函数计算，导致我研究了半天后还是放弃这个库了。

检验是否适合因子分析

参考自：http://www.srcmini.com/24087.html

1. Bartlett 球形度检验
   Bartlett 球形度检验使用观察到的相关矩阵和恒等矩阵检查观察到的变量是否相互关联。如果测试发现统计上不重要, 则不应使用因子分析。

from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity
chi_square_value, p_value=calculate_bartlett_sphericity(df)
# 若 p_value < 0.05，则说明数据具有统计学意义, 表明所观察到的相关矩阵不是恒等矩阵，可以进行因子分析。

2. Kaiser-Meyer-Olkin 检验
   Kaiser-Meyer-Olkin(KMO)测试可测量数据是否适合进行因子分析。它确定每个观察变量和完整模型的充分性。 KMO估计所有观察变量之间的方差比例。较低的比例ID更适合因子分析。 KMO值介于0到1之间。KMO值小于0.6被认为是不合适的。

from factor_analyzer.factor_analyzer import calculate_kmo
kmo_all, kmo_model=calculate_kmo(df)
# 若 kmo_model > 0.6，则认为适合做因子分析

factor_analyzer.FactorAnalyzer

from factor_analyzer import FactorAnalyzer

FactorAnalyzer(n_factors=3, rotation=‘promax’, method=‘minres’, use_smc=True, is_corr_matrix=False, bounds=(0.005, 1), impute=‘median’, rotation_kwargs=None)

常用参数如下：

rotation 有如下可选参数：
(1) varimax (orthogonal rotation) 方差最大化矩阵，常用
(2) promax (oblique rotation) 默认
(3) oblimin (oblique rotation)
(4) oblimax (orthogonal rotation)
(5) quartimin (oblique rotation)
(6) quartimax (orthogonal rotation)
(7) equamax (orthogonal rotation)
（orthogonal rotation 正交旋转，oblique rotation 斜交旋转）

method 有如下可选参数：
(1) minres 最小残差法
(2) ml 最大似然法
(3) principal 主轴因素法

常用方法如下：

常用属性如下：

时间序列预测算法

python 中统计模型由 statsmodels 库提供。
这部分内容，感觉目前写的方法并不好，就只放可套用的代码了，以后再补充吧。

ADF检验

对于很多时间序列预测模型，会要求时间序列必须是平稳的，因此每一步都需要做平稳性检验。最常用的平稳性检验是 ADF检验（单位根检验）。
详细参考：https://www.pianshen.com/article/5826219147/
具体使用时，可简单用以下代码：

from statsmodels.tsa.stattools import adfuller
dftest = adfuller(ts) 						# ts为 series对象
dftest[1]
# 若 dftest[1]（即 p-value）小于 0.05，则拒绝序列存在单位根的假设，即可以认为序列平稳

若检验结果为不平稳，往往需要对原始数据作差分（一般不超过二阶差分），再次作检验。对差分后的数据进行预测。

ts_diff=ts.diff(1)
ts_diff.dropna(inplace=True) #由于差分之后第一位是空值，因此需要去掉空值

AIC 定阶

import statsmodels.api as sm
res = sm.tsa.arma_order_select_ic(ts_diff,max_ar = 5,max_ma = 5, ic=['aic'])
p = res.aic_min_order[0]
q = res.aic_min_order[1]

ARIMA 自回归滑动平均模型

from statsmodels.tsa.arima_model import ARIMA

# 第一种：使用原数据，在模型中d参数设置为1阶差分
model1 = ARIMA(ts, order=(p,1,q))
res_arima1 = model1.fit() #
pre1 = res_arima1.predict(start=str('1960-01'),end=str('1960-12'),dynamic=False)
# 第二种：使用差分后的数据
model2 = ARIMA(ts_diff, order=(p,0,q))
res_arima2 = model2.fit()
pre2 = res_arima2.predict(start=str('1960-01'),end=str('1960-12'),dynamic=False)

以第一种方法为例，下面为还原预测数据的代码。

pre1.iloc[0] = pre1.iloc[0] + data.loc['1959-12','#Passengers'][0] #先将第一个数据还原
pre_cumsum1 = pre1.cumsum() #累计求和 比如一个列表是这样[1,2,3,4,5] 返回是这样[1,3,6,10,15]