写一段python代码，读取一个csv文件，该文件没有表头，第一列为时间编号,编号以1,2,3……这样自然数的形式出现，第二列为充电量数值，将该数据集的前90%划分为训练集，其余部分设置为测试集，采用简单的遗传算法对lstm模型进行优化，并基于优化后的模型对时间序列进行预测，并打印rmse作为评价指标，将训练集和测试集分别绘制在两张图上，两张图片的横坐标单位为time/h，纵坐标单位为kwh

以下是一段读取csv文件、划分训练集和测试集、使用遗传算法优化LSTM模型并对时间序列进行预测的Python代码。需要使用pytorch和pandas库。

import pandas as pd
import torch
import torch.nn as nn
import numpy as np
from deap import algorithms, base, creator, tools

# 读取csv文件
df = pd.read_csv('data.csv', header=None)

# 划分训练集和测试集
train_size = int(len(df) * 0.9)
train_data, test_data = df[:train_size], df[train_size:]

# 定义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))
        y_pred = self.linear(lstm_out.view(len(input), -1))
        return y_pred[-1]

# 定义遗传算法
creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)
toolbox = base.Toolbox()
toolbox.register("attr_float", np.random.uniform, low=0, high=1)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_float, n=3)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
def evaluate(individual):
    input_size = int(individual[0] * len(train_data))
    hidden_size = int(individual[1] * 100)
    output_size = int(individual[2] * 10)
    lstm = LSTM(input_size, hidden_size, output_size)
    optimizer = torch.optim.Adam(lstm.parameters(), lr=0.01)
    loss_fn = nn.MSELoss()
    for epoch in range(100):
        optimizer.zero_grad()
        y_pred = lstm(train_data[1][:input_size])
        loss = loss_fn(y_pred, train_data[1][1:input_size+1])
        loss.backward()
        optimizer.step()
    y_true = test_data[1].tolist()
    y_pred = [lstm(test_data[1][:i+1]).item() for i in range(len(test_data))]
    rmse = np.sqrt(np.mean((np.array(y_true) - np.array(y_pred)) ** 2))
    return rmse,

toolbox.register("evaluate", evaluate)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.1, indpb=0.1)
toolbox.register("select", tools.selTournament, tournsize=3)

# 运行遗传算法
random.seed(1)
pop = toolbox.population(n=10)
hof = tools.HallOfFame(1)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("min", np.min)
pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=10, halloffame=hof, stats=stats)

# 训练优化后的模型并预测时间序列
lstm = LSTM(int(hof[0][0] * len(df)), int(hof[0][1] * 100), int(hof[0][2] * 10))
optimizer = torch.optim.Adam(lstm.parameters(), lr=0.01)
loss_fn = nn.MSELoss()
for epoch in range(100):
    optimizer.zero_grad()
    y_pred = lstm(df[1][:train_size])
    loss = loss_fn(y_pred, df[1][1:train_size+1])
    loss.backward()
    optimizer.step()
y_true = df[1][train_size:].tolist()
y_pred = [lstm(df[1][:i+train_size]).item() for i in range(len(df)-train_size)]
rmse = np.sqrt(np.mean((np.array(y_true) - np.array(y_pred)) ** 2))
print('RMSE: %f' % rmse)

# 绘制训练集和测试集的时间序列
import matplotlib.pyplot as plt
plt.plot(train_data[0], train_data[1], label='Train')
plt.plot(test_data[0], test_data[1], label='Test')
plt.xlabel('Time/h')
plt.ylabel('kwh')
plt.legend()
plt.show()