机器学习经典算法：高斯朴素贝叶斯（Gaussian Naive Bayes）原理、手动计算与Python/Java双代码实战

from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据
data = load_iris()
X, y = data.data, data.target

# 为简化，只取前两类（Setosa 和 Versicolor）
X = X[y != 2]
y = y[y != 2]

# 划分训练/测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 训练模型
clf = GaussianNB()
clf.fit(X_train, y_train)

# 预测新样本 [5.5, 3.2, ...]（后两个特征用均值填充）
import numpy as np
new_sample = np.array([[5.5, 3.2, X_train[:, 2].mean(), X_train[:, 3].mean()]])
pred = clf.predict(new_sample)
print("预测类别:", "Setosa" if pred[0] == 0 else "Versicolor")

import numpy as np

class GaussianNB:
    def fit(self, X, y):
        self.classes = np.unique(y)
        self.params = {}
        
        for c in self.classes:
            X_c = X[y == c]
            # 计算每个特征的均值和方差
            mean = np.mean(X_c, axis=0)
            var = np.var(X_c, axis=0) + 1e-9  # 防止除零
            self.params[c] = (mean, var)
        
        # 先验概率
        self.priors = {c: np.mean(y == c) for c in self.classes}
    
    def _gaussian_pdf(self, x, mean, var):
        # 计算高斯概率密度（对数形式）
        return -0.5 * np.sum(np.log(2 * np.pi * var)) - 0.5 * np.sum((x - mean) ** 2 / var)
    
    def predict(self, X):
        predictions = []
        for x in X:
            posteriors = {}
            for c in self.classes:
                mean, var = self.params[c]
                log_likelihood = self._gaussian_pdf(x, mean, var)
                log_prior = np.log(self.priors[c])
                posteriors[c] = log_likelihood + log_prior
            predictions.append(max(posteriors, key=posteriors.get))
        return np.array(predictions)

# 使用简化数据
X_train = np.array([[5.0, 3.6], [5.4, 3.4], [5.4, 3.0], [5.6, 3.0], [5.7, 2.9]])
y_train = np.array([0, 0, 1, 1, 1])

gnb = GaussianNB()
gnb.fit(X_train, y_train)
pred = gnb.predict(np.array())
print("预测结果:", "Setosa" if pred[0] == 0 else "Versicolor")  # 输出: Setosa

import java.util.*;

public class GaussianNaiveBayes {
    private Map<Integer, double[]> classMeans = new HashMap<>();
    private Map<Integer, double[]> classVars = new HashMap<>();
    private Map<Integer, Double> priors = new HashMap<>();
    private int numFeatures;

    public void fit(double[][] X, int[] y) {
        // 获取所有唯一类别
        Set<Integer> classes = new HashSet<>();
        for (int label : y) classes.add(label);
        numFeatures = X[0].length;

        // 为每个类别计算均值和方差
        for (int c : classes) {
            List<double[]> classData = new ArrayList<>();
            for (int i = 0; i < y.length; i++) {
                if (y[i] == c) {
                    classData.add(X[i]);
                }
            }

            // 计算均值
            double[] mean = new double[numFeatures];
            for (double[] row : classData) {
                for (int j = 0; j < numFeatures; j++) {
                    mean[j] += row[j];
                }
            }
            for (int j = 0; j < numFeatures; j++) {
                mean[j] /= classData.size();
            }
            classMeans.put(c, mean);

            // 计算方差
            double[] variance = new double[numFeatures];
            for (double[] row : classData) {
                for (int j = 0; j < numFeatures; j++) {
                    variance[j] += Math.pow(row[j] - mean[j], 2);
                }
            }
            for (int j = 0; j < numFeatures; j++) {
                variance[j] = variance[j] / classData.size() + 1e-9; // 防止除零
            }
            classVars.put(c, variance);

            // 先验概率
            priors.put(c, (double) classData.size() / y.length);
        }
    }

    private double gaussianLogPdf(double[] x, double[] mean, double[] var) {
        double logProb = 0.0;
        for (int i = 0; i < numFeatures; i++) {
            logProb -= 0.5 * Math.log(2 * Math.PI * var[i]);
            logProb -= 0.5 * Math.pow(x[i] - mean[i], 2) / var[i];
        }
        return logProb;
    }

    public int predict(double[] x) {
        Map<Integer, Double> posteriors = new HashMap<>();
        for (int c : priors.keySet()) {
            double logLikelihood = gaussianLogPdf(x, classMeans.get(c), classVars.get(c));
            double logPrior = Math.log(priors.get(c));
            posteriors.put(c, logLikelihood + logPrior);
        }

        // 返回后验概率最大的类别
        return Collections.max(posteriors.entrySet(), Map.Entry.comparingByValue()).getKey();
    }

    // 测试
    public static void main(String[] args) {
        double[][] X = {
            {5.0, 3.6},
            {5.4, 3.4},
            {5.4, 3.0},
            {5.6, 3.0},
            {5.7, 2.9}
        };
        int[] y = {0, 0, 1, 1, 1};

        GaussianNaiveBayes gnb = new GaussianNaiveBayes();
        gnb.fit(X, y);

        double[] testSample = {5.5, 3.2};
        int prediction = gnb.predict(testSample);
        System.out.println("预测结果: " + (prediction == 0 ? "Setosa" : "Versicolor"));
        // 输出: Setosa
    }
}