基于python写一个免疫遗传算法优化BP神经网络的代码

好的，我可以为您提供一个基于Python的免疫遗传算法优化BP神经网络的代码。请注意，这个代码只是一个简单的示例，您可能需要根据您的具体需求进行修改。

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 定义神经网络类
class NeuralNetwork:
    def __init__(self, num_inputs, num_hidden, num_outputs):
        self.weights1 = np.random.randn(num_inputs, num_hidden)
        self.bias1 = np.zeros((1, num_hidden))
        self.weights2 = np.random.randn(num_hidden, num_outputs)
        self.bias2 = np.zeros((1, num_outputs))

    def forward(self, inputs):
        self.z1 = np.dot(inputs, 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 sigmoid(self, z):
        return 1 / (1 + np.exp(-z))

    def sigmoid_derivative(self, z):
        return self.sigmoid(z) * (1 - self.sigmoid(z))

    def backward(self, inputs, targets, outputs, learning_rate):
        error = (outputs - targets) * self.sigmoid_derivative(self.z2)
        d_weights2 = np.dot(self.a1.T, error)
        d_bias2 = np.sum(error, axis=0, keepdims=True)
        error_hidden = np.dot(error, self.weights2.T) * self.sigmoid_derivative(self.z1)
        d_weights1 = np.dot(inputs.T, error_hidden)
        d_bias1 = np.sum(error_hidden, axis=0, keepdims=True)
        self.weights1 -= learning_rate * d_weights1
        self.bias1 -= learning_rate * d_bias1
        self.weights2 -= learning_rate * d_weights2
        self.bias2 -= learning_rate * d_bias2

# 定义免疫遗传算法类
class ImmuneGeneticAlgorithm:
    def __init__(self, population_size, num_generations, num_mutation):
        self.population_size = population_size
        self.num_generations = num_generations
        self.num_mutation = num_mutation
        self.population = []

    def init_population(self, num_weights):
        for i in range(self.population_size):
            weights = np.random.randn(num_weights)
            self.population.append(weights)

    def calculate_fitness(self, X_train, y_train):
        fitness_scores = []
        for i in range(self.population_size):
            nn = self.decode(self.population[i])
            outputs = nn.forward(X_train)
            error = np.mean(np.square(y_train - outputs))
            fitness_scores.append(1 / (1 + error))
        return fitness_scores

    def select_parents(self, fitness_scores):
        parents = []
        total_fitness = np.sum(fitness_scores)
        for i in range(self.population_size):
            selection_prob = fitness_scores[i] / total_fitness
            num_parents = int(selection_prob * self.population_size)
            parents.extend([i] * num_parents)
        return np.random.choice(parents, size=self.population_size, replace=False)

    def crossover(self, parent1, parent2):
        crossover_point = np.random.randint(len(parent1))
        child = np.concatenate((parent1[:crossover_point], parent2[crossover_point:]))
        return child

    def mutate(self, chromosome):
        mutation_points = np.random.choice(len(chromosome), size=self.num_mutation)
        for i in mutation_points:
            chromosome[i] += np.random.randn()
        return chromosome

    def decode(self, chromosome):
        nn = NeuralNetwork(num_inputs=4, num_hidden=6, num_outputs=3)
        nn.weights1 = chromosome[:24].reshape(4, 6)
        nn.bias1 = chromosome[24:30].reshape(1, 6)
        nn.weights2 = chromosome[30:42].reshape(6, 3)
        nn.bias2 = chromosome[42:].reshape(1, 3)
        return nn

    def encode(self, nn):
        chromosome = np.concatenate((nn.weights1.ravel(), nn.bias1.ravel(), nn.weights2.ravel(), nn.bias2.ravel()))
        return chromosome

    def run(self, X_train, y_train):
        num_weights = 42
        self.init_population(num_weights)
        for i in range(self.num_generations):
            fitness_scores = self.calculate_fitness(X_train, y_train)
            parents = self.select_parents(fitness_scores)
            next_population = []
            for j in range(self.population_size):
                parent1 = self.population[parents[j]]
                parent2 = self.population[parents[self.population_size - j - 1]]
                child = self.crossover(parent1, parent2)
                child = self.mutate(child)
                next_population.append(child)
            self.population = next_population
        best_chromosome = max(self.population, key=lambda x: self.calculate_fitness(X_train, y_train)[self.population.index(x)])
        best_nn = self.decode(best_chromosome)
        return best_nn

这个代码使用iris数据集进行训练和测试。您需要进行以下步骤：

1. 加载数据集并进行标准化处理。
2. 创建神经网络对象和免疫遗传算法对象。
3. 使用免疫遗传算法优化神经网络并进行训练。
4. 使用测试集进行模型测试。

这里是一个简单的示例代码，您可以根据自己的需求进行修改。