Python实现贝叶斯分类器
Python技术的文本分类方法
Python技术的文本分类方法随着电子文本内容的爆炸式增长，人们对于高效的文本分类方法的需求越来越迫切。
文本分类是一种将文本按照其语义和主题进行预先定义的类别划分的技术，可应用于信息检索、情感分析、垃圾邮件过滤等众多领域。
Python作为一种功能强大且易于上手的编程语言，为实现文本分类提供了各种灵活可靠的方法。
本文将介绍几种常用的Python技术的文本分类方法。
1. 词袋模型（Bag of Words）词袋模型是文本分类中应用最广泛的方法之一。
该方法将文本看作是一个词语的集合，而文本的特征表示则是单词的出现频率。
实现词袋模型的一种常见方法是使用Python中的CountVectorizer类。
这个类可将文本数据中的词语转换为特征向量，然后使用统计学算法训练分类器。
这个方法在文本分类中非常有效，然而它忽略了词语的顺序和语境信息。
2. TF-IDFTF-IDF（Term Frequency-Inverse Document Frequency）是另一种常用的文本分类方法，用于评估一个词语在文本中的重要性。
它通过计算词语的词频和逆文档频率，得出一个特征向量来表示文本。
在Python中的实现方式是使用TfidfVectorizer 类。
相比词袋模型，TF-IDF更加关注文本的主题和关键词，能够提供更准确的特征表示。
3. 朴素贝叶斯分类器朴素贝叶斯分类器是一种基于贝叶斯定理和特征条件独立性假设的分类方法。
在文本分类中，朴素贝叶斯分类器被广泛应用于垃圾邮件过滤和情感分析等任务。
Python中的scikit-learn库提供了多种朴素贝叶斯分类器的实现，如MultinomialNB 和BernoulliNB。
这些分类器可以将文本转换为特征向量，并使用贝叶斯概率模型来进行训练和分类。
4. 支持向量机（SVM）支持向量机是一种强大的监督学习算法，也常用于文本分类。
SVM通过构建超平面将不同类别的样本点分开。
在文本分类中，支持向量机可以将文本数据转换为高维特征空间，并寻找最佳超平面来实现分类。
机器学习：贝叶斯分类器（二）——高斯朴素贝叶斯分类器代码实现
机器学习：贝叶斯分类器（⼆）——⾼斯朴素贝叶斯分类器代码实现⼀⾼斯朴素贝叶斯分类器代码实现⽹上搜索不调⽤sklearn实现的朴素贝叶斯分类器基本很少，即使有也是结合⽂本分类的多项式或伯努利类型，因此⾃⼰写了⼀遍能直接封装的⾼斯类型NB分类器，当然与真正的源码相⽐少了很多属性和⽅法，有兴趣的可以⾃⼰添加。
代码如下（有详细注释）：class NaiveBayes():'''⾼斯朴素贝叶斯分类器'''def __init__(self):self._X_train = Noneself._y_train = Noneself._classes = Noneself._priorlist = Noneself._meanmat = Noneself._varmat = Nonedef fit(self, X_train, y_train):self._X_train = X_trainself._y_train = y_trainself._classes = np.unique(self._y_train) # 得到各个类别priorlist = []meanmat0 = np.array([[0, 0, 0, 0]])varmat0 = np.array([[0, 0, 0, 0]])for i, c in enumerate(self._classes):# 计算每个种类的平均值，⽅差，先验概率X_Index_c = self._X_train[np.where(self._y_train == c)] # 属于某个类别的样本组成的“矩阵”priorlist.append(X_Index_c.shape[0] / self._X_train.shape[0]) # 计算类别的先验概率X_index_c_mean = np.mean(X_Index_c, axis=0, keepdims=True) # 计算该类别下每个特征的均值，结果保持⼆维状态[[3 4 6 2 1]]X_index_c_var = np.var(X_Index_c, axis=0, keepdims=True) # ⽅差meanmat0 = np.append(meanmat0, X_index_c_mean, axis=0) # 各个类别下的特征均值矩阵罗成新的矩阵，每⾏代表⼀个类别。
朴素贝叶斯原理、实例与Python实现
朴素贝叶斯原理、实例与Python实现初步理解⼀下：对于⼀组输⼊，根据这个输⼊，输出有多种可能性，需要计算每⼀种输出的可能性，以可能性最⼤的那个输出作为这个输⼊对应的输出。
那么，如何来解决这个问题呢？贝叶斯给出了另⼀个思路。
根据历史记录来进⾏判断。
思路是这样的：1、根据贝叶斯公式：P（输出|输⼊）=P（输⼊|输出）*P（输出）/P（输⼊）2、P（输⼊）=历史数据中，某个输⼊占所有样本的⽐例；3、P（输出）=历史数据中，某个输出占所有样本的⽐例；4、P（输⼊|输出）=历史数据中，某个输⼊，在某个输出的数量占所有样本的⽐例，例如：30岁，男性，中午吃⾯条，其中【30岁，男性就是输⼊】，【中午吃⾯条】就是输出。
⼀、条件概率的定义与贝叶斯公式⼆、朴素贝叶斯分类算法朴素贝叶斯是⼀种有监督的分类算法，可以进⾏⼆分类，或者多分类。
⼀个数据集实例如下图所⽰：现在有⼀个新的样本， X = (年龄：<=30, 收⼊：中，是否学⽣：是，信誉：中)，⽬标是利⽤朴素贝叶斯分类来进⾏分类。
假设类别为C(c1=是或 c2=否)，那么我们的⽬标是求出P(c1|X)和P(c2|X)，⽐较谁更⼤，那么就将X分为某个类。
下⾯，公式化朴素贝叶斯的分类过程。
三、实例下⾯，将下⾯这个数据集作为训练集，对新的样本X = (年龄：<=30, 收⼊：中，是否学⽣：是，信誉：中) 作为测试样本，进⾏分类。
我们可以将这个实例中的描述属性和类别属性，与公式对应起来，然后计算。
参考python实现代码#coding:utf-8# 极⼤似然估计朴素贝叶斯算法import pandas as pdimport numpy as npclass NaiveBayes(object):def getTrainSet(self):dataSet = pd.read_csv('F://aaa.csv')dataSetNP = np.array(dataSet) #将数据由dataframe类型转换为数组类型trainData = dataSetNP[:,0:dataSetNP.shape[1]-1] #训练数据x1,x2labels = dataSetNP[:,dataSetNP.shape[1]-1] #训练数据所对应的所属类型Yreturn trainData, labelsdef classify(self, trainData, labels, features):#求labels中每个label的先验概率labels = list(labels) #转换为list类型labelset = set(labels)P_y = {} #存⼊label的概率for label in labelset:P_y[label] = labels.count(label)/float(len(labels)) # p = count(y) / count(Y)print(label,P_y[label])#求label与feature同时发⽣的概率P_xy = {}for y in P_y.keys():y_index = [i for i, label in enumerate(labels) if label == y] # labels中出现y值的所有数值的下标索引for j in range(len(features)): # features[0] 在trainData[:,0]中出现的值的所有下标索引x_index = [i for i, feature in enumerate(trainData[:,j]) if feature == features[j]]xy_count = len(set(x_index) & set(y_index)) # set(x_index)&set(y_index)列出两个表相同的元素pkey = str(features[j]) + '*' + str(y)P_xy[pkey] = xy_count / float(len(labels))print(pkey,P_xy[pkey])#求条件概率P = {}for y in P_y.keys():for x in features:pkey = str(x) + '|' + str(y)P[pkey] = P_xy[str(x)+'*'+str(y)] / float(P_y[y]) #P[X1/Y] = P[X1Y]/P[Y]print(pkey,P[pkey])#求[2,'S']所属类别F = {} #[2,'S']属于各个类别的概率for y in P_y:F[y] = P_y[y]for x in features:F[y] = F[y]*P[str(x)+'|'+str(y)] #P[y/X] = P[X/y]*P[y]/P[X]，分母相等，⽐较分⼦即可，所以有F=P[X/y]*P[y]=P[x1/Y]*P[x2/Y]*P[y] print(str(x),str(y),F[y])features_label = max(F, key=F.get) #概率最⼤值对应的类别return features_labelif__name__ == '__main__':nb = NaiveBayes()# 训练数据trainData, labels = nb.getTrainSet()# x1,x2features = [8]# 该特征应属于哪⼀类result = nb.classify(trainData, labels, features)print(features,'属于',result)#coding:utf-8#朴素贝叶斯算法贝叶斯估计，λ=1 K=2， S=3；λ=1 拉普拉斯平滑import pandas as pdimport numpy as npclass NavieBayesB(object):def__init__(self):self.A = 1 # 即λ=1self.K = 2self.S = 3def getTrainSet(self):trainSet = pd.read_csv('F://aaa.csv')trainSetNP = np.array(trainSet) #由dataframe类型转换为数组类型trainData = trainSetNP[:,0:trainSetNP.shape[1]-1] #训练数据x1,x2labels = trainSetNP[:,trainSetNP.shape[1]-1] #训练数据所对应的所属类型Yreturn trainData, labelsdef classify(self, trainData, labels, features):labels = list(labels) #转换为list类型#求先验概率P_y = {}for label in labels:P_y[label] = (labels.count(label) + self.A) / float(len(labels) + self.K*self.A)#求条件概率P = {}for y in P_y.keys():y_index = [i for i, label in enumerate(labels) if label == y] # y在labels中的所有下标y_count = labels.count(y) # y在labels中出现的次数for j in range(len(features)):pkey = str(features[j]) + '|' + str(y)x_index = [i for i, x in enumerate(trainData[:,j]) if x == features[j]] # x在trainData[:,j]中的所有下标 xy_count = len(set(x_index) & set(y_index)) #x y同时出现的次数P[pkey] = (xy_count + self.A) / float(y_count + self.S*self.A) #条件概率#features所属类F = {}for y in P_y.keys():F[y] = P_y[y]for x in features:F[y] = F[y] * P[str(x)+'|'+str(y)]features_y = max(F, key=F.get) #概率最⼤值对应的类别return features_yif__name__ == '__main__':nb = NavieBayesB()# 训练数据trainData, labels = nb.getTrainSet()# x1,x2features = [10]# 该特征应属于哪⼀类result = nb.classify(trainData, labels, features)print(features,'属于',result)参考链接：https:///ten_sory/article/details/81237169。
Bayes分类器原理分析以及实现
Bayes分类器原理分析以及实现编程环境：python 3.7jupyter notebook⽂章说明：这⾥只是贝叶斯分类器的原理进⾏分析以及实现，重点关注其中的数学原理和逻辑步骤，在测试等阶段直接调⽤了python机器学习的库。
基本步骤：输⼊类数,特征数,待分样本数输⼊训练样本数和训练样本集计算先验概率计算各类条件概率密度计算各类的后验概率若按最⼩错误率原则分类,则根据后验概率判定若按最⼩风险原则分类,则计算各样本属于各类时的风险并判定# 导⼊基本库import pandas as pdimport numpy as npimport mathimport matplotlib.pyplot as plt%matplotlib inline%config InlineBackend.figure_format = 'png'数据预处理colume_names = ['','gender','height','weight','size']df= pd.read_excel('data/gender.xlsx',index_col=0,names=colume_names)df.head(5)gender height weight size1⼥163.062.036.02⼥158.042.036.03男168.067.042.04男180.067.041.05男180.075.046.0df.shape(571, 4)这⾥可以看到数据有4个维度，分别为性别、⾝⾼、体重、鞋码，共有571条记录。
下⾯做⼀些简单的处理：# 性别数据转换df.replace('男',1,inplace=True)df.replace('⼥',2,inplace=True)df.head(5)gender height weight size12163.062.036.022158.042.036.031168.067.042.041180.067.041.0gender height weight size 51180.075.046.0# 男⽣⼥⽣数据分开male_df = df.loc[df['gender']==1]female_df = df.loc[df['gender']==2]female_df.head(5)gender height weight size 12163.062.036.022158.042.036.092160.045.036.0102163.048.037.0112161.045.036.01、单个特征——⾝⾼为了更加深⼊得理解贝叶斯分类器原理，我们从简单的⼀维特征开始。
朴素贝叶斯分类器基本代码n折交叉优化
朴素贝叶斯分类器基本代码n折交叉优化⾃⼰也是刚刚⼊门。
没脸把⾃⼰的代码放上去，先⽤别⼈的。
加上⾃⼰的解析，挺全⾯的，希望有⽤。
import reimport pandas as pdimport numpy as npfrom sklearn.metrics import roc_auc_scorefrom sklearn.feature_extraction.text import TfidfVectorizerfrom sklearn.naive_bayes import MultinomialNB as MNB #朴素贝叶斯公式from sklearn.model_selection import cross_val_scoredef proces(review):#把review转成词序列review_text=re.sub("[^a-zA-Z]","",review) #⾮⼤⼩写字母的字符替换成空格#re.sub是正则表达式的函数，实现⽐普通字符串更强⼤的替换功能#print(review_text)words=review_text.lower().split() #全转换为⼩写后，根据空格分割单词#print(words)return wordstrain=pd.read_csv('train.csv',lineterminator='\n') #使⽤pandas的read读取⽂件，以换⾏符号为⽌为⼀段数据'''官⽅⽂件：pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer',names=None, index_col=None, usecols=None, squeeze=False, prefix=None,mangle_dupe_cols=True, dtype=None, engine=None, converters=None,true_values=None, false_values=None, skipinitialspace=False,skiprows=None, nrows=None, na_values=None, keep_default_na=True,na_filter=True, verbose=False, skip_blank_lines=True,parse_dates=False, infer_datetime_format=False, keep_date_col=False,date_parser=None, dayfirst=False, iterator=False, chunksize=None,compression='infer', thousands=None, decimal=b'.', lineterminator=None,quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None,dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True,skipfooter=0, doublequote=True, delim_whitespace=False,low_memory=True, memory_map=False, float_precision=None）https:///sinat_35562946/article/details/81058221这个博客讲的还⾏'''print(train.head(5))x=train['review']#print(x)y=train['label']#print(y)'''x与y分离train中的记录和标签'''class_mapping = {'Negative': 0, 'Positive': 1}y=y.map(class_mapping)#把label中的Negative,Positive转换成0,1标签test=pd.read_csv('test.csv', lineterminator='\n')z=test['review']w=test['label']'''x与y分离test中的记录和标签'''w=w.map(class_mapping)train_data=[]for i in range(len(x)):train_data.append(''.join(proces(x[i]))) #⽤空格将train.data的list⾥的words串联在⼀起passtest_data=[]for i in range(len(z)):test_data.append(''.join(proces(z[i]))) #⽤空格将test_data的list⾥的words串联在⼀起passdata_all=train_data+test_data #所有词合并成⼤表data#print(data_all)#TF-IDF倾向于过滤掉常见的词语，保留重要的词语。
数学建模常用的30个常用算法(python代码)
数学建模常用的30个常用算法(python代码) 数学建模中使用的算法涉及多个领域，包括优化、统计、机器学习等。
以下是一些在数学建模中常用的30个算法的简要说明和Python代码示例。
请注意，这只是一小部分，具体应用场景和需求可能需要使用其他算法。
1.线性规划（Linear Programming）:from scipy.optimize import linprog2.整数规划（Integer Programming）:from scipy.optimize import linprog3.非线性规划（Nonlinear Programming）:from scipy.optimize import minimize4.蒙特卡洛模拟（Monte Carlo Simulation）:import numpy as np5.差分方程（Difference Equations）:import numpy as np6.梯度下降法（Gradient Descent）:import numpy as np7.贪心算法（Greedy Algorithm）:def greedy_algorithm(values, weights, capacity):n = len(values)ratio = [(values[i] / weights[i], i) for i in range(n)]ratio.sort(reverse=True)result = [0] * ntotal_value = 0current_weight = 0for _, i in ratio:if weights[i] + current_weight <= capacity: result[i] = 1current_weight += weights[i]total_value += values[i]return result, total_value8.动态规划（Dynamic Programming）:def dynamic_programming(weights, values, capacity): n = len(values)dp = [[0] * (capacity + 1) for _ in range(n + 1)]for i in range(1, n + 1):for w in range(capacity + 1):if weights[i - 1] <= w:dp[i][w] = max(dp[i - 1][w], values[i - 1] + dp[i - 1][w - weights[i - 1]])else:dp[i][w] = dp[i - 1][w]return dp[n][capacity]9.遗传算法（Genetic Algorithm）:import numpy as np10.模拟退火算法（Simulated Annealing）:import numpy as np11.马尔可夫链（Markov Chains）:import numpy as np12.蒙特卡洛树搜索（Monte Carlo Tree Search）:import numpy as np13.K均值聚类（K-means Clustering）:from sklearn.cluster import KMeans14.主成分分析（Principal Component Analysis）:from sklearn.decomposition import PCA15.支持向量机（Support Vector Machine）:from sklearn.svm import SVC16.朴素贝叶斯分类器（Naive Bayes Classifier）:from sklearn.naive_bayes import GaussianNB17.决策树（Decision Tree）:from sklearn.tree import DecisionTreeClassifier18.随机森林（Random Forest）:from sklearn.ensemble import RandomForestClassifier19.K最近邻算法（K-Nearest Neighbors）:from sklearn.neighbors import KNeighborsClassifier20.多层感知器（Multilayer Perceptron）:from sklearn.neural_network import MLPClassifier21.梯度提升机（Gradient Boosting）:from sklearn.ensemble import GradientBoostingClassifier22.高斯混合模型（Gaussian Mixture Model）:from sklearn.mixture import GaussianMixture23.时间序列分析（Time Series Analysis）:import statsmodels.api as sm24.马尔科夫链蒙特卡洛（Markov Chain Monte Carlo）:import pymc3 as pm25.局部最小二乘回归（Local Polynomial Regression）:from statsmodels.nonparametric.kernel_regression import KernelReg26.逻辑回归（Logistic Regression）:from sklearn.linear_model import LogisticRegression27.拉格朗日插值法（Lagrange Interpolation）:from scipy.interpolate import lagrange28.最小二乘法（Least Squares Method）:import numpy as np29.牛顿法（Newton's Method）:def newton_method(f, df, x0, tol=1e-6, max_iter=100):x = x0for i in range(max_iter):x = x - f(x) / df(x)if abs(f(x)) < tol:breakreturn x30.梯度下降法（Gradient Descent）:def gradient_descent(f, df, x0, learning_rate=0.01, tol=1e-6, max_iter=100):x = x0for i in range(max_iter):x = x - learning_rate * df(x)if abs(df(x)) < tol:breakreturn x以上代码只是简单示例，实际应用中可能需要根据具体问题进行调整和扩展。
python pymc3实例
Python是一种强大的编程语言，被广泛应用于数据分析、科学计算、人工智能等领域。
而pymc3则是一个Python库，用于概率编程和贝叶斯统计建模。
它以贝叶斯方法为基础，为用户提供了建立概率模型和进行贝叶斯推断的工具，可以用于解决复杂的统计问题。
本文将通过介绍pymc3的基本原理和实际应用，帮助读者了解如何使用pymc3进行概率编程和贝叶斯统计建模，并提供一些实际案例来演示pymc3的强大功能。
一、pymc3的基本原理pymc3是一个概率编程的工具，它基于Python语言，利用贝叶斯统计方法来进行概率建模和推断。
其基本原理可以归纳为以下几点：1. 概率建模：pymc3允许用户使用Python代码来构建概率模型，包括随机变量、概率分布和模型参数等。
用户可以根据具体的统计问题构建相应的概率模型，并使用pymc3提供的工具进行建模和推断。
2. 贝叶斯推断：通过概率建模，pymc3可以实现贝叶斯推断，即根据观测数据和先验知识来推断模型参数的后验分布。
这样可以获得更准确的估计结果，并量化参数估计的不确定性。
3. MCMC采样：pymc3使用马尔科夫链蒙特卡罗(MCMC)方法来进行参数估计和后验推断。
MCMC是一种基于随机采样的方法，它可以从参数的后验分布中抽取样本，并用这些样本来估计参数的分布特征。
二、pymc3的实际应用pymc3可以应用于各种统计问题，包括回归分析、时间序列分析、分类模型等。
接下来，我们将通过几个实际案例来演示pymc3的应用。
1. 线性回归模型假设我们要建立一个线性回归模型，用于预测某个因变量Y与若干自变量X之间的关系。
我们可以使用pymc3来构建一个贝叶斯线性回归模型，并进行参数估计和预测分析。
我们需要定义模型的参数和先验分布。
假设Y服从正态分布，且均值与X之间存上线性关系，我们可以定义参数β和σ来描述这一关系。
我们可以利用pymc3提供的工具来构建模型，并使用MCMC方法来进行参数估计。
Python与朴素贝叶斯分类的应用
Python与朴素贝叶斯分类的应用导言Python是一种高级的、内容丰富的编程语言，最早由荷兰人Guido van Rossum在1989年创造。
Python与许多其他编程语言一样，可以用于各种任务，例如Web开发、数据分析、科学计算等等。
Python还广泛应用于人工智能领域，朴素贝叶斯分类就是Python中常用的一种算法。
朴素贝叶斯分类是一个简单而高效的机器学习模型，用于处理分类问题。
该算法的核心思想是基于特征和类别的条件概率对未知数据进行分类。
本文将探讨Python与朴素贝叶斯分类的应用，介绍朴素贝叶斯算法的基本概念，以及如何使用Python实现朴素贝叶斯算法进行分类。
朴素贝叶斯算法的基本概念朴素贝叶斯算法是一种基于贝叶斯定理的分类算法，该算法假设数据集中所有特征都是独立的，从而简化了计算。
算法的核心思想是，根据先验概率和条件概率，计算出后验概率，以此来判断数据属于哪个类别。
在朴素贝叶斯算法中，我们需要计算先验概率、条件概率和后验概率。
其中，先验概率是在不知道数据属于哪个类别的情况下，每种类别的概率。
条件概率是在已知某种类别的情况下，数据拥有某个特征的概率。
后验概率是在知道特征和类别的情况下，数据属于某个类别的概率。
贝叶斯定理将这些概率联系在一起：P(Y|X) = P(X|Y) * P(Y) / P(X)其中，P(Y|X)是后验概率，即在已知特征和类别的情况下，数据属于某个类别的概率；P(X|Y)是条件概率，即在已知某种类别的情况下，数据拥有某个特征的概率；P(Y)是先验概率，即每种类别的概率；P(X)是样本空间中数据拥有某个特征的概率。
在分类问题中，我们需要计算出所有类别的后验概率，然后选择最大值作为分类结果。
因为贝叶斯定理假设每个特征是独立的，所以朴素贝叶斯算法的名称中含有“朴素”这个词。
如何使用Python实现朴素贝叶斯算法进行分类Python中有多个库可用于机器学习，其中就包括用于分类的朴素贝叶斯算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
关于朴素贝叶斯朴素贝叶斯算法是一个直观的方法，使用每个属性归属于某个类的概率来做预测。
你可以使用这种监督性学习方法，对一个预测性建模问题进行概率建模。
给定一个类，朴素贝叶斯假设每个属性归属于此类的概率独立于其余所有属性，从而简化了概率的计算。
这种强假定产生了一个快速、有效的方法。
给定一个属性值，其属于某个类的概率叫做条件概率。
对于一个给定的类值，将每个属性的条件概率相乘，便得到一个数据样本属于某个类的概率。
我们可以通过计算样本归属于每个类的概率，然后选择具有最高概率的类来做预测。
通常，我们使用分类数据来描述朴素贝叶斯，因为这样容易通过比率来描述、计算。
一个符合我们目的、比较有用的算法需要支持数值属性，同时假设每一个数值属性服从正态分布（分布在一个钟形曲线上），这又是一个强假设，但是依然能够给出一个健壮的结果。
预测糖尿病的发生本文使用的测试问题是“皮马印第安人糖尿病问题”。
这个问题包括768个对于皮马印第安患者的医疗观测细节，记录所描述的瞬时测量取自诸如患者的年纪，怀孕和血液检查的次数。
所有患者都是21岁以上（含21岁）的女性，所有属性都是数值型，而且属性的单位各不相同。
每一个记录归属于一个类，这个类指明以测量时间为止，患者是否是在5年之内感染的糖尿病。
如果是，则为1，否则为0。
机器学习文献中已经多次研究了这个标准数据集，好的预测精度为70%-76%。
下面是pima-indians.data.csv文件中的一个样本，了解一下我们将要使用的数据。
注意：下载文件，然后以.csv扩展名保存（如：pima-indians-diabetes.data.csv）。
查看文件中所有属性的描述。
Python1 2 3 4 5 6,148,72,35,0,33.6,0.627,50,1 1,85,66,29,0,26.6,0.351,31,0 8,183,64,0,0,23.3,0.672,32,1 1,89,66,23,94,28.1,0.167,21,0 0,137,40,35,168,43.1,2.288,33,1朴素贝叶斯算法教程教程分为如下几步：1.处理数据：从CSV文件中载入数据，然后划分为训练集和测试集。
2.提取数据特征：提取训练数据集的属性特征，以便我们计算概率并做出预测。
3.单一预测：使用数据集的特征生成单个预测。
4.多重预测：基于给定测试数据集和一个已提取特征的训练数据集生成预测。
5.评估精度：评估对于测试数据集的预测精度作为预测正确率。
6.合并代码：使用所有代码呈现一个完整的、独立的朴素贝叶斯算法的实现。
1.处理数据首先加载数据文件。
CSV格式的数据没有标题行和任何引号。
我们可以使用csv模块中的open函数打开文件，使用reader函数读取行数据。
我们也需要将以字符串类型加载进来属性转换为我们可以使用的数字。
下面是用来加载匹马印第安人数据集（Pima indians dataset）的loadCsv()函数。
Python1 2 3 4 5 6 7 import csvdef loadCsv(filename):lines = csv.reader(open(filename, "rb"))dataset = list(lines)for i in range(len(dataset)):dataset[i] = [float(x) for x in dataset[i]] return dataset我们可以通过加载皮马印第安人数据集，然后打印出数据样本的个数，以此测试这个函数。
Python1 2 3 filename = 'pima-indians-dataset = loadCsv(filename)print('Loaded data file {0} with {1} rows').format(filename, len(dataset))运行测试，你会看到如下结果：Python1 Loaded data file with 150 rows下一步，我们将数据分为用于朴素贝叶斯预测的训练数据集，以及用来评估模型精度的测试数据集。
我们需要将数据集随机分为包含67%的训练集合和包含33%的测试集（这是在此数据集上测试算法的通常比率）。
下面是splitDataset()函数，它以给定的划分比例将数据集进行划分。
Python1 2 3 4 5 6 7 8 9 import randomdef splitDataset(dataset, splitRatio):trainSize = int(len(dataset) * splitRatio)trainSet = []copy = list(dataset)while len(trainSet) < trainSize:index = random.randrange(len(copy))trainSet.append(copy.pop(index)) return [trainSet, copy]我们可以定义一个具有5个样例的数据集来进行测试，首先它分为训练数据集和测试数据集，然后打印出来，看看每个数据样本最终落在哪个数据集。
Python1 2 dataset = [[1], [2], [3], [4], [5]] splitRatio = 0.673 4 train, test = splitDataset(dataset, splitRatio)print('Split {0} rows into train with {1} and test with {2}').format(len(dataset), train, test)运行测试，你会看到如下结果：Python1 Split 5 rows into train with [[4], [3], [5]] and test with [[1], [2]]提取数据特征朴素贝叶斯模型包含训练数据集中数据的特征，然后使用这个数据特征来做预测。
所收集的训练数据的特征，包含相对于每个类的每个属性的均值和标准差。
举例来说，如果如果有2个类和7个数值属性，然后我们需要每一个属性（7）和类（2）的组合的均值和标准差，也就是14个属性特征。
在对特定的属性归属于每个类的概率做计算、预测时，将用到这些特征。
我们将数据特征的获取划分为以下的子任务：1.按类别划分数据2.计算均值3.计算标准差4.提取数据集特征5.按类别提取属性特征按类别划分数据首先将训练数据集中的样本按照类别进行划分，然后计算出每个类的统计数据。
我们可以创建一个类别到属于此类别的样本列表的的映射，并将整个数据集中的样本分类到相应的列表。
下面的SeparateByClass()函数可以完成这个任务：Python1 2 3 4 5 6 7 8 def separateByClass(dataset):separated = {}for i in range(len(dataset)):vector = dataset[i]if (vector[-1] not in separated):separated[vector[-1]] = []separated[vector[-1]].append(vector) return separated可以看出，函数假设样本中最后一个属性（-1）为类别值，返回一个类别值到数据样本列表的映射。
我们可以用一些样本数据测试如下：Python1 dataset = [[1,20,1], [2,21,0], [3,22,1]]2 3 separated = separateByClass(dataset)print('Separated instances: {0}').format(separated)运行测试，你会看到如下结果：Python1 Separated instances: {0: [[2, 21, 0]], 1: [[1, 20, 1], [3, 22, 1]]}计算均值我们需要计算在每个类中每个属性的均值。
均值是数据的中点或者集中趋势，在计算概率时，我们用它作为高斯分布的中值。
我们也需要计算每个类中每个属性的标准差。
标准差描述了数据散布的偏差，在计算概率时，我们用它来刻画高斯分布中，每个属性所期望的散布。
标准差是方差的平方根。
方差是每个属性值与均值的离差平方的平均数。
注意我们使用N-1的方法（译者注：参见无偏估计），也就是在在计算方差时，属性值的个数减1。
Python1 2 3 4 5 6 7 8 import mathdef mean(numbers):return sum(numbers)/float(len(numbers)) def stdev(numbers):avg = mean(numbers)variance = sum([pow(x-avg,2) for x in numbers])/float(len(numbers)-1)return math.sqrt(variance)通过计算从1到5这5个数的均值来测试函数。
Python1 2 numbers = [1,2,3,4,5]print('Summary of {0}: mean={1}, stdev={2}').format(numbers, mean(numbers), stdev(numbers))运行测试，你会看到如下结果：Python1 Summary of [1, 2, 3, 4, 5]: mean=3.0, stdev=1.008提取数据集的特征现在我们可以提取数据集特征。
对于一个给定的样本列表（对应于某个类），我们可以计算每个属性的均值和标准差。
zip函数将数据样本按照属性分组为一个个列表，然后可以对每个属性计算均值和标准差。
Python1 def summarize(dataset):2 3 4 summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)] del summaries[-1]return summaries我们可以使用一些测试数据来测试这个summarize()函数，测试数据对于第一个和第二个数据属性的均值和标准差显示出显著的不同。
Python1 2 3 dataset = [[1,20,0], [2,21,1], [3,22,0]]summary = summarize(dataset)print('Attribute summaries: {0}').format(summary)运行测试，你会看到如下结果：Python1 Attribute summaries: [(2.0, 1.0), (21.0, 1.0)]按类别提取属性特征合并代码，我们首先将训练数据集按照类别进行划分，然后计算每个属性的摘要。