Duplicate from clarenceleo/HonorNet_v1

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 [Tianyi Li]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,121 @@
+# HonorNet 🎮
+
+> 一个基于行为克隆的王者荣耀AI，从零开始，在Mac上训练，在Android模拟器中运行。
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-red.svg)](https://pytorch.org/)
+
+## ✨ 项目简介
+
+**HonorNet** 是一个完全开源的王者荣耀AI项目。它的特点：
+
+- 🍎 **在Mac上训练**：利用Apple Silicon的MPS加速
+- 📱 **控制Android模拟器**：通过ADB截图和发送触摸事件
+- 🧠 **行为克隆**：学习人类玩家的操作数据
+- 🎯 **16个动作空间**：移动8方向 + 技能 + 攻击 + 战术
+- 🔓 **MIT协议**：完全开源，任意使用
+
+这不是一个“调用API”的demo，而是一个**从数据采集到模型训练再到部署**的完整工程。
+
+## 🎯 项目状态
+
+| 阶段 | 状态 |
+|------|------|
+| 数据采集 | ✅ 完成（886帧标注） |
+| 行为克隆训练 | ✅ 完成（验证准确率54.5%） |
+| 模拟器部署 | ✅ 完成 |
+| 强化学习微调 | 🚧 进行中 |
+
+## 🏗️ 项目结构
+
+```
+HonorNet/
+├── data/              # 数据处理脚本
+├── models/            # 模型定义 + 训练
+├── inference/         # 模拟器控制 + AI运行
+├── config.py          # 配置文件
+└── requirements.txt   # 依赖
+```
+
+## 🚀 快速开始
+
+### 1. 环境配置
+
+```bash
+# 克隆仓库
+git lfs clone https://huggingface.co/clarenceleo/HonorNet_v1
+cd HonorNet_v1
+
+# 安装依赖
+pip install -r requirements.txt
+
+# 安装ADB（macOS）
+brew install android-platform-tools
+```
+
+### 2. 准备数据
+
+将王者荣耀1v1录屏放入 `data/raw_videos/`，然后：
+
+```bash
+# 抽帧
+python data/extract_frames.py
+
+# 预处理
+python data/preprocess.py
+
+# 标注动作（可选，我们提供了标注工具）
+python data/annotate.py
+```
+
+### 3. 训练模型
+
+```bash
+python models/train_bc.py
+```
+
+### 4. 让AI打游戏
+
+1. 启动Android模拟器，打开王者荣耀1v1模式
+2. 运行AI：
+
+```bash
+python inference/run_ai.py
+```
+
+## 📊 训练结果
+
+使用886帧标注数据训练50轮：
+
+| 指标 | 数值 |
+|------|------|
+| 最佳验证准确率 | **54.49%** |
+| 随机基线 | 6.25% |
+| 训练准确率 | 95.48% |
+
+**54.5%的准确率意味着AI学会了**：
+- 根据画面判断移动方向
+- 何时普攻、放技能
+- 何时回城、升级
+
+## 🛠️ 技术栈
+
+- **PyTorch**：深度学习框架
+- **ADB**：Android调试桥，控制模拟器
+- **OpenCV**：图像处理
+- **Android Studio AVD**：模拟器运行环境
+
+## 📈 后续计划
+
+- [ ] 强化学习微调（PPO）
+- [ ] 支持更多英雄
+- [ ] 5v5多智能体
+- [ ] 实时学习（边打边学）
+
+## 🤝 贡献
+
+模型开发与训练数据清洗标注：李天祎（1637321445@qq.com）
+训练数据录制与提供：姜懿原
+
+欢迎提交Issue和Pull Request！

config.py

@@ -0,0 +1,47 @@
+# config.py
+import os
+
+# 路径配置
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+RAW_VIDEO_DIR = os.path.join(DATA_DIR, "raw_videos")
+FRAMES_DIR = os.path.join(DATA_DIR, "frames")
+ANNOTATIONS_DIR = os.path.join(DATA_DIR, "annotations")
+PROCESSED_DIR = os.path.join(DATA_DIR, "processed")
+MODEL_DIR = os.path.join(BASE_DIR, "models")
+
+# 创建目录
+os.makedirs(RAW_VIDEO_DIR, exist_ok=True)
+os.makedirs(FRAMES_DIR, exist_ok=True)
+os.makedirs(ANNOTATIONS_DIR, exist_ok=True)
+os.makedirs(PROCESSED_DIR, exist_ok=True)
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+# 图像处理参数
+IMG_HEIGHT = 84
+IMG_WIDTH = 84
+IMG_CHANNELS = 3
+CROP_TOP_RATIO = 0.08   # 裁剪顶部8%（去掉状态栏）
+CROP_BOTTOM_RATIO = 0.05 # 裁剪底部5%（去掉按钮栏）
+
+# 视频抽帧参数
+EXTRACT_FPS = 5  # 每秒抽5帧
+
+# 动作空间（16个动作）
+ACTIONS = [
+    'move_up', 'move_down', 'move_left', 'move_right',
+    'move_upleft', 'move_upright', 'move_downleft', 'move_downright',
+    'attack', 'skill_1', 'skill_2', 'skill_3',
+    'recall', 'heal', 'summoner', 'upgrade'
+]
+
+NUM_ACTIONS = len(ACTIONS)
+
+# 训练参数
+BATCH_SIZE = 64
+LEARNING_RATE = 0.0001
+NUM_EPOCHS = 50
+TRAIN_SPLIT = 0.8
+
+# 设备
+DEVICE = None  # 运行时自动检测

inference/action_mapper.py

@@ -0,0 +1,169 @@
+# inference/action_mapper.py
+import subprocess
+import time
+import io
+from PIL import Image
+
+class GameController:
+    """ADB 游戏控制器"""
+    
+    def __init__(self, device_id="emulator-5554"):
+        self.device_id = device_id
+    
+    def tap(self, x, y):
+        """点击"""
+        cmd = f"adb -s {self.device_id} shell input tap {x} {y}"
+        subprocess.run(cmd, shell=True)
+    
+    def swipe(self, x1, y1, x2, y2, duration=50):
+        """滑动"""
+        cmd = f"adb -s {self.device_id} shell input swipe {x1} {y1} {x2} {y2} {duration}"
+        subprocess.run(cmd, shell=True)
+    
+    def swipe_continuous(self, x1, y1, x2, y2, duration_ms=50):
+        """连续滑动（用于保持移动）"""
+        cmd = f"adb -s {self.device_id} shell input swipe {x1} {y1} {x2} {y2} {duration_ms}"
+        subprocess.run(cmd, shell=True)
+    
+    def screenshot(self):
+        """截图"""
+        cmd = f"adb -s {self.device_id} exec-out screencap -p"
+        output = subprocess.check_output(cmd, shell=True)
+        return Image.open(io.BytesIO(output))
+    
+    def get_screen_size(self):
+        """获取屏幕分辨率"""
+        cmd = f"adb -s {self.device_id} shell wm size"
+        output = subprocess.check_output(cmd, shell=True).decode()
+        size_str = output.split(":")[1].strip()
+        w, h = map(int, size_str.split("x"))
+        return w, h
+
+
+class ActionMapper:
+    """
+    动作映射器 - 使用持续滑动保持移动
+    """
+    
+    def __init__(self, controller):
+        self.ctrl = controller
+        
+        # 按钮坐标
+        self.buttons = {
+            "joystick_center": (448, 861),
+            "attack": (1936, 925),
+            "skill_1": (1723, 750),
+            "skill_2": (1927, 635),
+            "skill_3": (1443, 969),
+            "recall": (1150, 979),
+            "heal": (1283, 979),
+            "summoner": (1443, 969),
+            "upgrade": (1513, 833),
+        }
+        
+        # 移动目标坐标（摇杆应该滑到的位置）
+        self.move_targets = {
+            "up": (448, 741),
+            "down": (448, 981),
+            "left": (328, 861),
+            "right": (568, 861),
+            "upleft": (363, 776),
+            "upright": (533, 776),
+            "downleft": (363, 946),
+            "downright": (533, 946),
+        }
+        
+        # 当前状态
+        self.current_direction = None
+        
+        # 动作映射
+        self.action_to_button = {
+            "attack": "attack",
+            "skill_1": "skill_1",
+            "skill_2": "skill_2",
+            "skill_3": "skill_3",
+            "summoner": "summoner",
+            "recall": "recall",
+            "heal": "heal",
+            "upgrade": "upgrade",
+        }
+    
+    def execute(self, action_name):
+        """
+        执行动作（每帧调用）
+        """
+        # 移动动作
+        if action_name.startswith("move_"):
+            direction = action_name.replace("move_", "")
+            if direction in self.move_targets:
+                self._do_move(direction)
+            return
+        
+        # 停止移动
+        if action_name == "move_stop":
+            self._stop_move()
+            return
+        
+        # 点击动作
+        if action_name in self.action_to_button:
+            button = self.action_to_button[action_name]
+            if button in self.buttons:
+                x, y = self.buttons[button]
+                self.ctrl.tap(x, y)
+    
+    def _do_move(self, direction):
+        """
+        执行移动：每帧都滑动到目标位置
+        这样才能保持英雄持续移动
+        """
+        cx, cy = self.buttons["joystick_center"]
+        tx, ty = self.move_targets[direction]
+        
+        # 每帧都执行滑动，保持摇杆位置
+        self.ctrl.swipe(cx, cy, tx, ty, duration=30)
+        self.current_direction = direction
+    
+    def _stop_move(self):
+        """停止移动：摇杆回中心"""
+        cx, cy = self.buttons["joystick_center"]
+        self.ctrl.swipe(cx, cy, cx, cy, duration=30)
+        self.current_direction = None
+    
+    def attack(self):
+        """普攻"""
+        x, y = self.buttons["attack"]
+        self.ctrl.tap(x, y)
+    
+    def skill_1(self):
+        """技能1"""
+        x, y = self.buttons["skill_1"]
+        self.ctrl.tap(x, y)
+    
+    def skill_2(self):
+        """技能2"""
+        x, y = self.buttons["skill_2"]
+        self.ctrl.tap(x, y)
+    
+    def skill_3(self):
+        """技能3"""
+        x, y = self.buttons["skill_3"]
+        self.ctrl.tap(x, y)
+    
+    def recall(self):
+        """回城"""
+        x, y = self.buttons["recall"]
+        self.ctrl.tap(x, y)
+
+
+if __name__ == "__main__":
+    ctrl = GameController()
+    mapper = ActionMapper(ctrl)
+    
+    print("测试移动...")
+    print("向上移动3秒")
+    for i in range(30):
+        mapper.execute("move_up")
+        time.sleep(0.1)
+    
+    print("停止")
+    mapper.execute("move_stop")

inference/game_controller.py

@@ -0,0 +1,33 @@
+# game_controller.py
+import subprocess
+from PIL import Image
+import io
+
+class GameController:
+    def __init__(self, device_id="emulator-5554"):
+        self.device_id = device_id
+    
+    def screenshot(self):
+        """截图并返回PIL Image对象"""
+        cmd = f"adb -s {self.device_id} exec-out screencap -p"
+        output = subprocess.check_output(cmd, shell=True)
+        img = Image.open(io.BytesIO(output))
+        return img
+    
+    def tap(self, x, y):
+        """点击指定坐标"""
+        cmd = f"adb -s {self.device_id} shell input tap {x} {y}"
+        subprocess.run(cmd, shell=True)
+    
+    def swipe(self, x1, y1, x2, y2, duration=50):
+        """滑动操作"""
+        cmd = f"adb -s {self.device_id} shell input swipe {x1} {y1} {x2} {y2} {duration}"
+        subprocess.run(cmd, shell=True)
+    
+    def get_screen_size(self):
+        """获取屏幕分辨率"""
+        cmd = f"adb -s {self.device_id} shell wm size"
+        output = subprocess.check_output(cmd, shell=True).decode()
+        size_str = output.split(":")[1].strip()
+        w, h = map(int, size_str.split("x"))
+        return w, h

inference/run_ai.py

@@ -0,0 +1,106 @@
+# inference/run_ai.py
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import torch
+import time
+import numpy as np
+from inference.action_mapper import GameController, ActionMapper
+from models.king_ai import KingAI
+from data.preprocess import ImageProcessor
+from config import NUM_ACTIONS, ACTIONS
+
+class AIPlayer:
+    def __init__(self, model_path):
+        # 设备
+        if torch.backends.mps.is_available():
+            self.device = torch.device("mps")
+        elif torch.cuda.is_available():
+            self.device = torch.device("cuda")
+        else:
+            self.device = torch.device("cpu")
+        
+        # 模型
+        self.model = KingAI(num_actions=NUM_ACTIONS).to(self.device)
+        self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.model.eval()
+        
+        # 控制器
+        self.ctrl = GameController()
+        self.mapper = ActionMapper(self.ctrl)
+        self.processor = ImageProcessor()
+        
+        # 动作持续
+        self.current_move = None
+        self.move_remaining = 0
+        self.MOVE_DURATION_FRAMES = 10      # 移动持续10帧
+        
+        self.frame_rate = 10                 # 每秒10帧
+        self.inference_interval = 5          # 每5帧推理一次
+        
+        self.frame_count = 0
+        self.inference_count = 0
+        
+        print(f"✅ AI 加载完成，设备: {self.device}")
+        print(f"移动持续: {self.MOVE_DURATION_FRAMES} 帧 ({self.MOVE_DURATION_FRAMES/self.frame_rate:.1f}秒)")
+    
+    def run(self):
+        print("\n🎮 AI 开始，按 Ctrl+C 停止\n")
+        
+        try:
+            while True:
+                # 每 N 帧推理一次
+                if self.frame_count % self.inference_interval == 0:
+                    # 截图
+                    screen = self.ctrl.screenshot()
+                    screen_np = np.array(screen)
+                    processed = self.processor.preprocess(screen_np)
+                    tensor = torch.from_numpy(processed).unsqueeze(0).to(self.device)
+                    
+                    # 推理
+                    with torch.no_grad():
+                        logits = self.model(tensor)
+                        action_id = torch.argmax(logits, dim=1).item()
+                    
+                    action = ACTIONS[action_id]
+                    self.inference_count += 1
+                    
+                    # 执行动作
+                    if action.startswith("move_"):
+                        # 移动动作：设置持续帧数
+                        self.current_move = action
+                        self.move_remaining = self.MOVE_DURATION_FRAMES
+                        print(f"[{self.inference_count}] {action} (持续{self.MOVE_DURATION_FRAMES}帧)")
+                    else:
+                        # 攻击/技能：立即执行
+                        self.mapper.execute(action)
+                        print(f"[{self.inference_count}] {action}")
+                
+                # 每帧都执行当前移动（保持移动）
+                if self.current_move and self.move_remaining > 0:
+                    self.mapper.execute(self.current_move)
+                    self.move_remaining -= 1
+                    
+                    if self.move_remaining == 0:
+                        # 移动结束，停止
+                        self.mapper.execute("move_stop")
+                        self.current_move = None
+                        print("  移动停止")
+                
+                self.frame_count += 1
+                time.sleep(1.0 / self.frame_rate)
+                
+        except KeyboardInterrupt:
+            self.mapper.execute("move_stop")
+            print(f"\n✅ 停止，共推理 {self.inference_count} 次")
+
+
+if __name__ == "__main__":
+    model_path = "models/best_model.pth"
+    if not os.path.exists(model_path):
+        print(f"❌ 模型不存在: {model_path}")
+        sys.exit(1)
+    
+    ai = AIPlayer(model_path)
+    ai.run()

models/best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:800bf47a5776df6cdcdd45d9a555ba8e0ac7a416467dd0a257871accfe1c0b3a
+size 6765301

models/final_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:589f9b776ca64fb3e2725786b520bd26cf7b207d02d05d5148e8fd2ea2565d49
+size 6765317

models/king_ai.py

@@ -0,0 +1,119 @@
+# models/king_ai.py
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config import NUM_ACTIONS, IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS
+
+class KingAI(nn.Module):
+    """
+    王者荣耀 AI 模型
+    输入: (batch, 3, 84, 84) 游戏画面
+    输出: (batch, NUM_ACTIONS) 动作概率
+    """
+    
+    def __init__(self, num_actions=NUM_ACTIONS):
+        super().__init__()
+        
+        # 卷积层
+        self.conv1 = nn.Conv2d(IMG_CHANNELS, 32, kernel_size=8, stride=4)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)
+        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)
+        
+        # 计算全连接层输入维度
+        self._calculate_fc_dim()
+        
+        # 全连接层
+        self.fc1 = nn.Linear(self.fc_input_dim, 512)
+        self.fc2 = nn.Linear(512, num_actions)
+        
+        self._initialize_weights()
+    
+    def _calculate_fc_dim(self):
+        """计算卷积层输出维度"""
+        with torch.no_grad():
+            dummy = torch.zeros(1, IMG_CHANNELS, IMG_HEIGHT, IMG_WIDTH)
+            x = F.relu(self.conv1(dummy))
+            x = F.relu(self.conv2(x))
+            x = F.relu(self.conv3(x))
+            self.fc_input_dim = x.view(1, -1).shape[1]
+    
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+    
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.relu(self.conv3(x))
+        x = x.view(x.size(0), -1)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+
+class ActorCritic(nn.Module):
+    """
+    Actor-Critic 网络，用于强化学习
+    共享特征层，分别输出动作概率和状态价值
+    """
+    
+    def __init__(self, num_actions=NUM_ACTIONS):
+        super().__init__()
+        
+        self.conv1 = nn.Conv2d(IMG_CHANNELS, 32, 8, stride=4)
+        self.conv2 = nn.Conv2d(32, 64, 4, stride=2)
+        self.conv3 = nn.Conv2d(64, 64, 3, stride=1)
+        
+        # 计算维度
+        with torch.no_grad():
+            dummy = torch.zeros(1, IMG_CHANNELS, IMG_HEIGHT, IMG_WIDTH)
+            x = F.relu(self.conv1(dummy))
+            x = F.relu(self.conv2(x))
+            x = F.relu(self.conv3(x))
+            fc_dim = x.view(1, -1).shape[1]
+        
+        self.fc_shared = nn.Linear(fc_dim, 512)
+        self.actor = nn.Linear(512, num_actions)
+        self.critic = nn.Linear(512, 1)
+        
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+    
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.relu(self.conv3(x))
+        x = x.view(x.size(0), -1)
+        x = F.relu(self.fc_shared(x))
+        
+        action_logits = self.actor(x)
+        value = self.critic(x)
+        
+        return action_logits, value
+
+
+def test_model():
+    """测试模型输出"""
+    model = KingAI()
+    dummy = torch.randn(4, 3, 84, 84)
+    output = model(dummy)
+    print(f"KingAI - 输入: {dummy.shape}, 输出: {output.shape}")
+    print(f"参数量: {sum(p.numel() for p in model.parameters()):,}")
+    
+    ac_model = ActorCritic()
+    logits, values = ac_model(dummy)
+    print(f"ActorCritic - logits: {logits.shape}, values: {values.shape}")
+
+
+if __name__ == "__main__":
+    test_model()

models/train_bc.py

@@ -0,0 +1,109 @@
+# models/train_bc.py
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from config import NUM_EPOCHS, LEARNING_RATE, MODEL_DIR, DEVICE
+from models.king_ai import KingAI
+from data.dataset import get_dataloaders
+
+
+def train():
+    """训练行为克隆模型"""
+    # 检测设备
+    if torch.backends.mps.is_available():
+        device = torch.device("mps")
+        print("✅ 使用 MPS (Apple Silicon GPU) 加速")
+    elif torch.cuda.is_available():
+        device = torch.device("cuda")
+        print("✅ 使用 CUDA (NVIDIA GPU) 加速")
+    else:
+        device = torch.device("cpu")
+        print("⚠️ 使用 CPU 训练")
+    
+    # 加载数据
+    print("\n加载数据...")
+    train_loader, val_loader = get_dataloaders(
+        frames_dir="data/frames/game_01",
+        annotation_file="data/annotations/annotations.json"
+    )
+    
+    # 创建模型
+    model = KingAI().to(device)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5)
+    
+    print(f"\n开始训练 {NUM_EPOCHS} 轮...")
+    print("=" * 50)
+    
+    best_acc = 0.0
+    
+    for epoch in range(NUM_EPOCHS):
+        # 训练阶段
+        model.train()
+        train_loss = 0.0
+        train_correct = 0
+        train_total = 0
+        
+        for images, actions in train_loader:
+            images, actions = images.to(device), actions.to(device)
+            
+            optimizer.zero_grad()
+            outputs = model(images)
+            loss = criterion(outputs, actions)
+            loss.backward()
+            optimizer.step()
+            
+            train_loss += loss.item()
+            _, predicted = torch.max(outputs, 1)
+            train_total += actions.size(0)
+            train_correct += (predicted == actions).sum().item()
+        
+        train_acc = 100 * train_correct / train_total
+        
+        # 验证阶段
+        model.eval()
+        val_loss = 0.0
+        val_correct = 0
+        val_total = 0
+        
+        with torch.no_grad():
+            for images, actions in val_loader:
+                images, actions = images.to(device), actions.to(device)
+                outputs = model(images)
+                loss = criterion(outputs, actions)
+                
+                val_loss += loss.item()
+                _, predicted = torch.max(outputs, 1)
+                val_total += actions.size(0)
+                val_correct += (predicted == actions).sum().item()
+        
+        val_acc = 100 * val_correct / val_total
+        
+        scheduler.step()
+        
+        print(f"Epoch [{epoch+1:3d}/{NUM_EPOCHS}] "
+              f"Train Loss: {train_loss/len(train_loader):.4f} "
+              f"Train Acc: {train_acc:.2f}% | "
+              f"Val Loss: {val_loss/len(val_loader):.4f} "
+              f"Val Acc: {val_acc:.2f}%")
+        
+        # 保存最佳模型
+        if val_acc > best_acc:
+            best_acc = val_acc
+            torch.save(model.state_dict(), os.path.join(MODEL_DIR, "best_model.pth"))
+            print(f"  ✅ 保存最佳模型 (准确率: {val_acc:.2f}%)")
+    
+    # 保存最终模型
+    torch.save(model.state_dict(), os.path.join(MODEL_DIR, "final_model.pth"))
+    print(f"\n🎉 训练完成！最佳验证准确率: {best_acc:.2f}%")
+    print(f"模型保存在: {MODEL_DIR}")
+
+
+if __name__ == "__main__":
+    train()

requirements.txt

@@ -0,0 +1,7 @@
+torch>=2.0.0
+torchvision>=0.15.0
+opencv-python>=4.8.0
+numpy>=1.24.0
+pillow>=10.0.0
+matplotlib>=3.7.0
+jupyter>=1.0.0

tests/test_mapper.py

@@ -0,0 +1,163 @@
+# test_mapper.py
+from inference.game_controller import GameController
+from inference.action_mapper import ActionMapper
+import time
+import os
+
+def test_all_actions():
+    """测试所有动作映射"""
+    ctrl = GameController()
+    mapper = ActionMapper(ctrl)
+    
+    print("=" * 50)
+    print("王者荣耀AI控制测试 - 全面测试")
+    print("=" * 50)
+    
+    # 1. 测试移动（8个方向）
+    print("\n[1/4] 测试移动控制...")
+    moves = [
+        "move_up", "move_down", "move_left", "move_right",
+        "move_upleft", "move_upright", "move_downleft", "move_downright"
+    ]
+    
+    for move in moves:
+        print(f"  执行: {move}")
+        mapper.execute(move)
+        time.sleep(0.5)  # 每个动作间隔0.5秒
+    
+    # 2. 测试战斗技能
+    print("\n[2/4] 测试战斗技能...")
+    combat_actions = ["attack", "skill_damage", "skill_control"]
+    
+    for action in combat_actions:
+        print(f"  执行: {action}")
+        mapper.execute(action)
+        time.sleep(0.8)
+    
+    # 3. 测试战术动作
+    print("\n[3/4] 测试战术动作...")
+    tactical_actions = ["recall", "heal", "summoner", "enhance", "upgrade"]
+    
+    for action in tactical_actions:
+        print(f"  执行: {action}")
+        mapper.execute(action)
+        time.sleep(0.8)
+    
+    # 4. 测试截图功能
+    print("\n[4/4] 测试截图功能...")
+    try:
+        img = ctrl.screenshot()
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        filename = f"screenshot_{timestamp}.png"
+        img.save(filename)
+        print(f"  截图已保存: {filename}")
+        
+        # 获取屏幕尺寸
+        w, h = ctrl.get_screen_size()
+        print(f"  屏幕尺寸: {w}x{h}")
+        
+        # 显示截图信息
+        print(f"  图片尺寸: {img.size}")
+        print(f"  图片模式: {img.mode}")
+        
+    except Exception as e:
+        print(f"  截图失败: {e}")
+    
+    print("\n" + "=" * 50)
+    print("测试完成！")
+    print("=" * 50)
+
+def test_single_action():
+    """交互式测试单个动作"""
+    ctrl = GameController()
+    mapper = ActionMapper(ctrl)
+    
+    print("\n=== 交互式测试模式 ===")
+    print("可用动作:")
+    print("  移动: up, down, left, right, upleft, upright, downleft, downright")
+    print("  战斗: attack, damage, control")
+    print("  战术: recall, heal, summoner, enhance, upgrade")
+    print("  其他: screenshot, quit")
+    print("-" * 40)
+    
+    while True:
+        cmd = input("\n请输入动作: ").strip().lower()
+        
+        if cmd == 'quit':
+            print("退出测试")
+            break
+        elif cmd == 'screenshot':
+            try:
+                img = ctrl.screenshot()
+                filename = "manual_screenshot.png"
+                img.save(filename)
+                print(f"截图已保存: {filename}")
+            except Exception as e:
+                print(f"截图失败: {e}")
+        elif cmd in ['up', 'down', 'left', 'right', 'upleft', 'upright', 'downleft', 'downright']:
+            action = f"move_{cmd}"
+            print(f"执行: {action}")
+            mapper.execute(action)
+        elif cmd in ['attack', 'damage', 'control']:
+            if cmd == 'damage':
+                action = 'skill_damage'
+            elif cmd == 'control':
+                action = 'skill_control'
+            else:
+                action = cmd
+            print(f"执行: {action}")
+            mapper.execute(action)
+        elif cmd in ['recall', 'heal', 'summoner', 'enhance', 'upgrade']:
+            print(f"执行: {cmd}")
+            mapper.execute(cmd)
+        else:
+            print(f"未知动作: {cmd}")
+        
+        time.sleep(0.3)
+
+def test_with_delay():
+    """带延迟的循环测试（用于观察）"""
+    ctrl = GameController()
+    mapper = ActionMapper(ctrl)
+    
+    print("\n=== 自动循环测试模式 ===")
+    print("将依次执行所有动作，每个动作间隔1秒")
+    print("按 Ctrl+C 停止\n")
+    
+    actions = [
+        # 移动
+        "move_up", "move_down", "move_left", "move_right",
+        "move_upleft", "move_upright", "move_downleft", "move_downright",
+        # 战斗
+        "attack", "skill_damage", "skill_control",
+        # 战术
+        "recall", "heal", "summoner", "enhance", "upgrade"
+    ]
+    
+    try:
+        for i, action in enumerate(actions, 1):
+            print(f"[{i}/{len(actions)}] {action}")
+            mapper.execute(action)
+            time.sleep(1)  # 每个动作间隔1秒
+            
+        print("\n循环测试完成")
+    except KeyboardInterrupt:
+        print("\n用户中断测试")
+
+if __name__ == "__main__":
+    print("选择测试模式:")
+    print("1. 全面测试（一次执行所有动作）")
+    print("2. 交互式测试（手动输入动作）")
+    print("3. 循环测试（自动循环，可观察）")
+    
+    choice = input("\n请选择 (1/2/3): ").strip()
+    
+    if choice == '1':
+        test_all_actions()
+    elif choice == '2':
+        test_single_action()
+    elif choice == '3':
+        test_with_delay()
+    else:
+        print("无效选择，运行全面测试")
+        test_all_actions()