NumPyCNN：从零开始实现卷积神经网络

NumPyCNN 是一个使用 NumPy 从零开始实现的卷积神经网络（CNN）Python 库。

重要提示 如果您是为名为使用 NumPy 从零开始构建卷积神经网络 的教程代码而来，那么该代码已于 2020 年 5 月 20 日移至 TutorialProject 目录下。

该项目包含一个名为 cnn.py 的模块，实现了构建 CNN 所需的所有类和函数。

需要注意的是，该项目仅实现了 CNN 训练的 前向传播，并且 未使用任何学习算法。每次迭代后仅会根据学习率对权重进行一些调整，这比保持权重不变要好。

该项目可用于分类问题，但每个样本只能属于一个类别。

未来，该项目将借助名为 PyGAD 的库扩展为 使用遗传算法训练 CNN。请参阅该库的文档：Read The Docs：https://pygad.readthedocs.io

捐赠

• 信用卡/借记卡：https://donate.stripe.com/eVa5kO866elKgM0144
• Open Collective：opencollective.com/pygad
• PayPal：可使用此链接：paypal.me/ahmedfgad，或发送邮件至 ahmed.f.gad@gmail.com
• Interac 电子转账：请使用电子邮件地址 ahmed.f.gad@gmail.com

安装

要安装 PyGAD，只需使用 pip 从 PyPI（Python 软件包索引）下载并安装该库。该库在 PyPI 上的页面为：https://pypi.org/project/pygad。

通过以下命令安装 PyGAD：

pip install pygad

要开始使用 PyGAD，请阅读位于 Read The Docs 的文档：https://pygad.readthedocs.io。

PyGAD 源代码

PyGAD 各模块的源代码位于以下 GitHub 项目中：

• pygad：(https://github.com/ahmedfgad/GeneticAlgorithmPython)
• pygad.nn：https://github.com/ahmedfgad/NumPyANN
• pygad.gann：https://github.com/ahmedfgad/NeuralGenetic
• pygad.cnn：https://github.com/ahmedfgad/NumPyCNN
• pygad.gacnn：https://github.com/ahmedfgad/CNNGenetic
• pygad.kerasga：https://github.com/ahmedfgad/KerasGA
• pygad.torchga：https://github.com/ahmedfgad/TorchGA

PyGAD 的文档可在 Read The Docs 上找到：https://pygad.readthedocs.io。

PyGAD 文档

PyGAD 库的文档可在 Read The Docs 上找到，链接为：https://pygad.readthedocs.io。文档详细介绍了 PyGAD 支持的模块、所有类、方法、属性和函数，并为每个模块提供了多个示例。

如果在使用 PyGAD 时遇到问题，欢迎在 GitHub 仓库 中提交问题：https://github.com/ahmedfgad/GeneticAlgorithmPython，或发送邮件至 ahmed.f.gad@gmail.com。

如果您开发了使用 PyGAD 的项目，请将以下信息发送至 ahmed.f.gad@gmail.com，以便您的项目能被收录到文档中：

• 项目标题
• 简要描述
• 最好附上指向您项目的链接

更多联系方式请参阅“联系我们”部分。

PyGAD 生命周期

下图列出了 pygad.GA 类实例生命周期中的各个阶段。请注意，当所有代数完成，或者传递给 on_generation 参数的函数返回字符串 stop 时，PyGAD 将停止运行。

以下代码实现了所有回调函数，用于跟踪遗传算法的执行过程。每个回调函数都会打印其名称。

import pygad
import numpy

function_inputs = [4,-2,3.5,5,-11,-4.7]
desired_output = 44

def fitness_func(ga_instance, solution, solution_idx):
    output = numpy.sum(solution*function_inputs)
    fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
    return fitness

fitness_function = fitness_func

def on_start(ga_instance):
    print("on_start()")

def on_fitness(ga_instance, population_fitness):
    print("on_fitness()")

def on_parents(ga_instance, selected_parents):
    print("on_parents()")

def on_crossover(ga_instance, offspring_crossover):
    print("on_crossover()")

def on_mutation(ga_instance, offspring_mutation):
    print("on_mutation()")

def on_generation(ga_instance):
    print("on_generation()")

def on_stop(ga_instance, last_population_fitness):
    print("on_stop()")

ga_instance = pygad.GA(num_generations=3,
                       num_parents_mating=5,
                       fitness_func=fitness_function,
                       sol_per_pop=10,
                       num_genes=len(function_inputs),
                       on_start=on_start,
                       on_fitness=on_fitness,
                       on_parents=on_parents,
                       on_crossover=on_crossover,
                       on_mutation=on_mutation,
                       on_generation=on_generation,
                       on_stop=on_stop)

ga_instance.run()

根据 num_generations 参数设置的 3 个世代，输出如下：

on_start()

on_fitness()
on_parents()
on_crossover()
on_mutation()
on_generation()

on_fitness()
on_parents()
on_crossover()
on_mutation()
on_generation()

on_fitness()
on_parents()
on_crossover()
on_mutation()
on_generation()

on_stop()

示例

有关此示例的实现信息，请参阅 PyGAD 的文档。

import numpy
import pygad.cnn

train_inputs = numpy.load("dataset_inputs.npy")
train_outputs = numpy.load("dataset_outputs.npy")

sample_shape = train_inputs.shape[1:]
num_classes = 4

input_layer = pygad.cnn.Input2D(input_shape=sample_shape)
conv_layer1 = pygad.cnn.Conv2D(num_filters=2,
                               kernel_size=3,
                               previous_layer=input_layer,
                               activation_function=None)
relu_layer1 = pygad.cnn.Sigmoid(previous_layer=conv_layer1)
average_pooling_layer = pygad.cnn.AveragePooling2D(pool_size=2, 
                                                   previous_layer=relu_layer1,
                                                   stride=2)

conv_layer2 = pygad.cnn.Conv2D(num_filters=3,
                               kernel_size=3,
                               previous_layer=average_pooling_layer,
                               activation_function=None)
relu_layer2 = pygad.cnn.ReLU(previous_layer=conv_layer2)
max_pooling_layer = pygad.cnn.MaxPooling2D(pool_size=2, 
                                           previous_layer=relu_layer2,
                                           stride=2)

conv_layer3 = pygad.cnn.Conv2D(num_filters=1,
                               kernel_size=3,
                               previous_layer=max_pooling_layer,
                               activation_function=None)
relu_layer3 = pygad.cnn.ReLU(previous_layer=conv_layer3)
pooling_layer = pygad.cnn.AveragePooling2D(pool_size=2, 
                                           previous_layer=relu_layer3,
                                           stride=2)

flatten_layer = pygad.cnn.Flatten(previous_layer=pooling_layer)
dense_layer1 = pygad.cnn.Dense(num_neurons=100, 
                               previous_layer=flatten_layer,
                               activation_function="relu")
dense_layer2 = pygad.cnn.Dense(num_neurons=num_classes, 
                               previous_layer=dense_layer1,
                               activation_function="softmax")

model = pygad.cnn.Model(last_layer=dense_layer2,
                        epochs=1,
                        learning_rate=0.01)

model.summary()

model.train(train_inputs=train_inputs, 
            train_outputs=train_outputs)

predictions = model.predict(data_inputs=train_inputs)
print(predictions)

num_wrong = numpy.where(predictions != train_outputs)[0]
num_correct = train_outputs.size - num_wrong.size
accuracy = 100 * (num_correct/train_outputs.size)
print("正确分类的数量：{num_correct}。".format(num_correct=num_correct))
print("错误分类的数量：{num_wrong}。".format(num_wrong=num_wrong.size))
print("分类准确率：{accuracy}%。".format(accuracy=accuracy))

更多信息

有多种资源可以帮助您开始构建卷积神经网络及其 Python 实现。

教程：在 Python 中实现遗传算法

要开始编写遗传算法代码，您可以查看题为 “在 Python 中实现遗传算法” 的教程，该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets

本教程 是基于该项目的早期版本编写的，但仍然是开始学习遗传算法编程的一个很好的资源。

教程：遗传算法简介

通过阅读题为 “使用遗传算法进行优化简介” 的教程来入门遗传算法，该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets

教程：在 Python 中构建神经网络

通过题为 “使用 NumPy 实现人工神经网络并分类 Fruits360 图像数据集” 的教程了解如何在 Python 中构建神经网络，该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets

教程：用遗传算法优化神经网络

通过题为 “使用遗传算法和 Python 优化人工神经网络” 的教程了解如何利用遗传算法训练神经网络，该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets

教程：用Python构建卷积神经网络

要开始编写遗传算法，您可以查看题为从零开始使用NumPy构建卷积神经网络的教程，该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets
• 中文翻译

本教程是基于该项目的早期版本编写的，但仍然是开始编码CNN的一个很好的资源。

教程：从全连接神经网络推导卷积神经网络

通过阅读题为逐步从全连接网络推导卷积神经网络的教程，您可以开始学习遗传算法。该教程可通过以下链接访问：

• LinkedIn
• Towards Data Science
• KDnuggets

书籍：使用CNN进行深度学习的实用计算机视觉应用

您还可以查阅我的著作，即Ahmed Fawzy Gad《使用CNN进行深度学习的实用计算机视觉应用》。2018年12月，Apress出版社，ISBN 978-1-4842-4167-7，书中讨论了神经网络、卷积神经网络、深度学习、遗传算法等内容。

您可以通过以下链接找到该书：

• 亚马逊
• 施普林格
• Apress
• O'Reilly
• Google图书

引用PyGAD——BibTeX格式的引用

如果您使用了PyGAD，请考虑在关于PyGAD的论文中添加以下引用：

@misc{gad2021pygad,
      title={PyGAD: 一个直观的遗传算法Python库}, 
      author={Ahmed Fawzy Gad},
      year={2021},
      eprint={2106.06158},
      archivePrefix={arXiv},
      primaryClass={cs.NE}
}

联系我们

• 邮箱：ahmed.f.gad@gmail.com
• LinkedIn
• 亚马逊作者页面
• Heartbeat
• Paperspace
• KDnuggets
• TowardsDataScience
• GitHub

NumPyCNN 快速上手指南

NumPyCNN 是一个完全使用 Python 和 NumPy 从零开始实现的卷积神经网络（CNN）库。该项目主要用于教学和理解 CNN 的前向传播原理，并计划结合遗传算法（通过 PyGAD 库）进行模型训练。

注意：当前版本主要实现 CNN 的前向传播。虽然支持通过简单的学习率调整权重，但并未包含标准的反向传播学习算法。完整的训练功能需配合 PyGAD 库使用遗传算法实现。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统：Windows、Linux 或 macOS
• Python 版本：Python 3.x
• 核心依赖：
  • numpy：用于数值计算
  • pygad：用于遗传算法训练（NumPyCNN 的核心训练依赖）

安装步骤

推荐使用 pip 进行安装。如果您在中国大陆地区，建议使用国内镜像源以加速下载。

1. 安装依赖库

使用清华镜像源安装 pygad（该库已包含对 NumPyCNN 的支持及 numpy 依赖）：

pip install pygad -i https://pypi.tuna.tsinghua.edu.cn/simple

或者使用阿里云镜像源：

pip install pygad -i https://mirrors.aliyun.com/pypi/simple/

2. 验证安装

安装完成后，您可以在 Python 中尝试导入模块以验证是否成功：

import pygad.cnn
import numpy
print("Installation successful!")

基本使用

以下是一个构建简单 CNN 模型并进行预测的最小化示例。该示例展示了如何定义网络层、初始化模型以及执行前向传播。

代码示例

import numpy
import pygad.cnn

# 1. 准备数据 (此处使用随机数据演示，实际使用时请加载您的数据集)
# 假设输入形状为 (样本数, 高, 宽, 通道数)，例如 (10, 28, 28, 1)
train_inputs = numpy.random.rand(10, 28, 28, 1)
# 假设输出为分类标签 (0-3)
train_outputs = numpy.random.randint(0, 4, size=(10,))

sample_shape = train_inputs.shape[1:]
num_classes = 4

# 2. 构建网络层
# 输入层
input_layer = pygad.cnn.Input2D(input_shape=sample_shape)

# 卷积层 1 + 激活函数
conv_layer1 = pygad.cnn.Conv2D(num_filters=2,
                               kernel_size=3,
                               previous_layer=input_layer,
                               activation_function=None)
relu_layer1 = pygad.cnn.Sigmoid(previous_layer=conv_layer1) # 原文示例使用 Sigmoid，也可用 ReLU

# 池化层 1
average_pooling_layer = pygad.cnn.AveragePooling2D(pool_size=2, 
                                                   previous_layer=relu_layer1,
                                                   stride=2)

# 卷积层 2 + 激活函数
conv_layer2 = pygad.cnn.Conv2D(num_filters=3,
                               kernel_size=3,
                               previous_layer=average_pooling_layer,
                               activation_function=None)
relu_layer2 = pygad.cnn.ReLU(previous_layer=conv_layer2)

# 池化层 2
max_pooling_layer = pygad.cnn.MaxPooling2D(pool_size=2, 
                                           previous_layer=relu_layer2,
                                           stride=2)

# 卷积层 3 + 激活函数
conv_layer3 = pygad.cnn.Conv2D(num_filters=1,
                               kernel_size=3,
                               previous_layer=max_pooling_layer,
                               activation_function=None)
relu_layer3 = pygad.cnn.ReLU(previous_layer=conv_layer3)

# 展平层
flatten_layer = pygad.cnn.Flatten(previous_layer=relu_layer3)

# 全连接层 (Dense Layers)
dense_layer1 = pygad.cnn.Dense(num_neurons=100, 
                               previous_layer=flatten_layer,
                               activation_function="relu")
dense_layer2 = pygad.cnn.Dense(num_neurons=num_classes, 
                               previous_layer=dense_layer1,
                               activation_function="softmax")

# 3. 初始化模型
model = pygad.cnn.Model(last_layer=dense_layer2,
                        epochs=1,          # 迭代次数
                        learning_rate=0.01) # 学习率

# 查看模型结构摘要
model.summary()

# 4. 训练模型
# 注意：此处的 train 方法主要基于遗传算法框架或简单的权重扰动，非传统反向传播
model.train(train_inputs=train_inputs, 
            train_outputs=train_outputs)

# 5. 进行预测
predictions = model.predict(data_inputs=train_inputs)

# 6. 计算准确率
num_wrong = numpy.where(predictions != train_outputs)[0]
num_correct = train_outputs.size - num_wrong.size
accuracy = 100 * (num_correct/train_outputs.size)

print(f"Number of correct classifications : {num_correct}.")
print(f"Number of wrong classifications : {num_wrong.size}.")
print(f"Classification accuracy : {accuracy}.")

说明

• 层连接：每一层通过 previous_layer 参数连接到上一层，形成链式结构。
• 训练机制：由于本项目侧重于从零实现原理，其 train 方法在未结合外部优化器时，仅利用学习率对权重进行微调。若要获得更好的训练效果，请参考 PyGAD 文档使用遗传算法进行优化。
• 数据类型：本示例适用于单标签分类问题（每个样本仅属于一个类别）。