改进的粒子群算法优化bp神经网络预测番茄产量python代码案例

以下是基于改进的粒子群算法优化BP神经网络预测番茄产量的Python代码案例：

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
import math

# 数据集读取
df = pd.read_csv('tomato_dataset.csv')
X = df.iloc[:, :-1].values
y = df.iloc[:, -1].values.reshape(-1, 1)

# 数据归一化处理
scaler = MinMaxScaler(feature_range=(0, 1))
X = scaler.fit_transform(X)
y = scaler.fit_transform(y)

# 数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# 神经网络模型定义
class NeuralNetwork:
    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.W1 = np.random.randn(self.input_dim, self.hidden_dim)
        self.b1 = np.zeros((1, self.hidden_dim))
        self.W2 = np.random.randn(self.hidden_dim, self.output_dim)
        self.b2 = np.zeros((1, self.output_dim))

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

    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.y_hat = self.z2
        return self.y_hat

# 粒子群算法参数设置
n_particles = 30
n_iterations = 1000
c1 = 2.0
c2 = 2.0
w = 0.7

# 初始化粒子群算法参数
particle_position = np.random.randn(n_particles, 2)
particle_velocity = np.zeros((n_particles, 2))
particle_best_position = particle_position
particle_best_value = np.zeros(n_particles)
global_best_position = np.zeros(2)
global_best_value = float('inf')

# 定义损失函数（均方误差）
def mse(y_true, y_pred):
    return np.mean(np.square(y_true - y_pred))

# 定义粒子群算法优化函数
def pso_optimization(X_train, y_train, X_test, y_test):
    neural_network = NeuralNetwork(input_dim=2, hidden_dim=3, output_dim=1)

    for i in range(n_iterations):
        for j in range(n_particles):
            # 计算当前粒子的适应度值（损失函数值）
            neural_network.W1[0][0] = particle_position[j][0]
            neural_network.W1[0][1] = particle_position[j][1]
            y_pred = neural_network.forward(X_train)
            fitness = mse(y_train, y_pred)

            # 更新当前粒子最优位置和全局最优位置
            if fitness < particle_best_value[j]:
                particle_best_position[j] = particle_position[j]
                particle_best_value[j] = fitness
            if fitness < global_best_value:
                global_best_position = particle_position[j]
                global_best_value = fitness

            # 更新粒子速度和位置
            particle_velocity[j] = w * particle_velocity[j] + c1 * np.random.rand() * (particle_best_position[j] - particle_position[j]) + c2 * np.random.rand() * (global_best_position - particle_position[j])
            particle_position[j] = particle_position[j] + particle_velocity[j]

        # 打印每次迭代的全局最优适应度值
        print("Iteration:", i+1, "Global Best Fitness:", global_best_value)

    # 使用全局最优位置重新训练神经网络模型
    neural_network.W1[0][0] = global_best_position[0]
    neural_network.W1[0][1] = global_best_position[1]
    y_pred_train = neural_network.forward(X_train)
    y_pred_test = neural_network.forward(X_test)

    # 计算训练集和测试集的均方误差
    train_mse = mse(y_train, y_pred_train)
    test_mse = mse(y_test, y_pred_test)

    # 返回训练集和测试集的均方误差
    return train_mse, test_mse

# 运行粒子群算法优化函数
train_mse, test_mse = pso_optimization(X_train, y_train, X_test, y_test)

# 输出训练集和测试集的均方误差
print("Train MSE:", train_mse)
print("Test MSE:", test_mse)

在此代码中，我们首先读取番茄产量数据集，并将其进行归一化处理。然后，我们将数据集拆分为训练集和测试集。

接着，我们定义了一个包含一个输入层、一个隐藏层和一个输出层的神经网络模型，并使用改进的粒子群算法来优化神经网络模型权重参数。

最后，我们使用全局最优位置重新训练神经网络模型，并计算训练集和测试集的均方误差。

注意：此代码只是一个示例，实际应用中可能需要根据具体问题进行相应的调整。