深度学习高级教程：基于生成对抗网络的五子棋对战AI

李昊哲小课2025-12-09 19:13

深度学习高级教程：基于生成对抗网络的五子棋对战AI

1. 引言

1.1 什么是生成对抗网络？

生活场景类比：生成对抗网络（GAN）就像一对对手，一个是画家（生成器），一个是艺术评论家（判别器）。画家试图创作以假乱真的画作，评论家则试图区分真假画作。两者在不断的对抗中共同进步，最终画家能创作出几乎以假乱真的作品。

生成对抗网络是一种深度学习模型，它由两个神经网络相互竞争、共同进化：

  • 生成器：生成数据样本，试图欺骗判别器
  • 判别器：区分真实数据和生成器生成的假数据

1.2 为什么要学习生成对抗网络？

生成对抗网络在很多领域都取得了突破性的进展：

  • 图像生成：生成逼真的图像、艺术作品
  • 视频生成：生成流畅的视频片段
  • 自然语言处理：生成文本、对话
  • 游戏AI：训练智能游戏对手
  • 数据增强：生成用于训练的合成数据

学习生成对抗网络可以让你掌握这些前沿技术，为从事人工智能相关工作打下坚实的基础。

1.3 本教程的目标

在本教程中，我们将：

  • 学习生成对抗网络的基本原理
  • 理解残差块和注意力机制的工作原理
  • 用PyTorch实现一个基于GAN的五子棋对战AI
  • 训练和测试模型，分析结果
  • 实现AI的自我对弈和进化

2. 环境搭建

2.1 WSL Ubuntu安装

首先，我们需要在Windows上安装WSL（Windows Subsystem for Linux）。请按照微软官方文档的步骤进行安装：安装WSL

2.2 GPU驱动安装

要使用GPU加速深度学习，我们需要安装NVIDIA GPU驱动。请从NVIDIA官网下载并安装适合你GPU型号的驱动：NVIDIA驱动下载

2.3 安装Python环境

  1. 升级系统环境

    bash 复制代码 
    sudo apt update && sudo apt -y dist-upgrade

  2. 安装Python 3.12

    bash 复制代码 
    sudo apt -y install --upgrade python3 python3-pip python3.12-venv

  3. 设置国内镜像源（加速下载）

    bash 复制代码 
    pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

2.4 创建虚拟环境

虚拟环境可以隔离不同项目的依赖，避免版本冲突。

  1. 创建项目目录

    bash 复制代码 
    mkdir pytorch-code && cd pytorch-code

  2. 创建并激活虚拟环境

    bash 复制代码 
    python3 -m venv .venv && source .venv/bin/activate

  3. 升级基础依赖

    bash 复制代码 
    python -m pip install --upgrade pip setuptools wheel -i https://pypi.tuna.tsinghua.edu.cn/simple

2.5 安装PyTorch

PyTorch是一个流行的深度学习框架，它提供了丰富的工具和API，方便我们构建和训练深度学习模型。

bash 复制代码 
# 安装PyTorch GPU版本
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

# 安装其他依赖
pip install matplotlib numpy seaborn scikit-learn

2.6 验证安装

安装完成后，我们可以运行以下命令来验证PyTorch和CUDA是否正确安装：

python 复制代码 
import torch
print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA是否可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU型号: {torch.cuda.get_device_name(0)}")
    print(f"CUDA版本: {torch.version.cuda}")

如果输出显示CUDA可用，并且显示了你的GPU型号，说明安装成功！

3. 生成对抗网络原理大白话

3.1 什么是生成对抗网络？

生活场景类比：生成对抗网络就像一个造假者和一个鉴宝师在互相竞争。造假者（生成器）试图制造假文物，鉴宝师（判别器）试图区分真假文物。随着时间的推移，造假者的技艺越来越高超，鉴宝师的眼光也越来越敏锐，最终造假者能制造出几乎以假乱真的文物。

在深度学习中，生成对抗网络由两个神经网络组成：

  • 生成器（Generator）：生成假数据，试图欺骗判别器
  • 判别器（Discriminator）：区分真实数据和生成器生成的假数据

3.2 GAN的基本结构

生活场景类比：GAN就像一个模拟对抗的游戏，生成器和判别器在不断的对抗中共同进步。

graph TD A[真实数据
15×15五子棋棋盘] --> B[判别器
CNN] C[生成器
CNN] --> D[生成的落子位置
15×15概率图] D --> B B --> |损失反馈| E[训练
优化器] E --> |更新参数| B E --> |更新参数| C

3.3 残差块和注意力机制

生活场景类比：残差块就像在建筑中使用的钢筋混凝土结构，它可以增强结构的稳定性和承载能力。注意力机制就像你在阅读时会重点关注文章的关键部分，而不是平均分配注意力。

  • 残差块：解决深层网络的梯度消失问题，允许信息直接从低层传递到高层
  • 注意力机制：让模型能够自动关注重要的特征，提高模型的表现能力

4. 生成对抗网络原理详解

4.1 生成器

生成器负责生成最佳落子位置，它接收当前棋盘状态作为输入，输出一个15×15的概率图，表示每个位置的落子价值。生成器使用了残差块和通道注意力机制，能够捕捉棋盘的复杂特征和长期依赖关系。

4.2 判别器

判别器负责评估落子位置的优劣，它接收当前棋盘状态和落子位置作为输入，输出一个概率值，表示这个落子位置是真实（好）还是假（坏）的。判别器使用了卷积神经网络，能够学习到棋盘的模式和策略。

4.3 训练过程

GAN的训练是一个极小极大博弈过程：

  1. 固定生成器，训练判别器：让判别器能够更好地区分真实落子和生成的落子
  2. 固定判别器，训练生成器：让生成器能够生成更好的落子，欺骗判别器
  3. 重复上述过程，直到收敛

4.4 损失函数

生成对抗网络使用两个损失函数：

  • 判别器损失：衡量判别器区分真假落子的能力
  • 生成器损失：衡量生成器生成的落子能够欺骗判别器的程度

5. 代码实现与解读

5.1 项目结构

我们的项目按照以下结构组织：

复制代码 
module7/
├── model.py          # GAN模型定义（生成器和判别器）
├── game.py           # 五子棋游戏逻辑
├── utils.py          # 工具函数
├── train.py          # 模型训练
├── test.py           # 模型测试
├── models/           # 模型保存目录
└── results/          # 结果可视化目录
代码架构图

model.py
GAN模型定义 train.py
模型训练 test.py
模型测试 game.py
游戏逻辑 utils.py
工具函数 models/
模型保存 results/
结果可视化

代码流程图
flowchart TD A[开始] --> B[初始化游戏
game.py] B --> C[初始化模型
model.py] C --> D[训练模型
train.py] D --> E[保存模型
models/] D --> F[绘制训练曲线
results/] E --> G[测试模型
test.py] F --> G G --> H[生成对战结果
results/] H --> I[结束]

5.2 游戏逻辑实现（game.py）

python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
五子棋游戏逻辑实现

开发思路：
1. 设计一个清晰的棋盘状态表示方法
2. 实现落子、胜负判断等核心游戏逻辑
3. 提供可视化功能，便于调试和观察
4. 支持获取合法走法和棋盘状态

开发过程：
- 首先定义棋盘大小和游戏规则
- 实现落子函数，处理边界条件
- 实现胜负判断，检查所有可能的获胜组合
- 添加棋盘可视化功能
- 实现获取合法走法的功能
"""

import numpy as np
import matplotlib.pyplot as plt

class GobangGame:
    """
    五子棋游戏类，实现游戏逻辑和状态管理
    """
    def __init__(self):
        """初始化游戏
        
        棋盘大小为15×15，使用15×15×2的张量表示棋盘状态
        - 通道0：黑方棋子位置
        - 通道1：白方棋子位置
        """
        # 棋盘大小
        self.board_size = 15
        # 初始化棋盘状态：15×15×2，全0表示空棋盘
        self.board = np.zeros((self.board_size, self.board_size, 2), dtype=np.float32)
        # 当前玩家：0表示黑方，1表示白方
        self.current_player = 0
        # 游戏结束标记
        self.game_over = False
        # 获胜玩家：0表示黑方获胜，1表示白方获胜，-1表示平局
        self.winner = -1
        # 步数计数
        self.step_count = 0
    
    def reset(self):
        """重置游戏状态
        
        将棋盘清空，重置当前玩家和游戏结束标记
        """
        self.board = np.zeros((self.board_size, self.board_size, 2), dtype=np.float32)
        self.current_player = 0
        self.game_over = False
        self.winner = -1
        self.step_count = 0
    
    def is_valid_move(self, row, col):
        """检查落子是否合法
        
        参数：
            row: 行索引
            col: 列索引
            
        返回：
            bool: 落子是否合法
        """
        # 检查坐标是否在棋盘范围内
        if row < 0 or row >= self.board_size or col < 0 or col >= self.board_size:
            return False
        # 检查该位置是否为空（两个通道都为0）
        if np.sum(self.board[row, col]) > 0:
            return False
        # 检查游戏是否已结束
        if self.game_over:
            return False
        return True
    
    def make_move(self, row, col):
        """执行落子
        
        参数：
            row: 行索引
            col: 列索引
            
        返回：
            bool: 落子是否成功
        """
        # 检查落子是否合法
        if not self.is_valid_move(row, col):
            return False
        
        # 在当前玩家的通道上落子
        self.board[row, col, self.current_player] = 1
        # 检查是否获胜
        if self.check_winner(row, col):
            self.game_over = True
            self.winner = self.current_player
        # 检查是否平局（棋盘已满）
        elif self.step_count >= self.board_size * self.board_size - 1:
            self.game_over = True
            self.winner = -1
        # 切换玩家
        self.current_player = 1 - self.current_player
        # 步数加1
        self.step_count += 1
        return True
    
    def check_winner(self, row, col):
        """检查是否有玩家获胜
        
        参数：
            row: 最后落子的行索引
            col: 最后落子的列索引
            
        返回：
            bool: 是否有玩家获胜
        """
        # 获取当前玩家的棋子颜色
        player = 1 - self.current_player  # 因为刚刚切换了玩家，所以需要取反
        
        # 检查水平方向
        count = 1
        # 向左检查
        c = col - 1
        while c >= 0 and self.board[row, c, player] == 1:
            count += 1
            c -= 1
        # 向右检查
        c = col + 1
        while c < self.board_size and self.board[row, c, player] == 1:
            count += 1
            c += 1
        if count >= 5:
            return True
        
        # 检查垂直方向
        count = 1
        # 向上检查
        r = row - 1
        while r >= 0 and self.board[r, col, player] == 1:
            count += 1
            r -= 1
        # 向下检查
        r = row + 1
        while r < self.board_size and self.board[r, col, player] == 1:
            count += 1
            r += 1
        if count >= 5:
            return True
        
        # 检查对角线方向（左上到右下）
        count = 1
        # 左上方向
        r, c = row - 1, col - 1
        while r >= 0 and c >= 0 and self.board[r, c, player] == 1:
            count += 1
            r -= 1
            c -= 1
        # 右下方向
        r, c = row + 1, col + 1
        while r < self.board_size and c < self.board_size and self.board[r, c, player] == 1:
            count += 1
            r += 1
            c += 1
        if count >= 5:
            return True
        
        # 检查对角线方向（右上到左下）
        count = 1
        # 右上方向
        r, c = row - 1, col + 1
        while r >= 0 and c < self.board_size and self.board[r, c, player] == 1:
            count += 1
            r -= 1
            c += 1
        # 左下方向
        r, c = row + 1, col - 1
        while r < self.board_size and c >= 0 and self.board[r, c, player] == 1:
            count += 1
            r += 1
            c -= 1
        if count >= 5:
            return True
        
        return False
    
    def get_valid_moves(self):
        """获取所有合法走法
        
        返回：
            list: 合法走法列表，每个元素是(row, col)元组
        """
        valid_moves = []
        for row in range(self.board_size):
            for col in range(self.board_size):
                if self.is_valid_move(row, col):
                    valid_moves.append((row, col))
        return valid_moves
    
    def get_board_state(self):
        """获取当前棋盘状态
        
        返回：
            tuple: (board, current_player, game_over, winner)
        """
        return self.board.copy(), self.current_player, self.game_over, self.winner
    
    def visualize_board(self):
        """可视化棋盘
        
        使用matplotlib绘制棋盘和棋子
        """
        fig, ax = plt.subplots(figsize=(10, 10))
        
        # 绘制网格线
        for i in range(self.board_size + 1):
            ax.axhline(i - 0.5, color='black', linewidth=0.5)
            ax.axvline(i - 0.5, color='black', linewidth=0.5)
        
        # 绘制棋子
        for row in range(self.board_size):
            for col in range(self.board_size):
                # 黑方棋子（通道0）
                if self.board[row, col, 0] == 1:
                    ax.scatter(col, row, s=200, color='black', marker='o')
                # 白方棋子（通道1）
                elif self.board[row, col, 1] == 1:
                    ax.scatter(col, row, s=200, color='white', edgecolor='black', marker='o')
        
        # 设置坐标轴
        ax.set_xlim(-0.5, self.board_size - 0.5)
        ax.set_ylim(-0.5, self.board_size - 0.5)
        ax.set_xticks(range(self.board_size))
        ax.set_yticks(range(self.board_size))
        ax.set_title(f"Gobang Game - Current Player: {'Black' if self.current_player == 0 else 'White'}")
        ax.invert_yaxis()  # 使(0,0)位于左上角
        
        plt.grid(False)
        plt.show()

# 测试代码
if __name__ == "__main__":
    # 创建游戏实例
    game = GobangGame()
    # 测试落子
    game.make_move(7, 7)  # 黑方在中心点落子
    game.make_move(7, 8)  # 白方在右侧落子
    game.make_move(8, 7)  # 黑方在下方落子
    game.make_move(8, 8)  # 白方在右下角落子
    # 可视化棋盘
    game.visualize_board()
    print(f"当前玩家: {'黑方' if game.current_player == 0 else '白方'}")
    print(f"游戏结束: {game.game_over}")
    print(f"获胜玩家: {game.winner}")

5.3 模型定义（model.py）

python 复制代码 
import torch
import torch.nn as nn

class ResidualBlock(nn.Module):
    """残差块，有助于梯度流动和信息保留"""
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        # 快捷连接，处理通道数变化
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += self.shortcut(x)  # 残差连接
        out = self.relu(out)
        return out

class ChannelAttention(nn.Module):
    """通道注意力机制，增强重要特征"""
    def __init__(self, in_channels, reduction_ratio=16):
        super(ChannelAttention, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(in_channels, in_channels // reduction_ratio, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(in_channels // reduction_ratio, in_channels, bias=False),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)

class Generator(nn.Module):
    def __init__(self, in_channels=3, out_channels=1, hidden_channels=64):
        super(Generator, self).__init__()
        
        # 初始卷积层
        self.initial = nn.Sequential(
            nn.Conv2d(in_channels, hidden_channels, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.BatchNorm2d(hidden_channels)
        )
        
        # 增强的编码器，使用残差块
        self.encoder = nn.Sequential(
            ResidualBlock(hidden_channels, hidden_channels),
            ResidualBlock(hidden_channels, hidden_channels*2, stride=1),
            ChannelAttention(hidden_channels*2),  # 通道注意力
            ResidualBlock(hidden_channels*2, hidden_channels*4, stride=1),
            ChannelAttention(hidden_channels*4),  # 通道注意力
            ResidualBlock(hidden_channels*4, hidden_channels*8, stride=1),
            ChannelAttention(hidden_channels*8),  # 通道注意力
        )
        
        # 增强的解码器，使用残差块
        self.decoder = nn.Sequential(
            ResidualBlock(hidden_channels*8, hidden_channels*4, stride=1),
            ChannelAttention(hidden_channels*4),  # 通道注意力
            ResidualBlock(hidden_channels*4, hidden_channels*2, stride=1),
            ChannelAttention(hidden_channels*2),  # 通道注意力
            ResidualBlock(hidden_channels*2, hidden_channels, stride=1),
            ChannelAttention(hidden_channels),  # 通道注意力
        )
        
        # 输出层
        self.output = nn.Sequential(
            nn.Conv2d(hidden_channels, out_channels, kernel_size=1, stride=1, padding=0),
            nn.Sigmoid()  # 确保输出在0-1之间
        )
    
    def forward(self, x):
        x = self.initial(x)
        features = self.encoder(x)
        out = self.decoder(features)
        out = self.output(out)
        return out

class Discriminator(nn.Module):
    def __init__(self, in_channels=4, hidden_channels=64):
        super(Discriminator, self).__init__()
        self.conv_layers = nn.Sequential(
            nn.Conv2d(in_channels, hidden_channels, kernel_size=3, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),  
            nn.BatchNorm2d(hidden_channels),
            nn.Conv2d(hidden_channels, hidden_channels*2, kernel_size=3, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm2d(hidden_channels*2),
            nn.Conv2d(hidden_channels*2, hidden_channels*4, kernel_size=3, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm2d(hidden_channels*4),
            nn.Conv2d(hidden_channels*4, hidden_channels*8, kernel_size=3, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm2d(hidden_channels*8),
        )
        self.fc_layers = nn.Sequential(
            nn.Flatten(),  
            nn.Linear(hidden_channels*8 * 1 * 1, hidden_channels*4),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.5),  
            nn.Linear(hidden_channels*4, hidden_channels*2),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.5),
            nn.Linear(hidden_channels*2, 1),
            nn.Sigmoid()  
        )
    
    def forward(self, x):
        features = self.conv_layers(x)
        output = self.fc_layers(features)
        return output

if __name__ == "__main__":
    generator = Generator()
    discriminator = Discriminator()
    gen_input = torch.randn(2, 3, 15, 15)
    gen_output = generator(gen_input)
    print(f"生成器输入形状: {gen_input.shape}")
    print(f"生成器输出形状: {gen_output.shape}")
    disc_input = torch.randn(2, 4, 15, 15)
    disc_output = discriminator(disc_input)
    print(f"判别器输入形状: {disc_input.shape}")
    print(f"判别器输出形状: {disc_output.shape}")

6. 脚本执行顺序与作用

6.1 执行顺序

  1. 模型测试 ：运行python model.py，验证模型结构是否正确
  2. 游戏逻辑测试 ：运行python game.py，验证游戏逻辑是否正常
  3. 模型训练 ：运行python train.py，训练GAN模型
  4. 模型测试 ：运行python test.py，测试训练好的模型

6.2 各脚本作用

脚本名 作用 执行命令
model.py 定义GAN模型，包含生成器和判别器 python model.py
game.py 实现五子棋游戏逻辑，包括落子、胜负判断等 python game.py
utils.py 提供工具函数，包括棋盘转换、损失计算等 被train.py和test.py调用
train.py 训练GAN模型，保存最佳模型，绘制训练曲线 python train.py
test.py 测试模型性能，进行AI对战，生成对战结果 python test.py

7. 结果分析与可视化

7.1 训练曲线

训练曲线展示了GAN模型在训练过程中的损失变化：

  • 生成器损失：随着训练轮数的增加，生成器损失逐渐下降，说明生成器生成的落子位置越来越合理
  • 判别器损失：随着训练轮数的增加，判别器损失也逐渐下降，说明判别器的区分能力越来越强

7.2 对战结果

模型训练完成后，我们可以使用test.py脚本进行AI对战，观察AI的表现：

  • AI vs AI：让两个AI相互对战，观察它们的策略和表现
  • AI vs 人类：人类可以与AI对战，测试AI的棋力
  • 自我对弈：AI通过与自己对战不断进化，提高棋力

8. 总结与扩展

8.1 总结

本教程实现了一个基于生成对抗网络的五子棋对战AI，主要内容包括：

  1. 生成对抗网络的基本原理和架构
  2. 残差块和注意力机制的应用
  3. 五子棋游戏逻辑的实现
  4. GAN模型的训练和测试
  5. AI对战和自我对弈

8.2 扩展方向

  1. 模型优化：

    • 使用更复杂的注意力机制，如自注意力
    • 调整模型超参数，如隐藏层维度、学习率等
    • 使用更先进的优化器，如AdamW

  2. 强化学习结合：

    • 结合强化学习方法，如PPO、DQN等
    • 实现更有效的自我对弈机制
    • 添加奖励函数，引导AI学习更好的策略

  3. 多智能体系统：

    • 实现多个不同策略的AI对战
    • 研究AI之间的策略进化和博弈

  4. 部署应用：

    • 将AI部署为网页应用，支持在线对战
    • 集成到游戏引擎中，提供更好的用户体验

通过本教程的学习，你应该已经掌握了生成对抗网络的基本原理和实现方法，可以尝试解决更复杂的生成式AI问题。

相关推荐
TDengine （老段）2 小时前
TDengine IDMP 产品路线图
大数据·数据库·人工智能·ai·时序数据库·tdengine·涛思数据
hoiii1872 小时前
MATLAB中主成分分析（PCA）与相关性分析的实现
前端·人工智能·matlab
不叫猫先生2 小时前
AI Prompt 直达生产级爬虫，Bright Data AI Scraper Studio 让数据抓取更高效
人工智能·爬虫·prompt
老蒋新思维2 小时前
创客匠人启示录：AI 时代知识变现的底层逻辑重构 —— 从峰会实践看创始人 IP 的破局之路
网络·人工智能·网络协议·tcp/ip·数据挖掘·创始人ip·创客匠人
大千AI助手2 小时前
Softmax回归：原理、实现与多分类问题的基石
人工智能·机器学习·分类·数据挖掘·回归·softmax·大千ai助手
机器之心2 小时前
谷歌TPU杀疯了，产能暴涨120%、性能4倍吊打，英伟达还坐得稳吗？
人工智能·openai
币圈菜头3 小时前
GAEA × REVOX 合作 — 共建「情感 AI + Web3 应用」新生态
人工智能·web3·去中心化·区块链
CoovallyAIHub3 小时前
何必先OCR再LLM？视觉语言模型直接读图，让百页长文档信息不丢失
深度学习·算法·计算机视觉
CoovallyAIHub3 小时前
NAN-DETR：集中式噪声机制如何让检测更“团结”？
深度学习·算法·计算机视觉
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04UV安装并设置国内源05React CVE-2025-55182漏洞排查与修复指南06Linux下V2Ray安装配置指南07BongoCat - 跨平台键盘猫动画工具08从入门到实战：Gemini 3 使用指南速览09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10本地部署阿里最新开源的Z-Image