机器学习之分类算法
1.德国信息卡欺诈数据分类
import numpy as np
import pandas as pd
_author_ = '张起凡'
from sklearn.model_selection import train_test_split
from sklearn.linear_model._logistic import LogisticRegression
from sklearn.metrics import accuracy_score
# 二分类
# 逻辑回归，使用sigmoid函数
# 德国信用卡欺诈数据集分类
data = pd.read_csv("./数据集/credit-a.csv", header=None)
# print(data.head())
x = data[data.columns[:-1]]
y = data[15].replace(-1, 0)
print(y)
x_train, x_test, y_train, y_test = train_test_split(x, y) # 划分训练集和测试集
model = LogisticRegression(max_iter=10000) # 建立模型
model.fit(x_train, y_train) # 使用训练集训练模型
y_pre = model.predict(x_test)
print(y_pre)
# 此时可以直接得到分类预测的结果，但如果想得到sigmoid函数的概率值
y_gailv = model.predict_proba(x_test)
print(y_gailv)
# 最后计算准确率,可以逐一利用循环对比统计准确率，也可以使用sklearn中现成函数
accuracy_sum = accuracy_score(y_pre, y_test)
print(accuracy_sum)
# 如果想提高分类的准确率，需要对数据进行预处理
图中分别为预测的结果以及根据函数变换后得出的概率，第一组前面大，预测为0，第二组后面大，预测为1，以此类推。
预测的准确率如下图：
2.决策树算法原理
# 决策树算法原理 ''' 1.最经典的机器学习模型之一 2.预测结果容易理解，易于解释 3.可处理类别型和连续型数据 ''' ''' 先对哪个特征进行分类？ 信息的量化，基尼不纯度 哪个特征能带来最多的信息变化幅度，就优先选择哪个 如果特征为连续的，先进行离散化处理 ''' ''' 什么时候停止 1.可以到所有特征都划分完毕的时候停止 2.可以设置一个阈值，此时获得的信息增益非常小，达到时停止 ''' ''' 决策树解决过拟合方法： 1.前剪枝：设定一个阈值，信息熵减小的数量小于这个值，停止创建分支 2.后剪枝：决策树创建完成后，对节点检查其信息熵的增益 3.控制决策树的最大深度 '''
3.泰坦尼克号数据集预处理
# 泰坦尼克数据集预处理
data = pd.read_csv('./数据集/train.csv')
print(data.columns)
data = data[['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
data['Age']=data['Age'].fillna(data['Age'].mean()) # 将缺省的年龄值设为平均值
print(data['Age'])
data.fillna(0,inplace=True) # 空白填充法，填充为0，对缺失值进行处理
data['Sex']=[1 if x=='male' else 0 for x in data.Sex] # 使用列表推导式,男性为1，女性为0
data['p1']=np.array(data['Pclass']==1).astype(np.int32)
data['p2']=np.array(data['Pclass']==2).astype(np.int32)
data['p3']=np.array(data['Pclass']==3).astype(np.int32)
# 在数据集中有1，2,3三个登记，为了防止计算机引入默认的线性关系，所以分离出来，比如3是1的三倍
del data['Pclass']# 删除原有列
print(data.Embarked.unique()) # 唯一显示登船港口
data['e1']=np.array(data['Embarked']=='S').astype(np.int32)
data['e2']=np.array(data['Embarked']=='C').astype(np.int32)
data['e3']=np.array(data['Embarked']=='Q').astype(np.int32)
del data['Embarked']
data_train=data[['Sex','Age', 'SibSp', 'Parch', 'Fare','p1','p2','p3','e1','e2','e3']]
print(data_train)
data_target=data['Survived'].values.reshape(len(data),1) # 变为一列
# print(data_target)
print(np.shape(data_train))
print(np.shape(data_target))
数据处理的结果为：
4.决策树模型的建立以及参数的选择
（1）对训练集和测试集进行二八划分
x_train,x_test,y_train,y_test=train_test_split(data_train,data_target,test_size=0.2) # 训练集占百分之八十
print(x_train.shape,x_test.shape)
（2）建立模型进行训练，并查看在训练集和测试集上的准确率：
model=DecisionTreeClassifier()
model.fit(x_train,y_train)
print(model.score(x_test,y_test))
print(model.score(x_train,y_train))
可以看到在训练集上的准确率远远超过在测试集上的准确率，此时出现了过拟合现象，接下来要解决过拟合问题。
（3） 通过调整树的深度找到准确率最高的参数，解决过拟合问题
def m_score(depth):
model=DecisionTreeClassifier(max_depth=depth)
model.fit(x_train,y_train)
train_score=model.score(x_train,y_train)
test_score=model.score(x_test,y_test)
return train_score,test_score
depths=range(2,15)
scores=[m_score(depth) for depth in depths]
# scores=np.array(scores)
for m in scores:
print(m)
train_s=[s[0] for s in scores]
test_s=[s[1] for s in scores]
plt.plot(train_s)
plt.plot(test_s)
plt.show()
树的深度取值设置为从2到15，前面为在训练集上的准确率，后面为在测试集上的准确率，通过这些数据作图，可以找出测试集准确率最高的点
（4）通过设置阈值解决过拟合问题
在下一次分支时如果对于特征的整合程度不超过阈值则不进行分割。
def m_score2(value):
model=DecisionTreeClassifier(min_impurity_decrease=value)
model.fit(x_train,y_train)
train_score=model.score(x_train,y_train)
test_score=model.score(x_test,y_test)
return train_score,test_score
values = np.linspace(0,0.5,50)
scores2=[m_score2(value) for value in values]
train_s2=[s[0] for s in scores2]
test_s2=[s[1] for s in scores2]
best_indes=np.argmax(test_s2) # 取出最大值的索引
best_score=test_s2[best_indes]
best_value=values[best_indes]
print(best_score,best_value)
plt.plot(train_s2,c='red')
plt.plot(test_s2,c='blue')
plt.show()
由于数据集的切分每次都是随机的，所以每次的运行结果都不一样，之后可以采用交叉验证的方式。
（5）完整代码
# 决策树模型的建立以及参数的选择
x_train,x_test,y_train,y_test=train_test_split(data_train,data_target,test_size=0.2) # 训练集占百分之八十
print(x_train.shape,x_test.shape)
model=DecisionTreeClassifier()
model.fit(x_train,y_train)
print(model.score(x_test,y_test))
print(model.score(x_train,y_train))
def m_score(depth):
model=DecisionTreeClassifier(max_depth=depth)
model.fit(x_train,y_train)
train_score=model.score(x_train,y_train)
test_score=model.score(x_test,y_test)
return train_score,test_score
depths=range(2,15)
scores=[m_score(depth) for depth in depths]
# scores=np.array(scores)
for m in scores:
print(m)
train_s=[s[0] for s in scores]
test_s=[s[1] for s in scores]
plt.plot(train_s)
plt.plot(test_s)
plt.show()
def m_score2(value):
model=DecisionTreeClassifier(min_impurity_decrease=value)
model.fit(x_train,y_train)
train_score=model.score(x_train,y_train)
test_score=model.score(x_test,y_test)
return train_score,test_score
values = np.linspace(0,0.5,50)
scores2=[m_score2(value) for value in values]
train_s2=[s[0] for s in scores2]
test_s2=[s[1] for s in scores2]
best_indes=np.argmax(test_s2) # 取出最大值的索引
best_score=test_s2[best_indes]
best_value=values[best_indes]
print(best_score,best_value)
plt.plot(train_s2,c='red')
plt.plot(test_s2,c='blue')
plt.show()
5.交叉验证及多参数选择
# 交叉验证及多参数选择
# 解决随机划分的差异
from sklearn.model_selection import GridSearchCV
values= np.linspace(0,0.5,50)
depths=range(2,15)
param_grid={'max_depth':depths,'min_impurity_split':values}# 以字典形式存储参数
model=GridSearchCV(DecisionTreeClassifier(),param_grid,cv=5)
# cv=5,将数据划分成5份，每次用其中一份作为test，其他4份作为train，循环进行5次交叉验证
model.fit(data_train,data_target) # 对模型进行训练，只填入数据，会自动划分
print('最佳参数为：',model.best_params_) # 获取最佳参数
print('最佳得分为：',model.best_score_) # 获取test数据集上的最佳得分
6.随机森林算法的原理
随机森林算法应用广泛，性能强悍。
7.随机森林算法的代码实现：
（1） 初始化分类器并测试训练准确率
print('————————————————以下为随机森林算法的代码实现——————————————————')
# 继续使用泰坦尼克数据集
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, n_jobs=4) # 初始化随机森林分类器
model.fit(x_train, y_train.ravel()) # .ravel:必须为一列的状态
print(model.score(x_test, y_test)) # 测试集上的正确率
（2）随机森林算法可以查看每个特征的比重
print(model.feature_importances_) # 显示各个特征的重要性，与训练数据的特征对应相关
for futh, imp in zip(['Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'p1', 'p2', 'p3', 'e1', 'e2', 'e3'],
model.feature_importances_):
print(futh, ':', imp)
（3）对一行的数据进行预测
x_test1=np.array(x_test)
print(model.predict(x_test1[0].reshape(1,-1))) # 对一行的数据进行预测
# print(model.predict(x_test[0].reshape(1,-1))) # 对一行的数据进行预测
（4）查看一百棵决策树的信息
print(model.estimators_) # 查看一百棵决策树的信息
（5）进行交叉验证
# 进行交叉验证阶段
from sklearn.model_selection import GridSearchCV
n_estimators = range(80, 130)
param_grid = {'n_estimators': n_estimators}
model = GridSearchCV(RandomForestClassifier(), param_grid=param_grid, cv=5)
model.fit(data_train, data_target.ravel())
print(model.best_params_) # 最佳参数选择
print(model.best_score_) # 最高准确率
（6）完整代码
# 随机森林算法的代码实现
'''
sklearns内置的随机森林函数中的超参数
1.n_estimators:进行投票前或采取平均值前建立树的数量
2.max_features：随机森林中单棵树可拥有的特征最大数量
3.min_sample_leaf:决定叶子的数量
4.n_jobs:允许使用处理器的数量，-1没有限制
'''
print('————————————————以下为随机森林算法的代码实现——————————————————')
# 继续使用泰坦尼克数据集
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, n_jobs=4) # 初始化随机森林分类器
model.fit(x_train, y_train.ravel()) # .ravel:必须为一列的状态
print(model.score(x_test, y_test)) # 测试集上的正确率
print(model.feature_importances_) # 显示各个特征的重要性，与训练数据的特征对应相关
for futh, imp in zip(['Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'p1', 'p2', 'p3', 'e1', 'e2', 'e3'],
model.feature_importances_):
print(futh, ':', imp)
x_test1=np.array(x_test)
print(model.predict(x_test1[0].reshape(1,-1))) # 对一行的数据进行预测
# print(model.predict(x_test[0].reshape(1,-1))) # 对一行的数据进行预测
print(model.estimators_) # 查看一百棵决策树的信息
# 进行交叉验证阶段
from sklearn.model_selection import GridSearchCV
n_estimators = range(80, 130)
param_grid = {'n_estimators': n_estimators}
model = GridSearchCV(RandomForestClassifier(), param_grid=param_grid, cv=5)
model.fit(data_train, data_target.ravel())
print(model.best_params_) # 最佳参数选择
print(model.best_score_) # 最高准确率8.支持向量机算法原理：
9.SVM模型解决德国信用卡数据分类问题
# 在sklearn中实现SVM算法
print('———————————————————————以下为SVM模型解决德国信用卡数据分类问题——————————————————————')
# 支持向量机分类
data = pd.read_csv('./数据集/credit-a.csv', header=None)
print(data.head())
x = data[data.columns[:-1]]
y = data[15].replace(-1, 0)
x_train, x_test, y_train, y_test = train_test_split(x, y)
from sklearn import preprocessing
scaler = preprocessing.StandardScaler().fit(x_train) # 通过x_train构建一个标准化模型，训练一个scaler
x_train = scaler.transform(x_train) # 统一标准化
x_test = scaler.transform(x_test) # 统一标准化,
from sklearn.svm import SVC
model = SVC(kernel="poly", degree=3, C=5)
model.fit(x_train, y_train)
print('多项式核函数准确率为：', model.score(x_test, y_test))
model2 = SVC(kernel="rbf", gamma=0.5, C=5)
model2.fit(x_train, y_train)
print('高斯核函数准确率为：', model2.score(x_test, y_test))
10.完整代码
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
_author_ = '张起凡'
from sklearn.model_selection import train_test_split
from sklearn.linear_model._logistic import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.tree import DecisionTreeClassifier
# 二分类
# 逻辑回归，使用sigmoid函数
# 德国信用卡欺诈数据集分类
data = pd.read_csv("./数据集/credit-a.csv", header=None)
# print(data.head())
x = data[data.columns[:-1]]
y = data[15].replace(-1, 0)
print(y)
x_train, x_test, y_train, y_test = train_test_split(x, y) # 划分训练集和测试集
model = LogisticRegression(max_iter=10000) # 建立模型
model.fit(x_train, y_train) # 使用训练集训练模型
y_pre = model.predict(x_test)
print(y_pre)
# 此时可以直接得到分类预测的结果，但如果想得到sigmoid函数的概率值
y_gailv = model.predict_proba(x_test)
print(y_gailv)
# 最后计算准确率,可以逐一利用循环对比统计准确率，也可以使用sklearn中现成函数
accuracy_sum = accuracy_score(y_pre, y_test)
print(accuracy_sum)
# 如果想提高分类的准确率，需要对数据进行预处理
# 决策树算法原理
'''
1.最经典的机器学习模型之一
2.预测结果容易理解，易于解释
3.可处理类别型和连续型数据
'''
'''
先对哪个特征进行分类？
信息的量化，基尼不纯度
哪个特征能带来最多的信息变化幅度，就优先选择哪个
如果特征为连续的，先进行离散化处理
'''
'''
什么时候停止
1.可以到所有特征都划分完毕的时候停止
2.可以设置一个阈值，此时获得的信息增益非常小，达到时停止
'''
'''
决策树解决过拟合方法：
1.前剪枝：设定一个阈值，信息熵减小的数量小于这个值，停止创建分支
2.后剪枝：决策树创建完成后，对节点检查其信息熵的增益
3.控制决策树的最大深度
'''
# 泰坦尼克数据集预处理
data = pd.read_csv('./数据集/train.csv')
print(data.columns)
data = data[['Survived', 'Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']]
data['Age'] = data['Age'].fillna(data['Age'].mean()) # 将缺省的年龄值设为平均值
print(data['Age'])
data.fillna(0, inplace=True) # 空白填充法，填充为0，对缺失值进行处理
data['Sex'] = [1 if x == 'male' else 0 for x in data.Sex] # 使用列表推导式,男性为1，女性为0
data['p1'] = np.array(data['Pclass'] == 1).astype(np.int32)
data['p2'] = np.array(data['Pclass'] == 2).astype(np.int32)
data['p3'] = np.array(data['Pclass'] == 3).astype(np.int32)
# 在数据集中有1，2,3三个登记，为了防止计算机引入默认的线性关系，所以分离出来，比如3是1的三倍
del data['Pclass'] # 删除原有列
print(data.Embarked.unique()) # 唯一显示登船港口
data['e1'] = np.array(data['Embarked'] == 'S').astype(np.int32)
data['e2'] = np.array(data['Embarked'] == 'C').astype(np.int32)
data['e3'] = np.array(data['Embarked'] == 'Q').astype(np.int32)
del data['Embarked']
data_train = data[['Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'p1', 'p2', 'p3', 'e1', 'e2', 'e3']]
print(data_train)
data_target = data['Survived'].values.reshape(len(data), 1) # 变为一列
# print(data_target)
print(np.shape(data_train))
print(np.shape(data_target))
# 决策树模型的建立以及参数的选择
x_train, x_test, y_train, y_test = train_test_split(data_train, data_target, test_size=0.2) # 训练集占百分之八十
print(x_train.shape, x_test.shape)
model = DecisionTreeClassifier()
model.fit(x_train, y_train)
print(model.score(x_test, y_test))
print(model.score(x_train, y_train))
def m_score(depth):
model = DecisionTreeClassifier(max_depth=depth)
model.fit(x_train, y_train)
train_score = model.score(x_train, y_train)
test_score = model.score(x_test, y_test)
return train_score, test_score
depths = range(2, 15)
scores = [m_score(depth) for depth in depths]
# scores=np.array(scores)
for m in scores:
print(m)
train_s = [s[0] for s in scores]
test_s = [s[1] for s in scores]
plt.plot(train_s)
plt.plot(test_s)
plt.show()
def m_score2(value):
model = DecisionTreeClassifier(min_impurity_decrease=value)
model.fit(x_train, y_train)
train_score = model.score(x_train, y_train)
test_score = model.score(x_test, y_test)
return train_score, test_score
values = np.linspace(0, 0.5, 50)
scores2 = [m_score2(value) for value in values]
train_s2 = [s[0] for s in scores2]
test_s2 = [s[1] for s in scores2]
best_indes = np.argmax(test_s2) # 取出最大值的索引
best_score = test_s2[best_indes]
best_value = values[best_indes]
print(best_score, best_value)
plt.plot(train_s2, c='red')
plt.plot(test_s2, c='blue')
plt.show()
# 交叉验证及多参数选择
# 解决随机划分的差异
from sklearn.model_selection import GridSearchCV
values = np.linspace(0, 0.5, 50)
depths = range(2, 15)
param_grid = {'max_depth': depths, 'min_impurity_split': values} # 以字典形式存储参数
model = GridSearchCV(DecisionTreeClassifier(), param_grid, cv=5)
# cv=5,将数据划分成5份，每次用其中一份作为test，其他4份作为train，循环进行5次交叉验证
model.fit(data_train, data_target) # 对模型进行训练，只填入数据，会自动划分
print('最佳参数为：', model.best_params_) # 获取最佳参数
print('最佳得分为：', model.best_score_) # 获取test数据集上的最佳得分
# 随机森林算法原理
# 随机森林算法的代码实现
'''
sklearns内置的随机森林函数中的超参数
1.n_estimators:进行投票前或采取平均值前建立树的数量
2.max_features：随机森林中单棵树可拥有的特征最大数量
3.min_sample_leaf:决定叶子的数量
4.n_jobs:允许使用处理器的数量，-1没有限制
'''
print('————————————————以下为随机森林算法的代码实现——————————————————')
# 继续使用泰坦尼克数据集
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, n_jobs=4) # 初始化随机森林分类器
model.fit(x_train, y_train.ravel()) # .ravel:必须为一列的状态
print(model.score(x_test, y_test)) # 测试集上的正确率
print(model.feature_importances_) # 显示各个特征的重要性，与训练数据的特征对应相关
for futh, imp in zip(['Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'p1', 'p2', 'p3', 'e1', 'e2', 'e3'],
model.feature_importances_):
print(futh, ':', imp)
x_test1 = np.array(x_test)
print(model.predict(x_test1[0].reshape(1, -1))) # 对一行的数据进行预测
# print(model.predict(x_test[0].reshape(1,-1))) # 对一行的数据进行预测
print(model.estimators_) # 查看一百棵决策树的信息
# 进行交叉验证阶段
from sklearn.model_selection import GridSearchCV
n_estimators = range(80, 130)
param_grid = {'n_estimators': n_estimators}
model = GridSearchCV(RandomForestClassifier(), param_grid=param_grid, cv=5)
model.fit(data_train, data_target.ravel())
print(model.best_params_) # 最佳参数选择
print(model.best_score_) # 最高准确率
# 在sklearn中实现SVM算法
print('———————————————————————以下为SVM模型解决德国信用卡数据分类问题——————————————————————')
# 支持向量机分类
data = pd.read_csv('./数据集/credit-a.csv', header=None)
print(data.head())
x = data[data.columns[:-1]]
y = data[15].replace(-1, 0)
x_train, x_test, y_train, y_test = train_test_split(x, y)
from sklearn import preprocessing
scaler = preprocessing.StandardScaler().fit(x_train) # 通过x_train构建一个标准化模型，训练一个scaler
x_train = scaler.transform(x_train) # 统一标准化
x_test = scaler.transform(x_test) # 统一标准化,
from sklearn.svm import SVC
model = SVC(kernel="poly", degree=3, C=5)
model.fit(x_train, y_train)
print('多项式核函数准确率为：', model.score(x_test, y_test))
model2 = SVC(kernel="rbf", gamma=0.5, C=5)
model2.fit(x_train, y_train)
print('高斯核函数准确率为：', model2.score(x_test, y_test))