def lm_fit():
file = "../data/model.xls"
net_file = "../tmp/model.xls"
data = pd.read_excel(file)
data = data.as_matrix()
p = 0.8
train = data[:int(len(data) * p), :]
test = data[int(len(data) * p):, :]
net = Sequential()
net.add(Dense(input_dim=3, units=10))
net.add(Activation('relu'))
net.add(Dense(input_dim=10, units=1))
net.add(Activation('sigmoid'))
net.compile(loss='binary_crossentropy',
optimizer='adam',
sample_weight_mode='binary')
net.fit(train[:, :3], train[:, 3], nb_epoch=1000, batch_size=1)
net.save_weights(net_file)
predict_result = net.predict_classes(train[:, :3]).reshape(len(train))
cm_plot(train[:, 3], predict_result).show()
if (prediction > 0):
pred.append(1)
else:
pred.append(0)
for i in range(0, len(data_test)):
prediction = netModel.activate(
(data_test[i][0], data_test[i][1], data_test[i][2]))
if prediction > 0:
sum += 1
test.append(1)
else:
test.append(0)
print sum
#print result
from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(really, pred).show() #显示混淆矩阵可视化结果
#注意到Scikit-Learn使用predict方法直接给出预测结果。
from sklearn.metrics import roc_curve #导入ROC曲线函数
fpr, tpr, thresholds = roc_curve(really, pred, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label='ROC of BP', 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() #显示作图结果
x_data = x.values.astype(int)
y = data.iloc[:, 3]
y_data = y.values.astype(int)
print(x_data, y_data)
# 建立和训练模型
model = Sequential()
model.add(Dense(3, input_shape=(3, )))
model.add(Activation('relu')) # 用relu函数做激活函数，能大幅度提高准确度
model.add(Dense(1))
model.add(Activation('sigmoid')) # 由于是0-1输出，所以用sigmoid函数做激活函数
"""
编译模型：
1.由于使用的是二元分类，所以指定损失函数为binary_crossentropy，以及模型为binary
2.其他常见的损失函数还有mean_squared_error\categroical_crossentropy等
3.求解方法(优化器)用adam，此外常用的还有sgd、rmsprop等可选
"""
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
result = model.fit(x=x_data, y=y_data, epochs=1000, batch_size=10) # 训练模型1000次
yp = model.predict_classes(x_data).reshape(len(y_data)) # 分类预测
print(
yp
) # [1 1 1 0 1 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0]
from cm_plot import *
cm_plot(y_data, yp).show()
# 分割训练集/测试集
p = 0.8
train = data[:int(len(data)*p),:]
test = data[int(len(data)*p):,:]
# 决策树
from sklearn.tree import DecisionTreeClassifier
treefile = '../tmp/tree.pkl'
tree = DecisionTreeClassifier()
tree.fit(train[:,:3],train[:,3])
from sklearn.externals import joblib
joblib.dump(tree,treefile)
# 混淆矩阵
from cm_plot import *
cm_plot(train[:,3],tree.predict(train[:,:3])).savefig('../tmp/dt_cm.png')
# ROC曲线
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
plt.clf()
fpr,tpr,thresholds = roc_curve(test[:,3],tree.predict_proba(test[:,:3])[:,1],pos_label=1)
plt.plot(fpr,tpr,linewidth=2,label='ROC of CART')
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.savefig('../tmp/dt_roc.png')
netfile = 'net.model' #构建的神经网络模型存储路径
net = Sequential() #建立神经网络
net.add(Dense(input_dim=3, output_dim=10)) #添加输入层（3节点）到隐藏层（10节点）的连接
net.add(Activation('relu')) #隐藏层使用relu激活函数
net.add(Dense(input_dim=10, output_dim=1)) #添加隐藏层（10节点）到输出层（1节点）的连接
net.add(Activation('sigmoid')) #输出层使用sigmoid激活函数
net.compile(loss='binary_crossentropy', optimizer='adam',
class_mode="binary") #编译模型，使用adam方法求解
net.fit(train[:, :3], train[:, 3], nb_epoch=1000, batch_size=1) #训练模型，循环1000次
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() #显示混淆矩阵可视化结果
from sklearn.metrics import roc_curve #导入ROC曲线函数
predict_result = net.predict(test[:, :3]).reshape(len(test))
fpr, tpr, thresholds = roc_curve(test[:, 3], predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label='ROC of LM') #作出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() #显示作图结果
#Compile Model:
#Because of binary classify, we use binary_crossentropy and binary
#Other loss functions are mean_squared_error, categorical_crossentropy etc, see help docs
#We also use adam，and sgd, rmsprop as options
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam')
model.fit(x, y, epochs = 100, batch_size = 10) #Train model, machine-learning 1000 times
yp = model.predict_classes(x).reshape(len(y)) #Classify predict
#!pip install cm_plot
"""def cm_plot(y, yp):
from sklearn.metrics import confusion_matrix#Import confusion_matrix function
cm = confusion_matrix(y, yp)#confusion matrix
import matplotlib.pyplot as plt #Import plotlibrary
#More usage of cm.Greens，please read official website
plt.matshow(cm, cmap=plt.cm.Greens)
plt.colorbar()
for x in range(len(cm)): #Data Label
for y in range(len(cm)):
plt.annotate(cm[x,y], xy=(x, y), horizontalalignment='center', verticalalignment='center')
plt.ylabel('True label') #Axis Label
plt.xlabel('Predicted label') #Axis Label
return plt"""
from cm_plot import *
cm_plot(y, yp).savefig('./data/neiral_network.png')
print("Done on this run of neural_network_model_training by DK ", datetime.now())
#数据是类别标签，要将它转换为数据
#用1来表示“好”、“是”、“高”这三个属性，用0来表示“坏”、“否”、“低”
data[data == u'好'] = 1
data[data == u'是'] = 1
data[data == u'高'] = 1
data[data != 1] = 0
x = data.iloc[:, :3].as_matrix().astype(int)
y = data.iloc[:, 3].as_matrix().astype(int)
from keras.models import Sequential
from keras.layers.core import Dense, Activation
model = Sequential() #建立模型
model.add(Dense(3, 10))
model.add(Activation('relu')) #用relu函数作为激活函数，能够大幅提供准确度
model.add(Dense(10, 1))
model.add(Activation('sigmoid')) #由于是0-1输出，用sigmoid函数作为激活函数
model.compile(loss='binary_crossentropy',
optimizer='adam',
class_mode='binary')
#编译模型。由于我们做的是二元分类，所以我们指定损失函数为binary_crossentropy，以及模式为binary
#另外常见的损失函数还有mean_squared_error、categorical_crossentropy等，请阅读帮助文件。
#求解方法我们指定用adam，还有sgd、rmsprop等可选
model.fit(x, y, nb_epoch=1000, batch_size=10) #训练模型，学习一千次
yp = model.predict_classes(x).reshape(len(y)) #分类预测
from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(y, yp).show() #显示混淆矩阵可视化结果
netfile = '../tmp/net.model' #构建的神经网络模型存储路径
net = Sequential() #建立神经网络
net.add(Dense(10, input_shape=(3,))) #添加输入层（3节点）到隐藏层（10节点）的连接
net.add(Activation('relu')) #隐藏层使用relu激活函数
net.add(Dense(1, input_shape=(10,))) #添加隐藏层（10节点）到输出层（1节点）的连接
'''Dense的参数把书里的改了，否则报错 Layer is not connected. Did you forget to set "input_shape"?'''
net.add(Activation('sigmoid')) #输出层使用sigmoid激活函数
net.compile(loss = 'binary_crossentropy', optimizer = 'adam', class_mode = "binary") #编译模型，使用adam方法求解
net.fit(train[:,:3], train[:,3], nb_epoch=1000, batch_size=1) #训练模型，循环1000次 #前三列是神经网络的输入X，第四列是输出Y
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() #显示混淆矩阵可视化结果
from sklearn.metrics import roc_curve #导入ROC曲线函数
predict_result = net.predict(test[:,:3]).reshape(len(test))
fpr, tpr, thresholds = roc_curve(test[:,3], predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label = 'ROC of LM') #作出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() #显示作图结果
train_filename = '/Users/Mac/Desktop/train_neural_network_data.xls'
test_filename = '/Users/Mac/Desktop/test_neural_network_data.xls'
train_data = pd.read_excel(train_filename)
test_data = pd.read_excel(test_filename)
y_train_data = train_data.iloc[:, 4].as_matrix()
x_train_data = train_data.iloc[:, 5:16].as_matrix()
y_test_data = test_data.iloc[:, 4].as_matrix()
x_test_data = test_data.iloc[:, 5:16].as_matrix()
from keras.models import Sequential
from keras.layers.core import Dense, Activation
model = Sequential()
model.add(Dense(units=17, input_dim=11))
model.add(Activation('relu'))
model.add(Dense(units=10))
model.add(Activation('relu'))
model.add(Dense(units=1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train_data, y_train_data, nb_epoch=150, batch_size=1)
y_pre = model.predict_classes(x_test_data)
from cm_plot import *
cm_plot(y_test_data, y_pre).show()
"""-----------------------CART决策树模型构建---------------------------"""
from sklearn.tree import DecisionTreeClassifier # 导入决策树模型
# 建立模型并训练
tree = DecisionTreeClassifier()
tree.fit(train_data[:, :3], train_data[:, 3])
# 保存模型
from sklearn.externals import joblib
output_file = '../outputfiles/窃漏电用户自动识别CART决策树模型.pkl'
joblib.dump(tree, output_file)
# 用cm_plot模块可视化混淆矩阵
from cm_plot import *
cm_plot(train_data[:, 3], tree.predict(train_data[:, :3])) # sklearn使用predict方法直接给出预测结果
plt.show()
# plt.savefig('../outputfiles/窃漏电用户自动识别决策树预测结果的混淆矩阵.jpg')
"""-----------------------用ROC曲线评价模型，使用测试集数据---------------------------"""
from sklearn.metrics import roc_curve # 导入roc曲线绘制的函数
fpr, tpr, thresholds = roc_curve(test_data[:, 3], tree.predict_proba(test_data[:, :3])[:, 1], pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label='ROC of CART') # 绘制roc曲线
plt.ylabel('True Positive Rate') # 设置y坐标轴标签
plt.xlabel('False Positive Rate') # 设置x坐标轴标签
plt.ylim(0, 1.05) # 设置y轴方向的边界范围
plt.xlim(0, 1.05) # 设置x轴方向的边界范围
plt.legend(loc=4) # 设置图例
# plt.show()
plt.savefig('../outputfiles/窃漏电用户自动识别的CART决策树模型评价的ROC曲线.jpg')
# 模型训练1000轮，并保存参数
net.fit(x=train_data[:, :3], y=train_data[:, 3], epochs=1000, batch_size=1)
output_file = '../outputfiles/电力窃漏电用户自动识别的LM神经网络模型.model'
net.save_weights(output_file) # 保存为HDF5文件类型
# 再次使用需要导入from keras.models import load_model
# 并用model.load_model(filepath)载入模型
# 用模型进行预测
predict_result = net.predict_classes(train_data[:, :3]).reshape(len(train_data)) # 预测结果变形
# keras的predict给出预测概率，predict_classes才是给出预测类别，而且两者的预测结果都是n*1维数组，而不是通常的1*n维
# 用cm_plot模块可视化混淆矩阵
from cm_plot import *
cm_plot(train_data[:, 3], predict_result)
plt.show()
# plt.savefig('../outputfiles/窃漏电用户自动识别LM神经网络预测结果的混淆矩阵.jpg')
"""-----------------------用ROC曲线评价模型，使用测试集数据---------------------------"""
from sklearn.metrics import roc_curve # 导入roc曲线绘制的函数
test_predict_result = net.predict_classes(test_data[:, :3]).reshape(len(test_data)) # 预测结果变形
fpr, tpr, thresholds = roc_curve(test_data[:, 3], test_predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label='ROC of LM') # 绘制roc曲线
plt.ylabel('True Positive Rate') # 设置y坐标轴标签
plt.xlabel('False Positive Rate') # 设置x坐标轴标签
plt.ylim(0, 1.05) # 设置y轴方向的边界范围
plt.xlim(0, 1.05) # 设置x轴方向的边界范围
plt.legend(loc=4) # 设置图例
plt.show()
# 输出层使用sigmoid激活函数
net.add(Activation('sigmoid'))
# 编译模型，用adam求解
net.compile(loss='binary_crossentropy',optimizer='adam',class_mode='binary')
# 训练模型，循环1000次
net.fit(train[:,:3],train[:,3],nb_epoch=100,batch_size=1)
# 保存模型
net.save_weights(netFile)
# 这里要提醒的是，Keras用predict给出预测概率，predict_classes才是给出预测类型，
# 而且两者的预测结果都是n*1维数组，而不是通常的1*n
predict_result = net.predict_classes(train[:,:3]).reshape(len(train))
# 导入自行编写的混淆矩阵可视化函数
from cm_plot import *
cm_plot(train[:,3],predict_result).show()
# 代码清单6-5 绘制决策树模型的ROC曲线
# 导入ROC曲线函数
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
# 预测结果变形
predict_result = net.predict(test[:,:3]).reshape(len(test))
fpr,tpr,thresholds = roc_curve(test[:,3],predict_result,pos_label=1)
# 作出ROC曲线
plt.plot(fpr,tpr,linewidth=2,label='ROC of LM')
# 坐标轴标签
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
# 边界范围
from keras.layers.core import Dense,Activation
netfile = '../tmp/net.model'
# 构建神经网络
net = Sequential()
net.add(Dense(10,input_shape=(3,)))
net.add(Activation('relu'))
net.add(Dense(1,input_shape=(10,)))
net.add(Activation('sigmoid'))
net.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy','binary_accuracy'])
# 喂数据、训练、预测
net.fit(train[:,:3],train[:,3],epochs=100,batch_size=1)
net.save_weights(netfile)
predict_result = net.predict_classes(train[:,:3]).reshape(len(train))
# 混淆矩阵图
from cm_plot import *
cm_plot(train[:,3],predict_result).savefig('../tmp/lm_cm.png')
# ROC曲线
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
plt.clf()
predict_result = net.predict(test[:,:3]).reshape(len(test))
fpr,tpr,thresholds = roc_curve(test[:,3],predict_result,pos_label=1)
plt.plot(fpr,tpr,linewidth=2,label='ROC of LM')
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.savefig('../tmp/lm_roc.png')
clf = clf.fit(train_data, train_label)
# 可视化
dataLabels = [
'ZL',
'ZR',
'ZF',
'ZM',
'ZC',
]
data_list = []
data_dict = {}
for each_label in dataLabels:
for each in data:
data_list.append(each[dataLabels.index(each_label)])
data_dict[each_label] = data_list
data_list = []
lenses_pd = pd.DataFrame(data_dict)
print(lenses_pd.keys())
dot_data = StringIO()
tree.export_graphviz(clf,
out_file=dot_data,
feature_names=lenses_pd.keys(),
class_names=clf.classes_,
filled=True,
rounded=True,
special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_pdf("tree.pdf")
from cm_plot import *
cm_plot(test_label, clf.predict(test_data)).show()
data = pd.read_excel(inputfile, index_col = u'序号') #导入数据
#数据是类别标签，要将它转换为数据
#用1来表示“好”、“是”、“高”这三个属性，用0来表示“坏”、“否”、“低”
data[data == u'好'] = 1
data[data == u'是'] = 1
data[data == u'高'] = 1
data[data != 1] = 0
x = data.iloc[:,:3].as_matrix().astype(int)
y = data.iloc[:,3].as_matrix().astype(int)
from keras.models import Sequential
from keras.layers.core import Dense, Activation
model = Sequential() #建立模型
model.add(Dense(3,10))
model.add(Activation('relu')) #用relu函数作为激活函数，能够大幅提供准确度
model.add(Dense(10, 1))
model.add(Activation('sigmoid')) #由于是0-1输出，用sigmoid函数作为激活函数
model.compile(loss = 'binary_crossentropy', optimizer = 'adam', class_mode = 'binary')
#编译模型。由于我们做的是二元分类，所以我们指定损失函数为binary_crossentropy，以及模式为binary
#另外常见的损失函数还有mean_squared_error、categorical_crossentropy等，请阅读帮助文件。
#求解方法我们指定用adam，还有sgd、rmsprop等可选
model.fit(x, y, nb_epoch = 1000, batch_size = 10) #训练模型，学习一千次
yp = model.predict_classes(x).reshape(len(y)) #分类预测
from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(y,yp).show() #显示混淆矩阵可视化结果
model.add(Dense(units=10, input_dim=17)) # 添加隐藏层、二层隐藏层的连接
model.add(Activation('relu')) # 以relu函数为激活函数
model.add(Dense(units=1, input_dim=10)) # 添加二层隐藏层、输出层的连接
model.add(Activation('sigmoid')) # 以sigmoid函数为激活函数
# 编译模型，损失函数为binary_crossentropy,用adam法求解
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(x_train, y_train, nb_epoch=1000, batch_size=1)
model.save_weights(netfile) # 保存模型参数
# In[6]:
predict_result_train = model.predict_classes(x_train).reshape(
len(data_train)) #给出预测类别（训练集）
from cm_plot import *
cm_plot(y_train, predict_result_train).show() #显示混淆矩阵可视化结果 看训练结果正确率
# In[11]:
from sklearn.metrics import confusion_matrix
predict_result_test = model.predict_classes(x_test).reshape(
len(data_test)) #给出预测类别（测试集）
from cm_plot import *
cm = confusion_matrix(y_test, predict_result_test)
cm_plot(y_test, predict_result_test).show() #显示混淆矩阵可视化结果 看训练结果正确率
# In[13]:
from __future__ import division
correctRate = (cm[1, 1] + cm[0, 0]) / cm.sum()
correctRate
# net.save_weights(netfile) # 仅保存模型的权重参数，导入前需要规定好神经网络的结构，导入用model.load_weight，占空间较小
model.save(modelfile) # 保存模型整体结构，导入用 model.load() 占空间最大，保存的是.h5文件
'''预测结果 这里仅展示predict_classes的用法，实际绘制ROC曲线图 与 混淆矩阵时，要通过test，即测试集的数据，来评判性能指标。
## 注： keras中，
predict：表示预测概率，
predict_classes：表示预测类别
两者的预测结果都是n * 1维数组，而不是通常的 1 * n'''
# predict_result = model.predict_classes(train[:,:1000]).reshape(len(train)) #训练集，预测结果
# predict_result = model.predict_classes(dev[:,:1000]).reshape(len(dev)) #验证集，预测结果
predict_result = model.predict_classes(test[:, :1000]).reshape(
len(test)) #测试集，预测结果（通过测试集来进行性能评判）
'''性能评判 混淆矩阵'''
from cm_plot import * # 导入自行编写的混淆矩阵可视化函数
# cm_plot(train[:, 1000], predict_result).show() # 显示 训练集 混淆矩阵可视化结果
cm_plot(test[:, 1000], predict_result).show() # 显示 训练集 混淆矩阵可视化结果
'''性能评判 ROC曲线'''
from sklearn.metrics import roc_curve # 导入ROC曲线函数
import matplotlib.pyplot as plt
fpr, tpr, thresholds = roc_curve(test[:, 1000], predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label='ROC of LM') # 作出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() # 显示作图结果
'''性能分析 loss曲线'''
import matplotlib.pyplot as plt
''' 当训练完成后，model.fit会返回一个history，其中保存了训练过程中的所有数据
# 数据前处理的代码重复部分略去
# 构建CART决策树模型
from sklearn.tree import DecisionTreeClassifier
treefile = '/Users/Mac/Desktop/tree.pkl'
tree = DecisionTreeClassifier()
tree.fit(train[:,:3],train[:,3])
from sklearn.externals import joblib
joblib.dump(tree, treefile) # 这里使用joblib模块来保存模型数据
from cm_plot import *
cm_plot(train[:,3], tree.predict(train[:,:3])).show()
# 数据前处理部分略去
#模型测试
from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt
from sklearn.externals import joblib
tree = joblib.load('/Users/Mac/Desktop/tree.pkl')
fpr, tpr, thresholds = roc_curve(test[:,3], tree.predict_proba(test[:,:3])[:,1],pos_label=1)
plt.plot(fpr, tpr, linewidth = 2, label = 'ROC of CART')
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()
for j in range(0,4):
if origin[j] == 1:
really.append(j)
break
print predictions
#from sklearn.metrics import f1_score
#print("F-score: {0:.2f}".format(f1_score(predictions,really)))
from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(really, predictions).show() #显示混淆矩阵可视化结果
#注意到Scikit-Learn使用predict方法直接给出预测结果。
from sklearn.metrics import roc_curve #导入ROC曲线函数
fpr, tpr, thresholds = roc_curve(really, predictions, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label = 'ROC of BP', 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() #显示作图结果
inputfile = 'E:\\pythonDataSet\\chapter5\\demo\\data\\sales_data.xls'
data = pd.read_excel(inputfile, index_col=u'序号')
data[data == u'好'] = 1
data[data == u'是'] = 1
data[data == u'高'] = 1
data[data != 1] = -1
X = data.iloc[:, :3].as_matrix().astype(int)
y = data.iloc[:, 3].as_matrix().astype(int)
print X, y
from keras.models import Sequential
from keras.layers.core import Dense, Activation
model = Sequential()
model.add(Dense(3, 10))
model.add(Activation('relu'))
model.add(Dense(10, 1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
class_mode='binary')
model.fit(X, y, nb_epoch=1000, batch_size=10)
yp = model.predict_classes(X).reshape(len(y))
from cm_plot import *
cm_plot(y, yp).show()
netfile = "./tmp/net.model2" # 构建的神经网络模型存储路径
net = Sequential() # 建立神经网络
net.add(Dense(input_dim=3, units=10)) # 添加输入层（3节点）到隐藏层（10节点）的连接
net.add(Activation("relu")) # 隐藏层使用relu激活函数
net.add(Dense(input_dim=10, units=1)) # 添加隐藏层（10节点）到输出层（1节点）的连接
net.add(Activation("sigmoid")) # 输出层使用sigmoid激活函数
net.compile(loss="binary_crossentropy", optimizer="adam") # 编译模型，使用adam方法求解
net.fit(train[:, :3], train[:, 3], epochs=40, batch_size=1) # 训练模型，循环1000次
net.save(netfile)
#print("Baseline Error: %.2f%%"%(100-scores)*100)
predict_result = net.predict_classes(train[:, :3]).reshape(
len(train)) # 预测结果变形
from cm_plot import *
cm_plot(train[:, 3], predict_result).show()
from sklearn.metrics import roc_curve # 导入ROC曲线函数
predict_result = net.predict(test[:, :3]).reshape(len(test))
fpr, tpr, thresholds = roc_curve(test[:, 3], predict_result, pos_label=1)
plt.plot(fpr, tpr, linewidth=2, label="ROC of LM")
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()
# !/usr/bin/env python # _*_ coding: utf-8 _*_ import pandas as pd train_filename = '/Users/Mac/Desktop/train_neural_network_data.xls' test_filename = '/Users/Mac/Desktop/test_neural_network_data.xls' train_data = pd.read_excel(train_filename) test_data = pd.read_excel(test_filename) y_train_data = train_data.iloc[:, 4].as_matrix() x_train_data = train_data.iloc[:, 5:16].as_matrix() y_test_data = test_data.iloc[:, 4].as_matrix() x_test_data = test_data.iloc[:, 5:16].as_matrix() from sklearn import svm model = svm.SVC() model.fit(x_train_data, y_train_data) from cm_plot import * cm_plot(y_test_data, model.predict(x_test_data)).show()
x_test = data[int(0.8 * len(data)):, :6]
y_test = data[int(0.8 * len(data)):, 6]
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.metrics import accuracy_score
import pydotplus
from cm_plot import *
model = DecisionTreeClassifier()
model.fit(x_train, y_train.astype('int'))
# 使用accuracy_score函数计算正确率
train_accuracy = accuracy_score(y_train, model.predict(x_train))
test_accuracy = accuracy_score(y_test, model.predict(x_test))
# 绘制混淆矩阵
cm_plot(y_train, model.predict(x_train)).show()
cm_plot(y_test, model.predict(x_test)).show()
# 输出决策树可视化文件
dot_data = export_graphviz(model,
out_file=None,
feature_names=list(dataframe.columns)[:6])
graph = pydotplus.graph_from_dot_data(dot_data)
graph.write_pdf('/Users/Mac/Desktop/tree.pdf')
print(train_accuracy, test_accuracy)
# 结果
# train_accuracy=1.0
# test_accuracy=0.953125
test = data[int(len(data) * p):, :] # 后20%为测试集
# 构建CART决策树模型
from sklearn.tree import DecisionTreeClassifier # 导入决策树模型
treefile = '../tmp/tree.pkl' # 模型输出名字
tree = DecisionTreeClassifier() # 建立决策树模型
tree.fit(train[:, :3], train[:, 3]) # 训练
# 保存模型
from sklearn.externals import joblib
joblib.dump(tree, treefile)
# 导入自行编写的混淆矩阵可视化函数
from cm_plot import *
cm_plot(train[:, 3], tree.predict(train[:, :3])).show() # 显示混淆矩阵可视化结果
#
# a = 0
# for item in range(len(train[:, :3])):
# if tree.predict(train[item, :3]) == train[item, 3]:
# a += 1
# print a
# 注意到Scikit-Learn使用predict方法直接给出预测结果。
from sklearn.metrics import roc_curve # 导入ROC曲线函数
import matplotlib.pyplot as plt
fpr, tpr, thresholds = roc_curve(test[:, 3],
tree.predict_proba(test[:, :3])[:, 1],
shuffle(data) #随机打乱数据
p = 0.8 #设置训练数据比例
train = data[:int(len(data)*p),:] #前80%为训练集
test = data[int(len(data)*p):,:] #后20%为测试集
#构建CART决策树模型
from sklearn.tree import DecisionTreeClassifier #导入决策树模型
treefile = '../tmp/tree.pkl' #模型输出名字
tree = DecisionTreeClassifier() #建立决策树模型
tree.fit(train[:,:3], train[:,3]) #训练
#保存模型
from sklearn.externals import joblib
joblib.dump(tree, treefile)
from cm_plot import * #导入自行编写的混淆矩阵可视化函数
cm_plot(train[:,3], tree.predict(train[:,:3])).show() #显示混淆矩阵可视化结果
#注意到Scikit-Learn使用predict方法直接给出预测结果。
from sklearn.metrics import roc_curve #导入ROC曲线函数
fpr, tpr, thresholds = roc_curve(test[:,3], tree.predict_proba(test[:,:3])[:,1], 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() #显示作图结果
