量化价值投资中的深度学习技术：TensorFlow实战
量化价值投资中的深度学习技术：TensorFlow实战
关键词：量化价值投资, 深度学习, TensorFlow, 股票预测, 因子模型, LSTM神经网络, 量化策略
摘要：本文将带你走进"量化价值投资"与"深度学习"的交叉地带，用小学生都能听懂的语言解释复杂概念，再通过手把手的TensorFlow实战案例，教你如何用AI技术挖掘股票市场中的价值宝藏。我们会从传统价值投资的痛点出发，揭示深度学习如何像"超级分析师"一样处理海量数据，发现人类难以察觉的价值规律。最终，你将学会构建一个基于财务数据和市场数据的股票价值预测模型，并通过历史数据验证其有效性。无论你是投资新手还是有经验的程序员，这篇文章都能让你轻松掌握用AI赋能价值投资的核心方法。
背景介绍
目的和范围
想象一下，你面前有1000家公司的财务报表，需要从中找出未来最有可能上涨的10家。如果用传统方法，你可能需要逐一阅读每份财报，计算市盈率、市净率等指标，再比较行业平均水平——这就像在沙滩上用手筛选金子，既慢又容易漏掉宝藏。
而今天，我们要学习的"量化价值投资+深度学习"技术，就像给你一台"智能淘金机"：它能自动处理海量财务数据，发现隐藏的价值规律，甚至预测股票未来的表现。本文的目的就是教会你如何搭建这样一台"淘金机"。
我们的旅程将覆盖三个核心领域：
- 价值投资的本质：如何判断一家公司是否被低估
- 深度学习的魔力：为什么神经网络能比传统方法更精准地挖掘价值
- TensorFlow实战：从零开始构建、训练和测试一个股票价值预测模型
注意：本文不是投资建议，而是技术教程。所有案例仅用于教学，不代表实际投资收益。投资有风险，决策需谨慎！
预期读者
本文适合三类读者：
- 投资爱好者：想了解AI如何帮助选股，但编程基础薄弱的朋友（我们会从Python基础讲起）
- 程序员：有编程经验但不懂金融，想进入量化投资领域的开发者
- 量化分析师：希望用深度学习改进传统量化策略的专业人士
无论你属于哪一类，只要带着好奇心和学习的热情，就能跟上我们的节奏。我们会像教小学生做算术一样，把每个复杂概念拆分成简单步骤。
文档结构概述
本文将按照"概念→原理→实战→应用"的逻辑展开，共分为8个核心章节：
- 核心概念与联系：用生活例子解释量化价值投资、深度学习和TensorFlow是什么，以及它们如何协作
- 核心算法原理：详解用于价值投资的深度学习模型（MLP、LSTM等）的工作原理
- 数学模型和公式：用简单数学解释神经网络为什么能预测股票价格
- 项目实战：手把手教你用TensorFlow构建股票价值预测模型（附完整代码）
- 实际应用场景：深度学习在量化价值投资中的典型应用案例
- 工具和资源推荐：数据获取、模型训练、策略回测的实用工具
- 未来发展趋势与挑战：AI量化投资的前沿方向和需要注意的"陷阱"
- 总结与思考题：回顾核心知识点，留下拓展思考的问题
术语表
核心术语定义
| 术语 | 通俗解释 | 生活类比 |
|---|---|---|
| 量化价值投资 | 通过数学模型和计算机程序，分析公司财务数据和市场数据，找出被低估的股票 | 用Excel表格和公式筛选"性价比高"的商品 |
| 深度学习 | 一种让计算机从数据中自动学习规律的技术，基于多层神经网络 | 像教孩子认字：看1000张猫的图片后，孩子能自己认出没见过的猫 |
| TensorFlow | 谷歌开发的深度学习框架，提供搭建神经网络的"积木" | 乐高积木套装：有各种形状的积木（层、激活函数等），可以拼出不同模型 |
| 因子 | 用来衡量股票价值的指标（如市盈率、ROE等） | 评价学生的指标：考试成绩（对应市盈率）、出勤率（对应营收增长率）等 |
| 时间序列 | 按时间顺序排列的数据（如股票每天的收盘价） | 孩子每年的身高记录：2018年120cm，2019年130cm，2020年140cm… |
| 神经网络 | 模仿人脑神经元连接方式设计的计算模型，由输入层、隐藏层、输出层组成 | 工厂生产线：原材料（输入数据）→加工车间（隐藏层）→成品（预测结果） |
| 过拟合 | 模型"死记硬背"训练数据，在新数据上表现差 | 学生只背题库，考试遇到新题就不会做 |
相关概念解释
价值投资 vs 量化投资 vs 量化价值投资：
- 传统价值投资：巴菲特式投资，人工分析公司财报和业务模式，寻找被低估的股票
- 量化投资：用数学模型和计算机自动交易，可基于技术指标（如均线）或市场情绪
- 量化价值投资：用计算机自动分析财务数据，找出符合价值投资理念的股票（如低市盈率、高ROE）
深度学习 vs 传统机器学习：
- 传统机器学习：需要人工设计特征（如手动计算市盈率），适合规则明确的问题
- 深度学习：能自动从原始数据中提取特征（如直接输入财报文本，自动识别关键指标），适合复杂非线性问题
缩略词列表
| 缩略词 | 全称 | 中文解释 |
|---|---|---|
| AI | Artificial Intelligence | 人工智能 |
| DL | Deep Learning | 深度学习 |
| TF | TensorFlow | 谷歌深度学习框架 |
| MLP | Multi-Layer Perceptron | 多层感知机（一种神经网络） |
| LSTM | Long Short-Term Memory | 长短期记忆网络（处理时间序列的神经网络） |
| PE | Price-to-Earnings Ratio | 市盈率 |
| PB | Price-to-Book Ratio | 市净率 |
| ROE | Return on Equity | 净资产收益率 |
| MSE | Mean Squared Error | 均方误差（衡量预测误差的指标） |
| API | Application Programming Interface | 应用程序编程接口（软件之间的"桥梁"） |
核心概念与联系
故事引入
小明的"股票淘金记"
10岁的小明听说爸爸在炒股，也想试试。爸爸给了他一个任务：从10家公司中选1家"最好"的股票。小明不知道怎么选，爸爸说：“你可以看它们的’成绩单’（财务报表）啊！”
于是小明拿到了10张"成绩单"，上面有各种数字：有的公司"考试分数"（利润）很高，但"学费"（股价）也很贵；有的公司"分数"一般，但"学费"很便宜。小明眼花缭乱，不知道该选哪个。
这时，做AI工程师的表哥来了。表哥说："我教你用电脑做个’股票筛选器’吧！"他带着小明做了三件事：
- 收集数据：把10家公司过去5年的"成绩单"（财务数据）和"价格记录"（股价数据）输入电脑
- 教电脑学习：告诉电脑"过去选哪些公司后来涨了"，让电脑自己找规律
- 自动筛选：电脑分析后，指出第3家公司"性价比最高"，虽然现在"学费"便宜，但"成绩"一直在进步
后来，第3家公司的股价真的涨了！小明明白了：原来选股票就像选性价比高的玩具，而AI能帮我们快速找到"物美价廉"的那一个。
这个故事里，小明的表哥用的就是量化价值投资+深度学习的思想：用数据和算法代替人工，发现被低估的价值。接下来，我们就来详细拆解这个过程。
核心概念解释（像给小学生讲故事一样）
核心概念一：什么是量化价值投资？
想象你要在超市买苹果。有100个苹果摆在面前，你怎么选又好又便宜的？
传统方法（对应传统价值投资）：你一个个拿起来看，摸一摸硬度，看一看颜色，问一问价格，最后挑几个你觉得最好的。但如果有1000个苹果，你就挑不过来了。
量化方法（对应量化价值投资）：你制定了几个"筛选规则"：
- 规则1：重量必须大于150克（对应"公司市值大于50亿"）
- 规则2：价格必须低于5元/个（对应"市盈率低于行业平均"）
- 规则3：甜度必须高于12度（对应"ROE高于15%"）
然后你用一个"筛选机器"（计算机程序）自动检查每个苹果，把符合所有规则的苹果挑出来。这就是量化投资：用明确的规则和计算机程序，从大量股票中筛选出符合条件的标的。
而价值投资的核心思想是"买便宜货"：当一个苹果本来值10元，现在只卖5元（被低估），就买入；等它涨到10元时再卖出。对应到股票，就是寻找那些市场价格低于其内在价值的公司。
所以，量化价值投资就是：用计算机程序自动计算股票的"内在价值"，找出那些价格低于内在价值的股票，进行投资。
核心概念二：什么是深度学习？
假设你想教一个外星人分辨"猫"和"狗"。你可以告诉他：“猫有尖耳朵、长尾巴、会喵喵叫”——这是传统机器学习（人工设计特征）。但如果遇到一只没有尾巴的猫，外星人就分不清了。
深度学习的方法则不同：你直接给外星人看100万张猫和狗的照片，告诉他"这些是猫，那些是狗"，让他自己找规律。外星人可能会发现：“猫的眼睛通常比较圆，狗的嘴巴通常比较宽”——这些规律是他自己总结的，不是你教的。
在量化价值投资中，传统方法需要人工设计"价值因子"（如PE、PB、ROE），而深度学习可以直接从原始财务数据（利润表、资产负债表）中自动学习哪些指标能预测股票未来收益。就像外星人自己学会了分辨猫狗的新特征，神经网络也能发现人类没注意到的"隐藏价值因子"。
核心概念三：什么是TensorFlow？
TensorFlow就像一套"乐高积木"，专门用来搭建深度学习模型。
普通乐高积木有方块、长条、轮子等零件；TensorFlow的"积木"包括：
- 层（Layers）：神经网络的基本组成部分，就像乐高的不同形状积木
- 激活函数（Activation Functions）：让神经网络能学习复杂规律，就像乐高的连接件，让积木能"弯曲"成不同形状
- 优化器（Optimizers）：帮模型"学习得更快更好"，就像乐高的电动马达，让模型能自动调整参数
- 损失函数（Loss Functions）：告诉模型"哪里做错了"，就像乐高说明书上的错误提示
用TensorFlow搭建模型，就像用乐高拼机器人：你把不同的"层"积木按顺序搭起来，用"激活函数"连接，最后用"优化器"让它动起来。即使你不会造积木（不懂底层实现），也能拼出很酷的模型（神经网络）。
核心概念之间的关系（用小学生能理解的比喻）
量化价值投资、深度学习和TensorFlow的关系，就像"做蛋糕"的过程：
-
量化价值投资是"做蛋糕的食谱"：告诉你要做什么（目标：找到被低估的股票），需要哪些原料（数据：财务指标、股价等），以及大致步骤（流程：数据收集→分析→筛选→投资）。
-
深度学习是"智能厨师"：传统食谱需要你手动搅拌（人工分析），而智能厨师能自动完成搅拌、烘焙等步骤，还能根据原料情况（数据特点）调整做法（模型参数），做出更好吃的蛋糕（更精准的预测）。
-
TensorFlow是"厨房电器"：智能厨师（深度学习）需要烤箱、搅拌机等工具（TensorFlow）才能工作。没有工具，厨师再厉害也做不出蛋糕；没有好的工具，做蛋糕的效率和质量都会下降。
三者合作的完整流程：
- 你（投资者）拿出食谱（量化价值投资策略），告诉智能厨师（深度学习）你想要"价值型蛋糕"（被低估的股票）
- 智能厨师（深度学习）检查厨房电器（TensorFlow）是否齐全，然后开始准备原料（数据预处理）
- 智能厨师用搅拌机（神经网络层）处理原料，用烤箱（训练算法）烘烤，期间根据蛋糕味道（损失函数）调整火候（优化参数）
- 最后，烤箱（TensorFlow）输出香喷喷的蛋糕（股票推荐列表），你可以根据这个结果做投资决策
核心概念原理和架构的文本示意图（专业定义）
量化价值投资的传统架构
[数据层] → [因子计算层] → [选股层] → [回测层] → [实盘交易]
↓ ↓ ↓ ↓
财务数据 PE/PB/ROE等 筛选规则 历史表现验证
市场数据 人工设计因子 排序打分 风险收益评估
融入深度学习的量化价值投资架构
[数据层] → [预处理层] → [深度学习模型层] → [选股层] → [回测层] → [实盘交易]
↓ ↓ ↓ ↓ ↓
财务数据 缺失值填充 MLP(财务因子) 预测股票 历史表现验证
市场数据 标准化/归一化 LSTM(时间序列) 未来收益 风险收益评估
文本数据 特征提取 CNN(文本特征) 排序筛选 策略优化
TensorFlow在深度学习层的角色
TensorFlow架构
┌─────────────────────────────────────────────────┐
│ 高级API (Keras)：快速搭建模型 │
│ ┌─────────┐ ┌─────────┐ ┌─────────────────┐ │
│ │ Sequential模型 │ Functional API │ 预训练模型 │ │
│ └─────────┘ └─────────┘ └─────────────────┘ │
├─────────────────────────────────────────────────┤
│ 中级API：自定义组件 │
│ ┌─────────┐ ┌─────────┐ ┌─────────────────┐ │
│ │ 自定义层 │ │ 损失函数 │ │ 优化器 │ │
│ └─────────┘ └─────────┘ └─────────────────┘ │
├─────────────────────────────────────────────────┤
│ 低级API：底层计算 │
│ ┌─────────┐ ┌─────────┐ ┌─────────────────┐ │
│ │ Tensor │ │ 计算图 │ │ GPU加速 │ │
│ └─────────┘ └─────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────┘
Mermaid 流程图 (量化价值投资中的深度学习流程)
核心算法原理 & 具体操作步骤
用于量化价值投资的深度学习模型
在量化价值投资中，我们最关心的问题是：如何根据历史数据预测股票未来的收益（或是否会上涨）。根据数据类型的不同，我们需要选择不同的深度学习模型：
1. 多层感知机（MLP）：处理结构化财务数据
适用场景：当输入是表格形式的财务指标（如PE、PB、ROE等因子）时，MLP是最简单有效的模型。
原理类比：MLP就像一个"多层筛子"，每层筛子有不同大小的孔（权重参数）。原始数据（因子）通过第一层筛子，留下重要信息；再通过第二层筛子，进一步提炼；最后得到预测结果（未来收益）。
网络结构：
输入层（因子数）→ 隐藏层1（神经元数）→ 隐藏层2（神经元数）→ 输出层（1个神经元，预测收益）
TensorFlow实现步骤：
- 导入Keras模块：
from tensorflow.keras.models import Sequential - 定义模型：
model = Sequential() - 添加输入层和隐藏层：
model.add(Dense(64, activation='relu', input_shape=(n_features,))) - 添加更多隐藏层：
model.add(Dense(32, activation='relu')) - 添加输出层：
model.add(Dense(1))（预测收益，不需要激活函数） - 编译模型：
model.compile(optimizer='adam', loss='mse') - 训练模型：
model.fit(X_train, y_train, epochs=50, validation_data=(X_val, y_val))
2. 长短期记忆网络（LSTM）：处理时间序列数据
适用场景：当输入是股票价格、成交量等随时间变化的数据时，LSTM能捕捉时间依赖关系（如"股价连续上涨3天后通常会回调"）。
原理类比：传统神经网络像"金鱼"，只有7秒记忆，记不住 earlier 的数据；LSTM像"大象"，能记住重要的历史信息。它有一个"记忆门"，决定哪些信息要记住（如上个月的重大利好），哪些要忘记（如某天的小幅波动）。
网络结构：
输入层（时间步×特征数）→ LSTM层（神经元数）→ Dense层（神经元数）→ 输出层（预测收益）
TensorFlow实现步骤：
- 准备时间序列数据：将数据转化为
[样本数, 时间步, 特征数]的格式 - 定义模型：
model = Sequential() - 添加LSTM层：
model.add(LSTM(50, return_sequences=False, input_shape=(time_steps, n_features)))return_sequences=True表示输出每个时间步的结果（用于堆叠多个LSTM层）
- 添加Dense层：
model.add(Dense(25, activation='relu')) - 添加输出层：
model.add(Dense(1)) - 编译和训练：与MLP相同
3. 混合模型（MLP+LSTM）：同时处理财务因子和时间序列
适用场景：实际投资中，我们既要看财务指标（基本面），也要看价格走势（技术面）。混合模型能同时输入这两类数据，综合判断。
原理类比：就像评价一个学生，既要看考试成绩（财务因子，MLP处理），也要看成绩的变化趋势（时间序列，LSTM处理），最后综合给出评价（预测未来成绩）。
网络结构：
财务因子 → MLP子网络 → 特征向量 → 拼接 → Dense层 → 输出层
↑
价格序列 → LSTM子网络 → 特征向量 →
TensorFlow实现步骤（使用Functional API）：
-
定义财务因子输入：
financial_input = Input(shape=(n_financial_features,)) -
MLP子网络：
x = Dense(32, activation='relu')(financial_input)
x = Dense(16, activation='relu')(x)
financial_output = Dense(8, activation='relu')(x) -
定义价格序列输入：
price_input = Input(shape=(time_steps, n_price_features)) -
LSTM子网络：
y = LSTM(32, return_sequences=False)(price_input)
price_output = Dense(8, activation='relu')(y) -
拼接两个子网络输出：
combined = concatenate([financial_output, price_output]) -
最终预测：
z = Dense(16, activation='relu')(combined)
output = Dense(1)(z) -
定义模型：
model = Model(inputs=[financial_input, price_input], outputs=output) -
编译和训练：与前面相同
模型训练的关键步骤
无论选择哪种模型，训练过程都包含以下关键步骤，我们称之为"深度学习五步法"：
步骤1：数据准备（“买菜前先挑好菜”）
- 数据来源：财务数据（tushare、Wind、同花顺）、市场数据（雅虎财经、聚宽）
- 特征选择：价值因子（PE、PB、PS、PCF、ROE、ROA）、成长因子（营收增长率、利润增长率）、质量因子（资产负债率、毛利率）
- 标签定义：预测未来1个月的收益率（
(未来价格-当前价格)/当前价格） - 数据划分：训练集（70%历史数据）、验证集（15%）、测试集（15%），注意时间序列不能随机划分！
步骤2：数据预处理（“洗菜切菜”）
- 缺失值处理：用均值/中位数填充（连续变量）或众数填充（分类变量）
- 异常值处理：用IQR法（四分位距）识别异常值，截断或替换
- 标准化/归一化：
- 标准化：
(x - 均值) / 标准差（适用于正态分布数据） - 归一化：
(x - 最小值) / (最大值 - 最小值)（将数据缩放到[0,1]）
- 标准化：
- 时间序列处理：创建滑动窗口（如用过去60天数据预测未来30天收益）
步骤3：模型构建（“搭灶台”）
- 选择合适的模型架构（MLP/LSTM/混合模型）
- 确定网络层数和每层神经元数（初学者可从简单开始：2-3层，每层32-128个神经元）
- 选择激活函数：隐藏层用ReLU（避免梯度消失），输出层回归问题不用激活函数
- 选择优化器：Adam（自适应学习率，适合大多数情况）
- 选择损失函数：回归问题用MSE（均方误差），分类问题用交叉熵
步骤4：模型训练（“炒菜”）
- 设置训练轮次（epochs）：通常50-200轮，太多容易过拟合
- 设置批次大小（batch_size）：32或64（GPU内存足够时可增大）
- 监控验证集损失：如果验证集损失不再下降，说明可能过拟合，需要早停
- 正则化：添加Dropout层（随机"关闭"部分神经元，防止过拟合）
model.add(Dropout(0.2)) # 每次训练随机丢弃20%的神经元
步骤5：模型评估与优化（“尝味道调火候”）
- 评估指标：
- MSE（均方误差）：
MSE = 1/n Σ(真实值-预测值)²（值越小越好） - MAE（平均绝对误差）：
MAE = 1/n Σ|真实值-预测值|（更直观的误差） - R²（决定系数）：越接近1越好，表示模型解释数据变异性的能力
- MSE（均方误差）：
- 优化方法：
- 调整网络结构（增加/减少层数或神经元数）
- 调整学习率（Adam默认0.001，可尝试0.0001或0.01）
- 增加正则化（Dropout、L2正则化）
- 收集更多数据或优化特征
数学模型和公式 & 详细讲解 & 举例说明
神经网络的数学基础
别担心，我们不会讲复杂的数学！这里的公式就像"1+1=2"一样简单，只是符号看起来吓人而已。
1. 神经元的数学表达（单个"小厨师"的工作）
一个神经元的输出 = 激活函数(输入×权重 + 偏置)
公式：y=f(∑i=1n(wixi)+b)y = f(\sum_{i=1}^{n}(w_i x_i) + b)y=f(∑i=1n(wixi)+b)
- xix_ixi：输入（如PE值、ROE值）
- wiw_iwi：权重（每个输入的重要性，如PE的权重是0.3，ROE的权重是0.7）
- bbb：偏置（调整整体输出的"偏移量"，就像菜谱里的"盐少许"）
- f()f()f()：激活函数（给神经元"调味"，让输出更有"味道"）
举例：假设我们有两个输入特征：PE（x1=10x_1=10x1=10）和ROE（x2=0.2x_2=0.2x2=0.2），权重w1=−0.5w_1=-0.5w1=−0.5（PE越低越好，所以权重为负），w2=2w_2=2w2=2（ROE越高越好，权重为正），偏置b=0.1b=0.1b=0.1，激活函数f(x)=xf(x)=xf(x)=x（线性激活）。
神经元输出：y=(−0.5×10)+(2×0.2)+0.1=−5+0.4+0.1=−4.5y = (-0.5×10) + (2×0.2) + 0.1 = -5 + 0.4 + 0.1 = -4.5y=(−0.5×10)+(2×0.2)+0.1=−5+0.4+0.1=−4.5
这个输出可以理解为股票的"价值分数"，分数越高，越值得投资。
2. 激活函数：让神经网络"思考"非线性问题
如果没有激活函数，无论多少层神经网络，都等价于单层线性模型，无法学习复杂规律。激活函数就像给神经元加上"思考能力"，让它能处理非线性关系（如"PE太低可能是公司有问题，并非价值高"）。
常用激活函数：
ReLU函数（最常用）：f(x)=max(0,x)f(x) = max(0, x)f(x)=max(0,x)
- 通俗解释：小于0的输入全部变成0（"忘记"不重要的信息），大于0的保持不变
- 图形：像一个向右侧打开的门，只让正数通过
- 优点：计算简单，缓解梯度消失问题
Sigmoid函数：f(x)=11+e−xf(x) = \frac{1}{1+e^{-x}}f(x)=1+e−x1
- 通俗解释：把任意输入压缩到0-1之间（可表示概率）
- 缺点：输入过大或过小时，梯度接近0，导致学习困难（梯度消失）
3. 损失函数：告诉模型"错在哪里"
损失函数是模型预测值与真实值之间的差距，训练的目标就是最小化损失函数。
均方误差（MSE）：MSE=1n∑i=1n(yi−y^i)2MSE = \frac{1}{n}\sum_{i=1}^{n}(y_i - \hat{y}_i)^2MSE=n1∑i=1n(yi−y^i)2
- yiy_iyi：真实值（如股票未来实际收益率10%）
- y^i\hat{y}_iy^i：预测值（如模型预测收益率8%）
- 举例：如果真实收益率是10%，预测是8%，则误差项是(0.1−0.08)2=0.0004(0.1-0.08)^2=0.0004(0.1−0.08)2=0.0004
- 特点：对大误差更敏感（平方放大了误差）
平均绝对误差（MAE）：MAE=1n∑i=1n∣yi−y^i∣MAE = \frac{1}{n}\sum_{i=1}^{n}|y_i - \hat{y}_i|MAE=n1∑i=1n∣yi−y^i∣
- 举例：同上例，MAE=∣0.1−0.08∣=0.02MAE = |0.1-0.08|=0.02MAE=∣0.1−0.08∣=0.02
- 特点：对异常值不敏感，更稳健
4. 优化器：让模型"学习进步"
优化器的作用是调整神经网络的权重www和偏置bbb，使损失函数最小化。最常用的是Adam优化器（Adaptive Moment Estimation）。
Adam优化器的核心思想：像开车时同时控制方向盘（梯度方向）和油门（学习率），根据路况（梯度变化）自动调整。
公式（简化版参数更新）：w=w−η⋅mtw = w - \eta \cdot m_tw=w−η⋅mt
- η\etaη：学习率（步长，如0.001）
- mtm_tmt：动量（考虑历史梯度，类似开车的惯性）
时间序列预测的数学模型（LSTM）
LSTM的数学公式比较复杂，但我们可以通过"三个门"来理解它的工作原理：
-
遗忘门：决定哪些历史信息要忘记
ft=σ(Wf⋅[ht−1,xt]+bf)f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)ft=σ(Wf⋅[ht−1,xt]+bf)- σ\sigmaσ：sigmoid函数（输出0-1，表示"忘记程度"）
- ht−1h_{t-1}ht−1：上一时刻的输出（短期记忆）
- xtx_txt：当前时刻的输入
-
输入门：决定哪些新信息要记住
it=σ(Wi⋅[ht−1,xt]+bi)i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)it=σ(Wi⋅[ht−1,xt]+bi)（哪些信息重要）
C~t=tanh(WC⋅[ht−1,xt]+bC)\tilde{C}_t = tanh(W_C \cdot [h_{t-1}, x_t] + b_C)C~t=tanh(WC⋅[ht−1,xt]+bC)（新信息的内容）
Ct=ft⋅Ct−1+it⋅C~tC_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_tCt=ft⋅Ct−1+it⋅C~t（更新细胞状态，长期记忆） -
输出门：决定当前输出什么
ot=σ(Wo⋅[ht−1,xt]+bo)o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)ot=σ(Wo⋅[ht−1,xt]+bo)（输出哪些信息）
ht=ot⋅tanh(Ct)h_t = o_t \cdot tanh(C_t)ht=ot⋅tanh(Ct)（当前输出，短期记忆）
通俗类比：LSTM就像一个"带记事本的秘书"：
- 遗忘门：秘书决定撕掉记事本上哪些旧内容（不重要的历史信息）
- 输入门：秘书决定在记事本上新写哪些内容（重要的新信息）
- 输出门：秘书根据当前问题，从记事本中找出相关内容回答（当前输出）
通过这三个门，LSTM能选择性地记住或忘记信息，从而处理长期依赖关系（如记住3个月前的财报数据对当前股价的影响）。
项目实战：代码实际案例和详细解释说明
开发环境搭建
在开始实战前，我们需要准备"厨房工具"。以下是详细的环境搭建步骤：
步骤1：安装Python
如果你的电脑还没有Python，按以下步骤安装：
- 访问Python官网（https://www.python.org/downloads/），下载Python 3.8或更高版本
- 安装时勾选"Add Python to PATH"（重要！这样可以在命令行直接使用Python）
- 安装完成后，打开命令行（Windows用Win+R输入cmd，Mac用Spotlight搜索Terminal），输入
python --version，如果显示Python 3.8.x，说明安装成功
步骤2：安装必要的库
在命令行输入以下命令，安装我们需要的所有库：
# 安装TensorFlow（深度学习框架）
pip install tensorflow==2.10.0 # 选择2.10.0版本，兼容性好
# 安装数据分析库
pip install pandas numpy matplotlib
# 安装金融数据获取库
pip install tushare # 国内股票数据
pip install yfinance # 国外股票数据（可选）
# 安装量化回测库
pip install backtrader
如果安装速度慢，可以使用国内镜像：
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow==2.10.0
步骤3：准备代码编辑器
推荐使用VS Code（免费、功能强大）：
- 下载VS Code（https://code.visualstudio.com/）并安装
- 安装Python插件：打开VS Code，在左侧扩展栏搜索"Python"，安装Microsoft官方插件
- 创建新项目：新建文件夹"quant_dl_tf"，用VS Code打开，新建文件"stock_prediction.py"
源代码详细实现和代码解读
我们的实战项目是：用LSTM模型预测股票未来1个月的收益率，并基于预测结果构建简单的价值投资策略。
完整代码结构
# 1. 导入库
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tushare as ts
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, r2_score
import backtrader as bt
import datetime
# 2. 设置中文显示（解决图表中文乱码问题）
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
# 3. 获取数据
def get_stock_data(code, start_date, end_date):
"""从tushare获取股票数据"""
# 设置tushare token（需要先在tushare官网注册获取）
ts.set_token('你的tushare token') # 替换成你的token
pro = ts.pro_api()
# 获取日线数据
df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)
# 获取财务数据（PE、PB、ROE等）
fina_indicator = pro.fina_indicator(ts_code=code, start_date=start_date, end_date=end_date)
# 数据预处理
df = df.sort_values('trade_date') # 按日期排序
df['trade_date'] = pd.to_datetime(df['trade_date']) # 转换日期格式
df.set_index('trade_date', inplace=True) # 设置日期为索引
# 合并财务数据（简单起见，这里只取PE）
fina_indicator = fina_indicator.sort_values('end_date')
fina_indicator['end_date'] = pd.to_datetime(fina_indicator['end_date'])
fina_indicator.set_index('end_date', inplace=True)
df = df.join(fina_indicator[['pe']], how='left') # 左连接PE数据
# 填充缺失值
df['pe'].fillna(method='ffill', inplace=True) # 前向填充PE缺失值
df.dropna(inplace=True) # 删除其他缺失值
return df
# 4. 数据预处理
def preprocess_data(df, look_back=60, predict_period=30):
"""
准备时间序列数据
look_back: 用过去多少天的数据作为输入
predict_period: 预测未来多少天的收益率
"""
# 计算未来收益率（标签）
df['future_return'] = df['close'].shift(-predict_period) / df['close'] - 1
df.dropna(inplace=True) # 删除最后predict_period行（没有未来数据）
# 选择特征：收盘价、成交量、PE
features = ['close', 'vol', 'pe']
data = df[features + ['future_return']].values
# 数据归一化（缩放到0-1之间）
scaler = MinMaxScaler(feature_range=(0, 1))
data_scaled = scaler.fit_transform(data)
# 构建输入X和输出y
X, y = [], []
for i in range(look_back, len(data_scaled)):
X.append(data_scaled[i-look_back:i, :len(features)]) # 输入：过去look_back天的特征
y.append(data_scaled[i, len(features)]) # 输出：未来收益率
X = np.array(X)
y = np.array(y)
# 划分训练集和测试集（时间序列不能随机划分）
train_size = int(0.7 * len(X))
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]
return X_train, X_test, y_train, y_test, scaler, df, features
# 5. 构建LSTM模型
def build_lstm_model(input_shape):
"""构建LSTM模型"""
model = Sequential()
# 添加LSTM层
model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape))
model.add(Dropout(0.2)) # Dropout防止过拟合
model.add(LSTM(units=50, return_sequences=False))
model.add(Dropout(0.2))
# 添加全连接层
model.add(Dense(units=25, activation='relu'))
model.add(Dense(units=1)) # 输出层：预测未来收益率
# 编译模型
model.compile(optimizer='adam', loss='mean_squared_error')
return model
# 6. 训练和评估模型
def train_evaluate_model(model, X_train, X_test, y_train, y_test, scaler, features):
"""训练模型并评估性能"""
# 训练模型
history = model.fit(
X_train, y_train,
batch_size=32,
epochs=50,
validation_data=(X_test, y_test),
verbose=1
)
# 绘制训练损失和验证损失
plt.figure(figsize=(12, 6))
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.title('模型损失变化')
plt.xlabel('训练轮次')
plt.ylabel('损失（MSE）')
plt.legend()
plt.show()
# 预测测试集
y_pred = model.predict(X_test)
# 反归一化（将预测值和真实值转换回原始尺度）
# 创建空数组，用于反归一化
y_pred_scaled = np.zeros((len(y_pred), len(features)+1))
y_pred_scaled[:, len(features)] = y_pred.flatten()
y_pred_unscaled = scaler.inverse_transform(y_pred_scaled)[:, len(features)]
y_test_scaled = np.zeros((len(y_test), len(features)+1))
y_test_scaled[:, len(features)] = y_test.flatten()
y_test_unscaled = scaler.inverse_transform(y_test_scaled)[:, len(features)]
# 计算评估指标
mse = mean_squared_error(y_test_unscaled, y_pred_unscaled)
r2 = r2_score(y_test_unscaled, y_pred_unscaled)
print(f'测试集MSE: {mse:.6f}')
print(f'测试集R²: {r2:.6f}')
# 绘制预测值vs真实值
plt.figure(figsize=(12, 6))
plt.plot(y_test_unscaled, label='真实收益率', alpha=0.7)
plt.plot(y_pred_unscaled, label='预测收益率', alpha=0.7)
plt.title('未来收益率预测 vs 真实值')
plt.xlabel('样本索引')
plt.ylabel('收益率')
plt.legend()
plt.show()
return model, y_pred_unscaled
# 7. 回测策略
class LSTMStrategy(bt.Strategy):
"""基于LSTM预测的交易策略"""
def __init__(self, model, scaler, features, look_back=60):
self.model = model
self.scaler = scaler
self.features = features
self.look_back = look_back
self.data_window = [] # 存储最近look_back天的特征数据
def next(self):
# 收集当前特征数据
current_features = [
self.data.close[0], # 收盘价
self.data.volume[0], # 成交量
self.data.pe[0] # PE值
]
self.data_window.append(current_features)
# 当数据窗口足够大时，进行预测
if len(self.data_window) >= self.look_back:
# 取最近look_back天的数据
input_data = self.data_window[-self.look_back:]
# 归一化
input_scaled = self.scaler.transform([input_data[-1] + [0]])[:, :len(self.features)] # 最后一位是占位的收益率
input_reshaped = input_scaled.reshape(1, self.look_back, len(self.features))
# 预测未来收益率
pred_return = self.model.predict(input_reshaped)[0][0]
# 交易逻辑：如果预测收益率>3%，买入；如果<0，卖出
if pred_return > 0.03 and not self.position:
self.buy(size=100) # 买入100股
print(f'买入：价格{self.data.close[0]:.2f}，预测收益率{pred_return:.2%}')
elif pred_return < 0 and self.position:
self.sell(size=100) # 卖出100股
print(f'卖出：价格{self.data.close[0]:.2f}，预测收益率{pred_return:.2%}')
def backtest_strategy(df, model, scaler, features, look_back=60):
"""回测策略"""
# 准备回测数据
cerebro = bt.Cerebro()
data = bt.feeds.PandasData(
dataname=df,
datetime='index',
openinterest=None
)
cerebro.adddata(data)
# 添加策略
cerebro.addstrategy(LSTMStrategy, model=model, scaler=scaler, features=features, look_back=look_back)
# 设置初始资金
cerebro.broker.setcash(100000.0)
# 设置佣金
cerebro.broker.setcommission(commission=0.001) # 1‰佣金
print(f'初始资金: {cerebro.broker.getvalue():.2f}')
# 运行回测
cerebro.run()
print(f'回测结束资金: {cerebro.broker.getvalue():.2f}')
# 绘制回测结果
cerebro.plot(style='candlestick')
# 8. 主函数
if __name__ == '__main__':
# 配置参数
STOCK_CODE = '600036.SH' # 招商银行
START_DATE = '20150101'
END_DATE = '20231231'
LOOK_BACK = 60 # 用过去60天数据预测
PREDICT_PERIOD = 30 # 预测未来30天收益率
# 步骤1：获取数据
print("获取股票数据...")
df = get_stock_data(STOCK_CODE, START_DATE, END_DATE)
print(f"获取到{len(df)}条数据")
print(df.head())
# 步骤2：数据预处理
print("数据预处理...")
X_train, X_test, y_train, y_test, scaler, df_processed, features = preprocess_data(
df, look_back=LOOK_BACK, predict_period=PREDICT_PERIOD
)
print(f"训练集大小