机器学习的算法knn,贝叶斯,决策树

sklearn数据集与估计器

数据集划分

机器学习一般的数据集会划分为两个部分：

训练数据：用于训练，构建模型

测试数据：在模型检验时使用，用于评估模型是否有效

数据集划分API

sklearn.model_selection.train_test_split

sklearn.datasets

加载获取流行数据集
from sklearn.datasets import load_*
datasets.load_*()
获取小规模数据集，数据包含在datasets里

datasets.fetch_*(data_home=None)

获取大规模数据集，需要从网络上下载，函
数的第一个参数是data_home，表示数据集
下载的目录,默认是 ~/scikit_learn_data/

获取数据集返回的类型

load*和fetch*返回的数据类型datasets.base.Bunch(字典格式)

data：特征数据数组，是 [n_samples * n_features] 的二维numpy.ndarray 数组

target：标签数组，是 n_samples 的一维 numpy.ndarray 数组

DESCR：数据描述

feature_names：特征名,新闻数据，手写数字、回归数据集没有

target_names：标签名,回归数据集没有

数据集进行分割

from sklearn.model_selection import train_test_split

x： 数据集的特征值

y： 数据集的标签值

test_size： 测试集的大小，一般为float

random_state： 随机数种子,不同的种子会造成不同的随机
采样结果。相同的种子采样结果相同。

return： 训练集特征值，测试集特征值，训练标签，测试标签
(默认随机取)

sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)	
#subset: 'train'或者'test','all'，可选，选择要加载的数据集.训练集的“训练”，测试集的“测试”，两者的“全部”

datasets.clear_data_home(data_home=None)
#清除目录下的数据

步骤

实例化类

name=load_*()

切割数据，输出训练集和测试集的train，test

x_train,x_test,y_train,y_test=train_test_split(li.data,li.target,test_size=0.25)#test_size是测试集的占比

sklearn机器学习算法的实现-估计器

在sklearn中，估计器(estimator)是一个重要的角色，分类器和回归器都属于estimator，是一类实现了算法的API

1、用于分类的估计器：

sklearn.neighbors	k-近邻算法
sklearn.naive_bayes      贝叶斯
sklearn.linear_model.LogisticRegression     逻辑回归

2、用于回归的估计器：

sklearn.linear_model.LinearRegression     线性回归
sklearn.linear_model.Ridge      岭回归 

估计器的工作流程

#分类算法-k近邻算法

定义： 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

来源： KNN算法最早是由Cover和Hart提出的一种分类算法

计算距离公式：
两个样本的距离可以通过如下公式计算，又叫欧式距离。比如说，a(a1,a2,a3),b(b1,b2,b3)

sklearn k-近邻算法API

from sklearn.neighbors import KNeighborsClassifier(n_neighbors=5,algorithm='auto')
	
	#n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数 
	#algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

实列流程

数据的处理

1、缩小数据集范围（a>1&a<2）
DataFrame.query()

2、处理日期数据，转化为时间序列
pd.to_datetime (data[‘time’],unit=‘s’)
pd.DatetimeIndex #时间序列转化为dataframe类型

3、增加分割的日期数据

4、删除没用的日期数据
pd.drop

5、将签到位置少于n个用户的删除
place_count =data.groupby(‘place_id’).aggregate(np.count_nonzero)
tf = place_count[place_count.row_id > 3].reset_index()
data = data[data[‘place_id’].isin(tf.place_id)]

2、分割数据集

#进行数据的分割训练集和测试集
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.25)

3、对数据集进行标准化

#特征工程（标准化）
std=StandardScaler()

#对测试集和训练集进行标准化
x_train = std.fit_transform(x_train)
x_test=std.transform(x_test)

4、estimator流程进行分类预测

#进行算法流程
knn=KNeighborsClassifier()
knn.fit(x_train,y_train)

#得出预测结果
y_predict=knn.predict(x_test)
print('预测的目标值签到位置为:\n',y_predict)

#得出准确率
print("预测的准确率\n",knn.score(x_test,y_test))

交叉验证

#构造一些参数
param = {'n_neighbors':[3,5,10]}

#进行网格搜索
gc = GridSearchCV(knn,param_grid=param,cv = 2)
gc.fit(x_train,y_train)

#预测准确率
print('在测试集上准确率:', gc.score(x_test,y_test))
print('在交叉验证当中最好的结果:', gc.best_score_)
print('选择最好的模型是:',gc.best_estimator_)
print('每个超参数每次交叉验证的结果是:',gc.cv_results_)

k近邻算法实例-预测入住位置

def knn():
    """
    knn算法
    :return:
    """
    #读取数据
    data=pd.read_csv(r"E:\QQ\Download\File\day2\train.csv")
    #取出规定范围的数据(缩小数据范围)
    print(data)
    data=data.query("0<x&x<1.0&y>1.0&y<2.0")
    # data = data.query("x > 1.0 &  x < 1.25 & y > 2.5 & y < 2.75")

    #处理时间数据
    time_value=pd.to_datetime(data["time"],unit="s")

    # 把日期格式转化成字典格式
    time_value = pd.DatetimeIndex(time_value)

    #构造一些特征
    data['day']=time_value.day
    data['hour'] = time_value.hour
    data['weekday'] = time_value.weekday

    #把时间戳数据删除
    data = data.drop(['time'],axis=1)
    # print(data)

    #把标签减少至n的位置（只要>n的数据）
    place_count=data.groupby(by='place_id').count()
    tf=place_count[place_count.row_id>3].reset_index()
    data=data[data['place_id'].isin(tf.place_id)]
    print(tf)

    # 取出数据中发特征值和目标值
    y = data["place_id"]
    x = data.drop(["place_id"], axis=1)


    #进行数据的分割训练集和测试集
    x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.25)

    #特征工程（标准化）
    std=StandardScaler()

    #对测试集和训练集进行标准化
    x_train = std.fit_transform(x_train)
    x_test=std.transform(x_test)

    #进行算法流程
    knn=KNeighborsClassifier()
    knn.fit(x_train,y_train)

    #得出预测结果
    y_predict=knn.predict(x_test)
    print('预测的目标值签到位置为:\n',y_predict)

    #得出准确率
    print("预测的准确率\n",knn.score(x_test,y_test))
##交叉验证
    #构造一些参数
    param = {'n_neighbors':[3,5,10]}

    #进行网格搜索
    gc = GridSearchCV(knn,param_grid=param,cv = 2)
    gc.fit(x_train,y_train)

    #预测准确率
    print('在测试集上准确率:', gc.score(x_test,y_test))
    print('在交叉验证当中最好的结果:', gc.best_score_)
    print('选择最好的模型是:',gc.best_estimator_)
    print('每个超参数每次交叉验证的结果是:',gc.cv_results_)
if __name__ == '__main__':
    knn()

问题

k值取很小：容易受异常点影响
k值取很大：容易受最近数据太多导致比例变化

优缺点

优点：
简单，易于理解，易于实现，无需估计参数，无需训练
缺点：
懒惰算法，对测试样本分类时的计算量大，内存开销大
必须指定K值，K值选择不当则分类精度不能保证
**应用场景：**小数据场景，几千～几万样本，具体场景具体业务
去测试

4、分类评估之混淆矩阵

其他分类标准，F1-score，反映了模型的稳健型

分类模型评估API

from sklearn.metrics import classification_report
	
sklearn.metrics.classification_report(y_true, y_pred, target_names=None)
	#y_true：真实目标值		y_pred：估计器预测目标值
	#target_names：目标类别名称   return：每个类别精确率与召回率

5、分类算法-朴素贝叶斯算法

概率基础： 概率定义为一件事情发生的可能性

###联合概率和条件概率
联合概率： 包含多个条件，且所有条件同时成立的概率

记作：p(A,B)

条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率

记作：p(A|B)

特性：P(A1,A2|B) = P(A1|B)P(A2|B)
注意：此条件概率的成立，是由于A1,A2相互独立的结果
##朴素贝叶斯-贝叶斯公式

拉普拉斯平滑系数

sklearn朴素贝叶斯实现API

from sklearn.naive_bayes import MultinomialNB

sk=sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
#实例化朴素贝叶斯分类	alpha：拉普拉斯平滑系数(基本为1)

朴素贝叶斯的优缺点

优点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。对缺失数据不太敏感，算法也比较简单，常用于文本分类。分类准确度高，速度快。

缺点：
需要知道先验概率P(F1,F2,…|C)，因此在某些时候会由于假设的先验
模型的原因导致预测效果不佳。
#6、朴素贝叶斯算法实例
def news():
“”"
朴素贝叶斯算法预测：
:return:
“”"
news=fetch_20newsgroups(subset=‘all’)
# print(news.data)

    #进行数据分割 （20篇文章3：1分为训练集，测试集）
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.25)

    # 对数据集进行特征抽取
    tf = TfidfVectorizer()

    # 以训练集当中的词的列表进行每篇文章重要性统计['a','b','c','d']
    x_train = tf.fit_transform(x_train)

    # print(tf.get_feature_names())

    x_test = tf.transform(x_test)

    # 进行朴素贝叶斯算法的预测
    mlt = MultinomialNB(alpha=1.0)
    print(x_train.toarray())

    mlt.fit(x_train, y_train)

    y_predict = mlt.predict(x_test)

    print("预测的文章类别为：", y_predict)

    # 得出准确率
    print("准确率为：", mlt.score(x_test, y_test))

    print("每个类别的精确率和召回率：", classification_report(y_test, y_predict, target_names=news.target_names))

    return None

7、模型的选择与调优

交叉验证：为了让被评估的模型更加准确可信
##1、交叉验证
**交叉验证：**将拿到的数据，分为训练和验证集。以下图为例：将数据分
成5份，其中一份作为验证集。然后经过5次(组)的测试，每次都更换不同
的验证集。即得到5组模型的结果，取平均值作为最终结果。又称5折交叉
验证

2、超参数搜索-网格搜索

通常情况下，有很多参数是需要手动指定的（如k-近邻算法中的K值），
这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组
合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建
立模型。

sklearn.model_selection.GridSearchCV

from sklearn.model_selection import GridSearchCV

sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
对估计器的指定参数值进行详尽搜索

estimator：估计器对象
param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}
cv：指定几折交叉验证
fit：输入训练数据
score：准确率
结果分析：
best_score_:在交叉验证中测试的最好结果
best_estimator_：最好的参数模型
cv_results_:每次交叉验证后的测试集准确率结果和训练集准确率结果

8、决策树与随机森林