数据分析常见五种算法

本文最后更新于：July 15, 2022 am

一、KNN最邻近分类理论概念

# 预测属于哪一种类型
# 接近k的邻居，就可以归为这一类
# 更偏向于哪一个
1
2
3
4
5
6
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
from sklearn.linear_model import LinearRegression
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from sklearn import neighbors  #  导入KNN分类模块
import warnings
warnings.filterwarnings('ignore')
#  不发出警告

data = pd.DataFrame({ 'fight':[3,2,1,101,99,98],
                    'kiss':[104,100,81,10,5,2],
                    'type':['R','R','R','A','A','A'],
                    'name':['北京遇上西雅图','喜欢你','疯狂动物城','战狼2','力王','敢死队']})
print(data)
print('----')
#  创建数据

plt.scatter(data[data['type'] == 'R']['fight'],data[data['type'] == 'R']['kiss'],color = 'r',marker = 'o',label = 'R')
plt.scatter(data[data['type'] == 'A']['fight'],data[data['type'] == 'A']['kiss'],color = 'r',marker = 'o',label = 'A')
plt.grid()
plt.legend()

knn = neighbors.KNeighborsClassifier()
knn.fit(data[['fight','kiss']],data['type'])

knn.predict([18,90])
plt.scatter(18,90,color = 'r',marker='x',label = 'R')
plt.ylabel('kiss')
plt.xlabel('fight')
plt.text(18,90,'《你的名字》',color='r')
1
2
3
4
5
6
7
8
9
10
11
data2 = pd.DataFrame(np.random.rand(100,2)*50,columns = ['fight','kiss'])
data2['typetest'] = knn.predict(data2)

plt.scatter(data[data['type'] == 'R']['fight'],data[data['type'] == 'R']['kiss'],color = 'r',marker = 'o',label = 'R')
plt.scatter(data[data['type'] == 'A']['fight'],data[data['type'] == 'A']['kiss'],color = 'r',marker = 'o',label = 'A')
plt.grid()
plt.legend()
plt.scatter(data2[data2['typetest'] == 'R']['fight'],data2[data2['typetest'] == 'R']['kiss'],color = 'r',marker = 'x',label = 'R')
plt.scatter(data2[data2['typetest'] == 'A']['fight'],data2[data2['typetest'] == 'A']['kiss'],color = 'g',marker = 'x',label = 'A')

data2.head()

二、K均值算法逻辑

# 1、 随机生k个初始点作为质心
# 2、 将数据集中的数据按照距离质心的远近分到各个簇中
# 3、 将各个簇中的数据求平均值，作为新的质心，重复上一步，直到所有的簇不再改变
1
2
3
4
5
6
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
from sklearn.linear_model import LinearRegression
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from sklearn.datasets.samples_generator import make_blobs
#  make_blobs聚类数据生成器

x,y_true = make_blobs(n_samples =300,    #生成300条数据
                     centers = 4,         #  四类数据
                     cluster_std = 0.5,    #  方差一致
                     random_state =0)
print(x[:5])
print(y_true[:5])
#  x（生成数据值）     y（生成数据值对应的类别标签）

plt.scatter(x[:,0],x[:,1],s = 10,alpha= 0.8)
plt.grid()
#  绘制图表
1
2
3
4
5
6
7
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=4)
kmeans.fit(x)
y_kmeans = kmeans.predict(x)
y_kmeans

plt.scatter(x[:,0],x[:,1],c = y_kmeans,cmap = "Dark2",s =50,alpha =0.5,marker = 'x')

三、PCA主要成分分析

将测量对象的群体按照相似性 和 相异性 进行不同群组的划分，划分后每个群组内部各对象相似度很高，而不同群组对象之间彼此相异度很高
回归 、 分类 —- 用于预测
聚类 — 产生一组集合，可用于降维（在没有因变量的前提下直接对数据进行降维）
取出保持原有信息的核心数据（效率很高）
其实是先降维，然后再从新的维度中根据贡献大小来提出主成分
1
2
3
4
5
6
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
from sklearn.linear_model import LinearRegression
1
2
3
4
5
6
7
8
9
10
11
12
#  二维数组降维
rng = np.random.RandomState(8)
data = np.dot(rng.rand(2,2),rng.randn(2,200))   #  矩阵相乘的方法
df = pd.DataFrame({'x1':data[:,0],
                  'x2':data[:,1]})
print(df.head())
print(df.shape)

plt.scatter(df['x1'],df['x2'],alpha = 0.8,marker ='.')
plt.axis('equal')
plt.grid()
# 生成图表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#  二维数据降维
#  构建模型，分析主成分

from sklearn.decomposition import PCA
# 加载主成分分析模块PCA

pca = PCA(n_components =1)   #  降为1维
pca.fit(df)   #  构建模型

print(pca.explained_variance_)  #  特征值
print(pca.components_)     # 特征向量
print(pca.n_components)   #  保留成分的个数

x_pca = pca.transform(df)
print(x_pca)
#  算出最后的结果

x_new = pca.inverse_transform(x_pca)
x_new
#  得到原来对的数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 多维数据降维
#  加载数据

from sklearn.datasets import load_digits
digits = load_digits()
#print(digits)
print(digits.keys())
print('数据长度为:%i条'% len(digits['data']))
print('数据形状为:',digits.data.shape)
print(digits.data[:2])
#  导入数据

pca = PCA(n_components =2)   #  降为2维
projected = pca.fit_transform(digits.data)
projected[:5]

plt.scatter(projected[:,0],projected[:,1],
           c = digits.target,edgecolor = 'none',alpha=0.8,
           cmap = 'Reds',s =5)
plt.axis('equal')
plt.grid()
plt.colorbar()
#  绘制二维数据图

四、线性回归理论概念

1
2
3
4
5
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
# 自变量可以是离散的，结果是连续的
# 区分好自变量和因变量
# 拟合数据
# 误差项和为0（均值为0），也就是说符合标准差的一个正态分布，但是拟合直线不要求完全服从，但是要求尽量趋近
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#  线性回归的python实现方法
#  简单线性回归（一元线性回归）

#  （1）  数据案例
from sklearn.linear_model import LinearRegression
#  导入线性回归模块

rang = np.random.RandomState(1)   #  随机数种子，对于一个随机数发生器，只要该种子一样，产生的随机数序列就是相同的
xtrain = 10 * rang.rand(30)
ytrain = 8 + 4 * xtrain + rang.rand(30)
#  y  = 8+ 4*x(大概的)

fig = plt.figure(figsize = (12,3))
ax1 = fig.add_subplot(1,2,1)
plt.scatter(xtrain,ytrain,marker = '.',color = 'k')
plt.grid()
#plt.title('样本数据散点图')
#  生成散点图

model = LinearRegression()  
model.fit(xtrain[:,np.newaxis],ytrain)      #  首先把x变成列形式的值

print(model.coef_)# 斜率
print(model.intercept_)

xtest = np.linspace(0,10,90)
ytest = model.predict(xtest[:,np.newaxis])

ax2 = fig.add_subplot(1,2,2)
plt.scatter(xtrain,ytrain,marker = '.',color = 'k')
plt.scatter(xtest,ytest,color = 'r',alpha = 0.2)
plt.grid()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
rng  = np.random.RandomState(5)
xtrain = 10 * rng.rand(150,4)
ytrain = 20 + np.dot(xtrain,[1.5,2,-4,3])
df = pd.DataFrame(xtrain,columns = ['b1','b2','b3','b4'])
df['y'] = ytrain

pd.plotting.scatter_matrix(df[['b1','b2','b3','b4']],figsize= (10,6),
                 diagonal = 'kde',
                 alpha = 0.5,
                 range_padding=0.1)
print(df.head())

#  四个变量相互独立

model = LinearRegression()  
model.fit(df[['b1','b2','b3','b4']],df['y'])  
#  多元回归拟合

print('斜率为:',model.coef_)
print('截距为:%.4f'%model.intercept_)
print('线性回归函数是：\ny = %.lfx1 + %.lfx2 + %.lfx3 +  %.lfx4 + %.lf'
     %(model.coef_[0],model.coef_[1],model.coef_[2],model.coef_[3],model.intercept_))
# 参数输出

五、线性回归模型的评估

1
2
3
4
5
6
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
from sklearn.linear_model import LinearRegression

SSE（和方差） ： 最后拟合数据和原始数据所对应点的误差的平方和,越接近于0，拟合越好，数据预测更准确均方差（SSE/N） 、 均方根(均方根的平方根)

R- square确定系数：
SSR（预测数据和原始数据均值之差的平方和）
SST（原始数据和均值之差的平方根）
SST = SSE +SSR
R- square = 1 - SSE/SST

越接近1，表明方程的变量对y的解释能力越强，这个模型对数据拟合的也比较好
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from sklearn import metrics

rang = np.random.RandomState(1)   #  随机数种子，对于一个随机数发生器，只要该种子一样，产生的随机数序列就是相同的
xtrain = 10 * rang.rand(30)
ytrain = 8 + 4 * xtrain + rang.rand(30)*3
#  创建数据

model = LinearRegression()  
model.fit(xtrain[:,np.newaxis],ytrain) 
#  多元回归拟合

ytest = model.predict(xtrain[:,np.newaxis])
mse =  metrics.mean_absolute_error(ytrain,ytest)
rmse = np.sqrt(mse)
print(mse)
print(rmse)

ssr = ((ytest-ytrain.mean())**2).sum()
sst = ((ytrain-ytrain.mean())**2).sum()
r2 = ssr/sst
r2  

r22 = model.score(xtrain[:,np.newaxis],ytrain)
print(r22)
print(r2)

六、蒙塔卡罗模拟

1
2
3
4
5
6
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
%matplotlib inline
from sklearn.linear_model import LinearRegression
# 随机抽样或统计实验方法
1、构造或描述概率过程
2、实现从已知概率分布抽样
3、建立各种估量值
随机采样上计算得到近似值，随着采样的增多，得到对的结果是正确结果的概率逐渐增大
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
n = 10000
r = 1.0
a,b = (0.0,0.0)

xmin,xmax = a-r,a+r
ymin,ymax = b-r,b+r

x = np.random.uniform(xmin,xmax,n)
y = np.random.uniform(ymin,ymax,n)

fig = plt.figure(figsize=(6,6))
axes = fig.add_subplot(1,1,1)
plt.plot(x,y,'ro',markersize=1)
plt.axis('equal')

d = np.sqrt((x-a)**2 + (y-b)**2)
res = sum(np.where(d<r,1,0))
pi = 4 * res /n
pi

from matplotlib.patches import Circle
circle = Circle(xy = (a,b),radius =r,alpha =0.5,color = 'gray')
axes.add_patch(circle)
plt.grid(True,linestyle = '--',linewidth = '0.8')
plt.show()