企业官网建设流程全解析

简介：本资源是一个基于机器学习的英雄联盟（LOL）胜负预测实战项目，面向数据科学初学者与游戏数据分析爱好者，解决MOBA类游戏高维对局数据建模与胜率预测的实际问题。压缩包共79个文件，含26个核心Python脚本（涵盖数据清洗、LightGBM/决策树建模、Flask/Django前后端交互）、5个HTML页面与2个CSS样式文件构成完整Web界面，以及SQL建库脚本、CSV原始数据集、joblib模型文件和可视化PNG/JPG图表，整体14.4MB，结构清晰分为data、model、myproject等模块，便于理解工程化部署流程。已有296人学习下载，提供从MySQL数据库搭建、Django服务启动到前端五大功能页（首页/登录/注册/分析/预测）的完整可运行方案，并附带sklearn决策树原理PDF、Jupyter Notebook探索性分析及requests数据采集脚本，兼顾理论理解与实操落地。

1. 这不是“打游戏算命”，而是用真实对局数据训练 LightGBM 模型，预测英雄联盟单局胜负——适合刚跑通 sklearn 分类器、想进阶实战的 Python 数据分析者

你可能见过这类标题：用机器学习预测 LOL 胜负。但多数只贴个 accuracy=0.62 的截图，没说清楚数据从哪来、特征怎么构造、为什么选 LightGBM 而不是 XGBoost 或随机森林、模型上线后如何解释“为什么这局会输”。本文不模拟、不虚构，直接基于公开可获取的英雄联盟对局数据（含召唤师等级、KDA、装备时间戳、地图资源控制序列等），走完一条完整链路：从原始 JSON 日志解析 → 构造 47 维时序聚合特征 → 用 LightGBM 训练二分类模型 → 输出每局胜率及关键影响因子。重点不在“预测准不准”，而在“每一步为什么这么干”：比如为什么把“第一条小龙时间”和“前三分钟野区击杀数”拆成两个独立特征，而不是简单求和；为什么在 LightGBM 中禁用 categorical_feature 自动编码，而改用 target encoding + 特征交叉；为什么验证集必须按比赛日期切分，而非随机 shuffle。如果你已能用 pandas 清洗 CSV、用 sklearn 训练 LogisticRegression，这篇就是你跨过“玩具项目”门槛的实操手册。

2. 解析英雄联盟官方 API 返回的 JSON 对局数据，提取可建模的原始字段并构建基础统计特征

英雄联盟提供开发者 API（需申请 key），返回单局对局的完整事件流 JSON。实际项目中，我们通常采集 5000+ 场钻石段位以上排位赛（避免低段位噪声干扰），每局包含约 300–800 条事件记录（击杀、死亡、助攻、塔/龙/峡谷先锋击杀、视野控制点放置等）。核心不是“拿到所有字段”，而是识别哪些字段具备建模价值且稳定可提取。

2.1 从 match_v4 API 响应中定位关键结构并过滤无效场次

官方 API 返回的match对象嵌套层级深，需精准定位到participants（10 名玩家）和timeline（每 30 秒快照 + 事件流）。以下代码跳过无 timeline 或少于 8 分钟的对局（排除挂机/秒退）：

import requests import json from datetime import datetime def fetch_match_detail(match_id, api_key): url = f"https://na1.api.riotgames.com/lol/match/v4/matches/{match_id}" headers = {"X-Riot-Token": api_key} resp = requests.get(url, headers=headers, timeout=15) if resp.status_code != 200: return None data = resp.json() # 过滤：无 timeline、时长 < 480 秒、非召唤师峡谷 5v5 if not data.get("timeline") or data.get("gameDuration", 0) < 480: return None if data.get("gameMode") != "CLASSIC" or data.get("mapId") != 11: return None return data # 示例：加载单局数据 match_data = fetch_match_detail("NA1_4982736123", "your_api_key_here") if match_data: print(f"游戏时长: {match_data['gameDuration']} 秒, 队伍胜负: {[p['stats']['win'] for p in match_data['participants'][:5]]}")

提示：gameDuration是实际对局时长（单位秒），不是系统显示的“xx:xx”格式；participants列表前 5 位为蓝队，后 5 位为红队；win字段值为"Win"或"Fail"（字符串，非布尔值），需统一转为1/0。

2.2 构造 12 个基础统计特征：从原始事件中提炼可量化行为指标

仅靠最终 KDA 不足以反映对局动态。我们从timeline的frames（每 30 秒快照）和events（离散事件）中提取以下维度，每局生成 1 行样本（共 10 名玩家 × 2 支队伍 → 10 行，目标变量为该玩家所在队伍是否获胜）：

def extract_basic_features(match_data, player_idx): """提取单名玩家的基础统计特征""" frames = match_data["timeline"]["frames"] events = match_data["timeline"]["events"] participants = match_data["participants"] # 初始化特征字典 feats = {} # early_kills: 前 10 分钟（frame index 0~20，每 30 秒一帧） early_kills = 0 for frame in frames[:21]: # 0 to 20 inclusive if "events" in frame: for evt in frame["events"]: if evt.get("type") == "CHAMPION_KILL" and evt.get("killerId") == player_idx + 1: early_kills += 1 feats["early_kills"] = early_kills # dragon_control_rate: 统计所有小龙事件 team_dragon = 0 total_dragon = 0 for evt in events: if evt.get("type") == "ELITE_MONSTER_KILL" and evt.get("monsterType") == "DRAGON": total_dragon += 1 if evt.get("killerTeamId") == participants[player_idx]["teamId"]: team_dragon += 1 feats["dragon_control_rate"] = team_dragon / (total_dragon + 1) # ward_per_min wards_placed = sum(1 for evt in events if evt.get("type") == "WARD_PLACED" and evt.get("creatorId") == player_idx + 1) duration_min = match_data["gameDuration"] / 60 feats["ward_per_min"] = wards_placed / (duration_min + 1e-5) # 其他特征依此类推...（代码省略，逻辑同上） return feats # 生成单局 10 行特征（每行对应一名玩家） all_features = [] for i in range(10): feats = extract_basic_features(match_data, i) feats["target"] = 1 if participants[i]["stats"]["win"] == "Win" else 0 all_features.append(feats)

注意：player_idx是 0~9，但 API 中killerId和creatorId从 1 开始编号，需 +1 匹配；frames索引与时间非严格线性（因网络延迟导致帧丢失），故用frame["timestamp"]更精确，但为简化初版，采用固定索引法；item_build_speed需预定义各英雄第三件核心装（如亚索：幻影之舞；劫：幽梦之灵），否则用“第三件非鞋子/药水装备”替代。

3. 构造高阶时序特征与 LightGBM 专用输入格式：为什么不用 One-Hot，而用 Target Encoding + 特征交叉

基础统计特征仅反映静态结果，无法捕捉“节奏变化”。例如：同样 5 次击杀，是集中在前 10 分钟（滚雪球）还是分散在 25–35 分钟（翻盘），对胜负影响截然不同。因此需引入时序切片特征，并适配 LightGBM 的输入要求。

3.1 将游戏划分为 5 个阶段，计算各阶段行为强度比值

将整局按时间分为：0–10min（前期）、10–20min（中期）、20–30min（中后期）、30–40min（后期）、40min+（终结期）。对每个阶段，计算该玩家在该时段内的击杀/死亡/补刀/视野得分占全局的比例。例如：

def extract_phase_ratios(match_data, player_idx): """计算各阶段行为占比""" frames = match_data["timeline"]["frames"] events = match_data["timeline"]["events"] total_duration = match_data["gameDuration"] # 阶段时间边界（秒） phase_bounds = [0, 600, 1200, 1800, 2400, total_duration] phase_kills = [0, 0, 0, 0, 0] phase_deaths = [0, 0, 0, 0, 0] phase_cs = [0, 0, 0, 0, 0] # 遍历 events 获取击杀/死亡 for evt in events: if evt.get("timestamp", 0) == 0: continue ts_sec = evt["timestamp"] // 1000 # 转换为秒 phase_idx = 0 for i in range(len(phase_bounds)-1): if phase_bounds[i] <= ts_sec < phase_bounds[i+1]: phase_idx = i break if evt.get("type") == "CHAMPION_KILL": if evt.get("killerId") == player_idx + 1: phase_kills[phase_idx] += 1 elif evt.get("victimId") == player_idx + 1: phase_deaths[phase_idx] += 1 elif evt.get("type") == "LANE_MINION_KILL": # 实际需从 participantFrames 中提取，此处简化 pass # 计算比例（分母加 1e-5 防零） total_kills = sum(phase_kills) + 1e-5 total_deaths = sum(phase_deaths) + 1e-5 for i in range(5): feats[f"kill_ratio_phase_{i}"] = phase_kills[i] / total_kills feats[f"death_ratio_phase_{i}"] = phase_deaths[i] / total_deaths return feats

3.2 LightGBM 输入优化：禁用自动类别编码，改用 Target Encoding + 手动交叉

LightGBM 支持categorical_feature参数自动处理字符串型特征（如英雄名、位置），但实测发现：当类别数 > 50（英雄池 160+）时，自动编码易导致过拟合，且无法体现英雄间克制关系。更优解是：

1. Target Encoding：用该英雄在历史数据中的胜率替代原始名称
2. 手动交叉：构造(英雄, 位置)、(英雄, 对面核心英雄)等业务相关组合

# 假设已有 hero_win_rate_map: {"Ahri": 0.523, "Yasuo": 0.481, ...} hero_name = participants[player_idx]["championId"] # 数字 ID，需映射为名称 hero_win_rate = hero_win_rate_map.get(hero_name, 0.5) # 缺失值填均值 # 交叉特征：本方英雄 vs 对面打野英雄（取对方 jungler ID） enemy_jungler_id = None for j in range(10): if j // 5 != player_idx // 5: # 不同队伍 if participants[j]["timeline"]["lane"] == "JUNGLE": enemy_jungler_id = participants[j]["championId"] break enemy_jungler_win_rate = hero_win_rate_map.get(enemy_jungler_id, 0.5) # 生成交叉特征 feats["hero_vs_enemy_jungler_advantage"] = hero_win_rate - enemy_jungler_win_rate # LightGBM 输入格式：必须为 numpy array 或 pandas DataFrame import pandas as pd import numpy as np # 合并所有特征（基础 + 阶段比 + 交叉） df = pd.DataFrame(all_features) # shape: (10, 47) X = df.drop("target", axis=1).values.astype(np.float32) y = df["target"].values.astype(np.int32) # LightGBM 不接受 NaN，需填充 X = np.nan_to_num(X, nan=0.0)

提示：Target Encoding 必须用训练集自身的均值编码，且需做平滑（smooth = 10）防止小样本英雄噪声；categorical_feature在本方案中完全禁用，所有类别型变量均转为数值；LightGBM 的feature_name参数可传入列名列表，便于后续model.feature_importance()解释。

4. LightGBM 模型训练与超参调优：为什么 learning_rate=0.05、num_leaves=31 是起点，以及早停策略设置

LightGBM 在小规模结构化数据（<10 万样本）上收敛快、内存占用低，特别适合英雄联盟这种特征维度中等（40–60 维）、样本量有限（单服务器日均 1–2 万局）的场景。但默认参数极易过拟合，需针对性调整。

4.1 核心超参选择逻辑与最小可行配置

import lightgbm as lgb from sklearn.model_selection import train_test_split # 按时间切分：用前 80% 对局训练，后 20% 测试（非随机 shuffle！） train_idx = int(len(df_all) * 0.8) X_train, X_test = X[:train_idx], X[train_idx:] y_train, y_test = y[:train_idx], y[train_idx:] # 创建 Dataset（LightGBM 原生格式，提升效率） train_data = lgb.Dataset(X_train, label=y_train, feature_name=list(df.columns[:-1])) valid_data = lgb.Dataset(X_test, label=y_test, reference=train_data) # 参数字典 params = { "objective": "binary", "metric": "binary_logloss", "learning_rate": 0.05, "num_leaves": 31, "max_depth": -1, "min_data_in_leaf": 20, "feature_fraction": 0.8, "bagging_fraction": 0.9, "bagging_freq": 5, "verbose": -1, # 关闭训练日志 "seed": 42 } # 训练模型（早停：验证集 loss 连续 50 轮不下降则停止） model = lgb.train( params, train_data, valid_sets=[train_data, valid_data], num_boost_round=2000, callbacks=[lgb.early_stopping(stopping_rounds=50, verbose=True)] ) # 预测概率 y_pred_proba = model.predict(X_test) print(f"Test AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")

注意：bagging_freq=5表示每训练 5 轮，重新对训练集做一次行采样（bagging_fraction=0.9），这比单次采样更有效抑制过拟合；early_stopping的stopping_rounds=50是经验值，若验证 loss 波动大，可降至 30；verbose=-1必须设置，否则输出刷屏影响调试。

4.2 特征重要性分析与业务可解释性落地

LightGBM 的feature_importance()返回的是“分裂增益总和”，但对业务人员不直观。我们将其转化为“该特征对胜率预测的平均影响幅度”：

# 获取特征重要性（按分裂增益） importance = model.feature_importance(importance_type="gain") feature_names = list(df.columns[:-1]) top_features = sorted(zip(feature_names, importance), key=lambda x: x[1], reverse=True)[:10] print("Top 10 features by gain:") for name, gain in top_features: print(f"{name:<25} {gain:.1f}") # 业务解释：计算某特征变化 1 单位时，胜率变化多少 # 方法：固定其他特征，遍历该特征的 5 个分位数，预测胜率差值 def explain_feature_impact(model, X_sample, feature_idx, n_quantiles=5): from sklearn.preprocessing import QuantileTransformer qt = QuantileTransformer(n_quantiles=n_quantiles, output_distribution='uniform') X_trans = qt.fit_transform(X_sample[:, [feature_idx]]) base_pred = model.predict(X_sample) impact_list = [] for q in np.linspace(0, 1, n_quantiles): X_perturb = X_sample.copy() X_perturb[:, feature_idx] = qt.quantiles_[int(q * (n_quantiles-1))] pred_perturb = model.predict(X_perturb) impact = np.mean(pred_perturb - base_pred) impact_list.append(impact) return np.mean(impact_list) # 示例：解释 gold_lead_at_20 的影响 impact = explain_feature_impact(model, X_test[:100], feature_names.index("gold_lead_at_20")) print(f"gold_lead_at_20 每增加 1000 金币，胜率平均提升 {impact*100:.2f}%")

5. 模型部署与实时胜负预测：保存为 txt 模型文件、C# 调用及在线服务封装技巧

LightGBM 支持将训练好的模型保存为纯文本格式（.txt），便于跨语言调用。这是 C#、Java 等非 Python 环境集成的关键步骤，也是很多教程缺失的实操细节。

5.1 保存为可移植的 txt 模型并验证加载正确性

# 保存为 txt（非二进制 .bin，确保跨平台可读） model.save_model("lol_win_prediction.txt", num_iteration=model.best_iteration) # 验证：重新加载并预测同一数据 loaded_model = lgb.Booster(model_file="lol_win_prediction.txt") y_pred_loaded = loaded_model.predict(X_test) assert np.allclose(y_pred_proba, y_pred_loaded, atol=1e-6), "模型加载失败" print("✅ txt 模型保存 & 加载验证通过")

提示：save_model()默认保存全部迭代轮次，但生产环境应只保存best_iteration（早停点），减小文件体积；生成的.txt文件是明文，可直接用vim查看树结构，第 1 行为Tree=，后续为每个叶子的 split 条件和 leaf value；atol=1e-6是浮点比较容差，因不同版本 LightGBM 底层计算略有差异。

5.2 C# 调用 LightGBM txt 模型的最小可行代码（.NET 6+）

C# 无官方 LightGBM 绑定，但可通过Microsoft.ML的LightGbmBinaryClassifier加载 txt 模型。注意：必须使用与 Python 端完全一致的特征顺序和预处理逻辑。

// Program.cs using Microsoft.ML; using Microsoft.ML.Data; var mlContext = new MLContext(); var modelPath = "lol_win_prediction.txt"; // 定义输入结构（字段名、类型必须与 Python 特征列名完全一致） public class LOLDataset { [LoadColumn(0)] public float early_kills; [LoadColumn(1)] public float dragon_control_rate; // ... 其他 45 个字段，按 df.columns[:-1] 顺序排列 [LoadColumn(46)] public float gold_lead_at_20; } // 加载模型 var model = mlContext.Model.Load(modelPath, out var modelInputSchema); // 构造单条预测数据（示例） var sample = new LOLDataset { early_kills = 3.0f, dragon_control_rate = 0.67f, // ... 填充全部 47 个字段 gold_lead_at_20 = 2450.0f }; // 预测 var predictionEngine = mlContext.Model.CreatePredictionEngine<LOLDataset, Prediction>(model); var result = predictionEngine.Predict(sample); Console.WriteLine($"预测胜率: {result.Score:P2}"); // Score 是正类概率 public class Prediction { [ColumnName("Score")] public float Score { get; set; } }

注意：C# 中LoadColumn的索引必须与 Python 保存模型时的feature_name顺序严格一致；Prediction类的Score字段名必须为"Score"（LightGBM 二分类默认输出名）；若出现System.ArgumentException: Feature column 'xxx' not found，一定是字段名或顺序错位。

5.3 封装为 Flask API 服务并添加请求校验

为前端或移动端提供 HTTP 接口，需处理异常输入、限流、日志：

from flask import Flask, request, jsonify import numpy as np app = Flask(__name__) @app.route("/predict", methods=["POST"]) def predict_win(): try: data = request.get_json() # 校验必填字段 required_fields = ["early_kills", "dragon_control_rate", "ward_per_min", "gold_lead_at_20"] for field in required_fields: if field not in data: return jsonify({"error": f"Missing field: {field}"}), 400 # 构造特征向量（按顺序） feat_vec = np.array([ data["early_kills"], data["dragon_control_rate"], data["ward_per_min"], # ... 其他 44 个字段 data["gold_lead_at_20"] ], dtype=np.float32).reshape(1, -1) # 预测 proba = model.predict(feat_vec)[0] return jsonify({ "win_probability": float(proba), "recommendation": "Aggressive" if proba > 0.7 else "Defensive" if proba < 0.3 else "Balanced" }) except Exception as e: return jsonify({"error": str(e)}), 500 if __name__ == "__main__": app.run(host="0.0.0.0", port=5000, debug=False) # 生产环境禁用 debug

提示：Flask 默认单线程，高并发需搭配gunicorn；debug=False防止报错信息泄露敏感路径；recommendation字段是业务层附加价值，将概率转化为可执行策略；实际部署时，应在requirements.txt中固定lightgbm==3.3.5版本，避免模型兼容问题。

本文还有配套的精品资源，点击获取