机器学习实战教程：从零开始掌握Python数据科学与算法应用

最近在整理机器学习项目时，发现很多初学者在从理论过渡到实战时经常遇到各种问题：环境配置复杂、代码调试困难、算法理解不透彻等。本文基于实际项目经验，整合了一套完整的机器学习实战教程，涵盖从基础概念到项目落地的全流程，包含可运行的代码示例和常见问题解决方案，适合零基础入门和有一定经验的开发者参考使用。

1. 机器学习基础概念与环境准备

1.1 什么是机器学习

机器学习是人工智能的一个分支，它通过算法让计算机从数据中学习规律，并利用这些规律对新的数据进行预测或决策。简单来说，机器学习就是让计算机"学会"如何完成任务，而不是通过明确的编程指令。

机器学习的三大类型：

• 监督学习：从带有标签的训练数据中学习，用于分类和回归问题
• 无监督学习：从无标签的数据中发现内在结构，用于聚类和降维
• 强化学习：通过与环境交互学习最优策略，用于决策问题

1.2 环境配置与工具选择

对于机器学习入门，推荐使用Python语言，因为它有丰富的机器学习库和活跃的社区支持。以下是环境配置步骤：

操作系统要求：

• Windows 10/11、macOS 10.14+ 或 Ubuntu 16.04+
• 至少8GB内存，推荐16GB
• 至少20GB可用磁盘空间

Python环境安装：

# 下载Python 3.8+版本 # 验证安装是否成功 python --version pip --version

推荐使用Anaconda管理环境：

# 创建独立的机器学习环境 conda create -n ml-env python=3.9 conda activate ml-env # 安装核心机器学习库 pip install numpy pandas matplotlib scikit-learn jupyter

IDE选择：

• Jupyter Notebook：适合学习和实验
• VS Code：轻量级，功能丰富
• PyCharm：专业版对数据科学支持良好

2. Python机器学习基础库详解

2.1 NumPy数值计算基础

NumPy是Python科学计算的基础库，提供了高效的数组操作和数学函数。

import numpy as np # 创建数组 arr1 = np.array([1, 2, 3, 4, 5]) arr2 = np.arange(0, 10, 2) # [0, 2, 4, 6, 8] # 数组运算 result = arr1 + arr2[:5] # 元素级加法 matrix = np.random.randn(3, 3) # 3x3随机矩阵 # 常用统计函数 print(f"平均值: {np.mean(arr1)}") print(f"标准差: {np.std(arr1)}") print(f"最大值: {np.max(arr1)}")

2.2 Pandas数据处理实战

Pandas提供了DataFrame数据结构，非常适合处理表格型数据。

import pandas as pd from sklearn.datasets import load_iris # 加载示例数据 iris = load_iris() df = pd.DataFrame(iris.data, columns=iris.feature_names) df['target'] = iris.target # 数据探索 print(df.head()) # 前5行数据 print(df.info()) # 数据基本信息 print(df.describe()) # 统计描述 # 数据清洗示例 # 处理缺失值 df.fillna(df.mean(), inplace=True) # 数据筛选 setosa_data = df[df['target'] == 0] # 筛选setosa类别

2.3 Matplotlib数据可视化

数据可视化是理解数据和模型结果的重要手段。

import matplotlib.pyplot as plt import seaborn as sns # 设置中文字体 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False # 创建子图 fig, axes = plt.subplots(2, 2, figsize=(12, 10)) # 散点图 axes[0, 0].scatter(df['sepal length (cm)'], df['sepal width (cm)'], c=df['target'], alpha=0.6) axes[0, 0].set_xlabel('花萼长度') axes[0, 0].set_ylabel('花萼宽度') # 直方图 axes[0, 1].hist(df['sepal length (cm)'], bins=20, alpha=0.7) axes[0, 1].set_xlabel('花萼长度') axes[0, 1].set_ylabel('频数') # 箱线图 df.boxplot(column=['sepal length (cm)'], by='target', ax=axes[1, 0]) # 热力图 corr_matrix = df.corr() sns.heatmap(corr_matrix, annot=True, ax=axes[1, 1]) plt.tight_layout() plt.show()

3. 特征工程核心技术

3.1 数据预处理与清洗

特征工程是机器学习项目中最重要的环节之一，直接影响模型性能。

from sklearn.preprocessing import StandardScaler, LabelEncoder from sklearn.model_selection import train_test_split # 示例数据集 data = { 'age': [25, 30, 35, 40, 45, None, 55], 'income': [50000, 60000, 70000, 80000, 90000, 100000, 110000], 'education': ['本科', '硕士', '本科', '博士', '硕士', '本科', '博士'], 'purchased': [0, 1, 0, 1, 1, 0, 1] } df = pd.DataFrame(data) # 处理缺失值 df['age'].fillna(df['age'].median(), inplace=True) # 编码分类变量 label_encoder = LabelEncoder() df['education_encoded'] = label_encoder.fit_transform(df['education']) # 特征标准化 scaler = StandardScaler() df[['age_scaled', 'income_scaled']] = scaler.fit_transform(df[['age', 'income']]) print("处理后的数据:") print(df.head())

3.2 特征选择方法

选择合适的特征可以提高模型性能并减少过拟合。

from sklearn.feature_selection import SelectKBest, f_classif from sklearn.ensemble import RandomForestClassifier # 准备特征和目标变量 X = df[['age', 'income', 'education_encoded']] y = df['purchased'] # 方差选择法（移除低方差特征） from sklearn.feature_selection import VarianceThreshold selector = VarianceThreshold(threshold=0.1) X_variance = selector.fit_transform(X) # 单变量特征选择 selector_kbest = SelectKBest(score_func=f_classif, k=2) X_kbest = selector_kbest.fit_transform(X, y) # 基于模型的特征重要性 rf = RandomForestClassifier(n_estimators=100) rf.fit(X, y) feature_importance = pd.DataFrame({ 'feature': X.columns, 'importance': rf.feature_importances_ }).sort_values('importance', ascending=False) print("特征重要性排序:") print(feature_importance)

3.3 特征变换与创建

通过特征变换可以创建更有信息量的特征。

import numpy as np # 多项式特征 from sklearn.preprocessing import PolynomialFeatures poly = PolynomialFeatures(degree=2, include_bias=False) X_poly = poly.fit_transform(X[['age', 'income']]) # 创建交互特征 df['age_income_interaction'] = df['age'] * df['income'] # 分箱处理 df['age_binned'] = pd.cut(df['age'], bins=3, labels=['青年', '中年', '老年']) # 时间特征处理（假设有日期数据） # df['year'] = df['date'].dt.year # df['month'] = df['date'].dt.month # df['day_of_week'] = df['date'].dt.dayofweek print("特征变换后的数据:") print(df[['age', 'income', 'age_income_interaction', 'age_binned']].head())

4. 经典机器学习算法实战

4.1 线性回归模型

线性回归是理解机器学习基础的入门算法。

from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, r2_score from sklearn.datasets import fetch_california_housing # 加载加州房价数据集 housing = fetch_california_housing() X, y = housing.data, housing.target # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) # 特征标准化 scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # 训练线性回归模型 lr_model = LinearRegression() lr_model.fit(X_train_scaled, y_train) # 预测和评估 y_pred = lr_model.predict(X_test_scaled) mse = mean_squared_error(y_test, y_pred) r2 = r2_score(y_test, y_pred) print(f"线性回归模型性能:") print(f"均方误差(MSE): {mse:.4f}") print(f"决定系数(R²): {r2:.4f}") # 查看系数重要性 feature_importance = pd.DataFrame({ 'feature': housing.feature_names, 'coefficient': lr_model.coef_ }).sort_values('coefficient', key=abs, ascending=False) print("\n特征系数排序:") print(feature_importance)

4.2 逻辑回归分类

逻辑回归广泛应用于二分类问题。

from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score, classification_report, confusion_matrix # 使用鸢尾花数据集 from sklearn.datasets import load_iris iris = load_iris() # 只使用两个类别进行二分类 X_binary = iris.data[iris.target != 2] y_binary = iris.target[iris.target != 2] # 数据划分 X_train, X_test, y_train, y_test = train_test_split( X_binary, y_binary, test_size=0.3, random_state=42 ) # 特征标准化 scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # 训练逻辑回归模型 logistic_model = LogisticRegression(random_state=42) logistic_model.fit(X_train_scaled, y_train) # 预测和评估 y_pred = logistic_model.predict(X_test_scaled) accuracy = accuracy_score(y_test, y_pred) print("逻辑回归分类结果:") print(f"准确率: {accuracy:.4f}") print("\n分类报告:") print(classification_report(y_test, y_pred)) # 混淆矩阵 cm = confusion_matrix(y_test, y_pred) print("混淆矩阵:") print(cm)

4.3 决策树与随机森林

树模型可以处理非线性关系，且具有较好的可解释性。

from sklearn.tree import DecisionTreeClassifier, plot_tree from sklearn.ensemble import RandomForestClassifier import matplotlib.pyplot as plt # 使用完整的鸢尾花数据集（三分类） X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, test_size=0.3, random_state=42 ) # 决策树模型 dt_model = DecisionTreeClassifier(max_depth=3, random_state=42) dt_model.fit(X_train, y_train) dt_accuracy = dt_model.score(X_test, y_test) # 随机森林模型 rf_model = RandomForestClassifier( n_estimators=100, max_depth=3, random_state=42 ) rf_model.fit(X_train, y_train) rf_accuracy = rf_model.score(X_test, y_test) print(f"决策树准确率: {dt_accuracy:.4f}") print(f"随机森林准确率: {rf_accuracy:.4f}") # 可视化决策树 plt.figure(figsize=(15, 10)) plot_tree(dt_model, feature_names=iris.feature_names, class_names=iris.target_names, filled=True, rounded=True) plt.title("决策树可视化") plt.show() # 特征重要性 importance_df = pd.DataFrame({ 'feature': iris.feature_names, 'importance': rf_model.feature_importances_ }).sort_values('importance', ascending=False) print("\n随机森林特征重要性:") print(importance_df)

5. 支持向量机与K近邻算法

5.1 SVM分类实战

支持向量机在处理高维数据和小样本问题时表现优秀。

from sklearn.svm import SVC from sklearn.metrics import accuracy_score, precision_score, recall_score # 数据准备 X_train, X_test, y_train, y_test = train_test_split( iris.data, iris.target, test_size=0.3, random_state=42 ) # 特征标准化 scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # 线性SVM linear_svm = SVC(kernel='linear', C=1.0, random_state=42) linear_svm.fit(X_train_scaled, y_train) linear_pred = linear_svm.predict(X_test_scaled) # 高斯核SVM rbf_svm = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42) rbf_svm.fit(X_train_scaled, y_train) rbf_pred = rbf_svm.predict(X_test_scaled) # 性能比较 linear_accuracy = accuracy_score(y_test, linear_pred) rbf_accuracy = accuracy_score(y_test, rbf_pred) print("SVM分类性能比较:") print(f"线性核准确率: {linear_accuracy:.4f}") print(f"高斯核准确率: {rbf_accuracy:.4f}") # 超参数调优示例 from sklearn.model_selection import GridSearchCV param_grid = { 'C': [0.1, 1, 10, 100], 'gamma': [1, 0.1, 0.01, 0.001], 'kernel': ['rbf'] } grid_search = GridSearchCV(SVC(), param_grid, cv=5, scoring='accuracy') grid_search.fit(X_train_scaled, y_train) print(f"最优参数: {grid_search.best_params_}") print(f"最优交叉验证分数: {grid_search.best_score_:.4f}")

5.2 K近邻算法应用

KNN是一种简单而有效的惰性学习算法。

from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score # 寻找最优K值 k_range = range(1, 31) k_scores = [] for k in k_range: knn = KNeighborsClassifier(n_neighbors=k) knn.fit(X_train_scaled, y_train) scores = knn.score(X_test_scaled, y_test) k_scores.append(scores) # 可视化K值选择 plt.figure(figsize=(10, 6)) plt.plot(k_range, k_scores) plt.xlabel('K值') plt.ylabel('准确率') plt.title('KNN中K值选择') plt.grid(True) plt.show() # 使用最优K值 best_k = k_range[np.argmax(k_scores)] best_knn = KNeighborsClassifier(n_neighbors=best_k) best_knn.fit(X_train_scaled, y_train) best_pred = best_knn.predict(X_test_scaled) best_accuracy = accuracy_score(y_test, best_pred) print(f"最优K值: {best_k}") print(f"KNN最佳准确率: {best_accuracy:.4f}") # 距离度量比较 distance_metrics = ['euclidean', 'manhattan', 'minkowski'] for metric in distance_metrics: knn_metric = KNeighborsClassifier(n_neighbors=best_k, metric=metric) knn_metric.fit(X_train_scaled, y_train) metric_accuracy = knn_metric.score(X_test_scaled, y_test) print(f"{metric}距离准确率: {metric_accuracy:.4f}")

6. 聚类算法与降维技术

6.1 K均值聚类实战

无监督学习中的经典聚类算法。

from sklearn.cluster import KMeans from sklearn.metrics import silhouette_score from sklearn.datasets import make_blobs # 生成示例聚类数据 X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=42) # 寻找最优聚类数 inertia = [] silhouette_scores = [] k_range = range(2, 10) for k in k_range: kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X) inertia.append(kmeans.inertia_) silhouette_scores.append(silhouette_score(X, kmeans.labels_)) # 肘部法则可视化 plt.figure(figsize=(12, 4)) plt.subplot(1, 2, 1) plt.plot(k_range, inertia, 'bo-') plt.xlabel('聚类数 K') plt.ylabel('簇内平方和') plt.title('肘部法则') plt.subplot(1, 2, 2) plt.plot(k_range, silhouette_scores, 'ro-') plt.xlabel('聚类数 K') plt.ylabel('轮廓系数') plt.title('轮廓系数法') plt.tight_layout() plt.show() # 使用最优聚类数 optimal_k = 4 # 根据上图选择 final_kmeans = KMeans(n_clusters=optimal_k, random_state=42) y_pred = final_kmeans.fit_predict(X) # 可视化聚类结果 plt.figure(figsize=(8, 6)) plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', alpha=0.7) plt.scatter(final_kmeans.cluster_centers_[:, 0], final_kmeans.cluster_centers_[:, 1], marker='x', s=200, linewidths=3, color='red') plt.title('K均值聚类结果') plt.show() print(f"轮廓系数: {silhouette_score(X, y_pred):.4f}")

6.2 PCA降维应用

主成分分析是常用的降维技术。

from sklearn.decomposition import PCA from sklearn.datasets import load_digits # 加载手写数字数据集 digits = load_digits() X, y = digits.data, digits.target print(f"原始数据维度: {X.shape}") # PCA降维 pca = PCA(n_components=2) X_pca = pca.fit_transform(X) print(f"降维后数据维度: {X_pca.shape}") print(f"解释方差比例: {pca.explained_variance_ratio_.sum():.4f}") # 可视化降维结果 plt.figure(figsize=(10, 8)) scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y, cmap='tab10', alpha=0.6) plt.colorbar(scatter) plt.xlabel('第一主成分') plt.ylabel('第二主成分') plt.title('PCA降维可视化') plt.show() # 选择保留多少主成分 pca_full = PCA() pca_full.fit(X) # 累计解释方差 explained_variance_ratio_cumsum = np.cumsum(pca_full.explained_variance_ratio_) plt.figure(figsize=(10, 6)) plt.plot(range(1, len(explained_variance_ratio_cumsum) + 1), explained_variance_ratio_cumsum, 'bo-') plt.axhline(y=0.95, color='r', linestyle='--', label='95%方差解释') plt.xlabel('主成分数量') plt.ylabel('累计解释方差比例') plt.title('主成分数量选择') plt.grid(True) plt.legend() plt.show() # 找到达到95%方差解释所需的主成分数 n_components_95 = np.argmax(explained_variance_ratio_cumsum >= 0.95) + 1 print(f"达到95%方差解释所需主成分数: {n_components_95}")

7. 模型评估与优化策略

7.1 交叉验证与超参数调优

正确的模型评估方法对机器学习项目至关重要。

from sklearn.model_selection import cross_val_score, StratifiedKFold from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import classification_report, confusion_matrix import seaborn as sns # 交叉验证评估 rf = RandomForestClassifier(n_estimators=100, random_state=42) cv_scores = cross_val_score(rf, iris.data, iris.target, cv=5, scoring='accuracy') print("5折交叉验证结果:") print(f"各折分数: {cv_scores}") print(f"平均分数: {cv_scores.mean():.4f} (+/- {cv_scores.std() * 2:.4f})") # 分层K折交叉验证 stratified_kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42) stratified_scores = cross_val_score(rf, iris.data, iris.target, cv=stratified_kfold, scoring='accuracy') print("\n分层交叉验证结果:") print(f"平均分数: {stratified_scores.mean():.4f}") # 网格搜索调优 from sklearn.model_selection import GridSearchCV param_grid = { 'n_estimators': [50, 100, 200], 'max_depth': [3, 5, 7, None], 'min_samples_split': [2, 5, 10] } grid_search = GridSearchCV( RandomForestClassifier(random_state=42), param_grid, cv=5, scoring='accuracy', n_jobs=-1 ) grid_search.fit(iris.data, iris.target) print(f"\n最优参数: {grid_search.best_params_}") print(f"最优分数: {grid_search.best_score_:.4f}") # 使用最优模型进行预测 best_rf = grid_search.best_estimator_ y_pred = best_rf.predict(iris.data) # 详细评估报告 print("\n分类报告:") print(classification_report(iris.target, y_pred, target_names=iris.target_names)) # 混淆矩阵可视化 cm = confusion_matrix(iris.target, y_pred) plt.figure(figsize=(8, 6)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names) plt.xlabel('预测标签') plt.ylabel('真实标签') plt.title('混淆矩阵') plt.show()

7.2 学习曲线与验证曲线

通过曲线分析模型的表现和问题。

from sklearn.model_selection import learning_curve, validation_curve # 学习曲线 train_sizes, train_scores, test_scores = learning_curve( RandomForestClassifier(n_estimators=100, random_state=42), iris.data, iris.target, cv=5, scoring='accuracy', train_sizes=np.linspace(0.1, 1.0, 10) ) train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.figure(figsize=(10, 6)) plt.plot(train_sizes, train_scores_mean, 'o-', color='r', label='训练分数') plt.plot(train_sizes, test_scores_mean, 'o-', color='g', label='交叉验证分数') plt.fill_between(train_sizes, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.1, color='r') plt.fill_between(train_sizes, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, alpha=0.1, color='g') plt.xlabel('训练样本数') plt.ylabel('准确率') plt.title('学习曲线') plt.legend() plt.grid(True) plt.show() # 验证曲线（以max_depth为例） param_range = range(1, 11) train_scores, test_scores = validation_curve( RandomForestClassifier(n_estimators=100, random_state=42), iris.data, iris.target, param_name='max_depth', param_range=param_range, cv=5, scoring='accuracy' ) train_scores_mean = np.mean(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) plt.figure(figsize=(10, 6)) plt.plot(param_range, train_scores_mean, 'o-', color='r', label='训练分数') plt.plot(param_range, test_scores_mean, 'o-', color='g', label='交叉验证分数') plt.xlabel('最大深度') plt.ylabel('准确率') plt.title('验证曲线') plt.legend() plt.grid(True) plt.show()

8. 实战项目：鸢尾花分类系统

8.1 项目需求分析

构建一个完整的鸢尾花分类系统，实现以下功能：

• 数据加载和探索
• 特征工程处理
• 多种模型训练和比较
• 模型持久化保存
• 新数据预测接口

8.2 完整代码实现

import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split, cross_val_score from sklearn.preprocessing import StandardScaler from sklearn.ensemble import RandomForestClassifier from sklearn.svm import SVC from sklearn.linear_model import LogisticRegression from sklearn.metrics import classification_report, confusion_matrix, accuracy_score import joblib import warnings warnings.filterwarnings('ignore') class IrisClassifier: def __init__(self): self.models = {} self.scaler = StandardScaler() self.best_model = None self.feature_names = None self.target_names = None def load_data(self): """加载和探索数据""" iris = load_iris() self.X = iris.data self.y = iris.target self.feature_names = iris.feature_names self.target_names = iris.target_names # 创建DataFrame用于分析 self.df = pd.DataFrame(self.X, columns=self.feature_names) self.df['target'] = self.y self.df['species'] = [self.target_names[i] for i in self.y] print("数据集基本信息:") print(f"样本数: {self.X.shape[0]}, 特征数: {self.X.shape[1]}") print(f"类别分布:\n{self.df['species'].value_counts()}") return self.X, self.y def explore_data(self): """数据探索分析""" # 统计描述 print("\n数值特征统计描述:") print(self.df[self.feature_names].describe()) # 相关性分析 plt.figure(figsize=(10, 8)) correlation_matrix = self.df[self.feature_names].corr() sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0) plt.title('特征相关性热力图') plt.tight_layout() plt.show() # 特征分布可视化 fig, axes = plt.subplots(2, 2, figsize=(12, 10)) for i, feature in enumerate(self.feature_names): row, col = i // 2, i % 2 for species in self.target_names: species_data = self.df[self.df['species'] == species][feature] axes[row, col].hist(species_data, alpha=0.7, label=species) axes[row, col].set_xlabel(feature) axes[row, col].set_ylabel('频数') axes[row, col].legend() plt.tight_layout() plt.show() def prepare_data(self, test_size=0.2, random_state=42): """数据预处理和划分""" # 划分训练测试集 X_train, X_test, y_train, y_test = train_test_split( self.X, self.y, test_size=test_size, random_state=random_state, stratify=self.y ) # 特征标准化 X_train_scaled = self.scaler.fit_transform(X_train) X_test_scaled = self.scaler.transform(X_test) return X_train_scaled, X_test_scaled, y_train, y_test def train_models(self, X_train, y_train): """训练多个模型并比较""" # 定义模型 self.models = { '随机森林': RandomForestClassifier(n_estimators=100, random_state=42), '支持向量机': SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42), '逻辑回归': LogisticRegression(random_state=42, max_iter=1000) } # 训练并评估每个模型 model_scores = {} for name, model in self.models.items(): # 交叉验证 cv_scores = cross_val_score(model, X_train, y_train, cv=5) model_scores[name] = cv_scores.mean() # 训练最终模型 model.fit(X_train, y_train) print(f"{name} - 交叉验证平均准确率: {cv_scores.mean():.4f}") # 选择最佳模型 self.best_model_name = max(model_scores, key=model_scores.get) self.best_model = self.models[self.best_model_name] print(f"\n最佳模型: {self.best_model_name}") return model_scores def evaluate_model(self, X_test, y_test): """模型评估""" y_pred = self.best_model.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print(f"\n测试集准确率: {accuracy:.4f}") print("\n详细分类报告:") print(classification_report(y_test, y_pred, target_names=self.target_names)) # 混淆矩阵 plt.figure(figsize=(8, 6)) cm = confusion_matrix(y_test, y_pred) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=self.target_names, yticklabels=self.target_names) plt.xlabel('预测标签') plt.ylabel('真实标签') plt.title('混淆矩阵') plt.show() return accuracy def save_model(self, filepath='iris_classifier.pkl'): """保存训练好的模型""" model_data = { 'model': self.best_model, 'scaler': self.scaler, 'feature_names': self.feature_names, 'target_names': self.target_names } joblib.dump(model_data, filepath) print(f"模型已保存到: {filepath}") def load_model(self, filepath='iris_classifier.pkl'): """加载已保存的模型""" model_data = joblib.load(filepath) self.best_model = model_data['model'] self.scaler = model_data['scaler'] self.feature_names = model_data['feature_names'] self.target_names = model_data['target_names'] print(f"模型已从 {filepath} 加载") def predict_new_sample(self, features): """预测新样本""" if self.best_model is None: raise ValueError("请先训练或加载模型") # 特征标准化 features_scaled = self.scaler.transform([features]) # 预测 prediction = self.best_model.predict(features_scaled)[0] probability = self.best_model.predict_proba(features_scaled)[0] result = { 'predicted_class': self.target_names[prediction], 'probabilities': { self.target_names[i]: f"{prob:.4f}" for i, prob in enumerate(probability) } } return result # 使用示例 def main(): # 创建分类器实例 classifier = IrisClassifier() # 1. 加载数据 X, y = classifier.load_data() # 2. 数据探索 classifier.explore_data() # 3. 准备数据 X_train, X_test, y_train, y_test = classifier.prepare_data() # 4. 训练模型 model_scores = classifier.train_models(X_train, y_train) # 5. 评估模型 accuracy = classifier.evaluate_model(X_test, y_test) # 6. 保存模型 classifier.save_model() # 7. 预测新样本 # 示例：花萼长度5.1cm, 花萼宽度3.5cm, 花瓣长度1.4cm, 花瓣宽度0.2cm new_sample = [5.1, 3.5, 1.4, 0.2] prediction = classifier.predict_new_sample(new_sample) print("\n新样本预测结果:") print(f"预测类别: {prediction['predicted_class']}") print("各类别概率:") for class_name, prob in prediction['probabilities'].items(): print(f" {class_name}: {prob}") if __name__ == "__main__": main()

8.3 项目运行结果分析

运行上述代码，你将得到以下输出和分析：

1. 数据探索结果：了解数据集的基本统计信息和特征分布
2. 模型比较结果：三种算法的交叉验证准确率对比
3. 最佳模型选择：自动选择表现最好的模型
4. 详细评估报告：包括准确率、精确率、召回率等指标
5. 混淆矩阵可视化：直观显示分类结果
6. 模型持久化：训练好的模型保存为文件
7. 预测接口：可以对新的鸢尾花样本进行分类预测

这个实战项目展示了机器学习项目的完整流程，从数据探索到模型部署，涵盖了机器学习工程化的核心环节。

9. 常见问题与解决方案

9.1 环境配置问题

问题1：Python包安装失败

解决方案： 1. 使用国内镜像源：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package-name 2. 使用conda安装：conda install package-name 3. 检查Python版本兼容性

问题2：Jupyter Notebook无法启动

解决方案： 1. 检查是否在正确环境中安装：conda activate ml-env 2. 重新安装：pip install --upgrade jupyter 3. 指定端口启动：jupyter notebook --port 8889

9.2 数据处理问题

问题3：缺失值处理策略

# 数值特征：使用均值、中位数或插值法 df['column'].fillna(df['column'].mean(), inplace=True) # 分类特征：使用众数或单独类别 df['category_column'].fillna('Unknown', inplace=True) # 时间序列：使用前后值插值 df['timestamp_column'].interpolate(method='time', inplace=True)

**问题4：类别不平衡