相关系数excel-数据分析简单例子

数据挖掘是一种技术，它将传统的数据分析方法与处理大量数据的复杂算法相结合。

数据挖掘是在大型数据存储库中，自动地发现有用信息的过程。数据挖掘技术用来探查大型数据库，发现先前未知的有用模式。

数据挖掘（Data mining）是一个跨学科的计算机科学分支。它是用人工智能、机器学习、统计学和数据库的交叉方法在相对较大型的数据集中发现模式的计算过程。

数据挖掘的基本任务

• 利用分类与预测、聚类分析、关联规则、时序模式、偏差检测、智能推荐等方法，帮助企业提取数据中蕴含的商业价值，提高企业的竞争力。

数据挖掘建模过程

• 定义挖掘目标、数据取样 、数据探索 、数据预处理、挖掘建模、模型评价

Python 数据挖掘相关扩展库

• Numpy 提供数组支持，以及相应的高效的处理函数
• Scipy 提供矩阵支持，以及矩阵相关
• Matplotlib 强大的数据可视化工具，作图库
• Pandas 强大、灵活的数据分析和探索工具
• StatsModels 统计建模和计量经济学，包括描述统计，统计模型估计和推断
• Scikit-Learn 支持回归、分类、聚类等强大的机器学习库
• Keras 深度学习库，用于建立神经网络以及深度学习模型（Anaconda Navigator）
• Gensim 用来做文本主题模型的库，文本挖掘可能用到
• Numpy 基本操作 (数组的操作）

import numpy as np

a= np.array([2,0,1,5])

print a,type(a)

print (a[:3])

print (a.min())

a.sort()

print (a)

b=np.array([[1,2,3],[4,5,6]])

print b

print (b*b)

print (b**2)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

[2 0 1 5]

[2 0 1]

0

[0 1 2 5]

[[1 2 3]

[4 5 6]]

[[ 1 4 9]

[16 25 36]]

[[ 1 4 9]

[16 25 36]]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• Scipy （矩阵预算，线性代数、积分、插值、FFT、信号处理、图像处理等的计算）

求解线性方程组和数值积分

from scipy.optimize import fsolve # 导入求解方程组的函数

def f(x):

x1=x[0]

x2=x[1]

return [2*x1-x2**2-1,x1**2-x2-2]

result=fsolve(f,[1,1])

print (result)

from scipy import integrate #导入积分函数

def g(x):

return (1-x**2)**0.5

pi_2,err=integrate.quad(g,-1,1)

print (pi_2*2),err

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

[ 1.91963957 1.68501606]

3.14159265359 1.00023567207e-09

• 1
• 2
• 3
• Matplotlib 作图的基本代码

import numpy as np

import matplotlib.pyplot as plt

x=np.linspace(0,10,1000) #作图的变量自变量

y=np.sin(x)+1

z=np.cos(x**2)+1

plt.figure(figsize=(8,4)) #设置图像大小

plt.plot(x,y,label='$ sin x+1 $',color='red',linewidth=2) #作图，设置标签、线条颜色，宽度

plt.plot(x,z,'b--',label='$cos x^2+1$')

plt.xlabel('Time(s) ')

plt.ylabel('Volt')

plt.title('A Simple Example')

plt.ylim(0,2.2)

plt.legend() #显示图例

plt.show()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

np.random.seed(1000)

y=np.random.standard_normal(20)

print y

x=range(len(y))

print x

plt.plot(x,y)

plt.plot(y.cumsum(),'b',lw=1.5)

plt.plot(y.cumsum(),'ro',lw=1.5)

plt.show()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

[-0.8044583 0.32093155 -0.02548288 0.64432383 -0.30079667 0.38947455

-0.1074373 -0.47998308 0.5950355 -0.46466753 0.66728131 -0.80611561

-1.19606983 -0.40596016 -0.18237734 0.10319289 -0.13842199 0.70569237

1.27179528 -0.98674733]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

• 1
• 2
• 3
• 4
• 5
• 6

np.random.seed(2000)

#y1=np.random.standard_normal((20,2))

y=np.random.standard_normal((20,2)).cumsum(axis=0)

print y

plt.figure(figsize=(9,4))

plt.subplot(121)

plt.plot(y[:,0],lw=1.5,label='1st')

plt.plot(y[:,0],'ro')

plt.grid(True)

plt.legend(loc=0)

plt.axis('tight')

plt.xlabel('index')

plt.ylabel('value')

plt.title('1st Data Set')

plt.subplot(122)

plt.bar(np.arange(len(y)),y[:,1],width=0.5,color='g',label='2nd')

plt.grid(True)

plt.legend(loc=0)

plt.axis('tight')

plt.xlabel('index')

plt.ylabel('value')

plt.title('2st Data Set')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

[[ 1.73673761 1.89791391]

[-0.37003581 1.74900181]

[ 0.21302575 -0.51023122]

[ 0.35026529 -1.21144444]

[-0.27051479 -1.6910642 ]

[ 0.93922398 -2.76624806]

[ 1.74614319 -3.05703153]

[ 1.52519555 -3.22618757]

[ 2.62602999 -3.14367705]

[ 2.6216544 -4.8662353 ]

[ 3.67921082 -7.38414811]

[ 1.7685707 -6.07769276]

[ 2.19296834 -6.54686084]

[ 1.18689581 -7.46878388]

[ 1.81330034 -7.11160718]

[ 1.79458178 -6.89043591]

[ 2.49318589 -6.05592589]

[ 0.82754806 -8.95736573]

[ 0.77890953 -9.00274406]

[ 2.25424343 -9.51643749]]

Text(0.5,1,u'2st Data Set')

• 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

• pandas 的简单例子 (数据的读取、处理和探索) series(类似一维数组） dataFrame（相当于一张二维的表格，每一列都是一个Series）

import numpy as np

import pandas as pd

df=pd.DataFrame([10,20,30,40],columns=['numbers'],index=['a','b','c','d'])

df

• 1
• 2
• 3
• 4

numbersa10b20c30d40

df.index

• 1

Index([u'a', u'b', u'c', u'd'], dtype='object')

• 1
• 2

df.columns

• 1

Index([u'numbers'], dtype='object')

• 1
• 2

print df.ix['c']

print df.ix[['a','d']]

print df.ix[df.index[1:3]]

print df.sum()

print df.apply(lambda x:x**2)

• 1
• 2
• 3
• 4
• 5

numbers 30

Name: c, dtype: int64

numbers

a 10

d 40

numbers

b 20

c 30

numbers 100

dtype: int64

numbers

a 100

b 400

c 900

d 1600

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

df['floats']=(1.5,2.5,3.5,4.5)

df

• 1
• 2

numbersfloatsa101.5b202.5c303.5d404.5

df['names']=pd.DataFrame(['Yves','Guido','Feild','Fance'],index=['a','b','c','d'])

print df

df=df.append(pd.DataFrame({'numbers':100,'floats':5.75,'names':'Henry'},index=['Z']))

print df

• 1
• 2
• 3
• 4

numbers floats names

a 10 1.5 Yves

b 20 2.5 Guido

c 30 3.5 Feild

d 40 4.5 Fance

floats names numbers

a 1.50 Yves 10

b 2.50 Guido 20

c 3.50 Feild 30

d 4.50 Fance 40

Z 5.75 Henry 100

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

df['floats']['a']

• 1

1.5

• 1
• 2

type(df)

• 1

pandas.core.frame.DataFrame

• 1
• 2

df['numbers']

• 1

a 10

b 20

c 30

d 40

Z 100

Name: numbers, dtype: int64

• 1
• 2
• 3
• 4
• 5
• 6
• 7

type(df['numbers'])

• 1

pandas.core.series.Series

• 1
• 2

import matplotlib.pyplot as plt

df['numbers'].cumsum().plot(style='r',lw=2.) #画numbers这列的累加图形

plt.xlabel('date')

plt.ylabel('value')

plt.show()

• 1
• 2
• 3
• 4
• 5

import pandas as pd #Series和DataFrame数据结构

s=pd.Series([1,2,3],index=['a','b','c'])

print s

d=pd.DataFrame([[1,2,3],[4,5,6]],columns=['a','b','c'])

print d

d2=pd.DataFrame(s)

print d2

print d.head()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

a 1

b 2

c 3

dtype: int64

a b c

0 1 2 3

1 4 5 6

0

a 1

b 2

c 3

a b c

0 1 2 3

1 4 5 6

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• StatsModels 注重数据的统计建模分析，使pytohn有R语言的味道， StatsModels支持与pandas进行数据交互，强大的数据挖掘组合

from statsmodels.tsa.stattools import adfuller as ADF

from pandas.core import datetools

import numpy as np

ADF(np.random.rand(100)) #返回的结果是ADF值和p值 单位根和概率值

• 1
• 2
• 3
• 4
• 5

(-11.253758305760554,

1.6868652157937374e-20,

0L,

99L,

{'1%': -3.4981980821890981,

'10%': -2.5825959973472097,

'5%': -2.8912082118604681},

31.149412019471782)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• Scilit-Learn包括数据预处理、分类与预测、回归、聚类和模型分析

from sklearn import datasets #导入数据集

iris=datasets.load_iris() #加载数据集

print(iris.data.shape)

from sklearn import svm #建立线性SVM分类器

clf=svm.LinearSVC()#建立线性SVM分类器

clf.fit(iris.data,iris.target)# 用数据训练模型

clf.predict([[5.0,3.6,1.5,0.25]])#训练好模型之后，输入新的数据进行预测

clf.coef_ #训练好模型的参数

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

(150L, 4L)

array([[ 0.18424073, 0.451224 , -0.80793865, -0.45071743],

[ 0.0533189 , -0.89005676, 0.40352144, -0.93828342],

[-0.85072726, -0.98671105, 1.38088737, 1.86538905]])

• 1
• 2
• 3
• 4
• 5
• 6
• Keras 搭建神经网络 自编码器、循环神经网络、递归神经网络、卷积神经网络
• Gensim 处理语言方面的任务，如文本相似度计算、word2Vec等

数据探索

通过检验数据集的数据质量、绘制图表、计算某些特征量等手段，对样本数据集的结构和规律进行分析的过程。

有助于选择合适的数据预处理和建模方法。

数据质量分析

缺失值、异常值、不一致的值、重复数据及含有特殊符号的数据（#、￥、*）

缺失值的处理

• 缺失值产生的原因
• 1、信息暂时无法获取，或者信息获取代价太大
• 2、信息被遗漏
• 3、属性值不存在
• 缺失值的影响
• 数据挖掘建模将丢失大量有用信息； 数据挖掘模型表现出的不确定性更加显著，规律难把握；包含空值的数据建模，导致不可靠的输出。
• 缺失值分析
• 统计分析的方法，可以得到含有缺失值属性的个数。 删除记录、插补、不处理

异常值分析

简单统计量分析（最大值，最小值）、箱形图分析

import pandas as pd

catering_sale='data3/catering_sale.xls' #餐饮数据

data=pd.read_excel(catering_sale,index_col=u'日期') #日期列为索引列

data.head()

• 1
• 2
• 3
• 4

销量日期2015-03-0151.02015-02-282618.22015-02-272608.42015-02-262651.92015-02-253442.1

data.describe()

• 1

销量count200.000000mean2755.214700std751.029772min22.00000025%2451.97500050%2655.85000075%3026.125000max9106.440000

import pandas as pd

catering_sale = 'data3/catering_sale.xls' #餐饮数据

data = pd.read_excel(catering_sale, index_col = u'日期') #读取数据，指定“日期”列为索引列

import matplotlib.pyplot as plt #导入图像库

plt.figure() #建立图像

p = data.boxplot(return_type='dict') #画箱线图，直接使用DataFrame的方法

x = p['fliers'][0].get_xdata() # 'flies'即为异常值的标签

y = p['fliers'][0].get_ydata()

y.sort() #从小到大排序，该方法直接改变原对象

#用annotate添加注释

#其中有些相近的点，注解会出现重叠，难以看清，需要一些技巧来控制。

for i in range(len(x)):

if i>0:

plt.annotate(y[i], xy = (x[i],y[i]), xytext=(x[i]+0.05 -0.8/(y[i]-y[i-1]),y[i]))

else:

plt.annotate(y[i], xy = (x[i],y[i]), xytext=(x[i]+0.08,y[i]))

plt.show() #展示箱线图

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

数据特征分析

分布分析（定量数据的分布分析,定性数据的分布分析）、对比分析、统计量分析、周期性分析、贡献度分析、相关性分析，了解数据的规律和趋势，为数据挖掘的后续环节提供支持。

统计量分析：集中趋势度量（均值、中位数、众数）；离中趋势度量（极差、标准差、变异系数、四分位间距）；

# 统计量分析

import pandas as pd

catering_sale = 'data3/catering_sale.xls' #餐饮数据

data = pd.read_excel(catering_sale, index_col = u'日期') #读取数据，指定“日期”列为索引列

data = data[(data[u'销量'] > 400)&(data[u'销量'] < 5000)] #过滤异常数据

statistics = data.describe() #保存基本统计量

statistics.loc['range'] = statistics.loc['max']-statistics.loc['min'] #极差 最大值减最小值

statistics.loc['var'] = statistics.loc['std']/statistics.loc['mean'] #变异系数 比较两个或多个具有不同单位或波动幅度的数据集的离中趋势

statistics.loc['dis'] = statistics.loc['75%']-statistics.loc['25%'] #四分位数间距 值越大说明变异程度越大

print(statistics)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

销量

count 195.000000

mean 2744.595385

std 424.739407

min 865.000000

25% 2460.600000

50% 2655.900000

75% 3023.200000

max 4065.200000

range 3200.200000

var 0.154755

dis 562.600000

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

贡献度分析：A1-A7总盈利占85%

import pandas as pd

#初始化参数

dish_profit = 'data3/catering_dish_profit.xls' #餐饮菜品盈利数据

data = pd.read_excel(dish_profit, index_col = u'菜品名')

data = data[u'盈利'].copy()

data.sort_values(ascending = False)

import matplotlib.pyplot as plt #导入图像库

plt.figure()

data.plot(kind='bar')

plt.ylabel(u'盈利（元）')

p = 1.0*data.cumsum()/data.sum()

p.plot(color = 'r', secondary_y = True, style = '-o',linewidth = 2)

plt.annotate(format(p[6], '.4%'), xy = (6, p[6]), xytext=(6*0.9, p[6]*0.9), arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2")) #添加注释，即85%处的标记。这里包括了指定箭头样式。

plt.ylabel(u'盈利（比例）')

plt.show()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

相关性分析：相关系数

r=∑

n

i=1

(x

i

−x

¯

)(y

i

−y

¯

)

∑

n

i=1

(x

i

−x

¯

)

2

∑

n

i=1

(y

i

−y

¯

)

2

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

−

√

r=∑i=1n(xi−x¯)(yi−y¯)∑i=1n(xi−x¯)2∑i=1n(yi−y¯)2

import pandas as pd

catering_sale = 'data3/catering_sale_all.xls' #餐饮数据，含有其他属性

data = pd.read_excel(catering_sale, index_col = u'日期')

print data.head()

data.corr() #相关系数矩阵，即给出了任意两款菜式之间的相关系数

print data.corr()[u'百合酱蒸凤爪'] #只显示“百合酱蒸凤爪”与其他菜式的相关系数

print data[u'百合酱蒸凤爪'].corr(data[u'翡翠蒸香茜饺']) #计算“百合酱蒸凤爪”与“翡翠蒸香茜饺”的相关系数

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

百合酱蒸凤爪 翡翠蒸香茜饺 金银蒜汁蒸排骨 乐膳真味鸡 蜜汁焗餐包 生炒菜心 铁板酸菜豆腐 香煎韭菜饺 香煎罗卜糕

日期

2015-01-01 17 6 8 24 13.0 13 18 10 10

2015-01-02 11 15 14 13 9.0 10 19 13 14

2015-01-03 10 8 12 13 8.0 3 7 11 10

2015-01-04 9 6 6 3 10.0 9 9 13 14

2015-01-05 4 10 13 8 12.0 10 17 11 13

原汁原味菜心

日期

2015-01-01 27

2015-01-02 13

2015-01-03 9

2015-01-04 13

2015-01-05 14

百合酱蒸凤爪 1.000000

翡翠蒸香茜饺 0.009206

金银蒜汁蒸排骨 0.016799

乐膳真味鸡 0.455638

蜜汁焗餐包 0.098085

生炒菜心 0.308496

铁板酸菜豆腐 0.204898

香煎韭菜饺 0.127448

香煎罗卜糕 -0.090276

原汁原味菜心 0.428316

Name: 百合酱蒸凤爪, dtype: float64

0.00920580305184

• 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

数据预处理

数据预处理占到60%， 数据清洗、数据集成（属性冗余问题），数据变换、数据规约。

数据清洗主要包括：缺失值处理（均值、中位数、众数插补，最近临插补、回归方法、插值法）、异常值处理（删除、视为缺失值、平均值修正）。

y=a

0

+a

1

x+a

2

x

2

+...+a

n−1

x

n−1

y=a0+a1x+a2x2+...+an−1xn−1

lagrange插值法：

#拉格朗日插值代码

#拉格朗日插值代码

import pandas as pd #导入数据分析库Pandas

from scipy.interpolate import lagrange #导入拉格朗日插值函数

inputfile = 'data4/catering_sale.xls' #销量数据路径

outputfile = './sales.xls' #输出数据路径

data = pd.read_excel(inputfile) #读入数据

#data[u'销量'][(data[u'销量'] < 400) | (data[u'销量'] > 5000)] = None #过滤异常值，将其变为空值

row_indexs = (data[u'销量'] < 400) | (data[u'销量'] > 5000) #得到过滤数据的索引

data.loc[row_indexs,u'销量'] = None #过滤数据

#自定义列向量插值函数

#s为列向量，n为被插值的位置，k为取前后的数据个数，默认为5

def ployinterp_column(s, n, k=5):

y = s[list(range(n-k, n)) + list(range(n+1, n+1+k))] #取数

y = y[y.notnull()] #剔除空值

return lagrange(y.index, list(y))(n) #插值并返回拉格朗日插值结果

#逐个元素判断是否需要插值

for i in data.columns:

for j in range(len(data)):

if (data[i].isnull())[j]: #如果为空即插值。

# data[i][j] = ployinterp_column(data[i], j)

data.loc[j,i] = ployinterp_column(data[i], j)

data.to_excel(outputfile) #输出结果，写入文件

• 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

数据归一化：

#数据规范化

import pandas as pd

import numpy as np

datafile = 'data4/normalization_data.xls' #参数初始化

data = pd.read_excel(datafile, header = None) #读取数据

(data - data.min())/(data.max() - data.min()) #最小-最大规范化

(data - data.mean())/data.std() #零-均值规范化

data/10**np.ceil(np.log10(data.abs().max())) #小数定标规范化

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

012300.0780.5210.6020.286310.144-0.600-0.5210.224520.095-0.4570.468-0.128330.0690.5960.6950.105440.1900.5270.6910.205150.1010.4030.4700.248760.1460.4130.4350.2571

连续属性离散化：

等宽离散化: 将属性的值域分成相同宽度的区间

等频离散化：间相同数量的记录放进每个区间

基于聚类

#-*- coding: utf-8 -*-

import pandas as pd

datafile = 'data4/discretization_data.xls' #参数初始化

data = pd.read_excel(datafile) #读取数据

data = data[u'肝气郁结证型系数'].copy()

print data.head(10)

k = 4

#等宽离散化

d1 = pd.cut(data, k, labels = range(k)) #等宽离散化，各个类比依次命名为0,1,2,3

#等频率离散化

w = [1.0*i/k for i in range(k+1)] #[0.0, 0.25, 0.5, 0.75, 1.0]

w = data.describe(percentiles = w)[4:4+k+1] #使用describe函数自动计算分位数

w[0] = w[0]*(1-1e-10)

d2 = pd.cut(data, w, labels = range(k))

from sklearn.cluster import KMeans #引入KMeans

kmodel = KMeans(n_clusters = k, n_jobs = 4) #建立模型，n_jobs是并行数，一般等于CPU数较好

kmodel.fit(data.values.reshape((len(data), 1))) #训练模型

c = pd.DataFrame(kmodel.cluster_centers_).sort_values(0) #输出聚类中心，并且排序（默认是随机序的）

w = c.rolling(window=2,center=False).mean().iloc[1:] #相邻两项求中点，作为边界点

#w = pd.DataFrame.rolling(window=2,center=False).mean()

w = [0] + list(w[0]) + [data.max()] #把首末边界点加上

d3 = pd.cut(data, w, labels = range(k))

def cluster_plot(d, k): #自定义作图函数来显示聚类结果

import matplotlib.pyplot as plt

plt.figure(figsize = (8, 3))

for j in range(0, k):

plt.plot(data[d==j], [j for i in d[d==j]], 'o')

plt.ylim(-0.5, k-0.5)

return plt

cluster_plot(d1, k).show()

cluster_plot(d2, k).show()

cluster_plot(d3, k).show()

• 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
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42

0 0.056

1 0.488

2 0.107

3 0.322

4 0.242

5 0.389

6 0.246

7 0.330

8 0.257

9 0.205

Name: 肝气郁结证型系数, dtype: float64

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

#主成分分析 降维

import pandas as pd

#参数初始化

inputfile = 'data4/principal_component.xls'

outputfile = './dimention_reducted.xls' #降维后的数据

data = pd.read_excel(inputfile, header = None) #读入数据

from sklearn.decomposition import PCA

pca = PCA()

pca.fit(data)

print pca.components_ #返回模型的各个特征向量

print pca.explained_variance_ratio_ #返回各个成分各自的方差百分比

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

[[ 0.56788461 0.2280431 0.23281436 0.22427336 0.3358618 0.43679539

0.03861081 0.46466998]

[ 0.64801531 0.24732373 -0.17085432 -0.2089819 -0.36050922 -0.55908747

0.00186891 0.05910423]

[-0.45139763 0.23802089 -0.17685792 -0.11843804 -0.05173347 -0.20091919

-0.00124421 0.80699041]

[-0.19404741 0.9021939 -0.00730164 -0.01424541 0.03106289 0.12563004

0.11152105 -0.3448924 ]

[-0.06133747 -0.03383817 0.12652433 0.64325682 -0.3896425 -0.10681901

0.63233277 0.04720838]

[ 0.02579655 -0.06678747 0.12816343 -0.57023937 -0.52642373 0.52280144

0.31167833 0.0754221 ]

[-0.03800378 0.09520111 0.15593386 0.34300352 -0.56640021 0.18985251

-0.69902952 0.04505823]

[-0.10147399 0.03937889 0.91023327 -0.18760016 0.06193777 -0.34598258

-0.02090066 0.02137393]]

[ 7.74011263e-01 1.56949443e-01 4.27594216e-02 2.40659228e-02

1.50278048e-03 4.10990447e-04 2.07718405e-04 9.24594471e-05]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

pca=PCA(3)

pca.fit(data)

low_d=pca.transform(data)

low_d

• 1
• 2
• 3
• 4

array([[ 8.19133694, 16.90402785, 3.90991029],

[ 0.28527403, -6.48074989, -4.62870368],

[-23.70739074, -2.85245701, -0.4965231 ],

[-14.43202637, 2.29917325, -1.50272151],

[ 5.4304568 , 10.00704077, 9.52086923],

[ 24.15955898, -9.36428589, 0.72657857],

[ -3.66134607, -7.60198615, -2.36439873],

[ 13.96761214, 13.89123979, -6.44917778],

[ 40.88093588, -13.25685287, 4.16539368],

[ -1.74887665, -4.23112299, -0.58980995],

[-21.94321959, -2.36645883, 1.33203832],

[-36.70868069, -6.00536554, 3.97183515],

[ 3.28750663, 4.86380886, 1.00424688],

[ 5.99885871, 4.19398863, -8.59953736]])

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

挖掘建模

分类与预测（回归分析、决策树（ID3）、神经网络、贝叶斯网络、支持向量机）

聚类分析

关联规则（Apriori）

时序模式

偏差检测

ID3算法核心是在决策树的各级节点上，使用信息增益方法作为属性的选择标准，来帮助确定生成每个节点时所采用的合适属性。

I(s

1

,s

2

,...,s

m

)=−∑

i=1

m

P

i

log

2

(P

i

)

I(s1,s2,...,sm)=−∑i=1mPilog2(Pi)

m表示属性值的个数，s

i

si 是某个属性值的样本个数, P

i

Pi 可以用 s

i

S

siS,S是s样本数据的集合。

总信息熵：销售数量高的数据18，低的数据16, I(18,16)=−18

34

log

2

18

34

−16

34

log

2

16

34

I(18,16)=−1834log21834−1634log21634

是否周末属性：是的条件下，销售高的记录11，低为3，表示（11，3）；不是的条件下，销售高记录7，低为13，表示（7，13）；

是否周末的属性的信息熵增益：I(18,16)−(14

34

I(11,3)+20

34

I(7,13))

I(18,16)−(1434I(11,3)+2034I(7,13))

#使用ID3决策树算法预测销量高低

import pandas as pd

#参数初始化

inputfile = 'data5/sales_data.xls'

data = pd.read_excel(inputfile, index_col = u'序号') #导入数据

print data.head()

#数据是类别标签，要将它转换为数据

#用1来表示“好”、“是”、“高”这三个属性，用-1来表示“坏”、“否”、“低”

data[data == u'好'] = 1

data[data == u'是'] = 1

data[data == u'高'] = 1

data[data != 1] = -1

print data.head()

x = data.iloc[:,:3].as_matrix().astype(int) #前三个属性的矩阵

y = data.iloc[:,3].as_matrix().astype(int) #销量的矩阵

from sklearn.tree import DecisionTreeClassifier as DTC

dtc = DTC(criterion='entropy') #建立决策树模型，基于信息熵

dtc.fit(x, y) #训练模型

#导入相关函数，可视化决策树。

#导出的结果是一个dot文件，需要安装Graphviz才能将它转换为pdf或png等格式。

from sklearn.tree import export_graphviz

x = pd.DataFrame(x)

from sklearn.externals.six import StringIO

x = pd.DataFrame(x)

with open("tree.dot", 'w') as f:

f = export_graphviz(dtc, feature_names = x.columns, out_file = f)

• 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

天气 是否周末 是否有促销 销量

序号

1 坏 是 是 高

2 坏 是 是 高

3 坏 是 是 高

4 坏 否 是 高

5 坏 是 是 高

天气 是否周末 是否有促销 销量

序号

1 -1 1 1 1

2 -1 1 1 1

3 -1 1 1 1

4 -1 -1 1 1

5 -1 1 1 1

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

value=[0,6]代表0个低，6个高

Apriori算法： 找最大K项频繁集 没一项的支持度 p（a）=7/10, 支持度为0.2（支持度计数为2）

#使用Apriori算法挖掘菜品订单关联规则

import pandas as pd

from apriori import * #apriori函数

inputfile = 'data5/menu_orders.xls'

outputfile = './apriori_rules.xls' #结果文件

data = pd.read_excel(inputfile, header = None)

print data.head(11)

print(u'n转换原始数据至0-1矩阵...')

ct = lambda x : pd.Series(1, index = x[pd.notnull(x)]) #转换0-1矩阵的过渡函数

b = map(ct, data.as_matrix()) #用map方式执行

data = pd.DataFrame(list(b)).fillna(0) #实现矩阵转换，空值用0填充

print(u'n转换完毕。')

del b #删除中间变量b，节省内存

support = 0.2 #最小支持度 同时发生的概率

confidence = 0.5 #最小置信度 A发生则B发生的概率

ms = '---' #连接符，默认'--'，用来区分不同元素，如A--B。需要保证原始表格中不含有该字符

find_rule(data, support, confidence, ms).to_excel(outputfile) #保存结果

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

0 1 2 3

0 a c e NaN

1 b d NaN NaN

2 b c NaN NaN

3 a b c d

4 a b NaN NaN

5 b c NaN NaN

6 a b NaN NaN

7 a b c e

8 a b c NaN

9 a c e NaN

转换原始数据至0-1矩阵...

转换完毕。

正在进行第1次搜索...

数目：6...

正在进行第2次搜索...

数目：3...

正在进行第3次搜索...

数目：0...

结果为：

support confidence

e---a 0.3 1.000000

e---c 0.3 1.000000

c---e---a 0.3 1.000000

a---e---c 0.3 1.000000

a---b 0.5 0.714286

c---a 0.5 0.714286

a---c 0.5 0.714286

c---b 0.5 0.714286

b---a 0.5 0.625000

b---c 0.5 0.625000

b---c---a 0.3 0.600000

a---c---b 0.3 0.600000

a---b---c 0.3 0.600000

a---c---e 0.3 0.600000