深度学习-11

qhqlnannan2024-09-29 18:16

线性层及其它层介绍

归一化层

在深度学习中，归一化层（Normalization Layers）是神经网络中非常重要的一部分，它们有助于在训练过程中稳定网络，加速收敛，以及提高模型的泛化能力。以下是PyTorch框架中一些常见的归一化层的简要介绍：

  • nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d：

    这些是批归一化层，分别应用于2D（实际上是一维数据的批处理，如全连接层的输出）、4D（如二维卷积层的输出，格式为[N, C, H,

    W]）和5D（如三维卷积层的输出，格式为[N, C, D, H, W]）输入。

    它们通过计算每个特征维度上的均值和方差，对输入数据进行归一化处理，并可以学习一个尺度和偏移参数来恢复数据的表达能力。

  • nn.LazyBatchNorm1d, nn.LazyBatchNorm2d, nn.LazyBatchNorm3d：

    这些是带有懒初始化功能的批归一化层。懒初始化意味着在第一次前向传播时才初始化参数，这有助于在动态形状或模型架构变化时灵活处理。

  • nn.GroupNorm：

    组归一化层，它将通道分成小组，并在每个小组内进行归一化。这种方法不依赖于批大小，因此在小批量训练时也能有效。

    nn.SyncBatchNorm：

  • 同步批归一化层，用于分布式训练。它确保在多个GPU上计算的均值和方差是同步的，这对于大规模训练非常重要。

    nn.InstanceNorm1d, nn.InstanceNorm2d, nn.InstanceNorm3d：

  • 实例归一化层，对每个样本独立进行归一化处理，主要用于风格迁移等任务中。

  • nn.LazyInstanceNorm1d, nn.LazyInstanceNorm2d, nn.LazyInstanceNorm3d：

    带有懒初始化功能的实例归一化层。

  • nn.LayerNorm：

    层归一化层，它在单个样本的所有激活上计算均值和方差，主要用于Transformer等模型中。

  • nn.LocalResponseNorm：

    局部响应归一化层，用于模拟生物神经元之间的侧抑制现象，主要在早期的深度学习模型中使用（如AlexNet）。

  • nn.RMSNorm：

    根均方层归一化层，是LayerNorm的一种变体，主要用于Transformer模型中，特别是在一些NLP任务中表现良好。

这些归一化层各有特点，适用于不同的模型架构和任务。正确选择和使用归一化层可以显著提高模型的性能和训练稳定性。

采用归一化可以有效的提升神经网络的速度，归一化也叫做正则化

您所描述的是**批量归一化（Batch Normalization）**的一种变体，特别是在深度神经网络训练中的应用，以减少内部协变量偏移（Internal Covariate Shift）。这种方法通过规范化层的输入来加速训练过程，提高模型的稳定性和性能。

批量归一化的核心公式：

给定输入 $ x $，批量归一化按照以下方式进行变换：

y = x − E [ x ] V a r [ x ] + ϵ γ + β y = \frac{x - E[x]}{\sqrt{Var[x] + \epsilon}} \gamma + \beta y=Var[x]+ϵ x−E[x]γ+β

其中：

  • $ E[x] $ 和 $ Var[x] $ 分别是输入 $ x $ 的均值和方差，它们在每个小批量数据中按维度计算。
  • $ \epsilon $ 是一个小常数，用于防止分母为零。
  • $ \gamma $ 和 $ \beta $ 是可学习的参数向量，大小等于输入的特征数 $ C 。默认情况下， 。默认情况下， 。默认情况下， \gamma $ 设置为 1，$ \beta $ 设置为 0。
  • 在训练期间的前向传播中，标准差使用有偏估计计算（torch.var(input, unbiased=False)），但在移动平均中存储的标准差使用无偏估计计算（torch.var(input, unbiased=True)）。

运行统计量的更新：

在训练过程中，批量归一化层会保持其计算的均值和方差的运行估计，这些估计在评估期间用于归一化。运行估计的默认动量（momentum）为 0.1。更新规则如下：

x ^ new = ( 1 − momentum ) × x ^ + momentum × x t \hat{x}_{\text{new}} = (1 - \text{momentum}) \times \hat{x} + \text{momentum} \times x_t x^new=(1−momentum)×x^+momentum×xt

其中 $ \hat{x} $ 是估计的统计量，$ x_t $ 是新观察到的值。

注意事项：

  • 如果 track_running_stats 设置为 False，则此层不会保持运行估计，评估时也将使用批统计数据。
  • 提到的动量参数与优化器类中的动量不同，它是一个用于更新运行统计量的特定参数。

空间批量归一化：

由于批量归一化是在 $ C $ 维度上进行的，对 (N, H, W) 切片计算统计量，因此通常称之为空间批量归一化（Spatial Batch Normalization）。

总结：

批量归一化通过减少层输入的内部协变量偏移，有助于深度神经网络的快速稳定训练。它通过规范化输入，并使用可学习的参数进行缩放和平移，以适应数据的特定分布。此外，通过在训练期间维护运行统计量，批量归一化确保了在评估期间模型性能的稳定。

循环层

在深度学习的PyTorch框架中，循环层（Recurrent Layers）是用于处理序列数据的一系列神经网络模块。这些模块都基于nn.RNNBase这个基类，并各自实现了不同的循环神经网络架构。以下是对这些模块的详细解释：

  1. nn.RNNBase:

    • 这是所有RNN模块（包括RNN、LSTM、GRU等）的基类。它定义了一些共同的接口和属性，使得这些RNN模块在结构上保持一致。

  2. nn.RNN:

    • 这是一个多层Elman RNN的实现。Elman RNN是一种基本的循环神经网络，它在每个时间步都将前一个时间步的输出作为当前时间步的输入。nn.RNN可以使用tanh或ReLU作为激活函数来增加网络的非线性。

  3. nn.LSTM:

    • 这是一个多层长短期记忆（LSTM）RNN的实现。LSTM是一种特殊的RNN，设计用来解决长期依赖问题。它通过引入记忆细胞和三个门（输入门、遗忘门、输出门）来实现信息的长期存储和传递。

  4. nn.GRU:

    • 这是一个多层门控循环单元（GRU）RNN的实现。GRU是LSTM的一个简化版本，它只有两个门（重置门和更新门），但同样能够有效地处理长期依赖问题。GRU在计算效率和性能之间通常提供了一个良好的平衡点。

  5. nn.RNNCell:

    • 这是一个单层Elman RNN单元的实现。与nn.RNN不同，nn.RNNCell只处理单个时间步的输入和输出，而不是整个序列。这使得它更适合于需要逐个时间步处理数据的场景。

  6. nn.LSTMCell:

    • 这是一个单层LSTM单元的实现。与nn.LSTM类似，但它只处理单个时间步的输入和输出。nn.LSTMCell可以用于构建自定义的LSTM网络，或者在不需要整个序列处理的情况下使用。

  7. nn.GRUCell:

    • 这是一个单层GRU单元的实现。与nn.GRU类似，但它同样只处理单个时间步的输入和输出。nn.GRUCell可以用于构建自定义的GRU网络，或者在其他需要逐个时间步处理的场景中使用。

这些RNN模块在PyTorch中提供了强大的序列处理能力，使得开发者能够轻松地构建和训练各种循环神经网络模型。无论是处理自然语言文本、时间序列数据还是其他类型的序列数据，这些RNN模块都能够提供有效的解决方案。

Transformer层

在PyTorch框架中，Transformer Layers提供了一系列用于构建Transformer模型的组件。以下是这些组件的详细解释：

nn.Transformer

  • 定义：这是一个完整的Transformer模型，包含了编码器(Encoder)和解码器(Decoder)。这个类提供了将整个模型作为一个单一组件使用的接口。
  • 用途：适用于诸如机器翻译等任务，这些任务需要同时考虑输入和输出序列。

nn.TransformerEncoder

  • 定义：这是Transformer模型中编码器的部分，由N个nn.TransformerEncoderLayer层堆叠而成。编码器负责处理输入序列。
  • 用途：适用于只需要Transformer的编码部分的任务，如文本分类或特征提取任务。它比完整的Transformer模型更为简单和高效，因为它不涉及序列到序列的生成。

nn.TransformerDecoder

  • 定义：这是Transformer模型中解码器的部分，由N个nn.TransformerDecoderLayer层堆叠而成。解码器负责根据编码器的输出和之前的解码器输出生成目标序列。
  • 用途：适用于需要解码器生成输出序列的任务，如机器翻译。

nn.TransformerEncoderLayer

  • 定义：这是Transformer编码器的单个层，由自注意力(self-attention)机制和前馈网络(feedforward network)组成。编码器的每个层都会对输入数据进行自注意力计算，并通过前馈网络进行进一步的处理。
  • 内部结构 ：
    • 自注意力机制：使模型能够关注输入序列的不同部分。
    • 前馈神经网络：用于增强模型的表示能力。
    • 可能还包含层归一化(Layer Normalization)和残差连接(Residual Connection)，有助于模型的训练稳定性和性能提升。
  • 用途：作为构建Transformer编码器的基本单元，可以自定义编码器的内部结构。

nn.TransformerDecoderLayer

  • 定义：这是Transformer解码器的单个层，包含了自注意力、多头注意力(multi-head attention)机制和前馈网络。在这个层中，自注意力部分处理解码器的输入，多头注意力部分利用编码器的输出来增强解码器的预测能力。
  • 内部结构 ：
    • 自注意力机制：处理解码器的输入。
    • 多头注意力机制：利用编码器的输出来增强解码器的预测能力。
    • 前馈神经网络：进一步处理输入。
    • 同样可能包含层归一化和残差连接。
  • 用途：作为构建Transformer解码器的基本单元，可以自定义解码器的内部结构。

总的来说，Transformer Layers在PyTorch中提供了一系列灵活且强大的组件，用于构建和训练Transformer模型，这些模型在自然语言处理和其他序列到序列的任务中表现出了卓越的性能。

线性层

在PyTorch框架中，Linear Layers提供了一系列用于实现线性变换的神经网络层。以下是这些层的详细解释：

nn.Identity

  • 定义：这是一个占位符身份操作符，它对输入数据不进行任何变换，直接输出相同的数据。
  • 用途：通常用于构建复杂的神经网络结构时，作为不改变数据流的占位符使用。

nn.Linear

  • 定义：这是一个全连接层（也称为线性层或仿射变换），它对输入数据进行线性变换，输出结果为y = xA^T + b，其中x是输入数据，A是权重矩阵，b是偏置向量。
  • 参数 ：
    • in_features：输入数据的特征维度。
    • out_features：输出数据的特征维度。
    • bias（可选）：是否包含偏置项，默认为True。
  • 用途：广泛用于各种神经网络结构中，实现特征空间的线性变换。

nn.Bilinear

  • 定义：这是一个双线性变换层，它对两个输入数据进行双线性变换，输出结果为y = x1^T A x2 + b，其中x1和x2是输入数据，A是权重矩阵，b是偏置向量。
  • 参数 ：
    • in1_features：第一个输入数据的特征维度。
    • in2_features：第二个输入数据的特征维度。
    • out_features：输出数据的特征维度。
    • bias（可选）：是否包含偏置项，默认为True。
  • 用途：通常用于需要处理两个输入数据相互作用的场景，如某些类型的注意力机制或相似度计算。

nn.LazyLinear

  • 定义 ：这是一个与nn.Linear类似的线性层，但它的in_features参数是推断出来的，而不是在初始化时明确指定的。
  • 用途 ：当输入数据的特征维度在初始化时未知或动态变化时，可以使用nn.LazyLinear来自动推断in_features。这在处理动态形状的数据或构建灵活的神经网络结构时非常有用。

总的来说，Linear Layers在PyTorch中提供了一系列用于实现线性变换的神经网络层，这些层在构建和训练神经网络模型时起到了至关重要的作用。

在PyTorch中，torch.nn.Linear是一个实现仿射线性变换（也称为全连接层或线性层）的神经网络模块。以下是对该模块的详细解释：

torch.nn.Linear

功能 ：

对输入数据进行线性变换，输出结果为 y = xA^T + b，其中 x 是输入数据，A 是权重矩阵，b 是偏置向量。

参数：

  • in_features (int)：输入数据的特征维度，即输入样本的大小。
  • out_features (int)：输出数据的特征维度，即输出样本的大小。
  • bias (bool, 可选)：是否包含偏置项。如果设置为 False，则该层不会学习偏置。默认值为 True。
  • device (torch.device, 可选)：指定模块中参数和缓冲区的设备（如 'cpu' 或 'cuda'）。如果未指定，则使用默认设备。
  • dtype (torch.dtype, 可选)：指定模块中参数和缓冲区的数据类型（如 torch.float32）。如果未指定，则使用默认数据类型。

形状：

  • 输入：(*, H_in)，其中 * 表示任意数量的维度（包括零维），H_in = in_features。
  • 输出：(*, H_out)，其中所有维度（除了最后一个维度）与输入相同，H_out = out_features。

变量：

  • weight (torch.Tensor)：模块的可学习权重，形状为 (out_features, in_features)。权重值从均匀分布 U(-k, k) 中初始化，其中 k = 1 / sqrt(in_features)。
  • bias (torch.Tensor)：模块的可学习偏置，形状为 (out_features)。如果 bias 为 True，则偏置值也从均匀分布 U(-k, k) 中初始化。

示例：

python 复制代码 
>>> m = nn.Linear(20, 30)  # 创建一个输入特征维度为20，输出特征维度为30的线性层
>>> input = torch.randn(128, 20)  # 创建一个形状为(128, 20)的输入张量
>>> output = m(input)  # 将输入张量传递给线性层
>>> print(output.size())  # 输出张量的形状为(128, 30)
torch.Size([128, 30])

在上面的示例中，我们首先创建了一个 nn.Linear 模块，指定了输入和输出特征维度。然后，我们创建了一个形状为 (128, 20) 的输入张量，并将其传递给线性层。最后，我们打印了输出张量的形状，它应该是 (128, 30)。

torch.nn.Linear 模块在神经网络中非常常用，特别是用于实现特征空间的线性变换、分类器的最后一层等。

Dropout层

在PyTorch框架中，Dropout Layers提供了一系列用于实现Dropout操作的神经网络层。Dropout是一种正则化技术，通过在训练过程中随机地将输入张量的一部分元素设置为零，来减少模型对训练数据的过拟合。以下是这些Dropout层的详细解释：

nn.Dropout

  • 功能：在训练过程中，以概率p随机地将输入张量的一部分元素设置为零。在评估（evaluation）模式下，该层会简单地传递输入数据，不会进行任何改变。
  • 参数 ：
    • p（float）：Dropout概率，即每个元素被设置为零的概率。默认值为0.5。如果概率P设置为1，则设置为0的概率是100%，主要是为了防止过拟合
    • inplace（bool，可选）：是否在原地修改输入数据。如果设置为True，则会在不分配新内存的情况下直接修改输入张量。默认值为False。

nn.Dropout1d、nn.Dropout2d、nn.Dropout3d

  • 功能：这些层分别针对一维、二维和三维输入数据实现Dropout操作。它们会随机地将整个通道（channel）设置为零，而不是单个元素。
  • 参数 ：
    • p（float）：Dropout概率。
    • inplace（bool，可选）：是否在原地修改输入数据。

nn.AlphaDropout

  • 功能：Alpha Dropout是一种特殊的Dropout变体，它通过对输入数据进行缩放来保持输入的均值和方差不变。在训练过程中，它以概率p随机地将输入张量的一部分元素设置为零，并将剩余元素按1/(1-p)进行缩放。
  • 参数 ：
    • p（float）：Dropout概率。
    • inplace（bool，可选）：是否在原地修改输入数据。

nn.FeatureAlphaDropout

  • 功能：类似于nn.AlphaDropout，但它是针对特征（或通道）进行Dropout操作，而不是单个元素。它会随机地将整个通道设置为零，并对剩余通道进行缩放。
  • 参数 ：
    • p（float）：Dropout概率。
    • inplace（bool，可选）：是否在原地修改输入数据。

Dropout层在神经网络训练中起到了防止过拟合的重要作用。通过随机地丢弃一部分输入数据，模型被迫学习更加鲁棒的特征表示，从而提高了在未见数据上的泛化能力。

在PyTorch中，torch.nn.Dropout是一个用于实现Dropout正则化技术的神经网络层。Dropout是一种在训练过程中随机地将输入张量的一部分元素设置为零的方法，这有助于防止模型对训练数据的过拟合。

torch.nn.Dropout

功能 ：

在训练期间，以概率p随机地将输入张量的部分元素设置为零。这些被置零的元素对于每次前向调用都是独立选择的，并且是从伯努利分布中采样的。每个通道（对于多维数据而言）都会在每次前向调用时独立地被置零。此外，在训练期间，输出会被一个因子 1 / (1 - p) 缩放，以确保在评估（evaluation）模式下，该层简单地计算一个恒等函数（即不改变输入数据）。

参数：

  • p (float)：元素被设置为零的概率。默认值为0.5。
  • inplace (bool)：如果设置为True，则将在原地修改输入数据，而不分配新的内存。默认值为False。

形状：

  • 输入：(*)，输入可以是任何形状。
  • 输出：(*)，输出与输入形状相同。

示例：

python 复制代码 
>>> m = nn.Dropout(p=0.2)  # 创建一个Dropout层，其中20%的元素将被置零
>>> input = torch.randn(20, 16)  # 创建一个形状为(20, 16)的输入张量
>>> output = m(input)  # 将输入张量传递给Dropout层

在上面的示例中，我们首先创建了一个nn.Dropout层，并指定了Dropout概率p为0.2。然后，我们创建了一个形状为(20, 16)的输入张量，并将其传递给Dropout层。在训练模式下，Dropout层会随机地将输入张量中约20%的元素设置为零，并将剩余元素按1 / (1 - 0.2)进行缩放。在评估模式下（例如使用model.eval()后），Dropout层将不会改变输入数据。

Dropout层在神经网络训练中非常有用，因为它可以迫使模型学习更加鲁棒的特征表示，从而提高在未见数据上的泛化能力。

Sparse Layers层

在PyTorch框架中，Sparse Layers提供了处理稀疏数据的神经网络层，特别是用于处理词汇嵌入（word embeddings）和词袋模型（bag-of-words models）的层。以下是两个主要的Sparse Layers的详细解释：

nn.Embedding

功能 ：
nn.Embedding是一个简单的查找表，它存储了一个固定字典和大小的嵌入。这个层通常用于自然语言处理（NLP）任务中，将离散的词汇索引映射到连续的向量空间中。

参数：

  • num_embeddings (int)：嵌入字典的大小，即词汇表的大小。
  • embedding_dim (int)：每个嵌入向量的维度。
  • padding_idx (int, 可选)：如果提供，这个索引对应的嵌入向量将被零填充（即该索引在查找表中对应的向量是全零的）。这对于处理变长输入序列非常有用，可以通过填充来确保所有序列具有相同的长度。
  • max_norm (float, 可选)：如果提供，嵌入向量的范数将被限制在这个值以内。这有助于防止嵌入向量在训练过程中变得过大。
  • norm_type (float, 可选)：指定用于计算范数的类型，默认为2范数（欧几里得范数）。
  • scale_grad_by_freq (bool, 可选)：如果设置为True，则会根据词汇在训练数据中出现的频率来缩放梯度。这有助于处理不平衡的词汇分布。
  • sparse (bool, 可选)：如果设置为True，则使用稀疏梯度更新（即只更新非零梯度的嵌入向量）。这可以提高大规模嵌入矩阵的训练效率。

形状：

  • 输入：(N, *)，其中N是批量大小，*表示任意数量的额外维度（通常是序列长度）。
  • 输出：(N, *, embedding_dim)，其中*表示与输入相同的额外维度，embedding_dim是嵌入向量的维度。

nn.EmbeddingBag

功能 ：
nn.EmbeddingBag用于计算词袋（bags of embeddings）的和或均值，而不需要实例化中间的嵌入矩阵。这个层通常用于处理文本数据，其中每个样本由一个词汇索引的列表（即词袋）表示。通过直接计算词袋的和或均值，nn.EmbeddingBag可以提高训练效率，特别是当词汇量很大且每个样本只包含少量不同词汇时。

参数：

  • num_embeddings (int)：嵌入字典的大小。
  • embedding_dim (int)：每个嵌入向量的维度。
  • max_norm (float, 可选)：同nn.Embedding。
  • norm_type (float, 可选)：同nn.Embedding。
  • scale_grad_by_freq (bool, 可选)：同nn.Embedding。
  • mode (str)：指定如何聚合词袋中的嵌入向量。可以是'sum'（求和）或'mean'（求均值）。
  • sparse (bool, 可选)：同nn.Embedding。
  • per_sample_weights (bool, 可选)：如果设置为True，则允许为每个样本提供权重，用于在计算和或均值时进行加权。
  • include_last_offset (bool, 可选)：如果设置为True，则在计算词袋的索引时包括最后一个偏移量。这通常用于处理变长序列的填充。

形状：

  • 输入：(N, L)，其中N是批量大小，L是每个样本中词汇索引的长度（可以是变长的，但需要使用填充或截断来确保所有样本具有相同的L）。如果include_last_offset为True，则L应包含填充值。
  • offsets（如果include_last_offset为True）：(N,)，表示每个样本在输入张量中的结束位置（即每个词袋的边界）。
  • 输出：(N, embedding_dim)，其中N是批量大小，embedding_dim是嵌入向量的维度。输出是每个样本的词袋和或均值的嵌入向量。

这两个层在NLP任务中非常有用，特别是当需要处理大量词汇和变长输入序列时。通过将这些层与其他神经网络层（如LSTM、GRU等）结合使用，可以构建出强大的文本处理模型。

线性层详细介绍

  • in_features (int)：输入数据的特征维度，即输入样本的大小。对应input layer
  • out_features (int)：输出数据的特征维度，即输出样本的大小。对应到hidden layer
  • bias (bool, 可选)：是否包含偏置项。如果设置为 False，则该层不会学习偏置。默认值为 True。Ture的时候加b，false的不加B
  • device (torch.device, 可选)：指定模块中参数和缓冲区的设备（如 'cpu' 或 'cuda'）。如果未指定，则使用默认设备。
  • dtype (torch.dtype, 可选)：指定模块中参数和缓冲区的数据类型（如 torch.float32）。如果未指定，则使用默认数据类型。

    变量：

weight (torch.Tensor)：形状为(out_features, in_features)的可学习权重矩阵。权重值从均匀分布U(-k, k)中初始化，其中k = 1 / sqrt(in_features)。

bias (torch.Tensor)：形状为(out_features)的可学习偏置向量（如果bias为True）。偏置值也从相同的均匀分布中初始化。

将一个5*5的图像展开为一行25个像元的数据，最后变换为3个数据

代码

python 复制代码 
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="./CIFAR",train=False,
                                         transform=torchvision.transforms.ToTensor(),
                                         download=True)
dataloader =DataLoader(dataset,batch_size=64)
class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.linear1 = Linear(196608,10)
    def forward(self,input):
        output = self.linear1(input)
        return output

test = Test()

for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    output = torch.reshape(imgs,(1,1,1,-1))
    
    print(output.shape)
    output1 = test(output)
    print(output1.shape)

结果为

python 复制代码 
C:\Anaconda3\envs\pytorch_test\python.exe H:\Python\Test\nn_linear.py 
Files already downloaded and verified
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([64, 3, 32, 32])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([16, 3, 32, 32])
torch.Size([1, 1, 1, 49152])

Flattens函数介绍

torch.nn.Flatten 是一个在 PyTorch 中用于将张量的一个连续范围维度展平的操作。这个操作通常用于神经网络中，以将多维数据（如图像）展平为一维数据，从而可以输入到全连接层（线性层）中。

参数说明

  • start_dim (int): 开始展平的维度，默认值为1。
  • end_dim (int): 结束展平的维度，默认值为-1（表示到最后一个维度）。

形状变换

  • 输入形状 : ( ∗ , S s t a r t , . . . , S i , . . . , S e n d , ∗ ) (*, S_{start}, ..., S_i, ..., S_{end}, *) (∗,Sstart,...,Si,...,Send,∗)，其中 S i S_i Si 是维度 i i i 的大小， ∗ * ∗ 表示任意数量的维度，包括没有。
  • 输出形状 : ( ∗ , ∏ i = s t a r t e n d S i , ∗ ) (*, \prod_{i=start}^{end} S_i, *) (∗,∏i=startendSi,∗)，即将从 start_dim 到 end_dim 的所有维度展平为一个维度，其大小是这些维度大小的乘积。

示例

  1. 使用默认参数：

    python 复制代码 
    import torch
import torch.nn as nn

input = torch.randn(32, 1, 5, 5)  # 输入形状: (32, 1, 5, 5)
m = nn.Flatten()  # 默认 start_dim=1, end_dim=-1
output = m(input)
print(output.size())  # 输出形状: (32, 25)

    在这个例子中，从第二个维度（索引为1）开始到最后一个维度都被展平了，结果是一个形状为 (32, 25) 的张量，其中 25 是 155 的结果。

  2. 使用非默认参数：

    python 复制代码 
    input = torch.randn(32, 1, 5, 5)  # 输入形状: (32, 1, 5, 5)
m = nn.Flatten(0, 2)  # 从第一个维度到第三个维度展平
output = m(input)
print(output.size())  # 输出形状: (160, 5)

    在这个例子中，从第一个维度（索引为0）到第三个维度（索引为2）被展平，结果是一个形状为 (160, 5) 的张量，其中 160 是 3215 的结果。

通过使用 torch.nn.Flatten，你可以灵活地调整你的数据形状，以适应神经网络中不同层的需求。

代码块：

python 复制代码 
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="./CIFAR",train=False,
                                         transform=torchvision.transforms.ToTensor(),
                                         download=True)
dataloader =DataLoader(dataset,batch_size=64)
class Test(nn.Module):
    def __init__(self):
        super(Test,self).__init__()
        self.linear1 = Linear(196608,10)
    def forward(self,input):
        output = self.linear1(input)
        return output

test = Test()

for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    # output = torch.reshape(imgs,(1,1,1,-1))
    output = torch.flatten(imgs)
    print(output.shape)
    output1 = test(output)
    print(output1.shape)

结果是：

python 复制代码 
C:\Anaconda3\envs\pytorch_test\python.exe H:\Python\Test\nn_linear.py 
Files already downloaded and verified
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([16, 3, 32, 32])
torch.Size([49152])
相关推荐
泰迪智能科技011 小时前
高校深度学习视觉应用平台产品介绍
人工智能·深度学习
盛派网络小助手2 小时前
微信 SDK 更新 Sample，NCF 文档和模板更新，更多更新日志，欢迎解锁
开发语言·人工智能·后端·架构·c#
Eric.Lee20212 小时前
Paddle OCR 中英文检测识别 - python 实现
人工智能·opencv·计算机视觉·ocr检测
cd_farsight2 小时前
nlp初学者怎么入门？需要学习哪些？
人工智能·自然语言处理
AI明说2 小时前
评估大语言模型在药物基因组学问答任务中的表现：PGxQA
人工智能·语言模型·自然语言处理·数智药师·数智药学
Focus_Liu2 小时前
NLP-UIE(Universal Information Extraction)
人工智能·自然语言处理
PowerBI学谦3 小时前
使用copilot轻松将电子邮件转为高效会议
人工智能·copilot
audyxiao0013 小时前
AI一周重要会议和活动概览
人工智能·计算机视觉·数据挖掘·多模态
Jeremy_lf3 小时前
【生成模型之三】ControlNet & Latent Diffusion Models论文详解
人工智能·深度学习·stable diffusion·aigc·扩散模型
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍