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

好的，这是一道非常具体的编程问题，需要结合实际情况进行编写。以下是我的代码实现，供你参考：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout
from sklearn.metrics import mean_squared_error
import random

# 读取csv文件
data = pd.read_csv('data.csv', header=None)
# 获取数据行数
n = data.shape[0]
# 90%数据作为训练集
train_size = int(n * 0.9)
# 分割数据集
train_data = data.iloc[:train_size, :]
test_data = data.iloc[train_size:, :]

# 将数据转换成LSTM可以处理的格式
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back):
        a = dataset[i:(i+look_back), 1]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 1])
    return np.array(dataX), np.array(dataY)

# LSTM模型
def create_model(units):
    model = Sequential()
    model.add(LSTM(units=units, input_shape=(1, look_back)))
    model.add(Dense(1))
    model.compile(loss='mean_squared_error', optimizer='adam')
    return model

# 遗传算法
def genetic_algorithm(model, train_X, train_Y):
    # 遗传算法参数
    population_size = 10
    elite_size = 2
    mutation_rate = 0.01
    generations = 10

    # 初始化种群
    population = []
    for i in range(population_size):
        units = random.randint(4, 32)
        model = create_model(units)
        population.append(model)

    # 逐代进化
    for generation in range(generations):
        # 计算每个个体的适应度
        fitness = []
        for individual in population:
            individual.fit(train_X, train_Y, epochs=1, batch_size=1, verbose=0)
            y_pred = individual.predict(train_X)
            fitness.append(1 / mean_squared_error(train_Y, y_pred))

        # 选择精英个体
        elite_indexes = sorted(range(len(fitness)), key=lambda x: fitness[x], reverse=True)[:elite_size]
        elite_population = [population[i] for i in elite_indexes]

        # 生成下一代个体
        new_population = elite_population

        while len(new_population) < population_size:
            parent1 = random.choice(elite_population)
            parent2 = random.choice(elite_population)
            child = Sequential()
            for layer in parent1.layers:
                child.add(layer)
            for layer in parent2.layers:
                child.add(layer)
            # 突变
            if random.random() < mutation_rate:
                child.layers[random.randint(0, len(child.layers)-1)].set_weights(
                    [weight * (random.random() * 2 - 1) for weight in child.layers[random.randint(0, len(child.layers)-1)].get_weights()])
            new_population.append(child)

        population = new_population

    # 返回最优个体
    fitness = []
    for individual in population:
        individual.fit(train_X, train_Y, epochs=10, batch_size=1, verbose=0)
        y_pred = individual.predict(train_X)
        fitness.append(mean_squared_error(train_Y, y_pred))
    best_index = np.argmin(fitness)
    best_model = population[best_index]

    return best_model

# 数据预处理
look_back = 1
train_X, train_Y = create_dataset(train_data.values, look_back)
test_X, test_Y = create_dataset(test_data.values, look_back)
# 转换为3D格式
train_X = np.reshape(train_X, (train_X.shape[0], 1, train_X.shape[1]))
test_X = np.reshape(test_X, (test_X.shape[0], 1, test_X.shape[1]))

# 遗传算法优化LSTM模型
best_model = genetic_algorithm(create_model(4), train_X, train_Y)

# 预测并计算RMSE
train_predict = best_model.predict(train_X)
test_predict = best_model.predict(test_X)
train_rmse = np.sqrt(mean_squared_error(train_Y, train_predict))
test_rmse = np.sqrt(mean_squared_error(test_Y, test_predict))
print('Train RMSE:', train_rmse)
print('Test RMSE:', test_rmse)

# 绘制训练集和测试集的真实值和预测值
train_plot = np.empty_like(data.values)
train_plot[:, :] = np.nan
train_plot[look_back:len(train_predict)+look_back, :] = train_predict
test_plot = np.empty_like(data.values)
test_plot[:, :] = np.nan
test_plot[len(train_predict)+(look_back*2)+1:len(data.values)-1, :] = test_predict
plt.figure(figsize=(10, 6))
plt.plot(data.values[:, 1], label='True')
plt.plot(train_plot[:, 1], label='Train')
plt.plot(test_plot[:, 1], label='Test')
plt.xlabel('Time/h')
plt.ylabel('kwh')
plt.legend()
plt.show()

# 绘制训练集和测试集的真实值
plt.figure(figsize=(10, 6))
plt.plot(train_data.values[:, 1], label='Train')
plt.plot(test_data.values[:, 1], label='Test')
plt.xlabel('Time/h')
plt.ylabel('kwh')
plt.legend()
plt.show()

需要注意的是，这段代码中的遗传算法并不是最优的实现方式，只是为了简单实现而采用的一种方式。如果想要更加高效的遗传算法实现，可以参考遗传算法的相关论文并进行更深入的研究。