朴素贝叶斯分类算法，分别用C语言，C++,java,python编写出来

源码资源网

朴素贝叶斯分类算法是一种基于贝叶斯定理的简单概率分类算法。

贝叶斯分类的基础是概率推理，就是在各种条件的存在不确定，仅知其出现概率的情况下，如何完成推理和决策任务。概率推理是与确定性推理相对应的。而朴素贝叶斯分类器是基于独立假设的，即假设样本每个特征与其他特征都不相关。

朴素贝叶斯分类算法，分别用C语言，C++,java,python编写出来
当涉及朴素贝叶斯分类算法时，下面是使用C语言、C++、Java和Python编写的示例代码：
1.**C语言示例：**

1. #include <stdio.h>
   
2. #include <math.h>
   
3. #define NUM_CLASSES 2
   
4. #define NUM_FEATURES 4
   
5. struct DataPoint {
   
6.     double features[NUM_FEATURES];
   
7.     int label;
   
8. };
   
9. double calculateGaussian(double x, double mean, double variance) {
   
10.     double exponent = exp(-(pow(x - mean, 2) / (2 * variance)));
    
11.     return (1 / (sqrt(2 * M_PI * variance))) * exponent;
    
12. }
    
13. int predictClass(struct DataPoint testPoint, struct DataPoint trainingSet[], int numTrainingPoints) {
    
14.     double classProbabilities[NUM_CLASSES] = {0};
    
15.     for (int i = 0; i < numTrainingPoints; i++) {
    
16.         struct DataPoint trainingPoint = trainingSet[i];
    
17.         int label = trainingPoint.label;
    
18.         classProbabilities[label]++;
    
19.     }
    
20.     for (int i = 0; i < NUM_CLASSES; i++) {
    
21.         classProbabilities[i] /= numTrainingPoints;
    
22.     }
    
23.     double featureProbabilities[NUM_CLASSES][NUM_FEATURES][2] = {0};
    
24.     for (int i = 0; i < numTrainingPoints; i++) {
    
25.         struct DataPoint trainingPoint = trainingSet[i];
    
26.         int label = trainingPoint.label;
    
27.         for (int j = 0; j < NUM_FEATURES; j++) {
    
28.             double feature = trainingPoint.features[j];
    
29.             featureProbabilities[label][j][0] += feature;
    
30.             featureProbabilities[label][j][1] += pow(feature, 2);
    
31.         }
    
32.     }
    
33.     for (int i = 0; i < NUM_CLASSES; i++) {
    
34.         for (int j = 0; j < NUM_FEATURES; j++) {
    
35.             double mean = featureProbabilities[i][j][0] / classProbabilities[i];
    
36.             double variance = (featureProbabilities[i][j][1] / classProbabilities[i]) - pow(mean, 2);
    
37.             featureProbabilities[i][j][0] = mean;
    
38.             featureProbabilities[i][j][1] = variance;
    
39.         }
    
40.     }
    
41.     double maxProbability = 0;
    
42.     int predictedClass = -1;
    
43.     for (int i = 0; i < NUM_CLASSES; i++) {
    
44.         double probability = classProbabilities[i];
    
45.         for (int j = 0; j < NUM_FEATURES; j++) {
    
46.             double feature = testPoint.features[j];
    
47.             double mean = featureProbabilities[i][j][0];
    
48.             double variance = featureProbabilities[i][j][1];
    
49.             double likelihood = calculateGaussian(feature, mean, variance);
    
50.             probability *= likelihood;
    
51.         }
    
52.         if (probability > maxProbability) {
    
53.             maxProbability = probability;
    
54.             predictedClass = i;
    
55.         }
    
56.     }
    
57.     return predictedClass;
    
58. }
    
59. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

2.**C++示例：**

1. #include <iostream>
   
2. #include <cmath>
   
3. #include <vector>
   
4. #define NUM_CLASSES 2
   
5. #define NUM_FEATURES 4
   
6. struct DataPoint {
   
7.     std::vector<double> features;
   
8.     int label;
   
9. };
   
10. double calculateGaussian(double x, double mean, double variance) {
    
11.     double exponent = exp(-(pow(x - mean, 2) / (2 * variance)));
    
12.     return (1 / (sqrt(2 * M_PI * variance))) * exponent;
    
13. }
    
14. int predictClass(DataPoint testPoint, std::vector<DataPoint> trainingSet) {
    
15.     std::vector<double> classProbabilities(NUM_CLASSES, 0);
    
16.     for (int i = 0; i < trainingSet.size(); i++) {
    
17.         DataPoint trainingPoint = trainingSet[i];
    
18.         int label = trainingPoint.label;
    
19.         classProbabilities[label]++;
    
20.     }
    
21.     for (int i = 0; i < NUM_CLASSES; i++) {
    
22.         classProbabilities[i] /= trainingSet.size();
    
23.     }
    
24.     std::vector<std::vector<std::vector<double>>> featureProbabilities(NUM_CLASSES, std::vector<std::vector<double>>(NUM_FEATURES, std::vector<double>(2, 0)));
    
25.     for (int i = 0; i < trainingSet.size(); i++) {
    
26.         DataPoint trainingPoint = trainingSet[i];
    
27.         int label = trainingPoint.label;
    
28.         for (int j = 0; j < NUM_FEATURES; j++) {
    
29.             double feature = trainingPoint.features[j];
    
30.             featureProbabilities[label][j][0] += feature;
    
31.             featureProbabilities[label][j][1] += pow(feature, 2);
    
32.         }
    
33.     }
    
34.     for (int i = 0; i < NUM_CLASSES; i++) {
    
35.         for (int j = 0; j < NUM_FEATURES; j++) {
    
36.             double mean = featureProbabilities[i][j][0] / classProbabilities[i];
    
37.             double variance = (featureProbabilities[i][j][1] / classProbabilities[i]) - pow(mean, 2);
    
38.             featureProbabilities[i][j][0] = mean;
    
39.             featureProbabilities[i][j][1] = variance;
    
40.         }
    
41.     }
    
42.     double maxProbability = 0;
    
43.     int predictedClass = -1;
    
44.     for (int i = 0; i < NUM_CLASSES; i++) {
    
45.         double probability = classProbabilities[i];
    
46.         for (int j = 0; j < NUM_FEATURES; j++) {
    
47.             double feature = testPoint.features[j];
    
48.             double mean = featureProbabilities[i][j][0];
    
49.             double variance = featureProbabilities[i][j][1];
    
50.             double likelihood = calculateGaussian(feature, mean, variance);
    
51.             probability *= likelihood;
    
52.         }
    
53.         if (probability > maxProbability) {
    
54.             maxProbability = probability;
    
55.             predictedClass = i;
    
56.         }
    
57.     }
    
58.     return predictedClass;
    
59. }
    
60. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

3.**JAVA示例：**

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. public class NaiveBayesClassifier {
   
4.     private static final int NUM_CLASSES = 2;
   
5.     private static final int NUM_FEATURES = 4;
   
6.      private static class DataPoint {
   
7.         private double[] features;
   
8.         private int label;
   
9.          public DataPoint(double[] features, int label) {
   
10.             this.features = features;
    
11.             this.label = label;
    
12.         }
    
13.          public double[] getFeatures() {
    
14.             return features;
    
15.         }
    
16.          public int getLabel() {
    
17.             return label;
    
18.         }
    
19.     }
    
20.      private static double calculateGaussian(double x, double mean, double variance) {
    
21.         double exponent = Math.exp(-(Math.pow(x - mean, 2) / (2 * variance)));
    
22.         return (1 / (Math.sqrt(2 * Math.PI * variance))) * exponent;
    
23.     }
    
24.      private static int predictClass(DataPoint testPoint, List<DataPoint> trainingSet) {
    
25.         double[] classProbabilities = new double[NUM_CLASSES];
    
26.         for (DataPoint trainingPoint : trainingSet) {
    
27.             int label = trainingPoint.getLabel();
    
28.             classProbabilities[label]++;
    
29.         }
    
30.         for (int i = 0; i < NUM_CLASSES; i++) {
    
31.             classProbabilities[i] /= trainingSet.size();
    
32.         }
    
33.          double[][][] featureProbabilities = new double[NUM_CLASSES][NUM_FEATURES][2];
    
34.         for (DataPoint trainingPoint : trainingSet) {
    
35.             int label = trainingPoint.getLabel();
    
36.             for (int j = 0; j < NUM_FEATURES; j++) {
    
37.                 double feature = trainingPoint.getFeatures()[j];
    
38.                 featureProbabilities[label][j][0] += feature;
    
39.                 featureProbabilities[label][j][1] += Math.pow(feature, 2);
    
40.             }
    
41.         }
    
42.         for (int i = 0; i < NUM_CLASSES; i++) {
    
43.             for (int j = 0; j < NUM_FEATURES; j++) {
    
44.                 double mean = featureProbabilities[i][j][0] / classProbabilities[i];
    
45.                 double variance = (featureProbabilities[i][j][1] / classProbabilities[i]) - Math.pow(mean, 2);
    
46.                 featureProbabilities[i][j][0] = mean;
    
47.                 featureProbabilities[i][j][1] = variance;
    
48.             }
    
49.         }
    
50.          double maxProbability = 0;
    
51.         int predictedClass = -1;
    
52.         for (int i = 0; i < NUM_CLASSES; i++) {
    
53.             double probability = classProbabilities[i];
    
54.             for (int j = 0; j < NUM_FEATURES; j++) {
    
55.                 double feature = testPoint.getFeatures()[j];
    
56.                 double mean = featureProbabilities[i][j][0];
    
57.                 double variance = featureProbabilities[i][j][1];
    
58.                 double likelihood = calculateGaussian(feature, mean, variance);
    
59.                 probability *= likelihood;
    
60.             }
    
61.             if (probability > maxProbability) {
    
62.                 maxProbability = probability;
    
63.                 predictedClass = i;
    
64.             }
    
65.         }
    
66.          return predictedClass;
    
67.     }
    
68.    
    
69. }

复制代码

  

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

4.**Python示例：**

1. import numpy as np
   
2. class NaiveBayesClassifier:
   
3.     def __init__(self):
   
4.         self.classes = None
   
5.         self.class_priors = None
   
6.         self.feature_probs = None
   
7.      def fit(self, X, y):
   
8.         self.classes = np.unique(y)
   
9.         self.class_priors = np.zeros(len(self.classes))
   
10.         self.feature_probs = []
    
11.          for i, c in enumerate(self.classes):
    
12.             X_c = X[y == c]
    
13.             self.class_priors[i] = len(X_c) / len(X)
    
14.              feature_probs_c = []
    
15.             for j in range(X.shape[1]):
    
16.                 feature_values = np.unique(X[:, j])
    
17.                 feature_probs_j = []
    
18.                 for v in feature_values:
    
19.                     count = len(X_c[X_c[:, j] == v])
    
20.                     prob = (count + 1) / (len(X_c) + len(feature_values))
    
21.                     feature_probs_j.append(prob)
    
22.                 feature_probs_c.append(feature_probs_j)
    
23.             self.feature_probs.append(feature_probs_c)
    
24.      def predict(self, X):
    
25.         y_pred = []
    
26.         for x in X:
    
27.             class_probs = []
    
28.             for i, c in enumerate(self.classes):
    
29.                 class_prob = np.log(self.class_priors[i])
    
30.                 for j, feature_value in enumerate(x):
    
31.                     prob = self.feature_probs[i][j][feature_value]
    
32.                     class_prob += np.log(prob)
    
33.                 class_probs.append(class_prob)
    
34.             y_pred.append(self.classes[np.argmax(class_probs)])
    
35.         return np.array(y_pred)
    
36. # 示例用法
    
37. 
    

复制代码

游客，本帖隐藏的内容需要积分高于 9 才可浏览，您当前积分为 0

这个示例代码实现了一个简单的朴素贝叶斯分类器。首先， fit 方法用于训练模型，接受特征矩阵 X 和目标向量 y 作为输入。然后， predict 方法用于预测新数据点的类别，接受特征矩阵 X 作为输入，并返回预测的类别向量 y_pred 。
请注意，这只是一个基本的示例，用于理解朴素贝叶斯分类算法的基本原理。在实际应用中，可能需要根据具体的需求和数据进行适当的调整和改进。



扫码关注微信公众号，免费查看完整算法内容。