《python数据挖掘》实战篇

第6章：分类-窃电用户自动识别

 目标

  模型构建LM-NET和CART

   数据划分

        LM神经网络

       cart决策树

  模型评价ROC

第7章：聚类-航空公司客户价值分析

1RFM模型-传统

目标

    1分析方法与过程-数据预处理

    2构建kmeans模型（无代码：参考模型章节

第8章：关联规则-中医证型挖掘

目标：

过程

   属性离散化

模型-关联规则有问题-

第9章：分类-基于水色图像的水质评价

Svm模型

第10章 ：家用电器用户行为分析与时间识别

目标

过程

    1数据抽取：无放回随机抽样法

    2探索分析

    3数据预处理

    4构建专家样本：找资料进行合适的数据构造

模型

    阈值寻优模型

    用水事件的划分-阈值处理

    洗浴识别模型-BP神经网络分类

    模型检验-准确率

第11章 ：时间序列-应用系统负载分析与容量预测

目标

分析

    探索分析：周期性分析

数据预处理

    容量预测模型

    平稳性检验：

    白噪声检验：

            AIC定阶

    模型检验

    模型预测

模型评价与应用

第12章 ：电子商务网站用户行为分析及服务推荐（基于协同过滤算法）

https://blog.csdn.net/u012063773/article/details/79324194

目的

数据探索

    导入sql数据

    网页类型统计

数据预处理

模型构建-具体参考链接网页

第13章 ：预测-财政收入影响因素分析及预测模型

目标

数据探索分析

数据预处理

模型

    变量选择模型lasso或者AdaptiveLasso

    灰色预测与神经网络的组合模型

第14章 ：层次聚类-基于基站定位数据的商圈分析

目标

探索分析

模型-层次聚类

    1、 谱聚类

    2层次聚类

第15章：电商产品评论数据情感分析代码详解目标

数据预处理

    2文本去重

    4结巴分词

模型-LDA

 

第6章：分类-窃电用户自动识别

目标

归纳出窃漏电用户的关键特征，构建窃漏电用户的识别模型；

利用实时监测数据，调用窃漏电用户识别模型实现实时诊断。

先按照前面的几章节处理数据

模型构建LM-NET和CART

数据划分

import pandas as pd
from random import shuffle

datafile = '../data/model.xls'
data = pd.read_excel(datafile)
data = data.as_matrix()
shuffle(data)

p = 0.8 #设置训练数据比例
train = data[:int(len(data)*p),:]
test = data[int(len(data)*p):,:]

LM神经网络

from keras.models import Sequential #导入神经网络初始化函数
from keras.layers.core import Dense, Activation #导入神经网络层函数、激活函数

net = Sequential() #建立神经网络
net.add(Dense(10,input_dim=3)) #添加输入层（3节点）到隐藏层（10节点）的连接
net.add(Activation('relu')) #隐藏层使用relu激活函数
net.add(Dense(1,input_dim=10)) #添加隐藏层（10节点）到输出层（1节点）的连接
net.add(Activation('sigmoid')) #输出层使用sigmoid激活函数
net.compile(loss = 'binary_crossentropy', optimizer = 'adam') #, class_mode = "binary"编译模型，使用adam方法求解

net.fit(train[:,:3], train[:,3], epochs=1000, batch_size=1) #训练模型，循环1000次
netfile = '../tmp/net1.model' #构建的神经网络模型存储路径
net.save_weights(netfile) #保存模型

predict_result = net.predict_classes(train[:,:3]).reshape(len(train)) #预测结果变形
'''这里要提醒的是，keras用predict给出预测概率，predict_classes才是给出预测类别，而且两者的预测结果都是n x 1维数组，而不是通常的 1 x n'''

from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(train[:,3], predict_result).show() #显示混淆矩阵可视化结果

cart决策树

#构建CART决策树模型
from sklearn.tree import DecisionTreeClassifier #导入决策树模型
tree = DecisionTreeClassifier() #建立决策树模型
tree.fit(train[:,:3], train[:,3]) #训练
#保存模型
from sklearn.externals import joblib
joblib.dump(tree,  '../tmp/tree.pkl')#模型持久化的操作，导入joblib即
predict_result=tree.predict(train[:,:3])#注意到Scikit-Learn使用predict方法直接给出预测结果。

 

模型评价ROC

from sklearn.metrics import roc_curve #导入ROC曲线函数
fpr, tpr, thresholds = roc_curve(test[:,3], predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label = 'ROC of CART', color = 'green') #作出ROC曲线
plt.xlabel('False Positive Rate') #坐标轴标签
plt.ylabel('True Positive Rate') #坐标轴标签
plt.ylim(0,1.05) #边界范围
plt.xlim(0,1.05) #边界范围
plt.legend(loc=4) #图例位置
plt.show() #显示作图结果

 

 

第7章：聚类-航空公司客户价值分析

1RFM模型-传统

广泛用于分析客户价值的是RFM模型，它是通过三个指标（最近消费时间间隔(Recency)、消费频率(Frequency)、消费金额(Monetary)）来进行客户细分，识别出高价值的客户。

目标

借助航空公司客户数据，对客户进行分类；

对不同的客户类别进行特征分析，比较不同类客户的客户价值；

对不同价值的客户类别提供个性化服务，制定相应的营销策略。

 

1分析方法与过程-数据预处理

初步分析：提出适用航空公司的LRFMC模型

因消费金额指标在航空公司中不适用，故选择客户在一定时间内累积的飞行里程M和客户乘坐舱位折扣系数的平均值C两个指标代替消费金额。此外，考虑航空公司会员加入时间在一定程度上能够影响客户价值，所以在模型中增加客户关系长度L，作为区分客户的另一指标，因此构建出LRFMC模型。

 

采用聚类的方法对客户进行细分，并分析每个客户群的特征，识别其客户价值。

1数据探索describe（代码省略）

2数据清洗：选取需要的特征

#选择需要的数据
data = data[data['SUM_YR_1'].notnull()&data['SUM_YR_2'].notnull()] #丢弃票价为空的记录
#丢弃票价为零，或者平均折扣率与总飞行公里数不0的记录。
index1 = data['SUM_YR_1'] != 0#只保留票价非零的，或者平均折扣率与总飞行公里数同时为0的记录。
index2 = data['SUM_YR_2'] != 0
index3 = (data['SEG_KM_SUM'] == 0) & (data['avg_discount'] == 0) #该规则是“与”
data = data[index1 | index2 | index3] #该规则是“或”

3属性规约：原始数据中属性太多，根据LRFMC模型，选择与其相关的六个属性，删除不相关、弱相关或冗余的属性。

4、数据变换

（1）属性构造

L = LOAD_TIME - FFP_DATE

会员入会时间距观测窗口结束的月数 = 观测窗口的结束时间 - 入会时间[单位：月

R = LAST_TO_END

客户最近一次乘坐公司飞机距观测窗口结束的月数 = 最后一次乘机时间至观察窗口末端时长[单位：月]

F = FLIGHT_COUNT

客户在观测窗口内乘坐公司飞机的次数 = 观测窗口的飞行次数[单位：次]

M = SEG_KM_SUM

客户在观测时间内在公司累计的飞行里程 = 观测窗口总飞行公里数[单位：公里]

C = AVG_DISCOUNT

客户在观测时间内乘坐舱位所对应的折扣系数的平均值 = 平均折扣率[单位：无]

 

（2）数据标准化

2构建kmeans模型（无代码：参考模型章节

客户K-Means聚类-客户价值分析-模型应用

第8章：关联规则-中医证型挖掘

目标：

借助三阴乳腺癌患者的病理信息，挖掘患者的症状与中医证型之间的关联关系；

对截断治疗提供依据，挖掘潜性证素。

过程

数据收集-数据清洗-

数据规约：删除不相关属性，选取其中六种证型得分、患者编号和TNM分期属性。

数据变换：

（1）属性构造：为了更好的反应出中医证素分布的特征，采用证型系数代替具体单证型的证素得分，证型相关系数计算公式如下：证型系数 = 该证型得分／该证型总分

（2）属性离散化

Aprior关联规则无法处理连续型变量，需要聚类进行离散化处理

#-*- coding: utf-8 -*-
'''
聚类离散化，最后的result的格式为：
      1           2           3           4
A     0    0.178698    0.257724    0.351843
An  240  356.000000  281.000000   53.000000
即(0, 0.178698]有240个，(0.178698, 0.257724]有356个，依此类推。
'''
import pandas as pd
from sklearn.cluster import KMeans #导入K均值聚类算法

datafile = '../data/data.xls' #待聚类的数据文件
processedfile = '../tmp/data_processed.xls' #数据处理后文件
typelabel ={u'肝气郁结证型系数':'A', u'热毒蕴结证型系数':'B', u'冲任失调证型系数':'C', u'气血两虚证型系数':'D', u'脾胃虚弱证型系数':'E', u'肝肾阴虚证型系数':'F'}
k = 4 #需要进行的聚类类别数

#读取数据并进行聚类分析
data = pd.read_excel(datafile) #读取数据
keys = list(typelabel.keys())#标题6个类别变成列表
result = pd.DataFrame()

if __name__ == '__main__': #判断是否主窗口运行，如果是将代码保存为.py后运行，则需要这句，如果直接复制到命令窗口运行，则不需要这句。
  for i in range(len(keys)):
    #调用k-means算法，进行聚类离散化
    print(u'正在进行“%s”的聚类...' % keys[i])
    kmodel = KMeans(n_clusters = k, n_jobs = 4) #n_jobs是并行数，一般等于CPU数较好
    kmodel.fit(data[[keys[i]]].as_matrix()) #训练模型
    
    r1 = pd.DataFrame(kmodel.cluster_centers_, columns = [typelabel[keys[i]]]) #聚类中心
    r2 = pd.Series(kmodel.labels_).value_counts() #分类统计
    r2 = pd.DataFrame(r2, columns = [typelabel[keys[i]]+'n']) #转为DataFrame，记录各个类别的数目
    r = pd.concat([r1, r2], axis = 1).sort(typelabel[keys[i]]) #匹配聚类中心和类别数目
    r.index = [1, 2, 3, 4]
    
    r[typelabel[keys[i]]] = pd.rolling_mean(r[typelabel[keys[i]]], 2) #rolling_mean()用来计算相邻2列的均值，以此作为边界点。
    r[typelabel[keys[i]]][1] = 0.0 #这两句代码将原来的聚类中心改为边界点。
    result = result.append(r.T)

  result = result.sort() #以Index排序，即以A,B,C,D,E,F顺序排
  result.to_excel(processedfile)

 

模型-关联规则有问题-

#-*- coding: utf-8 -*-
from __future__ import print_function
import pandas as pd
from apriori import * #导入自行编写的apriori函数
import time #导入时间库用来计算用时

inputfile = '../data/apriori.txt' #输入事务集文件
data = pd.read_csv(inputfile, header=None, dtype = object)

start = time.clock() #计时开始
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(b).fillna(0) #实现矩阵转换，空值用0填充
end = time.clock() #计时结束
print(u'\n转换完毕，用时：%0.2f秒' %(end-start))
del b #删除中间变量b，节省内存

support = 0.06 #最小支持度
confidence = 0.75 #最小置信度
ms = '---' #连接符，默认'--'，用来区分不同元素，如A--B。需要保证原始表格中不含有该字符

start = time.clock() #计时开始
print(u'\n开始搜索关联规则...')
find_rule(data, support, confidence, ms)
end = time.clock() #计时结束
print(u'\n搜索完成，用时：%0.2f秒' %(end-start))

第9章：分类-基于水色图像的水质评价

图像特征：颜色，纹理，形状，空间，颜色有鲁棒性，本案例水色图样均匀看颜色

颜色特征：颜色直方图法、颜色矩

图像切割

特征提取：三阶分别表示：明暗，颜色分布范围，分布的对称性

构建模型：LM水质评价分类模型

Svm模型

#-*- coding: utf-8 -*-
import pandas as pd

inputfile = '../data/moment.csv' #数据文件
outputfile1 = '../tmp/cm_train.xls' #训练样本混淆矩阵保存路径
outputfile2 = '../tmp/cm_test.xls' #测试样本混淆矩阵保存路径
data = pd.read_csv(inputfile, encoding = 'gbk') #读取数据，指定编码为gbk
data = data.as_matrix()

from numpy.random import shuffle #引入随机函数
shuffle(data) #随机打乱数据
data_train = data[:int(0.8*len(data)), :] #选取前80%为训练数据
data_test = data[int(0.8*len(data)):, :] #选取前20%为测试数据

#构造特征和标签
x_train = data_train[:, 2:]*30
y_train = data_train[:, 0].astype(int)
x_test = data_test[:, 2:]*30
y_test = data_test[:, 0].astype(int)

#导入模型相关的函数，建立并且训练模型
from sklearn import svm
model = svm.SVC()
model.fit(x_train, y_train)
import pickle
pickle.dump(model, open('../tmp/svm.model', 'wb'))
#最后一句保存模型，以后可以通过下面语句重新加载模型：
#model = pickle.load(open('../tmp/svm.model', 'rb'))

#导入输出相关的库，生成混淆矩阵
from sklearn import metrics
cm_train = metrics.confusion_matrix(y_train, model.predict(x_train)) #训练样本的混淆矩阵
cm_test = metrics.confusion_matrix(y_test, model.predict(x_test)) #测试样本的混淆矩阵

#保存结果
pd.DataFrame(cm_train, index = range(1, 6), columns = range(1, 6)).to_excel(outputfile1)
pd.DataFrame(cm_test, index = range(1, 6), columns = range(1, 6)).to_excel(outputfile2)

第10章 ：家用电器用户行为分析与时间识别

目标

根据热水器采集到的数据，划分一次完整用水事件；

在划分好的一次完整用水事件中，识别出洗浴事件。

过程

1数据抽取：无放回随机抽样法

2探索分析

为了探究用户真实用水停顿时间间隔的分布情况，统计用水停顿的时间间隔并作频率分布直方图。

 

停顿时间间隔为0~0.3分钟的频率很高，根据日常用水经验可以判断其为一次用水时间中的停顿；停顿时间间隔为6~13分钟的频率较低，分析其为两次用水事件之间的停顿间隔。两次用水事件的停顿时间间隔分布在3~7分钟与现场实验统计用水停顿的时间间隔近似。

3数据预处理

数据规约

1数据规约

属性规约：因“热水器编号”、“即热”、“即时洗” 、“有无水流” 、“预约洗”、 “节能模式”对建模无作用，可以去除。

数值规约：当热水器“开关机状态”为“关”且水流量为0时，说明热水器不处于工作状态，数据记录可以规约掉。

2数据变换

1）一次完整用水事件的划分：不用水时间>阈值，就是停止用水，不是暂时停止

2）用水事件阈值寻优：根据水流量和停顿时间间隔的阈值划分一次完整的用水事件。

3）属性构造：根据用水行为，需构造四类指标：时长指标、频率指标、用水的量化指标以及用水的波动指标。

 

4）候选洗浴事件：体积和（总）用水时长<某个值不算

  现实中：经过实验分析，热水器设定温度为50摄氏度时，一次普通的洗浴时长为15分钟，总用水时长10分钟左右，热水的使用量为10~15升。

3 缺失值处理

结合实际问题添加：因存在网络故障等原因，导致用水数据状态记录缺失的情况，需要对缺失的数据状态记录进行添加。其添加方法：用水状态记录缺失的情况下，填充一条状态记录使水流量为0，发生时间加2秒，其余属性状态不变。

 

4构建专家样本：找资料进行合适的数据构造

模型

阈值寻优模型

#阈值寻优模型
import numpy as np
import pandas as pd
inputfile = '../data/water_heater.xls' #输入数据路径,需要使用Excel格式

threshold = pd.Timedelta(minutes = 5) #专家阈值
data = pd.read_excel(inputfile)
data[u'发生时间'] = pd.to_datetime(data[u'发生时间'], format = '%Y%m%d%H%M%S')
data = data[data[u'水流量'] > 0] #只要流量大于0的记录
#计算时间在某个阈值的数目
def event_num(ts):
  d = data[u'发生时间'].diff() > ts #相邻时间作差分，比较是否大于阈值
  return d.sum() + 1 #这样直接返回事件数

dt = [pd.Timedelta(minutes = i) for i in np.arange(1, 9, 0.25)]#list,1-9分钟，每一刻一次[Timedelta('0 days 00:01:00'), Timedelta('0 days 00:01:15'),
h = pd.DataFrame(dt, columns = [u'阈值']) #定义阈值列，
h[u'事件数'] = h[u'阈值'].apply(event_num) #计算每个阈值对应的事件数
h[u'斜率'] = h[u'事件数'].diff()/0.25 #计算每两个相邻点对应的斜率
n=4#获取比较平缓的时间，斜率，找斜率指标最小
h[u'斜率指标'] = pd.rolling_mean(h[u'斜率'].abs(),n) #采用后n个的斜率绝对值平均作为斜率指标
ts = h[u'阈值'][h[u'斜率指标'].idxmin() - n]
#注：用idxmin返回最小值的Index，由于rolling_mean()自动计算的是前n个斜率的绝对值平均,所以结果要进行平移（-n）

if ts > threshold:
  ts = pd.Timedelta(minutes = 4)#小于5，经过专家验证
print(ts)

用水事件的划分-阈值处理

#用水事件划分
import pandas as pd
threshold = pd.Timedelta('4 min') #阈值为分钟Timedelta
inputfile = '../data/water_heater.xls' #输入数据路径,需要使用Excel格式
outputfile = '../tmp/dividsequence.xls' #输出数据路径,需要使用Excel格式

data = pd.read_excel(inputfile)
data[u'发生时间'] = pd.to_datetime(data[u'发生时间'], format = '%Y%m%d%H%M%S')#to_datetime
data = data[data[u'水流量'] > 0] #只要流量大于0的记录
d = data[u'发生时间'].diff() > threshold #相邻时间作差分，比较是否大于阈值
data[u'事件编号'] = d.cumsum() + 1 #通过累积求和的方式为事件编号,true一次就+1

data.to_excel(outputfile)

 

洗浴识别模型-BP神经网络分类

#建立、训练多层神经网络，并完成模型的检验
import pandas as pd

inputfile1='../data/train_neural_network_data.xls' #训练数据
inputfile2='../data/test_neural_network_data.xls' #测试数据
testoutputfile = '../tmp/test_output_data1.xls' #测试数据模型输出文件
data_train = pd.read_excel(inputfile1) #读入训练数据(由日志标记事件是否为洗浴)
data_test = pd.read_excel(inputfile2) #读入测试数据(由日志标记事件是否为洗浴)
y_train = data_train.iloc[:,4].as_matrix() #训练样本标签列
x_train = data_train.iloc[:,5:17].as_matrix() #训练样本特征
y_test = data_test.iloc[:,4].as_matrix() #测试样本标签列
x_test = data_test.iloc[:,5:17].as_matrix() #测试样本特征

from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
model = Sequential() #建立模型
model.add(Dense(17,input_dim=11)) #添加输入层、隐藏层的连接
model.add(Activation('relu')) #以Relu函数为激活函数
model.add(Dense(10,input_dim=17)) #添加隐藏层、隐藏层的连接
model.add(Activation('relu')) #以Relu函数为激活函数
model.add(Dense(1,input_dim=10)) #添加隐藏层、输出层的连接
model.add(Activation('sigmoid')) #以sigmoid函数为激活函数
#编译模型，损失函数为binary_crossentropy，用adam法求解
model.compile(loss='binary_crossentropy', optimizer='adam', class_mode="binary") #, class_mode="binary"去掉不知道行不行

model.fit(x_train, y_train, epochs  = 100, batch_size = 1) #训练模型
model.save_weights('../tmp/net.model') #保存模型参数
#model.load_weights('../tmp/net.model')
r = pd.DataFrame(model.predict_classes(x_test), columns = [u'预测结果'])
pd.concat([data_test.iloc[:,:5], r], axis = 1).to_excel(testoutputfile)
model.predict(x_test)

模型检验-准确率

第11章 ：时间序列-应用系统负载分析与容量预测

目标

针对历史磁盘数据，采用数据挖掘的方法，预测应用系统服务器磁盘已使用空间大小；

根据用户需求设置不同的预警等级，将预测值与容量值进行比较，对其结果进行预警判断，为系统管理员提供定制化的预警提示；

分析

在不考虑人为因素的影响时，存储空间随时间变化存在很强的关联性，且历史数据对未来的发展存在一定的影响，故可采用时间序列分析法对磁盘已使用空间进行预测分析。

探索分析：周期性分析

对数据进行周期性分析，探索数据的平稳性

import pandas as pd

datafile = '../data/discdata.xls'
data = pd.read_excel(datafile)
data1 = data[(data['ENTITY'] == 'C:\\') & (data['TARGET_ID'] == 184)]

import datetime
import matplotlib.dates as mdates
import matplotlib.pyplot as plt


fig = plt.figure()
ax = fig.add_subplot(2, 1, 1)
ax.set_title(u'C盘空间')
ax.set(xlabel=u'时间', ylabel=u'C磁盘空间')
# 图上时间间隔显示为10天
ax.xaxis.set_major_locator(mdates.DayLocator(bymonthday=range(1, 32), interval=10))
ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d"))
plt.rc('figure', figsize=(9, 7))
plt.subplots_adjust(bottom=0.13, top=0.95)
ax.plot(data1['COLLECTTIME'], data1['VALUE'], 'ro-', )

fig.autofmt_xdate()  # 自动根据标签长度进行旋转  
'''''for label in ax.xaxis.get_ticklabels():   #此语句完成功能同上
       label.set_rotation(45)
'''
plt.savefig('c.jpg')
plt.show()

 

数据预处理

1数据清洗

实际业务中，监控系统会每天定时对磁盘的信息进行收集，但是磁盘容量属性一般情况下都是一个定值（不考虑中途扩容的情况），因此磁盘原始数据中会存在磁盘容量的重复数据。

剔除磁盘容量的重复数据。

将所有服务器的磁盘容量作为一个固定值，方便模型预警时需要。

data.drop_duplicates(data.columns[:-1],inplace=True)

属性构造：因每台服务器的磁盘信息可以通过表中NAME，TARGET_ID，ENTITY三个属性进行区分，且每台服务器的上述三个属性值是不变的，所以可以将三个属性的值进行合并。 （实质是将行转换成列）

#属性变换
#参数初始化
data = data[data['TARGET_ID'] == 184].copy() #只保留TARGET_ID为184的数据

data_group = data.groupby('COLLECTTIME') #以时间分组

def attr_trans(x): #定义属性变换函数
  result = pd.Series(index = ['SYS_NAME', 'CWXT_DB:184:C:\\', 'CWXT_DB:184:D:\\',  'COLLECTTIME'])
  result['SYS_NAME'] = x['SYS_NAME'].iloc[0]
  result['COLLECTTIME'] = x['COLLECTTIME'].iloc[0]
  result['CWXT_DB:184:C:\\'] = x['VALUE'].iloc[0]
  result['CWXT_DB:184:D:\\'] = x['VALUE'].iloc[1]
  return result

data_processed = data_group.apply(attr_trans) #逐组处理
data_processed.to_excel(transformeddata, index = False)

容量预测模型

模型流程图

 

平稳性检验：

为了确定原始数据序列中没有随机趋势或趋势，需要对数据进行平稳性检验，否则将会产生“伪回归”的现象。方法：单位跟检验或者观察时序图。

#-*- coding: utf-8 -*-
#平稳性检验
import pandas as pd

#参数初始化
discfile = '../data/discdata_processed.xls'
predictnum =5 #不使用最后5个数据

data = pd.read_excel(discfile)
data = data.iloc[: len(data)-5] #不检测最后5个数据

#平稳性检测
from statsmodels.tsa.stattools import adfuller as ADF
diff = 0
adf = ADF(data['CWXT_DB:184:D:\\'])
while adf[1] > 0.05:
  diff = diff + 1
  adf = ADF(data['CWXT_DB:184:D:\\'].diff(diff).dropna())

print(u'原始序列经过%s阶差分后归于平稳，p值为%s' %(diff, adf[1]))

 

白噪声检验：

为了验证序列中有用的信息是否已被提取完毕，需要对序列进行白噪声检验。如果序列检验为白噪声序列，就说明序列中有用的信息已经被提取完毕了，剩下的全是随机扰动，无法进行预测和使用。方法：一般采用LB统计量检验方法。

白噪声过程：对对于一个纯随机过程来说，其期望为0，方差为常数

 

#参数初始化
discfile = '../data/discdata_processed.xls'
data = pd.read_excel(discfile)
data = data.iloc[: len(data)-5] #不使用最后5个数据

#白噪声检测
from statsmodels.stats.diagnostic import acorr_ljungbox
[[lb], [p]] = acorr_ljungbox(data['CWXT_DB:184:D:\\'], lags = 1)
if p < 0.05:print(u'原始序列为非白噪声序列，对应的p值为：%s' %p)
else:print(u'原始该序列为白噪声序列，对应的p值为：%s' %p)

[[lb], [p]] = acorr_ljungbox(data['CWXT_DB:184:D:\\'].diff().dropna(), lags = 1)
if p < 0.05: print(u'一阶差分序列为非白噪声序列，对应的p值为：%s' %p)
else:  print(u'一阶差分该序列为白噪声序列，对应的p值为：%s' %p)

AIC定阶

通过AIC、BIC信息准则或者观测自相关图和偏自相关图确定P、Q的参数，识别其模型属于AR、MA和ARMA中的哪一种模型。

AIC信息准则即Akaike information criterion，是衡量统计模型拟合优良性的一种标准，所以优先考虑的模型应是AIC值最小的那一个，

参数估计：估计模型的其他参数。可以采用极大似然估计、条件最小二乘法确定。

#-*- coding: utf-8 -*-
#确定最佳p、d、q值
import pandas as pd

#参数初始化
discfile = '../data/discdata_processed.xls'
data = pd.read_excel(discfile, index_col = 'COLLECTTIME')
xdata = data['CWXT_DB:184:D:\\']

from statsmodels.tsa.arima_model import ARIMA

#定阶
pmax = int(len(xdata)/10) #一般阶数不超过length/10
qmax = int(len(xdata)/10) #一般阶数不超过length/10
bic_matrix = [] #bic矩阵
for p in range(pmax+1):
  tmp = []
  for q in range(qmax+1):
    try: #存在部分报错，所以用try来跳过报错。
      tmp.append(ARIMA(xdata, (p,1,q)).fit().bic)

      #tmp.append(ARMA(xdata2, (p,q)).fit().aic) #  AIC方式  
      #tmp.append(ARMA(xdata2, (p,q)).fit().hq) # HQ方式  
    except:
      tmp.append(None)
  bic_matrix.append(tmp)

bic_matrix = pd.DataFrame(bic_matrix) #从中可以找出最小值
p,q = bic_matrix.stack().idxmin() #先用stack展平，然后用idxmin找出最小值位置。
print(u'BIC最小的p值和q值为：%s、%s' %(p,q))

#BIC最小的p值和q值为：0、2

 

模型检验

确定模型后，需要检验其残差序列是否是白噪声，若不是，说明，残差中还存在有用的信息，需要修改模型或者进一步提取。若其残差不是白噪声，重新更换p,q的值，重新确定

#模型检验
import pandas as pd
#参数初始化
discfile = '../data/discdata_processed.xls'
lagnum = 12 #残差延迟个数
data = pd.read_excel(discfile, index_col = 'COLLECTTIME')
data = data.iloc[: len(data)-5] #不使用最后5个数据
xdata = data['CWXT_DB:184:D:\\']

from statsmodels.tsa.arima_model import ARIMA #建立ARIMA(0,1,1)模型
arima = ARIMA(xdata, (0, 1, 1)).fit() #建立并训练模型
xdata_pred = arima.predict(typ = 'levels') #预测
pred_error = (xdata_pred - xdata).dropna() #计算残差

from statsmodels.stats.diagnostic import acorr_ljungbox #白噪声检验
lb, p= acorr_ljungbox(pred_error, lags = lagnum)
h = (p < 0.05).sum() #p值小于0.05，认为是非白噪声。
if h > 0:print(u'模型ARIMA(0,1,1)不符合白噪声检验')
else:print(u'模型ARIMA(0,1,1)符合白噪声检验')

模型预测

model = ARIMA(data, (p,1,q)).fit() #建立ARIMA(0, 1, 1)模型
model.summary2() #给出一份模型报告
model.forecast(5) #作为期5天的预测，返回预测结果、标准误差、置信区间。

模型评价与应用

file = '../data/predictdata.xls'
data = pd.read_excel(file)
#计算误差
abs_ = (data[u'预测值'] - data[u'实际值']).abs()
mae_ = abs_.mean() # mae
rmse_ = ((abs_**2).mean())**0.5 # rmse
mape_ = (abs_/data[u'实际值']).mean() # mape

print(u'平均绝对误差为：%0.4f，\n均方根误差为：%0.4f，\n平均绝对百分误差为：%0.6f。' %(mae_, rmse_, mape_))

应用：根据预测的使用率进行警报

第12章 ：电子商务网站用户行为分析及服务推荐（基于协同过滤算法）

https://blog.csdn.net/u012063773/article/details/79324194

目的

了解用户行为以及网站关心内容

借助访问记录，发现访问习惯，进行推荐

数据探索

导入sql数据

import pandas as pd

from sqlalchemy import create_engine

 

engine = create_engine('mysql+pymysql://root:[email protected]:3306/test?charset=utf8')

sql = pd.read_sql('all_gzdata', engine, chunksize = 10000)

'''

用create_engine建立连接，连接地址的意思依次为“数据库格式（mysql）+程序名（pymysql）+账号密码@地址端口/数据库名（test）”，最后指定编码为utf8；

all_gzdata是表名，engine是连接数据的引擎，chunksize指定每次读取1万条记录。这时候sql是一个容器，未真正读取数据。

'''

网页类型统计

counts = [ i['fullURLId'].value_counts() for i in sql] #逐块统计

counts = pd.concat(counts).groupby(level=0).sum() #level=0，合并统计结果，把相同的统计项合并（即按index分组并求和）

counts = counts.reset_index() #重新设置index，将原来的index作为counts的一列。

counts.columns = ['index', 'num'] #重新设置列名，主要是第二列，默认为0

counts['type'] = counts['index'].str.extract('(\d{3})') #提取前三个数字作为类别id

counts_ = counts[['type', 'num']].groupby('type').sum() #按类别合并

counts_['ratio']=counts_/counts_.sum() #增加比例列

counts_.sort('num', ascending = False) #降序排列

 

#统计其他类别的情况def counts_type(type):

    counts_type=counts[counts['type']==type][['index', 'num']]

    counts_type['ratio']=counts_type['num']/counts_type['num'].sum()

    return counts_type.sort_values('num', ascending = False)

 

counts_type('102')   

 

#统计107类别的情况

def count107(i): #自定义统计函数

  j = i[['fullURL']][i['fullURLId'].str.contains('107')].copy() #找出类别包含107的网址

  j['type'] = None #添加空列

  j['type'][j['fullURL'].str.contains('info/.+?/')] = u'知识首页'

  j['type'][j['fullURL'].str.contains('info/.+?/.+?')] = u'知识列表页'

  j['type'][j['fullURL'].str.contains('/\d+?_*\d+?\.html')] = u'知识内容页'

  return j['type'].value_counts()

 

counts2 = [count107(i) for i in sql] #逐块统计

counts2 = pd.concat(counts2).groupby(level=0).sum() #合并统计结果

 

#瞎逛统计，没有单击具体的页面（html结尾），他们单机的大部分是目录网页

sql = pd.read_sql('all_gzdata', engine, chunksize = 10000)

counts5 = [ i['fullURLId'][(i['fullURL'].str.contains('html'))==0].value_counts() for i in sql]#没有点击以html结尾的具体页面

counts5= pd.concat(counts5).groupby(level=0).sum()   

counts5 = pd.DataFrame(counts5)  

counts5['type'] = counts5.index.str.extract('(\d{3})') #提取前三个数字作为类别id

counts5_ = counts5[['type', 'fullURLId']].groupby('type').sum()#按类别合并

counts5_['ratio']=counts5_/counts5_.sum() #增加比例列

counts5_.sort_values('fullURLId', ascending = False) #按类型编码顺序排序  

#点击次数统计

sql = pd.read_sql('all_gzdata', engine, chunksize = 10000)

c = [i['realIP'].value_counts() for i in sql] #统计各个IP出现次数

count6 = pd.concat(c).groupby(level=0).sum()  #合并统计结果

count6 = pd.DataFrame(count6) #将Series转为DataFrame

count6[1] = 1 #添加一列全为1

count6_=count6.groupby('realIP').sum() #统计各个不同点击数 出现的次数

count6_['ratio1']=count6_[1]/count6_[1].sum()

count6_['ratio2']=count6_[1]*count6_.index/(count6_[1]*count6_.index).sum()

count6_.head(10)

可以看出80%的用户只提供了30%的浏览量，点击次数最大值为42790次，是律师浏览的信息。

数据预处理

1、clean合理删除数据

for i in sql:

  d = i[['realIP', 'fullURL']] #只要网址列

  d = d[d['fullURL'].str.contains('\.html')].copy() #只要含有.html的网址

  #保存到数据库的cleaned_gzdata表中（如果表不存在则自动创建）

  d.to_sql('cleaned_gzdata', engine, index = False, if_exists = 'append')

 

2、改变数据删除重复：由于用户在浏览网页时存在翻页情况，不同的网址属于同一类型的网页，针对这些网页需要还原其原始类别。

sql = pd.read_sql('cleaned_gzdata', engine, chunksize = 10000)

for i in sql: #逐块变换并去重

d = i.copy()

d['fullURL'] = d['fullURL'].str.replace('_\d{0,2}.html', '.html') #将下划线后面部分去掉，规范为标准网址

d = d.drop_duplicates() #删除重复记录

d.to_sql('changed_gzdata', engine, index = False, if_exists = 'append') #保存

3、分类：目标是为用户提供个性化推荐，要进一步对数据进行分类。

sql = pd.read_sql('changed_gzdata', engine, chunksize = 10000)

for i in sql: #逐块变换并去重

d = i.copy()

d['type_1'] = d['fullURL'] #复制一列

d['type_1'][d['fullURL'].str.contains('(ask)|(askzt)')] = 'zixun' #将含有ask、askzt关键字的网址的类别一归为咨询（后面的规则就不详细列出来了，实际问题自己添加即可）

d.to_sql('splited_gzdata', engine, index = False, if_exists = 'append') #保存

模型构建-具体参考链接网页

基于物品的协同过滤推荐、随机推荐、按照流行度推荐

基于物品的协同过滤推荐要分为两步：

1. 计算物品之间的相似度；

2. 根据物品相似度和用户的历史行为给用户生成推荐列表

由于用户行为是二元选择（0或者1），此处选择采用杰卡德相似系数法计算物品的相似度。

import numpy as np

def Jaccard(a, b): #自定义相似系数

  return 1.0*(a*b).sum()/(a+b-a*b).sum()

 

class Recommender():

  sim = None #相似度矩阵

  def similarity(self, x, distance): #计算相似度矩阵的函数

    y = np.ones((len(x), len(x)))

    for i in range(len(x)):

      for j in range(len(x)):

        y[i,j] = distance(x[i], x[j])

return y

 

  def fit(self, x, distance = Jaccard): #训练函数

    self.sim = self.similarity(x, distance)

 

  def recommend(self, a): #推荐函数

    return np.dot(self.sim, a)*(1-a)  

第13章 ：预测-财政收入影响因素分析及预测模型

目标

（1） 梳理影响地方财政收入的关键特征，分析识别影响地方财政收入的关键特征的选择模型

（2） 结合（1）的分析，对某市2015年财政总收入以及各个类别收入进行预测。

数据探索分析

影响财政收入（y）的因素很多，经查阅资料选以下因素为自变量

社会从业人数（x1）在岗职工工资总额（x2）社会消费品零售总额（x3）城镇居民人均可支配收入（x4）城镇居民人均消费性支出（x5）年末总人口（x6）全社会固定资产投入（x7）地区生产总值（x8）第一产业产值（x9）税收（x10）居民消费价格指数（x11）第三产业与第二产业产值比（x12）居民消费水平（x13）

描述性分析describe

inputfile = '../data/data1.csv' #输入的数据文件

data = pd.read_csv(inputfile) #读取数据

r = [data.min(), data.max(), data.mean(), data.std()] #依次计算最小值、最大值、均值、标准差

r = pd.DataFrame(r, index = ['Min', 'Max', 'Mean', 'STD']).T  #计算相关系数矩阵

np.round(r, 2) #保留两位小数

相关性分析data.corr(method='pearson'):x11与财政收入的线性关系不显著

数据预处理

#标准化处理
dataNM=(data-data.min())/(data.max()-data.min())

模型

变量选择模型lasso或者AdaptiveLasso

data = pd.read_csv( '../data/data1.csv') #读取数据

#导入AdaptiveLasso算法，要在较新的Scikit-Learn才有。

from sklearn.linear_model import AdaptiveLasso#import Lasso

model = AdaptiveLasso(gamma=1)##model=Lasso()

model.fit(data.iloc[:,0:13],data['y'])

q=model.coef_ #各个特征的系数

灰色预测与神经网络的组合模型

自定义GM11函数

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

 

def GM11(x0): #自定义灰色预测函数

import numpy as np

x1 = x0.cumsum() #1-AGO序列

z1 = (x1[:len(x1)-1] + x1[1:])/2.0 #紧邻均值（MEAN）生成序列

z1 = z1.reshape((len(z1),1))

B = np.append(-z1, np.ones_like(z1), axis = 1)

Yn = x0[1:].reshape((len(x0)-1, 1))

[[a],[b]] = np.dot(np.dot(np.linalg.inv(np.dot(B.T, B)), B.T), Yn) #计算参数

f = lambda k: (x0[0]-b/a)*np.exp(-a*(k-1))-(x0[0]-b/a)*np.exp(-a*(k-2)) #还原值

delta = np.abs(x0 - np.array([f(i) for i in range(1,len(x0)+1)]))

C = delta.std()/x0.std()

P = 1.0*(np.abs(delta - delta.mean()) < 0.6745*x0.std()).sum()/len(x0)

return f, a, b, x0[0], C, P #返回灰色预测函数、a、b、首项、方差比、小残差概率

灰色预测

from GM11 import GM11 #引入自己编写的灰色预测函数

 

inputfile = '../data/data1.csv' #输入的数据文件

outputfile = '../tmp/data1_GM11.xls' #灰色预测后保存的路径

data = pd.read_csv(inputfile) #读取一部分数据

data.index = range(1994, 2014)

data.loc[2014] = None

data.loc[2015] = None

l=['x1','x2','x3','x4','x5','x6','x7']

for i in l:

  f = GM11(data[i][np.arange(1994, 2014)].as_matrix())[0]#range改成np.arange，key错误

  data[i][2014] = f(len(data)-1) #2014年预测结果

  data[i][2015] = f(len(data)) #2015年预测结果

  data[i] = data[i].round(2) #保留两位小数

 

data[l+['y']].to_excel(outputfile) #结果输出

神经网络

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

import pandas as pd

inputfile = '../tmp/data1_GM11.xls' #灰色预测后保存的路径

outputfile = '../data/revenue.xls' #神经网络预测后保存的结果

modelfile = '../tmp/1-net.model' #模型保存路径

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

feature = ['x1', 'x2', 'x3', 'x4', 'x5', 'x7'] #特征所在列

#统计

data_train = data.loc[range(1994,2014)].copy() #取2014年前的数据建模

data_mean = data_train.mean()

data_std = data_train.std()

data_train = (data_train - data_mean)/data_std #数据标准化

x_train = data_train[feature].as_matrix() #特征数据

y_train = data_train['y'].as_matrix() #标签数据

 

from keras.models import Sequential

from keras.layers.core import Dense, Activation

 

model = Sequential() #建立模型

model.add(Dense(12,input_dim=6))

model.add(Activation('relu')) #用relu函数作为激活函数，能够大幅提供准确度

model.add(Dense(1,input_dim=12))

model.compile(loss='mean_squared_error', optimizer='adam') #编译模型

model.fit(x_train, y_train, epochs = 10000, batch_size = 16) #训练模型，学习一万次

model.save_weights(modelfile) #保存模型参数

 

#预测，并还原结果。

x = ((data[feature] - data_mean[feature])/data_std[feature]).as_matrix()

data[u'y_pred'] = model.predict(x) * data_std['y'] + data_mean['y']#.tolist()

data.to_excel(outputfile)

 

import matplotlib.pyplot as plt #画出预测结果图

 

p = data[['y','y_pred']].plot(subplots = True, style=['b-o','r-*'])

plt.show()

第14章 ：层次聚类-基于基站定位数据的商圈分析

目标

1对用户的历史定位数据，采用数据挖掘技术，对基站进行分群

2对不同的商圈分群进行特征分析，比较不同商圈类别的价值，选择合适区域进行针对性的营销活动

探索分析

1、提取出基站范围内区域的人流特征：分类人流特征的四个指标，工作日上班时间人均停留时间、凌晨人均停留时间、周末人均停留时间和日均人流量。

2、由于各个属性之间的差异较大。为了消除数量级数据带来的影响，在聚类之前，需要进行离差标准化处理

data = (data - data.min())/(data.max() - data.min()) #离差标准化

模型-层次聚类

1、谱聚类

建模数据进行基于基站数据的商圈聚类，画出谱系聚类图

standardizedfile = '../data/standardized.xls' #标准化后的数据文件

data = pd.read_excel(standardizedfile, index_col = u'基站编号') #读取数据

 

import matplotlib.pyplot as plt

from scipy.cluster.hierarchy import linkage,dendrogram

#这里使用scipy的层次聚类函数

 

Z = linkage(data, method = 'ward', metric = 'euclidean') #谱系聚类图

P = dendrogram(Z, 0) #画谱系聚类图

plt.show()

2层次聚类

从图中可以看出，可以把聚类类别数取3类，再使用层次聚类算法进行训练模型

standardizedfile = '../data/standardized.xls' #标准化后的数据文件

k = 3 #聚类数

data = pd.read_excel(standardizedfile, index_col = u'基站编号') #读取数据

 

from sklearn.cluster import AgglomerativeClustering #导入sklearn的层次聚类函数

model = AgglomerativeClustering(n_clusters = k, linkage = 'ward')

model.fit(data) #训练模型

 

#详细输出原始数据及其类别

r = pd.concat([data, pd.Series(model.labels_, index = data.index)], axis = 1)  #详细输出每个样本对应的类别

r.columns = list(data.columns) + [u'聚类类别'] #重命名表头

 

import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei'] #用来正常显示中文标签

plt.rcParams['axes.unicode_minus'] = False #用来正常显示负号

 

style = ['ro-', 'go-', 'bo-']

xlabels = [u'工作日人均停留时间', u'凌晨人均停留时间', u'周末人均停留时间', u'日均人流量']

pic_output = '../tmp/type_' #聚类图文件名前缀

 

for i in range(k): #逐一作图，作出不同样式

  plt.figure()

  tmp = r[r[u'聚类类别'] == i].iloc[:,:4] #提取每一类

  for j in range(len(tmp)):

    plt.plot(range(1, 5), tmp.iloc[j], style[i])

  

  plt.xticks(range(1, 5), xlabels, rotation = 20) #坐标标签

  plt.title(u'商圈类别%s' %(i+1)) #我们计数习惯从1开始

  plt.subplots_adjust(bottom=0.15) #调整底部

  plt.savefig(u'%s%s.png' %(pic_output, i+1)) #保存图片

第15章：电商产品评论数据情感分析代码详解目标

数据预处理

1抽取品牌是美的的数据

inputfile = '../data/huizong.csv' #评论汇总文件

outputfile = '../data/meidi_jd.txt' #评论提取后保存路径

data = pd.read_csv(inputfile, encoding = 'utf-8')

data = data[[u'评论']][data[u'品牌'] == u'美的']

data.to_csv(outputfile, index = False, header = False, encoding = 'utf-8')

 

2文本去重

inputfile = '../data/meidi_jd.txt' #评论文件

outputfile = '../data/meidi_jd_process_1.txt' #评论处理后保存路径

data = pd.read_csv(inputfile, encoding = 'utf-8', header = None,sep='\t')

l1 = len(data)

data = pd.DataFrame(data[0].unique())

l2 = len(data)

data.to_csv(outputfile, index = False, header = False, encoding = 'utf-8')

print(u'删除了%s条评论。' %(l1 - l2))

3把评论前面的评分删除

inputfile1 = '../data/meidi_jd_process_end_负面情感结果.txt'

outputfile1 = '../data/meidi_jd_neg.txt'

 

data1 = pd.read_csv(inputfile1, encoding = 'utf-8', header = None) #读入数据

data1 = pd.DataFrame(data1[0].str.replace('.*?\d+?\\t ', '')) #用正则表达式修改数据,删除平分负数

data1.to_csv(outputfile1, index = False, header = False, encoding = 'utf-8')

4结巴分词

inputfile1 = '../data/meidi_jd_neg.txt'

outputfile1 = '../data/meidi_jd_neg_cut.txt'

 

data1 = pd.read_csv(inputfile1, encoding = 'utf-8', header = None) #读入数据

mycut = lambda s: ' '.join(jieba.cut(s)) #自定义简单分词函数

data1 = data1[0].apply(mycut) #通过“广播”形式分词，加快速度。

模型-LDA

K-means是聚类的，他主要是处理数据的，对数据进行聚类。

LDA其实也是聚类的，主要是处理字符串的，对字符串进行聚类

 

#参数初始化

negfile = '../data/meidi_jd_neg_cut.txt'

posfile = '../data/meidi_jd_pos_cut.txt'

stoplist = '../data/stoplist.txt'

 

neg = pd.read_csv(negfile, encoding = 'utf-8', header = None) #读入数据

stop = pd.read_csv(stoplist, encoding = 'utf-8', header = None, sep = 'tipdm')

#sep设置分割词，由于csv默认以半角逗号为分割词，而该词恰好在停用词表中，因此会导致读取出错

#所以解决办法是手动设置一个不存在的分割词，如tipdm。

stop = [' ', ''] + list(stop[0]) #Pandas自动过滤了空格符，这里手动添加

 

neg[1] = neg[0].apply(lambda s: s.split(' ')) #定义一个分割函数，然后用apply广播

neg[2] = neg[1].apply(lambda x: [i for i in x if i not in stop]) #逐词判断是否停用词，思路同上

 

from gensim import corpora, models

 

#负面主题分析

neg_dict = corpora.Dictionary(neg[2]) #建立词典

neg_corpus = [neg_dict.doc2bow(i) for i in neg[2]] #建立语料库

neg_lda = models.LdaModel(neg_corpus, num_topics = 3, id2word = neg_dict) #LDA模型训练

for i in range(3):

  neg_lda.print_topic(i) #输出每个主题