sklearn中文社区,有哪些汉语学习的 App 推荐

sklearn中文社区,有哪些汉语学习的 App 推荐详细介绍

本文目录一览： 分析技术 建立预测模型及模型的ROC曲线绘制

2020/5/27，受一名同学所托，为他的肿瘤Hub基因分析文章做一个预测模型和模型的ROC曲线、AUC值来验证Hub基因的可靠性。如果Hub基因有意义的话，用Hub基因作为特征建立的预测模型就应该能有效地分类癌组织或者正常组织。

本文结构如下：

首先，数据清洗和Hub基因筛选，他们已经把Hub基因找到了，换句话说可以直接跳过数据清洗和特征工程阶段。

一共10个关键基因，分为三类，高恶度癌（3）、低恶度癌（2）、正常对照组织（1），分别为9、20、20个样本。

首先创建两个.txt文件分别储存图2的特征值内容和标签内容，features.txt 和 label_2.txt（当然也可以直接用Pandas读取表格，个人习惯）然后用Python读入数据。

我在这里定义了一个函数，需要用主函数设置which_class，选择绘制哪一类的ROC

ROC、AUC、micro/macro-average ROC curve的理论部分可以看这个 ROC理论 ，本节简要解读一下多类别ROC图的结果：
这个是直接三分类的训练集：测试集=1：1的ROC曲线，class0代表鉴别正常组织和两种癌组织，class1代表鉴别低恶度癌和另外两种组织，class2代表鉴别高恶度癌和另外两种组织，可以看出class2的AUC值为1，表明Hub基因建立的模型确实可以有效鉴别ATC和另外两种预后较好的组织。

[1] sklearn中文官方文档：支持向量机
[2] Receiver Operating Characteristic (ROC)
[3] Receiver Operating Characteristic (ROC) with cross validation

假设检验：使用p值来接受或拒绝你的假设

作者|GUEST 编译|VK 来源|Analytics Vidhya
检验是统计学中最基本的概念之一。不仅在数据科学中，假设检验在各个领域都很重要。想知道怎么做？让我们举个例子。现在有一个lifebuoy沐浴露。
沐浴露厂商声称，它杀死99.9%的细菌。他们怎么能这么说呢？必须有一种测试技术来证明这种说法是正确的。所以假设检验用来证明一个主张或任何假设。
这个博客将这些概念分解成小部分，这样你就能理解它们的动机和用途。当你读完这个博客，假设检验的基础知识就会很清楚了！！
假设是关于参数值（均值、方差、中值等）的陈述、假设或主张。
比如说，如果我们说“多尼是有史以来最好的印度队长”，这是一个假设，我们是根据他担任队长期间球队的平均输赢情况做出的。我们可以根据所有的匹配数据来测试这个语句。
零假设是在假设为真的前提下，检验假设是否可能被拒绝。类似无罪的概念。我们假定无罪，直到我们有足够的证据证明嫌疑人有罪。
简单地说，我们可以把零假设理解为已经被接受的陈述，例如，天空是蓝色的。我们已经接受这个声明。
替代假设补充了零假设。它与原假设相反，替代假设和原假设一起覆盖了总体参数的所有可能值。
让我们用一个例子来理解这一点：
一家肥皂公司声称他们的产品平均杀死99%的细菌。为了检验这家公司的主张，我们将提出零和替代假设。
零假设（H0）：平均值等于99%
替代假设（H1）：平均值不等于99%。
注意:当我们检验一个假设时，我们假设原假设是真的，直到样本中有足够的证据证明它是假的。在这种情况下，我们拒绝原假设而支持替代假设。
如果样本不能提供足够的证据让我们拒绝零假设，我们不能说零假设是真的，因为它仅仅基于样本数据。零假设成立需要研究整个总体数据。
当一个假设指定了参数的精确值时，这是一个简单的假设，如果它指定了一个值的范围，则称为复合假设。例如
如果替代假设在两个方向（小于和大于）给出了在零假设中指定的参数值的替代，则称为双尾检验。
如果替代假设只在一个方向（小于或大于）给出了在零假设中指定的参数值的替代，则称为单尾检验。例如
根据H1，平均值可以大于或小于100。这是一个双尾检验的例子
同样，
在这里，平均值不到100。这叫做单尾检验。
拒绝域是样本空间中的拒绝区域，如果计算值在其中，那么我们就拒绝零假设。
让我们用一个例子来理解这一点：
假设你想租一套公寓。你从不同的真实国家网站列出了所有可用的公寓。你的预算是15000卢比/月。你不能再花那么多钱了。你所订的公寓清单的价格从7000/月到30000/月不等。
你从列表中随机选择一个公寓，并假设以下假设：
现在，既然你的预算是1.5万，你必须拒绝所有高于这个价格的公寓。
在这里所有价格超过15000成为你的拒绝域。如果随机公寓的价格在这个区域，你必须拒绝你的零假设，如果公寓的价格不在这个区域，你就不能拒绝你的零假设。
根据替代假设，拒绝域位于概率分布曲线的一条或两条尾巴上。拒绝域是与概率分布曲线中的截止值相对应的预定义区域。用α表示。
临界值是将支持或拒绝零假设的值分隔开的值，并根据alpha进行计算。
稍后我们将看到更多的例子，我们将清楚地知道如何选择α。
根据另一种假设，拒绝域出现了三种情况：
案例1 ）这是一个双尾检验。
案例2 ）这种情况也被称为左尾检验。
案例3 ）这种情况也被称为右尾检验。
因此，第一类和第二类错误是假设检验的重要课题之一。让我们把这个话题分解成更小的部分来简化它。
一个假正例（I型错误） ——当你拒绝一个真的零假设时。
假负性（II型错误） ——当你接受一个错误的零假设时。
例子：
这个人因犯有入室盗窃罪而被捕。由法官组成的陪审团必须裁定有罪或无罪。
H0 ：人是无辜的
H1 ：人有罪
第一类错误是如果陪审团判定某人有罪[拒绝接受H0]，尽管此人是无辜的[H0是真的]。
第二类错误将是当陪审团释放该人[不拒绝H0]虽然该人有罪[H1是真的]。
为了理解这个话题，让我们考虑一个例子：假设有一家糖果厂每天生产500克的糖果。工厂维修后的一天，一名工人声称他们不再生产500克的糖果，可能是少了或多了。
那么，这名工人凭什么宣称这一错误？那么，我们应该在哪里画一条线来决定糖果条重量的变化呢？这一决定/界限在统计学上具有重要意义。
顾名思义，我们有多自信：我们在做决定时有多自信。LOC（置信水平）应大于95%。不接受低于95%的置信度。
显著性水平，用最简单的术语来说，就是当事实上是真的时，错误地拒绝零假设的临界概率。这也称为I型错误率。
这是I类错误的概率。它也是拒绝域的大小。
一般来说，在测试中，它是非常低的水平，如0.05（5%）或0.01（1%）。
如果H0在5%的显著性水平上没有被拒绝，那么我们可以说我们的零假设是正确的，有95%的把握。
假设我们在1%的显著性水平上进行假设检验。
H0：平均值
<x （我们只是假设一个单尾检验的情况。）
我们得到临界值（基于我们使用的测试类型），发现我们的测试统计值大于临界值。因此，我们必须在这里拒绝零假设，因为它位于拒绝域。

如果零假设在1%时被拒绝，那么可以肯定的是，在更高的显著性水平上，比如5%或10%，它会被拒绝。

如果我们的显著性水平低于1%，那么我们是否也必须拒绝我们的假设呢？

是的，有可能发生上述情况，而“p值”正在发挥作用。

p值是可以拒绝零假设的最小显著性水平。

这就是为什么现在很多测试都给出p值，而且它更受欢迎，因为它给出的信息比临界值更多。

p值决策

我们比较p值和显著性水平（alpha）对零假设做出决定。

原文链接： https://www.analyticsvidhya.com/blog/2020/07/hypothesis-testing-68351/

欢迎关注磐创AI博客站： http://panchuang.net/

sklearn机器学习中文官方文档： http://sklearn123.com/

欢迎关注磐创博客资源汇总站： http://docs.panchuang.net/

高斯算法求分数？

高斯混合模型GMM
首先介绍高斯分布的概率密度函数。一维高斯分布的概率密度函数如下：
多维变量X=(x1,x2,…xn)的联合概率密度函数为：
这里引用李航《统计学习方法》书中的定义
简而言之，GMM是多个高斯分布的加权和，并且权重α之和等于1 。
Sklearn
sklearn.mixture 是一个应用高斯混合模型进行非监督学习的包(支持 diagonal，spherical，tied，full 四种协方差矩阵)。GaussianMixture 对象实现了用来拟合高斯混合模型的期望最大 (EM) 算法。它还可以为多变量模型绘制置信椭圆体，同时计算 BIC（Bayesian Information Criterion，贝叶斯信息准则）来评估数据中聚类的数量。详情见Sklearn中文官网2.1. 高斯混合模型。
期望最大算法EM
这里引用周志华《机器学习》书中的定义
上面是基本概念。关于数学公式推导，真心建议直接看吴恩达老师的课件。这里给出自己推导的结果
示例演示
演示GMM的使用。
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
from sklearn import mixture
n_samples = 300
# generate random sample, two components
np.random.seed(0)
# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])
# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)
# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])
# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)
# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)
CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)
plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
运行结果

有哪些汉语学习的 App 推荐

随着越来越多的外国人来华学习，掀起“中文热”，汉语学习热度不减，下面推荐几款良心汉语学习应用。
Fun with Chinese Characters（汉字趣画）
华语教学出版社开发的汉字学习App应用“Fun with Chinese Characters”（汉字趣画）是基于iOS操作系统的iPad应用，汉字零起点的英语母语者可以轻松操作。应用精选50个汉字，并将这50个汉字的演变过程分别开发成独立的小游戏，用户过关后汉字解锁，展示汉字演变过程的英文释义及典型字体。此外用户还可以利用这些解锁文字制作“中国画”在社交媒体上分享。
中文学习APP
是一款帮助用户学习中文的应用软件，发音清晰，英汉互译，单字解析，让您快速学习中文！这是一款能够帮助你学习中文的软件。他有中文以及中文拼音。还能为你组一些词组。目前只有8个单元。
普通话发音测试评分
普通话考试
普通话专项提高
普通话考试资讯
普通话学习社区
正音万里行
一款汉语语音学习软件，目前市场上的汉语语音学习应用极度匮乏，上面的几款应用虽说基本具有发音功能，但往往无法进行完整的语音学习。而该应用专门针对汉语声调和汉语拼音的学习，内容完整，有发音讲解，适合参考学习。不过应用虽然可以录音，但不具有语音评测功能。这款应用作为汉语初学者学习汉语拼音的辅助工具也是极好的。
如今手机可谓是生活中难以离身的物件，智能机的普及也使得手机不再仅仅承担着打电话、发短信的功用，我们用它玩游戏、拍照、社交、看新闻等等。当然，我们也可以用它来学习。
随着科技的发展，汉语的学习和教学中的科技元素逐渐进入人们视野。
当科技融入汉语学习。与高科技让汉字变得更形象化相比，高科技辅助汉语语音教学还是个“新生儿”。近年，语音识别、语音合成、语音评测等技术不断发展，为汉语语音教学提供了新思路。已获国家专利的汉语教学语音合成方法及装置是北京语言大学的科研人员在智能汉语语音教学方面做出的探索。该装置试图解决现有技术背景下的汉语学习方案并未针对不同的声调偏误进行因材施教的问题。该技术首先需获取语言学习者语音以及多个标准教师语音，再根据语音参数从标准教师语音中选择与语言学习者语音最接近的语音，最后合成声调教学语音。虽然该技术还处在研发阶段，但技术一旦成熟，则能更好地帮助汉语学习者的语音学习。
实际上，科技不仅有助于教学手段的创新，还融入到教学内容筛选、课程组织实施和测试评价等环节，智能阅卷、批改作业、收集学习数据、推荐个性学习方案等过程中也可见科技的身影。
那么也有很多APP是可以帮助学习汉语的哦，例如，《拼音入门》、《pleco》、《HSK》、《Vocab List》、《Amanda》、《recipes》等等。
但是其实除了APP之外，学习汉语还有很多方法，比如利用多媒体资源：
1，动画片。动画片呢，如果一定要找好的国产片，还要有中文的字幕。中国呢，最流行的就是《喜洋洋和灰太狼》了，但是早期水墨动画还有些早期的《小蝌蚪找妈妈》或者《大闹天宫》什么的也不错。（《机器猫》、《名侦探柯南》、《大头儿子小头爸爸》、《hello kitty》等）
2，电影。要找中文配音的！例如，《功夫熊猫》、《花木兰》、《宝莲灯》等。
3，电视节目。各种纪录片和脱口秀都是很不错的资源。例如，《舌尖上的中国》、《晓松奇谈》、《金星秀》等。
在汉语教育界，甚至整个语言教育界，很多新兴的科技手段的发展都远未达到预期：一是受技术水平制约，没有真正解决问题；二是语言习得本身的特点需要人的充分参与，目前效果最好的语言习得手段还是人与人交流。
事实上，不管学习英语还是汉语，还是其它小语种，通过人与人交流的方式是最快捷并且最有效的，最容易掌握的。
华语教学出版社开发的汉字学习App应用“Fun with Chinese Characters”（汉字趣画）是基于iOS操作系统的iPad应用，汉字零起点的英语母语者可以轻松操作。应用精选50个汉字，并将这50个汉字的演变过程分别开发成独立的小游戏，用户过关后汉字解锁，展示汉字演变过程的英文释义及典型字体。此外用户还可以利用这些解锁文字制作“中国画”在社交媒体上分享。
对外汉语+移动互联网确实很有想象力。用手机学习汉语确实可以给学习的汉语的人带来很多便利，那么有什么APP值得推荐呢？这款 talking learn 就非常不错。建议各位学习汉语的人。
还记得扎克伯格在清华做了一个全程的中文脱稿演讲吗？让在场的中国学生瞠目结舌，外国学生更是羡慕不已。 据说小札学汉语是为了能够跟妻子的家人更好地沟通，那么词汇必然是关键，没有强大的词汇量，有口难言，也只能干着急吧？ 工欲善其事，必先利其器。有没有人曾告诉你，学一门语言，真正的根基在于词汇？今天Talking learn 教你怎么样通过积累词汇让你比扎克伯格更快地学会汉语。
学汉语必备的专业APP——Talking learn，帮你打好根基盖大楼！ To lay the foundation of huge building, all you need is a professional learning Chinese App——Talking learn 你知道吗，扎克每天都花时间学习中文，有成千上万的用户和小札一样，每天登陆Talking learn学习和练习每日汉语，因为Talking learn 练习的种类多样，数量足够，全方位帮助你掌握和巩固，过好词汇关。 Talking learn 的词汇可不是一般的词汇。为了防止枯燥无味，Talking learn 将词汇融入到各个版块的学习内容中。利用不同的感官和方法学习和掌握词汇。
1.特色一、听觉和视觉结合。学一个句子，要先学会每个词，听音、解释、练习和巩固，360度无死角。在已学词汇的基础上拓展例句，理解、应用什么的，完全不是个问题。 2.特色二、跟读和模仿结合。多次练习，一遍又一遍，不怕学不会。在口语练习中，用户可以提交自己的录音，系统自动打分，实时纠正。看到自己的学习成果，很有成就感吧？ 3.特色三、练习和检验结合。学完了，到了检验自己成果的时候了。支持汉字版和拼音版，汉字拼音同时强化，有没有很强大？
此外，还有我们应用商城的一些好的APP，比如英语水平4级考试，中文课堂，学汉语。等等可以下载。

ngram模型在哪些场景运动较多

gram模型是自然语言处理中最常用的语言模型之一, 广泛应用于语音识别、手写识别、拼写纠错、机器翻译和搜索引擎等众多任务. 但是N-gram模型在训练和应用时经常会出现零概率问题, 导致无法获得良好的语言模型, 因此出现了拉普拉斯平滑、卡茨回退和Kneser-Ney平滑等平滑方法. 在介绍了这些平滑方法的基本原理后, 使用困惑度作为度量标准去比较了基于这几种平滑方法所训练出的语言模型.
关键词: N-gram模型 拉普拉斯平滑 卡茨回退 Kneser-Ney平滑
首页
博客
研修院
VIP
APP
问答
下载
社区
推荐频道
活动
招聘
专题
打开CSDN APP
Copyright ? 1999-2020, CSDN.NET, All Rights Reserved
风控模型特征工程
打开APP
风控建模二、特征工程---通用 原创
2022-09-17 11:46:33
1点赞
沐自礼
码龄8年
关注
目录
一、数据预处理
1.1 缺失值
1.2 异常值处理
1.3 样本不均衡处理
二、特征生成
2.1 特征归一化（or 标准化）
2.2 特征放缩（统计信息+ 简单加减乘除）
2.3 哑变量
2.3 分桶
2.4 日期类
2.5 组合特征
2.6 文本型（风控场景中应用比较少，传统nlp应用较多）
2.6.1 词袋模型+Ngram
2.6.2 tf-idf
2.6.3 word2vev/fastext
2.7 embedding
2.8 特征分解 （应用较少）
三、特征筛选
3.1 移除低方差的特征 (Removing features with low variance)
3.2. 单变量特征选择 (Univariate feature selection)
3.2.1 卡方(Chi2)检验
3.2.2 Pearson相关系数 (Pearson Correlation)
3.3 递归特征消除 (Recursive Feature Elimination)
3.4 基于L1的特征选择 (L1-based feature selection)
3.5 xgboost, lightGBM
参考文献
“特征决定了模型的上限， 而算法只是逼近这个上限”，由此可见特征工程在风控建模中的重要程度。 特征工程的本质是基于原始数据的信息提炼， 风控场景中的很多数据源， 单独来看可能和风险表现关联性并不强，但是加工成特征后， 却会与我们想要预测的目标产生紧密的联系。
下面我们将从特征预处理，特征生成，特征筛选三个模块对特征工程进行拆解。
一、数据预处理
1.1 缺失值
一般来说，未经处理的原始数据中通常会存在缺失值，因此在建模训练之前需要处理好缺失值。
1）缺失数据占比小于 20%。可以通过直接填充法，连续特征一般取均值填充，离散特征可以取众数填充；可以模型预测法，通过随机森林或者决策树进行预测结果填充；也可以通过插值法填充。
2）缺失数据占比大于 20% 小于 50%，这个时候可以把缺失值构建为新的特征，增加一列离散特征，即有缺失数据和无缺失数据。
3）缺失数据占比大于 50%，因为信息量较少，模型可能会学到大量噪音建议直接删除该特征。
像 xgboost 模型自带缺失值处理功能，可以不进行缺失值处理。
缺失值填充方法：
1). 如果是连续性，就使用平均值插补，如果是离散性，就使用众数来插补。 当然也可以用特殊值、中位数等代替。 其中采用均值填充的缺点：大大降低数据的方差
2). 随机插补法----从总体中随机抽取某个样本代替缺失样本
3). 引入预测模型，可考虑辅助回归，通过变量间的关系来预测缺失数据
下面代码就是均值填充的两种方案：
df_train['Age'].fillna(value=df_train['Age'].mean()).sample(10)

from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
df_train.loc[:,'Age'] = df_train['Age'].fillna(value=df_train['Age'].mean()).copy()
df_train.head(10)
1.2 异常值处理
异常值，即在数据集中存在不合理的值，又称离群点、极值等。可以通过统计分析、箱线图、聚类、3σ 原则、孤立森林等方法进行检查。
一般的处理方法如下：
1）直接删除含有异常值的样本。
2）视为缺失值。利用缺失值处理的方法进行处理。
3）最近值修正。可以用相近的观测值修正该异常值。
4）不处理。可以直接在具有异常值的数据集上进行数据建模。
大部分建模时，通过画图的方式进行看一下即可。
提供的方法：
统计分析，看四分位数，看数据分布。
箱线图：使用画图工具比如seaborn库 调用boxplot，distplot看一下。
聚类：使用sklearn中的聚类函数。
3σ: 需要自己同统计，类似看四分位数。
1.3 样本不均衡处理
推荐包：imbalance learn (https://imbalanced-learn.org/stable/references/index.html)
后面章节会对样本不均衡做详细的介绍，暂时可以先简单了解一下。一般应用场景中，常用样本不均衡的是解决方案为1,2。
样本不均衡现象是指正样本数目与负样本数目比列相差很大。处理方法如下：
1）下采样/欠采样(under sampling)：从多数类中随机抽取样本从而减少多数类别样本数据，使数据达到平衡的方式。比如本来样本正负例的比例是 10:1，可以对正样本进行下采样构建 10 个正负样本比例为 1:1 的模型，回归结果取平均值，分类结果进行投票。
2）上采样/过采样(Over Sampling)：和欠采样采用同样的原理，通过抽样来增加少数样本的数目，从而达到数据平衡的目的。同样比如本来样本正负例的比例是 10:1，可以对负样本进行上采样构建正负样本比例为 1:1 的模型。
3）Smote 算法：Smote 算法属于上采样的一种，通过人工合成的方法来生成少类别的样本。方法也很简单，对于某一个缺少样本的类别，它会随机找出几个该类别的样本，再找出最靠近这些样本的若干个该类别样本，组成一个候选合成集合，然后在这个集合中不停的选择距离较近的两个样本，在这两个样本之间，比如中点，构造一个新的该类别样本。举个例子，比如该类别的候选合成集合有两个样本(x1,y),(x2,y)(x1,y),(x2,y)，那么Smote采样后，可以得到一个新的训练样本(x1+x22,y)(x1+x22,y)，通过这种方法，我们可以得到不改变训练集分布的新样本，让训练集中各个类别的样本数趋于平衡。
4）Focal loss ：主要解决分类样本不平衡问题，通过修改交叉熵损失函数，通过增加类别权重 α 和样本难度权重调因子(modulating factor)(1?pt)γ(1?pt)γ，来减缓上述问题。
5）设置损失函数的权重：使得少数类别数据判断错误的损失大于多数类别数据判断错误的损失，即当我们的少数类别数据预测错误的时候，会产生一个比较大的损失值，从而导致模型参数往让少数类别数据预测准确的方向偏。
二、特征生成
2.1 特征归一化（or 标准化）
应用于数值类特征。
归一化（标准化），就是要把你需要处理的数据经过处理后（通过某种算法）限制在你需要的一定范围内。其目的一是把不同量纲的东西放在同一量纲下，保正程序运行时收敛加快，大部分模型归一化后收敛速度会加快。但像树模型不受特征归一化影响，所以不需要特征归一化。
归一化处理：最大最小值归一化或者叫 0-1 归一化，取值范围在 [0,1] 处理，max 为样本最大值， min 为样本最小值。
标准化处理：这里只介绍一种经常使用的 z-score 标准化，经过处理后的数据均值为 0，标准差为 1，符合标准的正态分布。其中 mean 为平均值，б 为标准差。
# 幅度缩放，最大最小值缩放到[0,1]区间内
from sklearn.preprocessing import MinMaxScaler
mm_scaler = MinMaxScaler()
fare_trans = mm_scaler.fit_transform(df_train[['Fare']])
# 幅度缩放，将每一列的数据标准化为正态分布的
from sklearn.preprocessing import StandardScaler
std_scaler = StandardScaler()
fare_std_trans = std_scaler.fit_transform(df_train[['Fare']])
#中位数或者四分位数去中心化数据，对异常值不敏感
from sklearn.preprocessing import robust_scale
fare_robust_trans = robust_scale(df_train[['Fare','Age']])
#将同一行数据规范化,前面的同一变为1以内也可以达到这样的效果
from sklearn.preprocessing import Normalizer
normalizer = Normalizer()
fare_normal_trans = normalizer.fit_transform(df_train[['Age','Fare']])
fare_normal_trans
2.2 特征放缩（统计信息+ 简单加减乘除）
应用于数值类特征，可以引入log非线性进行放缩。
import numpy as np
log_age = df_train['Age'].apply(lambda x:np.log(x))
df_train.loc[:,'log_age'] = log_age
# 最大最小值
max_age = df_train['Age'].max()
min_age = df_train["Age"].min()
# 分位数,极值处理，我们最粗暴的方法就是将前后1%的值抹去
age_quarter_01 = df_train['Age'].quantile(0.01)
print(age_quarter_01)
age_quarter_99 = df_train['Age'].quantile(0.99)
print(age_quarter_99)
df_train.loc[:,'family_size'] = df_train['SibSp']+df_train['Parch']+1
df_train.head() df_train.loc[:,'tmp'] = df_train['Age']*df_train['Pclass'] + 4*df_train['family_size']
df_train.head()
2.3 哑变量
哑变量用于类别，一般如性别，分为男女两列。
embarked_oht = pd.get_dummies(df_train[['Embarked']])
embarked_oht.head()
2.3 分桶
应用于数值。
可以等频分桶，也可以自行指定区间分桶。非线性变化。
# 等频切分
df_train.loc[:,'fare_qcut'] = pd.qcut(df_train['Fare'], 10)
df_train.head()
df_train = df_train.sort_values('Fare')
alist = list(set(df_train['fare_qcut']))
badrate = {}
for x in alist:
a = df_train[df_train.fare_qcut == x]
bad = a[a.label == 1]['label'].count()
good = a[a.label == 0]['label'

python scikit-learn 有什么算法

1，前言
很久不发文章，主要是Copy别人的总感觉有些不爽，所以整理些干货，希望相互学习吧。不啰嗦，进入主题吧，本文主要时说的为朴素贝叶斯分类算法。与逻辑回归，决策树一样，是较为广泛使用的有监督分类算法，简单且易于理解（号称十大数据挖掘算法中最简单的算法）。但其在处理文本分类，邮件分类，拼写纠错，中文分词，统计机器翻译等自然语言处理范畴较为广泛使用，或许主要得益于基于概率理论，本文主要为小编从理论理解到实践的过程记录。
2，公式推断
一些贝叶斯定理预习知识：我们知道当事件A和事件B独立时，P（AB）=P（A）（B），但如果事件不独立，则P（AB）=P（A）P（B|A）。为两件事件同时发生时的一般公式，即无论事件A和B是否独立。当然也可以写成P（AB）=P（B）P（A|B），表示若要两件事同事发生，则需要事件B发生后，事件A也要发生。
由上可知，P（A）P（B|A）= P（B）P（A|B）
推出P（B|A）=
其中P（B）为先验概率，P（B|A）为B的后验概率，P（A|B）为A的后验概率（在这里也为似然值），P（A）为A的先验概率（在这也为归一化常量）。
由上推导可知，其实朴素贝叶斯法就是在贝叶斯定理基础上，加上特征条件独立假设，对特定输入的X（样本，包含N个特征），求出后验概率最大值时的类标签Y（如是否为垃圾邮件），理解起来比逻辑回归要简单多，有木有，这也是本算法优点之一，当然运行起来由于得益于特征独立假设，运行速度也更快。
. 参数估计
3，参数估计
由上面推断出的公式，我们知道其实朴素贝叶斯方法的学习就是对概率P(Y=ck)和P(X(j)=x(j)|Y=ck)的估计。我们可以用极大似然估计法估计上述先验概率和条件概率。
其中I(x)为指示函数，若括号内成立，则计1，否则为0。李航的课本直接给出了用极大似然（MLE）估计求出的结果，并没给推导过程，
我们知道，贝叶斯较为常见的问题为0概率问题。为此，需要平滑处理，主要使用拉普拉斯平滑，如下所示：
K是类的个数，Sj是第j维特征的最大取值。实际上平滑因子λ=0即为最大似然估计，这时会出现提到的0概率问题；而λ=1则避免了0概率问题，这种方法被称为拉普拉斯平滑。
4，算法流程
5，朴素贝叶斯算法优缺点
优点：朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率
需调参较少，简单高效，尤其是在文本分类/垃圾文本过滤/情感判别等自然语言处理有广泛应用。
在样本量较少情况下，也能获得较好效果，计算复杂度较小，即使在多分类问题。
无论是类别类输入还是数值型输入（默认符合正态分布）都有相应模型可以运用。
缺点：0概率问题，需要平滑处理，通常为拉普拉斯平滑，但加一平滑不一定为效果最好，
朴素贝叶斯有分布独立的假设前提，生活中较少完全独立，在属性个数比较多或者属性之间相关性较大时，NBC模型的分类效率比不上决策树模型。而在属性相关性较小时，NBC模型的性能最为良好。
模型注意点：
1， 大家也知道，很多特征是连续数值型的，一般选择使用朴素贝叶斯高斯模型。
2， 为避免0概率事件，记得平滑，简单一点可以用『拉普拉斯平滑』。先处理处理特征，把相关特征去掉，
3， 朴素贝叶斯分类器一般可调参数比较少，需集中精力进行数据的预处理等特征工程工作。
6，Scikit-learn三大朴素贝叶斯模型
Scikit-learn里面有3种不同类型的朴素贝叶斯（：
1， 高斯分布型模型：用于classification问题，假定属性/特征是服从正态分布的，一般用在数值型特征。,
2， 多项式型模型：用于离散值模型里。比如文本分类问题里面我们提到过，我们不光看词语是否在文本中出现，也得看出现的次数。如果总词数为n，出现词数为m的话，说起来有点像掷骰子n次出现m次这个词的场景。
3， 伯努利模型：这种情况下，就如提到的bag ofwords处理方式一样，最后得到的特征只有0(没出现)和1(出现过)。
7. Scikit-learn算法实践
小编通过实现朴素贝叶斯三种模型以及主要分类算法，对比发现跟SVM，随机森林，融合算法相比，贝叶斯差距明显，但其时间消耗要远低于上述算法，以下为主要算法主要评估指标）。
8. Python代码
# -*-coding: utf-8 -*-
importtime
fromsklearn import metrics
fromsklearn.naive_bayes import GaussianNB
fromsklearn.naive_bayes import MultinomialNB
fromsklearn.naive_bayes import BernoulliNB
fromsklearn.neighbors import KNeighborsClassifier
fromsklearn.linear_model import LogisticRegression
fromsklearn.ensemble import RandomForestClassifier
fromsklearn import tree
fromsklearn.ensemble import GradientBoostingClassifier
fromsklearn.svm import SVC
importnumpy as np
importurllib
# urlwith dataset
url ="-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
#download the file
raw_data= urllib.request.urlopen(url)
#load the CSV file as a numpy matrix
dataset= np.loadtxt(raw_data, delimiter=",")
#separate the data from the target attributes
X =dataset[:,0:7]
#X=preprocessing.MinMaxScaler().fit_transform(x)
#print(X)
y =dataset[:,8]
print("\n调用scikit的朴素贝叶斯算法包GaussianNB ")
model= GaussianNB()
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的朴素贝叶斯算法包MultinomialNB ")
model= MultinomialNB(alpha=1)
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的朴素贝叶斯算法包BernoulliNB ")
model= BernoulliNB(alpha=1,binarize=0.0)
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的KNeighborsClassifier ")
model= KNeighborsClassifier()
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的LogisticRegression(penalty='l2') ")
model= LogisticRegression(penalty='l2')
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的RandomForestClassifier(n_estimators=8) ")
model= RandomForestClassifier(n_estimators=8)
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的tree.DecisionTreeClassifier() ")
model= tree.DecisionTreeClassifier()
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的GradientBoostingClassifier(n_estimators=200) ")
model= GradientBoostingClassifier(n_estimators=200)
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
print("\n调用scikit的SVC(kernel='rbf', probability=True) ")
model= SVC(kernel='rbf', probability=True)
start_time= time.time()
model.fit(X,y)
print('training took %fs!' % (time.time() - start_time))
print(model)
expected= y
predicted= model.predict(X)
print(metrics.classification_report(expected,predicted))
print(metrics.confusion_matrix(expected,predicted))
"""
# 预处理代码集锦
importpandas as pd
df=pd.DataFrame(dataset)
print(df.head(3))
print(df.describe())##描述性分析
print(df.corr())##各特征相关性分析
##计算每行每列数据的缺失值个数
defnum_missing(x):
return sum(x.isnull())
print("Missing values per column:")
print(df.apply(num_missing, axis=0)) #axis=0代表函数应用于每一列
print("\nMissing values per row:")
print(df.apply(num_missing, axis=1).head()) #axis=1代表函数应用于每一行"""

数据科学统计学：什么是偏度？

简单分析一下，答案如图所示
作者|ABHISHEK SHARMA 编译|VK 来源|Analytics Vidhya
偏度的概念已融入我们的思维方式。当我们看到一个图像时，我们的大脑会直观地分辨出图表中的模式。
你可能已经知道，印度有超过50%的人口在25岁以下，65%以上的人口在35岁以下。
如果你画出印度人口年龄的分布图，你会发现在分布的左边有一个凸起，而右边是相对平坦的。换言之，我们可以说有个偏度倾向于末端。
所以，即使你没有读过数据科学或分析专业人士的偏度，你肯定已经在非正式上与这个概念进行了互动。
在统计学中，这实际上是一个相当简单的话题，然而很多人在匆忙学习其他看似复杂的数据科学概念的过程中匆匆浏览了一下这个概念。对我来说，这是个错误。
偏度是数据科学和分析领域的每个人都需要知道的一个基本统计学概念。这是我们无法逃避的。我相信你会在这篇文章的结尾理解这一点。
在这里，我们将以最简单的方式讨论倾斜的概念。你将了解偏度、它的类型以及它在数据科学领域中的重要性。
所以，系好安全带，因为你会学到一个在你整个数据科学职业生涯中都会重视的概念。
偏度是理想对称概率分布不对称性的度量，由三阶标准矩给出。如果这听起来太复杂了，别担心！我来给你解释一下。
简言之，偏度是衡量随机变量的概率分布偏离正态分布的程度。现在，你可能会想，为什么我在这里谈论正态分布？
正态分布是没有任何偏度的概率分布。你可以看看下面的图片，它显示了对称分布，基本上是正态分布，你可以看到虚线两边是对称的。除此之外，还有两种类型的偏度：
尾巴在右边的概率分布是正偏态分布，尾巴在左边的概率分布是负偏态分布。如果你觉得上面的数字令人困惑，没关系。我们稍后会更详细地了解这一点。
在此之前，让我们来了解为什么偏度对于作为数据科学专业人士的你来说是如此重要的概念。
现在，我们知道偏度是不对称性的度量，它的类型是由概率分布尾巴所在的那一边来区分的。但是为什么知道数据的偏度很重要呢
首先，线性模型假设自变量和目标变量的分布相似。因此，了解数据的偏度有助于我们创建更好的线性模型。
其次，让我们看看下面的分布。它是汽车的马力分布：
你可以清楚地看到上面的分布是正偏度的。现在，假设你想把这个作为模型的一个特性，它可以预测汽车的mpg（英里/加仑）。
因为我们的数据在这里是正偏度的，这意味着它有更多的低值数据点，也就是说，马力较小的汽车。
因此，当我们根据这些数据训练我们的模型时，它将在预测低马力汽车的mpg方面表现得比那些高马力的汽车更好。
另外，偏度告诉我们异常值的方向。你可以看到我们的分布是正偏度的，并且大多数异常值都出现在分布的右侧。
注意：偏度并不能告诉我们异常值的数量。它只告诉我们方向。
现在我们知道了为什么偏度很重要，让我们来了解一下我之前给你们看的分布。
是的，我们又回到正态分布了。
正态分布被用作确定分布的偏度度的参考。正如我前面提到的，理想的正态分布是几乎没有偏度的概率分布。它几乎完全对称。因此，正态分布的偏度值为零。
但是，为什么它几乎完全对称而不是绝对对称？
这是因为，事实上，没有一个真实的数据完全符合正态分布。因此，偏度的值不完全为零；它几乎为零。虽然零值被用作确定分布的偏度度的参考。
你可以在上图中看到，同一条线表示平均值、中值和众数。这是因为完全正态分布的平均值、中值和众数是相等的。
到目前为止，我们已经用概率或频率分布来理解正态分布的偏度。现在，让我们用箱线图来理解它，因为这是在数据科学领域观察分布的最常见的方法。
上图是对称分布的箱线图。你会注意到Q1和Q2之间的距离是相等的，即：
但这还不足以得出一个分布是否倾斜的结论。我们还看一下线的长度；如果它们相等，那么我们可以说分布是对称的，也就是说，它不是倾斜的。
既然我们已经讨论了正态分布中的偏度，现在是时候了解一下我们前面讨论过的两种类型的偏度了。让我们从正偏度开始。
正偏态分布是尾部在右侧的分布。正偏态分布的偏度值大于零。你可能已经通过观察这个数字了解到，平均值是最大的，然后是中位数，然后是众数。
为什么会这样？
好吧，答案是，分布的尾巴在右边；它导致平均值大于中值，平均值最终向右移动。此外，众数出现在分布的最高频率，即中位数的左侧。因此， 众数
<中位数<平均值 。
在上面的框线图中，你可以看到Q2靠近Q1。这代表了一个正偏态分布。根据四分位数，可以通过以下公式得出：

在这种情况下，很容易判断数据是否倾斜。但是如果我们有这样的图呢：

这里，Q2-Q1和Q3-Q2是相等的，但是分布是正偏度的。你们当中目光敏锐的人会注意到右线的长度大于左线的长度。由此，我们可以得出结论，数据是正偏度的。

所以，第一步总是检查Q2-Q1和Q3-Q2的相等性。如果这是相等的，那么我们寻找线的长度。

正如你可能已经猜到的，负偏态分布是尾巴位于左侧的分布。负偏态分布的偏度值小于零。你还可以在上图中看到 均值
<中值<众数 。
在箱线图中，负偏度四分位数之间的关系由以下公式给出：

与我们之前所做的类似，如果Q3-Q2和Q2-Q1相等，那么我们寻找线的长度。如果左线的长度大于右线的长度，那么我们可以说数据是负偏度的。

既然你知道倾斜数据会对机器学习模型的预测能力产生多大影响，那么最好将倾斜数据转换为正态分布数据。以下是一些可以转换倾斜数据的方法：

注 ：转换的选择取决于数据的统计特性。

在本文中，我们讨论了偏度的概念、它的类型以及它在数据科学领域中的重要性。我们在概念层面上讨论了偏度，但是如果你想更深入地研究，下一步你可以探索它的数学部分。

原文链接： https://www.analyticsvidhya.com/blog/2020/07/what-is-skewness-statistics/

欢迎关注磐创AI博客站： http://panchuang.net/

sklearn机器学习中文官方文档： http://sklearn123.com/

欢迎关注磐创博客资源汇总站： http://docs.panchuang.net/
</中值
</中位数

报错记录1-sklearn无法导入cross_validation 2- tensorflow报错AttributeError _parse_flags

1-
错误信息：
cannot import name 'cross_validation' from sklearn

错误原因：
scikit-learn 0.22.1版本中，cross_validation被去掉了

错误解决：
现在的cross_validation函数在model_selection中，所以只需要将所有的cross_validation替换为model_selection就可以了。

2-
错误信息：
AttributeError: _parse_flags

错误原因：
tensorflow的版本更新

错误解决：
将FLAGS._parse_flags()替换为FLAGS.flag_values_dict()

3-
错误信息：
SyntaxError: Non-ASCII character in file

错误原因：
脚本的注释用的是中文

错误解决：
在开始的地方添加一句

协同过滤，矩阵分解有感

????这个概念经常在机器学习的文章中看到，但由于接触不久，所以一直都是一知半解，没有好好了解过。

? ? 首先从字面上理解，“协同”需要一个“集体“，“过滤”就应该是晒选的意思，那么协同过滤总的来说就是通过“集体”来“筛选”，以评分推荐系统为例子，这里的“协同”我个人理解就是集合”众多人的评价”，这里的“评价”，就是“对集体都接触过的事物进行打分”，这样大概就能通过一些共同的事物反应出用户不同的”价值观“，然后通过这样的价值观来”筛选“出价值观高度相似的人，再相互推荐共同都喜爱的东西。那么这样的推荐就很有可能是大家都需要的。

? ? 经过资料洗礼过后，得知cf现在的两大方向，一种是以记忆为基础（Memory-base）,另一种是基于模型（Model-based Collaborative Filtering）。

????普及的比较多的前者，它基于关注的目标，又分为基于用户的协同过滤和基于项目的协同过滤，上面举的一个简单的评分推荐系统的例子就可以说是基于用户的协同过滤，它是通过用户对共同物品的“主观价值”来筛选相似用户，再互补评分高的商品，从而达到推荐商品的目的；那么基于项目的意思就是通过这个用户集体对商品集的评价，在物品的角度上去寻找相似度高的物品，达到推荐商品的效果。虽然针对的目标不通，但以我个人理解，大体上都是依赖这个用户集营造的“价值观”，只不过区别在于，基于用户的CF是“关心”各个用户的“主观价值”上的“区别”，而基于项目的CF则是要基于这整个用户集对项目集的“普世价值观”，来甄别出“物品”上的差异。不知道这么比喻恰不恰当哈，“普世”我这边理解就是“大多数”，是一种整体趋势的意思。价值观比较“抽象”的话，再直接点这里的“价值观”就相当于物理中的“参考系”。

????但是以上两种方法在面对，不是每个用户对大多数商品都做出过评价（数据稀疏）时就无能为力，所以基于这个问题就引导出了基于模型（Model-based ）的CF，我在最近的论文中接触到的就是一个“矩阵分解”的协同过滤，它能够基于现有的数据得到一个模型，再用此模型进行推荐。那么是如何做到的呢？接下来看看矩阵分解。

? ? 假设我先在有一个关于用户对音乐评分的矩阵如下图：

????只有上述的数据是很难使用户相互推荐音乐的，因为可以看出用户本身听过的歌就不够多，那么如何使数据更加“饱满”呢？这时正是需要矩阵分解的时候，矩阵分解算法的数学理论基础是矩阵的行列变换。行列变换中又有以下规则，我们知道矩阵A进行行变换相当于A左乘一个矩阵，矩阵A进行列变换等价于矩阵A右乘一个矩阵，因此矩阵A可以表示为A=PEQ=PQ（E是标准阵）。

? ? 形象的表示如下图：

????矩阵分解的目的就是把一个稀疏的用户评分矩阵分解成用户因子矩阵和项目因子矩阵相乘的形式R=U(转置)*I，我们的目的就是最后再让两个因子矩阵反乘回去得到饱满的用户评分矩阵。那么这个用户,项目因子是个什么东西呢？我们接着上面的音乐评分的形式说，一首歌可能包含多种音乐风格，我们可以量化风格，体现各种风格在一首歌中的比重，那么这里的“潜在因子”我们就可以当作“音乐风格”，K个因子就可以看作K种风格。譬如下图：

????可以说，这些因子就是我们的模型中的重要参数，个人理解分解出来的这两个因子矩阵就可以说是基于模型的CF中的，“模型”的了，其实我觉得可以类比线性模型中的参数，我们的回归模型最终重要的不就是公式中的各项参数吗，这两个因子矩阵其实就是我们这个模型中的重要参数，参数知道了模型也就求出来了。如果不了解线性模型可以参考吴恩达大大的机器学习课程，里面介绍的很详细，不像我这边一知半哈。

????那么这些个值具体是怎么得出来的呢？过程和求线性回归也很像，接下来就是相关的简单推倒，首先，我们假设，真实的用户评分和我们预测评分的差遵循高斯分布

R用是评分矩阵 ? U是用户因子矩阵，V是项目因子矩阵

接下来就是极大似然估计，使，在现有数据下概率最大化

????类比求线性模型，就能够了解思想很相似，所以应该同样是运用了似然估计的思想，要使值最大，式子两边同时取对数，可以看到，如果要使概率最大，那么公式的第一项就要最小，是不是想到了什么，没错接下来就可以看到最小二乘法的式子。

? ? 线性模型我们遇到这个情况一般怎么做，没错，就是梯度下降。首先求偏导数

最后就是梯度下降的矩阵因子更新公式：

????接下来迭代到自己设置的阈值收敛就能得到局部最优解了。

????下面是我根据上述矩阵分解的思想随机的模拟实践，可以自行感受一下准度，可能写搓了点～

注释：以上诸多图片材料来自网上多篇博客文章

https://www.zhihu.com/question/26743347

http://blog.csdn.net/dream_angel_z/article/details/46288167

还有方便实用sklearn的中文API文档

http://cwiki.apachecn.org/pages/viewpage.action?pageId=10030193

ValueError： buffer source array is read-only

调用scikit-learn的随机森林接口时，模型预测语句执行时，遇到报错ValueError: buffer source array is read-only

解决方法：

根据报错提示，可能是cpython相关报错。参考github的一些 报错讨论 、还有 这个 ，图1。

检查pandas安装的包

本来显示的Cython是None的，所以试着安装一下cython，参考官方文档（ 英文 、 中文 ）

安装好后，在运行着的jupyter notebook中是直接可以看到cython的版本的，见图2.但是，需要重启jupyter notebook！如果不重启jupyter notebook的话是无法生效的，自己就在这一点上被坑了一个小时，一直以为是自己的数据格式或者大小的问题。

具体报错：

---------------------------------------------------------------------------ValueErrorTraceback (most recent call last)

in

----> 1 y_pred_rt=pipeline.predict_proba(nd_X_test)[:,1] 2fpr_rt_lm,tpr_rt_lm,_=roc_curve(nd_y_test,y_pred_rt)~/.local/lib/python3.6/site-packages/sklearn/utils/metaestimators.pyin

(*args, **kwargs) 114 115# lambda, but not partial, allows help() to work with update_wrapper--> 116 out=lambda*args,**kwargs:self.fn(obj,*args,**kwargs) 117# update the docstring of the returned function 118update_wrapper(out,self.fn)~/.local/lib/python3.6/site-packages/sklearn/pipeline.pyinpredict_proba(self, X) 469Xt=X 470for_,name,transforminself._iter(with_final=False):--> 471 Xt=transform.transform(Xt) 472returnself.steps[-1][-1].predict_proba(Xt) 473~/.local/lib/python3.6/site-packages/sklearn/ensemble/_forest.pyintransform(self, X) 2251""" 2252check_is_fitted(self)-> 2253 returnself.one_hot_encoder_.transform(self.apply(X))~/.local/lib/python3.6/site-packages/sklearn/ensemble/_forest.pyinapply(self, X) 226**_joblib_parallel_args(prefer="threads"))( 227delayed(tree.apply)(X,check_input=False)--> 228 for tree in self.estimators_) 229 230returnnp.array(results).T~/.local/lib/python3.6/site-packages/joblib/parallel.pyin__call__(self, iterable) 1002# remaining jobs. 1003self._iterating=False-> 1004 ifself.dispatch_one_batch(iterator): 1005self._iterating=self._original_iteratorisnotNone 1006~/.local/lib/python3.6/site-packages/joblib/parallel.pyindispatch_one_batch(self, iterator) 833returnFalse 834else:--> 835 self._dispatch(tasks) 836returnTrue 837~/.local/lib/python3.6/site-packages/joblib/parallel.pyin_dispatch(self, batch) 752withself._lock: 753job_idx=len(self._jobs)--> 754 job=self._backend.apply_async(batch,callback=cb) 755# A job can complete so quickly than its callback is 756# called before we get here, causing self._jobs to~/.local/lib/python3.6/site-packages/joblib/_parallel_backends.pyinapply_async(self, func, callback) 207defapply_async(self,func,callback=None): 208"""Schedule a func to be run"""--> 209 result=ImmediateResult(func) 210ifcallback: 211callback(result)~/.local/lib/python3.6/site-packages/joblib/_parallel_backends.pyin__init__(self, batch) 588# Don't delay the application, to avoid keeping the input 589# arguments in memory--> 590 self.results=batch() 591 592defget(self):~/.local/lib/python3.6/site-packages/joblib/parallel.pyin__call__(self) 254withparallel_backend(self._backend,n_jobs=self._n_jobs): 255return [func(*args, **kwargs)--> 256 for func, args, kwargs in self.items] 257 258def__len__(self):~/.local/lib/python3.6/site-packages/joblib/parallel.pyin

(.0) 254withparallel_backend(self._backend,n_jobs=self._n_jobs): 255return [func(*args, **kwargs)--> 256 for func, args, kwargs in self.items] 257 258def__len__(self):~/.local/lib/python3.6/site-packages/sklearn/tree/_classes.pyinapply(self, X, check_input) 471check_is_fitted(self) 472X=self._validate_X_predict(X,check_input)--> 473 returnself.tree_.apply(X) 474 475defdecision_path(self,X,check_input=True):sklearn/tree/_tree.pyxinsklearn.tree._tree.Tree.apply()sklearn/tree/_tree.pyxinsklearn.tree._tree.Tree.apply()sklearn/tree/_tree.pyxinsklearn.tree._tree.Tree._apply_dense()~/.local/lib/python3.6/site-packages/sklearn/tree/_tree.cpython-36m-x86_64-linux-gnu.soinView.MemoryView.memoryview_cwrapper()~/.local/lib/python3.6/site-packages/sklearn/tree/_tree.cpython-36m-x86_64-linux-gnu.soinView.MemoryView.memoryview.__cinit__()ValueError: buffer source array is read-only

具体的报错截图：