用pyhton写一个遗传算法优化的多层感知机网络做回归预测

好的，下面是一个基于Python和PyTorch框架实现的遗传算法优化的多层感知机网络做回归预测的示例代码：

import torch
import torch.nn as nn
import numpy as np
import random

# 定义多层感知机神经网络
class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

# 定义遗传算法优化器
class GA_optimizer():
    def __init__(self, pop_size, gene_length, mutation_rate, cross_rate):
        self.pop_size = pop_size
        self.gene_length = gene_length
        self.mutation_rate = mutation_rate
        self.cross_rate = cross_rate
        self.pop = np.zeros((self.pop_size, self.gene_length))
        self.fitness = np.zeros((self.pop_size, 1))
        self.best_fitness = 0.0
        self.best_gene = np.zeros((self.gene_length,))

    # 初始化种群
    def init_pop(self):
        for i in range(self.pop_size):
            self.pop[i] = np.random.uniform(-1, 1, self.gene_length)

    # 计算适应度
    def calc_fitness(self, model, x, y):
        total_loss = 0.0
        for i in range(x.shape[0]):
            input_data = torch.tensor(x[i], dtype=torch.float32)
            target_data = torch.tensor(y[i], dtype=torch.float32)
            output = model(input_data)
            loss = torch.mean((output - target_data) ** 2)
            total_loss += loss.item()
        self.fitness = 1.0 / (total_loss + 1e-6)
        if self.fitness > self.best_fitness:
            self.best_fitness = self.fitness
            self.best_gene = self.pop[np.argmax(self.fitness)]

    # 交叉运算
    def crossover(self, parent1, parent2):
        child = np.zeros((self.gene_length,))
        cross_point = np.random.randint(self.gene_length)
        child[:cross_point] = parent1[:cross_point]
        child[cross_point:] = parent2[cross_point:]
        return child

    # 变异运算
    def mutation(self, gene):
        for i in range(self.gene_length):
            if random.random() < self.mutation_rate:
                gene[i] = random.uniform(-1, 1)
        return gene

    # 更新种群
    def evolve(self):
        new_pop = np.zeros((self.pop_size, self.gene_length))
        for i in range(self.pop_size):
            parent1 = self.pop[self.select()]
            parent2 = self.pop[self.select()]
            child = self.crossover(parent1, parent2)
            child = self.mutation(child)
            new_pop[i] = child
        self.pop = new_pop

    # 选择操作
    def select(self):
        total_fitness = np.sum(self.fitness)
        rand = random.uniform(0, total_fitness)
        index = 0
        while rand > 0:
            rand -= self.fitness[index]
            index += 1
        index -= 1
        return index

# 定义数据集
x_train = np.random.uniform(-1, 1, (1000, 10))
y_train = np.sum(x_train, axis=1)

# 定义超参数
input_size = 10
hidden_size = 20
output_size = 1
pop_size = 100
gene_length = (input_size * hidden_size) + (hidden_size * output_size)
mutation_rate = 0.01
cross_rate = 0.7
epochs = 100

# 初始化神经网络和遗传算法优化器
model = MLP(input_size, hidden_size, output_size)
optimizer = GA_optimizer(pop_size, gene_length, mutation_rate, cross_rate)

# 初始化种群并计算适应度
optimizer.init_pop()
optimizer.calc_fitness(model, x_train, y_train)

# 迭代训练
for epoch in range(epochs):
    optimizer.evolve()
    optimizer.calc_fitness(model, x_train, y_train)

    # 显示每轮迭代的结果
    print("epoch: %d, best_fitness: %f" % (epoch, optimizer.best_fitness))

# 使用遗传算法优化得到的最优个体更新神经网络参数
model.fc1.weight.data = torch.tensor(optimizer.best_gene[:input_size*hidden_size].reshape(hidden_size, input_size), dtype=torch.float32)
model.fc1.bias.data = torch.tensor(optimizer.best_gene[input_size*hidden_size:(input_size*hidden_size)+hidden_size], dtype=torch.float32)
model.fc2.weight.data = torch.tensor(optimizer.best_gene[(input_size*hidden_size)+hidden_size:(input_size*hidden_size)+hidden_size+hidden_size*output_size].reshape(output_size, hidden_size), dtype=torch.float32)
model.fc2.bias.data = torch.tensor(optimizer.best_gene[(input_size*hidden_size)+hidden_size+hidden_size*output_size:], dtype=torch.float32)

# 测试模型
x_test = np.random.uniform(-1, 1, (10, 10))
y_test = np.sum(x_test, axis=1)
for i in range(x_test.shape[0]):
    input_data = torch.tensor(x_test[i], dtype=torch.float32)
    target_data = torch.tensor(y_test[i], dtype=torch.float32)
    output = model(input_data)
    print("input: ", input_data)
    print("output: ", output)
    print("target: ", target_data)

在这个示例中，我们定义了一个包含一个输入层、一个隐藏层和一个输出层的多层感知机神经网络，并使用遗传算法优化器来搜索最优的神经网络参数。具体来说，我们使用遗传算法生成一个由多个个体（即一组神经网络参数）组成的种群，并计算每个个体的适应度（即神经网络在训练集上的拟合程度），然后使用交叉和变异运算来产生新的个体，并使用选择操作来选取最优的个体进行下一轮迭代。在迭代训练的过程中，我们不断更新遗传算法优化器中的种群和适应度，直到达到预设的迭代次数为止。最后，我们使用遗传算法优化得到的最优个体来更新神经网络参数，并测试模型的预测性能。