使用 PyTorch 实现遗传算法分类MNIST手写数据【附代码】

最新推荐文章于 2025-04-30 18:52:29 发布
最新推荐文章于 2025-04-30 18:52:29 发布
阅读量1k 收藏 26
点赞数 35
分类专栏： pytorch 深度学习初体验 文章标签： pytorch 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44886601/article/details/147599825
版权

优化算法能处理复杂问题，遗传算法是其中一种。

它可以方便地与PyTorch结合，用于多种优化任务。接下来介绍如何用PyTorch实现遗传算法。

1.遗传算法

遗传算法（GA）是一种受自然选择启发的优化方法。

它从一组初始解出发，通过多代迭代不断优化。

GA模拟自然选择机制，先评估解的优劣，再通过交叉和变异生成新解。

该过程反复进行，逐步改进解的质量，直至获得满意结果。

GA尤其适合解决传统方法难以处理的复杂问题。

​​遗传算法流程：​​

  1. ​​初始化​​：随机生成一组初始解。
  2. ​​适应度评估​​：用适应度函数衡量每个解的质量。
  3. ​​选择​​：筛选优质解作为父代。
  4. ​​交叉​​：组合父代生成新解（子代）。
  5. ​​变异​​：随机扰动部分解以维持多样性。
  6. ​​迭代​​：重复上述步骤多代，逐步优化解。

2.使用 PyTorch 实现遗传算法

我基于PyTorch实现了一个简易遗传算法(GA)用于神经网络超参数优化。具体流程如下：首先初始化一个包含多组超参数的种群；然后通过训练网络并评估性能来计算个体适应度；接着执行选择、交叉和变异操作生成新一代种群；最后重复该过程直至达到预定迭代次数。整个过程遵循以下步骤：

  1. 种群初始化

  2. 适应度评估

  3. 选择操作

  4. 交叉操作

  5. 变异操作

  6. 迭代优化

该方法通过多代进化逐步优化网络超参数配置。

步骤1：导入必要的库

我们首先导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

​​步骤2：神经网络定义​​

使用PyTorch的nn.Module构建CNN架构，具体结构如下：

  1. ​​卷积层​​
    • conv1: 第一卷积层
    • conv2: 第二卷积层
  2. ​​池化层​​
    • 最大池化操作
  3. ​​全连接层​​
    • fc1: 第一全连接层
    • fc2: 第二全连接层（输出层）

该CNN通过堆叠卷积、池化和全连接层实现特征提取与分类。

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = x.view(-1, 64 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return torch.log_softmax(x, dim=1)

​​步骤3：适应度计算​

​
定义适应度函数，用于评估个体的性能表现：

  1. ​​训练阶段​​：在训练集上对模型进行5个epoch的优化
  2. ​​评估阶段​​：在测试集上计算模型的分类准确率
  3. ​​适应度值​​：将测试准确率作为个体的适应度评分

该过程通过模型的实际表现来量化每个超参数组合的优劣。


def compute_fitness(model, train_loader, test_loader):
    criterion = nn.NLLLoss()
    optimizer = optim.Adam(model.parameters())

    model.train()
    for epoch in range(5):
        for data, target in train_loader:
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()

    accuracy = correct / total
    return accuracy

​​步骤4：遗传算法参数配置​

​
设置遗传算法运行的关键参数：

  1. ​​种群规模​​ (population_size)：定义每代包含的个体数量

  2. ​​变异率​​ (mutation_rate)：控制每个参数发生突变的概率

  3. ​​迭代代数​​ (num_generations)：指定算法进化的总世代数

这些参数直接影响算法的搜索能力和收敛速度。

population_size = 10
mutation_rate = 0.1
num_generations = 5

步骤5：种群初始化函数

该函数使用指定数量的 CNN 模型初始化种群。

def initialize_population():
    population = []
    for _ in range(population_size):
        model = CNN()
        population.append(model)
    return population

步骤6：交叉算子（crossover）

交叉算子将两个父模型的遗传信息结合起来，产生两个子模型。它通过交换父模型层面层之间的权重来实现单点交叉。

def crossover(parent1, parent2):
    child1 = CNN()
    child2 = CNN()
    child1.conv1.weight.data = torch.cat((parent1.conv1.weight.data[:16], parent2.conv1.weight.data[16:]), dim=0)
    child2.conv1.weight.data = torch.cat((parent2.conv1.weight.data[:16], parent1.conv1.weight.data[16:]), dim=0)
    return child1, child2

步骤7：变异变异（mutate）

变异算子以一定的概率（mutation_rate）对模型的参数进行随机扰动。它会给模型的参数添加高斯噪声。

def mutate(model):
    for param in model.parameters():
        if torch.rand(1).item() < mutation_rate:
            param.data += torch.randn_like(param.data) * 0.1 
    return model

步骤8：加载数据集

使用torchvision加载MNIST数据集。它由手写数字图像和相应的标签组成。

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

​​步骤9：遗传算法主循环​​


通过迭代优化实现超参数进化：

  1. ​​世代迭代​​：循环执行预设的代数（num_generations）

  2. ​​适应度评估​​：对当前种群所有个体进行模型训练和测试准确率计算

  3. ​​精英选择​​：保留每代表现最优的个体直接进入下一代

  4. ​​交叉重组​​：对选中个体进行超参数组合交换

  5. ​​随机变异​​：按概率（mutation_rate）对部分参数进行扰动

该过程持续优化种群，逐步逼近最优超参数组合。

population = initialize_population()
for generation in range(num_generations):
    print("Generation:", generation + 1)
    best_accuracy = 0
    best_individual = None

    for individual in population:
        fitness = compute_fitness(individual, train_loader, test_loader)
        if fitness > best_accuracy:
            best_accuracy = fitness
            best_individual = individual

    print("Best accuracy in generation", generation + 1, ":", best_accuracy)
    print("Best individual:", best_individual)

    next_generation = []

    selected_individuals = population[:population_size // 2]

    for i in range(0, len(selected_individuals), 2):
        parent1 = selected_individuals[i]
        parent2 = selected_individuals[i + 1]
        child1, child2 = crossover(parent1, parent2)
        child1 = mutate(child1)
        child2 = mutate(child2)
        next_generation.extend([child1, child2])

    population = next_generation

3.运行结果和分析

​​输出结果说明​​

  1. ​​迭代信息​​

    • ​​代数标识​​：显示当前进化到第X代（Generation: X）
    • ​​性能指标​​：输出该代最高测试准确率（Best accuracy in generation X: Y%）

  2. ​​模型架构​​

    • ​​最优个体​​：展示当代最佳CNN的超参数配置（Best individual: ...）

  3. ​​最终输出​​

    • ​​进化结果​​：完成所有迭代后，输出最终种群
    • ​​个体表示​​：每个个体对应一个CNN模型，并标注其超参数组合

该输出结构可清晰追踪算法进化过程与优化结果。

4.完整代码

如下：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader


class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = x.view(-1, 64 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return torch.log_softmax(x, dim=1)



def compute_fitness(model, train_loader, test_loader):
    criterion = nn.NLLLoss()
    optimizer = optim.Adam(model.parameters())

    model.train()
    for epoch in range(5):
        for data, target in train_loader:
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()

    accuracy = correct / total
    return accuracy


population_size = 10
mutation_rate = 0.1
num_generations = 5


def initialize_population():
    population = []
    for _ in range(population_size):
        model = CNN()
        population.append(model)
    return population


def crossover(parent1, parent2):
    child1 = CNN()
    child2 = CNN()
    child1.conv1.weight.data = torch.cat((parent1.conv1.weight.data[:16], parent2.conv1.weight.data[16:]), dim=0)
    child2.conv1.weight.data = torch.cat((parent2.conv1.weight.data[:16], parent1.conv1.weight.data[16:]), dim=0)
    return child1, child2


def mutate(model):
    for param in model.parameters():
        if torch.rand(1).item() < mutation_rate:
            param.data += torch.randn_like(param.data) * 0.1
    return model


transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)


population = initialize_population()
for generation in range(num_generations):
    print("Generation:", generation + 1)
    best_accuracy = 0
    best_individual = None

    for individual in population:
        fitness = compute_fitness(individual, train_loader, test_loader)
        if fitness > best_accuracy:
            best_accuracy = fitness
            best_individual = individual

    print("Best accuracy in generation", generation + 1, ":", best_accuracy)
    print("Best individual:", best_individual)

    next_generation = []

    selected_individuals = population[:population_size // 2]

    for i in range(0, len(selected_individuals), 2):
        parent1 = selected_individuals[i]
        parent2 = selected_individuals[i + 1]
        child1, child2 = crossover(parent1, parent2)
        child1 = mutate(child1)
        child2 = mutate(child2)
        next_generation.extend([child1, child2])

    population = next_generation

稀疏编码 (Sparse Coding) 算法详解与PyTorch实现
qq_42568323的博客
01-09 1253
稀疏编码（Sparse Coding）是一种无监督学习方法，旨在通过稀疏表示来捕捉数据的内在结构。稀疏编码的核心思想是将输入数据表示为少量基向量的线性组合，从而实现对数据的高效表示和压缩。稀疏编码广泛应用于图像处理、信号处理、神经科学等领域。MNIST数据集是一个经典的手写数字分类数据集，包含60000个训练样本和10000个测试样本，每个样本是一个28x28的灰度图像，目标是识别图像中的数字（0-9）。
神经进化实践：使用遗传算法优化 Keras 神经网络
盼小辉丶的博客
11-20 2762
Keras 是一个高级神经网络 API，现在已经成为 TensorFlow 的一部分，成为其默认的高级 API。Keras 的设计理念是简单易用、模块化和可扩展，能够快速实现神经网络的原型。在本节中，使用 Keras 构建了一个简单的多层感知机网络，并使用遗传算法优化该网络模型。
使用 PyTorch 实现遗传算法
bgfffg的博客
02-24 1131
CNN 类使用 PyTorch 的 nn.Module 定义了图层神经网络架构。它由两个图层层（conv1 和 conv2）以及后续的最大池化操作和两个连接层（fc1 和 fc2）组成。
多种深度模型实现手写字母MNIST的识别(CNN,RNN,DNN,逻辑回归,CRNN,LSTM/Bi-LSTM,GRU/Bi-GRU)
weixin_38468077的博客
07-28 1215
多种深度模型实现手写字母MNIST的识别(CNN,RNN,DNN,逻辑回归,CRNN,LSTM/Bi-LSTM,GRU/Bi-GRU)
使用 Pyro 和 PyTorch 的贝叶斯神经网络
gongdiwudu的专栏
10-27 5365
我知道我对分类器的期望是不切实际的。它的行为完全按照编程的方式进行。如果我将最后一层（softmax）输出解释为概率，那么作为输入给出的任何图像总会有一个具有最大值的类别。
Python遗传算法GA对长短期记忆LSTM深度学习模型超参数调优分析司机数据|附数据代码...
拓端研究室TRL
04-22 286
全文链接：https://tecdat.cn/?p=36004随着大数据时代的来临，深度学习技术在各个领域中得到了广泛的应用。长短期记忆（LSTM）网络作为深度学习领域中的一种重要模型，因其对序列数据的强大处理能力，在自然语言处理、时间序列预测等领域中取得了显著的成果（点击文末“阅读原文”获取完整代码数据）。相关视频然而，LSTM模型的性能在很大程度上取决于其超参数的设置。因此，如何有效地帮助客户...
遗传算法与深度学习：优化神经网络结构
AI天才研究院
05-23 2235
关键词： 遗传算法，深度学习，神经网络，结构优化，超参数调整深度学习近年来取得了令人瞩目的成就，其在图像识别、自然语言处理、语音识别等领域展现出巨大的应用潜力。然而，深度学习模型的性能很大程度上取决于其结构和超参数的设置。手动设计神经网络结构需要大量的专业知识和经验，并且效率低下。为了解决这个问题，人们开始探索使用自动化方法来优化神经网络结构，而遗传算法作为一种经典的进化算法，为解决这一问题提供了新的思路。遗传算法（Genetic Algorithm，GA）是一种模拟自然选择和遗传机制的优化算法。它将问题的
【视频讲解】Python遗传算法GA优化SVR支持向量回归、ANFIS自适应神经模糊推理系统预测证券指数ISE数据...
拓端研究室TRL
07-22 663
全文链接：https://tecdat.cn/?p=37060本文旨在通过应用多种机器学习技术，对交易所的历史数据进行深入分析和预测。我们帮助客户使用了遗传算法GA优化的支持向量回归（SVR）、自适应神经模糊推理系统（ANFIS）等方法，对数据进行了特征选择、数据预处理、模型训练与评估（点击文末“阅读原文”获取完整代码、数据、讲解视频）。实验结果表明，这些方法在预测证券交易所指数（ISE）方面具有...
遗传算法优化BP神经网络的实战研究
weixin_31974443的博客
10-04 1919
本文还有配套的精品资源，点击获取 简介：遗传算法是一种高效的全局搜索优化策略，能够优化BP神经网络的初始权重和阈值，以提高网络性能和解决局部最优问题。通过模拟生物进化过程，遗传算法在迭代中不断改进网络结构，增加全局搜索能力，并且能够并行处理和自适应调整搜索策略。本文详细探讨了遗传算法优化BP神经网络的理论基础、操作流程和应用场景，如分类与回归、控制优化和特征选择等，强调了该...
深度学习基于CNN的MNIST手写数字识别：遗传算法优化卷积神经网络模型训练过程
04-29
内容概要：本文介绍了一个基于PyTorch实现的卷积神经网络（CNN）及其遗传算法优化过程。首先定义了一个简单的CNN模型，该模型包括两个卷积层和两个全连接层。接着，定义了计算适应度的函数`compute_fitness`，用于...
使用遗传算法训练MNIST数据集的PYTORCH完整教程
使用MNIST数据集与PyTorch框架结合遗传算法进行训练，意味着创建了一个模型，该模型能够根据遗传算法的进化过程来优化其参数。在这个过程中，可能涉及创建一个神经网络模型，并且通过遗传算法来调整网络结构或权重...
一个完整的神经网络训练流程详解（附 PyTorch 示例）
hahaha_1112的博客
04-30 855
一个完整的神经网络训练流程详解
pytorch写张量pt文件，libtorch读张量pt文件
高恩阳的博客
04-27 416
以下是一个最简单的例子，展示如何在 Python 中保存张量到 TorchScript 模块，并在 C++ 中使用 LibTorch 加载。直接再python中，用torch.save保存的张量，可能因格式差异无法在C++中加载。这种方法可靠，因为 TorchScript 提供了跨语言的序列化支持，保证张量数据一致性。Python 代码 (save_tensor.py)C++ 代码 (load_tensor.cpp)
Python PyTorch库【机器学习框架】全面深入讲解与实践
记录点滴
04-29 1778
PyTorch 是由 Facebook AI Research (FAIR) 开发的开源机器学习框架，2016 年首次发布。动态计算图GPU 加速张量计算自动微分系统丰富的神经网络模块与 TensorFlow 的静态图相比，PyTorch 的动态图机制更符合 Python 编程习惯，使其在学术研究中迅速流行（2022 年论文采用率达 70%+）。
【锂电池剩余寿命预测】Transformer锂电池剩余寿命预测（Pytorch完整源码和数据）
机器学习之心的博客，关注并私信文章链接，获取对应文章源码和数据。
04-27 135
【锂电池剩余寿命预测】Transformer锂电池剩余寿命预测（Pytorch完整源码和数据）
“100% 成功的 PyTorch CUDA GPU 支持” 安装攻略
最新发布
love530love的博客
04-30 1535
通过严格按照上述步骤操作，特别是使用 PyTorch 官方网站生成的安装命令，我们能够确保torch和torchaudio三个包的版本兼容性，从而 100% 成功安装带有 CUDA 12.8 GPU 支持的 PyTorch。在安装过程中，要仔细检查每个步骤，根据不同的项目需求准确判断并配置安装选项，确保满足先决条件。同时，优先选择pip或conda从官方网站获取命令进行安装，避免使用不推荐的本地安装方式。希望这份攻略能够帮助我们顺利搭建起高效的深度学习开发环境。
pytorch对应gpu版本是否可用判断逻辑
lin的博客
04-30 279
判断gpu是否可用
动手学深度学习11.10. Adam算法-笔记&练习（PyTorch）
scdifsn的博客
04-27 1078
李沐老师《动手学深度学习（PyTorch）》11.10. Adam算法-笔记&练习详解
pytorch学习使用
weixin_42638946的博客
04-27 505
1.2 创建tensor 1.3 tensor之间的运算 1.4 tensor和数字之间的运算 1.5 tensor尺寸修改 1.6 tensor转置 1.7 tensor拼接 2. 搭建常见模型 2.1 DNN 2.1.1 代码 2.1.2 结果 2.1.3 输出结果分析 网络结构 线性全连接层的参数量为：(Cin+1)×Cout(C_{in}+1) \times C_{out}(Cin​+1)×Cout​，其中：CinC_{in}Cin​：输入维度；CoutC_{out}Cout​：输出
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

听风吹等浪起

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值