企业官网建设流程全解析

简介：这是一份围绕双色球历史开奖数据开展的机器学习实战包，面向具备Python基础、希望练习数据预处理、特征工程与分类建模的读者，也适合作为彩票数据探索的课程案例。压缩包共29个文件、约181KB，以16个Python脚本为主体，配合SQL建库脚本、依赖与配置文件、训练日志、示意图及说明文档，覆盖数据抓取入库、清洗转换、模型训练评估和结果记录等环节。已有385人学习，说明其在入门级数据项目中有一定参考价值。读者可据此梳理从原始开奖数据到特征构造、模型选择与调参的完整流程，观察TensorFlow、PyTorch与NumPy等脚本的组织方式，并借鉴日志与图表留存实验结果的思路；同时需理性看待彩票结果的随机性，将预测视为方法练习而非稳定中奖工具。

1. 开奖数据上的机器学习：先把「能预测」这个念头放下

有人把几年的开奖历史丢进模型，训练集准确率刷到 92%，兴奋了半宿；换成下一期真实数据，红球一个没沾上。这个 zip 做的是同一件事——用机器学习分析双色球开奖数据，但它真正的价值不在「算号码」这件玄学事上，而在一条完整的时序分类工程链路：原始 CSV 清洗、特征构造、多模型对比、逐期回测、结果可视化。适合两类人：手里有真实表格数据、想把 scikit-learn 从 fit 到 backtest 走一遍的初学者；以及想看看别人怎么把「预测」这种没有标准答案的问题，拆成有基线、有口径、可复现实验的老手。跑通它十分钟够，读懂它的评估口径要半小时，这两步之间的差距，就是这份资源最值得看的地方。

2. 项目定位与技术栈：解压后先认路，再谈模型

拿到一个陌生 zip，我一般不急着python train.py。先看目录，判断作者是把代码堆在一起，还是分了层；再看requirements.txt，判断这套东西在谁的机器上跑过。这两眼下去，项目大概什么水平就有数了。

2.1 目录结构：每个文件负责哪一段

这类项目解压后通常长成下面这样，命名可能不同，但职责划分大同小异。真正决定你能不能二次开发的，是features.py和backtest.py这两个文件的边界干不干净。

一个判断标准：如果train.py里出现了pd.read_csv和一堆df["红球1"] + df["红球2"]这种计算，说明特征逻辑散在训练脚本里了。这种结构你改一个特征要动三个文件，早晚翻车。合格的写法是features.py只吐一个宽表，train.py只认这个宽表，谁也不越界。

2.2 技术栈：为什么是 pandas + scikit-learn 这一套

依赖基本固定在这么几个上，版本号各家不同，但组合很稳定：

pandas>=1.5 # 表格清洗和滚动窗口 numpy>=1.23 # 向量化算和值、跨度、奇偶 scikit-learn>=1.1 # 逻辑回归、随机森林、时序切分 matplotlib>=3.5 # 走势图、遗漏图、命中率曲线 joblib>=1.2 # 模型落盘 pyyaml>=6.0 # 配置文件

不用深度学习框架，不是作者不会，是这个问题不值得。样本量摆在那里：一周开三期，一年一百五十多期，攒十年也就一千五百多条。这个量级上 LSTM 的参数比样本还多，训练集 loss 能压到很低，测试集该多少还是多少，典型的黑匣子自嗨。相比之下逻辑回归和浅层随机森林有两个好处：训练三秒出结果，可以反复试特征；特征贡献能看，哪个特征在捣乱一目了然。

我一般会把模型层做成可替换的，build_model(kind)里用字符串分发，这样后面想接 XGBoost 或者 LightGBM，加一个分支就行，不用动上层调用。多输出这块，红球的 33 个号码当成 33 个独立的二分类问题，直接用MultiOutputClassifier包一层，简单粗暴但够用。

2.3 十分钟跑通：环境、依赖与三条命令

先把环境隔开，别往系统 Python 里装：

# 1) 建虚拟环境 python -m venv .venv source .venv/bin/activate # Windows 用 .venv\Scripts\activate # 2) 装依赖 pip install -r requirements.txt # 3) 三步分开跑，出问题好定位 python -m src.features --config configs/base.yaml python -m src.train --config configs/base.yaml python -m src.backtest --config configs/base.yaml --start 800

三步拆开是有讲究的。features单独跑，你能立刻打开data/processed/features.parquet看列名对不对、有没有整列 NaN；train单独跑，你能看到交叉验证的分数和耗时；backtest单独跑，你能改--start反复试不同的回测起点，而不用重训模型。第一次跑建议就用默认配置，先确认能出数，再谈调参。

--start 800这个参数的意思是：前 800 期只当训练集滚进去，不参与评估。原因是特征里有「近 30 期出现次数」「遗漏值」这类滚动统计，期数太少的时候这些列全是噪声，评估出来的分数没有参考价值。等你数据集短于 800 期，就把它调成总期数的六成左右。

跑完你会拿到两类东西：models/下几个.pkl，和reports/backtest_*.csv里逐期的命中明细。后者才是重点，前者只是个中间产物。

提示：第一次跑之前先备份data/raw/。有些脚本会原地做去重和排序，写回同一个文件，出了问题原始数据就没了。

3. 数据管线：从一张开奖表到 30 多维特征矩阵

这个项目八成的工程量在特征上，模型只占两成。原因很直接：开奖数据本身只有 7 个数字，任何模型直接吃这 7 个原始列都学不到东西，必须靠人工把「结构信息」摊开成几十维，模型才有东西可抓。

3.1 原始表的字段与清洗规则

原始表通常是这个形态：期号、开奖日期、红球1 到红球6、蓝球。看着干净，实际脏的地方不少——编码是 GBK 的、列名里混了全角空格、某些期红球没排序、偶尔有重复期号。

import pandas as pd RAW_COLS = ["期号", "开奖日期", "红球1", "红球2", "红球3", "红球4", "红球5", "红球6", "蓝球"] def load_draws(path: str) -> pd.DataFrame: # 历史数据多为 GBK，按 utf-8 -> gbk 顺序回退 for enc in ("utf-8-sig", "utf-8", "gbk"): try: df = pd.read_csv(path, encoding=enc) break except UnicodeDecodeError: continue else: raise RuntimeError(f"三种编码都读不动: {path}") # 列名去空格（含全角空格），这一步不做后面 df["红球1"] 直接 KeyError df.columns = [c.replace("\u3000", "").strip() for c in df.columns] df = df[RAW_COLS].copy() df["开奖日期"] = pd.to_datetime(df["开奖日期"], errors="coerce") reds = [f"红球{i}" for i in range(1, 7)] for c in reds + ["蓝球"]: df[c] = pd.to_numeric(df[c], errors="coerce").astype("Int64") # 丢掉缺号、重复期号 df = df.dropna(subset=reds + ["蓝球", "开奖日期"]) df = df.drop_duplicates(subset="期号").sort_values("开奖日期").reset_index(drop=True) # 值域校验：红球必须在 1..33，蓝球在 1..16，越界的行直接扔 ok = df[reds].apply(lambda s: s.between(1, 33)).all(axis=1) ok &= df["蓝球"].between(1, 16) return df.loc[ok].reset_index(drop=True)

逻辑上就三件事：统一编码、统一类型、统一排序。astype("Int64")用大写 I 是有原因的，小写int64不允许有空值，pd.to_numeric(errors="coerce")一产生 NaN 就会整列变 float，后面做集合运算会得到{1.0, 2.0}这种奇怪的东西。errors="coerce"的作用是把脏值转成 NaN 而不是直接抛异常，配合后面的dropna一起用。

清洗完记得做一次自检：每期红球是否严格递增、有没有重复号。这两条任一不满足，说明数据来源本身就有问题，先别往下走。

3.2 特征工程：7 个球怎么摊成 30 多维

特征分四组，每组解决一类问题。基础统计描述「这期号码的整体形状」，结构特征描述「号码的分布规律」，时序特征描述「和上期、上上期的关系」，频率特征描述「最近哪些号码热」。

import numpy as np import pandas as pd def build_features(df: pd.DataFrame, window: int = 30) -> pd.DataFrame: reds = [f"红球{i}" for i in range(1, 7)] mat = df[reds].to_numpy(dtype="int16") # (n, 6) out = pd.DataFrame(index=df.index) # --- 基础统计 --- out["sum"] = mat.sum(axis=1) # 和值，理论范围 21..183 out["span"] = mat.max(axis=1) - mat.min(axis=1) # 跨度 out["mean"] = mat.mean(axis=1) out["std"] = mat.std(axis=1) # --- 结构特征 --- out["odd_cnt"] = (mat % 2 == 1).sum(axis=1) # 奇数个数 0..6 out["big_cnt"] = (mat >= 17).sum(axis=1) # 大号个数 out["zone1"] = (mat <= 11).sum(axis=1) # 一区 1..11 out["zone2"] = ((mat >= 12) & (mat <= 22)).sum(axis=1) out["zone3"] = (mat >= 23).sum(axis=1) primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31] out["prime_cnt"] = np.isin(mat, primes).sum(axis=1) out["consec"] = [int(np.sum(np.diff(np.sort(r)) == 1)) for r in mat] out["repeat"] = [len(set(mat[i]) & set(mat[i-1])) if i else 0 for i in range(len(mat))] # --- 时序特征：33 维遗漏值 --- miss = np.zeros((len(mat), 33), dtype="int16") last = np.full(33, -1) for i, row in enumerate(mat): for n in range(33): miss[i, n] = i - last[n] if last[n] >= 0 else i + 1 for n in row: last[n - 1] = i # 开奖后更新 # --- 频率特征：近 window 期出现次数 --- hot = np.zeros((len(mat), 33), dtype="int16") for i in range(len(mat)): hist = mat[max(0, i - window):i] if len(hist): hot[i] = np.bincount(hist.ravel(), minlength=34)[1:34] out = pd.concat([ out, pd.DataFrame(miss, index=df.index, columns=[f"miss_{n}" for n in range(1, 34)]), pd.DataFrame(hot, index=df.index, columns=[f"hot_{n}" for n in range(1, 34)]), ], axis=1) return out

sum、span、mean、std这四列是最基础的形状描述，odd_cnt、big_cnt、zone1..3、prime_cnt把号码的组成结构拆开，consec数连号对数，repeat算和上期的交集大小。这十来个列已经把一期号码的「长相」描述得差不多了。

关键在于miss那一段。last[n]存的是第 n 号球最近一次出现的期索引，miss[i, n]是它到第 i 期为止的遗漏期数，取值范围会一直涨，所以后面要么做对数变换，要么截断到 100。注意更新last的循环放在算miss之后，这样第 i 期的遗漏值反映的是「开奖前」的状态，才是合法的输入特征。这个顺序写反了就是数据泄漏，第 5 章会展开说。

hot那段用np.bincount(mat.ravel(), minlength=34)[1:34]统计次数，取[1:34]是因为 bincount 的下标从 0 开始，而球号从 1 开始，切片正好把 0 号位丢掉。window参数我一般设 30，也就是半年左右，太短噪声大，太长把早期规律也带进来了。

3.3 样本构造与时间切分：标签怎么定义

标签构造决定了整个项目怎么评估，这一步必须想清楚。常见的做法是把「预测下一期开什么」拆成 33 个独立的二分类：第 t 期的特征，去预测第 t+1 期每个红球出不出，标签矩阵是(n, 33)的 0/1；蓝球单独做成 16 分类，或者 16 个二分类。

def onehot_reds(draws: np.ndarray) -> np.ndarray: y = np.zeros((len(draws), 33), dtype="int8") for i, row in enumerate(draws): y[i, row - 1] = 1 # row 是 6 个红球号，1..33 return y def make_dataset(feat: pd.DataFrame, draws: np.ndarray, horizon: int = 1): """用第 t 期特征预测第 t+horizon 期，切片必须错开 horizon 位""" X = feat.to_numpy(dtype="float32")[:-horizon] Y = onehot_reds(draws)[horizon:] return X, Y def time_split(n: int, test_ratio: float = 0.2): cut = int(n * (1 - test_ratio)) return np.arange(cut), np.arange(cut, n) # 绝不 shuffle

horizon默认 1，就是想用今天推明天。X取[:-horizon]、Y取[horizon:]，两个切片错开一位，对齐关系才不会错。如果你写成X = feat、Y = onehot_reds(draws)，模型就是在拿当期的特征预测当期的号码——当期特征里包含了当期的开奖结果，分数能刷到接近 1.0，实际用起来一个不中。

time_split里那句「绝不 shuffle」是血泪经验。时序数据一旦随机打乱，测试集里就会混进训练集之后的样本，等于让模型偷看未来。正确做法是留最后 20% 做测试，或者直接用TimeSeriesSplit做多折滚动。

4. 模型与评估：把「命中率」这个词先定义清楚

模型本身没什么花活，逻辑回归加随机森林两档，加起来不到五十行。真正需要花时间的是评估口径——同一个模型，用两种口径能算出完全相反的结论，这是这个项目最容易自欺欺人的地方。

4.1 三档基线：没有对比就没有真相

任何「预测」类项目，第一件要做的事不是训模型，是定基线。红球 33 选 6，随机猜的期望命中个数是 6 × 6/33 ≈ 1.09 个，换算成单号命中率就是 18.2%。这个数字听起来挺高，很多人第一次看到会以为「随便猜都能中两成」，其实它衡量的是「你猜的号里有多少个真出了」，不是「你中了几个号」。六红全中的概率是 1/C(33,6) = 1/1107568，蓝球再乘 16，那就是另一个量级了。

我见过不少类似项目，报告里只写「模型准确率 78%」，不提基线。78% 在这种极度不平衡的二分类里毫无意义——把 33 个号全判成「不出」，准确率就有 27/33 ≈ 81.8%。所以评估必须用命中率、召回率这类口径，而且必须和随机基线同框对比。频率基线尤其值得跑，因为它就是大多数人凭直觉会用的策略，模型赢不了它，说明模型没学到东西。

4.2 训练与参数：两档模型摆在一起比

from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LogisticRegression from sklearn.ensemble import RandomForestClassifier from sklearn.multioutput import MultiOutputClassifier def build_model(kind: str = "lr", seed: int = 42): if kind == "lr": base = LogisticRegression( C=0.1, # 强正则，样本少的时候必须压 max_iter=1000, class_weight="balanced", # 正例只占 6/33，必须补偿 ) return Pipeline([("sc", StandardScaler()), ("clf", MultiOutputClassifier(base))]) if kind == "rf": base = RandomForestClassifier( n_estimators=300, max_depth=6, # 深度必须砍，不然每棵树都能记住训练集 min_samples_leaf=20, random_state=seed, n_jobs=-1, ) return Pipeline([("clf", MultiOutputClassifier(base))]) raise ValueError(f"未知模型类型: {kind}")

几个参数值得单独说。C=0.1是正则强度的倒数，越小正则越强。这个数据集特征维度三十多、样本一千多，属于典型的「特征比样本相对多」，正则不压紧一点，逻辑回归的系数会飘到没边。class_weight="balanced"是必须的，33 个二分类里正例只占 6/33，不加权模型会倾向于全判 0，训练完概率全挤在 0.18 附近，排序基本随机。

随机森林那边max_depth=6和min_samples_leaf=20都是在压过拟合。树模型在这种小样本上特别容易把训练集记住，不砍深度的话训练集准确率能到 0.9 以上，回测惨不忍睹。seed一定要显式传，不然换台机器结果对不上，调参时你会怀疑人生。

4.3 评估口径：逐期滚动回测才是真话

一次性切分只给你一个数字，滚动回测给你一条曲线。我一般写一个 walk-forward 循环：每次用 t 之前的全部数据训练，预测第 t+1 期，取概率最高的 6 个，和真实结果算交集大小。

import numpy as np def proba_matrix(model, X) -> np.ndarray: """MultiOutputClassifier 返回 33 个 (n,2)，取正类列拼成 (n,33)""" return np.column_stack([p[:, 1] for p in model.predict_proba(X)]) def backtest(model, feat, draws: np.ndarray, start: int, k: int = 6): hit_hist, base_hist = [], [] for t in range(start, len(draws) - 1): X_tr = feat.iloc[:t].to_numpy(dtype="float32") y_tr = onehot_reds(draws[:t]) model.fit(X_tr, y_tr) p = proba_matrix(model, feat.iloc[[t]].to_numpy(dtype="float32"))[0] top = np.argsort(p)[-k:][::-1] + 1 # 概率最高的 k 个红球 hit_hist.append(len(set(top) & set(draws[t + 1]))) rng = np.random.default_rng(t) # 同期随机基线，种子固定可复现 rnd = rng.choice(np.arange(1, 34), size=k, replace=False) base_hist.append(len(set(rnd) & set(draws[t + 1]))) return np.array(hit_hist), np.array(base_hist)

这个循环有点慢，一千期跑下来按模型复杂度要几分钟到十几分钟。想加速就把start之后的模型改成每 50 期重训一次，中间直接用旧模型预测，实践中对结果影响不大。

算完之后别只看均值，要看分布。我一般输出三个数：平均命中个数、命中 ≥3 个的期数占比、以及和随机基线的配对差值。前两个告诉你绝对水平，第三个告诉你模型到底有没有超越瞎猜。绝大多数情况下第三个数字会在 0 附近晃，这时候就该诚实地承认：模型没学到可用的规律。

注意：回测结果不要用「准确率」这个词汇报。33 维二分类的 accuracy 有 81.8% 的天然地板，写出来只会误导自己。

5. 避坑与排查：五个我真实踩过的现场

这类项目最气人的地方是「跑得通但结果是假的」——不报错、不崩、分数还挺好看，你却不知道它在骗你。下面五条是我在实际拆这类代码时反复遇到的，按「现象 → 原因 → 解决」写，遇到对得上的直接照方抓药。

5.1 指标虚高：随机打乱切分把未来漏进了训练集

现象：训练集准确率 0.85，测试集 0.83，看着很稳，可回测一跑平均命中 1.1 个，和随机猜没区别。

原因：用了train_test_split(X, Y, test_size=0.2)但没传shuffle=False。sklearn 这个函数默认打乱，时序数据被打乱后，测试集里混着大量「未来」样本，而特征里的遗漏值、近 30 期频率都是随时间累积的，模型实际上是在用未来的统计量预测过去。

解决：所有切分都按时间顺序走，要么手写cut = int(n * 0.8)，要么用TimeSeriesSplit(n_splits=5)。改完你会发现测试分数掉到 0.4 以下，那才是真实水平。这个数字掉下来是好事，说明你的评估终于开始说实话了。

5.2 特征里混进答案：和值、跨度当成预测输入

现象：模型对某些期给出极高的概率，一看果然全中，但下一期立刻打回原形。

原因：build_features和标签对齐的时候错位了。比如特征表里第 t 行存的是第 t 期的和值、跨度、奇偶比——这些量是开奖结果的函数，用它去预测第 t 期本身，就是标准的数据泄漏。写代码时如果不小心把feat.iloc[:t]写成feat.iloc[:t+1]，或者make_dataset里的horizon切片方向搞反，都会踩这个坑。

解决：加一条自检断言——所有特征列在第 t 行必须只依赖第 t 期及之前的数据。具体落地方式是构造完特征后，把某一期的未来数据全部抹掉重算，看当期特征值有没有变化，变了就说明渗透了未来。这个检查写起来十行，能省掉几天的自我怀疑。

5.3 编码和列名：UnicodeDecodeError与看不见的全角空格

现象：pd.read_csv直接抛UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd0，或者读进来了但df["红球1"]报KeyError。

原因：前者是历史数据表多用 GBK 编码，尤其从网页复制下来的表；后者是列名里混了全角空格或者前后有不可见字符，打印出来肉眼看不出差别。

解决：读文件时按utf-8-sig → utf-8 → gbk顺序回退，别硬写一个编码。列名统一做c.replace("\u3000", "").strip()，做之前先print([repr(c) for c in df.columns])把真实字符打出来，一眼就能看到'红球1\u3000'这种。这个坑特别隐蔽，我第一次遇到时盯着屏幕看了二十分钟。

5.4 阈值没定：概率输出被当成投注清单

现象：模型每期都吐出 20 多个「高概率号码」，用户不知道选哪几个，评估也算不明白。

原因：33 个独立二分类的输出概率没有做后处理，直接全打印了。每个号码的概率都在 0.1~0.3 之间，没有一个明确的取舍规则，导致「预测结果」和「评估口径」对不上——评估时取 top-6，展示时给 20 个，两个数字没法互相印证。

解决：把 top-k 的 k 固定进配置文件，评估和展示用同一个 k。想更严谨一点，可以按概率排序后做累计概率截断，或者用历史命中率反推最优 k（一般 k 就在 5~8 之间，太多覆盖率上去但命中率下来）。关键是这一个是配置项，不是每期手动决定。

5.5 版本与随机种子：换台机器结果就对不上

现象：本地跑出来平均命中 1.4 个，同事拉下来跑是 1.1 个，代码明明一样。

原因：两个。一是random_state没传或者传在不同的位置，随机森林的每一折采样都不同；二是 scikit-learn 版本差异，OneHotEncoder的sparse参数在 1.2 之后改名sparse_output，LogisticRegression的默认solver也变过，同样的代码不同版本行为不一致。

解决：requirements.txt里把版本号钉死（scikit-learn==1.3.2这种写法），随机种子统一从配置文件读，一路传到train_test_split、模型构造、交叉验证的random_state。再狠一点，在训练脚本开头调numpy.random.seed(seed)和random.seed(seed)，把所有随机源都按住。

提示：跨版本复现是玄学，别指望pip install -U之后结果还一样。要么锁版本，要么接受每次升级重跑一遍基线。

6. 二次开发：把一次性脚本改成能反复试的实验框架

这份代码跑通之后，最大的问题不是模型不够好，而是「想试个新特征要改三个文件、跑两遍全量数据」。我的做法是先做结构改造，再做模型升级，顺序反了会很痛苦。

改造分三块。第一块是特征注册：把build_features拆成若干个返回DataFrame的小函数，用一个列表登记，配置里写上启用哪些。这样试新特征只要加一个函数、改一行 yaml，不用动主流程。第二块是基线固化：把随机基线和频率基线写成baseline.py里的两个函数，任何一次训练结束都自动打印「模型 vs 基线」的配对差值，跑不出来就说明白忙。第三块是实验记录：每次训练把配置、git 短哈希、关键指标写进reports/exp_log.csv追加一行，一周后翻记录能省掉大量重复劳动。

还有一个我很推荐的技巧：写一个「泄漏自检」单元测试。做法是把第 t 期之后的所有数据整体打乱重排，再跑一遍build_features，如果第 t 期及之前的特征值有任何一列发生变化，测试就失败。这个测试跑起来不到一秒，但能挡住第 5.2 节那类最隐蔽的错误。同样值得写的还有「基线不变性」测试：随机基线在固定种子下的平均命中应该稳定在 1.09 左右，偏离太多说明数据加载或切片出了问题。

模型侧想升级的话，优先级我建议是 LightGBM 优于 XGBoost 优于 LSTM。前两个在千级样本上还能站住，LSTM 基本是给自己找麻烦。真要上序列模型，至少先把样本量做到五千期以上，否则训出来的东西连基线都打不过，纯属浪费时间。

最后说句掏心窝的：这类项目的正确心态不是「训出一个能用的模型」，而是「搭一套能快速否证假设的流程」。新增一个特征，五分钟内能知道它有没有用；换一个模型，十分钟内能拿到和基线的对比——这套流程本身的价值，比任何一次跑出来的命中率都高。从那以后我每次接这类时序预测的活，都强制先把随机基线跑出来贴在报告第一行，谁提「准确率 90%」我就让他先跟这行数字比一比。希望帮到你。

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