python实现机器学习

1、数据预处理：iris数据介绍、数据加载、数据展示、维度确认

数据预处理：
iris数据加载
数据展示
确认数据维度
使用scikit-learn进行数据处理的四个关键点

1区分开属性数据与结果数据
2属性数据与结果数据都是量化的
3运算过程中，属性数据与结果数据的类型都是Numpy数组
4属性数据与结果数据的维度是对应的

iris数据加载
from sklearn import datasets
iris = datasets.load_iris()

数据展示
iris.data
iris.feature_name
iris.target
iris.target_name

确认数据类型与数据维度
print(type(iris.data))
print(type(iris.target))
print(iris.data.shape)
print(iris.target.shape

2、模型训练：分类问题、KNN模型、模型加载、训练、预测

分类问题场景：垃圾邮件、三类或两类以下的品种的分类
分类算法：K近邻、逻辑回归、决策树、朴素贝叶斯
调用KNN模型：from sklearn.neighbors import KNeighborsclassifier
创建一个KNN模型实例knn = KNeighborsClassifier(n_neighbors=1)
模型训练（学习）：knn.fit(X,y)
模型预测：knn.predict([[1,2,3,4]])

使用scikit-learn建模四步骤
调用需要使用的模型类
模型初始化，创建一个模型实例
模型训练
模型预测

分类问题介绍
分类： 根据数据集目标的特征或者属性，划分到已有类别中
常用的分类算法：K近邻（KNN），逻辑回归、决策树、朴素贝叶斯

KNN
给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的K个实例，这K个实例的多数属于某个类，就把该输入实例分类到这个类中。

sklearn建模四步骤
调用需要使用的模型类
模型初始化（创建一个实例）
模型训练
模型预测

from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target
print(X.shape)
print(y.shape)

knn_1 = KNeighborsClassifier(n_neighbors=1)
knn_1.fit(X,y)
knn_1.predict([[1,2,3,4]])

3、模型评估：准确率、数据分离、参数选择
模型评估
#模型训练之全数据集

from sklearn.neighbors import KNeighborsClassifier
knn_1 = KNeighborsClassifier(n_neighbors=1)
knn_1.fit(X,y)
y1_pre = knn_1.predict(X)
print(y1_pre.shape)

#模型评估之准确率
from sklearn.metrics import accuracy_score
print(accuracy_score(y,y1_pre))

# 模型评估 比较不同K值 模型的好坏
# 全数据集训练与预测
# 训练数据集、测试数据集分离
# 如何选择模型合适的参数，预测新数据对应结果

将整个数据集用于训练与测试，训练数据与测试数据相同导致的问题：
1）训练模型的最终目标是为了预测新数据对应的结果
2）最大化训练准确率通常会导致模型复杂化
3) 过度复杂模型容易导致训练数据的过度拟合

用所有的数据进行训练可能会适得其反，不仅模型复杂化，且准确度不一定更高
评估思想：将训练数据和测试数据分离
判断模型的准确率：比较预测结果和实际结果，正解的比例占到多少
from sklearn.metrics import accuracy_scoreprint(accuracy_score(y,y_pred))

数据分离：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.4)
定义一个k的范围：k_range = list(range(1,26))
定义变量存储多个数据：score_train = []
将单个数据存储在范围变量中：score_train.append(accuracy_score(y_train, y_train_pred))

定义一个循环：for k in k_range：
以线的形式绘制一个对比图：
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot(k_range,score_test)
plt.xlabel('K(Knn model)')
plt.ylabel('test_accuracy')
当k=1的时候，模型是最复杂的

#在一定范围内寻求最优解

k_range = list(range(1,26))
#print(k_range)
scores_train = []
scores_test = []

for k in k_range:
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train,y_train)
y_train_pred = knn.predict(X_train)
y_test_pred = knn.predict(X_test)
scores_train.append(accuracy_score(y_train,y_train_pred))
scores_test.append(accuracy_score(y_test,y_test_pred))

for k in k_range:
print(k,scores_train[k-1])

import matplotlib.pyplot as plt
#在该界面展示
%matplotlib inline
plt.plot(k_range,scores_train)
plt.xlabel('K(KNN mode)')
plt.ylabel('Training Accuracy')

4、模型评估: 逻辑回归、混淆矩阵、召回率、F1分数

逻辑回归：计算概率判断类别，应用场景 二分类问题

准确率预测的局限性：准确度存在空准确率的问题（直接丢掉了负样本，只关注正样本）、没有体现实际分布情况、没有体现模型错误预测类型

混淆矩阵：又称为误差矩阵，衡量分类算法的准确程度，含6个指标

准确率 (TP+TN)/(TP+TN+FP+FN)
错误率 （FP+FN）/(TP+TN+FP+FN)
召回率 TP/(TP+FN)
特异度 TN/(TN+FP)
精确率 TP/(TP+FP)
F1分数 2*精确率*召回率/(精确率+召回率)

逻辑回归模型：计算数据归属于某一类别的概率P，根据概率数值判断其类别。主要应用于二分类问题

逻辑回归模型
准确率进行模型评估有其局限性，只能看到整体，而不知细节。
比如1000个数据（900个1，100个0),全部预测为1 ，整体准确率是90%，而实际上0全部预测为1，错误率100%，而1的准确率是100%
逻辑回归模型主要应用场景就是二分类问题：比如是不是垃圾邮件，是猫还是狗
神经网络模型也是基于此原理实现的

import pandas as pd
path = 'data/pima-indians-diabetes.csv'
pima=pd.read_csv(path)
pima.head()

#X,y赋值

feature_name=['pregnant','insulin','bmi','age']
X = pima[feature_names]
y =pima.label

#确认维度
print(X.shape)
print(y.shape)

#数据分离

from sklearn.model_selection import train_test_split
X_trian,X_test,y_train,y_test = train_test_split(X，y,random_state=0)

#模型训练

from sklearn.linear_model import logisticregression
logReg = logisticRegression()
logReg.fit(X_train,y_train)
y_pred = logReg.predict(X_test)
from sklearn import metric
print("metrics.accuracy_score(y_test,y_pred)

##确认正负样本的数据量以及空准确率

y_test.value_counts()
y_test.mean()
1-y_test.mean()
max(y_test.mean(),1-y_test.mean())

#展示部分书记结果与预测结果
print(y_test.value[0:25]
pritn(y_pred[0:25]

#计算并展示混淆矩阵
confusion = metrics.confusion_metrix(y_test,y_pred)

#四个因子赋值

TN = confusion[0][0]
FP = confusion[0][1]
FN = confusion[1][0]
TP = confusion[1][1]

#指标计算

accuracy = (TP+TN)/(TP+TN+FP+FN)
mis_rate =(FP+FN)/（TP+TN+FP+FN)
recall =TP/(TP+FN)
specificity =TN(TN+FP)
precision = TP/(TP+FP)
f1_score = 2*precison*recall/(precision+recall)