2024数模美赛参赛纪实(编程手视角)¶

2024-02-02 --- 2024-02-06

Day 1¶

阅读题目 (早)¶

早上8点起来，6点起来的队友已经将每个题目都大致看了一遍，然后开始边吃早餐边看题目边和队友讨论题目。

队友说，还是打算在MCM的三题(A B C题)里面选，所以我就着重看了这三题，D E F三题就只是简单扫了一眼了解了一下😅。

A题是关于 七鳃鳗 lampreys 的，大概是生态相关的问题。

B题是关于潜水艇，但看完后面的问题后，我感觉在建立相关的模型时，会需要地理相关的一些数据以及知识，感觉不是很好搞到这些数据。然后队友也说在读题目时有一个术语都不能准确理解具体是什么意思，所以我们优先排除了B题。

C题是关于网球，大概是需要根据提供的比赛时的数据，找到某种潜在的比赛球员赢球的 势头 momentum。

这时我和队友经过边看题边讨论，大概确定了选A题或C题，但还没最后确定选哪一题(队友说他打算第一天上午把题目确定好就行了)，然后我们就开始各自去查找资料(查找更多题目相关的资料来更深入了解题目，以便最终的选题确定)了。

了解网球规则¶

由于我理解的C题是需要寻找某种潜在的关系或者说规律，所以我觉得这很适合用机器学习来做，把C题所给的数据拿去跑。

于是我就开始去了解网球的规则(题目需要)，在b站上查看介绍网球比赛规则的相关视频，

• 网球规则解释（得分，术语等）_哔哩哔哩_bilibili
• 网球记分规则｜Alex的知识分享，内附Alex亲自上场示范～_哔哩哔哩_bilibili

看完这两个视频，明白了网球规则中的一些基础的概念，但还想再找更多的视频进行确认，而b站上感觉没有什么比较好且短的网球规则介绍视频了，于是我突然想到可以去油管上找，然后就找到一个帮助很大的视频(主要是英文的刚好能跟题目中的术语词汇对应上)，

• The Rules of Tennis - EXPLAINED! - YouTube

与老师讨论，确定选C题¶

到差不多11点左右，我们跟指导老师进行了讨论，老师当时主要看C题，并且也提到了可以运用机器学习去发掘潜在的关于势头的规律，(我的想法感觉跟老师不谋而合)于是我也跟老师说感觉这题适合用 神经网络 机器学习 来处理。

(我由于对模型和权重的概念还有些没厘清，于是向老师询问了一下)老师就进一步说到，这题大致的方案可以是先构建出模型，然后根据每个选手的数据训练出权重，最后应用权重在具体的数据上进行预测/估算。

因此我们最后决定了就选C题。

弄清楚字典中的各个术语¶

从11点半结束与老师的讨论，我们开始研究字典( data_dictionary.csv )中的那些变量名称，一直到12点左右各自去吃饭。其中几个比较关键的是

• serve_no 发球次数，即(在当前分中)第1次还是第2次发球(第2次发球包含双误 double fault的情况)
• ace 发球得分，仅通过发球直接赢得这一分(在油管视频中有介绍)
• xx_winner 正面赢球，通过打出让对手接不到的球而得分(与之相对的是对手失误而得分)，因此可能存在 p1 p2 都为 0 的情况
• xx_double_fault 双误，发球方在当前分发球两次都失误(下网或发球出界)，则会使对方得分
• xx_unf_err 非受迫性失误 unforced error ，类比羽毛球中的非受迫性失误，大概应该是主动失误丢分，像在不是拿点非常不好或者非常被动的情况下自己失误丢分
• xx_net_pt 网前回球，选手最后赢/输的那一球是在网前回的
• xx_net_pt_won 网前得分，与上面类似，只不过这球是赢了(感觉可能意味着拿点很好，因此会涨气势涨信心)
• xx_break_pt 在这一局中，作为接发方，并且如果赢下当前分则赢下这一局

因此最后我弄清楚的网球比分的规则和比赛得分的流程是这样的：

查找相关文献文章 (午)¶

下午从2点半左右到4点半左右，我和队友在查找运用 机器学习 神经网络 来对比赛形势进行预测的相关文献文章，

我主要找到了这两篇文献，

• A deep learning framework for football match prediction | Discover Applied Sciences (springer.com)
• Computers | Free Full-Text | On Predicting Soccer Outcomes in the Greek League Using Machine Learning (mdpi.com)

本来我是像通过查找文献来看能不能找到一些对于编程方面有用的一些东西，但是发现不太行，

所以在跟队友讨论了一下这两篇之后，就让他去参考这两篇文章去弄写作的事情去了，

初步复习以及进一步了解机器学习/神经网络¶

然后我开始在b站上搜索 机器学习/神经网络 相关的学习视频，我这时的想法是，找到一个教怎么去实现使用机器学习/神经网络的视频，然后我先跟着视频去实现/复现简单的神经网络，然后再根据题目的要求去修改代码，最终能将题目提供的数据用来训练

经过一番搜索，我发现了这个课程(一个非常好的课程，之前在23年4月在完成基地布置的考核任务时，任务中也有提到这个课程)，

合集·斯坦福2021秋季·实用机器学习【中文】【合集】-哔哩哔哩

浏览了一下每节课的标题，然后直接从3.1节 8分钟机器学习介绍开始看。

看到了5点多，然后6点队友想跟我讨论另一篇文献，讨论了大约半小时之后去吃饭了，吃完饭又感觉有点困不小心睡着了😅，到9点左右醒过来了，于是继续开始看

最后到这天晚上最后，大体看了这5节课

• 3.1 8分钟机器学习介绍
• 3.3 最简单也同样最常用的线性模型
• 3.5 多层感知机
• 3.6 卷积神经网络
• 3.7 循环神经网络

重新熟悉了一遍神经网络的基本的一些相关概念和大致结构，然后还新了解了 卷积神经网络CNN 递归神经网络RNN (之前只是知道这个名字，但不知道具体的与一般神经网络的区别以及各自的适用用途)。

根据我的看完之后的理解，大致是这样，CNN和RNN都是对于普通神经网络在特定用途下进行的改进的产物 或者说分支，

其中CNN是适用于处理图像的神经网络。由于一个图像包含的数据很大(300x300的像素就有9万个数据)，因此如果使用一般的神经网络，在迭代过程中会产生很多的参数。而图像又有一定的连续性(我的理解好像是这样的，但不知道是否准确)，因此使用卷积可以减小数据的量。

所以CNN对于这题中的数据就用不上。

而RNN是适用于处理有时间序列信息的数据(我觉得可以直接理解成，数据是一串或多串连续的序列的情况)，如 正常语句的字符串 或者 用于价格预测的历史数据 之类的，就是说 适用于 之前的数据有可能会影响到之后的数据 的情况

所以觉得RNN适合用于这题的数据处理。

还了解到RNN有两个优化的产物 GRU 和 LSTM 。

但这个课程中的这几节课感觉讲的比较多的是一些概念性的东西，没有太多的实现，然后我就注意到这个大佬up主还有一门主要教授各种神经网络的实现(主要使用pytorch来实现)的课 动手学深度学习v2，然后通过在他主页上搜索 rnn ，发现了两节课是讲rnn的，我觉得其中应该会有实现的代码，

• 54 循环神经网络 RNN【动手学深度学习v2】_哔哩哔哩_bilibili
• 55 循环神经网络 RNN 的实现【动手学深度学习v2】_哔哩哔哩_bilibili

但由于这天已经比较累了，所以就打算明天看这两节课来学习怎么实现RNN

Day 2¶

了解递归神经网络RNN的python实现 (早)¶

早上起来，接着昨天的进度看。

在看 54 循环神经网络 RNN 时，看到介绍RNN的应用的部分，就感觉C题的数据应该确实是可以用RNN来处理的，所以就差不多决定要使用RNN了

而在看 55 循环神经网络 RNN 的实现 时，本来是想边看边把视频中的代码敲出来，然后理解代码的每个部分的作用，但是看到训练部分的时候，发现有点复杂，开始不是那么好理解了 有点难懂😅，于是就去看p2的简洁实现了。

简洁实现 中的代码就没有那么多那么长了，于是我尝试运行，但发生了报错

AttributeError: module 'd2l.torch' has no attribute 'load_data_time_machine'

显示 d2l 包中没有 load_data_time_machine 这个函数或类

d2l 包应该是这个课程对应的专门用于教学的包，因为课程的教材网站名就叫 d2l

• 中文版网站 《动手学深度学习》 — 动手学深度学习 2.0.0 documentation (d2l.ai)
• 英文版网站 Dive into Deep Learning — Dive into Deep Learning 1.0.3 documentation (d2l.ai)

最后猜测可能是中文版教材中 d2l 包对应的版本比较老了，新版的包可能已经做了修改，于是去查看了英文版教材中的代码，复制出来然后尝试运行(我在两处 predict 的地方加了 print ，否则不会显示出结果)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

class RNN(d2l.Module):
    """The RNN model implemented with high-level APIs."""
    def __init__(self, num_inputs, num_hiddens):
        super().__init__()
        self.save_hyperparameters()
        self.rnn = nn.RNN(num_inputs, num_hiddens)

    def forward(self, inputs, H=None):
        return self.rnn(inputs, H)

class RNNLM(d2l.RNNLMScratch):
    """The RNN-based language model implemented with high-level APIs."""
    def init_params(self):
        self.linear = nn.LazyLinear(self.vocab_size)

    def output_layer(self, hiddens):
        return self.linear(hiddens).swapaxes(0, 1)

data = d2l.TimeMachine(batch_size=1024, num_steps=32)
rnn = RNN(num_inputs=len(data.vocab), num_hiddens=32)
model = RNNLM(rnn, vocab_size=len(data.vocab), lr=1)
# model.predict('it has', 20, data.vocab)
print(model.predict('it has', 20, data.vocab))

trainer = d2l.Trainer(max_epochs=100, gradient_clip_val=1, num_gpus=1)
trainer.fit(model, data)

# model.predict('it has', 20, data.vocab, d2l.try_gpu()
print(model.predict('it has', 20, data.vocab, d2l.try_gpu()))

运行的结果

it hasiiidddyiididyiididyi
<Figure size 350x250 with 1 Axes>
<Figure size 350x250 with 1 Axes>
...
it has and the proment the

但课程中也有提到GRU和LSTM是一般RNN的改进，两者效果差不多，但GRU似乎比LSTM简单一些(LSTM好像要更复杂一些)，所以决定最后要使用GRU来处理题目所给的数据

尝试实现GRU (午)¶

我直接打开了英文教材中的GRU部分 10.2. Gated Recurrent Units (GRU) ，将代码复制出来

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import torch
from torch import nn
from d2l import torch as d2l

class GRUScratch(d2l.Module):
    def __init__(self, num_inputs, num_hiddens, sigma=0.01):
        super().__init__()
        self.save_hyperparameters()

        init_weight = lambda *shape: nn.Parameter(torch.randn(*shape) * sigma)
        triple = lambda: (init_weight(num_inputs, num_hiddens),
                          init_weight(num_hiddens, num_hiddens),
                          nn.Parameter(torch.zeros(num_hiddens)))
        self.W_xz, self.W_hz, self.b_z = triple()  # Update gate
        self.W_xr, self.W_hr, self.b_r = triple()  # Reset gate
        self.W_xh, self.W_hh, self.b_h = triple()  # Candidate hidden state

@d2l.add_to_class(GRUScratch)
def forward(self, inputs, H=None):
    if H is None:
        # Initial state with shape: (batch_size, num_hiddens)
        H = torch.zeros((inputs.shape[1], self.num_hiddens),
                      device=inputs.device)
    outputs = []
    for X in inputs:
        Z = torch.sigmoid(torch.matmul(X, self.W_xz) +
                        torch.matmul(H, self.W_hz) + self.b_z)
        R = torch.sigmoid(torch.matmul(X, self.W_xr) +
                        torch.matmul(H, self.W_hr) + self.b_r)
        H_tilde = torch.tanh(torch.matmul(X, self.W_xh) +
                           torch.matmul(R * H, self.W_hh) + self.b_h)
        H = Z * H + (1 - Z) * H_tilde
        outputs.append(H)
    return outputs, H

data = d2l.TimeMachine(batch_size=1024, num_steps=32)
gru = GRUScratch(num_inputs=len(data.vocab), num_hiddens=32)
model = d2l.RNNLMScratch(gru, vocab_size=len(data.vocab), lr=4)
trainer = d2l.Trainer(max_epochs=50, gradient_clip_val=1, num_gpus=1)
trainer.fit(model, data)

print(model.predict('it has', 20, data.vocab, d2l.try_gpu()))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import torch
from torch import nn
from d2l import torch as d2l

class GRU(d2l.RNN):
    def __init__(self, num_inputs, num_hiddens):
        d2l.Module.__init__(self)
        self.save_hyperparameters()
        self.rnn = nn.GRU(num_inputs, num_hiddens)

data = d2l.TimeMachine(batch_size=1024, num_steps=32)
gru = GRU(num_inputs=len(data.vocab), num_hiddens=32)
model = d2l.RNNLM(gru, vocab_size=len(data.vocab), lr=4)
trainer = d2l.Trainer(max_epochs=50, gradient_clip_val=1, num_gpus=1)
trainer.fit(model, data)

print(model.predict('it has', 20, data.vocab, d2l.try_gpu()))

尝试运行并运行成功。

由于课程是使用的GRU来进行文本的预测，所以数据的格式肯定和题目所给的表格类型不太一样，于是我想看看能不能修改数据的格式并且还用教材上的代码来进行预测，

于是尝试询问copilot

import torch
from torch import nn
from d2l import torch as d2l

class GRU(d2l.RNN):
    def __init__(self, num_inputs, num_hiddens):
        d2l.Module.__init__(self)
        self.save_hyperparameters()
        self.rnn = nn.GRU(num_inputs, num_hiddens)

# 加载你的数据
# data 应该是一个可以迭代的数据集，每个元素都是一个形状为 (batch_size, sequence_length, num_features) 的张量
data = load_your_data()

num_features = data[0].shape[-1]  # 特征数量
num_targets = 1  # 目标值的数量，这里假设我们只有一个目标值

gru = GRU(num_inputs=num_features, num_hiddens=32)
model = d2l.RNNLM(gru, vocab_size=num_targets, lr=4)
trainer = d2l.Trainer(max_epochs=50, gradient_clip_val=1, num_gpus=1)
trainer.fit(model, data)

然后我就觉得，如果要对教材中的代码进行修改来适配这题的数据的使用的话，感觉不是那么方便，所以先放弃了这个想法

理解22年C题F奖GRU相关代码¶

由于在美赛开始的一周前，队友给我分享了一个github仓库

jishengpeng/2022MCM-C-problem: 2022美赛C题（MCM/ICM）F奖源码数据公开 (github.com)

是一支在22年美赛选择C题并最终获得F奖的队伍，仓库内有他们的论文以及处理数据的代码

所以另一个思路就是修改他们的代码，使得能适用于我们的题目所给的数据

确定衡量势头的方法¶

下午4点左右，因为在看着22年f奖的代码时，想到如果要将题目给的比赛时的各种状态的信息以及数据输入进行训练(或者说监督学习 supervised learning)，那么就还需要有确定的实际的势头结果用于训练时的检验，所以我突然有了一个想法，于是开始和队友讨论。

之前队友想的就是用下一分的输赢作为势头评判的标准(即把下一分赢的概率作为势头)，但我想到势头应该不止是对下一分有影响，应该还有可能影响到之后的几分，于是就和队友进行了讨论。

我们大致假设势头只体现在之后3分上(或者说再往后的分相关性不是那么大了，所以就忽略掉)，设 \(n_1\) \(n_2\) \(n_3\) 分别为之后第1 2 3分的输赢，赢为1 输为0，再假设势头与这3分结果的关系是这样的(最简单的线性关系，非线性感觉不好考虑) $$ 势头 = a \times n_1 + b \times n_2 + c \times n_3 $$ 然后我们打算通过分析一些比较显然的情况来确定参数 \(a\) \(b\) \(c\) 具体的大小(我认为直接凭感觉确定可能不一定是那么准确)，

• 首先可以确定的是后三分都赢或者后三分都输的情况，即 \(n_1=n_2=n_3=1\) 和 \(n_1=n_2=n_3=0\)

  1. 三分都赢时，我们想定势头为1，即 \(n_1=n_2=n_3=1\) 时 \(势头=1\) ，那么就能得到 $$ a+b+c=1 $$

  2. 三分都输时，我们认为势头应该为0，这个其实上只能得到势头的常数项为0，而我们假设的关系式中其实已经包含了这个条件

• 其次还可以确定的条件是，在后三分中只赢了1分的情况下，那么应该有 赢第1分的势头 > 赢第2分的势头 > 赢第3分的势头 ，那么就可以得到 $$ a > b > c > 0 $$

• 然后我们再取了一些特定的情况来进行比较，以此来进一步确定3个参数的大小。

  我们对只赢第1分和只输第1分(即赢了第2 3分)的情况进行分析比较，最后认为 只赢第1分的势头 应该略大于 只输第1分的势头，于是得到 $$ a > b + c $$

于是最后我们将系数确定成 \(a=0.55, b=0.25, c=0.2\) ，即 $$ 势头 = 0.55 n_1 + 0.25 n_2 + 0.2 n_3 $$ 然后我让队友随便挑一场比赛的数据，处理后按照公式算一算，然后队友选了决赛，下面是前100分冠军的势头

我感觉看起来还蛮ok的，这个波动感觉还算比较真实。

这时已经是晚上，累了一天就没有再做什么了

Day 3¶

继续理解22年C题F奖GRU相关代码 (早)¶

继续前一天的进度，

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
from sklearn import linear_model
from d2l import torch as d2l
import torch
import torch.nn as nn
import csv
path="/home/jishengpeng/美赛的模拟练习"
BCHAIN_MKPRU=pd.read_csv(path+"/BCHAIN-MKPRU.csv",dtype={"Date":np.str,"Value":np.float64})
LBMA_GOLD=pd.read_csv(path+"/LBMA-GOLD.csv",dtype={"Date":np.str,"Value":np.float64})
Data=pd.read_csv(path+"/C题处理后的中间文件2.csv")

def to_timestamp(date):
    return int(time.mktime(time.strptime(date,"%m/%d/%y")))

#将日期变为自然数
start_timestamp=to_timestamp(Data.iloc[0,0])
for i in range(Data.shape[0]):
    Data.iloc[i,0]=(to_timestamp(Data.iloc[i,0])-start_timestamp)/86400
print(Data)

batch_size=1 # 应该只能为1
start_input=30
input_size=Data.shape[0]#训练：通过前input_size天预测input_size+1天，预测：通过2到input_size+1天预测第input_size+2天
hidden_size=20
# input_size=200
output_size=1
layers_size=3
lr=10
num_epochs=1000

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, layers_size):
        super().__init__()
        self.GRU_layer = nn.GRU(input_size, hidden_size, layers_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.GRU_layer(x)
        x = self.linear(x)
        return x

device=torch.device("cuda")

gru=GRUModel(30, hidden_size, output_size, layers_size).to(device)

criterion = nn.L1Loss()
optimizer = torch.optim.Adam(gru.parameters(), lr)

ji=np.array(Data.iloc[0:input_size,3].dropna())
input_size=ji.shape[0]-2

trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30)).to(torch.float32).to(device)
trainB_y=torch.from_numpy(ji[input_size].reshape(-1,batch_size,output_size)).to(torch.float32).to(device)

losses = []

for epoch in range(num_epochs):
    output = gru(trainB_x).to(device)
    loss = criterion(output, trainB_y)
    losses.append(loss)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print("loss" + str(epoch) + ":", loss.item())

# 预测，以比特币为例
# pred_x_train=torch.from_numpy(np.array(Data.iloc[1:input_size+1,1]).reshape(-1,1,input_size)).to(torch.float32).to(device)
pred_x_train=torch.from_numpy(ji[input_size-29:input_size+1]).reshape(-1,1,30).to(torch.float32).to(device)
pred_y_train=gru(pred_x_train).to(device)
print("prediction:",pred_y_train.item())
print("actual:",ji[input_size+1])

# 预测代码
losses = []
predictions = []
actuals = []
for i in range(start_input, input_size + 1):
    print("进行到input_size=", i)
    # gru=GRUModel(i, hidden_size, output_size, layers_size).to(device)
    gru = GRUModel(30, hidden_size, output_size, layers_size).to(device)
    criterion = nn.L1Loss()
    optimizer = torch.optim.Adam(gru.parameters(), lr)

    # 数据，以比特币为例
    trainB_x = torch.from_numpy(ji[i - 30:i].reshape(-1, batch_size, 30)).to(torch.float32).to(device)
    trainB_y = torch.from_numpy(ji[i].reshape(-1, batch_size, output_size)).to(torch.float32).to(device)

    loss = None

    for epoch in range(num_epochs):
        output = gru(trainB_x).to(device)
        loss = criterion(output, trainB_y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # print("loss"+str(epoch)+":", loss.item())
    losses.append(loss.item())

    # 预测，以比特币为例
    pred_x_train = torch.from_numpy(ji[i - 29:i + 1].reshape(-1, 1, 30)).to(torch.float32).to(device)
    pred_y_train = gru(pred_x_train).to(device)
    # print("prediction:",pred_y_train.item())
    # print("actual:",Data.iloc[i+1,1])
    predictions.append(pred_y_train.item())
    actuals.append(ji[i + 1])
plt.plot(losses)

plt.plot(predictions)
plt.plot(actuals)

print(np.array(predictions).shape[0])
print(np.array(actuals).shape[0])
print(input_size-29)

f=open(path+'/周期lstm黄金预测1000版本.csv','w',encoding='utf-8',newline="")
csv_writer=csv.writer(f)
csv_writer.writerow(["实际价格","预测价格"])
for i in range(0,input_size-29):
    tmp=[]
    tmp.append(actuals[i])
    tmp.append(round(predictions[i],2))
    csv_writer.writerow(tmp)
f.close()

经过一段时间的查阅及分析，大致理解了代码各个部分的作用，

10
11
12
13
14
15
16
17
18
19
20
21
22

path="/home/jishengpeng/美赛的模拟练习"
BCHAIN_MKPRU=pd.read_csv(path+"/BCHAIN-MKPRU.csv",dtype={"Date":np.str,"Value":np.float64})
LBMA_GOLD=pd.read_csv(path+"/LBMA-GOLD.csv",dtype={"Date":np.str,"Value":np.float64})
Data=pd.read_csv(path+"/C题处理后的中间文件2.csv")

def to_timestamp(date):
    return int(time.mktime(time.strptime(date,"%m/%d/%y")))

#将日期变为自然数
start_timestamp=to_timestamp(Data.iloc[0,0])
for i in range(Data.shape[0]):
    Data.iloc[i,0]=(to_timestamp(Data.iloc[i,0])-start_timestamp)/86400
print(Data)

这部分代码是在对数据进行加载和预处理，

24
25
26
27
28
29
30
31
32

batch_size=1 # 应该只能为1
start_input=30
input_size=Data.shape[0]#训练：通过前input_size天预测input_size+1天，预测：通过2到input_size+1天预测第input_size+2天
hidden_size=20
# input_size=200
output_size=1
layers_size=3
lr=10
num_epochs=1000

这里是在设置模型的一些参数，其中我认为最后需要改动的只有 input_size 输入数据的维数 和 num_epochs 训练批次。

由于之前在测试运行原本的代码时，训练时间比较久，所以为了方便测试我就将 num_epochs 改成了 1 。

34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, layers_size):
        super().__init__()
        self.GRU_layer = nn.GRU(input_size, hidden_size, layers_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.GRU_layer(x)
        x = self.linear(x)
        return x

device=torch.device("cuda")

gru=GRUModel(30, hidden_size, output_size, layers_size).to(device)

criterion = nn.L1Loss()
optimizer = torch.optim.Adam(gru.parameters(), lr)

这一块代码是在设置GRU模型的函数，但似乎用的只是线性的函数( nn.Linear 这一行)，并没有添加非线性的激活函数。

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

ji=np.array(Data.iloc[0:input_size,3].dropna())
input_size=ji.shape[0]-2

trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30)).to(torch.float32).to(device)
trainB_y=torch.from_numpy(ji[input_size].reshape(-1,batch_size,output_size)).to(torch.float32).to(device)

losses = []

for epoch in range(num_epochs):
    output = gru(trainB_x).to(device)
    loss = criterion(output, trainB_y)
    losses.append(loss)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print("loss" + str(epoch) + ":", loss.item())

# 预测，以比特币为例
# pred_x_train=torch.from_numpy(np.array(Data.iloc[1:input_size+1,1]).reshape(-1,1,input_size)).to(torch.float32).to(device)
pred_x_train=torch.from_numpy(ji[input_size-29:input_size+1]).reshape(-1,1,30).to(torch.float32).to(device)
pred_y_train=gru(pred_x_train).to(device)
print("prediction:",pred_y_train.item())
print("actual:",ji[input_size+1])

这一段代码似乎是进行的一次训练和预测的测试(因为在之后的代码中，与这段代码结构非常相似的代码被放在了 for 循环中)。

由于一开始没有看懂代码😅，所以把头5行代码拿来询问copilot

ji=np.array(Data.iloc[0:input_size,3].dropna())
input_size=ji.shape[0]-2

trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30)).to(torch.float32).to(device)
trainB_y=torch.from_numpy(ji[input_size].reshape(-1,batch_size,output_size)).to(torch.float32).to(device)

ji=np.array(Data.iloc[0:input_size,3].dropna())

input_size=ji.shape[0]-2

trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30)).to(torch.float32).to(device)
trainB_y=torch.from_numpy(ji[input_size].reshape(-1,batch_size,output_size)).to(torch.float32).to(device)

ji = np.array(Data.iloc[0:input_size, 3].dropna())

input_size = ji.shape[0] - 2

trainB_x = torch.from_numpy(ji[input_size-30:input_size].reshape(-1, batch_size, 30)).to(torch.float32).to(device)
trainB_y = torch.from_numpy(ji[input_size].reshape(-1, batch_size, output_size)).to(torch.float32).to(device)

于是大概理解了代码的含义，先是从csv文件中取出 黄金价值 这一列的数据，

C题处理后的中间文件2.csv
1 2 3 4 5	日期(月/日/年),比特币价值,是否可以买卖黄金,黄金价值 9/11/16,621.65,1 9/12/16,609.67,0,1324.6 9/13/16,610.92,0,1323.65 ...

然后取倒数第32到倒数第3的30个数据和倒数第2个数据作为训练的输入和输出，

他们好像是需要使用前30天的价格来预测下一天的价格，因此如果要预测哪一天，就需要取那一天往前数30天的数据作为输入

最后再取倒数第31到倒数第2的30个数据输入模型来对最后一天的价格进行预测，最后再和实际的价格一起显示进行比较。

而从 # 预测代码 开始的剩下的代码，就是依次从第31天到最后1天，每天取其前30天作为输入序列进行预测。

尝试对 GRU模型.py 的代码进行修改以输入多维数据 (午)¶

理解了 GRU模型.py 中的代码之后，我开始尝试在chatgpt的帮助下，修改他们的代码来实现多维数据的输入，

但大概尝试了一下感觉不是很好改，于是最后还是放弃了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
from sklearn import linear_model
from d2l import torch as d2l
import torch
import torch.nn as nn
import csv
path="."
BCHAIN_MKPRU=pd.read_csv(path+"/BCHAIN-MKPRU.csv",dtype={"Date":np.str,"Value":np.float64})
LBMA_GOLD=pd.read_csv(path+"/LBMA-GOLD.csv",dtype={"Date":np.str,"Value":np.float64})
Data=pd.read_csv(path+"/C题处理后的中间文件2.csv")

def to_timestamp(date):
    return int(time.mktime(time.strptime(date,"%m/%d/%y")))

#将日期变为自然数
start_timestamp=to_timestamp(Data.iloc[0,0])
for i in range(Data.shape[0]):
    Data.iloc[i,0]=(to_timestamp(Data.iloc[i,0])-start_timestamp)/86400
print(Data)

batch_size=1 # 应该只能为1
start_input=30
input_size=Data.shape[0]#训练：通过前input_size天预测input_size+1天，预测：通过2到input_size+1天预测第input_size+2天
hidden_size=20
# input_size=200
output_size=1
layers_size=3
lr=10
num_epochs=1

# exit(0)

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, layers_size):
        """
        Initializes a GRUModel instance.

        Args:
            input_size (int): The number of expected features in the input x
            hidden_size (int): The number of features in the hidden state h
            output_size (int): The number of output features
            layers_size (int): Number of recurrent layers

        """
        super().__init__()
        self.GRU_layer = nn.GRU(input_size, hidden_size, layers_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        """
        Forward pass of the GRUModel.

        Args:
            x (Tensor): Input tensor of shape (seq_len, batch, input_size)

        Returns:
            Tensor: Output tensor of shape (seq_len, batch, output_size)

        """
        x, _ = self.GRU_layer(x)
        x = self.linear(x)
        return x

device=torch.device("cuda")

gru=GRUModel(30, hidden_size, output_size, layers_size).to(device)

criterion = nn.L1Loss()
optimizer = torch.optim.Adam(gru.parameters(), lr)

ji=np.array(Data.iloc[0:input_size,3].dropna())
input_size=ji.shape[0]-2

trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30)).to(torch.float32).to(device)
trainB_y=torch.from_numpy(ji[input_size].reshape(-1,batch_size,output_size)).to(torch.float32).to(device)

losses = []

for epoch in range(num_epochs):
    output = gru(trainB_x).to(device)
    loss = criterion(output, trainB_y)
    losses.append(loss)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print("loss" + str(epoch) + ":", loss.item())

# 预测，以比特币为例
# pred_x_train=torch.from_numpy(np.array(Data.iloc[1:input_size+1,1]).reshape(-1,1,input_size)).to(torch.float32).to(device)
pred_x_train=torch.from_numpy(ji[input_size-29:input_size+1]).reshape(-1,1,30).to(torch.float32).to(device)
pred_y_train=gru(pred_x_train).to(device)
print("prediction:",pred_y_train.item())
print("actual:",ji[input_size+1])

# 假设每个输入样本是一个长度为n的向量
n = 10  # 请根据你的实际需求设置向量的维度

# ...

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, layers_size):
        super().__init__()
        self.GRU_layer = nn.GRU(input_size, hidden_size, layers_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.GRU_layer(x)
        x = self.linear(x)
        return x

# ...

# 数据处理部分
ji = np.array(Data.iloc[0:input_size, 3:n+3].dropna())  # 修改为包含n维向量的处理方式
input_size = ji.shape[0] - 2

trainB_x = torch.from_numpy(ji[input_size-30:input_size].reshape(-1, batch_size, 30, n)).to(torch.float32).to(device)
trainB_y = torch.from_numpy(ji[input_size].reshape(-1, batch_size, output_size)).to(torch.float32).to(device)

# ...

# 预测部分
pred_x_train = torch.from_numpy(ji[input_size-29:input_size+1].reshape(-1, 1, 30, n)).to(torch.float32).to(device)

# 假设每个元素是一个长度为3的三维向量
n = 3  # 请根据你的实际需求设置向量的维度

# ...

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, layers_size):
        super().__init__()
        self.GRU_layer = nn.GRU(input_size, hidden_size, layers_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.GRU_layer(x)
        x = self.linear(x)
        return x

# ...

# 数据处理部分
ji = np.array(Data.iloc[0:input_size, 3:n+3].dropna())  # 修改为包含n维向量的处理方式
input_size = ji.shape[0] - 2

# 构造训练数据
trainB_x = torch.from_numpy(ji[input_size-30:input_size+1].reshape(-1, batch_size, 30, n)).to(torch.float32).to(device)
trainB_y = torch.from_numpy(ji[input_size+1].reshape(-1, batch_size, output_size)).to(torch.float32).to(device)

# ...

# 预测部分
pred_x_train = torch.from_numpy(ji[input_size-29:input_size+1].reshape(-1, 1, 30, n)).to(torch.float32).to(device)

    trainB_x=torch.from_numpy(ji[input_size-30:input_size].reshape(-1,batch_size,30, 4)).to(torch.float32).to(device)
TypeError: can't convert np.ndarray of type numpy.object_. The only supported types are: float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint8, and bool.

ji = np.array(Data.iloc[0:input_size, 3:n+3].dropna(), dtype=np.float32)

trainB_x = torch.from_numpy(ji[input_size-30:input_size].reshape(-1, batch_size, 30, n)).to(torch.float32).to(device)

ji: [1324.6  1323.65 1321.75 ... 1786.   1788.25 1794.6 ]
ji: [[1.000000e+00 6.096700e+02 0.000000e+00 1.324600e+03]
 [2.000000e+00 6.109200e+02 0.000000e+00 1.323650e+03]
 [3.000000e+00 6.088200e+02 0.000000e+00 1.321750e+03]
 ...
 [1.249000e+03 1.027538e+04 0.000000e+00 1.563700e+03]
 [1.250000e+03 1.035430e+04 0.000000e+00 1.575050e+03]
 [1.251000e+03 1.024243e+04 0.000000e+00 1.581400e+03]]
Traceback (most recent call last):
  ..."E:\Programs\Anaconda3\envs\genrec\lib\site-packages\torch\nn\modules\rnn.py", line 206, in check_input
    raise RuntimeError(
RuntimeError: input must have 3 dimensions, got 5

# 构造训练数据
trainB_x = torch.from_numpy(ji[input_size-30:input_size].reshape(30, batch_size, n)).to(torch.float32).to(device)
trainB_y = torch.from_numpy(ji[input_size+1].reshape(-1, batch_size, output_size)).to(torch.float32).to(device)

开始尝试使用TensorFlow来实现GRU¶

新建了一个与chatgpt的对话，询问如果输入是个多维向量的序列，应该如何编写代码，而这时chatgpt让我使用TensorFlow来实现，然后看了一下它给的代码，感觉比用pytorch实现GRU要简单许多，于是产生了尝试使用tensorflow实现的想法。

pip install tensorflow

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense
import numpy as np

# 生成虚拟数据
def generate_data():
    # 生成输入序列和对应的目标值
    seq_length = 10
    num_samples = 1000
    x = np.random.rand(num_samples, seq_length, 3)  # 3维向量的输入序列
    y = np.sum(x, axis=2)  # 目标值是输入序列各元素之和

    return x, y

# 构建模型
def build_model():
    model = Sequential()
    model.add(GRU(50, input_shape=(None, 3)))  # 使用50个GRU单元
    model.add(Dense(1))  # 输出层，用于回归问题

    return model

# 编译模型
model = build_model()
model.compile(optimizer='adam', loss='mean_squared_error')

# 生成数据
x_train, y_train = generate_data()

# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=32)

# 保存权重文件
model.save_weights('gru_weights.h5')

然后尝试运行了一下chatgpt给我的代码，发现能运行，于是打算在这个代码的基础上进行修改尝试

debug并最终成功实现数据的训练和预测¶

此时大约下午4:30

一开始是想看看能不能使用gpu来进行训练，于是询问继续chatgpt

pip install tensorflow-gpu

# 导入 TensorFlow 并检查 GPU 是否可用
import tensorflow as tf
print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))

# 其余的代码保持不变
# ...

# 编译模型，确保 Tensorflow 使用 GPU 加速
model.compile(optimizer='adam', loss='mean_squared_error')

# 训练模型，TensorFlow 会自动使用 GPU
model.fit(x_train, y_train, epochs=10, batch_size=32)

# 保存权重文件
model.save_weights('gru_weights.h5')

于是我尝试运行命令

pip install tensorflow-gpu

但是发生了报错

...
        File "E:\Programs\Anaconda3\envs\genrec\lib\site-packages\setuptools\_vendor\packaging\requirements.py", line 37, in __init__
          raise InvalidRequirement(str(e)) from e
      setuptools.extern.packaging.requirements.InvalidRequirement: Expected end or semicolon (after name and no valid version specifier)
          python_version>"3.7"
                        ^
      [end of output]

  note: This error originates from a subprocess, and is likely not a problem with pip.
error: metadata-generation-failed

× Encountered error while generating package metadata.
╰─> See above for output.

note: This is an issue with the package mentioned above, not pip.
hint: See above for details.

然后搜索相关信息，找到这个issue

pip install tensorflow-gpu gives setuptools.extern.packaging.requirements.InvalidRequirement · Issue #60074 · tensorflow/tensorflow (github.com)

根据 tilakrayal的回答，在新的版本中，tensorflow已经不区分gpu和非gpu版本了，合并成一个版本

From tensorflow v2.12, removed redundant packages tensorflow-gpu and tf-nightly-gpu. These packages were removed and replaced with packages that direct users to switch to tensorflow or tf-nightly respectively.

于是我就尝试chatgpt回答中的这个代码

print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))

但是显示了 0。

最后我感觉要弄好这个gpu可能比较费时间，并且cpu也足够用，于是就不打算再追究这个。

将原本chatgpt给我的代码稍加修改了一下(为了查看输入数据/矩阵的形状，以及进行预测)(由于生成的数据太多，为了方便查看所以将 num_samples 设置成了 10 )，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense
import numpy as np

# 生成虚拟数据
def generate_data():
    # 生成输入序列和对应的目标值
    seq_length = 10
    num_samples = 10
    x = np.random.rand(num_samples, seq_length, 3)  # 3维向量的输入序列
    y = np.sum(x, axis=2)  # 目标值是输入序列各元素之和

    return x, y

# 构建模型
def build_model():
    model = Sequential()
    model.add(GRU(50, input_shape=(None, 3)))  # 使用50个GRU单元
    model.add(Dense(1))  # 输出层，用于回归问题

    return model

# 编译模型
model = build_model()
model.compile(optimizer='adam', loss='mean_squared_error')

# 生成数据
x_train, y_train = generate_data()

print(x_train)
print(y_train)

for a, b in zip(x_train[0], y_train[0]):
    print(f"sum {a} = {b}")

# exit(0)

# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=32)

# 保存权重文件
model.save_weights('gru_weights.h5')

# 预测并计算每个序列输出的和
predictions = model.predict(x_train)
sum_predictions = np.sum(predictions, axis=1)

# 打印结果
print("Predictions:")
print(predictions)

终端输出出来的 x_train y_train (31和32行的两个 print )是这样的

[[[0.7944328  0.19991478 0.1717165 ]
  [0.52863161 0.18222096 0.70395594]
  [0.57382239 0.64215397 0.63834019]
  [0.1210313  0.22205257 0.51856381]
  [0.64116937 0.40346543 0.73267251]
  [0.68666603 0.96090184 0.69283727]
  [0.72992198 0.02034594 0.84201691]
  [0.81079883 0.20875773 0.03558987]
  [0.81432445 0.47643867 0.87499175]
  [0.28032208 0.5911067  0.99797703]]

 ...

 [[0.41748414 0.33052038 0.83109248]
  [0.70159718 0.8524119  0.02944102]
  [0.22653771 0.11587124 0.50194598]
  [0.75814563 0.03297447 0.14874201]
  [0.30183465 0.36516737 0.5084972 ]
  [0.46178636 0.34466552 0.93100872]
  [0.85690693 0.26805801 0.61805625]
  [0.08040773 0.75785972 0.98884817]
  [0.11996411 0.0269658  0.932087  ]
  [0.72871391 0.80410475 0.30108709]]]

[[1.16606407 1.4148085  1.85431655 0.86164768 1.77730731 2.34040514
  1.59228483 1.05514643 2.16575486 1.86940581]
 [1.579097   1.5834501  0.84435492 0.93986211 1.17549922 1.73746061
  1.74302119 1.82711561 1.0790169  1.83390576]
 [1.05626799 1.40353675 1.45449643 1.47791795 1.33798364 1.23835848
  1.22593666 0.61404874 1.56806409 2.00279187]
 [1.52692854 1.02003715 1.43574853 2.16162096 1.87126819 2.39616241
  1.58802291 0.59642459 1.03014043 2.33408625]
 [0.6888727  1.89631828 2.22542497 2.02600974 1.80885565 2.04338134
  1.39698629 1.74913134 2.41820951 2.1095142 ]
 [1.45975555 1.66387383 1.31121027 2.17661788 1.53556581 1.65127684
  1.4565594  0.7422163  1.27289512 1.5068791 ]
 [0.54572599 0.89128647 1.99626636 1.02370802 2.11791123 0.68699581
  1.49900562 1.77851229 2.19032219 0.97705314]
 [1.59726203 1.81477729 1.27713759 1.28049124 0.39606842 2.15493916
  1.24729366 0.96491842 1.44108162 1.70740263]
 [2.08867844 0.4113912  1.61522844 1.86740305 2.00394564 2.32879784
  1.17513393 1.68913914 2.71357174 0.92150995]
 [1.46399312 2.29460573 1.33109995 1.54187649 1.93523676 1.60621029
  2.06562629 0.79873924 1.14552017 1.76911693]]