朴素贝叶斯
现分别有 A、B 两个容器，
在容器 A 里分别有 7 个红球和 3 个白球，
在容器 B 里有 1 个红球和 9 个白球，
现已知从这两个容器里任意抽出了一个球，且是红球，
问这个红球是来自容器 A 的概率是多少?
设 球来自A容器是 事件A 来自容器A的概率是 P(A) = 1/2
设 球是红球 是 事件B 球是红球的概率 P(B) = 8/20
已知是红球的前提下 来自A的概率 P(A|B)=P(B|A)*P(A)/P(B)
P(B|A)表示 球是从A容器中取出来的前提下 球是红球的概率 P(B|A)=7/10
P(A|B)= 7/10*1/2/(8/20)
一座别墅在过去的 20 年里一共发生过 2 次被盗，
别墅的主人有一条狗，狗平均每周晚上叫 3 次，
在盗贼入侵时狗叫的概率被估计为 0.9，
问题是：在狗叫的时候发生入侵的概率是多少？
假设狗叫是事件A P(A) = 3/7
盗贼入侵是事件B P(B) = 2/(20*365)
盗贼入侵的前提下 狗 叫了 的概率 P(A|B)=9/10
狗叫的前提下 发生盗贼入侵的概率
P(B|A)=P(A|B)P(B)/P(A)=9/102/(20*365)/(3/7)
【关键词】朴素：独立性假设、贝叶斯公式
优点：
- 朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率；
- 对小规模的数据表现很好；
- 能处理多分类任务，适合增量式训练；
- 对缺失数据不太敏感，算法也比较简单，常用于文本分类
缺点：
- 只能用于分类问题
- 需要计算先验概率；
- 分类决策存在错误率；
- 对输入数据的表达形式很敏感
一、朴素贝叶斯原理
朴素贝叶斯算法是一个典型的统计学习方法，主要理论基础就是一个贝叶斯公式，贝叶斯公式的基本定义如下：
这个公式虽然看上去简单，但它却能总结历史，预知未来：
- 公式的右边是总结历史
- 公式的左边是预知未来
如果把Y看成类别，X看成特征，P(Yk|X)就是在已知特征X的情况下求Yk类别的概率，而对P(Yk|X)的计算又全部转化到类别Yk的特征分布上来。
举个例子，大学的时候，某男生经常去图书室晚自习，发现他喜欢的那个女生也常去那个自习室，心中窃喜，于是每天买点好吃点在那个自习室蹲点等她来，可是人家女生不一定每天都来，眼看天气渐渐炎热，图书馆又不开空调，如果那个女生没有去自习室，该男生也就不去，每次男生鼓足勇气说：“嘿，你明天还来不？”,“啊，不知道，看情况”。
然后该男生每天就把她去自习室与否以及一些其他情况做一下记录，用Y表示该女生是否去自习室，即Y={去，不去}，X是跟去自习室有关联的一系列条件，比如当天上了哪门主课，蹲点统计了一段时间后，该男生打算今天不再蹲点，而是先预测一下她会不会去，现在已经知道了今天上了常微分方法这么主课，于是计算P(Y=去|常微分方程)与P(Y=不去|常微分方程)，看哪个概率大，如果P(Y=去|常微分方程) >P(Y=不去|常微分方程)，那这个男生不管多热都屁颠屁颠去自习室了，否则不就去自习室受罪了。P(Y=去|常微分方程)的计算可以转为计算以前她去的情况下，那天主课是常微分的概率P(常微分方程|Y=去)，注意公式右边的分母对每个类别（去/不去）都是一样的，所以计算的时候忽略掉分母，这样虽然得到的概率值已经不再是0~1之间，但是通过比较大小还是能选择类别。
后来他发现还有一些其他条件可以挖，比如当天星期几、当天的天气，以及上一次与她在自修室的气氛，统计了一段时间后，该男子一计算，发现不好算了，因为总结历史的公式：
这里n=4，x(1)表示主课，x(2)表示天气，x(3)表示星期几，x(4)表示气氛，Y仍然是{去，不去}，现在主课有8门，天气有晴、雨、阴三种、气氛有A+,A,B+,B，C五种，那么总共需要估计的参数有8×3×7×5×2=1680个，每天只能收集到一条数据，那么等凑齐1680条数据，大学都毕业了，男生大呼不妙，于是做了一个独立性假设，假设这些影响她去自习室的原因是独立互不相关的，于是：
有了这个独立假设后，需要估计的参数就变为，(8+3+7+5)×2 = 46个了，而且每天收集的一条数据，可以提供4个参数，这样该男生就预测越来越准了。
朴素的概念：独立性假设，假设各个特征之间是独立不相关的（这一点对于自然语言处理非常重要）。
P(去|上了数学课) = P(上了数学课|去)*P(去)/P(上了数学课)
P(不去|上了数学课)= P(上了数学课|不去)*P(不去)/P(上了数学课)
P(上了数学课|去)P(去) ?? P(上了数学课|不去)P(不去)
今天我们好像要搬家啦 # 5000**10
5000*10 我们知道 单词的前后是有关了的 所以 这种独立性假设是错误 肯定降低了分析的准确度
但是 至少 我们可以计算了
二、3种贝叶斯模型
1、高斯分布朴素贝叶斯
高斯分布就是正态分布
【用途】用于一般分类问题（两种类型的分布差异明显时适合使用）
使用自带的鸢尾花数据
from sklearn.datasets import load_iris
iris = load_iris()
data = iris.data # 特征值
target = iris.target # 目标值
先取前面两个特征看看分类效果
import matplotlib.pyplot as plt
# 先取前两个 特征 分别作为 x和y 画图 看分类效果 （对比 knn lgr）
X_train = data[:,:2]
y_train = target
plt.scatter(X_train[:,0],X_train[:,1],c=target) # 一会儿 是为了给大家 展示 分类效果 所以只选两个特征
# （如果真的要分类准确 肯定是四个特征都考虑）
# 取遍平面上的所有点
xmin,xmax = X_train[:,0].min(),X_train[:,0].max() # 找到x轴的最小值和最大值
ymin,ymax = X_train[:,1].min(),X_train[:,1].max() # 找到y轴的最小值和最大值
import numpy as np
x = np.linspace(xmin,xmax,100) # 根据x的最小值和最大值 在整个范围内取100个点（取遍）
y = np.linspace(ymin,ymax,100)
xx,yy = np.meshgrid(x,y) # 交叉 网格化
X_test = np.c_[xx.flatten(),yy.flatten()] # 把x中在内容 扁平化 y里面的内容也扁平化
使用机器学习模型 去分类 （获取模型 训练模型 使用模型去预测）
from sklearn.naive_bayes import GaussianNB # 高斯贝叶斯
gnb = GaussianNB()
gnb.fit(X_train,y_train)
y_ = gnb.predict(X_test)
plt.scatter(X_test[:,0],X_test[:,1],c=y_) # 高斯朴素贝叶斯的预测结果
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
y2_ = knn.predict(X_test)
plt.scatter(X_test[:,0],X_test[:,1],c=y2_) # knn的预测结果
from sklearn.linear_model import LogisticRegression
lgc = LogisticRegression()
lgc.fit(X_train,y_train)
y3_ = lgc.predict(X_test)
plt.scatter(X_test[:,0],X_test[:,1],c=y3_) # 逻辑回归的预测结果
# 逻辑回归中 各个特征都有其权重
# gnb 高斯朴素贝叶斯 一般是用来对 符合正态分布的 数据 进行分类的
# 这类数据 的分布 一般是 中间多 周围少
简单看看分类的准确率
# 刚才 是需要绘图 给大家展示效果 所以只取了两个特征
# 接下来真正要分类了 所有的特征都取
# 并且要 把 数据集 分成 训练集 和 测试集
from sklearn.model_selection import train_test_split
data.shape
X_train,X_test,y_train,y_test = train_test_split(data,target,test_size=0.15)
gnb.fit(X_train,y_train)
gnb.score(X_test,y_test)
X_train,X_test,y_train,y_test = train_test_split(data,target,test_size=0.15)
knn.fit(X_train,y_train)
knn.score(X_test,y_test)
X_train,X_test,y_train,y_test = train_test_split(data,target,test_size=0.15)
lgc.fit(X_train,y_train)
lgc.score(X_test,y_test)
# lgc 优势是 使用的时候 速度很快
# 不过 lgc准确率比knn 稍低 而且训练时间长
2、多项式分布朴素贝叶斯
【用途】适用于文本数据（特征表示的是次数，例如某个词语的出现次数）
3、伯努利分布朴素贝叶斯
【用途】适用于伯努利分布，也适用于文本数据（此时特征表示的是是否出现，例如某个词语的出现为1，不出现为0）
绝大多数情况下表现不如多项式分布，但有的时候伯努利分布表现得要比多项式分布要好，尤其是对于小数量级的文本数据
三、文本分类实战
对短信进行二分类，数据为SMSSpamCollection
# spam是垃圾邮件 ham是正常邮件
import pandas as pd
# 最开始的一列 不是列索引 要设置header=None
df = pd.read_table('./data/SMSSpamCollection.tsv',header=None)
df.head()
target = df[0] # 目标值
data = df[1] # 特征值
data.shape
X_train,X_test,y_train,y_test = train_test_split(data,target)
# 获取模型
from sklearn.naive_bayes import GaussianNB,MultinomialNB,BernoulliNB # MultinomialNB多项式 BernoulliNB二项式
# 使用训练集去训练
mnb = MultinomialNB()
# X_train # 现在的X_train都是文本内容
mnb.fit(X_train,y_train)
训练模型
注意： 不能直接用文本内容去训练机器学习模型
mnb.fit(data,target) # 机器学习模型 肯定无法直接对 文本信息进行学习
我们需要对文本信息 进行特征值抽取
最后是使用文本的特征值 对 机器学习模型 进行训练
导包
导入sklearn.feature_extraction.text.TfidfVectorizer用于转换字符串
读取短信数据
tf.fit_transform()
- 参数必须是字符串的一维数组（比如列表或者Series）
- 返回的是一个稀疏矩阵类型的对象，行数为样本数，列数为所有出现的单词统计个数。
这里输入data[1]是Series类型，返回的是一个5572x8713 sparse matrix 其中5572是data[1]
# feature_extraction 特征抽取
# text 文本特征的抽取
# TfidfVectorizer
# Tfidf tf idf
# tf term frequency 词频 词语在文章中出现的频率
# idf inverse document frequency 逆文档频率
# Tfidf 其实就是 某个次在当前文章中出现的频率/这个词语在所有文章中出现的频率
from sklearn.feature_extraction.text import TfidfVectorizer
tfidf = TfidfVectorizer() # 获取模型(这个模型可以把 文档内容向量化)
# raw_documents 原文档 传入原文档
# Learn vocabulary and idf from training set 从训练集中学习 词汇表 和 idf
tfidf.fit(data) # 训练模型
data.shape
# 使用训练好的模型去转换文本内容
tfidf.transform(data)
# sparse matrix 稀疏矩阵 矩阵中的每一列就是一个单词 这个稀疏矩阵统计了每个样本中 每个单词出现的次数
tfidf_data = tfidf.fit_transform(data) # 如果 训练和转换 使用的是 同一个数据集 就可以使用 fit_transform 训练好了之后直接转换
训练数据
X_train,X_test,y_train,y_test = train_test_split(tfidf_data,target)
mnb.fit(X_train,y_train) # 训练集的 特征值和目标值
mnb.predict(X_test)
y_test
mnb.score(X_test,y_test)
预测数据，使用tf.transform([‘xx’])进行转换生成测试数据 传入的数据可以是一个列表，列表中装各个内容
tfidf_X_test2 = tfidf.transform([
'Who is your dady',
'Hi, laowang do you want to do something interesting with a men',
'100% MoneyBack Guaranteeed'
])
# 这里需要传入 tfidf处理后的 样本
mnb.predict(tfidf_X_test2)
四、垃圾邮件分类
（自己练习一下吧！）
对email进行二分类，两种邮件分别在ham和spam目录下
读取文件用open(file_path,encoding = ‘gbk’,errors=‘ignore’).read()
决策树
【关键词】树，信息增益
决策树的优缺点：
优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关特征数据。既能用于分类，也能用于回归
缺点：可能会产生过度匹配问题
一、决策树的原理
【二十个问题的游戏】
游戏的规则很简单：参与游戏的一方在脑海里想某个事物，其他参与者向他提问题，只允许提20个问题，问题的答案也只能用对或错回答。问问题的人通过推断分解，逐步缩小待猜测事物的范围。决策树的工作原理与20个问题类似，用户输人一系列数据 ，然后给出游戏的答案。
我们经常使用决策树处理分类问题。近来的调查表明决策树也是最经常使用的数据挖掘算法。它之所以如此流行，一个很重要的原因就是使用者基本上不用了解机器学习算法，也不用深究它是如何工作的。
如果以前没有接触过决策树，完全不用担心，它的概念非常简单。即使不知道它也可以通过简单的图形了解其工作原理。
决策树分类的思想类似于找对象。现想象一个女孩的母亲要给这个女孩介绍男朋友，于是有了下面的对话：
女儿：多大年纪了？
母亲：26。
女儿：长的帅不帅？
母亲：挺帅的。
女儿：收入高不？
母亲：不算很高，中等情况。
女儿：是公务员不？
母亲：是，在税务局上班呢。
女儿：那好，我去见见。
这个女孩的决策过程就是典型的分类树决策。相当于通过年龄、长相、收入和是否公务员对将男人分为两个类别：见和不见。
有了上面直观的认识，我们可以正式定义决策树了：
决策树（decision tree）是一个树结构（可以是二叉树或非二叉树）。其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个类别。使用决策树进行决策的过程就是从根节点开始，测试待分类项中相应的特征属性，并按照其值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。
可以看到，决策树的决策过程非常直观，容易被人理解。目前决策树已经成功运用于医学、制造产业、天文学、分支生物学以及商业等诸多领域。
之前介绍的K-近邻算法可以完成很多分类任务，但是它最大的缺点就是无法给出数据的内在含义，决策树的主要优势就在于数据形式非常容易理解。
决策树算法能够读取数据集合，构建类似于上面的决策树。决策树很多任务都是为了数据中所蕴含的知识信息，因此决策树可以使用不熟悉的数据集合，并从中提取出一系列规则，机器学习算法最终将使用这些机器从数据集中创造的规则。专家系统中经常使用决策树，而且决策树给出结果往往可以匹敌在当前领域具有几十年工作经验的人类专家。
知道了决策树的定义以及其应用方法，下面介绍决策树的构造算法。
二、决策树的构造
分类解决离散问题，回归解决连续问题
- 决策树：信息论
- 逻辑斯底回归、贝叶斯：概率论
不同于逻辑斯蒂回归和贝叶斯算法，决策树的构造过程不依赖领域知识，它使用属性选择度量来选择将元组最好地划分成不同的类的属性。所谓决策树的构造就是进行属性选择度量确定各个特征属性之间的拓扑结构。
构造决策树的关键步骤是分裂属性。所谓分裂属性就是在某个节点处按照某一特征属性的不同划分构造不同的分支，其目标是让各个分裂子集尽可能地“纯”。尽可能“纯”就是尽量让一个分裂子集中待分类项属于同一类别。分裂属性分为三种不同的情况：
1、属性是离散值且不要求生成二叉决策树。此时用属性的每一个划分作为一个分支。
2、属性是离散值且要求生成二叉决策树。此时使用属性划分的一个子集进行测试，按照“属于此子集”和“不属于此子集”分成两个分支。
3、属性是连续值。此时确定一个值作为分裂点split_point，按照>split_point和<=split_point生成两个分支。
构造决策树的关键性内容是进行属性选择度量，属性选择度量是一种选择分裂准则，它决定了拓扑结构及分裂点split_point的选择。
属性选择度量算法有很多，一般使用自顶向下递归分治法，并采用不回溯的贪心策略。这里介绍常用的ID3算法。
ID3算法
划分数据集的大原则是：将无序的数据变得更加有序。
我们可以使用多种方法划分数据集，但是每种方法都有各自的优缺点。组织杂乱无章数据的一种方法就是使用信息论度量信息，信息论是量化处理信息的分支科学。我们可以在划分数据之前使用信息论量化度量信息的内容。
在划分数据集之前之后信息发生的变化称为信息增益，知道如何计算信息增益，我们就可以计算每个特征值划分数据集获得的信息增益，获得信息增益最高的特征就是最好的选择。
在可以评测哪种数据划分方式是最好的数据划分之前，我们必须学习如何计算信息增益。集合信息的度量方式称为香农熵或者简称为熵，这个名字来源于信息论之父克劳德•香农。
entropy
熵定义为信息的期望值，在明晰这个概念之前，我们必须知道信息的定义。如果待分类的事务可能划分在多个分类之中，则符号x的信息定义为：
其中p(x)是选择该分类的概率
为了计算熵，我们需要计算所有类别所有可能值包含的信息期望值，通过下面的公式得到：
其中n是分类的数目。
在决策树当中，设D为用类别对训练元组进行的划分，则D的熵（entropy）表示为：
其中pi表示第i个类别在整个训练元组中出现的概率，可以用属于此类别元素的数量除以训练元组元素总数量作为估计。熵的实际意义表示是D中元组的类标号所需要的平均信息量。
现在我们假设将训练元组D按属性A进行划分，则A对D划分的期望信息为：
而信息增益即为两者的差值：
ID3算法就是在每次需要分裂时，计算每个属性的增益率，然后选择增益率最大的属性进行分裂。下面我们继续用SNS社区中不真实账号检测的例子说明如何使用ID3算法构造决策树。
练习
-
计算女神的回答中的信息熵
-(0.5math.log2(0.5)+0.5math.log2(0.5)) # 模棱两可
-(0.9math.log2(0.9)+0.1math.log2(0.1))
-(0.999math.log2(0.999)+0.001math.log2(0.001)) # 不确定性以及很小了
-(1*math.log2(1))import math
-(0.999math.log2(0.999)+0.001math.log2(0.001))
import numpy as np
import matplotlib.pyplot as plt绘图（留着）
X = np.arange(0.01,1,0.01) # [0.01,0.99] 每隔0.01取一个
y = []
for i in X:
# print(-(i*math.log2(i)+(1-i)math.log2(1-i)))
y.append(-(imath.log2(i)+(1-i)*math.log2(1-i)))plt.scatter(X,y)
plt.grid()
2、计算上图的信息熵，确定下一个分类的特征
# 判断账号是否真实的系统中 的 信息熵
# n 0.3
# y 0.7
info_D = -(0.3*math.log2(0.3)+0.7*math.log2(0.7))
info_D # 原本的信息熵
# 按照 日志密度这一特征判断 帐号是否真实的系统中 的 信息熵 # 累加(当前特征的概率*当前特征中的信息熵)
# s 0.3 n=2 y=1
# m 0.4 n=1 y=3
# l 0.3 n=0 y=3
info_D_L = -0.3*((2/3)*math.log2(2/3)+(1/3)*math.log2(1/3))-0.4*((1/4)*math.log2(1/4)+(3/4)*math.log2(3/4))
info_D_L
info_D - info_D_L # 信息增益
# 按照 好友密度这一特征判断 帐号是否真实的系统中 的 信息熵
# s 0.4 n=3 y=1
# m 0.4 n=0 y=4
# l 0.2 n=0 y=2
info_D_F = -0.4*((3/4)*math.log2(3/4)+(1/4)*math.log2(1/4))
info_D-info_D_F
# 求 依据是否使用真实头像判断 帐号是否真实 的 信息熵
# 结论： 优先按照 好友密度 然后是 日志密度 最后是 头像
3、使用决策树对帐号真实情况做判断，体会决策树模型的特性
# 日志密度 s m l 0 1 2
# 好友密度 s m l 0 1 2
# 头像 n y 0 1
# s s n
# s l y
# l m y
# m m y
# l m y
# m l n
# m s n
# l m n
# m s n
# s s y
# 0 0 0
# 0 2 1
# 2 1 1
# 1 1 1
# 2 1 1
# 1 2 0
# 1 0 0
# 2 1 0
# 1 0 0
# 0 0 1
# 特征值
X_train = np.array([
[0,0,0],
[0,2,1],
[2,1,1],
[1,1,1],
[2,1,1],
[1,2,0],
[1,0,0],
[2,1,0],
[1,0,0],
[0,0,1],
])
# 目标值
y_train = np.array([0,1,1,1,1,1,0,1,1,0])
y_train
from sklearn.tree import DecisionTreeClassifier
dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train)
# 三列 分别是 日志密度 好友密度 头像真假
dtree.predict([
[0,0,0], # 日致密度低 好友密度低 头像是假的
[0,1,0], # 其他两个特征都不好 好友密度还可以
[2,0,1], # 其他两个特征都好 好友密度不行
])
三、实战
【注意】 参数max_depth越大，越容易过拟合
1、使用自带的iris数据集
from sklearn.datasets import load_iris
iris = load_iris()
data = iris.data
target = iris.target
无需切分训练集和测试集 取出前两个特征绘图看分类效果
X_train = data[:,:2]
y_train = target
plt.scatter(X_train[:,0],X_train[:,1],c=y_train)
使用决策树算法
# 分类问题 用DecisionTreeClassifier 回归问题 用DecisionTreeRegressor
from sklearn.tree import DecisionTreeClassifier
# max_depth 默认是none 会分成很多区域 直到每一个区域内 只有一个分类位置
# max_depth=1 分1次 分成2份
# max_depth=2 分2次 分成4份
# max_depth=3 分3次 分成8份
# max_depth决策深度 如果太小 容易欠拟合
dtree = DecisionTreeClassifier(max_depth=10)
dtree.fit(X_train,y_train)
# 取遍整个画布
xmin,xmax = X_train[:,0].min(),X_train[:,0].max()
ymin,ymax = X_train[:,1].min(),X_train[:,1].max()
x = np.linspace(xmin,xmax,100)
y = np.linspace(ymin,ymax,100)
xx,yy = np.meshgrid(x,y)
X_test = np.c_[xx.flatten(),yy.flatten()] # 画布上所有的点的座标
y_ = dtree.predict(X_test)
plt.scatter(X_test[:,0],X_test[:,1],c=y_)
plt.scatter(X_test[:,0],X_test[:,1],c=y2_)
使用KNN算法
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(X_train,y_train)
y2_ = knn.predict(X_test)
使用逻辑斯蒂回归算法
max_depth指的是决策深度
如果max_depth取值太小 容易欠拟合 取值太大容易过拟合(这个问题不好解决 将来可以使用 随机森林来解决)
处理分类问题
有明确的业务逻辑（反映到图上 是 很规整的散点） 这个时候适合用决策树
knn(容易过拟合)和lgc（容易欠拟合）
能不用knn 尽量不用knn 样本量稍微大一点 速度就会很慢 内存消耗就会很太大
2、使用回归预测一个椭圆
引入决策树的回归模型
from sklearn.tree import DecisionTreeRegressor
在-np.pi到np.pi的范围 中 产生200个点
生成正弦值和余弦值
然后根据正弦值和余弦值产生目标值
from sklearn.tree import DecisionTreeRegressor
# 先产生200个点
X_train = np.linspace(-np.pi,np.pi,200)
s = np.sin(X_train)
c = np.cos(X_train)
plt.scatter(X_train,s)
plt.scatter(X_train,c)
plt.figure(figsize=(5,5))
plt.scatter(s,c)
np.c_[s,c]
# 把s,c作为目标值的两列
y_train = np.c_[s,c]
plt.scatter(y_train[:,0],y_train[:,1])
撒盐操作，让圆上的40个点不规则的显示在圆的周围
y_train
# 40行2列
noise = np.random.randn(40,2)/10
noise
target.shape
y_train[::5]+=noise
plt.scatter(y_train[:,0],y_train[:,1])
创建不同深度的决策树
进行数据训练
# max_depth
dtree = DecisionTreeRegressor(max_depth=6)
dtree.fit(X_train.reshape(-1,1),y_train)
X_test = np.linspace(-np.pi,np.pi,180)
X_test
对数据进行预测
y_ = dtree.predict(X_test.reshape(-1,1))
显示图片
y_
plt.figure(figsize=(5,5))
plt.scatter(y_[:,0],y_[:,1])
决策树的回归用的很少
容易过拟合或者欠拟合
同时预测出来的值还不连续
思考：给你一个样本和目标值，通过代码计算各个特征的信息增益
随机森林
# max_depth
# knn lgc gnb dtree xxx
# 随机森林就是一个集成方法 只不过里面集成的模型全都是决策树模型
# ensemble就是集成的意思
from sklearn.ensemble import RandomForestClassifier
data = iris.data
target = iris.target
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(data,target)
# 一个决策树 是 树 好多棵树 就是森林了
# n_estimators 用来指定里面使用多少个决策树来对分类进行预测和投票
rfc = RandomForestClassifier(n_estimators=9)
rfc.fit(X_train,y_train)
rfc.score(X_test,y_test)
dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train)
dtree.score(X_test,y_test)
# 对比 普通的决策树 和 随机森林 的差异
X_train,X_test,y_train,y_test = train_test_split(data,target)
rfc.fit(X_train,y_train)
dtree.fit(X_train,y_train)
rfc.score(X_test,y_test),dtree.score(X_test,y_test)
# 即使有的时候 可能 随机森林打分 比决策树 还低
# 但是 随机森林 很低的分数也不会低的离谱 而决策树可能会非常低
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
