朴素贝叶斯算法

已于 2022-06-05 18:44:52 修改
阅读量1.2k 收藏
点赞数 2
分类专栏： machine learning 文章标签： 机器学习
于 2022-05-04 23:22:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taifyang/article/details/124579931
版权

原理参考：
Python手写实现朴素贝叶斯（从原理到代码）
朴素贝叶斯算法的Python实现（多项式、高斯）
三种常用的朴素贝叶斯实现算法——高斯朴素贝叶斯、伯努利朴素贝叶斯、多项式朴素贝叶斯

代码传送门：https://github.com/taifyang/machine-learning

目录

伯努利模型

python实现：

import numpy as np

class BernoulliNB(object):
    def __init__(self, alpha = 1.0, fit_prior=True):
        self.alpha = alpha
        self.fit_prior = fit_prior #是否学习类的先验几率，False则使用统一的先验
        self.class_prior = None    #类的先验几率，若指定则先验不能根据数据调整   
        self.classes = None
        self.conditional_prob = None
        self.predict_prob = None

    def fit(self,x,y):
        #计算类别y的先验几率
        self.classes = np.unique(y)
        if self.class_prior == None:#先验几率没有指定
            class_num = len(self.classes)
            self.class_prior = {}
            if not self.fit_prior:
                for d in self.classes:
                    self.class_prior[d] = 1.0/class_num 
            else:        
                for d in self.classes:
                    c_num = np.sum(np.equal(y,d))
                    self.class_prior[d]=(c_num+self.alpha) / (len(y) + class_num * self.alpha)          
        print(self.class_prior)
        #计算条件几率------伯努利模型
        self.conditional_prob = {}#{x1|y1:p1,x2|y1:p2,.....,x1|y2:p3,x2|y2:p4,.....}
        x_class = [0,1]
        y = list(y)
        for yy in self.class_prior.keys():          
            y_index = [i for i,label in enumerate(y) if label == yy] #标签的先验几率
            for i in range(len(x)):       
                for c in x_class:
                    x_index = [j for j,feature in enumerate(x[i]) if feature == c]
                    xy_count = len(set(x_index) & set(y_index))
                    pkey = str(c) + '|' + str(yy)
                    self.conditional_prob[pkey] = (xy_count+self.alpha) / (len(y_index)+2)
        print(self.conditional_prob)
        return self

    def predict(self, x):
        labels = []
        for i in range(x.shape[0]):
            self.predict_prob = {}
            for j in self.classes:
                self.predict_prob[j] = self.class_prior[j]          
                for d in x[i]:
                    self.predict_prob[j] = self.predict_prob[j]*self.conditional_prob[str(d) + '|'+ str(j)]
            print(self.predict_prob)
            label = max(self.predict_prob, key=self.predict_prob.get)
            labels.append(label)
        return labels


if __name__ == '__main__':   
    x = np.array([[1,1,1,1,1,0,0,0,0,0,1,1,1,1,1],[0,1,1,0,0,0,1,1,1,1,1,1,1,1,1]])
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    bnb= BernoulliNB(alpha=1.0,fit_prior=True)
    bnb.fit(x, y)
    print('预测值为：', bnb.predict(np.array([[0,0]])))

python调包：

import numpy as np
from sklearn.naive_bayes import BernoulliNB

if __name__ == '__main__':   
    x = np.array([[1,1,1,1,1,0,0,0,0,0,1,1,1,1,1],[0,1,1,0,0,0,1,1,1,1,1,1,1,1,1]]).T
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    bnb = BernoulliNB()
    bnb.fit(x,y)
    print('预测值为：', bnb.predict(np.array([[0,0]])))

C++实现：

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>

class BernoulliNB
{
public:
	BernoulliNB(float alpha, bool fit_prior = true):m_alpha(alpha),m_fit_prior(fit_prior){}

	void fit(std::vector<std::vector<float>> x, std::vector<float> y)
	{
		for (auto i : y)	
			m_classes.insert(i);
		if (m_class_prior.size() == 0)
		{
			int class_num = m_classes.size();
			if (!m_fit_prior)
			{
				for (auto d : m_classes)
					m_class_prior[d] = 1.0 / class_num;
			}
			else {
				for (auto d : m_classes)
				{
					int c_num = 0;
					for (auto i:y)	c_num += (d == i ? 1 : 0);
					m_class_prior[d] = (c_num + m_alpha) / (y.size() + class_num*m_alpha);
				}
			}
		}

		std::vector<float> x_class = { 0, 1 };
		for (auto pa : m_class_prior)
		{
			//	std::cout << pa.first << " " << pa.second << std::endl;
			std::vector<int> y_index;
			for (size_t i = 0; i < y.size(); i++)
			{
				if (y[i] == pa.first)	y_index.push_back(i);
			}

			for (size_t i = 0; i < x.size(); i++)
			{
				for (auto c : x_class)
				{
					std::vector<int> x_index;
					for (size_t j = 0; j < x[i].size(); j++)
					{
						if (x[i][j] == c)	x_index.push_back(j);
					}

					std::sort(x_index.begin(), x_index.end());
					std::sort(y_index.begin(), y_index.end());
					std::vector<int> xy_index;
					std::set_intersection(x_index.begin(), x_index.end(), y_index.begin(), y_index.end(), std::back_inserter(xy_index));//求交集 

					std::string pkey = std::to_string(c) + "|" + std::to_string(pa.first);
					//std::cout << pkey << std::endl;

					m_conditional_prob[pkey] = (xy_index.size() + m_alpha) / (y_index.size() + 2);
				}
			}
		}
		
		for (auto pa : m_conditional_prob)
			std::cout << pa.first << " " << pa.second << std::endl;
	}

	std::vector<float> predict(std::vector<std::vector<float>> x)
	{
		std::vector<float> labels;
		for (size_t i = 0; i < x.size(); i++)
		{
			m_predict_prob.clear();
			for (auto j : m_classes)
			{
				m_predict_prob[j] = m_class_prior[j];
				for (auto d : x[i])
				{
					m_predict_prob[j] *= m_conditional_prob[std::to_string(d) + "|" + std::to_string(j)];
				}
			}

			for (auto pa : m_predict_prob)
				std::cout << pa.first << " " << pa.second << std::endl;

			std::vector<std::pair<float, float>>  m_predict_prob_vec;
			for (std::map<float, float>::iterator it = m_predict_prob.begin(); it != m_predict_prob.end(); it++)
			{
				m_predict_prob_vec.push_back(std::make_pair((*it).first, (*it).second));
			}
			std::sort(m_predict_prob_vec.begin(), m_predict_prob_vec.end(), [](std::pair<float, float> p1, std::pair<float, float> p2) {return p1.second < p2.second; });
			float label = m_predict_prob_vec.rbegin()->first;
			labels.push_back(label);
		}
	
		return labels;
	}

private:
	float m_alpha;
	bool m_fit_prior;
	std::map<float, float> m_class_prior;
	std::set<float> m_classes;
	std::map<std::string, float> m_conditional_prob;
	std::map<float, float> m_predict_prob;
};


int main(int argc, char* argv[])
{
	std::vector<std::vector<float>> x = { { 1,1,1,1,1,0,0,0,0,0,1,1,1,1,1 }, { 0,1,1,0,0,0,1,1,1,1,1,1,1,1,1 } };
	std::vector<float> y = { -1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1 };

	BernoulliNB bnb = BernoulliNB(1.0, true);
	bnb.fit(x, y);
	std::cout << "预测值为：" << bnb.predict({ { 0,0 } })[0] << std::endl;

	system("pause");
	return EXIT_SUCCESS;
}

多项式模型

python实现：

import numpy as np

class MultinomialNB(object):
    def __init__(self, alpha = 1.0, fit_prior=True):
        self.alpha = alpha
        self.fit_prior = fit_prior #是否学习类的先验几率，False则使用统一的先验
        self.class_prior = None    #类的先验几率，若指定则先验不能根据数据调整   
        self.classes = None
        self.conditional_prob = None
        self.predict_prob = None

    def fit(self,x,y):
        #计算类别y的先验几率
        self.classes = np.unique(y)
        if self.class_prior == None:#先验几率没有指定
            class_num = len(self.classes)
            self.class_prior = {}
            if not self.fit_prior:
                for d in self.classes:
                    self.class_prior[d] = 1.0/class_num 
            else:        
                for d in self.classes:
                    c_num = np.sum(np.equal(y,d))
                    self.class_prior[d]=(c_num+self.alpha) / (len(y) + class_num * self.alpha)          
        print(self.class_prior)
        #计算条件几率------多项式模型
        self.conditional_prob = {}#{x1|y1:p1,x2|y1:p2,.....,x1|y2:p3,x2|y2:p4,.....}
        y = list(y)
        for yy in self.class_prior.keys():
            y_index = [i for i,label in enumerate(y) if label == yy] #标签的先验几率
            for i in range(len(x)):
                x_class = np.unique(x[i])
                #print(x_class)
                for c in list(x_class):
                    x_index = [j for j,feature in enumerate(x[i]) if feature == c]
                    xy_count = len(set(x_index) & set(y_index))
                    pkey = str(c) + '|' + str(yy)
                    self.conditional_prob[pkey] = (xy_count+self.alpha) / (len(y_index)+x_class.shape[0])
        print(self.conditional_prob)
        return self

    def predict(self, x):
        labels = []
        for i in range(x.shape[0]):
            self.predict_prob = {}
            for j in self.classes:
                self.predict_prob[j] = self.class_prior[j]          
                for d in x[i]:
                    self.predict_prob[j] = self.predict_prob[j]*self.conditional_prob[str(d) + '|'+ str(j)]
            print(self.predict_prob)
            label = max(self.predict_prob, key=self.predict_prob.get)
            labels.append(label)
        return labels


if __name__ == '__main__':
    x = np.array([[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3],[1,2,2,1,1,1,2,2,3,3,3,2,2,3,3]])
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    mnb = MultinomialNB(alpha=1.0,fit_prior=True)
    mnb.fit(x, y)
    print('预测值为：', mnb.predict(np.array([[2,1]])))

python调包：

import numpy as np
from sklearn.naive_bayes import MultinomialNB

if __name__ == '__main__':   
    x = np.array([[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3],[1,2,2,1,1,1,2,2,3,3,3,2,2,3,3]]).T
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    mnb = MultinomialNB()
    mnb.fit(x,y)
    print('预测值为：', mnb.predict(np.array([[2,1]])))

C++实现：

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>

class MultinomialNB
{
public:
	MultinomialNB(float alpha, bool fit_prior = true) :m_alpha(alpha), m_fit_prior(fit_prior) {}

	void fit(std::vector<std::vector<float>> x, std::vector<float> y)
	{
		for (auto i : y)
			m_classes.insert(i);
		if (m_class_prior.size() == 0)
		{
			int class_num = m_classes.size();
			if (!m_fit_prior)
			{
				for (auto d : m_classes)
					m_class_prior[d] = 1.0 / class_num;
			}
			else {
				for (auto d : m_classes)
				{
					int c_num = 0;
					for (auto i : y)	c_num += (d == i ? 1 : 0);
					m_class_prior[d] = (c_num + m_alpha) / (y.size() + class_num*m_alpha);
				}
			}
		}

		for (auto pa : m_class_prior)
		{
			//	std::cout << pa.first << " " << pa.second << std::endl;
			std::vector<int> y_index;
			for (size_t i = 0; i < y.size(); i++)
			{
				if (y[i] == pa.first)	y_index.push_back(i);
			}

			for (size_t i = 0; i < x.size(); i++)
			{
				std::set<float> x_class(x[i].begin(), x[i].end());
				for (auto c : x_class)
				{
					std::vector<int> x_index;
					for (size_t j = 0; j < x[i].size(); j++)
					{
						if (x[i][j] == c)	x_index.push_back(j);
					}

					std::sort(x_index.begin(), x_index.end());
					std::sort(y_index.begin(), y_index.end());
					std::vector<int> xy_index;
					std::set_intersection(x_index.begin(), x_index.end(), y_index.begin(), y_index.end(), std::back_inserter(xy_index));//求交集 

					std::string pkey = std::to_string(c) + "|" + std::to_string(pa.first);
					m_conditional_prob[pkey] = (xy_index.size() + m_alpha) / (y_index.size() + x_class.size());
				}
			}
		}

		for (auto pa : m_conditional_prob)
			std::cout << pa.first << " " << pa.second << std::endl;
	}

	std::vector<float> predict(std::vector<std::vector<float>> x)
	{
		std::vector<float> labels;
		for (size_t i = 0; i < x.size(); i++)
		{
			m_predict_prob.clear();
			for (auto j : m_classes)
			{
				m_predict_prob[j] = m_class_prior[j];
				for (auto d : x[i])
				{
					m_predict_prob[j] *= m_conditional_prob[std::to_string(d) + "|" + std::to_string(j)];
				}
			}

			for (auto pa : m_predict_prob)
				std::cout << pa.first << " " << pa.second << std::endl;

			std::vector<std::pair<float, float>>  m_predict_prob_vec;
			for (std::map<float, float>::iterator it = m_predict_prob.begin(); it != m_predict_prob.end(); it++)
			{
				m_predict_prob_vec.push_back(std::make_pair((*it).first, (*it).second));
			}
			std::sort(m_predict_prob_vec.begin(), m_predict_prob_vec.end(), [](std::pair<float, float> p1, std::pair<float, float> p2) {return p1.second < p2.second; });
			float label = m_predict_prob_vec.rbegin()->first;
			labels.push_back(label);
		}

		return labels;
	}

private:
	float m_alpha;
	bool m_fit_prior;
	std::map<float, float> m_class_prior;
	std::set<float> m_classes;
	std::map<std::string, float> m_conditional_prob;
	std::map<float, float> m_predict_prob;
};


int main(int argc, char* argv[])
{
	std::vector<std::vector<float>> x = { { 1,1,1,1,1,2,2,2,2,2,3,3,3,3,3 },{ 1,2,2,1,1,1,2,2,3,3,3,2,2,3,3 } };
	std::vector<float> y = { -1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1 };

	MultinomialNB mnb = MultinomialNB(1.0, true);
	mnb.fit(x, y);
	std::cout << "预测值为：" << mnb.predict({ { 2,1 } })[0] << std::endl;

	system("pause");
	return EXIT_SUCCESS;
}

高斯模型

python实现：

import numpy as np

class GaussionNB(object):   #计算条件几率的方法不同
    def __init__(self, fit_prior=True):
        self.fit_prior = fit_prior #是否学习类的先验几率，False则使用统一的先验
        self.class_prior = None    #类的先验几率，若指定则先验不能根据数据调整  
        self.classes = None
        self.mean = None
        self.var = None
        self.predict_prob = None

    def fit(self,x,y):
        #计算类别y的先验几率
        self.classes = np.unique(y)
        if self.class_prior == None:#先验几率没有指定
            class_num = len(self.classes)
            self.class_prior = {}
            if not self.fit_prior:
                for d in self.classes:
                    self.class_prior[d] = 1.0/class_num 
            else:
                self.class_prior = {}
                for d in self.classes:
                    c_num = np.sum(np.equal(y,d))
                    self.class_prior[d]= c_num / len(y)
        print(self.class_prior)           
        #计算条件几率------高斯模型
        self.mean = {}
        self.var = {}
        y = list(y)
        for yy in self.class_prior.keys():
            y_index = [i for i,label in enumerate(y) if label == yy] #标签的先验几率
            #print(y_index)
            for i in range(len(x)):
                x_class =[]
                for j in y_index:
                    x_class.append(x[i][j])
                    pkey = str(i) + '|' + str(yy)
                    mean = np.mean(x_class)
                    var = np.var(x_class)
                    self.mean[pkey] = mean
                    self.var[pkey] = var
                #print(x_class)
        print(self.mean, self.var)
        return self

    def _calculat_prob_gaussion(self,mu,sigma,x):    
        return  1.0/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (x - mu)**2 / (2 * sigma**2)) 

    def predict(self,x):
        labels = []
        for i in range(x.shape[0]):
            self.predict_prob = {}
            for yy in self.class_prior.keys():
                self.predict_prob[yy] = self.class_prior[yy]
                for c,d in  enumerate(list(x[i])):
                    tkey = str(c)+'|'+str(yy)
                    mu = self.mean[tkey] 
                    sigma = self.var[tkey] 
                    print(mu,sigma)
                    self.predict_prob[yy] = self.predict_prob[yy]*self._calculat_prob_gaussion(mu,sigma,d)     
            print(self.predict_prob)
            label = max(self.predict_prob, key=self.predict_prob.get)
            labels.append(label)
        return labels


if __name__ == '__main__':
    x = np.array([[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3],[1,2,2,1,1,1,2,2,3,3,3,2,2,3,3]])
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    gnb = GaussionNB()
    gnb.fit(x, y)
    print('预测值为：', gnb.predict(np.array([[2,1]])))

python调包：

import numpy as np
from sklearn.naive_bayes import GaussianNB

if __name__ == '__main__':   
    x = np.array([[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3],[1,2,2,1,1,1,2,2,3,3,3,2,2,3,3]]).T
    y = np.array([-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1])
    gnb = GaussianNB()
    gnb.fit(x,y)
    print('预测值为：', gnb.predict(np.array([[2,1]])))

C++实现：

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>

#define PI 3.1415926

class GaussionNB
{
public:
	GaussionNB(bool fit_prior = true) : m_fit_prior(fit_prior) {}

	void fit(std::vector<std::vector<float>> x, std::vector<float> y)
	{
		for (auto i : y)
			m_classes.insert(i);
		if (m_class_prior.size() == 0)
		{
			int class_num = m_classes.size();
			if (!m_fit_prior)
			{
				for (auto d : m_classes)
					m_class_prior[d] = 1.0 / class_num;
			}
			else {
				for (auto d : m_classes)
				{
					float c_num = 0;
					for (auto i : y)	c_num += (d == i ? 1 : 0);
					m_class_prior[d] = c_num / y.size();
				}
			}
		}

		for (auto pa : m_class_prior)
		{
			//std::cout << pa.first << " " << pa.second << std::endl;
			std::vector<int> y_index;
			for (size_t i = 0; i < y.size(); i++)
			{
				if (y[i] == pa.first)	y_index.push_back(i);
			}
			//for (size_t j = 0; j < y_index.size(); j++) std::cout << y_index[j] << " "; std::cout << std::endl;
			
			for (size_t i = 0; i < x.size(); i++)
			{
				std::vector<float> x_class;

				for (auto j:y_index)
				{
					x_class.push_back(x[i][j]);

					std::string pkey = std::to_string(i) + "|" + std::to_string(pa.first);
					
					float mean_val = 0;
					for (size_t k = 0; k < x_class.size(); k++)
					{
						mean_val += x_class[k];
					}
					mean_val /= x_class.size();
					m_mean[pkey] = mean_val;

					float var_val = 0;
					for (size_t k = 0; k < x_class.size(); k++)
					{
						var_val += pow(x_class[k] - mean_val, 2);
					}
					var_val /= x_class.size();
					m_var[pkey] = var_val;
				}

				//for (auto i : x_class)	std::cout << i << " "; std::cout << std::endl;
			}
		}

		//for (auto pa : m_mean)	std::cout << pa.first << " " << pa.second << std::endl;
		//for (auto pa : m_var)	std::cout << pa.first << " " << pa.second << std::endl;
	}

	float _calculat_prob_gaussion(float mu, float sigma, float x)
	{
		return 1.0 / (sigma*sqrt(2 * PI))*exp(-pow(x - mu, 2) / (2 * pow(sigma, 2)));
	}

	std::vector<float> predict(std::vector<std::vector<float>> x)
	{
		std::vector<float> labels;
		for (size_t i = 0; i < x.size(); i++)
		{
			m_predict_prob.clear();
			for (auto pa : m_class_prior)
			{
				m_predict_prob[pa.first] = m_class_prior[pa.first];
				for (size_t j = 0; j < x[i].size(); ++j)
				{
					std::string tkey = std::to_string(j) + "|" + std::to_string(pa.first);
					//std::cout << tkey << std::endl;

					float mu = m_mean[tkey];
					float sigma = m_var[tkey];
					//std::cout << mu << " " << sigma << std::endl;
					m_predict_prob[pa.first] *= _calculat_prob_gaussion(mu, sigma, x[i][j]);
				}
			}

			//for (auto pa : m_predict_prob)	std::cout << pa.first << " " << pa.second << std::endl;

			std::vector<std::pair<float, float>>  m_predict_prob_vec;
			for (std::map<float, float>::iterator it = m_predict_prob.begin(); it != m_predict_prob.end(); it++)
			{
				m_predict_prob_vec.push_back(std::make_pair((*it).first, (*it).second));
			}
			std::sort(m_predict_prob_vec.begin(), m_predict_prob_vec.end(), [](std::pair<float, float> p1, std::pair<float, float> p2) {return p1.second < p2.second; });
			float label = m_predict_prob_vec.rbegin()->first;
			labels.push_back(label);
		}

		return labels;
	}

private:
	bool m_fit_prior;
	std::map<float, float> m_class_prior;
	std::set<float> m_classes;
	std::map<std::string, float> m_mean;
	std::map<std::string, float> m_var;
	std::map<float, float> m_predict_prob;
};


int main(int argc, char* argv[])
{
	std::vector<std::vector<float>> x = { { 1,1,1,1,1,2,2,2,2,2,3,3,3,3,3 },{ 1,2,2,1,1,1,2,2,3,3,3,2,2,3,3 } };
	std::vector<float> y = { -1,-1,1,1,-1,-1,-1,1,1,1,1,1,1,1,-1 };

	GaussionNB gnb = GaussionNB();
	gnb.fit(x, y);
	std::cout << "预测值为：" << gnb.predict({ { 2,1 } })[0] << std::endl;

	system("pause");
	return EXIT_SUCCESS;
}
给算法爸爸上香
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
三种常用的朴素贝叶斯实现算法——高斯朴素贝叶斯、伯努利朴素贝叶斯、多项式朴素贝叶斯
ws19920726的博客
04-24 9480
在sklearn中，提供了若干种朴素贝叶斯的实现算法，不同的朴素贝叶斯算法，主要是对P(xi|y)的分布假设不同，进而采用不同的参数估计方式。我们能够发现，朴素贝叶斯算法，主要就是计算P(xi|y)，一旦P(xi|y)确定，最终属于每个类别的概率，自然也就迎刃而解了。 常用的三种朴素贝叶斯为： 高斯朴素贝叶斯 伯努利朴素贝叶斯 多项式朴素贝叶斯 高斯朴素贝叶斯 适用于连续变量，其假定各个特征x...
手推朴素贝叶斯
weixin_43913783的博客
04-23 276
手推朴素贝叶斯&Sklearn 调库方法手推朴素贝叶斯**下溢问题****Sklearn调库实现** 手推朴素贝叶斯 下溢问题 数值下溢问题：是指计算机浮点数计算的结果小于可以表示的最小数，因为计算机的能力有限，当数值小于一定数时，其无法精确保存，会造成数值的精度丢失. 由上述公式可以看到，求概率时多个概率值相乘，得到的结果往往非常小；因此通常采用取对数的方式，将连乘转化为连加，...
9.机器学习-十大算法之一朴素贝叶斯（Naive Bayes）算法案例讲解
weixin_50804299的博客
05-23 3012
机器学习中的朴素贝叶斯（Naive Bayes）算法是一种基于贝叶斯定理和特征条件独立假设的分类算法。该算法通过计算给定特征下各个类别的概率，并选择概率最大的类别作为预测结果。朴素贝叶斯算法因其简单、高效且易于实现的特点，在文本分类、垃圾邮件过滤、情感分析等领域得到广泛应用。以下案例将详细讲解朴素贝叶斯算法的原理、应用及其实践过程中的注意事项。以山河作礼。🎖️🎖️:Python领域新星创作者，CSDN实力新星认证，CSDN内容合伙人，阿里云社区专家博主，新星计划导师，在职数据分析师。
【手写算法实现】 之 朴素贝叶斯 Naive Bayes 篇
风信子的猫Redamancy的快乐星球
09-01 5851
【手写算法实现】 之 朴素贝叶斯 Naive Bayes 篇 朴素贝叶斯模型(naive bayes)属于分类模型，也是最为简单的概率图模型，对于之后理解HMM、CRF等模型，大有裨益。这里手写算法介绍一下朴素贝叶斯模型。.........
高斯朴素贝叶斯
flyfish
10-25 5999
高斯朴素贝叶斯flyfish正态分布（Normal distribution）其他名字高斯分布（Gaussian distribution）若随机变量X服从一个数学期望为μ、标准方差为σ^2的高斯分布，记为：X∼N(μ,σ^2), 则其概率密度函数为f(x)=1σ2π√e−(x−μ)22σ2f(x) = {1 \over \sigma\sqrt{2\pi} }\,e^{- {{(x-\mu )^2
Spark 低配版高斯朴素贝叶斯实现
Qero的专栏
08-24 1237
最近有项目用到Scikit-learn上的高斯朴素贝叶斯模型（简称GNB），随着数据量增大，单机上跑GNB肯定会很慢，所以打算转Spark上。然后发现MLlib并没有实现GNB，自己动手，丰衣足食～原理  GNB的原理是基于朴素贝叶斯，所以先交代朴素贝叶斯的原理。朴素贝叶斯贝叶斯公式...
朴素贝叶斯算法.ppt
10-18
在人工智能领域，贝叶斯方法是一种非常具有代表性的不确定性知识表示和推理方法。
项目实战-朴素贝叶斯算法实现新闻分类源码及数据集.zip
04-17
1、内容概要：本资源主要基朴素贝叶斯算法实现新闻分类，适用于初学者学习文本分类使用。 2、新闻分类源码实现过程：将数据集划分为训练集和测试集；使用jieba模块进行分词，词频统计，停用词过滤，文本特征提取，将...
java实现朴素贝叶斯分类算法
12-23
2. **朴素贝叶斯假设**：朴素贝叶斯算法的核心在于“朴素”一词，即假设所有特征之间相互独立。这简化了计算过程，使得我们只需要知道每个特征独立出现的概率。 3. **数据预处理**：在Java实现中，首先需要对数据...
朴素贝叶斯算法实现(使用MNIST数据集)_Python环境
07-26
朴素贝叶斯算法是一种基于概率理论的分类方法，它的核心思想是假设各个特征之间相互独立，并且基于贝叶斯定理来计算一个实例属于某个类别的概率。在本项目中，我们将利用朴素贝叶斯算法处理MNIST数据集，这是一个...
朴素贝叶斯--（高斯朴素贝叶斯）
zz__dm的博客
01-13 349
import numpy as np import pandas as pd import random import os import scipy.stats os.chdir(r'D:\Python 练习') dataSet = pd.read_csv('iris.csv') def randSplit(dataSet,rate): l=list(dataSet.inde...
机器学习（五）：高斯朴素贝叶斯（基础篇）
Auraros的博客
07-12 3743
机器学习（五）：高斯朴素贝叶斯（基础篇） 在高斯朴素贝叶斯中，每个特征都是连续的，并且都呈高斯分布。高斯分布又称为正态分布。图画出来以后像一个倒挂的钟，以均值为轴对称，如下图所示： GaussianNB 实现了运用于分类的高斯朴素贝叶斯算法。特征的可能性(即概率)假设为高斯分布: 参数\large \sigma _{y}和\large \mu _{y}使用最大似然法估计。 使用数据集：Iris...
【机器学习sklearn】高斯朴素贝叶斯 Gaussian naive bayes
Aoyama的博客
12-21 1万+
贝叶斯Bayes - Thomas Bayes前言一、贝叶斯决策论（Bayesian decision theory）二、实例：高斯朴素贝叶斯 Gaussian Naive Bayes (GaussianNB)1.引入库2.生成数据3.高斯朴素贝叶斯模型总结 前言 在介绍贝叶斯之前，我们先了解一下几个概率相关的定义： 条件概率（后验概率）：事件A在另一个事件B已经发生的条件下发生概率，公式表示为P(A|B)，读作“在B条件下A的概率”。 P(A∣B)=P(A∩B)P(B)P(A|B)=\frac{P(.
朴素贝叶斯的三个常用模型：高斯、多项式、伯努利
热门推荐
qq_27009517的博客
04-22 4万+
在文本分类中，假设我们有一个文档d∈X，X是文档向量空间(document space)，和一个固定的类集合C={c1,c2,…,cj}，类别又称为标签。显然，文档向量空间是一个高维度空间。我们把一堆打了标签的文档集合&lt;d,c&gt;作为训练样本，&lt;d,c&gt;∈X×C。例如：&lt;d,c&gt;={Beijing joins the World Trade Organizatio...
高斯朴素贝叶斯分类的原理解释和手写代码实现
deephub
04-07 5398
Gaussian Naive Bayes (GNB) 是一种基于概率方法和高斯分布的机器学习的分类技术。朴素贝叶斯假设每个参数（也称为特征或预测变量）具有预测输出变量的独立能力。所有参数的预测组合是最终预测，它返回因变量被分类到每个组中的概率，最后的分类被分配给概率较高的分组（类）。 什么是高斯分布？ 高斯分布也称为正态分布，是描述自然界中连续随机变量的统计分布的统计模型。正态分布由其钟形曲线定义， 正态分布中两个最重要的特征是均值 (μ) 和标准差 (σ)。平均值是分布的平均值，标准差是分布在平均值周围
机器学习之朴素贝叶斯算法的详解（包含高斯朴素贝特斯、多项式朴素贝叶斯、伯努利朴素贝叶斯，以及相应算法的简单实现）
weixin_40247876的博客
06-02 7136
机器学习18_贝叶斯算法详解（2021.06.02） 一. 朴素贝叶斯算法 为什么需要朴素贝叶斯算法？ 比如说，我们想预测一个人究竟是否能够侥幸在空难中生还，那么我们就需要建立一个分类模型来学习我们的训练集。在训练集中，其中一个人的特征是30岁，男，普通舱，他最终在空难中去世了。训练完成后，当我们使用训练好的模型进行测试的时候，测试的目标的特征也是30岁，男，普通舱，那么我们的模型必然会给这个人打上去世的标签。然而事实却不一定为此，也许这个人正好坐在了离逃生口最近的位置，他得到了第一时间的救治而生存下来了
高斯朴素贝叶斯、K近邻算法实现 | Python
OnedayIlove的博客
07-24 435
这些算法实现依赖于numpy/pandas库，而且度量结果与SKlearn一致 贝叶斯算法实现 算法介绍:华校专的笔记 这里只实现了 “假设所有特征都是数值型”。 class GaussianNaiveBayes(): def __init__(self): # 有多少类别 self.classes = None # 每...
高斯朴素贝叶斯算法
kmmel的博客
03-16 504
课后修正：存在的问题有没有解释高斯，高斯实际上就是数据是服从高斯分布的，朴素贝叶斯和贝叶斯算法不同，朴素贝叶斯针对高维数据的计算做出简化，假设高维数据各个特征并不相关，那么计算后验概率的时候可以把乘法改成用加法。而后将新的数据带入贝叶斯公式利用不同类型发生情况的概率（先验概率）和观测值算出一系列概率，最后取其中最大的一个作为最终的概率。在一个房间中，穿红色衣服的人一定是病人，工作人员中有一半的人穿红色衣服一半穿白色衣服。直接对已经有的数据进行估计，估计它的分布，得到一系列的先验概率。
高斯朴素贝叶斯算法和朴素贝叶斯算法的区别
最新发布
06-04
高斯朴素贝叶斯算法是朴素贝叶斯算法的一种变形，它假设特征的概率分布符合高斯分布。在分类时，它会计算每个类别下每个特征的高斯分布参数（即均值和方差），并利用贝叶斯公式计算后验概率来进行分类。 而朴素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

给算法爸爸上香

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

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

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

打赏作者

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

抵扣说明：

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

余额充值