机器学习系列(16)_朴素贝叶斯算法

最新推荐文章于 2024-05-18 09:31:01 发布
最新推荐文章于 2024-05-18 09:31:01 发布
阅读量1k 收藏 10
点赞数 3
分类专栏： # 【机器学习】 文章标签： 机器学习 算法 概率论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxfighting/article/details/124974238
版权

注：机器学习之分类<朴素贝叶斯>

期末会有一道贝叶斯的计算的题目

文章目录

一、朴素贝叶斯

朴素贝叶斯是一种直接衡量标签和特征之间的概率关系的有监督算法。

1、概率论贝叶斯

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2、朴素贝叶斯GaussianNB实例

import numpy as np
from sklearn.naive_bayes import GaussianNB
X = np.array([[-1, -1], [-2, -2], [-3, -3], [-4, -4], [1, 1], [2, 2], [3, 3]])
y = np.array([1, 1, 1, 1, 2, 2, 2])

进行实例化和拟合，构建模型：

clf = GaussianNB()
re = clf.fit(X, y)
print(re)

参数：

re1 = clf.priors
print(re1)  #None

# 设置priors参数值
re2 = clf.set_params(priors=[0.625, 0.375])
print(re2)

# 返回各类标记对应先验概率组成的列表
re3 = clf.priors
print(re3)

re4 = clf.class_prior_
print(re4)

re5 = type(clf.class_prior_) # 类型
print(re5)

re6 = clf.class_count_
print(re6)

re7 = clf.theta_
print(re7)

re8 = clf.sigma_
print(re8)

re9 = clf.get_params(deep=True)
print(re9)

re10 = clf.get_params()
print(re10)

re11 = clf.set_params(priors=[0.625, 0.375])
print(re11)

re12 = clf.fit(X, y, np.array([0.05, 0.05, 0.1, 0.1, 0.1, 0.2, 0.2]))
re13 = clf.theta_
re14 = clf.sigma_
print(re12)
print(re13)
print(re14)

对约会数据进行整理：

from sklearn import metrics
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
 
# 读取数据
X = []
Y = []
fr = open("datingTestSet.txt", encoding='utf-8')
print(fr)
index = 0
for line in fr.readlines():
    # print(line)
    line = line.strip() # 去除首位空格
    line = line.split('\t') # 按制表符进行分割
    X.append(line[:3])
    Y.append(line[-1])
 
# 归一化
scaler = MinMaxScaler()
# print(X)
X = scaler.fit_transform(X)
# print(X)
 
# 交叉分类
train_X, test_X, train_y, test_y = train_test_split(X, Y, test_size=0.2)
 
#高斯贝叶斯模型
model = GaussianNB()
model.fit(train_X, train_y)
 
# 预测测试集数据
predicted = model.predict(test_X)
# 输出分类信息
res = metrics.classification_report(test_y, predicted)
# print(res)
# 去重复，得到标签类别
label = list(set(Y))
print(label)
# 输出混淆矩阵信息
matrix_info = metrics.confusion_matrix(test_y, predicted, labels=label)
print(matrix_info)

在这里插入图片描述

3、约会实例

from sklearn import metrics
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
 
# 读取数据
X = []
Y = []
fr = open("datingTestSet.txt", encoding='utf-8')
print(fr)
index = 0
for line in fr.readlines():
    # print(line)
    line = line.strip()
    line = line.split('\t')
    X.append(line[:3])
    Y.append(line[-1])
 
# 归一化
scaler = MinMaxScaler()
# print(X)
X = scaler.fit_transform(X)
# print(X)
 
# 交叉分类
train_X, test_X, train_y, test_y = train_test_split(X, Y, test_size=0.2)
 
#高斯贝叶斯模型
model = GaussianNB()
model.fit(train_X, train_y)
 
# 预测测试集数据
predicted = model.predict(test_X)
# 输出分类信息
res = metrics.classification_report(test_y, predicted)
# print(res)
# 去重复，得到标签类别
label = list(set(Y))
print(label)
# 输出混淆矩阵信息
matrix_info = metrics.confusion_matrix(test_y, predicted, labels=label)
print(matrix_info)

在这里插入图片描述

import pandas as pd
import numpy as np
import cv2
import time
 
from sklearn.model_selection import train_test_split
from sklearn.metrics  import accuracy_score
 
# 获取数据
def load_data():
    # 读取csv数据
    raw_data = pd.read_csv('bayes_train.csv', header=0)
    data = raw_data.values
    features = data[::, 1::]
    labels = data[::, 0]
    # 避免过拟合，采用交叉验证，随机选取33%数据作为测试集，剩余为训练集
    train_X, test_X, train_y, test_y = train_test_split(features, labels, test_size=0.33, random_state=0)
    return train_X, test_X, train_y, test_y
 
# 二值化处理
def binaryzation(img):
    # 类型转化成Numpy中的uint8型
    cv_img = img.astype(np.uint8)
    # 大于50的值赋值为0，不然赋值为1
    cv2.threshold(cv_img, 50, 1, cv2.THRESH_BINARY_INV, cv_img)
    return cv_img
 
# 训练，计算出先验概率和条件概率
def Train(trainset, train_labels):
    # 先验概率
    prior_probability = np.zeros(class_num)
    # 条件概率
    conditional_probability = np.zeros((class_num, feature_len, 2))
 
    # 计算
    for i in range(len(train_labels)):
        # 图片二值化，让每一个特征都只有0， 1 两种取值
        img = binaryzation(trainset[i])
        label = train_labels[i]
 
        prior_probability[label] += 1
        for j in range(feature_len):
            conditional_probability[label][j][img[j]] += 1
 
    # 将条件概率归到 [1, 10001]
    for i in range(class_num):
        for j in range(feature_len):
            # 经过二值化后图像只有0， 1 两种取值
            pix_0 = conditional_probability[i][i][0]
            pix_1 = conditional_probability[i][j][1]
            # 计算0， 1像素点对应的条件概率
            probability_0 = (float(pix_0)/float(pix_0 + pix_1))*10000 + 1
            probability_1 = (float(pix_1)/float(pix_0 + pix_1))*10000 + 1
 
            conditional_probability[i][j][0] = probability_0
            conditional_probability[i][j][1] = probability_1
 
    return prior_probability, conditional_probability
 
# 计算概率
def calculate_probability(img, label):
    probability = int(prior_probability[label])
    for j in range(feature_len):
        probability *= int(conditional_probability[label][j][img[j]])
    return probability
 
# 预测
def Predict(testset, prior_probability, conditional_probability):
    predict = []
    # 对于每个输入的X，将后验概率最大的类作为X的类输出
    for img in testset:
        # 图像二值化
        img = binaryzation(img)
 
        max_label = 0
        max_probability = calculate_probability(img, 0)
        for j in range(1, class_num):
            probability = calculate_probability(img, j)
            if max_probability < probability:
                max_label = j
                max_probability = probability
        predict.append(max_label)
    return np.array(predict)
 
 
# MNIST数据集有10种labels，分别为“0，1,2，3,4,5,6,7,8,9
class_num = 10
feature_len = 784
 
if __name__ == '__main__':
    time_1 = time.time()
    train_X, test_X, train_y, test_y = load_data()
    prior_probability, conditional_probability = Train(train_X, train_y)
    test_predict = Predict(test_X, prior_probability, conditional_probability)
    score = accuracy_score(test_y, test_predict)
    print(score)

在这里插入图片描述

二、朴素贝叶斯实现步骤

  • Step 1: Separate By Class 据类分割
    • 要计算数据属于某类的可能性，即可基本概率
    • 需要按类别进行训练数据的分割
    • 可使用dict对象
#自定义据类分割的函数
def separate_by_class(dataset):
	separated = dict()
	for i in range(len(dataset)):
		vector = dataset[i]
		class_value = vector[-1]
		if (class_value not in separated):
			separated[class_value] = list()
		separated[class_value].append(vector)
	return separated
  • Step 2: Summarize Dataset 汇总数据
    • 给定数据集需要两个统计数据：平均值和标准差
    • 对每列计算平均值和标准差
#自定义平均值函数
def mean(numbers):
	return sum(numbers)/float(len(numbers))

#自定义标准差函数
def stdev(numbers):
	avg = mean(numbers)
	variance = sum([(x-avg)**2 for x in numbers]) / float(len(numbers)-1)
	return sqrt(variance)

#自定义数据集内计算均值和标准差
def summarize_dataset(dataset):
	summaries = [(mean(column), stdev(column), len(column)) for column in zip(*dataset)]
	del(summaries[-1])
	return summaries

#应用
from math import sqrt
dataset = [[3.393533211,2.331273381,0],
	[3.110073483,1.781539638,0],
	[1.343808831,3.368360954,0],
	[3.582294042,4.67917911,0],
	[2.280362439,2.866990263,0],
	[7.423436942,4.696522875,1],
	[5.745051997,3.533989803,1],
	[9.172168622,2.511101045,1],
	[7.792783481,3.424088941,1],
	[7.939820817,0.791637231,1]]
summary = summarize_dataset(dataset)
print(summary)

在这里插入图片描述

  • Step 3: Summarize Data By Class 按类汇总数据
    • 按类组织训练集中的统计数据
#自定义按类汇总数据集函数
def summarize_by_class(dataset):
	separated = separate_by_class(dataset)
	summaries = dict()
	for class_value, rows in separated.items():
		summaries[class_value] = summarize_dataset(rows)
	return summaries

from math import sqrt
dataset = [[3.393533211,2.331273381,0],
	[3.110073483,1.781539638,0],
	[1.343808831,3.368360954,0],
	[3.582294042,4.67917911,0],
	[2.280362439,2.866990263,0],
	[7.423436942,4.696522875,1],
	[5.745051997,3.533989803,1],
	[9.172168622,2.511101045,1],
	[7.792783481,3.424088941,1],
	[7.939820817,0.791637231,1]]
summary = summarize_by_class(dataset)
for label in summary:
	print(label)
	for row in summary[label]:
		print(row)
  • Step 4: Gaussian Probability Density Function 高斯概率密度函数
#自定义计算概率函数
def calculate_probability(x, mean, stdev):
	exponent = exp(-((x-mean)**2 / (2 * stdev**2 )))
	return (1 / (sqrt(2 * pi) * stdev)) * exponent

#测试高斯PDF
from math import sqrt
from math import pi
from math import exp

# Calculate the Gaussian probability distribution function for x
def calculate_probability(x, mean, stdev):
	exponent = exp(-((x-mean)**2 / (2 * stdev**2 )))
	return (1 / (sqrt(2 * pi) * stdev)) * exponent

# Test Gaussian PDF
print(calculate_probability(1.0, 1.0, 1.0))
print(calculate_probability(2.0, 1.0, 1.0))
print(calculate_probability(0.0, 1.0, 1.0))

在这里插入图片描述

  • Step 5: Class Probabilities 类概率计算
    • 每个类别的概率是单独计算的。这意味着我们首先计算一条新数据属于第一类的概率，然后计算它属于第二类的概率，以此类推。
    • 一条数据属于一个类的概率计算如下：P(类|数据) = P(X|类) * P(类) *不用除法简化计算
#自定义分类概率函数
def calculate_class_probabilities(summaries, row):
	total_rows = sum([summaries[label][0][2] for label in summaries])
	probabilities = dict()
	for class_value, class_summaries in summaries.items():
		probabilities[class_value] = summaries[class_value][0][2]/float(total_rows)
		for i in range(len(class_summaries)):
			mean, stdev, count = class_summaries[i]
			probabilities[class_value] *= calculate_probability(row[i], mean, stdev)
	return probabilities

三、朴素贝叶斯对IRIS进行分类

#计算样例数据的分类概率
from math import sqrt
from math import pi
from math import exp
dataset = [[3.393533211,2.331273381,0],
	[3.110073483,1.781539638,0],
	[1.343808831,3.368360954,0],
	[3.582294042,4.67917911,0],
	[2.280362439,2.866990263,0],
	[7.423436942,4.696522875,1],
	[5.745051997,3.533989803,1],
	[9.172168622,2.511101045,1],
	[7.792783481,3.424088941,1],
	[7.939820817,0.791637231,1]]
summaries = summarize_by_class(dataset)
probabilities = calculate_class_probabilities(summaries, dataset[0])
print(probabilities)
```# 5、Iris案例
```python
# Naive Bayes On The Iris Dataset
from csv import reader
from random import seed
from random import randrange
from math import sqrt
from math import exp
from math import pi
import math


# 加载数据
def load_csv(filename):
	dataset = list()
	with open(filename, 'r') as file:
		csv_reader = reader(file)
		for row in csv_reader:
			if not row:
				continue
			dataset.append(row)
	return dataset

# 将数据转换为float
def str_column_to_float(dataset, column):
	for row in dataset:
		row[column] = float(row[column].strip())

# 将数据转换为integer
def str_column_to_int(dataset, column):
    class_values = [row[column] for row in dataset]
    unique = set(class_values)
    lookup = dict()
    for i, value in enumerate(unique):
        lookup[value] = i
        print('[%s] => %d' % (value, i))
    for row in dataset:
        row[column] = lookup[row[column]]
    return lookup

# 将数据集拆分为k折
def cross_validation_split(dataset, n_folds):
	dataset_split = list()
	dataset_copy = list(dataset)
	fold_size = int(len(dataset) / n_folds)
	for _ in range(n_folds):
		fold = list()
		while len(fold) < fold_size:
			index = randrange(len(dataset_copy))
			fold.append(dataset_copy.pop(index))
		dataset_split.append(fold)
	return dataset_split

# 计算准确性百分比
def accuracy_metric(actual, predicted):
	correct = 0
	for i in range(len(actual)):
		if actual[i] == predicted[i]:
			correct += 1
	return correct / float(len(actual)) * 100.0

# 使用交叉验证评估算法
def evaluate_algorithm(dataset, algorithm, n_folds, *args):
	folds = cross_validation_split(dataset, n_folds)
	scores = list()
	for fold in folds:
		train_set = list(folds)
		train_set.remove(fold)
		train_set = sum(train_set, [])
		test_set = list()
		for row in fold:
			row_copy = list(row)
			test_set.append(row_copy)
			row_copy[-1] = None
		predicted = algorithm(train_set, test_set, *args)
		actual = [row[-1] for row in fold]
		accuracy = accuracy_metric(actual, predicted)
		scores.append(accuracy)
	return scores

# 据类分割数据，返回字段
def separate_by_class(dataset):
	separated = dict()
	for i in range(len(dataset)):
		vector = dataset[i]
		class_value = vector[-1]
		if (class_value not in separated):
			separated[class_value] = list()
		separated[class_value].append(vector)
	return separated

# 返回平均值
def mean(numbers):
	return sum(numbers)/float(len(numbers))

# 计算标准差
def stdev(numbers):
	avg = mean(numbers)
	variance = sum([(x-avg)**2 for x in numbers]) / float(len(numbers)-1)
	return sqrt(variance)

# 计算每列的均值与标准差
def summarize_dataset(dataset):
	summaries = [(mean(column), stdev(column), len(column)) for column in zip(*dataset)]
	del(summaries[-1])
	return summaries

# 据类分割数据集计算每行统计指标
def summarize_by_class(dataset):
	separated = separate_by_class(dataset)
	summaries = dict()
	for class_value, rows in separated.items():
		summaries[class_value] = summarize_dataset(rows)
	return summaries

# 计算高斯PDF
def calculate_probability(x, mean, stdev):
    exponent=exp(-((x-mean)**2 / (2 * stdev**2 )))
    return (1 / (math.sqrt(2 * pi) * math.pow(stdev,2))) * exponent

# 计算每行给定数据的分类预测概率
def calculate_class_probabilities(summaries, row):
	total_rows = sum([summaries[label][0][2] for label in summaries])
	probabilities = dict()
	for class_value, class_summaries in summaries.items():
		probabilities[class_value] = summaries[class_value][0][2]/float(total_rows)
		for i in range(len(class_summaries)):
			mean, stdev, _ = class_summaries[i]
			probabilities[class_value] *= calculate_probability(row[i], mean, stdev)
	return probabilities

# 对给定的数据进行分类预测
def predict(summaries, row):
	probabilities = calculate_class_probabilities(summaries, row)
	best_label, best_prob = None, -1
	for class_value, probability in probabilities.items():
		if best_label is None or probability > best_prob:
			best_prob = probability
			best_label = class_value
	return best_label

# 定义贝叶斯算法
def naive_bayes(train, test):
	summarize = summarize_by_class(train)
	predictions = list()
	for row in test:
		output = predict(summarize, row)
		predictions.append(output)
	return(predictions)


# 在iris数据集上测试贝叶斯算法
seed(1)
filename = 'iris无索引.csv'
dataset = load_csv(filename)
for i in range(len(dataset[0])-1):
	str_column_to_float(dataset, i)
    
# 将类转换为整型
str_column_to_int(dataset, len(dataset[0])-1)
# 评估算法
n_folds = 5
scores = evaluate_algorithm(dataset, naive_bayes, n_folds)
print('Scores: %s' % scores)
print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))
# 总的准确速度

在这里插入图片描述

给定一个数据集，测试它的分类：

str_column_to_int(dataset, len(dataset[0])-1)
model = summarize_by_class(dataset)
# 数据集给定要符合相相关要求
row = [5.0,3.3,1.4,0.2]
# 预测分类标签
label = predict(model, row)
3print('Data=%s, Predicted: %s' % (row, label))

在这里插入图片描述

from sklearn import datasets
iris = datasets.load_iris() #直接调用数据中台的数据

from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()#拟合
clf = clf.fit(iris.data, iris.target)#建立模型
y_pred=clf.predict(iris.data)#做预测
print("高斯朴素贝叶斯，样本总数： %d 错误样本数 : %d" % (iris.data.shape[0],(iris.target != y_pred).sum()))

在这里插入图片描述

温欣2030
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
机器学习基础算法—贝叶斯
afk110的博客
12-22 260
目录 1
轻松搞定朴素贝叶斯(有例题)
doge_coding的博客
04-23 5556
(哪怕只有高中数学基础都能看懂)通过详细的手写的公式、例题讲清楚朴素贝叶斯，朴素贝叶斯再也不是难题，例题写的很清晰，仅仅详细的讲解理论，没有代码
clf是什么意思：深入剖析其定义、应用场景、挑战与未来展望
最新发布
huejiaqwerty888的博客
05-18 771
其次，clf的选择和调参也是一个复杂的过程，需要根据具体任务和数据特点进行权衡。未来，clf将更加注重模型的可解释性和鲁棒性，以提高其在复杂场景下的可靠性。此外，随着数据资源的不断丰富和计算能力的提升，clf的性能也将得到进一步提升。clf通过对大量已标记数据进行学习，建立起一套分类规则，然后利用这些规则对新的未标记数据进行分类。总之，clf作为机器学习领域的重要工具，其在各个领域的应用不断扩展和深化。虽然面临着一些挑战和困难，但随着技术的不断进步和创新，相信clf将为我们带来更多的惊喜和突破。
机器学习（十）——贝叶斯分类器
嘟嘟伐木工的博客
06-14 447
第一章节 贝叶斯决策论 贝叶斯决策论是概率框架下的实施决策的基本方法；贝叶斯决策论考虑如何基于这些概率和误判损失来选择最优的类别标记。 1 贝叶斯基本原理 目的：通过误判损失最小化得到   过程：参考周志华《机器学习》的贝斯决策论      不难看出，欲使用贝叶斯判定准则来最小化决策风险，首先要获得后验概率P(c\x)-----（下面的截图中c和x改为A和D）   对于...
朴素贝叶斯算法
01-07
一、朴素贝叶斯综述 \quad贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素贝叶斯分类是贝叶斯分类中最简单也是最常见的一种。 \quad对于分类问题，其实谁都不陌生，日常生活中我们每天都进行着分类过程，例如，当你看到一个人，你的脑子下意识判断他是学生还是社会上的人；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话，其实这就是一种分类操作。 \quad既然是贝叶斯分类算法，那么分类的数学描述又是什么呢？ \quad从数学角度来说，分类问题可做如下定义：已知集合C=y1,y2,…,ynC=y_1,y_2,…,y_nC=y1​,y2​,…,y
机器学习之朴素贝叶斯（连续值）二
Huangxin_Yu的博客
10-24 1685
朴素贝叶斯分类器（连续值） 某样本如下： 问题：身高170，体重130，鞋码42，请问是男是女？ 当特征为连续值时，直接求条件概率就比较困难。假设特征均为正太分布，即身高、体重、鞋码均为正太分布，正太分布的均值、标准差由样本算出，根据正太分布算出某一个特征的具体值。 实现求正太分布中某一值的概率密度，如下： from pandas import DataFrame from scipy import stats #step1 导入数据 data = DataFrame({'身高':[183,182,17
机器学习之贝叶斯算法
大数据同盟会的博客
09-07 2883
机器学习算法，就是基于大量经验数据对某个问题进行预测的算法； 1、机器学习分类 从训练特点，可以分为监督学习、无监督学习、半监督学习； 从解决问题，可以分为分类算法，聚类算法，回归分析算法，推荐算法； 2、数学基础 向量： 就是一串数字，代表现实中某个事物的一系列特征和特征值 相似度： 用欧几里得距离来衡量相似度： 用余弦相似度衡量： 概率入门： 联合概率 P(A^B) ：多件事情都发生的可能性！ 条件概率 P(A | B) = P(A^B)/ P(B) : B条件下A发生的概率 贝叶斯公式 P(B
bayes09_机器学习_机器学习的算法_朴素贝叶斯_
09-29
在机器学习领域，朴素贝叶斯算法是一种广泛应用的分类方法，尤其在文本分类、垃圾邮件过滤和推荐系统中表现出色。这个压缩包“bayes09_机器学习_机器学习的算法_朴素贝叶斯_”可能包含了关于朴素贝叶斯算法的详细...
Bayes_new5i8_朴素贝叶斯算法_strangeg7w_朴素贝叶斯_
10-04
朴素贝叶斯算法是一种基于概率的分类方法，其理论基础源于贝叶斯定理。在机器学习领域，它被广泛应用于文本分类、垃圾邮件过滤、情感分析等多种问题中。在这个项目"Bayes_new5i8_朴素贝叶斯算法_strangeg7w_朴素...
Logistic回归_机器学习_朴素贝叶斯_
09-30
接着，我们探讨朴素贝叶斯算法。朴素贝叶斯是一种基于贝叶斯定理和特征条件独立假设的分类方法。它假设各特征之间相互独立，这在实际应用中可能并不完全成立，因此称为“朴素”。尽管如此，朴素贝叶斯在许多情况下...
机器学习__朴素贝叶斯分类器.pptx
01-14
在机器学习领域，朴素贝叶斯分类器因其简单、高效且易于实现而被广泛应用。它主要依赖于两个关键假设：一是贝叶斯定理，二是属性条件独立假设。 贝叶斯定理描述了在已知先验概率的情况下，如何通过观测到的证据来...
决策树分类和朴素贝叶斯分类练习题及答案.pdf
05-16
精品资料 欢迎下载
PHP实现机器学习之朴素贝叶斯算法详解
12-19
本文实例讲述了PHP实现机器学习之朴素贝叶斯算法。分享给大家供大家参考，具体如下： 机器学习已经在我们的生活中变得随处可见了。比如从你在家的时候温控器开始工作到智能汽车以及我们口袋中的智能手机。机器学习看...
【机器学习实战】朴素贝叶斯(连续型/离散型)
热门推荐
花丸大老师的博客
08-15 1万+
朴素贝叶斯 一、连续型 当特征中数据是连续型时，通常有两种方法来估计条件概率。 第一种方法是把每一个连续的数据离散化，然后用相应的离散区间替换连续数值。这种方法对于划分离散区间的粒度要求较高，不能太细，也不能太粗。 第二种方法是假设连续数据服从某个概率分布，使用训练数据估计分布参数，通常我们用高斯分布来表示连续数据的类条件概率分布。 此处我们使用第二种方法： 1.计算高斯概...
机器学习之朴素贝叶斯（一）思想及典型例题手写实现
繁华三千东流水不舍昼夜的博客
08-13 3735
朴素贝叶斯对应特殊的例题的简易实现，重要的还是理解其原理，调库的时候可以灵活使用。
朴素贝叶斯的算法
weixin_44677406的博客
11-15 2783
1.朴素贝叶斯的算法 朴素贝叶斯（Naive Bayes）是一种简单经典的分类算法，它的经典应用案例为人所熟知：文本分类（如垃圾邮件过滤） 1.1 贝叶斯定理 条件概率： P(A|B)表示事件B已经发生的前提下，事件A发生的概率，叫做事件B发生下事件A的条件概率。其基本求解公式为：P(A|B)=P(AB)P(B) 贝叶斯定理便是基于条件概率，通过P(A|B)来求P(B|A)： 另外：上式中的分母P(A),可以根据全概率公式分解为： 1.2 特征条件独立假设 特征条件假设:假设每个特征之间没有联系 给定训
贝叶斯公式习题
rv0p111
06-23 8778
简单记录下
机器学习实战——朴素贝叶斯练习
瑶子的博客
08-26 420
参考：https://www.cnblogs.com/zy230530/p/6847243.html 代码段需完善 假设这里要被分类的类别有两类，类c1和类c2，那么我们需要计算概率p(c1|x,y)和p(c2|x,y)的大小并进行比较： 如果：p(c1|x,y)&amp;gt;p(c2|x,y),则(x,y)属于类c1 p(c1|x,y)&amp;lt;p(c2|x,y),则(x,y)属于类c...
机器学习-朴素贝叶斯实例分析
D.W 的专栏
06-01 2840
引文：由于之前讲过了朴素贝叶斯的理论Stanford机器学习[第五讲]-生成学习算法第四部分，同时朴素贝叶斯的算法实现也讲过了，见机器学习算法-朴素贝叶斯Python实现。那么这节课打算讲解一下朴素贝叶斯算法的具体计算流程，通过一个具体的实例来讲解。PS：为了专注于某一个细节，本章节只抽取了视频的一部分来讲解，只讲解一个贝叶斯算法的计算流程，关于视频里面的具体内容请参考下面的视频链接。讲解的实例是一
机器学习朴素贝叶斯算法实验
11-01
机器学习中的朴素贝叶斯算法是一种基于概率统计的分类算法，它可以用于文本分类、垃圾邮件过滤、情感分析等任务。在实验中，我们需要准备好训练数据集和测试数据集，然后使用朴素贝叶斯算法对训练数据进行训练，得到分类器模型。接着，我们可以使用测试数据集对分类器模型进行测试，计算分类器的准确率、召回率、F1值等指标来评估分类器的性能。在实验中，我们还可以尝试使用不同的特征提取方法、不同的参数设置等来优化分类器的性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

温欣2030

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值