本文目录
- matlab 怎么输出confusion matrix
- python scikit-learn 有什么算法
- R中随机森林函数所画的图怎么理解
- confusionmatrix输出结果怎么看
- python里面一些简单代码的含义是什么（题主零基础）
- 如何用python画好confusion matrix
- python是否有绘制混淆矩阵的函数，怎么来实现
- r使用随机森林实现所属类别的概率吗
- 隐马尔可夫模型的模型表达
matlab 怎么输出confusion matrix
以Training confusion matrix为例。 M（1，1），对应内含[1000，17.1%]数字。表示，有1000个输出为1类中，被正确反应了是1类。M（1，2），表示：在253个输出为1类中，却实际上是属于第2类。M（1，3），对应内含[79.8%，20.2%]。表示，在输出的1中，有79.8%被正确反应了。M（3，1），对应内含[69.5%，30.5%]。表示，实际中属于第1类的个数中，有69.5%的个体被正确认别。M（3，2），表示，实际中属于第2类的个数中，有94.3%的个体被正确认别。
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代表函数应用于每一行“““
R中随机森林函数所画的图怎么理解
用R做随机森林，先用训练集建模，之后用测试集进行预测，为什么总是显示allargumentsmusthavethesamelength？代码如下sub《-sample(1:nrow(dx),round(nrow(partd)/4))x1.rf《-randomForest(X1T~.,data=dx,importance=T,subset=-sub)pre1《-predict(x1.rf,data=dx,subset=sub)另外，随机森林的结果里给出的confusionmatrix是什么意思？和预测错误
confusionmatrix输出结果怎么看
A,实际上,由Appzard项目向导生成的默认的头文件及CPP文件StdAfx.h和StdAfx.cpp可以是任何名字的.原因很简单.但如果你要这样做就要记得修改相应的Project-》setting...下的几个预编译指令(/Yc,/Yu,/Yx,/Fp)的参数. B.在任何一个包括了将要预编译的头文件而使用了.PCH文件的工程文件的开头,一定必须要是在最开头,你要包含那个指定生成.PCH文件的.H文件(通过.CPP文件包括,默认为StdAfx.cpp),如果没包括将产生我最开头产生的错误.如果不是在最开头包括将产生让你意想不到的莫名其妙错误,如若不信,盍为试之? C.预编译文件.PCH生成之很耗时间,而且生成之后它也很占磁盘空间,常在5-6M,注意项目完成之后及时清理无用的.PCH文件以节约磁盘空间. D.如果丢了或删了.PCH文件而以后要再修改工程文件时,可将指定的/Yc的.CPP文件(默认为StdAfx.cpp)重新编译一次即可再次生成.PCH文件,不用傻傻的按F7或Rebuild All
python里面一些简单代码的含义是什么（题主零基础）
主要就两个文件 一个是sample的名字 labels.txt还有个放矩阵 predict.txt 两列，一列pre 二列true放矩阵那里他会调confusion_matrix自己算，如果你自己算好了不需要算，那代码就要改confusion_matrix介绍见http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html这东西用R画快多了，python的也只是刚才看了下介绍，应该没啥大问题
如何用python画好confusion matrix
在做分类的时候，经常需要画混淆矩阵，下面我们使用python的matplotlib包，scikit-learning机器学习库也同样提供了例子：， 但是这样的图并不能满足我们的要求，首先是刻度的显示是在方格的中间，这需要隐藏刻度，其次是如何把每个label显示在每个方块的中间， 其次是如何在每个方格中显示accuracy数值， 最后是如何在横坐标和纵坐标显示label的名字，在label name比较长的时候，如何处理显示问题。[python] view plain copy’’’’’compute confusion matrix labels.txt: contain label name. predict.txt: predict_label true_label ’’’ from sklearn.metrics import confusion_matrix import matplotlib.pyplot as plt import numpy as np #load labels. labels = file = open(’labels.txt’, ’r’) lines = file.readlines() for line in lines: labels.append(line.strip()) file.close() y_true = y_pred = #load true and predict labels. file = open(’predict.txt’, ’r’) lines = file.readlines() for line in lines: y_true.append(int(line.split(“ “).strip())) y_pred.append(int(line.split(“ “).strip())) file.close() tick_marks = np.array(range(len(labels))) + 0.5 def plot_confusion_matrix(cm, title=’Confusion Matrix’, cmap = plt.cm.binary): plt.imshow(cm, interpolation=’nearest’, cmap=cmap) plt.title(title) plt.colorbar() xlocations = np.array(range(len(labels))) plt.xticks(xlocations, labels, rotation=90) plt.yticks(xlocations, labels) plt.ylabel(’True label’) plt.xlabel(’Predicted label’) cm = confusion_matrix(y_true, y_pred) print cm np.set_printoptions(precision=2) cm_normalized = cm.astype(’float’)/cm.sum(axis=1)[:, np.newaxis] print cm_normalized plt.figure(figsize=(12,8), dpi=120) #set the fontsize of label. #for label in plt.gca().xaxis.get_ticklabels(): # label.set_fontsize(8) #text portion ind_array = np.arange(len(labels)) x, y = np.meshgrid(ind_array, ind_array) for x_val, y_val in zip(x.flatten(), y.flatten()): c = cm_normalized[y_val][x_val] if (c 》 0.01): plt.text(x_val, y_val, “%0.2f“ %(c,), color=’red’, fontsize=7, va=’center’, ha=’center’) #offset the tick plt.gca().set_xticks(tick_marks, minor=True) plt.gca().set_yticks(tick_marks, minor=True) plt.gca().xaxis.set_ticks_position(’none’) plt.gca().yaxis.set_ticks_position(’none’) plt.grid(True, which=’minor’, linestyle=’-’) plt.gcf().subplots_adjust(bottom=0.15) plot_confusion_matrix(cm_normalized, title=’Normalized confusion matrix’) #show confusion matrix plt.show()
python是否有绘制混淆矩阵的函数，怎么来实现
# -*- coding: UTF-8 -*-“““绘制混淆矩阵图“““import matplotlib.pyplot as pltfrom sklearn.metrics import confusion_matrixdef confusion_matrix_plot_matplotlib(y_truth, y_predict, cmap=plt.cm.Blues): “““Matplotlib绘制混淆矩阵图 parameters ---------- y_truth: 真实的y的值, 1d array y_predict: 预测的y的值, 1d array cmap: 画混淆矩阵图的配色风格, 使用cm.Blues，更多风格请参考官网 “““ cm = confusion_matrix(y_truth, y_predict) plt.matshow(cm, cmap=cmap) # 混淆矩阵图 plt.colorbar() # 颜色标签 for x in range(len(cm)): # 数据标签 for y in range(len(cm)): plt.annotate(cm[x, y], xy=(x, y), horizontalalignment=’center’, verticalalignment=’center’) plt.ylabel(’True label’) # 坐标轴标签 plt.xlabel(’Predicted label’) # 坐标轴标签 plt.show() # 显示作图结果if __name__ == ’__main__’: y_truth = [1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0] y_predict = [1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0] confusion_matrix_plot_matplotlib(y_truth, y_predict)
r使用随机森林实现所属类别的概率吗
用R做随机森林，先用训练集建模，之后用测试集进行预测，为什么总是显示allargumentsmusthavethesamelength？代码如下sub《-sample(1:nrow(dx),round(nrow(partd)/4))x1.rf《-randomForest(X1T~.,data=dx,importance=T,subset=-sub)pre1《-predict(x1.rf,data=dx,subset=sub)另外，随机森林的结果里给出的confusionmatrix是什么意思？和预测错误
隐马尔可夫模型的模型表达
隐马尔可夫模型（HMM）可以用五个元素来描述，包括2个状态集合和3个概率矩阵：1. 隐含状态 S这些状态之间满足马尔可夫性质，是马尔可夫模型中实际所隐含的状态。这些状态通常无法通过直接观测而得到。（例如S1、S2、S3等等)2. 可观测状态 O在模型中与隐含状态相关联，可通过直接观测而得到。(例如O1、O2、O3等等，可观测状态的数目不一定要和隐含状态的数目一致。）3. 初始状态概率矩阵 π表示隐含状态在初始时刻t=1的概率矩阵，(例如t=1时，P(S1)=p1、P(S2)=P2、P(S3)=p3，则初始状态概率矩阵 π=[ p1 p2 p3 ].4. 隐含状态转移概率矩阵 A。描述了HMM模型中各个状态之间的转移概率。其中Aij = P( Sj | Si ),1≤i,,j≤N.表示在 t 时刻、状态为 Si 的条件下，在 t+1 时刻状态是 Sj 的概率。5. 观测状态转移概率矩阵 B （英文名为Confusion Matrix，直译为混淆矩阵不太易于从字面理解）。令N代表隐含状态数目，M代表可观测状态数目，则：Bij = P( Oi | Sj ), 1≤i≤M,1≤j≤N.表示在 t 时刻、隐含状态是 Sj 条件下，观察状态为 Oi 的概率。总结：一般的，可以用λ=(A,B,π)三元组来简洁的表示一个隐马尔可夫模型。隐马尔可夫模型实际上是标准马尔可夫模型的扩展，添加了可观测状态集合和这些状态与隐含状态之间的概率关系。