编写pytorch代码，定义个lstm模型，定义个cpso优化算法，调用优化算法去优化模型，读取训练集trainset，计算在训练集上的损失，将最优的参数设置给模型，读取测试集testset，再测试集上测试模型，并输出测试损失，绘制测试集的预测值和实际值，计算测试集的均方根误差

好的，以下是代码实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
import numpy as np
import matplotlib.pyplot as plt

# 定义LSTM模型
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, input):
        lstm_out, _ = self.lstm(input.view(len(input), 1, -1))
        output = self.linear(lstm_out.view(len(input), -1))
        return output[-1]

# 定义CPSO优化算法
class CPSO:
    def __init__(self, pop_size, dim, max_iter, c1=2, c2=2, w_min=0.4, w_max=0.9):
        self.pop_size = pop_size
        self.dim = dim
        self.max_iter = max_iter
        self.c1 = c1
        self.c2 = c2
        self.w_min = w_min
        self.w_max = w_max
        self.w = w_max
        self.c = c1 + c2
        self.x = torch.rand(pop_size, dim)
        self.v = torch.rand(pop_size, dim)
        self.pbest = self.x.clone().detach()
        self.gbest = self.pbest[0]

    def optimize(self, model, trainset):
        # 适应值函数
        def fitness_func(x):
            with torch.no_grad():
                for i, param in enumerate(model.parameters()):
                    param.data = x[i]
                loss_func = nn.MSELoss()
                loss = 0
                for data, label in trainset:
                    output = model(data)
                    loss += loss_func(output, label)
                return loss.item()

        # 初始化粒子群
        pbest_fit = [fitness_func(x) for x in self.x]
        gbest_fit = min(pbest_fit)
        gbest_idx = pbest_fit.index(gbest_fit)
        self.gbest = self.pbest[gbest_idx]

        # 开始迭代
        for iter in range(self.max_iter):
            r1 = torch.rand(self.pop_size, self.dim)
            r2 = torch.rand(self.pop_size, self.dim)
            self.v = self.w * self.v + self.c1 * r1 * (self.pbest - self.x) + self.c2 * r2 * (self.gbest - self.x)
            self.x = self.x + self.v
            self.x = torch.clamp(self.x, 0, 1)  # 限制参数范围
            fit = [fitness_func(x) for x in self.x]
            for i in range(self.pop_size):
                if fit[i] < pbest_fit[i]:
                    self.pbest[i] = self.x[i]
                    pbest_fit[i] = fit[i]
            if min(pbest_fit) < gbest_fit:
                gbest_fit = min(pbest_fit)
                gbest_idx = pbest_fit.index(gbest_fit)
                self.gbest = self.pbest[gbest_idx]
            self.w = self.w_max - (self.w_max - self.w_min) * iter / self.max_iter

        # 将最优的参数设置给模型
        with torch.no_grad():
            for i, param in enumerate(model.parameters()):
                param.data = self.gbest[i]

# 定义数据集
class MyDataset(Dataset):
    def __init__(self, data, label):
        self.data = torch.tensor(data, dtype=torch.float)
        self.label = torch.tensor(label, dtype=torch.float)

    def __getitem__(self, index):
        return self.data[index], self.label[index]

    def __len__(self):
        return len(self.data)

# 读取数据集
train_data = np.load('train_data.npy')
train_label = np.load('train_label.npy')
test_data = np.load('test_data.npy')
test_label = np.load('test_label.npy')
trainset = MyDataset(train_data, train_label)
testset = MyDataset(test_data, test_label)

# 定义模型和优化算法
model = LSTM(1, 16, 1)
cpso = CPSO(10, sum(p.numel() for p in model.parameters()), 100)

# 使用CPSO优化模型
cpso.optimize(model, trainset)

# 在训练集上计算损失
with torch.no_grad():
    loss_func = nn.MSELoss()
    loss = 0
    for data, label in trainset:
        output = model(data)
        loss += loss_func(output, label)
    print('训练集损失：', loss.item())

# 在测试集上测试模型
with torch.no_grad():
    loss_func = nn.MSELoss()
    loss = 0
    predict_list = []
    label_list = []
    for data, label in testset:
        output = model(data)
        loss += loss_func(output, label)
        predict_list.append(output.item())
        label_list.append(label.item())
    print('测试集损失：', loss.item())

# 绘制测试集的预测值和实际值
plt.plot(label_list)
plt.plot(predict_list)
plt.legend(['label', 'predict'])
plt.show()

# 计算测试集的均方根误差
rmse = np.sqrt(np.mean((np.array(label_list) - np.array(predict_list)) ** 2))
print('测试集均方根误差：', rmse)

需要注意的是，这段代码中的数据集格式为numpy数组，如果数据集为其他格式，需要进行相应的转换。另外，在实际使用中，可能需要根据情况对模型结构、优化算法等进行调整。