机器学习算法是人工智能领域的核心技术基础掌握这些算法对于从事数据分析、AI开发或相关技术工作至关重要。本文将通过系统化的方式带你全面了解回归算法、聚类算法、决策树、随机森林、神经网络、贝叶斯算法、支持向量机等十大核心机器学习算法。这些算法构成了现代机器学习的基础框架从传统的统计学习方法到深度学习技术每种算法都有其独特的应用场景和优势。无论是想要入门机器学习的新手还是希望系统梳理知识体系的从业者这篇文章都将提供实用的技术指导和实践案例。1. 机器学习算法核心能力速览算法类别主要算法适用场景学习类型技术特点回归算法线性回归、逻辑回归数值预测、分类问题监督学习简单易用解释性强聚类算法K-means、层次聚类数据分组、模式发现无监督学习无需标签自动分组决策树ID3、C4.5、CART分类和回归任务监督学习可视化强易于理解随机森林多决策树集成复杂分类和回归监督学习抗过拟合精度高神经网络BP神经网络、CNN、RNN图像、语音、文本处理监督/无监督拟合能力强适用复杂问题贝叶斯算法朴素贝叶斯文本分类、垃圾邮件过滤监督学习计算效率高适合高维数据支持向量机SVM小样本分类、非线性问题监督学习泛化能力强边界清晰2. 机器学习算法适用场景分析2.1 监督学习算法应用边界监督学习算法需要带标签的训练数据适用于有明确预测目标的场景。回归算法适合预测连续数值如房价预测、销量预测等。分类算法如决策树、SVM等适用于客户分群、图像分类等任务。在实际应用中需要考虑数据标签的获取成本和质量。监督学习算法的性能高度依赖于标注数据的准确性和代表性在标签稀缺或标注成本高的场景下需要谨慎选择。2.2 无监督学习算法的独特价值聚类算法作为典型的无监督学习方法在客户细分、异常检测、模式发现等方面具有重要价值。其优势在于不需要预先标注的数据能够从数据本身发现内在结构。然而无监督学习的结果解释性相对较差需要结合业务知识进行结果验证。在选择聚类算法时需要考虑数据分布特征和业务目标的一致性。3. 环境准备与工具配置3.1 Python机器学习环境搭建机器学习算法的实践需要合适的开发环境。推荐使用Python作为主要编程语言配合以下工具库# 创建虚拟环境 python -m venv ml_env source ml_env/bin/activate # Linux/Mac # 或 ml_env\Scripts\activate # Windows # 安装核心库 pip install numpy pandas matplotlib seaborn pip install scikit-learn tensorflow torch pip install jupyter notebook3.2 数据集准备与预处理机器学习算法实践需要合适的数据集。常用的公开数据集包括分类问题鸢尾花数据集、手写数字MNIST、泰坦尼克号数据集回归问题波士顿房价数据集、糖尿病数据集聚类问题鸢尾花数据集、葡萄酒数据集数据预处理是机器学习的重要环节包括数据清洗、特征缩放、缺失值处理等import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split # 数据加载和预处理示例 def prepare_data(data_path): data pd.read_csv(data_path) # 处理缺失值 data data.dropna() # 特征和标签分离 X data.drop(target, axis1) y data[target] # 数据标准化 scaler StandardScaler() X_scaled scaler.fit_transform(X) # 划分训练测试集 X_train, X_test, y_train, y_test train_test_split( X_scaled, y, test_size0.2, random_state42) return X_train, X_test, y_train, y_test4. 回归算法详解与实践4.1 线性回归原理与实现线性回归是机器学习中最基础的算法之一用于建立输入特征与连续目标值之间的线性关系。import numpy as np from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, r2_score class LinearRegressionDemo: def __init__(self): self.model LinearRegression() def train(self, X_train, y_train): 训练线性回归模型 self.model.fit(X_train, y_train) print(模型训练完成) print(f系数: {self.model.coef_}) print(f截距: {self.model.intercept_}) def predict(self, X_test): 使用模型进行预测 return self.model.predict(X_test) def evaluate(self, X_test, y_test): 评估模型性能 y_pred self.predict(X_test) mse mean_squared_error(y_test, y_pred) r2 r2_score(y_test, y_pred) print(f均方误差(MSE): {mse:.4f}) print(fR²分数: {r2:.4f}) return mse, r2 # 使用示例 def linear_regression_example(): # 生成示例数据 from sklearn.datasets import make_regression X, y make_regression(n_samples100, n_features1, noise10, random_state42) # 划分训练测试集 X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.2, random_state42) # 创建和训练模型 lr_demo LinearRegressionDemo() lr_demo.train(X_train, y_train) lr_demo.evaluate(X_test, y_test)4.2 逻辑回归的分类应用虽然名为回归但逻辑回归实际上是一种分类算法特别适用于二分类问题from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score, classification_report, confusion_matrix class LogisticRegressionDemo: def __init__(self): self.model LogisticRegression() def train(self, X_train, y_train): 训练逻辑回归模型 self.model.fit(X_train, y_train) print(逻辑回归模型训练完成) def predict(self, X_test): 预测类别 return self.model.predict(X_test) def predict_proba(self, X_test): 预测概率 return self.model.predict_proba(X_test) def evaluate(self, X_test, y_test): 全面评估模型 y_pred self.predict(X_test) accuracy accuracy_score(y_test, y_pred) report classification_report(y_test, y_pred) cm confusion_matrix(y_test, y_pred) print(f准确率: {accuracy:.4f}) print(分类报告:) print(report) print(混淆矩阵:) print(cm) return accuracy, report, cm5. 聚类算法深度解析5.1 K-means聚类算法实践K-means是最常用的聚类算法适用于发现数据中的自然分组from sklearn.cluster import KMeans from sklearn.preprocessing import StandardScaler import matplotlib.pyplot as plt class KMeansClustering: def __init__(self, n_clusters3, random_state42): self.n_clusters n_clusters self.model KMeans(n_clustersn_clusters, random_staterandom_state) self.scaler StandardScaler() def preprocess_data(self, X): 数据预处理 return self.scaler.fit_transform(X) def fit_predict(self, X): 训练模型并进行聚类 X_scaled self.preprocess_data(X) labels self.model.fit_predict(X_scaled) return labels def find_optimal_clusters(self, X, max_k10): 使用肘部法则寻找最优聚类数 X_scaled self.preprocess_data(X) inertias [] for k in range(1, max_k 1): kmeans KMeans(n_clustersk, random_state42) kmeans.fit(X_scaled) inertias.append(kmeans.inertia_) # 绘制肘部曲线 plt.figure(figsize(10, 6)) plt.plot(range(1, max_k 1), inertias, markero) plt.xlabel(聚类数量) plt.ylabel(簇内平方和) plt.title(肘部法则 - 最优聚类数选择) plt.show() return inertias # 聚类结果可视化 def visualize_clusters(X, labels, true_labelsNone): 可视化聚类结果 plt.figure(figsize(12, 5)) plt.subplot(1, 2, 1) plt.scatter(X[:, 0], X[:, 1], clabels, cmapviridis) plt.title(聚类结果) plt.xlabel(特征1) plt.ylabel(特征2) if true_labels is not None: plt.subplot(1, 2, 2) plt.scatter(X[:, 0], X[:, 1], ctrue_labels, cmapviridis) plt.title(真实标签) plt.xlabel(特征1) plt.ylabel(特征2) plt.tight_layout() plt.show()5.2 层次聚类算法应用层次聚类提供了一种树状的聚类结构适合分析数据的不同粒度层次from sklearn.cluster import AgglomerativeClustering from scipy.cluster.hierarchy import dendrogram, linkage import numpy as np class HierarchicalClustering: def __init__(self, n_clustersNone, linkageward): self.n_clusters n_clusters self.linkage linkage self.model AgglomerativeClustering( n_clustersn_clusters, linkagelinkage) def fit_predict(self, X): 执行层次聚类 return self.model.fit_predict(X) def plot_dendrogram(self, X, methodward): 绘制树状图 # 计算链接矩阵 linked linkage(X, methodmethod) plt.figure(figsize(10, 7)) dendrogram(linked, orientationtop, distance_sortdescending, show_leaf_countsTrue) plt.title(层次聚类树状图) plt.xlabel(样本索引) plt.ylabel(距离) plt.show() # 层次聚类示例 def hierarchical_clustering_demo(): from sklearn.datasets import make_blobs # 生成示例数据 X, y_true make_blobs(n_samples300, centers4, cluster_std0.60, random_state42) # 层次聚类 hc HierarchicalClustering(n_clusters4) labels hc.fit_predict(X) # 可视化 visualize_clusters(X, labels, y_true) # 绘制树状图 hc.plot_dendrogram(X)6. 决策树与随机森林实战6.1 决策树算法实现决策树通过树状结构进行决策具有很好的可解释性from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor, plot_tree from sklearn.model_selection import GridSearchCV class DecisionTreeDemo: def __init__(self, problem_typeclassification, **kwargs): self.problem_type problem_type if problem_type classification: self.model DecisionTreeClassifier(**kwargs) else: self.model DecisionTreeRegressor(**kwargs) def train(self, X_train, y_train): 训练决策树模型 self.model.fit(X_train, y_train) print(决策树模型训练完成) def predict(self, X_test): 进行预测 return self.model.predict(X_test) def plot_decision_tree(self, feature_namesNone, class_namesNone): 可视化决策树 plt.figure(figsize(20, 10)) plot_tree(self.model, feature_namesfeature_names, class_namesclass_names, filledTrue, roundedTrue, fontsize10) plt.title(决策树可视化) plt.show() def get_feature_importance(self, feature_namesNone): 获取特征重要性 importances self.model.feature_importances_ if feature_names is not None: feature_imp pd.DataFrame({ feature: feature_names, importance: importances }).sort_values(importance, ascendingFalse) return feature_imp return importances # 决策树参数调优 def decision_tree_tuning(X_train, y_train, problem_typeclassification): 决策树超参数调优 if problem_type classification: param_grid { max_depth: [3, 5, 7, 10, None], min_samples_split: [2, 5, 10], min_samples_leaf: [1, 2, 4], criterion: [gini, entropy] } model DecisionTreeClassifier() else: param_grid { max_depth: [3, 5, 7, 10, None], min_samples_split: [2, 5, 10], min_samples_leaf: [1, 2, 4], criterion: [squared_error, friedman_mse] } model DecisionTreeRegressor() grid_search GridSearchCV(model, param_grid, cv5, scoringaccuracy) grid_search.fit(X_train, y_train) print(最优参数:, grid_search.best_params_) print(最优分数:, grid_search.best_score_) return grid_search.best_estimator_6.2 随机森林算法深度应用随机森林通过集成多个决策树来提高模型性能和稳定性from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor from sklearn.metrics import accuracy_score, mean_squared_error class RandomForestDemo: def __init__(self, problem_typeclassification, **kwargs): self.problem_type problem_type if problem_type classification: self.model RandomForestClassifier(**kwargs) else: self.model RandomForestRegressor(**kwargs) def train(self, X_train, y_train): 训练随机森林模型 self.model.fit(X_train, y_train) print(随机森林模型训练完成) def predict(self, X_test): 进行预测 return self.model.predict(X_test) def evaluate(self, X_test, y_test): 评估模型性能 y_pred self.predict(X_test) if self.problem_type classification: accuracy accuracy_score(y_test, y_pred) print(f准确率: {accuracy:.4f}) return accuracy else: mse mean_squared_error(y_test, y_pred) print(f均方误差: {mse:.4f}) return mse def get_feature_importance(self, feature_namesNone): 获取特征重要性排序 importances self.model.feature_importances_ if feature_names is not None: importance_df pd.DataFrame({ feature: feature_names, importance: importances }).sort_values(importance, ascendingFalse) # 可视化特征重要性 plt.figure(figsize(10, 6)) plt.barh(importance_df[feature][:10], importance_df[importance][:10]) plt.xlabel(特征重要性) plt.title(随机森林特征重要性TOP10) plt.gca().invert_yaxis() plt.show() return importance_df return importances # 随机森林参数优化 def random_forest_tuning(X_train, y_train, problem_typeclassification): 随机森林超参数优化 if problem_type classification: param_grid { n_estimators: [50, 100, 200], max_depth: [10, 20, None], min_samples_split: [2, 5], min_samples_leaf: [1, 2], bootstrap: [True, False] } model RandomForestClassifier(random_state42) else: param_grid { n_estimators: [50, 100, 200], max_depth: [10, 20, None], min_samples_split: [2, 5], min_samples_leaf: [1, 2] } model RandomForestRegressor(random_state42) grid_search GridSearchCV(model, param_grid, cv5, scoringaccuracy) grid_search.fit(X_train, y_train) print(最优参数:, grid_search.best_params_) print(最优分数:, grid_search.best_score_) return grid_search.best_estimator_7. 神经网络算法实战指南7.1 BP神经网络实现BP神经网络是最基础的前馈神经网络适用于各种分类和回归任务import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset import numpy as np class BPNeuralNetwork(nn.Module): def __init__(self, input_size, hidden_sizes, output_size, dropout_rate0.2): super(BPNeuralNetwork, self).__init__() layers [] # 输入层到第一个隐藏层 layers.append(nn.Linear(input_size, hidden_sizes[0])) layers.append(nn.ReLU()) layers.append(nn.Dropout(dropout_rate)) # 添加更多隐藏层 for i in range(len(hidden_sizes) - 1): layers.append(nn.Linear(hidden_sizes[i], hidden_sizes[i1])) layers.append(nn.ReLU()) layers.append(nn.Dropout(dropout_rate)) # 输出层 layers.append(nn.Linear(hidden_sizes[-1], output_size)) self.network nn.Sequential(*layers) def forward(self, x): return self.network(x) class NeuralNetworkTrainer: def __init__(self, model, learning_rate0.001): self.model model self.criterion nn.CrossEntropyLoss() # 分类任务 self.optimizer optim.Adam(model.parameters(), lrlearning_rate) self.device torch.device(cuda if torch.cuda.is_available() else cpu) self.model.to(self.device) def train(self, train_loader, epochs100): 训练神经网络 self.model.train() train_losses [] for epoch in range(epochs): epoch_loss 0.0 for batch_idx, (data, target) in enumerate(train_loader): data, target data.to(self.device), target.to(self.device) self.optimizer.zero_grad() output self.model(data) loss self.criterion(output, target) loss.backward() self.optimizer.step() epoch_loss loss.item() avg_loss epoch_loss / len(train_loader) train_losses.append(avg_loss) if epoch % 10 0: print(fEpoch {epoch}, Loss: {avg_loss:.4f}) return train_losses def evaluate(self, test_loader): 评估模型性能 self.model.eval() correct 0 total 0 with torch.no_grad(): for data, target in test_loader: data, target data.to(self.device), target.to(self.device) outputs self.model(data) _, predicted torch.max(outputs.data, 1) total target.size(0) correct (predicted target).sum().item() accuracy 100 * correct / total print(f测试准确率: {accuracy:.2f}%) return accuracy # 神经网络训练示例 def neural_network_example(): # 生成示例数据 from sklearn.datasets import make_classification from sklearn.preprocessing import StandardScaler X, y make_classification(n_samples1000, n_features20, n_classes3, random_state42) # 数据预处理 scaler StandardScaler() X_scaled scaler.fit_transform(X) # 转换为PyTorch张量 X_tensor torch.FloatTensor(X_scaled) y_tensor torch.LongTensor(y) # 创建数据集和数据加载器 dataset TensorDataset(X_tensor, y_tensor) train_loader DataLoader(dataset, batch_size32, shuffleTrue) # 创建模型 input_size X.shape[1] hidden_sizes [64, 32] output_size 3 model BPNeuralNetwork(input_size, hidden_sizes, output_size) trainer NeuralNetworkTrainer(model) # 训练模型 losses trainer.train(train_loader, epochs50) # 绘制损失曲线 plt.plot(losses) plt.title(训练损失曲线) plt.xlabel(Epoch) plt.ylabel(Loss) plt.show()7.2 卷积神经网络(CNN)实战CNN在图像处理领域表现出色以下是基本的CNN实现class SimpleCNN(nn.Module): def __init__(self, num_classes10): super(SimpleCNN, self).__init__() self.conv1 nn.Conv2d(1, 32, kernel_size3, padding1) self.conv2 nn.Conv2d(32, 64, kernel_size3, padding1) self.pool nn.MaxPool2d(2, 2) self.dropout1 nn.Dropout(0.25) self.dropout2 nn.Dropout(0.5) self.fc1 nn.Linear(64 * 7 * 7, 128) self.fc2 nn.Linear(128, num_classes) def forward(self, x): x self.pool(torch.relu(self.conv1(x))) x self.pool(torch.relu(self.conv2(x))) x self.dropout1(x) x x.view(-1, 64 * 7 * 7) x torch.relu(self.fc1(x)) x self.dropout2(x) x self.fc2(x) return x # CNN训练函数 def train_cnn_model(): 训练CNN模型示例 # 加载MNIST数据集 transform transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset datasets.MNIST(./data, trainTrue, downloadTrue, transformtransform) test_dataset datasets.MNIST(./data, trainFalse, transformtransform) train_loader DataLoader(train_dataset, batch_size64, shuffleTrue) test_loader DataLoader(test_dataset, batch_size1000, shuffleFalse) # 创建模型 model SimpleCNN(num_classes10) device torch.device(cuda if torch.cuda.is_available() else cpu) model.to(device) # 定义损失函数和优化器 criterion nn.CrossEntropyLoss() optimizer optim.Adam(model.parameters(), lr0.001) # 训练循环 for epoch in range(10): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target data.to(device), target.to(device) optimizer.zero_grad() output model(data) loss criterion(output, target) loss.backward() optimizer.step() # 每个epoch后评估 model.eval() correct 0 with torch.no_grad(): for data, target in test_loader: data, target data.to(device), target.to(device) output model(data) pred output.argmax(dim1, keepdimTrue) correct pred.eq(target.view_as(pred)).sum().item() accuracy 100. * correct / len(test_loader.dataset) print(fEpoch {epoch}: 准确率 {accuracy:.2f}%)8. 贝叶斯算法与支持向量机8.1 朴素贝叶斯分类器朴素贝叶斯基于贝叶斯定理特别适合文本分类和高维数据from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB from sklearn.feature_extraction.text import CountVectorizer from sklearn.metrics import accuracy_score, classification_report class NaiveBayesDemo: def __init__(self, model_typegaussian): self.model_type model_type if model_type gaussian: self.model GaussianNB() elif model_type multinomial: self.model MultinomialNB() else: self.model BernoulliNB() def train(self, X_train, y_train): 训练朴素贝叶斯模型 self.model.fit(X_train, y_train) print(f{self.model_type}朴素贝叶斯模型训练完成) def predict(self, X_test): 进行预测 return self.model.predict(X_test) def predict_proba(self, X_test): 预测概率 return self.model.predict_proba(X_test) def evaluate(self, X_test, y_test): 评估模型性能 y_pred self.predict(X_test) accuracy accuracy_score(y_test, y_pred) report classification_report(y_test, y_pred) print(f准确率: {accuracy:.4f}) print(分类报告:) print(report) return accuracy, report # 文本分类示例 def text_classification_example(): 朴素贝叶斯文本分类示例 from sklearn.datasets import fetch_20newsgroups # 加载新闻数据集 categories [sci.space, comp.graphics, rec.sport.baseball] newsgroups_train fetch_20newsgroups(subsettrain, categoriescategories) newsgroups_test fetch_20newsgroups(subsettest, categoriescategories) # 文本特征提取 vectorizer CountVectorizer(stop_wordsenglish, max_features1000) X_train vectorizer.fit_transform(newsgroups_train.data) X_test vectorizer.transform(newsgroups_test.data) y_train newsgroups_train.target y_test newsgroups_test.target # 训练朴素贝叶斯模型 nb NaiveBayesDemo(model_typemultinomial) nb.train(X_train, y_train) accuracy, report nb.evaluate(X_test, y_test) return accuracy, vectorizer.get_feature_names_out() # 不同朴素贝叶斯变体比较 def compare_naive_bayes_models(X_train, X_test, y_train, y_test): 比较不同朴素贝叶斯变体的性能 models { GaussianNB: GaussianNB(), MultinomialNB: MultinomialNB(), BernoulliNB: BernoulliNB() } results {} for name, model in models.items(): model.fit(X_train, y_train) y_pred model.predict(X_test) accuracy accuracy_score(y_test, y_pred) results[name] accuracy print(f{name} 准确率: {accuracy:.4f}) # 可视化比较结果 plt.figure(figsize(10, 6)) plt.bar(results.keys(), results.values()) plt.title(不同朴素贝叶斯变体性能比较) plt.ylabel(准确率) plt.ylim(0, 1) plt.show() return results8.2 支持向量机(SVM)实战SVM在小样本、非线性问题上表现优异以下是完整的SVM实现from sklearn.svm import SVC, SVR from sklearn.preprocessing import StandardScaler from sklearn.metrics import accuracy_score, classification_report import numpy as np class SupportVectorMachine: def __init__(self, problem_typeclassification, **kwargs): self.problem_type problem_type self.scaler StandardScaler() if problem_type classification: self.model SVC(**kwargs) else: self.model SVR(**kwargs) def preprocess_data(self, X_train, X_test): 数据标准化处理 X_train_scaled self.scaler.fit_transform(X_train) X_test_scaled self.scaler.transform(X_test) return X_train_scaled, X_test_scaled def train(self, X_train, y_train): 训练SVM模型 self.model.fit(X_train, y_train) print(SVM模型训练完成) def predict(self, X_test): 进行预测 return self.model.predict(X_test) def evaluate(self, X_test, y_test): 评估模型性能 y_pred self.predict(X_test) if self.problem_type classification: accuracy accuracy_score(y_test, y_pred) report classification_report(y_test, y_pred) print(f准确率: {accuracy:.4f}) print(分类报告:) print(report) return accuracy, report else: mse mean_squared_error(y_test, y_pred) print(f均方误差: {mse:.4f}) return mse # SVM参数优化 def svm_parameter_tuning(X_train, y_train, problem_typeclassification): SVM超参数优化 from sklearn.model_selection import GridSearchCV # 数据标准化 scaler StandardScaler() X_train_scaled scaler.fit_transform(X_train) if problem_type classification: param_grid { C: [0.1, 1, 10, 100], gamma: [1, 0.1, 0.01, 0.001], kernel: [rbf, linear, poly] } model SVC() scoring accuracy else: param_grid { C: [0.1, 1, 10, 100], gamma: [1, 0.1, 0.01, 0.001], kernel: [rbf, linear] } model SVR() scoring neg_mean_squared_error grid_search GridSearchCV(model, param_grid, cv5, scoringscoring, n_jobs-1) grid_search.fit(X_train_scaled, y_train) print(最优参数:, grid_search.best_params_) print(最优分数:, grid_search.best_score_) return grid_search.best_estimator_ # SVM决策边界可视化 def plot_svm_decision_boundary(model, X, y, titleSVM决策边界): 可视化SVM的决策边界适用于二维数据 if X.shape[1] ! 2: print(只能可视化二维特征数据) return # 创建网格点 x_min, x_max X[:, 0].min() - 1, X[:, 0].max() 1 y_min, y_max X[:, 1].min() - 1, X[:, 1].max() 1 xx, yy np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02)) # 预测网格点 Z model.predict(np.c_[xx.ravel(), yy.ravel()]) Z Z.reshape(xx.shape) # 绘制决策边界 plt.contourf(xx, yy, Z, alpha0.8) scatter plt.scatter(X[:, 0], X[:, 1], cy, edgecolorsk, markero) plt.xlabel(特征1) plt.ylabel(特征2) plt.title(title) plt.colorbar(scatter) plt.show() # 不同核函数比较 def compare_svm_kernels(X_train, X_test, y_train, y_test): 比较SVM不同核函数的性能 kernels [linear, rbf, poly, sigmoid] results {} scaler StandardScaler() X_train_scaled scaler.fit_transform(X_train) X_test_scaled scaler.transform(X_test) for kernel in kernels: if kernel poly: model SVC(kernelkernel, degree3) else: model SVC(kernelkernel) model.fit(X_train_scaled, y_train) y_pred model.predict(X_test_scaled) accuracy accuracy_score(y_test, y_pred) results[kernel] accuracy print(f核函数 {kernel} 准确率: {accuracy:.4f}) # 可视化比较结果 plt.figure(figsize(10, 6)) plt.bar(results.keys(), results.values()) plt.title(SVM不同核函数性能比较) plt.ylabel(准确率) plt.ylim(0, 1) plt.show() return results9. 模型评估与性能优化9.1 交叉验证与模型选择交叉验证是评估模型泛化能力的重要技术from sklearn.model_selection import cross_val_score, StratifiedKFold from sklearn.metrics import confusion_matrix, classification_report import seaborn as sns class ModelEvaluator: def __init__(self, modelsNone): self.models models or {} self.results {} def add_model(self, name, model): 添加模型到评估器 self.models[name] model def cross_validate(self, X, y, cv5, scoringaccuracy): 执行交叉验证 for name, model in self.models.items(): scores cross_val_score(model, X, y, cvcv, scoringscoring) self.results[name] { mean_score: scores.mean(), std_score: scores.std(), scores: scores } print(f{name}: 平均{scoring} {scores.mean():.4f} (±{scores.std():.4f})) def plot_comparison(self): 可视化模型比较结果 names list(self.results.keys()) means [self.results[name][mean_score] for name in names] stds [self.results[name][std_score] for name in names] plt.figure(figsize(12, 6)) bars plt.bar(names, means, yerrstds, capsize5, alpha0.7) plt.ylabel(准确率) plt.title(模型性能比较) #