关于数据挖掘:Python用GAN生成对抗性神经网络判别模型拟合多维数组分类识别手写数字图像可视化

全文链接：https://tecdat.cn/?p=33566

原文出处：拓端数据部落公众号

生成反抗网络（GAN）是一种神经网络，能够生成相似于人类产生的资料，如图像、音乐、语音或文本。最近咱们被客户要求撰写对于 GAN 生成对抗性神经网络的钻研报告，包含一些图形和统计输入。

近年来，GAN 始终是钻研的热门话题。Facebook 的 AI 钻研总监 Yann LeCun 称反抗训练是“过来 10 年中最乏味的机器学习畛域的想法”。

本文将介绍以下内容：

• 什么是生成模型以及它与判断模型的区别
• GAN 的构造和训练形式
• 如何应用 PyTorch 构建 GAN
• 如何应用 GPU 和 PyTorch 训练 GAN 以实现理论利用

什么是生成反抗网络？

生成反抗网络是一种能够学习模拟给定数据分布的机器学习零碎。它们最早是由深度学习专家 Ian Goodfellow 及其共事在 2014 年的一篇 NeurIPS 论文中提出的。

GAN 由两个神经网络组成，一个网络用于生成数据，另一个网络用于辨别实在数据和假数据（因而模型具备 ” 反抗 ” 的性质）。尽管生成数据的构造并不陈腐，但在图像和视频生成方面，GAN 获得了令人印象粗浅的成绩，例如：

• 应用 CycleGAN 进行格调转换，能够对图像进行多种令人信服的格调转换
• 利用 StyleGAN 生成人脸，如网站 This Person Does Not Exist 上所示

判断模型与生成模型

如果您学习过神经网络，那么您接触到的大多数利用很可能是应用判断模型实现的。而生成反抗网络属于一类不同的模型，被称为生成模型。

在训练过程中，您会应用一个算法来调整模型的参数。指标是通过最小化损失函数使模型学习到给定输出的输入的概率分布。在训练阶段之后，您能够应用该模型通过预计输出最可能对应的数字来对新的手写数字图像进行分类，如下图所示：

您能够将用于分类问题的判断模型设想成应用训练数据来学习类别之间边界的区块。而后，它们应用这些边界来辨别输出并预测其类别。数学上来说，判断模型学习输入 y 给定输出 x 的条件概率P(y|x)。

除了神经网络，其余构造也能够用作判断模型，例如逻辑回归模型和反对向量机（SVM）。

然而，生成模型（如 GAN）被训练为形容数据集的生成形式，以概率模型的模式进行。通过从生成模型中采样，您能够生成新的数据。尽管判断模型罕用于有监督学习，但生成模型通常与无标签的数据集一起应用，并可被视为一种无监督学习的模式。

应用手写数字数据集，您能够训练一个生成模型来生成新的数字。在训练阶段，您会应用某种算法来调整模型的参数，以最小化损失函数并学习训练集的概率分布。而后，通过训练好的模型，您能够生成新的样本，如下图所示：

为了输入新的样本，生成模型通常思考到一个随机元素，该随机元素影响模型生成的样本。用于驱动生成器的随机样本是从 ” 潜在空间 ” 中取得的，在该空间中，向量示意一种压缩模式的生成样本。

与判断模型不同，生成模型学习输出数据 x 的概率P(x)，通过具备输出数据分布，它们可能生成新的数据实例。

只管 GAN 近年来受到了宽泛关注，但它们并不是惟一可用作生成模型的架构。除了 GAN，还有其余各种生成模型架构，例如：

• 伯劳兹曼机（Boltzmann machines）
• 变分自编码器（Variational autoencoders）
• 隐马尔可夫模型（Hidden Markov models）
• 预测序列中的下一个词的模型，如 GPT-2

然而，因为其在图像和视频生成方面获得的令人兴奋的后果，GAN 最近引起了公众的最大关注。

当初您已理解生成模型的基础知识，接下来将介绍 GAN 的工作原理和训练方法。

生成反抗网络（GAN）的架构

生成反抗网络由两个神经网络组成，一个称为 ” 生成器 ”（generator），另一个称为 ” 判断器 ”（discriminator）。

生成器的作用是预计实在样本的概率分布，以提供相似实在数据的生成样本。而判断器则被训练来预计给定样本来自实在数据的概率，而不是由生成器提供的。

这些构造被称为生成反抗网络，因为生成器和判断器被训练以相互竞争：生成器试图在愚弄判断器方面变得更好，而判断器试图在辨认生成样本方面变得更好。

为了了解 GAN 的训练过程，思考一个示例，蕴含一个由二维样本（x₁, x₂）组成的数据集，其中 x₁ 在 0 到 2π 的区间内，x₂ = sin(x₁)，如下图所示：

能够看到，这个数据集由位于正弦曲线上的点 (x₁, x₂) 组成，具备十分非凡的散布。GAN 的整体构造用于生成相似数据集样本的 (x̃₁, x̃₂) 对，如下图所示：

生成器 G 接管来自潜在空间的随机数据，并且其作用是生成相似实在样本的数据。在这个示例中，咱们有一个二维的潜在空间，因而生成器接管随机的 (z₁, z₂) 对，并要求将它们转化为相似实在样本的模式。

生成反抗网络（GAN）

作为生成反抗网络的首次试验，你将实现后面一节中形容的示例。

要运行这个示例，你须要应用 PyTorch 库，能够通过 Anaconda Python 发行版和 conda 软件包和环境管理系统来装置。

首先，创立一个 conda 环境并激活它：

$ conda create --name gan
$ conda activate gan

当你激活 conda 环境后，你的命令提示符会显示环境的名称，即gan。而后你能够在该环境中装置必要的包：

$ conda install -c pytorch pytorch=1.4.0
$ conda install matplotlib jupyter

因为 PyTorch 是一个十分沉闷的开发框架，其 API 可能会在新版本中发生变化。为了确保示例代码可能运行，你须要装置特定的版本 1.4.0。

除了 PyTorch，你还将应用 Matplotlib 进行绘图，并在 Jupyter Notebook 中运行交互式代码。这并不是强制性的，但它有助于进行机器学习我的项目的工作。

在关上 Jupyter Notebook 之前，你须要注册 conda 环境 gan，以便能够将其作为内核来创立 Notebook。要做到这一点，在激活gan 环境后，运行以下命令：

$ python -m ipykernel install --user --name gan

当初你能够通过运行 jupyter notebook 来关上 Jupyter Notebook。通过点击“新建”而后抉择“gan”来创立一个新的 Notebook。

在 Notebook 中，首先导入必要的库：

import torch
from torch import nn

import math
import matplotlib.pyplot as plt

在这里，你应用 torch 导入了 PyTorch 库。你还导入 nn，为了可能以更简洁的形式设置神经网络。而后你导入math 来获取 pi 常数的值，并依照常规导入 Matplotlib 绘图工具为plt。

为了使试验在任何机器上都能齐全复现，最好设置一个 随机生成器种子。在 PyTorch 中，能够通过运行以下代码来实现：

torch.manual_seed(111)

数字 111 代表用于初始化随机数生成器的随机种子，它用于初始化神经网络的权重。只管试验具备随机性，但只有应用雷同的种子，它应该产生雷同的后果。

当初环境曾经设置好，能够筹备训练数据了。

筹备训练数据

训练数据由一对（x₁，x₂）组成，其中x₂是x₁在区间从 0 到 2π 上的正弦值。你能够依照以下形式实现它：

train_data_length = 1024

train_set = [(train_data[i], train_labels[i]) for i in range(train_data_length)
]

在这里，你创立了一个蕴含 1024 对（x₁，x₂）的训练集。在 第 2 行 ，你初始化了train_data，它是一个具备1024 行和 2 列的张量，所有元素都为零。张量 是一个相似于 NumPy 数组的多维数组。

在 第 3 行 ，你应用train_data 的第一列来存储在 0 到2π区间内的随机值。而后，在 第 4 行，你计算了张量的第二列，即第一列的正弦值。

接下来，你须要一个标签张量，PyTorch 的数据加载器须要应用它。因为 GAN 应用无监督学习技术，标签能够是任何值。毕竟，它们不会被应用。

在 第 5 行 ，你创立了一个填充了零的train_labels 张量。最初，在 第 6 到 8 行 ，你将train_set 创立为元组列表，其中每个元组代表 train_data 和train_labels的每一行，正如 PyTorch 的数据加载器所冀望的那样。

你能够通过绘制每个点（x₁，x₂）来查看训练数据：

plt.plot(train_data[:, 0], train_data[:, 1], ".")

输入应该相似于以下图形：

应用train_set，您能够创立一个 PyTorch 数据加载器：

batch_size = 32

)

在这里，您创立了一个名为 train_loader 的数据加载器，它将对 train_set 中的数据进行洗牌，并返回大小为 32 的样本批次，您将应用这些批次来训练神经网络。

设置训练数据后，您须要为判断器和生成器创立神经网络，它们将组成 GAN。在下一节中，您将实现判断器。

实现判断器

在 PyTorch 中，神经网络模型由继承自 nn.Module 的类示意，因而您须要定义一个类来创立判断器。

判断别器是一个具备二维输出和一维输入的模型。它将接管来自实在数据或生成器的样本，并提供样本属于实在训练数据的概率。上面的代码展现了如何创立判断器：

class Discriminator(nn.Module):
    def __init__(self):
   
            nn.Linear(64, 1),
            nn.Sigmoid(),)

    def forward(self, x):
        output = self.model(x)
        return output

您应用 . __init __() 来构建模型。首先，您须要调用 super().__init __() 来运行 nn.Module 中的 .__init __()。您应用的判断器是在nn.Sequential() 中以程序形式定义的 MLP 神经网络。它具备以下特点：

• 第 5 和第 6 行：输出为二维，第一个暗藏层由 256 个神经元组成，并应用 ReLU)激活函数。
• 第 8、9、11 和 12 行：第二个和第三个暗藏层别离由 128 个和 64 个神经元组成，并应用 ReLU 激活函数。
• 第 14 和第 15 行：输入由一个神经元组成，并应用 sigmoidal 激活函数示意概率。
• 第 7、10 和 13 行：在第一个、第二个和第三个暗藏层之后，您应用 dropout)来防止过拟合。

最初，您应用 .forward() 来形容如何计算模型的输入。这里，x示意模型的输出，它是一个二维张量。在此实现中，通过将输出 x 馈送到您定义的模型中而不进行任何其余解决来取得输入。

申明判断器类后，您应该实例化一个 Discriminator 对象：

discriminator = Discriminator()

discriminator代表您定义的神经网络的一个实例，筹备好进行训练。然而，在实现训练循环之前，您的 GAN 还须要一个生成器。您将在下一节中实现一个生成器。

实现生成器

在生成反抗网络中，生成器是一个以潜在空间中的样本作为输出，并生成相似于训练集中数据的模型。在这种状况下，它是一个具备二维输出的模型，将接管随机点（z₁，z₂），并提供相似于训练数据中的（x̃₁，x̃₂）点的二维输入。

实现相似于您为判断器所做的操作。首先，您必须创立一个从 nn.Module 继承并定义神经网络架构的 Generator 类，而后须要实例化一个 Generator 对象：

class Generator(nn.Module):
    def __init__(self):
        super().__init__()
  
generator = Generator()

在这里，generator代表生成器神经网络。它由两个具备 16 个和 32 个神经元的暗藏层组成，两者都应用 ReLU 激活函数，以及一个具备 2 个神经元的线性激活层作为输入。这样，输入将由一个蕴含两个元素的向量组成，能够是从负无穷大到正无穷大的任何值，这些值将示意（x̃₁，x̃₂）。

当初，您已定义了判断器和生成器的模型，能够开始进行训练了！

训练模型

在训练模型之前，您须要设置一些参数来在训练过程中应用：

lr = 0.001
num_epochs = 300

在这里，您设置了以下参数：

• 第 1 行 设置学习率（lr），您将应用它来调整网络权重。
• 第 2 行 设置了周期数（num_epochs），定义了对整个训练集进行训练的反复次数。
• 第 3 行 将变量 loss_function 赋值为二进制穿插熵函数BCELoss()，这是您将用于训练模型的损失函数。

二进制穿插熵函数是训练判断器的实用损失函数，因为它思考了二元分类工作。它也实用于训练生成器，因为它将其输入馈送给判断器，后者提供一个二进制的可观测输入。

PyTorch 在 torch.optim 中实现了各种权重更新规定用于模型训练。您将应用 Adam 算法来训练判断器和生成器模型。要应用 torch.optim 创立优化器，请运行以下代码：

optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

最初，你须要实现一个训练循环，在该循环中，将训练样本输出模型，并更新其权重以最小化损失函数：

for epoch in range(num_epochs):
    for n, (real_samples, _) in enumerate(train_loader):
        # 训练判断器的数据
        real_samples_labels = torch.ones((batch_size, 1))
  
  
        # 训练判断器
        discriminator.zero_grad()
  
  
        # 训练生成器的数据
        latent_space_samples = torch.randn((batch_size, 2))

        # 训练生成器
        generator.zero_grad()
    
    

        # 显示损失
        if epoch % 10 == 0 and n == batch_size - 1:
        
        

对于生成反抗网络（GANs），您须要在每个训练迭代中更新判断器和生成器的参数。与所有神经网络一样，训练过程包含两个循环，一个用于训练周期，另一个用于每个周期的批处理。在外部循环中，您开始筹备用于训练判断器的数据：

• 第 2 行： 从数据加载器中获取以后批次的实在样本，并将其赋值给 real_samples。请留神，张量的第一个维度具备与batch_size 相等的元素数量。这是在 PyTorch 中组织数据的规范形式，张量的每一行示意批次中的一个样本。
• 第 4 行： 应用 torch.ones() 为实在样本创立标签，并将标签赋给real_samples_labels。
• 第 5 和第 6 行： 通过在 latent_space_samples 中存储随机数据，创立生成的样本，而后将其输出生成器以取得generated_samples。
• 第 7 行： 应用 torch.zeros() 将标签值 0 调配给生成的样本的标签，而后将标签存储在 generated_samples_labels 中。
• 第 8 到 11 行： 将实在样本和生成的样本以及标签连接起来，并将其存储在 all_samples 和all_samples_labels中，您将应用它们来训练判断器。

接下来，在第 14 到 19 行，您训练了判断器：

• 第 14 行： 在 PyTorch 中，每个训练步骤都须要革除梯度，以防止积攒。您能够应用 .zero_grad() 来实现这一点。
• 第 15 行： 您应用训练数据 all_samples 计算判断器的输入。
• 第 16 和 17 行： 您应用模型的输入 output_discriminator 和标签 all_samples_labels 来计算损失函数。
• 第 18 行： 您应用 loss_discriminator.backward() 计算梯度以更新权重。
• 第 19 行： 您通过调用 optimizer_discriminator.step() 来更新判断器的权重。

接下来，在第 22 行，您筹备用于训练生成器的数据。您将随机数据存储在 latent_space_samples 中，行数与 batch_size 相等。因为您将二维数据作为输出提供给生成器，因而应用了两列。

而后，在第 25 到 32 行，您训练了生成器：

• 第 25 行： 应用 .zero_grad() 革除梯度。
• 第 26 行： 将 latent_space_samples 提供给生成器，并将其输入存储在 generated_samples 中。
• 第 27 行： 将生成器的输入输出判断器，并将其输入存储在 output_discriminator_generated 中，您将应用其作为整个模型的输入。
• 第 28 到 30 行： 应用分类零碎的输入 output_discriminator_generated 和标签 real_samples_labels 计算损失函数，这些标签都等于1。
• 第 31 和 32 行： 计算梯度并更新生成器的权重。请记住，当训练生成器时，放弃判断器权重解冻，因为您创立了optimizer_generator，其第一个参数等于generator.parameters()。

最初，在第 35 到 37 行，您显示了每十个周期完结时判断器和生成器损失函数的值。

因为此示例中应用的模型参数较少，训练将在几分钟内实现。在接下来的局部中，您将应用训练的 GAN 生成一些样本。

查看 GAN 生成的样本

生成反抗网络被设计用于生成数据。因而，在训练过程完结后，您能够从潜在空间中获取一些随机样本，并将它们提供给生成器以取得一些生成的样本：

latent_space_samples = torch.randn(100, 2)

而后，您能够绘制生成的样本，并查看它们是否相似于训练数据。在绘制 generated_samples 数据之前，您须要应用 .detach() 从 PyTorch 计算图中返回一个张量，而后应用它来计算梯度：

generated_samples = generated_samples.detach()

输入应相似于以下图像：

您能够看到，生成的数据分布相似于实在数据。通过应用固定的潜在空间样本张量，并在训练过程的每个周期完结时将其提供给生成器，您能够可视化训练的演变。

手写数字图像与 GAN

生成反抗网络能够生成高维样本，例如图像。在此示例中，您将应用 GAN 生成手写数字图像。为此，您将应用蕴含手写数字的 MNIST 数据集，该数据集已蕴含在 torchvision 包中。

首先，您须要在已激活的gan conda 环境中装置torchvision：

$ conda install -c pytorch torchvision=0.5.0

与后面一样，您应用特定版本的 torchvision 来确保示例代码能够运行，就像您在 pytorch 上所做的一样。设置好环境后，您能够在 Jupyter Notebook 中开始实现模型。

与之前的示例一样，首先导入必要的库：

import torch
from torch import nn

除了之前导入的库外，您还将须要 torchvision 和transforms来获取训练数据并执行图像转换。

同样，设置随机生成器种子以便可能复制试验：

torch.manual_seed(111)

因为此示例在训练集中应用图像，所以模型须要更简单，并且具备更多的参数。这使得训练过程变慢，当在 CPU 上运行时，每个周期须要大概两分钟。您须要大概 50 个周期能力取得相干后果，因而在应用 CPU 时的总训练工夫约为 100 分钟。

为了缩小训练工夫，如果您有可用的 GPU，能够应用它来训练模型。然而，您须要手动将张量和模型挪动到 GPU 上，以便在训练过程中应用它们。

您能够通过创立一个指向 CPU 或（如果有）GPU 的 device 对象来确保您的代码将在任何一种设置上运行：

device = ""device = torch.device("cpu")

稍后，您将应用此 device 在可用的状况下应用 GPU 来设置张量和模型的创立地位。

当初根本环境曾经设置好了，您能够筹备训练数据。

筹备训练数据

MNIST 数据集由 28×28 像素的灰度手写数字图像组成，范畴从 0 到 9。为了在 PyTorch 中应用它们，您须要进行一些转换。为此，您定义了一个名为 transform 的函数来加载数据时应用：

transform = transforms.Compose()

该函数分为两个局部：

1. transforms.ToTensor()将数据转换为 PyTorch 张量。
2. transforms.Normalize()转换张量系数的范畴。

由 transforms.ToTensor() 产生的原始系数范畴从 0 到 1，而且因为图像背景是彩色，当应用此范畴示意时，大多数系数都等于 0。

transforms.Normalize()通过从原始系数中减去 0.5 并将后果除以0.5，将系数的范畴更改为 - 1 到 1。通过这种转换，输出样本中为 0 的元素数量大大减少，有助于训练模型。

transforms.Normalize()的参数是两个元组 (M₁, ..., Mₙ) 和(S₁, ..., Sₙ)，其中 n 示意图像的通道)数量。MNIST 数据集中的灰度图像只有一个通道，因而元组只有一个值。因而，对于图像的每个通道 i，transforms.Normalize() 从系数中减去 Mᵢ 并将后果除以Sᵢ。

当初，您能够应用 torchvision.datasets.MNIST 加载训练数据，并应用 transform 进行转换：

train_set = torchvision.datasets.MNIST()

参数 download=True 确保您第一次运行上述代码时，MNIST 数据集将会被下载并存储在当前目录中，如参数 root 所批示的地位。

当初您曾经创立了train_set，能够像之前一样创立数据加载器：

batch_size = 32
train_loader = torch.utils.data.DataLoader()

您能够应用 Matplotlib 绘制一些训练数据的样本。为了改善可视化成果，您能够应用 cmap=gray_r 来反转色彩映射，并以彩色数字在红色背景上绘制：

real_samples, mnist_labels = next(iter(train_loader))
for i in range(16):
  
  

输入应该相似于以下内容：

如您所见，有不同的手写格调的数字。随着 GAN 学习数据的散布，它还会生成具备不同手写格调的数字。

当初您曾经筹备好了训练数据，能够实现判断器和生成器模型。

实现判断器和生成器

本例中判断器是一个 MLP 神经网络，它接管一个 28 × 28 像素的图像，并提供图像属于实在训练数据的概率。

您能够应用以下代码定义模型：

class Discriminator(nn.Module):
    def __init__(self):
     
     

    def forward(self, x):
      
      
        return output

为了将图像系数输出到 MLP 神经网络中，能够将它们进行向量化)，使得神经网络接管具备 784 个系数的向量。

矢量化产生在 .forward() 的第一行，因为调用 x.view() 能够转换输出张量的形态。在这种状况下，输出 x 的原始形态是 32×1×28×28，其中 32 是您设置的批量大小。转换后，x的形态变为 32×784，每行示意训练集中图像的系数。

要应用 GPU 运行判断器模型，您必须实例化它并应用 .to() 将其发送到 GPU。要在有可用 GPU 时应用 GPU，能够将模型发送到先前创立的 device 对象：

discriminator = Discriminator().to(device=device)

因为生成器将生成更简单的数据，因而须要减少来自潜在空间的输出维数。在这种状况下，生成器将接管一个 100 维的输出，并提供一个由 784 个系数组成的输入，这些系数将以 28×28 的张量示意为图像。

上面是残缺的生成器模型代码：

 class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(

在第 12 行，应用双曲正切函数 Tanh() 作为输入层的激活函数，因为输入系数应该在 - 1 到 1 的区间内。在第 20 行，实例化生成器并将其发送到 device 以应用可用的 GPU。

当初您曾经定义了模型，能够应用训练数据对它们进行训练。

训练模型

要训练模型，须要定义训练参数和优化器，就像在之前的示例中所做的那样：

lr = 0.0001
num_epochs = 50
loss_function = nn.BCELoss()


optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

为了取得更好的后果，将学习率从先前的示例中升高。还将将 epoch 数设置为50，以缩小训练工夫。

训练循环与之前的示例十分类似。在突出显示的行中，将训练数据发送到 device 以在有 GPU 可用时应用：

for epoch in range(num_epochs):
    for n, (real_samples, mnist_labels) in enumerate(train_loader):
    
    e, 100)).to(device=device)

   
   
        loss_generator = loss_function(output_discriminator_generated, real_samples_labels)
        loss_generator.backward()
        optimizer_generator.step()

.: {loss_generator}")

某些张量不须要应用 device 显式地发送到 GPU。这实用于第 11 行中的 generated_samples，它将曾经被发送到可用 GPU，因为latent_space_samples 和generator先前已被发送到 GPU。

因为此示例具备更简单的模型，训练可能须要更长时间。训练实现后，您能够通过生成一些手写数字样本来查看后果。

查看 GAN 生成的样本

要生成手写数字，您须要从潜在空间中随机采样一些样本并将其提供给生成器：

latent_space_samples = torch.randn(batch_size, 100).to(device=device)

要绘制generated_samples，您须要将数据移回 GPU 上运行时，以便在应用 Matplotlib 绘制数据之前，能够简略地调用.cpu()。与之前一样，还须要在应用 Matplotlib 绘制数据之前调用.detach()：

generated_samples = generated_samples.cpu().detach()
for i in range(16):

输入应该是相似训练数据的数字，如以下图片所示：

通过 50 个 epoch 的训练后，生成了一些相似实在数字的生成数字。通过减少训练 epoch 次数，能够改善后果。

与之前的示例一样，通过在训练过程的每个周期完结时应用固定的潜在空间样本张量并将其提供给生成器，能够可视化训练的演变。

总结

您曾经学会了如何实现本人的生成反抗网络。在深入探讨生成手写数字图像的理论利用之前，您首先通过一个简略的示例理解了 GAN 的构造。

您看到，只管 GAN 的复杂性很高，但像 PyTorch 这样的机器学习框架通过提供主动微分和简便的 GPU 设置，使其实现更加简略直观。

在本文中，您学到了：

• 判断模型和生成模型的区别
• 如何结构化和训练生成反抗网络
• 如何应用 PyTorch 等工具和 GPU 来实现和训练 GAN 模型

GAN 是一个十分沉闷的研究课题，近年来提出了几个令人兴奋的利用。如果您对此主题感兴趣，请亲密关注技术和迷信文献，以获取新的利用想法。

最受欢迎的见解

1.R 语言实现 CNN（卷积神经网络）模型进行回归

2.r 语言实现拟合神经网络预测和后果可视化

3.python 用遗传算法 - 神经网络 - 含糊逻辑控制算法对乐透剖析

4.R 语言联合新冠疫情 COVID-19 股票价格预测：ARIMA，KNN 和神经网络工夫序列剖析

5.Python TensorFlow 循环神经网络 RNN-LSTM 神经网络预测股票市场价格工夫序列和 MSE 评估准确性

6.Matlab 用深度学习长短期记忆（LSTM）神经网络对文本数据进行分类

7. 用于 NLP 的 seq2seq 模型实例用 Keras 实现神经机器翻译

8. R 语言用 FNN-LSTM 假近邻长短期记忆人工神经网络模型进行工夫序列深度学习预测

9.Python 用 RNN 循环神经网络：LSTM 长期记忆、GRU 门循环单元、回归和 ARIMA 对 COVID-19 新冠疫情新增人数工夫序列预测