请基于python环境帮我构建免疫遗传算法优化BP神经网络的框架

好的，我们可以使用Python的numpy库作为BP神经网络的基础，使用遗传算法对其进行优化，具体框架如下：

1. 定义BP神经网络的类，包括初始化网络、前向传播、反向传播、训练和预测等方法。

import numpy as np

class BPNeuralNetwork:
    def __init__(self, input_dim, hidden_dim, output_dim):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.weights1 = np.random.randn(self.input_dim, self.hidden_dim)
        self.weights2 = np.random.randn(self.hidden_dim, self.output_dim)
        self.bias1 = np.random.randn(self.hidden_dim)
        self.bias2 = np.random.randn(self.output_dim)

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, x):
        self.z1 = np.dot(x, self.weights1) + self.bias1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.weights2) + self.bias2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def backward(self, x, y, output):
        self.delta2 = (y - output) * self.sigmoid_derivative(output)
        self.weights2 += np.dot(self.a1.T, self.delta2)
        self.bias2 += np.sum(self.delta2, axis=0)
        self.delta1 = np.dot(self.delta2, self.weights2.T) * self.sigmoid_derivative(self.a1)
        self.weights1 += np.dot(x.T, self.delta1)
        self.bias1 += np.sum(self.delta1, axis=0)

    def train(self, x, y):
        output = self.forward(x)
        self.backward(x, y, output)

    def predict(self, x):
        return self.forward(x)

2. 定义免疫遗传算法的类，包括初始化个体、种群、免疫操作、遗传操作、适应值评估和优化等方法。

import random

class ImmuneGA:
    def __init__(self, pop_size, gene_size):
        self.pop_size = pop_size
        self.gene_size = gene_size
        self.population = [[random.uniform(-1, 1) for _ in range(gene_size)] for _ in range(pop_size)]
        self.fitness = [0] * pop_size

    def mutation(self, gene):
        return gene + random.uniform(-0.1, 0.1)

    def immune_operation(self):
        for i in range(self.pop_size):
            for j in range(i + 1, self.pop_size):
                if random.random() < 0.5:
                    for k in range(self.gene_size):
                        self.population[i][k], self.population[j][k] = self.population[j][k], self.population[i][k]

    def crossover(self, parent1, parent2):
        split_point = random.randint(0, self.gene_size - 1)
        child1 = parent1[:split_point] + parent2[split_point:]
        child2 = parent2[:split_point] + parent1[split_point:]
        return child1, child2

    def genetic_operation(self):
        for i in range(self.pop_size):
            parent1 = self.population[i]
            parent2 = self.population[random.randint(0, self.pop_size - 1)]
            child1, child2 = self.crossover(parent1, parent2)
            self.population[i] = child1
            self.population[random.randint(0, self.pop_size - 1)] = child2

    def evaluate_fitness(self, x, y, bp_nn):
        for i in range(self.pop_size):
            bp_nn.weights1 = np.array(self.population[i][:bp_nn.input_dim * bp_nn.hidden_dim]).reshape(bp_nn.input_dim, bp_nn.hidden_dim)
            bp_nn.weights2 = np.array(self.population[i][bp_nn.input_dim * bp_nn.hidden_dim:]).reshape(bp_nn.hidden_dim, bp_nn.output_dim)
            output = bp_nn.forward(x)
            error = np.sum(np.square(y - output))
            self.fitness[i] = 1 / (1 + error)

    def optimize(self, x, y, bp_nn, max_iter):
        for i in range(max_iter):
            self.evaluate_fitness(x, y, bp_nn)
            self.immune_operation()
            self.genetic_operation()
        best_individual_index = self.fitness.index(max(self.fitness))
        best_individual = self.population[best_individual_index]
        bp_nn.weights1 = np.array(best_individual[:bp_nn.input_dim * bp_nn.hidden_dim]).reshape(bp_nn.input_dim, bp_nn.hidden_dim)
        bp_nn.weights2 = np.array(best_individual[bp_nn.input_dim * bp_nn.hidden_dim:]).reshape(bp_nn.hidden_dim, bp_nn.output_dim)

3. 使用上述两个类进行BP神经网络的优化，代码如下：

input_dim = 2
hidden_dim = 5
output_dim = 1
x_train = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_train = np.array([[0], [1], [1], [0]])

bp_nn = BPNeuralNetwork(input_dim, hidden_dim, output_dim)
ga = ImmuneGA(50, input_dim * hidden_dim + hidden_dim * output_dim)
ga.optimize(x_train, y_train, bp_nn, 200)

print(bp_nn.predict(x_train))

其中，我们使用一个简单的异或问题作为训练样本，通过免疫遗传算法对BP神经网络进行优化，最终输出了网络对训练样本的预测结果。