MLP Mixer pytorch实现 《MLP-Mixer: An all-MLP Architecture for Vision》

最新推荐文章于 2023-04-22 00:20:03 发布
最新推荐文章于 2023-04-22 00:20:03 发布
阅读量659 收藏 17
点赞数 3
文章标签： python 神经网络 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CooperLuo32/article/details/119635427
版权

谷歌团队最新的文章《MLP-Mixer: An all-MLP Architecture for Vision》提出了一个无需卷积CNN，无需attention的多层感知机网络。文章试图证明Neither of them are necessary.
由于网络并不复杂，尝试了自己搭建了一下模型。

1.模型的规格参照paper中的Table 1，各种形参名称都是对应该表。
Specifications of the Mixer architecture used in this paper
2. 模型的整体框架如下图，其中搭建的时候分割成三部分：
两个全连接的mlp-block，
token-mixing和channel-mixing的Mixer Layer
图片分割和Global average pooling 以及分类头
模型整体结构
代码块如下，还是比较清晰明了的

import torch
import torch.nn as nn
from torchsummary import summary


# 这个是两层FC加一个激活函数的mlp block
# 因为有两个mixing,进出的维度都不变，只是中间全连接层的神经元数量不同
class mlp_block(nn.Module):
    def __init__(self, in_channels, mlp_dim, drop_ratio=0.):
        super().__init__()
        self.block = nn.Sequential(
            nn.Linear(in_channels, mlp_dim),
            nn.GELU(),
            nn.Dropout(drop_ratio),
            nn.Linear(mlp_dim, in_channels),
            nn.Dropout(drop_ratio)
        )

    def forward(self, x):
        x = self.block(x)
        return x


class mlp_layer(nn.Module):
    def __init__(self, seq_length_s, hidden_size_c, mlp_dimension_dc, mlp_dimension_ds):
        super().__init__()
        self.ln = nn.LayerNorm(hidden_size_c)
        # 注意两个block分别作用于输入的行和列， 即SXC，所以in_channels不一样
        self.token_mixing = mlp_block(in_channels=seq_length_s, mlp_dim=mlp_dimension_dc)
        self.channel_mixing = mlp_block(in_channels=hidden_size_c, mlp_dim=mlp_dimension_ds)

    def forward(self, x):
        x1 = self.ln(x)
        x2 = x1.transpose(1, 2)  # 转置矩阵
        x3 = self.token_mixing(x2)
        x4 = x3.transpose(1, 2)

        y1 = x + x4  # skip-connection
        y2 = self.ln(y1)
        y3 = self.channel_mixing(y2)
        y = y1 + y3

        return y


# 按照paper中的 Table 1 来配置参数
class mlp_mixer(nn.Module):
    def __init__(self,
                 num_classes=1000,
                 img_size=224,
                 in_channels=3,
                 layer_num=12,
                 patch_size=32,
                 hidden_size_c=768,
                 seq_length_s=49,
                 mlp_dimension_dc=3072,
                 mlp_dimension_ds=384,
                 ):
        super().__init__()
        self.num_classes = num_classes
        self.img_size = img_size
        self.in_channels = in_channels
        self.patch_size = patch_size
        self.layer_num = layer_num
        self.hidden_size_c = hidden_size_c
        self.seq_length_s = seq_length_s
        self.mlp_dimension_dc = mlp_dimension_dc
        self.mlp_dimension_ds = mlp_dimension_ds

        self.ln = nn.LayerNorm(self.hidden_size_c)

        # 图片切割并做映射embedding，通过一个卷积实现
        self.proj = nn.Conv2d(self.in_channels, self.hidden_size_c, kernel_size=self.patch_size, stride=self.patch_size)

        # 添加多个mixer-layer
        self.mixer_layer = nn.ModuleList([])
        for _ in range(self.layer_num):
            self.mixer_layer.append(mlp_layer(seq_length_s, hidden_size_c, mlp_dimension_ds, mlp_dimension_dc))

        # 最后全连接的分类头
        self.linear_classifier_head = nn.Linear(hidden_size_c, num_classes)

# 定义正向传播过程
    def forward(self, x):
        B, C, H, W = x.shape
        assert H == self.img_size and W == self.img_size, \
            f"Input image size ({H}*{W}) doesn't match model ({self.img_size}*{self.img_size})."

        # flatten: [B, C, H, W] -> [B, C, HW]  # 第二个维度上展平 刚好是高度维度
        # transpose: [B, C, HW] -> [B, HW, C]
        x = self.proj(x).flatten(2).transpose(1, 2)
        for mixer_layer in self.mixer_layer:
            x = mixer_layer(x)
        x = self.ln(x)
        x = x.mean(dim=1)  # Global average pooling
        x = self.linear_classifier_head(x)
        return x

# 参数初始化
def _init_mlp_mixer_weights(m):
    """
    MLP Mixer weight initialization
    :param m: module
    """
    if isinstance(m, nn.Linear):
        nn.init.trunc_normal_(m.weight, std=.01)
        if m.bias is not None:
            nn.init.zeros_(m.bias)
    elif isinstance(m, nn.Conv2d):
        nn.init.kaiming_normal_(m.weight, mode="fan_out")
        if m.bias is not None:
            nn.init.zeros_(m.bias)
    elif isinstance(m, nn.LayerNorm):
        nn.init.zeros_(m.bias)
        nn.init.ones_(m.weight)


 # 不同配置
def mlp_mixer_s_32(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=8,
                      patch_size=32,
                      hidden_size_c=512,
                      seq_length_s=49,
                      mlp_dimension_dc=2048,
                      mlp_dimension_ds=3256)
    return model


def mlp_mixer_s_16(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=8,
                      patch_size=16,
                      hidden_size_c=512,
                      seq_length_s=196,
                      mlp_dimension_dc=2048,
                      mlp_dimension_ds=256,

                      )
    return model


def mlp_mixer_b_32(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=12,
                      patch_size=32,
                      hidden_size_c=768,
                      seq_length_s=49,
                      mlp_dimension_dc=3072,
                      mlp_dimension_ds=384,

                      )
    return model


def mlp_mixer_b_16(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=12,
                      patch_size=16,
                      hidden_size_c=768,
                      seq_length_s=196,
                      mlp_dimension_dc=3072,
                      mlp_dimension_ds=384,

                      )
    return model


def mlp_mixer_l_32(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=24,
                      patch_size=32,
                      hidden_size_c=1024,
                      seq_length_s=49,
                      mlp_dimension_dc=4096,
                      mlp_dimension_ds=512,

                      )
    return model


def mlp_mixer_l_16(num_classes: int = 1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=24,
                      patch_size=16,
                      hidden_size_c=1024,
                      seq_length_s=196,
                      mlp_dimension_dc=4096,
                      mlp_dimension_ds=512,

                      )
    return model


def mlp_mixer_h_14(num_classes=1000):
    model = mlp_mixer(num_classes=num_classes,
                      img_size=224,
                      in_channels=3,
                      layer_num=32,
                      patch_size=14,
                      hidden_size_c=1280,
                      seq_length_s=256,
                      mlp_dimension_dc=5120,
                      mlp_dimension_ds=640,

                      )
    return model


# 测试用
if __name__ == '__main__':
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = mlp_mixer_s_16(num_classes=1000).to(device)
    summary(model, (3, 224, 224))

使用S/16 测试网络框架以及参数量结果如下，和paper中一致，模型搭建正确。

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1          [-1, 512, 14, 14]         393,728
         LayerNorm-2             [-1, 196, 512]           1,024
            Linear-3             [-1, 512, 256]          50,432
              GELU-4             [-1, 512, 256]               0
           Dropout-5             [-1, 512, 256]               0
            Linear-6             [-1, 512, 196]          50,372
           Dropout-7             [-1, 512, 196]               0
         mlp_block-8             [-1, 512, 196]               0
         LayerNorm-9             [-1, 196, 512]           1,024
           Linear-10            [-1, 196, 2048]       1,050,624
             GELU-11            [-1, 196, 2048]               0
          Dropout-12            [-1, 196, 2048]               0
           Linear-13             [-1, 196, 512]       1,049,088
          Dropout-14             [-1, 196, 512]               0
        mlp_block-15             [-1, 196, 512]               0
        mlp_layer-16             [-1, 196, 512]               0
        LayerNorm-17             [-1, 196, 512]           1,024
           Linear-18             [-1, 512, 256]          50,432
             GELU-19             [-1, 512, 256]               0
          Dropout-20             [-1, 512, 256]               0
           Linear-21             [-1, 512, 196]          50,372
          Dropout-22             [-1, 512, 196]               0
        mlp_block-23             [-1, 512, 196]               0
        LayerNorm-24             [-1, 196, 512]           1,024
           Linear-25            [-1, 196, 2048]       1,050,624
             GELU-26            [-1, 196, 2048]               0
          Dropout-27            [-1, 196, 2048]               0
           Linear-28             [-1, 196, 512]       1,049,088
          Dropout-29             [-1, 196, 512]               0
        mlp_block-30             [-1, 196, 512]               0
        mlp_layer-31             [-1, 196, 512]               0
        LayerNorm-32             [-1, 196, 512]           1,024
           Linear-33             [-1, 512, 256]          50,432
             GELU-34             [-1, 512, 256]               0
          Dropout-35             [-1, 512, 256]               0
           Linear-36             [-1, 512, 196]          50,372
          Dropout-37             [-1, 512, 196]               0
        mlp_block-38             [-1, 512, 196]               0
        LayerNorm-39             [-1, 196, 512]           1,024
           Linear-40            [-1, 196, 2048]       1,050,624
             GELU-41            [-1, 196, 2048]               0
          Dropout-42            [-1, 196, 2048]               0
           Linear-43             [-1, 196, 512]       1,049,088
          Dropout-44             [-1, 196, 512]               0
        mlp_block-45             [-1, 196, 512]               0
        mlp_layer-46             [-1, 196, 512]               0
        LayerNorm-47             [-1, 196, 512]           1,024
           Linear-48             [-1, 512, 256]          50,432
             GELU-49             [-1, 512, 256]               0
          Dropout-50             [-1, 512, 256]               0
           Linear-51             [-1, 512, 196]          50,372
          Dropout-52             [-1, 512, 196]               0
        mlp_block-53             [-1, 512, 196]               0
        LayerNorm-54             [-1, 196, 512]           1,024
           Linear-55            [-1, 196, 2048]       1,050,624
             GELU-56            [-1, 196, 2048]               0
          Dropout-57            [-1, 196, 2048]               0
           Linear-58             [-1, 196, 512]       1,049,088
          Dropout-59             [-1, 196, 512]               0
        mlp_block-60             [-1, 196, 512]               0
        mlp_layer-61             [-1, 196, 512]               0
        LayerNorm-62             [-1, 196, 512]           1,024
           Linear-63             [-1, 512, 256]          50,432
             GELU-64             [-1, 512, 256]               0
          Dropout-65             [-1, 512, 256]               0
           Linear-66             [-1, 512, 196]          50,372
          Dropout-67             [-1, 512, 196]               0
        mlp_block-68             [-1, 512, 196]               0
        LayerNorm-69             [-1, 196, 512]           1,024
           Linear-70            [-1, 196, 2048]       1,050,624
             GELU-71            [-1, 196, 2048]               0
          Dropout-72            [-1, 196, 2048]               0
           Linear-73             [-1, 196, 512]       1,049,088
          Dropout-74             [-1, 196, 512]               0
        mlp_block-75             [-1, 196, 512]               0
        mlp_layer-76             [-1, 196, 512]               0
        LayerNorm-77             [-1, 196, 512]           1,024
           Linear-78             [-1, 512, 256]          50,432
             GELU-79             [-1, 512, 256]               0
          Dropout-80             [-1, 512, 256]               0
           Linear-81             [-1, 512, 196]          50,372
          Dropout-82             [-1, 512, 196]               0
        mlp_block-83             [-1, 512, 196]               0
        LayerNorm-84             [-1, 196, 512]           1,024
           Linear-85            [-1, 196, 2048]       1,050,624
             GELU-86            [-1, 196, 2048]               0
          Dropout-87            [-1, 196, 2048]               0
           Linear-88             [-1, 196, 512]       1,049,088
          Dropout-89             [-1, 196, 512]               0
        mlp_block-90             [-1, 196, 512]               0
        mlp_layer-91             [-1, 196, 512]               0
        LayerNorm-92             [-1, 196, 512]           1,024
           Linear-93             [-1, 512, 256]          50,432
             GELU-94             [-1, 512, 256]               0
          Dropout-95             [-1, 512, 256]               0
           Linear-96             [-1, 512, 196]          50,372
          Dropout-97             [-1, 512, 196]               0
        mlp_block-98             [-1, 512, 196]               0
        LayerNorm-99             [-1, 196, 512]           1,024
          Linear-100            [-1, 196, 2048]       1,050,624
            GELU-101            [-1, 196, 2048]               0
         Dropout-102            [-1, 196, 2048]               0
          Linear-103             [-1, 196, 512]       1,049,088
         Dropout-104             [-1, 196, 512]               0
       mlp_block-105             [-1, 196, 512]               0
       mlp_layer-106             [-1, 196, 512]               0
       LayerNorm-107             [-1, 196, 512]           1,024
          Linear-108             [-1, 512, 256]          50,432
            GELU-109             [-1, 512, 256]               0
         Dropout-110             [-1, 512, 256]               0
          Linear-111             [-1, 512, 196]          50,372
         Dropout-112             [-1, 512, 196]               0
       mlp_block-113             [-1, 512, 196]               0
       LayerNorm-114             [-1, 196, 512]           1,024
          Linear-115            [-1, 196, 2048]       1,050,624
            GELU-116            [-1, 196, 2048]               0
         Dropout-117            [-1, 196, 2048]               0
          Linear-118             [-1, 196, 512]       1,049,088
         Dropout-119             [-1, 196, 512]               0
       mlp_block-120             [-1, 196, 512]               0
       mlp_layer-121             [-1, 196, 512]               0
       LayerNorm-122             [-1, 196, 512]           1,024
          Linear-123                 [-1, 1000]         513,000
================================================================
Total params: 18,528,264
Trainable params: 18,528,264
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 154.16
Params size (MB): 70.68
Estimated Total Size (MB): 225.42
----------------------------------------------------------------

Process finished with exit code 0
CooperLuo
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
浅谈 Mlp-Mixer（pytorch and keras）
__不想写代码__的博客
07-11 3723
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
Google的MLP-MIXer的复现（pytorch实现）
最新发布
qq_45689158的博客
05-23 538
2.在处理两个差异的时候，如输入维度[32,196,512],其中代表的意思分别为batch_size为32，196为图片在经过patch之后的224*224输入之后经过patch=16，变为14 * 14即196，512会在二维卷积处理之后输出的channel类似。在nn.linear那儿的in_channel与第三个维度保持一致，就可以不必将其三维的转换为二维的。在将flax框架的代码改为pytorch实现的时候，还是踩了不少的坑，在此讲一下，希望后面做的人，可以避免。
MLP-Mixer的Pytorch实现和分析（一）
HHzdh的博客
10-16 2526
MLP-Mixer网络结构分析：MLP-Mixer: An all-MLP Architecture for Vision_HHzdh的博客-CSDN博客 Mixer的Pytorch代码实现的难点在于矩阵旋转，我们使用einops中的Rearrange实现矩阵旋转，同时使用torchsummary和tensorboardX来查看网络结构。 ​ 1、导入相关库 import torch import torch.nn as nn from torchsumma...
MLP-Mixer的Pytorch实现和分析（二）
HHzdh的博客
10-16 922
model = MLPMixer(in_channels=3, dim=512, num_classes=1000, patch_size=16, image_size=224, depth=1, token_dim=256, channel_dim=2048).to(device) summary(model,(3,224,224)) 首先参数意义如下（输入图片为3*224*224）： in_channels：输入图片的通道数，3。 dim：卷积操.
《MLP-Mixer: An all-MLP Architecture for Vision》2021
u010087277的博客
05-11 1620
摘要：卷积网络CNN是计算机视觉中的必用模型。最近，基于注意力机制的网络结构，比如视觉Transformer，也越来越流行。在这篇文章中我们将展示，虽然卷积和注意力机制是获得优良性能的必要结构，但它们都不是必须的。我们提出MLP-Mixer，一个仅仅基于多层感知机(MLPs)的结构。MLP-Mixer包含两种类型的网络层：一种是独立应用于图像patch的多层感知机MLPs(比如 "混合"每个局部特征)。另一个是应用于交叉patches的多层感知机（比如 “混合”空间信息）。当MLP-Mixer在大的数据集上
MLP-Mixer [代码实现（基于MNIST）]
昔风不起，唯有努力生存！
05-24 2517
本文基于lucidrains在gitHub上开源的mlp-mixer-pytorch实现mlp-mixer在MNIST数据上的demo。 MLP-Mixer: An all-MLP Architecture for Vision[PDF] MLP-Mixer简介和一些想法 [CSDN博客] 新坑来了！谷歌提出MLP-Mixer：一种用于视觉的全MLP架构[CSDN博客] lucidrains/mlp-mixer-pytorch [pytorch 实现] lucidrains/mlp-mixer-py.
mlp-mixer-pytorch-main.zip
09-29
**标题解析：** "mlp-mixer-pytorch-main.zip" 这个文件名暗示了这是一个与多层感知机（MLP）相关的项目，且它使用PyTorch框架实现。"main"通常指的是项目的主体部分，暗示我们可能将找到一个核心的MLP模型实现。 *...
Federated-Learning-PyTorch:实施基于分散数据的深度网络通信高效学习
05-06
联合学习（PyTorch） 香草联合学习论文的实施：。 在MNIST，Fashion MNIST和CIFAR10（IID和非IID）上进行了实验。 在非IID的情况下，用户之间的数据可以相等或不相等地分割。 由于这些实验的目的是说明联合学习范例...
Mnist-MLP:使用Mnist数据的多层感知器
05-09
**压缩包子文件的文件名称列表：** "Mnist-MLP-master" 通常表示这是一个项目仓库的主分支，很可能包含了项目的源代码、数据、README文件等资源，用户可以下载并按照指导运行和理解项目。 **详细知识点：** 1. **...
point-transformer-pytorch:Pytorch中Point Transformer层的实现
04-12
点变压器-火炬在Pytorch中实现自注意层。 上面的简单电路似乎允许他们的小组在点云分类和分割方面胜过所有以前的方法。安装$ pip install point-transformer-pytorch用法import torchfrom point_transformer_pytorch...
关于Pytorch的MLP模块实现方式
09-18
今天小编就为大家分享一篇关于Pytorch的MLP模块实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
mlp.zip_MLP_MLP-Map
09-24
**标题解析：** "mlp.zip_MLP_MLP-Map" 这个标题暗示了压缩文件包含与多层感知器（MLP, Multi-Layer Perceptron）相关的材料，特别是与MLP-Map有关的内容。MLP是人工神经网络的一种基本类型，常用于监督学习中的分类...
dejahu的深度学习学习笔记03-感知机和MLP|Pytorch代码实现
dejahu的博客
07-07 430
前面的笔记中我们讨论了线性回归和softmax分类，都可以看作是一层的全连接层，其中线性回归的输出是一个神经元，softmax的输出是多个神经元，softmax主要作用在损失函数的计算部分，相应地模型也需要学习到更多的权重。今天我们来看一下感知机（perceptron）以及感知机的进化版本，多层感知机(MLP)。 开始之前给大家安利一下我之前写的使用tensorflow2构建物体分类模型的博客，我在博客中详细介绍了数据集收集、模型构建和模型使用三个方面，结合视频你也可以快速构建自己的物体分类模型，快去试试吧
MLP4Rec：用于序列推荐的纯MLP架构
EzrealWithPyDream的博客
02-17 606
论文阅读笔记
MLP-Mixer论文与代码阅读
qq_42208244的博客
09-23 628
没有采用convolution以及attention的网络结构，纯粹使用MLP作为主要架构。
【PyTorch】MLP回归模型预测波士顿房价
weixin_39274067的博客
12-14 7027
import numpy as np import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.metrics import mean_squared_error,mean_absolute_error from sklearn.model_selection import train_test_split from sklearn.datasets import fetch_california_ho
Pytorch深度学习笔记（六）用pytorch实现线性回归
qq_45981086的博客
04-22 756
torch.optim.SGD(params, lr=required, momentum=0, dampening=0,weight_decay=0, nesterov=False),params参数，lr学习率。torch.nn.Linear(in_features,out_features,bias=True),in_features,out_features为输入样本和输出样本的数量。，如图，线性模型的x，y都是3*1的向量张量。
动手学深度学习--softmax回归和MLP的pytorch实现
iwill323的博客
09-20 1074
softmax和MLP的pytorch实现
mlp-mixer: an all-mlp architecture for vision
06-28
mlp-mixer是一种全MLP架构，用于视觉任务。它使用多层感知机（MLP）来代替传统的卷积神经网络（CNN）来处理图像。这种架构的优点是可以更好地处理不同尺度和方向的特征，同时减少了计算和内存消耗。它在许多视觉任务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值