CentOS Stream 9入门学习教程，从入门到精通，CentOS Stream 9 中人工智能 —语法详解与实战案例(14）

CentOS Stream 9 中人工智能 ---语法详解与实战案例

系统环境：CentOS Stream 9 x86_64

Python 版本建议：3.9~3.11（兼容 TensorFlow 2.x）

IDE 推荐：VSCode + Jupyter Notebook / PyCharm

一、机器学习开发环境配置

1.1 机器学习概述

机器学习（Machine Learning, ML） 是人工智能的核心分支，让计算机从数据中自动学习规律，无需显式编程。
三大类型：

类型	说明	典型算法
监督学习	有标签数据训练模型	线性回归、SVM、决策树
无监督学习	无标签数据发现结构	KMeans、PCA、DBSCAN
强化学习	通过奖励机制学习策略	Q-Learning、DQN

本章重点：无监督聚类（KMeans） + 深度学习图像分类

1.2 安装 Anaconda

Anaconda 是 Python 数据科学发行版，包含：

Python 解释器
包管理器 conda
180+ 预装科学包（numpy, pandas, scikit-learn, matplotlib）
Jupyter Notebook / Lab

✅ CentOS Stream 9 安装步骤：

bash 复制代码

# 1. 下载 Anaconda（以 Python 3.11 为例）
wget https://repo.anaconda.com/archive/Anaconda3-2024.02-1-Linux-x86_64.sh

# 2. 运行安装脚本
bash Anaconda3-2024.02-1-Linux-x86_64.sh

# 3. 按提示阅读协议，输入 yes
# 4. 默认安装路径：~/anaconda3
# 5. 初始化 conda？输入 yes

# 6. 重新加载 shell 配置
source ~/.bashrc

# 7. 验证安装
conda --version
python --version

✅ 创建独立环境（推荐）：

bash 复制代码

# 创建名为 ml_env 的环境，指定 Python 版本
conda create -n ml_env python=3.11

# 激活环境
conda activate ml_env

# 退出环境
conda deactivate

1.3 conda 基本用法

conda 是包和环境管理器，支持 Python 和非 Python 包。
常用命令：

命令	说明
`conda create -n <name> python=x.x`	创建新环境
`conda activate <name>`	激活环境
`conda deactivate`	退出环境
`conda env list`	列出所有环境
`conda install <package>`	安装包
`conda remove --name <name> --all`	删除环境
`conda list`	列出当前环境包
`conda update --all`	更新所有包

✅ 实战：安装机器学习核心包

bash 复制代码

# 激活环境
conda activate ml_env

# 安装核心包（scikit-learn, matplotlib, jupyter）
conda install scikit-learn matplotlib jupyter pandas numpy

# 或使用 pip（conda 仓库没有时）
pip install scikit-learn matplotlib jupyter pandas numpy

# 启动 Jupyter Notebook
jupyter notebook

1.4 Python 开发基础（AI 向）

重点掌握以下语法结构：

① 导入模块

python 复制代码

# 标准导入
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

② NumPy 数组操作

python 复制代码

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])

# 常用操作
print(arr.shape)        # (5,)
print(matrix.ndim)      # 2
print(matrix.mean())    # 2.5
print(np.zeros((3,3)))  # 3x3 零矩阵

③ Matplotlib 绘图

python 复制代码

import matplotlib.pyplot as plt

# 简单折线图
x = [1, 2, 3, 4]
y = [1, 4, 2, 3]
plt.plot(x, y, 'ro-')  # 红色圆点连线
plt.title("Sample Plot")
plt.xlabel("X轴")
plt.ylabel("Y轴")
plt.grid(True)
plt.show()

④ 函数定义

python 复制代码

def calculate_distance(p1, p2):
    """计算两点间欧氏距离"""
    return np.sqrt(np.sum((p1 - p2) ** 2))

# 调用
dist = calculate_distance(np.array([0,0]), np.array([3,4]))
print(f"距离: {dist}")  # 输出: 距离: 5.0

⑤ 类定义（面向对象）

python 复制代码

class DataProcessor:
    def __init__(self, data):
        self.data = np.array(data)
    
    def normalize(self):
        """归一化到 [0,1]"""
        min_val = self.data.min()
        max_val = self.data.max()
        self.data = (self.data - min_val) / (max_val - min_val)
        return self.data

# 使用
processor = DataProcessor([10, 20, 30, 40])
normalized = processor.normalize()
print(normalized)  # [0.  0.333 0.666 1. ]

二、综合案例：基于 scikit-learn 的聚类分析实践

2.1 案例概述

使用 KMeans 聚类算法 对人工生成的二维数据进行无监督聚类。
数据集：make_blobs 生成的 3 个簇的点集

目标：自动发现数据中的 3 个聚类中心

可视化：使用 matplotlib 展示原始数据与聚类结果

2.2 案例详解

✅ 完整代码（带详细注释）：

python 复制代码

# -*- coding: utf-8 -*-
"""
基于 scikit-learn 的 KMeans 聚类分析实战
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

# ==================== 1. 生成模拟数据 ====================
# 生成 300 个样本，3 个中心，标准差 1.5
X, y_true = make_blobs(
    n_samples=300,      # 样本数量
    centers=3,          # 聚类中心数量
    cluster_std=1.5,    # 簇的标准差（控制分散程度）
    random_state=42,    # 随机种子，确保结果可复现
    n_features=2        # 特征维度（二维数据）
)

print(f"数据形状: {X.shape}")  # (300, 2)
print(f"真实标签: {np.unique(y_true)}")  # [0 1 2]

# ==================== 2. 创建并训练 KMeans 模型 ====================
kmeans = KMeans(
    n_clusters=3,       # 聚类数量
    init='k-means++',   # 初始化方法（比随机更好）
    n_init=10,          # 用不同质心初始化运行的次数
    max_iter=300,       # 最大迭代次数
    random_state=42     # 随机种子
)

# 训练模型（无监督，不需要 y_true）
kmeans.fit(X)

# 获取聚类标签和聚类中心
y_pred = kmeans.labels_         # 每个样本的预测簇标签
centers = kmeans.cluster_centers_  # 聚类中心坐标

print(f"预测标签: {np.unique(y_pred)}")  # [0 1 2]
print(f"聚类中心:\n{centers}")

# ==================== 3. 可视化结果 ====================
plt.figure(figsize=(14, 5))

# 子图1：原始数据（按真实标签着色）
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y_true, cmap='viridis', s=50, alpha=0.8)
plt.title('真实聚类分布', fontsize=14, fontweight='bold')
plt.xlabel('特征 1')
plt.ylabel('特征 2')
plt.grid(True, alpha=0.3)

# 子图2：KMeans 聚类结果
plt.subplot(1, 2, 2)
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', s=50, alpha=0.8, label='数据点')
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, marker='X', label='聚类中心')
plt.title('KMeans 聚类结果', fontsize=14, fontweight='bold')
plt.xlabel('特征 1')
plt.ylabel('特征 2')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ==================== 4. 评估聚类效果（可选） ====================
from sklearn.metrics import adjusted_rand_score, silhouette_score

# 调整兰德指数（需要真实标签）
ari = adjusted_rand_score(y_true, y_pred)
print(f"调整兰德指数 (ARI): {ari:.4f}")  # 越接近1越好

# 轮廓系数（无需真实标签）
silhouette_avg = silhouette_score(X, y_pred)
print(f"平均轮廓系数: {silhouette_avg:.4f}")  # 越接近1越好

# ==================== 5. 尝试不同 K 值（肘部法则） ====================
k_range = range(1, 11)
inertias = []

for k in k_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X)
    inertias.append(km.inertia_)  # 样本到最近聚类中心的距离平方和

# 绘制肘部图
plt.figure(figsize=(8, 5))
plt.plot(k_range, inertias, 'bo-', linewidth=2, markersize=8)
plt.xlabel('聚类数量 K')
plt.ylabel('簇内平方和 (WCSS)')
plt.title('肘部法则确定最佳 K 值', fontsize=14)
plt.grid(True, alpha=0.3)
plt.xticks(k_range)
plt.show()

✅ 运行结果说明：

左图：原始数据分布（3个簇）
右图：KMeans 聚类结果 + 红色 X 标记聚类中心
控制台输出：聚类中心坐标、评估指标
肘部图：帮助选择最佳 K 值（拐点处）

✅ 输出示例：

复制代码

数据形状: (300, 2)
真实标签: [0 1 2]
预测标签: [0 1 2]
聚类中心:
[[ 1.78  4.05]
 [-2.15 -3.18]
 [ 4.82 -1.06]]
调整兰德指数 (ARI): 0.9987
平均轮廓系数: 0.7482

三、深度学习开发环境配置

3.1 深度学习概述

深度学习（Deep Learning） 是机器学习的一个子领域，使用多层神经网络自动学习数据特征。
典型应用：

图像识别（CNN）
语音识别（RNN/LSTM）
自然语言处理（Transformer）
生成模型（GAN, Diffusion）

本章重点：图像分类（CNN）

3.2 TensorFlow 简介

TensorFlow 是 Google 开发的开源深度学习框架，支持：

静态图（1.x）和动态图（2.x，默认）
GPU/TPU 加速
Keras 高级 API（推荐新手使用）
模型部署（TensorFlow Lite, TF Serving）

TensorFlow 2.x 核心组件：

组件	说明
`tf.keras`	高级神经网络 API
`tf.data`	数据管道
`tf.GradientTape`	自动微分
`tf.function`	图编译加速

3.3 安装 TensorFlow

✅ 方法1：使用 conda（推荐，自动解决依赖）

bash 复制代码

conda activate ml_env  # 或新建深度学习环境
conda install tensorflow

✅ 方法2：使用 pip（最新版本）

bash 复制代码

pip install tensorflow==2.16.1  # 指定版本避免兼容问题

✅ 方法3：GPU 版本（需提前安装 NVIDIA 驱动 + CUDA）

bash 复制代码

pip install tensorflow[and-cuda]  # TF 2.11+ 新语法
# 或
pip install tensorflow-gpu      # 旧版本

⚠️ CentOS Stream 9 注意：

确保系统更新：sudo dnf update
安装开发工具：sudo dnf groupinstall "Development Tools"
安装 Python 头文件：sudo dnf install python3-devel

3.4 测试是否安装成功

✅ 测试脚本 test_tf.py：

python 复制代码

# test_tf.py - TensorFlow 安装测试

import tensorflow as tf

print("✅ TensorFlow 版本:", tf.__version__)

# 检查 GPU 支持
print("✅ GPU 是否可用:", tf.config.list_physical_devices('GPU'))
if tf.config.list_physical_devices('GPU'):
    print("🎉 恭喜！检测到 GPU，可加速训练！")
else:
    print("⚠️ 未检测到 GPU，使用 CPU 运行（速度较慢）")

# 简单计算测试
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])
c = tf.matmul(a, b)

print("✅ 矩阵乘法测试:")
print("A =\n", a.numpy())
print("B =\n", b.numpy())
print("A × B =\n", c.numpy())

# 创建简单模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(4,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy')
print("✅ Keras 模型创建成功！")

print("\n🎉 TensorFlow 安装成功！可以开始深度学习之旅了！")

✅ 运行：

bash 复制代码

python test_tf.py

✅ 成功输出示例：

复制代码

✅ TensorFlow 版本: 2.16.1
✅ GPU 是否可用: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
🎉 恭喜！检测到 GPU，可加速训练！
✅ 矩阵乘法测试:
A =
 [[1 2]
 [3 4]]
B =
 [[5 6]
 [7 8]]
A × B =
 [[19 22]
 [43 50]]
✅ Keras 模型创建成功！

🎉 TensorFlow 安装成功！可以开始深度学习之旅了！

四、综合案例：基于 TensorFlow 的服饰图像分类实践

4.1 案例概述

使用 TensorFlow/Keras 构建卷积神经网络（CNN），对 Fashion MNIST 数据集进行分类。
数据集：10 类服饰图片（28x28 灰度图）

类别：T恤、裤子、套头衫、裙子、外套、凉鞋、衬衫、运动鞋、包、靴子

模型：CNN（卷积层 + 池化层 + 全连接层）

目标：达到 >90% 测试准确率

4.2 环境准备

✅ 安装依赖包：

bash 复制代码

conda install matplotlib numpy jupyter
# TensorFlow 已安装

✅ 数据集说明：

tf.keras.datasets.fashion_mnist 内置数据集
60,000 张训练图像 + 10,000 张测试图像
标签 0~9 对应 10 种服饰

4.3 案例详解

✅ 完整代码（带详细注释）：

python 复制代码

# -*- coding: utf-8 -*-
"""
基于 TensorFlow 的 Fashion MNIST 图像分类实战
"""

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体（可选）
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# ==================== 1. 加载并预处理数据 ====================
print("📥 正在加载 Fashion MNIST 数据集...")

# 加载数据（首次运行会自动下载）
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

print(f"训练集形状: {x_train.shape}")  # (60000, 28, 28)
print(f"测试集形状: {x_test.shape}")   # (10000, 28, 28)
print(f"训练标签: {np.unique(y_train)}")  # [0 1 2 3 4 5 6 7 8 9]

# 数据预处理
x_train = x_train.astype('float32') / 255.0  # 归一化到 [0,1]
x_test = x_test.astype('float32') / 255.0

# 添加通道维度 (28,28) -> (28,28,1)
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]

print(f"预处理后训练集形状: {x_train.shape}")  # (60000, 28, 28, 1)

# 标签名称
class_names = ['T恤', '裤子', '套头衫', '裙子', '外套',
               '凉鞋', '衬衫', '运动鞋', '包', '靴子']

# ==================== 2. 构建 CNN 模型 ====================
model = tf.keras.Sequential([
    # 第一个卷积块
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D((2, 2)),
    
    # 第二个卷积块
    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
    tf.keras.layers.MaxPooling2D((2, 2)),
    
    # 第三个卷积块
    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
    
    # 展平层
    tf.keras.layers.Flatten(),
    
    # 全连接层
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),  # 防止过拟合
    tf.keras.layers.Dense(10, activation='softmax')  # 10 分类
])

# 显示模型结构
model.summary()

# ==================== 3. 编译模型 ====================
model.compile(
    optimizer='adam',              # 优化器
    loss='sparse_categorical_crossentropy',  # 损失函数（标签是整数）
    metrics=['accuracy']           # 评估指标
)

# ==================== 4. 训练模型 ====================
print("\n🚀 开始训练模型...")

history = model.fit(
    x_train, y_train,
    epochs=10,                     # 训练轮数
    batch_size=32,                 # 批次大小
    validation_split=0.2,          # 20% 数据用于验证
    verbose=1                      # 显示训练进度
)

# ==================== 5. 评估模型 ====================
print("\n🧪 正在评估模型...")

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f'✅ 测试准确率: {test_acc:.4f} ({test_acc*100:.2f}%)')

# ==================== 6. 可视化训练过程 ====================
plt.figure(figsize=(12, 4))

# 子图1：训练 & 验证准确率
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.title('模型准确率')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.grid(True, alpha=0.3)

# 子图2：训练 & 验证损失
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('模型损失')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ==================== 7. 预测并可视化结果 ====================
# 随机选择测试图像
num_images = 5
indices = np.random.choice(len(x_test), num_images, replace=False)

plt.figure(figsize=(15, 3))
for i, idx in enumerate(indices):
    # 预测
    prediction = model.predict(x_test[idx:idx+1])  # 注意维度
    predicted_label = np.argmax(prediction)
    true_label = y_test[idx]
    
    # 显示图像
    plt.subplot(1, num_images, i+1)
    plt.imshow(x_test[idx].reshape(28, 28), cmap='gray')
    plt.title(f'真实: {class_names[true_label]}\n预测: {class_names[predicted_label]}',
              color='green' if predicted_label == true_label else 'red')
    plt.axis('off')

plt.suptitle('预测结果（绿色=正确，红色=错误）', fontsize=16)
plt.tight_layout()
plt.show()

# ==================== 8. 保存模型（可选） ====================
model.save('fashion_mnist_model.h5')
print("💾 模型已保存为 'fashion_mnist_model.h5'")

# 加载模型（演示）
# loaded_model = tf.keras.models.load_model('fashion_mnist_model.h5')

✅ 关键代码注释：

[..., tf.newaxis]：添加通道维度，符合 CNN 输入要求
Conv2D(32, (3,3))：32 个 3x3 卷积核
MaxPooling2D((2,2))：2x2 最大池化，降维
Dropout(0.5)：随机丢弃 50% 神经元，防止过拟合
sparse_categorical_crossentropy：适用于整数标签的多分类损失
history.history：记录训练过程中的指标变化

✅ 预期输出：

训练准确率 > 95%
验证准确率 > 90%
测试准确率 > 90%
可视化图表 + 预测结果展示

✅ 运行时间（CPU）：约 5-10 分钟 / 10 epochs

✅ 运行时间（GPU）：约 1-2 分钟 / 10 epochs

✅ 人工智能开发最佳实践

环境隔离：始终使用 conda 虚拟环境
版本固定 ：pip freeze > requirements.txt
数据预处理：归一化、标准化、数据增强
模型验证：使用 validation_split 或交叉验证
防止过拟合：Dropout、正则化、早停
可视化：训练过程、预测结果、混淆矩阵
模型保存 ：model.save() 便于部署
GPU 加速：安装 CUDA + cuDNN 提升训练速度

📚 附录：常用命令与代码速查

功能	代码/命令
创建 conda 环境	`conda create -n ai_env python=3.11`
激活环境	`conda activate ai_env`
安装 TensorFlow	`conda install tensorflow`
启动 Jupyter	`jupyter notebook`
加载 Fashion MNIST	`tf.keras.datasets.fashion_mnist.load_data()`
构建 CNN	`tf.keras.Sequential([...])`
编译模型	`model.compile(optimizer='adam', loss='...', metrics=['accuracy'])`
训练模型	`model.fit(x_train, y_train, epochs=10, validation_split=0.2)`
评估模型	`model.evaluate(x_test, y_test)`
保存模型	`model.save('model.h5')`

这份文档覆盖了 CentOS Stream 9 上 人工智能开发的全部核心知识点 + 语法细节 + 实用案例 + 综合项目，所有代码均含详细注释，可直接用于教学、自学或生产环境参考。