├── .gitignore ├── README.assets └── image-20210204204408427.png ├── README.md ├── lstm.ipynb ├── main.ipynb ├── predict.py ├── predict_scaler.py ├── results ├── _README.md ├── model.pt ├── model_scaler.pt └── tb_results │ └── README.md ├── train.py ├── train_data.npy └── train_scaler.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.DS_Store 2 | .idea/* 3 | 4 | # Byte-compiled / optimized / DLL files 5 | __pycache__/ 6 | *.py[cod] 7 | *$py.class 8 | 9 | # C extensions 10 | *.so 11 | 12 | # Distribution / packaging 13 | .Python 14 | build/ 15 | develop-eggs/ 16 | dist/ 17 | downloads/ 18 | eggs/ 19 | .eggs/ 20 | lib/ 21 | lib64/ 22 | parts/ 23 | sdist/ 24 | var/ 25 | wheels/ 26 | pip-wheel-metadata/ 27 | share/python-wheels/ 28 | *.egg-info/ 29 | .installed.cfg 30 | *.egg 31 | MANIFEST 32 | 33 | # PyInstaller 34 | # Usually these files are written by a python script from a template 35 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 36 | *.manifest 37 | *.spec 38 | 39 | # Installer logs 40 | pip-log.txt 41 | pip-delete-this-directory.txt 42 | 43 | # Unit test / coverage reports 44 | htmlcov/ 45 | .tox/ 46 | .nox/ 47 | .coverage 48 | .coverage.* 49 | .cache 50 | nosetests.xml 51 | coverage.xml 52 | *.cover 53 | *.py,cover 54 | .hypothesis/ 55 | .pytest_cache/ 56 | 57 | # Translations 58 | *.mo 59 | *.pot 60 | 61 | # Django stuff: 62 | *.log 63 | local_settings.py 64 | db.sqlite3 65 | db.sqlite3-journal 66 | 67 | # Flask stuff: 68 | instance/ 69 | .webassets-cache 70 | 71 | # Scrapy stuff: 72 | .scrapy 73 | 74 | # Sphinx documentation 75 | docs/_build/ 76 | 77 | # PyBuilder 78 | target/ 79 | 80 | # Jupyter Notebook 81 | .ipynb_checkpoints 82 | 83 | # IPython 84 | profile_default/ 85 | ipython_config.py 86 | 87 | # pyenv 88 | .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 98 | __pypackages__/ 99 | 100 | # Celery stuff 101 | celerybeat-schedule 102 | celerybeat.pid 103 | 104 | # SageMath parsed files 105 | *.sage.py 106 | 107 | # Environments 108 | .env 109 | .venv 110 | env/ 111 | venv/ 112 | ENV/ 113 | env.bak/ 114 | venv.bak/ 115 | 116 | # Spyder project settings 117 | .spyderproject 118 | .spyproject 119 | 120 | # Rope project settings 121 | .ropeproject 122 | 123 | # mkdocs documentation 124 | /site 125 | 126 | # mypy 127 | .mypy_cache/ 128 | .dmypy.json 129 | dmypy.json 130 | 131 | # Pyre type checker 132 | .pyre/ 133 | -------------------------------------------------------------------------------- /README.assets/image-20210204204408427.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QikaiXu/Stock-Forecasting/ccaa1462ef071ac7943e1dc70b4a916f8408b3cc/README.assets/image-20210204204408427.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Stock-Forecasting 2 | 3 | >浙江大学《机器学习及其应用》课程作业，A 股预测。 4 | > 5 | >项目来源于：（只有我自己的号才能上）。 6 | 7 | 项目介绍及说明查看 `main.ipynb`。 8 | 9 | ## 1 LSTM 10 | 11 | 这里用了一个简单的 LSTM 网络来训练 12 | 13 | ```python 14 | class LSTM(nn.Module): 15 | def __init__(self, num_hiddens, num_outputs): 16 | super(LSTM, self).__init__() 17 | self.lstm = nn.LSTM( 18 | input_size=1, 19 | hidden_size=num_hiddens, 20 | num_layers=1, 21 | batch_first=True 22 | ) 23 | self.fc = nn.Linear(num_hiddens, num_outputs) 24 | 25 | def forward(self, x): 26 | x = x.view(x.shape[0], -1, 1) 27 | r_out, (h_n, h_c) = self.lstm(x, None) 28 | out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output 29 | return out 30 | ``` 31 | 32 | 运行 `train.py` 进行训练，部分输出如下 33 | 34 | ```text 35 | torch.Size([1984, 14]) torch.Size([1984, 1]) 36 | epoch 10, train loss 72.788601, train mae 5.694631, mape 0.464045, valid mae 5.694631, mape 0.464045, time 0.46 sec 37 | epoch 20, train loss 52.200684, train mae 5.528595, mape 0.626163, valid mae 5.528595, mape 0.626163, time 0.46 sec 38 | ... 39 | epoch 190, train loss 0.581325, train mae 0.423464, mape 0.035151, valid mae 0.423464, mape 0.035151, time 0.53 sec 40 | epoch 200, train loss 0.513529, train mae 0.349038, mape 0.026197, valid mae 0.349038, mape 0.026197, time 0.55 sec 41 | ``` 42 | 43 | 最后的预测效果： 44 | 45 | ![image-20210204204408427](README.assets/image-20210204204408427.png) 46 | 47 | 其他指标等可查看 `lstm.ipynb`。 48 | 49 | 50 | 51 | ## 2 加上数据归一化 52 | 53 | 用 `MinMaxScaler` 进行归一化后，虽然指标有一定的下降，但是在测试的时候效果更好了。 54 | 55 | 运行 `train_scaler.py` 进行训练，部分输出如下 56 | 57 | ```text 58 | (1984, 14) (1984,) 59 | (1984, 14) (1984,) 60 | torch.Size([1984, 14]) torch.Size([1984, 1]) 61 | epoch 10, train loss 0.000570, train mae 5.679749, mape 0.692404, valid mae 5.679749, mape 0.692404, time 0.45 sec 62 | epoch 20, train loss 0.000466, train mae 5.188509, mape 0.622329, valid mae 5.188509, mape 0.622329, time 0.44 sec 63 | ... 64 | epoch 190, train loss 0.000015, train mae 0.605080, mape 0.049801, valid mae 0.605080, mape 0.049801, time 0.44 sec 65 | epoch 200, train loss 0.000014, train mae 0.569416, mape 0.045786, valid mae 0.569416, mape 0.045786, time 0.46 sec 66 | ``` 67 | 68 | -------------------------------------------------------------------------------- /lstm.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "torch.Size([1984, 14]) torch.Size([1984, 1])\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "# 首先 import 一些主要的包\n", 18 | "import numpy as np\n", 19 | "import pandas as pd\n", 20 | "import time\n", 21 | "import matplotlib.pyplot as plt\n", 22 | "import os\n", 23 | "import torch\n", 24 | "import torch.nn as nn\n", 25 | "import torch.utils.data as Data\n", 26 | "\n", 27 | "\n", 28 | "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n", 29 | "\n", 30 | "\n", 31 | "# 获取文件名\n", 32 | "file_name = 'train_data.npy'\n", 33 | "\n", 34 | "# 读取数组\n", 35 | "data = np.load(file_name)\n", 36 | "\n", 37 | "\n", 38 | "# 生成题目所需的训练集合\n", 39 | "def generate_data(data):\n", 40 | " # 记录 data 的长度\n", 41 | " n = data.shape[0]\n", 42 | "\n", 43 | " # 目标是生成可直接用于训练和测试的 x 和 y\n", 44 | " x = []\n", 45 | " y = []\n", 46 | "\n", 47 | " # 建立 (14 -> 1) 的 x 和 y\n", 48 | " for i in range(15, n):\n", 49 | " x.append(data[i - 15: i - 1])\n", 50 | " y.append(data[i - 1])\n", 51 | "\n", 52 | " # 转换为 numpy 数组\n", 53 | " x = np.array(x)\n", 54 | " y = np.array(y)\n", 55 | "\n", 56 | " return x, y\n", 57 | "\n", 58 | "\n", 59 | "x, y = generate_data(data)\n", 60 | "x = torch.tensor(x, dtype=torch.float32)\n", 61 | "y = torch.tensor(y, dtype=torch.float32)\n", 62 | "\n", 63 | "# 将 y 转化形状\n", 64 | "y = torch.unsqueeze(y, dim=1)\n", 65 | "print(x.shape, y.shape)\n", 66 | "\n", 67 | "# 样本总数\n", 68 | "num_samples = x.shape[0]\n", 69 | "num_train = round(num_samples * 0.8)\n", 70 | "num_valid = round(num_samples * 0.1)\n", 71 | "num_test = num_samples - num_train - num_valid\n", 72 | "\n", 73 | "dataset = Data.TensorDataset(x, y)\n", 74 | "train_data, valid_data, test_data = Data.random_split(dataset, (num_train, num_valid, num_test))\n", 75 | "\n", 76 | "batch_size = 512\n", 77 | "train_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", 78 | "valid_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False)\n", 79 | "test_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False)\n", 80 | "\n", 81 | "\n", 82 | "def compute_mae(y_hat, y):\n", 83 | " \"\"\"\n", 84 | " :param y_hat: 用户的预测值\n", 85 | " :param y: 标准值\n", 86 | " :return: MAE 平均绝对误差 mean(|y*-y|)\n", 87 | " \"\"\"\n", 88 | " return torch.mean(torch.abs(y_hat - y))\n", 89 | "\n", 90 | "\n", 91 | "def compute_mape(y_hat, y):\n", 92 | " \"\"\"\n", 93 | " :param y_hat: 用户的预测值\n", 94 | " :param y: 标准值\n", 95 | " :return: MAPE 平均百分比误差 mean(|y*-y|/y)\n", 96 | " \"\"\"\n", 97 | " return torch.mean(torch.abs(y_hat - y)/y)\n", 98 | "\n", 99 | "\n", 100 | "def evaluate_accuracy(data_loader, model):\n", 101 | " \"\"\"\n", 102 | " :param data_loader: 输入的 DataLoader\n", 103 | " :param model: 用户的模型\n", 104 | " :return: 对应的 MAE 和 MAPE\n", 105 | " \"\"\"\n", 106 | " # 初始化参数\n", 107 | " mae_sum, mape_sum, n = 0.0, 0.0, 0\n", 108 | "\n", 109 | " # 对每一个 data_iter 的每一个 x,y 进行计算\n", 110 | " for x, y in data_loader:\n", 111 | " x = x.to(device)\n", 112 | " # 计算模型得出的 y_hat\n", 113 | " y_hat = model(x)\n", 114 | "\n", 115 | " # 计算对应的 MAE 和 RMSE 对应的和，并乘以 batch 大小\n", 116 | " mae_sum += compute_mae(y_hat, y) * y.shape[0]\n", 117 | " mape_sum += compute_mape(y_hat, y) * y.shape[0]\n", 118 | "\n", 119 | " # n 用于统计 DataLoader 中一共有多少数量\n", 120 | " n += y.shape[0]\n", 121 | "\n", 122 | " # 返回时需要除以 batch 大小，得到平均值\n", 123 | " return mae_sum / n, mape_sum / n" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 2, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "epoch 10, train loss 84.488137, valid loss 79.061480, train mae 6.191897, mape 0.462094, valid mae 6.191897,mape 0.462094, time 0.61 sec\n", 136 | "epoch 20, train loss 51.881460, valid loss 51.321243, train mae 5.388396, mape 0.598972, valid mae 5.388397,mape 0.598972, time 0.61 sec\n", 137 | "epoch 30, train loss 39.687344, valid loss 38.196685, train mae 4.188094, mape 0.422561, valid mae 4.188094,mape 0.422561, time 0.69 sec\n", 138 | "epoch 40, train loss 16.941381, valid loss 16.088817, train mae 1.840968, mape 0.093014, valid mae 1.840969,mape 0.093014, time 0.76 sec\n", 139 | "epoch 50, train loss 9.570748, valid loss 9.205929, train mae 1.287824, mape 0.066941, valid mae 1.287824,mape 0.066941, time 0.82 sec\n", 140 | "epoch 60, train loss 6.029313, valid loss 5.857967, train mae 0.953497, mape 0.050485, valid mae 0.953497,mape 0.050485, time 0.76 sec\n", 141 | "epoch 70, train loss 4.243387, valid loss 4.131803, train mae 0.773826, mape 0.044891, valid mae 0.773826,mape 0.044891, time 0.75 sec\n", 142 | "epoch 80, train loss 3.136638, valid loss 3.084975, train mae 0.667456, mape 0.040476, valid mae 0.667456,mape 0.040476, time 0.74 sec\n", 143 | "epoch 90, train loss 2.459801, valid loss 2.397520, train mae 0.565397, mape 0.033940, valid mae 0.565397,mape 0.033940, time 0.80 sec\n", 144 | "epoch 100, train loss 1.972009, valid loss 1.941861, train mae 0.518831, mape 0.032440, valid mae 0.518831,mape 0.032440, time 0.93 sec\n", 145 | "epoch 110, train loss 1.653135, valid loss 1.622370, train mae 0.501283, mape 0.034187, valid mae 0.501283,mape 0.034187, time 0.67 sec\n", 146 | "epoch 120, train loss 1.369202, valid loss 1.360729, train mae 0.468862, mape 0.031990, valid mae 0.468862,mape 0.031990, time 0.77 sec\n", 147 | "epoch 130, train loss 1.164905, valid loss 1.134859, train mae 0.427357, mape 0.028761, valid mae 0.427357,mape 0.028761, time 1.15 sec\n", 148 | "epoch 140, train loss 0.987103, valid loss 0.972625, train mae 0.415618, mape 0.029969, valid mae 0.415618,mape 0.029969, time 0.83 sec\n", 149 | "epoch 150, train loss 0.857409, valid loss 0.836930, train mae 0.383053, mape 0.027678, valid mae 0.383053,mape 0.027678, time 1.30 sec\n", 150 | "epoch 160, train loss 0.735783, valid loss 0.729461, train mae 0.361860, mape 0.025869, valid mae 0.361860,mape 0.025869, time 0.62 sec\n", 151 | "epoch 170, train loss 0.661346, valid loss 0.658983, train mae 0.348935, mape 0.025331, valid mae 0.348935,mape 0.025331, time 0.64 sec\n", 152 | "epoch 180, train loss 0.619186, valid loss 0.604036, train mae 0.338060, mape 0.024919, valid mae 0.338060,mape 0.024919, time 0.79 sec\n", 153 | "epoch 190, train loss 0.574209, valid loss 0.573524, train mae 0.351483, mape 0.026995, valid mae 0.351483,mape 0.026995, time 0.67 sec\n", 154 | "epoch 200, train loss 0.542768, valid loss 0.536849, train mae 0.334966, mape 0.025359, valid mae 0.334966,mape 0.025359, time 0.98 sec\n" 155 | ] 156 | } 157 | ], 158 | "source": [ 159 | "# 输入的数量是前 14 个交易日的收盘价\n", 160 | "num_inputs = 14\n", 161 | "# 输出是下一个交易日的收盘价\n", 162 | "num_outputs = 1\n", 163 | "# 隐藏层的个数\n", 164 | "num_hiddens = 128\n", 165 | "\n", 166 | "\n", 167 | "# 建立一个稍微复杂的 LSTM 模型\n", 168 | "class LSTM(nn.Module):\n", 169 | " def __init__(self, num_hiddens, num_outputs):\n", 170 | " super(LSTM, self).__init__()\n", 171 | " self.lstm = nn.LSTM(\n", 172 | " input_size=1,\n", 173 | " hidden_size=num_hiddens,\n", 174 | " num_layers=1,\n", 175 | " batch_first=True\n", 176 | " )\n", 177 | " self.fc = nn.Linear(num_hiddens, num_outputs)\n", 178 | "\n", 179 | " def forward(self, x):\n", 180 | " x = x.view(x.shape[0], -1, 1)\n", 181 | " r_out, (h_n, h_c) = self.lstm(x, None)\n", 182 | " out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output\n", 183 | " return out\n", 184 | "\n", 185 | "\n", 186 | "lstm = LSTM(num_hiddens, num_outputs).to(device)\n", 187 | "loss_fn = nn.MSELoss()\n", 188 | "optimizer = torch.optim.Adam(lstm.parameters(), lr=1e-3)\n", 189 | "\n", 190 | "\n", 191 | "# 用于绘图用的信息\n", 192 | "train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes = [], [], [], [], [], []\n", 193 | "\n", 194 | "# 循环 num_epochs 次\n", 195 | "epochs = 200\n", 196 | "for epoch in range(epochs):\n", 197 | " # 初始化参数\n", 198 | " train_l_sum, n = 0.0, 0\n", 199 | " # 初始化时间\n", 200 | " start = time.time()\n", 201 | "\n", 202 | " lstm.train()\n", 203 | "\n", 204 | " # 对训练数据集的每个 batch 执行\n", 205 | " for x, y in train_loader:\n", 206 | " x, y = x.to(device), y.to(device)\n", 207 | "\n", 208 | " y_hat = lstm(x)\n", 209 | " loss = loss_fn(y_hat, y)\n", 210 | " optimizer.zero_grad()\n", 211 | " loss.backward()\n", 212 | " optimizer.step()\n", 213 | " train_l_sum += loss.item() * y.shape[0]\n", 214 | "\n", 215 | " # 计数一共有多少个元素\n", 216 | " n += y.shape[0]\n", 217 | "\n", 218 | " # 模型开启预测状态\n", 219 | " lstm.eval()\n", 220 | "\n", 221 | " # 同样的，我们可以计算验证集上的 loss\n", 222 | " valid_l_sum, valid_n = 0, 0\n", 223 | " for x, y in valid_loader:\n", 224 | " x, y = x.to(device), y.to(device)\n", 225 | " y_hat = lstm(x)\n", 226 | " loss = loss_fn(y_hat, y)\n", 227 | "\n", 228 | " # 对 loss 求和（在下面打印出来）\n", 229 | " valid_l_sum += loss.item() * y.shape[0]\n", 230 | "\n", 231 | " # 计数一共有多少个元素\n", 232 | " valid_n += y.shape[0]\n", 233 | "\n", 234 | " # 对验证集合求指标\n", 235 | " # 这里训练集其实可以在循环内高效地直接算出，这里为了代码的可读性牺牲了效率\n", 236 | " train_mae, train_mape = evaluate_accuracy(train_loader, lstm)\n", 237 | " valid_mae, valid_mape = evaluate_accuracy(valid_loader, lstm)\n", 238 | " if (epoch + 1) % 10 == 0:\n", 239 | " print(\n", 240 | " 'epoch %d, train loss %.6f, valid loss %.6f, train mae %.6f, mape %.6f, valid mae %.6f,mape %.6f, time %.2f sec'\n", 241 | " % (epoch + 1, train_l_sum / n, valid_l_sum / valid_n, train_mae, train_mape, valid_mae, valid_mape,\n", 242 | " time.time() - start))\n", 243 | "\n", 244 | " # 记录绘图有关的信息\n", 245 | " train_losses.append(train_l_sum / n)\n", 246 | " valid_losses.append(valid_l_sum / valid_n)\n", 247 | " train_maes.append(train_mae)\n", 248 | " train_mapes.append(train_mape)\n", 249 | " valid_maes.append(valid_mae)\n", 250 | " valid_mapes.append(valid_mape)\n" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 3, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "data": { 260 | "text/plain": [ 261 | "" 262 | ] 263 | }, 264 | "execution_count": 3, 265 | "metadata": {}, 266 | "output_type": "execute_result" 267 | }, 268 | { 269 | "data": { 270 | "image/png": "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\n", 271 | "text/plain": [ 272 | "
" 273 | ] 274 | }, 275 | "metadata": { 276 | "needs_background": "light" 277 | }, 278 | "output_type": "display_data" 279 | } 280 | ], 281 | "source": [ 282 | "# 新建一个图像\n", 283 | "plt.figure(figsize=(16,8))\n", 284 | "\n", 285 | "# 绘制 train_loss 曲线\n", 286 | "plt.plot(train_losses, label='train_loss')\n", 287 | "\n", 288 | "# 绘制 valid_loss 曲线\n", 289 | "plt.plot(valid_losses, label='valid_loss')\n", 290 | "\n", 291 | "# 展示带标签的图像\n", 292 | "plt.legend()" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 4, 298 | "metadata": {}, 299 | "outputs": [ 300 | { 301 | "data": { 302 | "text/plain": [ 303 | "" 304 | ] 305 | }, 306 | "execution_count": 4, 307 | "metadata": {}, 308 | "output_type": "execute_result" 309 | }, 310 | { 311 | "data": { 312 | "image/png": "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\n", 313 | "text/plain": [ 314 | "
" 315 | ] 316 | }, 317 | "metadata": { 318 | "needs_background": "light" 319 | }, 320 | "output_type": "display_data" 321 | } 322 | ], 323 | "source": [ 324 | "# 新建一个图像\n", 325 | "plt.figure(figsize=(16,8))\n", 326 | "\n", 327 | "# 绘画结点\n", 328 | "plt.plot(train_maes, c='blue', label='train_mae')\n", 329 | "\n", 330 | "plt.plot(train_mapes, c='red', label='train_rmse')\n", 331 | "\n", 332 | "plt.plot(valid_maes, c='green', label='valid_mae')\n", 333 | "\n", 334 | "plt.plot(valid_mapes, c='orange', label='valid_rmse')\n", 335 | "\n", 336 | "# 展示图像\n", 337 | "plt.legend()" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 5, 343 | "metadata": {}, 344 | "outputs": [ 345 | { 346 | "data": { 347 | "text/plain": [ 348 | "" 349 | ] 350 | }, 351 | "execution_count": 5, 352 | "metadata": {}, 353 | "output_type": "execute_result" 354 | }, 355 | { 356 | "data": { 357 | "image/png": "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\n", 358 | "text/plain": [ 359 | "
" 360 | ] 361 | }, 362 | "metadata": { 363 | "needs_background": "light" 364 | }, 365 | "output_type": "display_data" 366 | } 367 | ], 368 | "source": [ 369 | "# 新建一个图像\n", 370 | "plt.figure(figsize=(16,8))\n", 371 | "\n", 372 | "# 预测结果\n", 373 | "x_test, y_test, y_hat = [], [], []\n", 374 | "for b_x, b_y in test_loader:\n", 375 | " b_x = b_x.to(device)\n", 376 | " y_pred = lstm(b_x).detach().cpu()\n", 377 | " y_test += list(b_y)\n", 378 | " y_hat += list(y_pred)\n", 379 | "\n", 380 | "# 绘画某些结点第一天的情况\n", 381 | "plt.plot(y_test[: 100], c='blue', label='y_test')\n", 382 | "plt.plot(y_hat[: 100], c='red', label='y_hat')\n", 383 | "\n", 384 | "# 展示图像\n", 385 | "plt.legend()" 386 | ] 387 | }, 388 | { 389 | "cell_type": "code", 390 | "execution_count": null, 391 | "metadata": {}, 392 | "outputs": [], 393 | "source": [] 394 | } 395 | ], 396 | "metadata": { 397 | "kernelspec": { 398 | "display_name": "Python 3", 399 | "language": "python", 400 | "name": "python3" 401 | }, 402 | "language_info": { 403 | "codemirror_mode": { 404 | "name": "ipython", 405 | "version": 3 406 | }, 407 | "file_extension": ".py", 408 | "mimetype": "text/x-python", 409 | "name": "python", 410 | "nbconvert_exporter": "python", 411 | "pygments_lexer": "ipython3", 412 | "version": "3.7.4" 413 | } 414 | }, 415 | "nbformat": 4, 416 | "nbformat_minor": 4 417 | } 418 | -------------------------------------------------------------------------------- /main.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# A 股预测\n", 8 | "
\n", 9 | "
" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "# 1.实验介绍" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "\n", 24 | "## 1.1 实验背景\n", 25 | "时间序列分析在金融、证券领域的应用非常广泛，尤其是对股票价格的预测。我们对数据进行预处理，接着使用数据分析方法，建立基础特征，进一步构建线性回归模型，且基于新数据验证模型效果。\n", 26 | "\n" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "## 1.2 实验要求\n", 34 | "输入某股票前 14 个交易日的收盘价，预测下一个交易日的收盘价。\n", 35 | "\n", 36 | "实验指标为平均绝对百分比误差（ `MAPE` ）和平均绝对误差（ `MAE` ）。\n", 37 | "\n" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "## 1.3 实验环境 \n", 45 | "可以使用基于 `Python` 的 `Pandas` 、 `Numpy` 、`Scikit-learn` 等库进行相关特征处理，使用 `Keras`、`Tensorflow`、`Pytorch` 等框架建立深度学习模型，使用过程中请注意 `Python` 包（库）的版本。\n", 46 | "\n" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## 1.4 注意事项\n", 54 | "- 使用平台的注意事项\n", 55 | "\n", 56 | "该平台的 `Notebook` 在 `CPU` 上运行，故尽量不要尝试在 `Notebook` 上做希望让 `GPU` 做的工作。\n", 57 | "\n", 58 | "- 训练模型的注意事项\n", 59 | "\n", 60 | "如果想要线下训练模型，请保证线下的环境与该平台一致，否则可能无法在该平台运行，可以在该平台的 `terminal` 输入```pip list```查看对应包版本。\n", 61 | "\n", 62 | "- 该作业的注意事项\n", 63 | "\n", 64 | "该作业目的在于加深对空间和时序模型的理解和运用，理论上作品的预测相关指标不应低于基本模型。\n", 65 | "\n" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "## 1.5 参考资料\n", 73 | "- 相关框架的文档\n", 74 | "\n", 75 | "scikit-learn: https://scikit-learn.org/stable/\n", 76 | "\n", 77 | "tensorflow: https://tensorflow.google.cn/tutorials?hl=zh_cn\n", 78 | "\n", 79 | "pytorch: https://pytorch.org/tutorials/\n", 80 | "\n", 81 | "- 框架的学习教程\n", 82 | "\n", 83 | "《动手学深度学习》(Pytorch版): https://tangshusen.me/Dive-into-DL-PyTorch/\n", 84 | "\n", 85 | "《深度学习框架PyTorch：入门与实战》: https://github.com/chenyuntc/pytorch-book" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "# 2.实验内容" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "## 2.1 数据集\n", 100 | "\n", 101 | "数据集由网上的相关平台获取，训练集给出了五十几支股票的情况。数据以 `npy` 格式给出，名称为`train_data.npy` 。\n" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "# 首先 import 一些主要的包\n", 111 | "import numpy as np\n", 112 | "import pandas as pd\n", 113 | "import time\n", 114 | "import matplotlib.pyplot as plt\n", 115 | "import os\n", 116 | "\n", 117 | "# 画图使用\n", 118 | "%matplotlib inline" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "# 简单读出一个股票\n", 128 | "\n", 129 | "# 获取文件名\n", 130 | "file_name = 'train_data.npy'\n", 131 | "\n", 132 | "# 读取数组\n", 133 | "data = np.load(file_name)\n", 134 | "\n", 135 | "# 简单展示信息\n", 136 | "data" 137 | ] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "接下来可以对其进行绘制，这样可以具体感受到股价的变化。" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "# 新建一个图像\n", 153 | "plt.figure(figsize=(20,10))\n", 154 | "\n", 155 | "# 绘画该股票不同的时间段的图像\n", 156 | "plt.plot(data,c='blue')\n", 157 | "\n", 158 | "# 展示图像\n", 159 | "plt.show()" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "注意到波动还是比较大的，且数值较大处和较小处相比差距存在，为了深度模型更好的工作，我们使用 `MinMaxScaler` 进行归一化。当然，用户也可以自行选择其他的预处理方式。\n", 167 | "\n", 168 | "这里我们选用 `sklearn` 的 `Scaler` ，如果有兴趣，也可以使用 `torchvision` 或者自己实现相关内容。\n", 169 | "\n", 170 | "当然， `MinMaxScaler` 并不是唯一的选择，甚至可能并不是正确的选择，这里只是用作示范，请自行学习相关内容并使用。\n", 171 | "\n", 172 | "但注意，如果 `scaler` 运算后的结果小于或等于 $0$ 可能带来严重后果，因为指标之一是 `MAPE` 。" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "from sklearn.preprocessing import MinMaxScaler\n", 182 | "\n", 183 | "# 这个 [0, 300] 是手动的预设值，可以自己更改\n", 184 | "scaler = MinMaxScaler().fit(np.array([0, 300]).reshape(-1, 1))" 185 | ] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "## 2.2 数据处理\n" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "首先需要生成题目所需的训练集合。" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [ 207 | "# 生成题目所需的训练集合\n", 208 | "def generate_data(data):\n", 209 | " \n", 210 | " # 记录 data 的长度\n", 211 | " n = data.shape[0]\n", 212 | " \n", 213 | " # 目标是生成可直接用于训练和测试的 x 和 y\n", 214 | " x = []\n", 215 | " y = []\n", 216 | " \n", 217 | " # 建立 (14 -> 1) 的 x 和 y\n", 218 | " for i in range(15, n):\n", 219 | " x.append(data[i-15:i-1])\n", 220 | " y.append(data[i])\n", 221 | " \n", 222 | " # 转换为 numpy 数组\n", 223 | " x = np.array(x)\n", 224 | " y = np.array(y)\n", 225 | " \n", 226 | " return x,y\n", 227 | "\n", 228 | "x,y = generate_data(data)\n", 229 | "print('x.shape : ', x.shape)\n", 230 | "print('y.shape : ', y.shape)" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "然后对数据集合进行分割，其中训练集用于训练，校验集用于检验模型训练情况，测试集合用于测试模型效果。" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "# 生成 train valid test 集合，以供训练所需\n", 247 | "def generate_training_data(x, y):\n", 248 | " # 样本总数\n", 249 | " num_samples = x.shape[0]\n", 250 | " # 测试集大小\n", 251 | " num_test = round(num_samples * 0.2)\n", 252 | " # 训练集大小\n", 253 | " num_train = round(num_samples * 0.7)\n", 254 | " # 校验集大小\n", 255 | " num_val = num_samples - num_test - num_train\n", 256 | " \n", 257 | " # 训练集拥有从 0 起长度为 num_train 的样本\n", 258 | " x_train, y_train = x[:num_train], y[:num_train]\n", 259 | " # 校验集拥有从 num_train 起长度为 num_val 的样本\n", 260 | " x_val, y_val = (\n", 261 | " x[num_train: num_train + num_val],\n", 262 | " y[num_train: num_train + num_val],\n", 263 | " )\n", 264 | " # 测试集拥有尾部 num_test 个样本\n", 265 | " x_test, y_test = x[-num_test:], y[-num_test:]\n", 266 | " \n", 267 | " # 返回这些集合\n", 268 | " return x_train, y_train, x_val, y_val, x_test, y_test\n", 269 | "\n", 270 | "x_train, y_train, x_val, y_val, x_test, y_test = generate_training_data(x, y)\n", 271 | "print('x_train.shape : ', x_train.shape)\n", 272 | "print('y_train.shape : ', y_train.shape)\n", 273 | "print('x_val.shape : ', x_val.shape)\n", 274 | "print('y_val.shape : ', y_val.shape)\n", 275 | "print('x_test.shape : ', x_test.shape)\n", 276 | "print('y_test.shape : ', y_test.shape)" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "## 2.3 建立一个简单的模型\n", 284 | "\n", 285 | "- 选用一种框架，告诉其创建模型的常用方式以及常用的接口\n", 286 | "- 建立一个简单模型并进行训练保存\n", 287 | "- 分析模型训练过程以及模型概况\n", 288 | "- 加载模型并对模型进行评估\n", 289 | "- **加载模型并预测输入数据的结果**" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "### 2.3.1 处理数据\n", 297 | "\n", 298 | "该实验示范使用 `Pytorch` 完成。也可以选用其他框架进行训练并预测结果。" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | "# 加载 pytorch\n", 308 | "import torch" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "处理数据，并将其转化为 `Pytorch` 的形式。" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [ 324 | "# 获取数据中的 x, y\n", 325 | "x,y = generate_data(data)\n", 326 | "\n", 327 | "# 将 x,y 转换乘 tensor ， Pytorch 模型默认的类型是 float32\n", 328 | "x = torch.tensor(x)\n", 329 | "y = torch.tensor(y)\n", 330 | "\n", 331 | "print(x.shape,y.shape)\n", 332 | "\n", 333 | "# 将 y 转化形状\n", 334 | "y = y.view(y.shape[0],1)\n", 335 | "\n", 336 | "print(x.shape,y.shape)" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": null, 342 | "metadata": {}, 343 | "outputs": [], 344 | "source": [ 345 | "# 对 x, y 进行 minmaxscale\n", 346 | "x_scaled = scaler.transform(x.reshape(-1,1)).reshape(-1,14)\n", 347 | "y_scaled = scaler.transform(y)\n", 348 | "\n", 349 | "x_scaled = torch.tensor(x_scaled, dtype=torch.float32)\n", 350 | "y_scaled = torch.tensor(y_scaled, dtype=torch.float32)" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": null, 356 | "metadata": {}, 357 | "outputs": [], 358 | "source": [ 359 | "# 处理出训练集，校验集和测试集\n", 360 | "x_train, y_train, x_val, y_val, x_test, y_test = generate_training_data(x_scaled, y_scaled)" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "为了方便使用 `DataLoader` ，我们需要自定义一个 `Dataset` ，自定义的 `Dataset` 只需要继承后实现下面三个函数。" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": null, 373 | "metadata": {}, 374 | "outputs": [], 375 | "source": [ 376 | "# 建立一个自定 Dataset\n", 377 | "class MyDataset(torch.utils.data.Dataset):\n", 378 | " def __init__(self, x, y):\n", 379 | " self.x = x\n", 380 | " self.y = y\n", 381 | " \n", 382 | " def __getitem__(self, item):\n", 383 | " return self.x[item], self.y[item]\n", 384 | " \n", 385 | " def __len__(self):\n", 386 | " return len(self.x)" 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": null, 392 | "metadata": {}, 393 | "outputs": [], 394 | "source": [ 395 | "# 建立训练数据集、校验数据集和测试数据集\n", 396 | "train_data = MyDataset(x_train,y_train)\n", 397 | "valid_data = MyDataset(x_val,y_val)\n", 398 | "test_data = MyDataset(x_test,y_test)" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": null, 404 | "metadata": {}, 405 | "outputs": [], 406 | "source": [ 407 | "# 规定批次的大小\n", 408 | "batch_size = 512\n", 409 | "\n", 410 | "# 创建对应的 DataLoader\n", 411 | "train_iter = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", 412 | "\n", 413 | "# 校验集和测试集的 shuffle 是没有必要的，因为每次都会全部跑一遍\n", 414 | "valid_iter = torch.utils.data.DataLoader(valid_data, batch_size=batch_size, shuffle=False)\n", 415 | "test_iter = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", 416 | "for i, read_data in enumerate(test_iter):\n", 417 | " # i表示第几个batch， data表示该batch对应的数据，包含data和对应的labels\n", 418 | " print(\"第 {} 个Batch \\n{}\".format(i, read_data))\n", 419 | " break\n", 420 | "# 表示输出数据\n", 421 | "print(read_data[0].shape, read_data[0])\n", 422 | "# 表示输出标签\n", 423 | "print(read_data[1].shape, read_data[1])" 424 | ] 425 | }, 426 | { 427 | "cell_type": "markdown", 428 | "metadata": {}, 429 | "source": [ 430 | "### 2.3.2 建立模型\n", 431 | "\n", 432 | "下面展示如何建立模型， `Pytorch` 的建立模型较为简单，只需要完成 `forward` ，即前向传播函数即可进行训练。这里展示建立一个简单的线性模型。参数 `Pytorch` 会自动初始化，具体请查看官方文档。" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": null, 438 | "metadata": {}, 439 | "outputs": [], 440 | "source": [ 441 | "# 输入的数量是前 14 个交易日的收盘价\n", 442 | "num_inputs = 14\n", 443 | "# 输出是下一个交易日的收盘价\n", 444 | "num_outputs = 1\n", 445 | "\n", 446 | "# 建立一个简单的线性模型\n", 447 | "class LinearNet(torch.nn.Module):\n", 448 | " def __init__(self, num_inputs, num_outputs):\n", 449 | " super(LinearNet, self).__init__()\n", 450 | " # 一个线性层\n", 451 | " self.linear = torch.nn.Linear(num_inputs, num_outputs)\n", 452 | " \n", 453 | " # 前向传播函数\n", 454 | " def forward(self, x): # x shape: (batch, 14)\n", 455 | " y = self.linear(x)\n", 456 | " return y" 457 | ] 458 | }, 459 | { 460 | "cell_type": "markdown", 461 | "metadata": {}, 462 | "source": [ 463 | "下面建立一个复杂但不太有效的 `LSTM` 模型，仅供理解 `Pytorch` 的运行方式而使用。" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": null, 469 | "metadata": {}, 470 | "outputs": [], 471 | "source": [ 472 | "# 隐藏层的个数\n", 473 | "num_hiddens = 128 \n", 474 | "# 建立一个稍微复杂的 LSTM 模型\n", 475 | "class LSTMNet(torch.nn.Module):\n", 476 | " def __init__(self, num_hiddens, num_outputs):\n", 477 | " super(LSTMNet, self).__init__()\n", 478 | " self.hidden_size = num_hiddens\n", 479 | " # RNN 层，这里的 batch_first 指定传入的是 (批大小，序列长度，序列每个位置的大小)\n", 480 | " # 如果不指定其为 True，传入顺序应当是 (序列长度，批大小，序列每个位置的大小)\n", 481 | " self.rnn = torch.nn.LSTM(input_size=num_inputs//24, hidden_size=num_hiddens,batch_first=True)\n", 482 | " # 线性层\n", 483 | " self.dense = torch.nn.Linear(self.hidden_size*24, 256)\n", 484 | " self.dense2 = torch.nn.Linear(256,num_outputs)\n", 485 | " # dropout 层，这里的参数指 dropout 的概率\n", 486 | " self.dropout = torch.nn.Dropout(0.3)\n", 487 | " self.dropout2 = torch.nn.Dropout(0.5)\n", 488 | " # ReLU 层\n", 489 | " self.relu = torch.nn.ReLU()\n", 490 | " \n", 491 | " # 前向传播函数，这是一个拼接的过程，使用大量变量是为了避免混淆，不做过多讲解\n", 492 | " def forward(self, x): # x shape: (batch_size, 24, 307)\n", 493 | " # LSTM 层会传出其参数，这里用 _ 将其舍弃\n", 494 | " h, _ = self.rnn(x)\n", 495 | " # LSTM 层会传出 (batch_size, 24, num_hiddens) 个参数，故需要 reshape 后丢入全连接层\n", 496 | " h_r = h.reshape(-1,self.hidden_size*24)\n", 497 | " h_d = self.dropout(h_r)\n", 498 | " y = self.dense(h_d)\n", 499 | " drop_y = self.dropout2(y)\n", 500 | " a = self.relu(drop_y)\n", 501 | " y2 = self.dense2(a)\n", 502 | " return y2" 503 | ] 504 | }, 505 | { 506 | "cell_type": "markdown", 507 | "metadata": {}, 508 | "source": [ 509 | "可以看到，`Pytorch`建立一个模型较为清楚简单，具体使用可以参考文档。\n", 510 | "\n", 511 | "`Pytorch` 在使用 `GPU` 和 `CPU` 上的写法有所不同。在需要将保存在内存中的数据在 `GPU` 上运行时，需要主动将数据和模型拷贝到显存。\n", 512 | "\n", 513 | "为了简化差异，我们使用一个布尔值：`use_gpu` 来判断是否可用 `GPU` ，从而淡化差异。这样就不需要写两份代码。" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": null, 519 | "metadata": {}, 520 | "outputs": [], 521 | "source": [ 522 | "# 判断 gpu 是否可用\n", 523 | "use_gpu = torch.cuda.is_available()\n", 524 | "\n", 525 | "# 另一种写法是固定 device，每次调用数据都 to(device)即可\n", 526 | "# device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" 527 | ] 528 | }, 529 | { 530 | "cell_type": "markdown", 531 | "metadata": {}, 532 | "source": [ 533 | "### 2.3.3 评估函数建立\n", 534 | "\n", 535 | "这里给出了评估使用的函数，可以自测以获得信息。\n", 536 | "\n", 537 | "实验指标为均方根误差（ `RMSE` ）和平均绝对误差（ `MAE` ）。" 538 | ] 539 | }, 540 | { 541 | "cell_type": "code", 542 | "execution_count": null, 543 | "metadata": {}, 544 | "outputs": [], 545 | "source": [ 546 | "def compute_mae(y_hat, y):\n", 547 | " '''\n", 548 | " :param y: 标准值\n", 549 | " :param y_hat: 用户的预测值\n", 550 | " :return: MAE 平均绝对误差 mean(|y*-y|)\n", 551 | " '''\n", 552 | " return torch.mean(torch.abs(y_hat - y))\n", 553 | "\n", 554 | "def compute_mape(y_hat, y):\n", 555 | " '''\n", 556 | " :param y: 标准值\n", 557 | " :param y_hat: 用户的预测值\n", 558 | " :return: MAPE 平均百分比误差 mean(|y*-y|/y)\n", 559 | " '''\n", 560 | " return torch.mean(torch.abs(y_hat - y)/y)" 561 | ] 562 | }, 563 | { 564 | "cell_type": "markdown", 565 | "metadata": {}, 566 | "source": [ 567 | "下面描绘评估函数，输入 `DataLoader` 和用户的模型，返回对应的 `MAE` 和 `RMSE` 。" 568 | ] 569 | }, 570 | { 571 | "cell_type": "code", 572 | "execution_count": null, 573 | "metadata": {}, 574 | "outputs": [], 575 | "source": [ 576 | "def evaluate_accuracy(data_iter, model):\n", 577 | " '''\n", 578 | " :param data_iter: 输入的 DataLoader\n", 579 | " :param model: 用户的模型\n", 580 | " :return: 对应的 MAE 和 MAPE\n", 581 | " '''\n", 582 | " # 初始化参数\n", 583 | " mae_sum, mape_sum, n = 0.0, 0.0, 0\n", 584 | " \n", 585 | " # 对每一个 data_iter 的每一个 x,y 进行计算\n", 586 | " for x, y in data_iter:\n", 587 | " \n", 588 | " # 如果运行在 GPU 上，需要将内存中的 x 拷贝到显存中\n", 589 | " if (use_gpu):\n", 590 | " x=x.cuda()\n", 591 | " \n", 592 | " # 计算模型得出的 y_hat\n", 593 | " y_hat = model(x)\n", 594 | " \n", 595 | " # 将 y_hat 逆归一化，这里逆归一化需要将数据转移到 CPU 才可以进行\n", 596 | " y_hat_real = torch.from_numpy(scaler.inverse_transform(np.array(y_hat.detach().cpu()).reshape(-1,1)).reshape(y_hat.shape))\n", 597 | " y_real = torch.from_numpy(scaler.inverse_transform(np.array(y.reshape(-1,1))).reshape(y.shape))\n", 598 | " \n", 599 | " # 计算对应的 MAE 和 RMSE 对应的和，并乘以 batch 大小\n", 600 | " mae_sum += compute_mae(y_hat_real,y_real) * y.shape[0]\n", 601 | " mape_sum += compute_mape(y_hat_real,y_real) * y.shape[0]\n", 602 | " \n", 603 | " # n 用于统计 DataLoader 中一共有多少数量\n", 604 | " n += y.shape[0]\n", 605 | " \n", 606 | " # 返回时需要除以 batch 大小，得到平均值\n", 607 | " return mae_sum / n, mape_sum / n" 608 | ] 609 | }, 610 | { 611 | "cell_type": "markdown", 612 | "metadata": {}, 613 | "source": [ 614 | "### 2.3.4 模型训练\n", 615 | "\n", 616 | "首先我们需要选取优化器和损失函数。\n", 617 | "\n", 618 | "`Pytorch` 使用的优化器和损失函数可以选用其提供的，也可以自己写。一般来说， `Pytorch` 自带的具有更好的数值稳定性，这里给出参考。" 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": null, 624 | "metadata": {}, 625 | "outputs": [], 626 | "source": [ 627 | "# 使用均方根误差\n", 628 | "loss = torch.nn.MSELoss()\n", 629 | "\n", 630 | "# 自定义的损失函数，可以直接调用\n", 631 | "def my_loss_func(y_hat, y):\n", 632 | " return compute_mae(y_hat, y)\n" 633 | ] 634 | }, 635 | { 636 | "cell_type": "markdown", 637 | "metadata": {}, 638 | "source": [ 639 | "`Pytorch` 的优化器需要提供 `model` 的 `parameters` ，故需要先定义网络。" 640 | ] 641 | }, 642 | { 643 | "cell_type": "code", 644 | "execution_count": null, 645 | "metadata": {}, 646 | "outputs": [], 647 | "source": [ 648 | "# 使用上面描述的线性网络\n", 649 | "model = LinearNet(num_inputs,num_outputs)\n", 650 | "\n", 651 | "# 使用 Adam 优化器， learning rate 调至 0.0001\n", 652 | "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", 653 | "\n", 654 | "# 也可选用 SGD 或其他优化器\n", 655 | "# optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9, weight_decay=0.1)" 656 | ] 657 | }, 658 | { 659 | "cell_type": "markdown", 660 | "metadata": {}, 661 | "source": [ 662 | "下面是训练函数。用于模型的直接训练。" 663 | ] 664 | }, 665 | { 666 | "cell_type": "code", 667 | "execution_count": null, 668 | "metadata": {}, 669 | "outputs": [], 670 | "source": [ 671 | "def train_model(model, train_iter, valid_iter, loss, num_epochs,\n", 672 | " params=None, optimizer=None):\n", 673 | " \n", 674 | " # 用于绘图用的信息\n", 675 | " train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes = [], [], [], [], [], []\n", 676 | " \n", 677 | " # 循环 num_epochs 次\n", 678 | " for epoch in range(num_epochs):\n", 679 | " # 初始化参数\n", 680 | " train_l_sum, n = 0.0, 0\n", 681 | " # 初始化时间\n", 682 | " start = time.time()\n", 683 | " # 模型改为训练状态，如果使用了 dropout, batchnorm 之类的层时，训练状态和评估状态的表现会有巨大差别\n", 684 | " model.train()\n", 685 | " \n", 686 | " # 对训练数据集的每个 batch 执行\n", 687 | " for x, y in train_iter:\n", 688 | " \n", 689 | " # 如果使用了 GPU 则拷贝进显存\n", 690 | " if (use_gpu):\n", 691 | " x,y = x.cuda(),y.cuda()\n", 692 | " \n", 693 | " # 计算 y_hat\n", 694 | " y_hat = model(x)\n", 695 | " \n", 696 | " # 计算损失\n", 697 | " l = loss(y_hat, y).mean()\n", 698 | "\n", 699 | " # 梯度清零\n", 700 | " optimizer.zero_grad()\n", 701 | " \n", 702 | " # L1 正则化\n", 703 | " # for param in params:\n", 704 | " # l += torch.sum(torch.abs(param))\n", 705 | " \n", 706 | " # L2 正则化可以在 optimizer 上加入 weight_decay 的方式加入\n", 707 | "\n", 708 | " # 求好对应的梯度\n", 709 | " l.backward()\n", 710 | "\n", 711 | " # 执行一次反向传播\n", 712 | " optimizer.step()\n", 713 | "\n", 714 | " # 对 loss 求和（在下面打印出来）\n", 715 | " train_l_sum += l.item() * y.shape[0]\n", 716 | " \n", 717 | " # 计数一共有多少个元素\n", 718 | " n += y.shape[0]\n", 719 | " \n", 720 | " # 模型开启预测状态\n", 721 | " model.eval()\n", 722 | " \n", 723 | " # 同样的，我们可以计算验证集上的 loss\n", 724 | " valid_l_sum, valid_n = 0, 0\n", 725 | " for x, y in valid_iter:\n", 726 | " # 如果使用了 GPU 则拷贝进显存\n", 727 | " if (use_gpu):\n", 728 | " x,y = x.cuda(),y.cuda()\n", 729 | " \n", 730 | " # 计算 y_hat\n", 731 | " y_hat = model(x)\n", 732 | " \n", 733 | " # 计算损失\n", 734 | " l = loss(y_hat, y).mean()\n", 735 | "\n", 736 | " # 对 loss 求和（在下面打印出来）\n", 737 | " valid_l_sum += l.item() * y.shape[0]\n", 738 | " \n", 739 | " # 计数一共有多少个元素\n", 740 | " valid_n += y.shape[0]\n", 741 | " \n", 742 | " # 对验证集合求指标\n", 743 | " # 这里训练集其实可以在循环内高效地直接算出，这里为了代码的可读性牺牲了效率\n", 744 | " train_mae, train_mape = evaluate_accuracy(train_iter, model)\n", 745 | " valid_mae, valid_mape = evaluate_accuracy(valid_iter, model)\n", 746 | " if (epoch+1) % 10 == 0:\n", 747 | " print('epoch %d, train loss %.6f, valid loss %.6f, train mae %.6f, mape %.6f, valid mae %.6f,mape %.6f, time %.2f sec'\n", 748 | " % (epoch + 1, train_l_sum / n, valid_l_sum / valid_n, train_mae, train_mape, valid_mae, valid_mape, time.time() - start))\n", 749 | " \n", 750 | " # 记录绘图有关的信息\n", 751 | " train_losses.append(train_l_sum / n)\n", 752 | " valid_losses.append(valid_l_sum / valid_n)\n", 753 | " train_maes.append(train_mae)\n", 754 | " train_mapes.append(train_mape)\n", 755 | " valid_maes.append(valid_mae)\n", 756 | " valid_mapes.append(valid_mape)\n", 757 | " \n", 758 | " # 返回一个训练好的模型和用于绘图的集合\n", 759 | " return model, (train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes)\n" 760 | ] 761 | }, 762 | { 763 | "cell_type": "markdown", 764 | "metadata": {}, 765 | "source": [ 766 | "下面进行正式的模型训练，但是这里的模型训练在这里的 `Notebook(CPU)` 上要耗费较长的时间（单 `epoch` 约 $20$ 秒），建议使用离线任务中的 `GPU` 完成该步骤。将对应的数据保存到 `results` 文件夹中，在 `Notebook` 中读取并绘图。" 767 | ] 768 | }, 769 | { 770 | "cell_type": "code", 771 | "execution_count": null, 772 | "metadata": {}, 773 | "outputs": [], 774 | "source": [ 775 | "# 训练模型\n", 776 | "model, (train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes) = train_model(model, train_iter, test_iter, loss, 200, model.parameters(), optimizer)" 777 | ] 778 | }, 779 | { 780 | "cell_type": "markdown", 781 | "metadata": {}, 782 | "source": [ 783 | "可以直接使用 `numpy` 保存并读取。" 784 | ] 785 | }, 786 | { 787 | "cell_type": "code", 788 | "execution_count": null, 789 | "metadata": {}, 790 | "outputs": [], 791 | "source": [ 792 | "# 为了方便储存与读取，建立成一个元组\n", 793 | "draw_data = (train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes)" 794 | ] 795 | }, 796 | { 797 | "cell_type": "code", 798 | "execution_count": null, 799 | "metadata": {}, 800 | "outputs": [], 801 | "source": [ 802 | "# 记录保存路径\n", 803 | "save_path = 'results/datas.npz'\n", 804 | "# 保存到硬盘\n", 805 | "np.savez(save_path, draw_data=draw_data)" 806 | ] 807 | }, 808 | { 809 | "cell_type": "code", 810 | "execution_count": null, 811 | "metadata": {}, 812 | "outputs": [], 813 | "source": [ 814 | "# 读取数据\n", 815 | "draw_data = np.load(save_path)['draw_data']" 816 | ] 817 | }, 818 | { 819 | "cell_type": "code", 820 | "execution_count": null, 821 | "metadata": {}, 822 | "outputs": [], 823 | "source": [ 824 | "# 提取其中的数据\n", 825 | "(train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes) = draw_data" 826 | ] 827 | }, 828 | { 829 | "cell_type": "markdown", 830 | "metadata": {}, 831 | "source": [ 832 | "### 2.3.5 模型的评估\n", 833 | "\n", 834 | "首先绘制训练图像，以供观测，下面绘制 `loss` 图像。" 835 | ] 836 | }, 837 | { 838 | "cell_type": "code", 839 | "execution_count": null, 840 | "metadata": {}, 841 | "outputs": [], 842 | "source": [ 843 | "# 新建一个图像\n", 844 | "plt.figure(figsize=(16,8))\n", 845 | "\n", 846 | "# 绘制 train_loss 曲线\n", 847 | "plt.plot(train_losses, label='train_loss')\n", 848 | "\n", 849 | "# 绘制 valid_loss 曲线\n", 850 | "plt.plot(valid_losses, label='valid_loss')\n", 851 | "\n", 852 | "# 展示带标签的图像\n", 853 | "plt.legend()" 854 | ] 855 | }, 856 | { 857 | "cell_type": "markdown", 858 | "metadata": {}, 859 | "source": [ 860 | "下面绘制 `MAE` 与 `RMSE` 在 `epoch` 中的变化。" 861 | ] 862 | }, 863 | { 864 | "cell_type": "code", 865 | "execution_count": null, 866 | "metadata": {}, 867 | "outputs": [], 868 | "source": [ 869 | "# 新建一个图像\n", 870 | "plt.figure(figsize=(16,8))\n", 871 | "\n", 872 | "# 绘画结点\n", 873 | "plt.plot(train_maes, c='blue', label='train_mae')\n", 874 | "\n", 875 | "plt.plot(train_mapes, c='red', label='train_rmse')\n", 876 | "\n", 877 | "plt.plot(valid_maes, c='green', label='valid_mae')\n", 878 | "\n", 879 | "plt.plot(valid_mapes, c='orange', label='valid_rmse')\n", 880 | "\n", 881 | "# 展示图像\n", 882 | "plt.legend()" 883 | ] 884 | }, 885 | { 886 | "cell_type": "markdown", 887 | "metadata": {}, 888 | "source": [ 889 | "下面绘制结点 $5$ 在校验集中与真实值的差距。这里仅考虑 `Notebook(CPU)` ， `GPU` 版本的需要稍加修改。" 890 | ] 891 | }, 892 | { 893 | "cell_type": "code", 894 | "execution_count": null, 895 | "metadata": {}, 896 | "outputs": [], 897 | "source": [ 898 | "# 新建一个图像\n", 899 | "plt.figure(figsize=(16,8))\n", 900 | "\n", 901 | "# 预测结果\n", 902 | "y_hat = model(x_test).detach()\n", 903 | "\n", 904 | "# 取前 300 个测试集\n", 905 | "num_for_draw = 300\n", 906 | "\n", 907 | "# 绘画某些结点第一天的情况\n", 908 | "plt.plot(scaler.inverse_transform(y_test[:num_for_draw].reshape(-1,1)).reshape(-1), c='blue', label='y_test')\n", 909 | "\n", 910 | "plt.plot(scaler.inverse_transform(y_hat[:num_for_draw].reshape(-1,1)).reshape(-1), c='red', label='y_hat')\n", 911 | "\n", 912 | "# 展示图像\n", 913 | "plt.legend()" 914 | ] 915 | }, 916 | { 917 | "cell_type": "markdown", 918 | "metadata": {}, 919 | "source": [ 920 | "当在校验集上取得较为满意的结果的时候，可以来到测试集一试。" 921 | ] 922 | }, 923 | { 924 | "cell_type": "code", 925 | "execution_count": null, 926 | "metadata": {}, 927 | "outputs": [], 928 | "source": [ 929 | "# 获得测试集的数据\n", 930 | "test_mae, test_mape = evaluate_accuracy(test_iter, model)\n", 931 | "\n", 932 | "print('test mae, rmse: %.3f,%.3f' % (test_mae,test_mape))" 933 | ] 934 | }, 935 | { 936 | "cell_type": "markdown", 937 | "metadata": {}, 938 | "source": [ 939 | "在测试集也能取得满意结果的时候，可以在平台上测试并提交。" 940 | ] 941 | }, 942 | { 943 | "cell_type": "markdown", 944 | "metadata": {}, 945 | "source": [ 946 | "### 2.3.6 保存和读取模型\n", 947 | "\n", 948 | "下面介绍保存和读取模型。模型应当保存在`results`文件夹下。" 949 | ] 950 | }, 951 | { 952 | "cell_type": "code", 953 | "execution_count": null, 954 | "metadata": {}, 955 | "outputs": [], 956 | "source": [ 957 | "# 设计目录\n", 958 | "model_path = 'results/mymodel.pt'\n", 959 | "# 保存模型\n", 960 | "torch.save(model.state_dict(), model_path)" 961 | ] 962 | }, 963 | { 964 | "cell_type": "markdown", 965 | "metadata": {}, 966 | "source": [ 967 | "读取模型" 968 | ] 969 | }, 970 | { 971 | "cell_type": "code", 972 | "execution_count": null, 973 | "metadata": {}, 974 | "outputs": [], 975 | "source": [ 976 | "# 指定目录\n", 977 | "model_path = 'results/mymodel.pt'\n", 978 | "# 选用使用的模型类\n", 979 | "model = LinearNet(num_inputs,num_outputs)\n", 980 | "# 读入对应的参数\n", 981 | "model.load_state_dict(torch.load(model_path))\n", 982 | "# \n", 983 | "model.eval()" 984 | ] 985 | }, 986 | { 987 | "cell_type": "markdown", 988 | "metadata": {}, 989 | "source": [ 990 | " ### 2.3.7 torch 张量 和 numpy.ndarray 数据类型相互转换 " 991 | ] 992 | }, 993 | { 994 | "cell_type": "code", 995 | "execution_count": null, 996 | "metadata": {}, 997 | "outputs": [], 998 | "source": [ 999 | "# torch.Tensor 转化为 numpy.ndarray\n", 1000 | "x_torch = torch.empty(3,5)\n", 1001 | "print(type(x_torch))\n", 1002 | "\n", 1003 | "# torch to numpy\n", 1004 | "x_numpy = x_torch.numpy()\n", 1005 | "x_numpy_v2 = np.array(x_torch)\n", 1006 | "print(type(x_numpy))\n", 1007 | "print(type(x_numpy_v2))\n", 1008 | "\n", 1009 | "# numpy to torch\n", 1010 | "x_torch_v2 = torch.from_numpy(x_numpy)\n", 1011 | "print(type(x_torch_v2))" 1012 | ] 1013 | }, 1014 | { 1015 | "cell_type": "markdown", 1016 | "metadata": {}, 1017 | "source": [ 1018 | "# 3.作业\n", 1019 | "\n", 1020 | "## 3.1 训练模型\n", 1021 | "- 模型训练时请主要在 `GPU` 上训练，在平台上可以使用离线任务 `GPU` 完成，并将模型保存到 `results` 文件夹中，并在模型预测时读取。" 1022 | ] 1023 | }, 1024 | { 1025 | "cell_type": "code", 1026 | "execution_count": null, 1027 | "metadata": {}, 1028 | "outputs": [], 1029 | "source": [ 1030 | "def train():\n", 1031 | " '''训练模型\n", 1032 | " :return: model 一个训练好的模型\n", 1033 | " '''\n", 1034 | " \n", 1035 | " model = None\n", 1036 | " # --------------------------- 此处下方加入训练模型相关代码 -------------------------------\n", 1037 | " \n", 1038 | " \n", 1039 | " \n", 1040 | " \n", 1041 | " \n", 1042 | " # 如果使用的不是 pytorch 框架，还需要改动下面的代码\n", 1043 | " # 模型保存的位置\n", 1044 | " model_path = 'results/mymodel.pt'\n", 1045 | " # 保存模型\n", 1046 | " torch.save(model.state_dict(), model_path)\n", 1047 | " # --------------------------- 此处上方加入训练模型相关代码 -------------------------------\n", 1048 | " \n", 1049 | " \n", 1050 | " \n", 1051 | " return model" 1052 | ] 1053 | }, 1054 | { 1055 | "cell_type": "markdown", 1056 | "metadata": {}, 1057 | "source": [ 1058 | "\n", 1059 | "## 3.2 模型预测\n", 1060 | "\n", 1061 | "注意事项：\n", 1062 | "1. 本实验并不严格限定使用的框架，可以使用 `Pytorch` , `Tensorflow` 或其他框架。只需训练好模型并保存，并在下文中写入合适的读取模型并实现预测即可。\n", 1063 | "2. 点击左侧栏`提交作业`后点击`生成文件`则只需勾选 `predict()` 函数的cell，即【**模型预测代码答题区域**】的 cell。\n", 1064 | "3. 请导入必要的包和第三方库 (包括此文件中曾经导入过的)。\n", 1065 | "4. 请加载你认为训练最佳的模型，即请按要求填写模型路径。\n", 1066 | "5. `predict()`函数的输入和输出请**不要改动**。\n", 1067 | "6. 注意，模型预测 `x.shape[0] < 20000` 的数据不能超过 $5$ 分钟，否则将被记为超时。\n", 1068 | "7. `predict()`函数 返回的类型必须是 `numpy` 数组类型。\n", 1069 | "8. 实验指标为平均绝对误差（ `MAPE` ）和平均绝对误差（ `MAE` ）。\n", 1070 | "9. 作业测试时记得填写你的模型路径及名称, 如果采用 [离线任务](https://momodel.cn/docs/#/zh-cn/%E5%9C%A8GPU%E6%88%96CPU%E8%B5%84%E6%BA%90%E4%B8%8A%E8%AE%AD%E7%BB%83%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%E6%A8%A1%E5%9E%8B) 请将模型保存在 **results** 文件夹下。" 1071 | ] 1072 | }, 1073 | { 1074 | "cell_type": "markdown", 1075 | "metadata": {}, 1076 | "source": [ 1077 | "在下方规定区域内写入**加载模型**的方式，该函数是在被测试和评估时调用的**预测函数**。注意，为了便于用户使用各种框架，输出的数组必须为 `numpy` 数组。\n", 1078 | "\n", 1079 | " ================== **提交 Notebook 训练模型结果数据处理参考示范** ==================" 1080 | ] 1081 | }, 1082 | { 1083 | "cell_type": "code", 1084 | "execution_count": null, 1085 | "metadata": { 1086 | "deletable": false, 1087 | "select": true 1088 | }, 1089 | "outputs": [], 1090 | "source": [ 1091 | "# 1.导入相关第三方库或者包（根据自己需求，可以增加、删除等改动）\n", 1092 | "import numpy as np\n", 1093 | "import pandas as pd\n", 1094 | "import time\n", 1095 | "import matplotlib.pyplot as plt\n", 1096 | "import os\n", 1097 | "import torch\n", 1098 | "from sklearn.preprocessing import MinMaxScaler\n", 1099 | "\n", 1100 | "# 2.导入 Notebook 使用的模型\n", 1101 | "# 建立一个简单的线性模型\n", 1102 | "class LinearNet(torch.nn.Module):\n", 1103 | " def __init__(self, num_inputs, num_outputs):\n", 1104 | " super(LinearNet, self).__init__()\n", 1105 | " # 一个线性层\n", 1106 | " self.linear = torch.nn.Linear(num_inputs, num_outputs)\n", 1107 | " \n", 1108 | " # 前向传播函数\n", 1109 | " def forward(self, x): # x shape: (batch, 14)\n", 1110 | " y = self.linear(x)\n", 1111 | " return y\n" 1112 | ] 1113 | }, 1114 | { 1115 | "cell_type": "markdown", 1116 | "metadata": {}, 1117 | "source": [ 1118 | "============================ **模型预测代码答题区域** ============================\n", 1119 | "
\n", 1120 | "在下方的代码块中编写 **模型预测** 部分的代码，请勿在别的位置作答" 1121 | ] 1122 | }, 1123 | { 1124 | "cell_type": "code", 1125 | "execution_count": null, 1126 | "metadata": { 1127 | "deletable": false, 1128 | "select": true 1129 | }, 1130 | "outputs": [], 1131 | "source": [ 1132 | "# 加载 Notebook 模型流程\n", 1133 | "\n", 1134 | "# 输入的数量是前 14 个交易日的收盘价\n", 1135 | "num_inputs = 14\n", 1136 | "# 输出是下一个交易日的收盘价\n", 1137 | "num_outputs = 1\n", 1138 | "\n", 1139 | "# ------------------------- 请加载您最满意的模型网络结构 -----------------------------\n", 1140 | "# 读取模型\n", 1141 | "model = LinearNet(num_inputs,num_outputs)\n", 1142 | " \n", 1143 | "# ----------------------------- 请加载您最满意的模型 -------------------------------\n", 1144 | "# 加载模型(请加载你认为的最佳模型)\n", 1145 | "# 加载模型,加载请注意 model_path 是相对路径, 与当前文件同级。\n", 1146 | "# 如果你的模型是在 results 文件夹下的 temp.pth 模型，则 model_path = 'results/mymodel.pt'\n", 1147 | "# 模型保存的位置，如果模型路径不同，请修改！！！\n", 1148 | "model_path = 'results/mymodel.pt'\n", 1149 | "model.load_state_dict(torch.load(model_path))\n", 1150 | "model.eval()\n", 1151 | "\n", 1152 | "def predict(test_x):\n", 1153 | " '''\n", 1154 | " 对于给定的 x 预测未来的 y 。\n", 1155 | " :param test_x: 给定的数据集合 x ，对于其中的每一个元素需要预测对应的 y 。e.g.:np.array([[6.69,6.72,6.52,6.66,6.74,6.55,6.35,6.14,6.18,6.17,5.72,5.78,5.69,5.67]]\n", 1156 | " :return: test_y 对于每一个 test_x 中的元素，给出一个对应的预测值。e.g.:np.array([[0.0063614]])\n", 1157 | " '''\n", 1158 | " # test 的数目\n", 1159 | " n_test = test_x.shape[0]\n", 1160 | " \n", 1161 | " test_y = None\n", 1162 | " # --------------------------- 此处下方加入读入模型和预测相关代码 -------------------------------\n", 1163 | " # 此处为 Notebook 模型示范，你可以根据自己数据处理方式进行改动\n", 1164 | " # scaler = MinMaxScaler().fit(np.array([0, 300]).reshape(-1, 1))\n", 1165 | " # test_x = scaler.transform(test_x.reshape(-1, 1)).reshape(-1, 14)\n", 1166 | " test_x = torch.tensor(test_x, dtype=torch.float32)\n", 1167 | " \n", 1168 | " test_y = model(test_x)\n", 1169 | " \n", 1170 | " # 如果使用 MinMaxScaler 进行数据处理，预测后应使用下一句将预测值放缩到原范围内\n", 1171 | " # test_y = scaler.inverse_transform(test_y.detach().cpu())\n", 1172 | " test_y = test_y.detach().cpu().numpy()\n", 1173 | " # --------------------------- 此处上方加入读入模型和预测相关代码 -------------------------------\n", 1174 | " \n", 1175 | " # 保证输出的是一个 numpy 数组\n", 1176 | " assert(type(test_y) == np.ndarray)\n", 1177 | " \n", 1178 | " # 保证 test_y 的 shape 正确\n", 1179 | " assert(test_y.shape == (n_test, 1))\n", 1180 | " \n", 1181 | " return test_y" 1182 | ] 1183 | }, 1184 | { 1185 | "cell_type": "code", 1186 | "execution_count": null, 1187 | "metadata": {}, 1188 | "outputs": [], 1189 | "source": [ 1190 | "# 测试用例\n", 1191 | "model_test_x = np.array([[6.69,6.72,6.52,6.66,6.74,6.55,6.35,6.14,6.18,6.17,5.72,5.78,5.69,5.67]])\n", 1192 | "print(predict(test_x = model_test_x))" 1193 | ] 1194 | }, 1195 | { 1196 | "cell_type": "markdown", 1197 | "metadata": {}, 1198 | "source": [ 1199 | "## 3.3 提交程序报告\n", 1200 | "\n", 1201 | "为了检查作业的详实程度及具体方法，本实验需要提交程序报告。\n", 1202 | "\n", 1203 | "提交作业时请记得左侧文件列表中上传『程序报告.docx』或者 『程序报告.pdf』。" 1204 | ] 1205 | } 1206 | ], 1207 | "metadata": { 1208 | "kernelspec": { 1209 | "display_name": "Python 3", 1210 | "language": "python", 1211 | "name": "python3" 1212 | }, 1213 | "language_info": { 1214 | "codemirror_mode": { 1215 | "name": "ipython", 1216 | "version": 3 1217 | }, 1218 | "file_extension": ".py", 1219 | "mimetype": "text/x-python", 1220 | "name": "python", 1221 | "nbconvert_exporter": "python", 1222 | "pygments_lexer": "ipython3", 1223 | "version": "3.7.5" 1224 | } 1225 | }, 1226 | "nbformat": 4, 1227 | "nbformat_minor": 4 1228 | } 1229 | -------------------------------------------------------------------------------- /predict.py: -------------------------------------------------------------------------------- 1 | # 1.导入相关第三方库或者包（根据自己需求，可以增加、删除等改动） 2 | import numpy as np 3 | import pandas as pd 4 | import time 5 | import matplotlib.pyplot as plt 6 | import os 7 | import torch 8 | import torch.nn as nn 9 | from sklearn.preprocessing import MinMaxScaler 10 | 11 | 12 | # 2.导入 Notebook 使用的模型 13 | # 建立一个稍微复杂的 LSTM 模型 14 | class LSTM(nn.Module): 15 | def __init__(self, num_hiddens, num_outputs): 16 | super(LSTM, self).__init__() 17 | self.lstm = nn.LSTM( 18 | input_size=1, 19 | hidden_size=num_hiddens, 20 | num_layers=1, 21 | batch_first=True 22 | ) 23 | self.fc = nn.Linear(num_hiddens, num_outputs) 24 | 25 | def forward(self, x): 26 | x = x.view(x.shape[0], -1, 1) 27 | r_out, (h_n, h_c) = self.lstm(x, None) 28 | out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output 29 | return out 30 | 31 | 32 | # 输入的数量是前 14 个交易日的收盘价 33 | num_inputs = 14 34 | # 输出是下一个交易日的收盘价 35 | num_outputs = 1 36 | 37 | # ------------------------- 请加载您最满意的模型网络结构 ----------------------------- 38 | # 读取模型 39 | model = LSTM(128, num_outputs) 40 | 41 | model_path = 'results/model.pt' 42 | model.load_state_dict(torch.load(model_path)) 43 | model.eval() 44 | 45 | 46 | def predict(test_x): 47 | ''' 48 | 对于给定的 x 预测未来的 y 。 49 | :param test_x: 给定的数据集合 x ，对于其中的每一个元素需要预测对应的 y 。e.g.:np.array([[6.69,6.72,6.52,6.66,6.74,6.55,6.35,6.14,6.18,6.17,5.72,5.78,5.69,5.67]] 50 | :return: test_y 对于每一个 test_x 中的元素，给出一个对应的预测值。e.g.:np.array([[0.0063614]]) 51 | ''' 52 | # test 的数目 53 | n_test = test_x.shape[0] 54 | 55 | test_y = None 56 | # --------------------------- 此处下方加入读入模型和预测相关代码 ------------------------------- 57 | # 此处为 Notebook 模型示范，你可以根据自己数据处理方式进行改动 58 | # scaler = MinMaxScaler().fit(np.array([0, 300]).reshape(-1, 1)) 59 | # test_x = scaler.transform(test_x.reshape(-1, 1)).reshape(-1, 14) 60 | test_x = torch.tensor(test_x, dtype=torch.float32) 61 | 62 | test_y = model(test_x) 63 | 64 | # 如果使用 MinMaxScaler 进行数据处理，预测后应使用下一句将预测值放缩到原范围内 65 | # test_y = scaler.inverse_transform(test_y.detach().cpu()) 66 | test_y = test_y.detach().cpu().numpy() 67 | # --------------------------- 此处上方加入读入模型和预测相关代码 ------------------------------- 68 | 69 | # 保证输出的是一个 numpy 数组 70 | assert (type(test_y) == np.ndarray) 71 | 72 | # 保证 test_y 的 shape 正确 73 | assert (test_y.shape == (n_test, 1)) 74 | 75 | return test_y -------------------------------------------------------------------------------- /predict_scaler.py: -------------------------------------------------------------------------------- 1 | # 1.导入相关第三方库或者包（根据自己需求，可以增加、删除等改动） 2 | import numpy as np 3 | import pandas as pd 4 | import time 5 | import matplotlib.pyplot as plt 6 | import os 7 | import torch 8 | import torch.nn as nn 9 | from sklearn.preprocessing import MinMaxScaler 10 | 11 | 12 | # 2.导入 Notebook 使用的模型 13 | # 建立一个稍微复杂的 LSTM 模型 14 | class LSTM(nn.Module): 15 | def __init__(self, num_hiddens, num_outputs): 16 | super(LSTM, self).__init__() 17 | self.lstm = nn.LSTM( 18 | input_size=1, 19 | hidden_size=num_hiddens, 20 | num_layers=1, 21 | batch_first=True 22 | ) 23 | self.fc = nn.Linear(num_hiddens, num_outputs) 24 | 25 | def forward(self, x): 26 | x = x.view(x.shape[0], -1, 1) 27 | r_out, (h_n, h_c) = self.lstm(x, None) 28 | out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output 29 | return out 30 | 31 | 32 | # 输入的数量是前 14 个交易日的收盘价 33 | num_inputs = 14 34 | # 输出是下一个交易日的收盘价 35 | num_outputs = 1 36 | 37 | # ------------------------- 请加载您最满意的模型网络结构 ----------------------------- 38 | # 读取模型 39 | model = LSTM(128, num_outputs) 40 | 41 | model_path = 'results/model_scaler.pt' 42 | model.load_state_dict(torch.load(model_path)) 43 | model.eval() 44 | 45 | 46 | def predict(test_x): 47 | ''' 48 | 对于给定的 x 预测未来的 y 。 49 | :param test_x: 给定的数据集合 x ，对于其中的每一个元素需要预测对应的 y 。e.g.:np.array([[6.69,6.72,6.52,6.66,6.74,6.55,6.35,6.14,6.18,6.17,5.72,5.78,5.69,5.67]] 50 | :return: test_y 对于每一个 test_x 中的元素，给出一个对应的预测值。e.g.:np.array([[0.0063614]]) 51 | ''' 52 | # test 的数目 53 | n_test = test_x.shape[0] 54 | 55 | test_y = None 56 | # --------------------------- 此处下方加入读入模型和预测相关代码 ------------------------------- 57 | # 此处为 Notebook 模型示范，你可以根据自己数据处理方式进行改动 58 | scaler = MinMaxScaler() 59 | scaler.fit(np.array([0, 300]).reshape(-1, 1)) 60 | test_x = scaler.transform(test_x.reshape(-1, 1)).reshape(-1, 14) 61 | test_x = torch.tensor(test_x, dtype=torch.float32) 62 | 63 | test_y = model(test_x) 64 | 65 | # 如果使用 MinMaxScaler 进行数据处理，预测后应使用下一句将预测值放缩到原范围内 66 | test_y = scaler.inverse_transform(test_y.detach().cpu()) 67 | # --------------------------- 此处上方加入读入模型和预测相关代码 ------------------------------- 68 | 69 | # 保证输出的是一个 numpy 数组 70 | assert (type(test_y) == np.ndarray) 71 | 72 | # 保证 test_y 的 shape 正确 73 | assert (test_y.shape == (n_test, 1)) 74 | 75 | return test_y -------------------------------------------------------------------------------- /results/_README.md: -------------------------------------------------------------------------------- 1 | 如果你使用了 job 功能，请把你的训练结果保存在这个文件夹内 2 | 3 | Please store your training checkpoints or results here 4 | -------------------------------------------------------------------------------- /results/model.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QikaiXu/Stock-Forecasting/ccaa1462ef071ac7943e1dc70b4a916f8408b3cc/results/model.pt -------------------------------------------------------------------------------- /results/model_scaler.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QikaiXu/Stock-Forecasting/ccaa1462ef071ac7943e1dc70b4a916f8408b3cc/results/model_scaler.pt -------------------------------------------------------------------------------- /results/tb_results/README.md: -------------------------------------------------------------------------------- 1 | 如果你使用了 tensorboard，请把你的 tensorboard 相关文件保存在这个文件夹内 2 | 3 | Please store your tensorboard results here 4 | -------------------------------------------------------------------------------- /train.py: -------------------------------------------------------------------------------- 1 | # 首先 import 一些主要的包 2 | import numpy as np 3 | import time 4 | import matplotlib.pyplot as plt 5 | import os 6 | import torch 7 | import torch.nn as nn 8 | import torch.utils.data as Data 9 | 10 | 11 | device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') 12 | 13 | 14 | # 获取文件名 15 | file_name = 'train_data.npy' 16 | 17 | # 读取数组 18 | data = np.load(file_name) 19 | 20 | 21 | # 生成题目所需的数据集合 22 | def generate_data(data): 23 | # 记录 data 的长度 24 | n = data.shape[0] 25 | 26 | # 目标是生成可直接用于训练和测试的 x 和 y 27 | x = [] 28 | y = [] 29 | 30 | # 建立 (14 -> 1) 的 x 和 y 31 | for i in range(15, n): 32 | x.append(data[i - 15: i - 1]) 33 | y.append(data[i - 1]) 34 | 35 | # 转换为 numpy 数组 36 | x = np.array(x) 37 | y = np.array(y) 38 | 39 | return x, y 40 | 41 | 42 | x, y = generate_data(data) 43 | x = torch.tensor(x, dtype=torch.float32) 44 | y = torch.tensor(y, dtype=torch.float32) 45 | 46 | # 将 y 转化形状 47 | y = torch.unsqueeze(y, dim=1) 48 | print(x.shape, y.shape) 49 | 50 | # 样本总数 51 | num_samples = x.shape[0] 52 | num_train = round(num_samples * 0.8) 53 | num_valid = round(num_samples * 0.1) 54 | num_test = num_samples - num_train - num_valid 55 | 56 | dataset = Data.TensorDataset(x, y) 57 | train_data, valid_data, test_data = Data.random_split(dataset, (num_train, num_valid, num_test)) 58 | 59 | batch_size = 512 60 | train_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=True) 61 | valid_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False) 62 | test_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False) 63 | 64 | 65 | def compute_mae(y_hat, y): 66 | """ 67 | :param y_hat: 用户的预测值 68 | :param y: 标准值 69 | :return: MAE 平均绝对误差 mean(|y*-y|) 70 | """ 71 | return torch.mean(torch.abs(y_hat - y)) 72 | 73 | 74 | def compute_mape(y_hat, y): 75 | """ 76 | :param y_hat: 用户的预测值 77 | :param y: 标准值 78 | :return: MAPE 平均百分比误差 mean(|y*-y|/y) 79 | """ 80 | return torch.mean(torch.abs(y_hat - y)/y) 81 | 82 | 83 | def evaluate_accuracy(data_loader, model): 84 | """ 85 | :param data_loader: 输入的 DataLoader 86 | :param model: 用户的模型 87 | :return: 对应的 MAE 和 MAPE 88 | """ 89 | # 初始化参数 90 | mae_sum, mape_sum, n = 0.0, 0.0, 0 91 | 92 | # 对每一个 data_iter 的每一个 x,y 进行计算 93 | for x, y in data_loader: 94 | x = x.to(device) 95 | # 计算模型得出的 y_hat 96 | y_hat = model(x) 97 | 98 | # 计算对应的 MAE 和 RMSE 对应的和，并乘以 batch 大小 99 | mae_sum += compute_mae(y_hat, y) * y.shape[0] 100 | mape_sum += compute_mape(y_hat, y) * y.shape[0] 101 | 102 | # n 用于统计 DataLoader 中一共有多少数量 103 | n += y.shape[0] 104 | 105 | # 返回时需要除以 batch 大小，得到平均值 106 | return mae_sum / n, mape_sum / n 107 | 108 | 109 | # 输入的数量是前 14 个交易日的收盘价 110 | num_inputs = 14 111 | # 输出是下一个交易日的收盘价 112 | num_outputs = 1 113 | # 隐藏层的个数 114 | num_hiddens = 128 115 | 116 | 117 | # 建立一个稍微复杂的 LSTM 模型 118 | class LSTM(nn.Module): 119 | def __init__(self, num_hiddens, num_outputs): 120 | super(LSTM, self).__init__() 121 | self.lstm = nn.LSTM( 122 | input_size=1, 123 | hidden_size=num_hiddens, 124 | num_layers=1, 125 | batch_first=True 126 | ) 127 | self.fc = nn.Linear(num_hiddens, num_outputs) 128 | 129 | def forward(self, x): 130 | x = x.view(x.shape[0], -1, 1) 131 | r_out, (h_n, h_c) = self.lstm(x, None) 132 | out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output 133 | return out 134 | 135 | 136 | lstm = LSTM(num_hiddens, num_outputs).to(device) 137 | loss_fn = nn.MSELoss() 138 | optimizer = torch.optim.Adam(lstm.parameters(), lr=1e-3) 139 | 140 | # 循环 num_epochs 次 141 | epochs = 200 142 | for epoch in range(epochs): 143 | # 初始化参数 144 | train_l_sum, n = 0.0, 0 145 | # 初始化时间 146 | start = time.time() 147 | 148 | lstm.train() 149 | 150 | # 对训练数据集的每个 batch 执行 151 | for x, y in train_loader: 152 | x, y = x.to(device), y.to(device) 153 | 154 | y_hat = lstm(x) 155 | loss = loss_fn(y_hat, y) 156 | optimizer.zero_grad() 157 | loss.backward() 158 | optimizer.step() 159 | train_l_sum += loss.item() * y.shape[0] 160 | 161 | # 计数一共有多少个元素 162 | n += y.shape[0] 163 | 164 | # 模型开启预测状态 165 | lstm.eval() 166 | 167 | # 对验证集合求指标 168 | # 这里训练集其实可以在循环内高效地直接算出，这里为了代码的可读性牺牲了效率 169 | train_mae, train_mape = evaluate_accuracy(train_loader, lstm) 170 | valid_mae, valid_mape = evaluate_accuracy(valid_loader, lstm) 171 | if (epoch + 1) % 10 == 0: 172 | print( 173 | 'epoch %d, train loss %.6f, train mae %.6f, mape %.6f, valid mae %.6f, mape %.6f, time %.2f sec' 174 | % (epoch + 1, train_l_sum / n, train_mae, train_mape, valid_mae, valid_mape, time.time() - start)) 175 | 176 | 177 | torch.save(lstm.state_dict(), 'results/model.pt') 178 | 179 | -------------------------------------------------------------------------------- /train_data.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QikaiXu/Stock-Forecasting/ccaa1462ef071ac7943e1dc70b4a916f8408b3cc/train_data.npy -------------------------------------------------------------------------------- /train_scaler.py: -------------------------------------------------------------------------------- 1 | # 首先 import 一些主要的包 2 | import numpy as np 3 | import pandas as pd 4 | import time 5 | import matplotlib.pyplot as plt 6 | import os 7 | import torch 8 | import torch.nn as nn 9 | import torch.utils.data as Data 10 | from sklearn.preprocessing import MinMaxScaler 11 | 12 | 13 | device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') 14 | 15 | 16 | # 获取文件名 17 | file_name = 'train_data.npy' 18 | 19 | # 读取数组 20 | data = np.load(file_name) 21 | 22 | 23 | # 生成题目所需的训练集合 24 | def generate_data(data): 25 | # 记录 data 的长度 26 | n = data.shape[0] 27 | 28 | # 目标是生成可直接用于训练和测试的 x 和 y 29 | x = [] 30 | y = [] 31 | 32 | # 建立 (14 -> 1) 的 x 和 y 33 | for i in range(15, n): 34 | x.append(data[i - 15: i - 1]) 35 | y.append(data[i - 1]) 36 | 37 | # 转换为 numpy 数组 38 | x = np.array(x) 39 | y = np.array(y) 40 | 41 | return x, y 42 | 43 | 44 | x, y = generate_data(data) 45 | print(x.shape, y.shape) 46 | 47 | scaler = MinMaxScaler() 48 | scaler.fit(np.array([0, 300]).reshape(-1, 1)) 49 | x = scaler.transform(x.reshape(-1, 1)).reshape(-1, 14) 50 | y = scaler.transform(y.reshape(-1, 1)).reshape(-1) 51 | print(x.shape, y.shape) 52 | 53 | 54 | x = torch.tensor(x, dtype=torch.float32) 55 | y = torch.tensor(y, dtype=torch.float32) 56 | 57 | # 将 y 转化形状 58 | y = torch.unsqueeze(y, dim=1) 59 | print(x.shape, y.shape) 60 | 61 | # 样本总数 62 | num_samples = x.shape[0] 63 | num_train = round(num_samples * 0.8) 64 | num_valid = round(num_samples * 0.1) 65 | num_test = num_samples - num_train - num_valid 66 | 67 | dataset = Data.TensorDataset(x, y) 68 | train_data, valid_data, test_data = Data.random_split(dataset, (num_train, num_valid, num_test)) 69 | 70 | batch_size = 512 71 | train_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=True) 72 | valid_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False) 73 | test_loader = Data.DataLoader(train_data, batch_size=batch_size, shuffle=False) 74 | 75 | 76 | def compute_mae(y_hat, y): 77 | """ 78 | :param y_hat: 用户的预测值 79 | :param y: 标准值 80 | :return: MAE 平均绝对误差 mean(|y*-y|) 81 | """ 82 | return torch.mean(torch.abs(y_hat - y)) 83 | 84 | 85 | def compute_mape(y_hat, y): 86 | """ 87 | :param y_hat: 用户的预测值 88 | :param y: 标准值 89 | :return: MAPE 平均百分比误差 mean(|y*-y|/y) 90 | """ 91 | return torch.mean(torch.abs(y_hat - y)/y) 92 | 93 | 94 | def evaluate_accuracy(data_loader, model): 95 | """ 96 | :param data_loader: 输入的 DataLoader 97 | :param model: 用户的模型 98 | :return: 对应的 MAE 和 MAPE 99 | """ 100 | # 初始化参数 101 | mae_sum, mape_sum, n = 0.0, 0.0, 0 102 | 103 | # 对每一个 data_iter 的每一个 x,y 进行计算 104 | for x, y in data_loader: 105 | x = x.to(device) 106 | # 计算模型得出的 y_hat 107 | y_hat = model(x) 108 | y_hat_real = torch.from_numpy( 109 | scaler.inverse_transform(np.array(y_hat.detach().cpu()).reshape(-1, 1)).reshape(y_hat.shape)) 110 | y_real = torch.from_numpy(scaler.inverse_transform(np.array(y.reshape(-1, 1))).reshape(y.shape)) 111 | # 计算对应的 MAE 和 RMSE 对应的和，并乘以 batch 大小 112 | mae_sum += compute_mae(y_hat_real, y_real) * y.shape[0] 113 | mape_sum += compute_mape(y_hat_real, y_real) * y.shape[0] 114 | 115 | # n 用于统计 DataLoader 中一共有多少数量 116 | n += y.shape[0] 117 | 118 | # 返回时需要除以 batch 大小，得到平均值 119 | return mae_sum / n, mape_sum / n 120 | 121 | 122 | # 输入的数量是前 14 个交易日的收盘价 123 | num_inputs = 14 124 | # 输出是下一个交易日的收盘价 125 | num_outputs = 1 126 | # 隐藏层的个数 127 | num_hiddens = 128 128 | 129 | 130 | # 建立一个稍微复杂的 LSTM 模型 131 | class LSTM(nn.Module): 132 | def __init__(self, num_hiddens, num_outputs): 133 | super(LSTM, self).__init__() 134 | self.lstm = nn.LSTM( 135 | input_size=1, 136 | hidden_size=num_hiddens, 137 | num_layers=1, 138 | batch_first=True 139 | ) 140 | self.fc = nn.Linear(num_hiddens, num_outputs) 141 | 142 | def forward(self, x): 143 | x = x.view(x.shape[0], -1, 1) 144 | r_out, (h_n, h_c) = self.lstm(x, None) 145 | out = self.fc(r_out[:, -1, :]) # 只需要最后一个的output 146 | return out 147 | 148 | 149 | lstm = LSTM(num_hiddens, num_outputs).to(device) 150 | loss_fn = nn.MSELoss() 151 | optimizer = torch.optim.Adam(lstm.parameters(), lr=1e-3) 152 | 153 | 154 | # 用于绘图用的信息 155 | train_losses, valid_losses, train_maes, train_mapes, valid_maes, valid_mapes = [], [], [], [], [], [] 156 | 157 | # 循环 num_epochs 次 158 | epochs = 200 159 | for epoch in range(epochs): 160 | # 初始化参数 161 | train_l_sum, n = 0.0, 0 162 | # 初始化时间 163 | start = time.time() 164 | 165 | lstm.train() 166 | 167 | # 对训练数据集的每个 batch 执行 168 | for x, y in train_loader: 169 | x, y = x.to(device), y.to(device) 170 | 171 | y_hat = lstm(x) 172 | 173 | loss = loss_fn(y_hat, y) 174 | optimizer.zero_grad() 175 | loss.backward() 176 | optimizer.step() 177 | train_l_sum += loss.item() * y.shape[0] 178 | 179 | # 计数一共有多少个元素 180 | n += y.shape[0] 181 | 182 | # 模型开启预测状态 183 | lstm.eval() 184 | 185 | # 对验证集合求指标 186 | # 这里训练集其实可以在循环内高效地直接算出，这里为了代码的可读性牺牲了效率 187 | train_mae, train_mape = evaluate_accuracy(train_loader, lstm) 188 | valid_mae, valid_mape = evaluate_accuracy(valid_loader, lstm) 189 | if (epoch + 1) % 10 == 0: 190 | print( 191 | 'epoch %d, train loss %.6f, train mae %.6f, mape %.6f, valid mae %.6f, mape %.6f, time %.2f sec' 192 | % (epoch + 1, train_l_sum / n, train_mae, train_mape, valid_mae, valid_mape, time.time() - start)) 193 | 194 | 195 | torch.save(lstm.state_dict(), 'results/model_scaler.pt') 196 | 197 | --------------------------------------------------------------------------------