用pytorch写一个天气预测的代码，用LSTM或CNN，读取天气中的csv文件，由时间和气温两列数据，区分训练集和测试集，用gpu训练，输入为60天的天气，输出为某一天的天气,并画出60天的实际曲线和预测曲线图，注意维度要一致

好的，以下是一个基于 PyTorch 的天气预测模型，使用 LSTM 和 GPU 进行训练：

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 读取数据
data = pd.read_csv('weather.csv')
time = data['time'].values
temperature = data['temperature'].values

# 构造数据集
class WeatherDataset(Dataset):
    def __init__(self, temperature, seq_length):
        self.temperature = temperature
        self.seq_length = seq_length
        
    def __len__(self):
        return len(self.temperature) - self.seq_length
    
    def __getitem__(self, idx):
        x = self.temperature[idx:idx+self.seq_length]
        y = self.temperature[idx+self.seq_length]
        return x, y

# 定义模型
class WeatherModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(WeatherModel, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out
    
# 参数设置
seq_length = 60
input_size = 1
hidden_size = 64
num_layers = 2
output_size = 1
learning_rate = 0.001
num_epochs = 1000
batch_size = 32

# 划分训练集和测试集
train_data = temperature[:int(len(temperature)*0.8)]
test_data = temperature[int(len(temperature)*0.8)-seq_length:]

# 数据集和数据加载器
train_dataset = WeatherDataset(train_data, seq_length)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 模型和优化器
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = WeatherModel(input_size, hidden_size, output_size, num_layers).to(device)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i, (x, y) in enumerate(train_loader):
        x = x.unsqueeze(-1).to(device)
        y = y.unsqueeze(-1).to(device)
        outputs = model(x)
        loss = criterion(outputs, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    if epoch % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 测试模型
model.eval()
with torch.no_grad():
    inputs = torch.Tensor(test_data[:-1]).unsqueeze(-1).to(device)
    labels = torch.Tensor(test_data[seq_length:]).unsqueeze(-1).to(device)
    predicted = model(inputs).squeeze().cpu().numpy()
    actual = labels.squeeze().cpu().numpy()

# 绘制实际曲线和预测曲线图
import matplotlib.pyplot as plt

plt.plot(np.arange(len(predicted)), predicted, label='predicted')
plt.plot(np.arange(len(actual)), actual, label='actual')
plt.legend()
plt.show()

其中，`weather.csv` 文件应该包含两列数据：`time` 和 `temperature`。`seq_length` 表示输入的天气序列长度，我们在本例中设置为 60。`input_size` 表示每个时间步的输入维度，本例中为 1，即只有一个气温数据。`hidden_size` 表示 LSTM 隐藏层的大小，我们在本例中设置为 64。`num_layers` 表示 LSTM 层数，我们在本例中设置为 2。`output_size` 表示每个时间步的输出维度，本例中为 1，即只有一个气温数据。`learning_rate` 表示学习率，我们在本例中设置为 0.001。`num_epochs` 表示训练轮数，我们在本例中设置为 1000。`batch_size` 表示批大小，我们在本例中设置为 32。

我们将前 80% 的数据作为训练集，后 20% 的数据作为测试集。我们使用 `WeatherDataset` 类来构造数据集，并使用 `DataLoader` 类来构造数据加载器。我们使用 `WeatherModel` 类来定义 LSTM 模型，并使用均方误差（`MSELoss`）作为损失函数，使用 Adam 优化器进行优化。

在训练过程中，我们迭代训练集中的所有序列，并计算每个序列的损失。在测试过程中，我们将模型的输出与测试集的标签进行比较，并计算它们之间的均方误差。最后，我们使用 Matplotlib 绘制实际曲线和预测曲线图。