Resnet-18和Resnet34 pytorch实现

最新推荐文章于 2024-06-01 12:02:32 发布
最新推荐文章于 2024-06-01 12:02:32 发布
阅读量712 收藏 3
点赞数
分类专栏： 深度学习 python 文章标签： cv pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52295416/article/details/120931067
版权

残差块：
在这里插入图片描述
在这里插入图片描述
18层：（2+2+2+2）*2+1+1

import torch.nn as nn
from torchinfo import summary
import torch


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        """

        :param inplanes: 输入通道数
        :param planes:  输出通道数
        :param stride: 步长
        :param downsample:  基础结构里有一个从x直接连到下面的线，
        如果上一个ResidualBlock的输出维度和当前的ResidualBlock的维度不一样，
        那就对这个x进行downSample操作，如果维度一样，直接加就行了，这时直接output=x+residual
        """

        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x

        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        x = self.conv2(x)
        x = self.bn2(x)

        if self.downsample is not None:
            residual = self.downsample(residual)

        out =x+ residual
        out = self.relu(out)

        return out
class ResNet_18(nn.Module):

    def __init__(self, block, layers, num_classes=1000):
        """

        :param block:  调用basicblock
        :param layers:  使用一个列表 储存想搭建的layer
        :param num_classes: fc的输出维度
        """

        self.inplanes = 64
        super(ResNet_18, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self.make_layer(block, 64, layers[0])
        self.layer2 = self.make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self.make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self.make_layer(block, 512, layers[3], stride=2)

        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
    #构建layer
    def make_layer(self, block, planes, blocks, stride=1):
        """
        
        :param block: 调用basicblock
        :param planes: 输出通道大小
        :param blocks: 调用列表
        :param stride: 步长
        :return: nn.Sequential(*layers)
        """
        downsample = None
        # if stride != 1 or self.inplanes != planes * block.expansion:
        #     downsample = nn.Sequential(
        #         nn.Conv2d(self.inplanes, planes * block.expansion,
        #                   kernel_size=1, stride=stride, bias=False),
        #         nn.BatchNorm2d(planes * block.expansion),
        #     )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        output = self.fc(x)

        return output

resnet=ResNet_18(BasicBlock,[2,2,2,2])

summary(resnet)

结果：

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
ResNet_18                                --
├─Conv2d: 1-1                            9,408
├─BatchNorm2d: 1-2                       128
├─ReLU: 1-3                              --
├─MaxPool2d: 1-4                         --
├─Sequential: 1-5                        --
│    └─BasicBlock: 2-1                   --
│    │    └─Conv2d: 3-1                  36,928
│    │    └─BatchNorm2d: 3-2             128
│    │    └─ReLU: 3-3                    --
│    │    └─Conv2d: 3-4                  36,928
│    │    └─BatchNorm2d: 3-5             128
│    └─BasicBlock: 2-2                   --
│    │    └─Conv2d: 3-6                  36,928
│    │    └─BatchNorm2d: 3-7             128
│    │    └─ReLU: 3-8                    --
│    │    └─Conv2d: 3-9                  36,928
│    │    └─BatchNorm2d: 3-10            128
├─Sequential: 1-6                        --
│    └─BasicBlock: 2-3                   --
│    │    └─Conv2d: 3-11                 73,856
│    │    └─BatchNorm2d: 3-12            256
│    │    └─ReLU: 3-13                   --
│    │    └─Conv2d: 3-14                 147,584
│    │    └─BatchNorm2d: 3-15            256
│    └─BasicBlock: 2-4                   --
│    │    └─Conv2d: 3-16                 147,584
│    │    └─BatchNorm2d: 3-17            256
│    │    └─ReLU: 3-18                   --
│    │    └─Conv2d: 3-19                 147,584
│    │    └─BatchNorm2d: 3-20            256
├─Sequential: 1-7                        --
│    └─BasicBlock: 2-5                   --
│    │    └─Conv2d: 3-21                 295,168
│    │    └─BatchNorm2d: 3-22            512
│    │    └─ReLU: 3-23                   --
│    │    └─Conv2d: 3-24                 590,080
│    │    └─BatchNorm2d: 3-25            512
│    └─BasicBlock: 2-6                   --
│    │    └─Conv2d: 3-26                 590,080
│    │    └─BatchNorm2d: 3-27            512
│    │    └─ReLU: 3-28                   --
│    │    └─Conv2d: 3-29                 590,080
│    │    └─BatchNorm2d: 3-30            512
├─Sequential: 1-8                        --
│    └─BasicBlock: 2-7                   --
│    │    └─Conv2d: 3-31                 1,180,160
│    │    └─BatchNorm2d: 3-32            1,024
│    │    └─ReLU: 3-33                   --
│    │    └─Conv2d: 3-34                 2,359,808
│    │    └─BatchNorm2d: 3-35            1,024
│    └─BasicBlock: 2-8                   --
│    │    └─Conv2d: 3-36                 2,359,808
│    │    └─BatchNorm2d: 3-37            1,024
│    │    └─ReLU: 3-38                   --
│    │    └─Conv2d: 3-39                 2,359,808
│    │    └─BatchNorm2d: 3-40            1,024
├─AvgPool2d: 1-9                         --
├─Linear: 1-10                           513,000
=================================================================
Total params: 11,519,528
Trainable params: 11,519,528
Non-trainable params: 0
=================================================================

Resnet-34

import torch.nn as nn
from torchinfo import summary
import torch


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        """

        :param inplanes: 输入通道数
        :param planes:  输出通道数
        :param stride: 步长
        :param downsample:  基础结构里有一个从x直接连到下面的线，
        如果上一个ResidualBlock的输出维度和当前的ResidualBlock的维度不一样，
        那就对这个x进行downSample操作，如果维度一样，直接加就行了，这时直接output=x+residual
        """

        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x

        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        x = self.conv2(x)
        x = self.bn2(x)

        if self.downsample is not None:
            residual = self.downsample(residual)

        out =x+ residual
        out = self.relu(out)

        return out
class ResNet_34(nn.Module):

    def __init__(self, block, layers, num_classes=1000):
        """

        :param block:  调用basicblock
        :param layers:  使用一个列表 储存想搭建的layer
        :param num_classes: fc的输出维度
        """

        self.inplanes = 64
        super(ResNet_34, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self.make_layer(block, 64, layers[0])
        self.layer2 = self.make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self.make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self.make_layer(block, 512, layers[3], stride=2)

        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
    #构建layer
    def make_layer(self, block, planes, blocks, stride=1):
        """

        :param block: 调用basicblock
        :param planes: 输出通道大小
        :param blocks: 调用列表
        :param stride: 步长
        :return: nn.Sequential(*layers)
        """
        downsample = None
        # if stride != 1 or self.inplanes != planes * block.expansion:
        #     downsample = nn.Sequential(
        #         nn.Conv2d(self.inplanes, planes * block.expansion,
        #                   kernel_size=1, stride=stride, bias=False),
        #         nn.BatchNorm2d(planes * block.expansion),
        #     )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        output = self.fc(x)

        return output

resnet=ResNet_34(BasicBlock,[3,4,6,3])

summary(resnet)

结果：

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
ResNet_18                                --
├─Conv2d: 1-1                            9,408
├─BatchNorm2d: 1-2                       128
├─ReLU: 1-3                              --
├─MaxPool2d: 1-4                         --
├─Sequential: 1-5                        --
│    └─BasicBlock: 2-1                   --
│    │    └─Conv2d: 3-1                  36,928
│    │    └─BatchNorm2d: 3-2             128
│    │    └─ReLU: 3-3                    --
│    │    └─Conv2d: 3-4                  36,928
│    │    └─BatchNorm2d: 3-5             128
│    └─BasicBlock: 2-2                   --
│    │    └─Conv2d: 3-6                  36,928
│    │    └─BatchNorm2d: 3-7             128
│    │    └─ReLU: 3-8                    --
│    │    └─Conv2d: 3-9                  36,928
│    │    └─BatchNorm2d: 3-10            128
│    └─BasicBlock: 2-3                   --
│    │    └─Conv2d: 3-11                 36,928
│    │    └─BatchNorm2d: 3-12            128
│    │    └─ReLU: 3-13                   --
│    │    └─Conv2d: 3-14                 36,928
│    │    └─BatchNorm2d: 3-15            128
├─Sequential: 1-6                        --
│    └─BasicBlock: 2-4                   --
│    │    └─Conv2d: 3-16                 73,856
│    │    └─BatchNorm2d: 3-17            256
│    │    └─ReLU: 3-18                   --
│    │    └─Conv2d: 3-19                 147,584
│    │    └─BatchNorm2d: 3-20            256
│    └─BasicBlock: 2-5                   --
│    │    └─Conv2d: 3-21                 147,584
│    │    └─BatchNorm2d: 3-22            256
│    │    └─ReLU: 3-23                   --
│    │    └─Conv2d: 3-24                 147,584
│    │    └─BatchNorm2d: 3-25            256
│    └─BasicBlock: 2-6                   --
│    │    └─Conv2d: 3-26                 147,584
│    │    └─BatchNorm2d: 3-27            256
│    │    └─ReLU: 3-28                   --
│    │    └─Conv2d: 3-29                 147,584
│    │    └─BatchNorm2d: 3-30            256
│    └─BasicBlock: 2-7                   --
│    │    └─Conv2d: 3-31                 147,584
│    │    └─BatchNorm2d: 3-32            256
│    │    └─ReLU: 3-33                   --
│    │    └─Conv2d: 3-34                 147,584
│    │    └─BatchNorm2d: 3-35            256
├─Sequential: 1-7                        --
│    └─BasicBlock: 2-8                   --
│    │    └─Conv2d: 3-36                 295,168
│    │    └─BatchNorm2d: 3-37            512
│    │    └─ReLU: 3-38                   --
│    │    └─Conv2d: 3-39                 590,080
│    │    └─BatchNorm2d: 3-40            512
│    └─BasicBlock: 2-9                   --
│    │    └─Conv2d: 3-41                 590,080
│    │    └─BatchNorm2d: 3-42            512
│    │    └─ReLU: 3-43                   --
│    │    └─Conv2d: 3-44                 590,080
│    │    └─BatchNorm2d: 3-45            512
│    └─BasicBlock: 2-10                  --
│    │    └─Conv2d: 3-46                 590,080
│    │    └─BatchNorm2d: 3-47            512
│    │    └─ReLU: 3-48                   --
│    │    └─Conv2d: 3-49                 590,080
│    │    └─BatchNorm2d: 3-50            512
│    └─BasicBlock: 2-11                  --
│    │    └─Conv2d: 3-51                 590,080
│    │    └─BatchNorm2d: 3-52            512
│    │    └─ReLU: 3-53                   --
│    │    └─Conv2d: 3-54                 590,080
│    │    └─BatchNorm2d: 3-55            512
│    └─BasicBlock: 2-12                  --
│    │    └─Conv2d: 3-56                 590,080
│    │    └─BatchNorm2d: 3-57            512
│    │    └─ReLU: 3-58                   --
│    │    └─Conv2d: 3-59                 590,080
│    │    └─BatchNorm2d: 3-60            512
│    └─BasicBlock: 2-13                  --
│    │    └─Conv2d: 3-61                 590,080
│    │    └─BatchNorm2d: 3-62            512
│    │    └─ReLU: 3-63                   --
│    │    └─Conv2d: 3-64                 590,080
│    │    └─BatchNorm2d: 3-65            512
├─Sequential: 1-8                        --
│    └─BasicBlock: 2-14                  --
│    │    └─Conv2d: 3-66                 1,180,160
│    │    └─BatchNorm2d: 3-67            1,024
│    │    └─ReLU: 3-68                   --
│    │    └─Conv2d: 3-69                 2,359,808
│    │    └─BatchNorm2d: 3-70            1,024
│    └─BasicBlock: 2-15                  --
│    │    └─Conv2d: 3-71                 2,359,808
│    │    └─BatchNorm2d: 3-72            1,024
│    │    └─ReLU: 3-73                   --
│    │    └─Conv2d: 3-74                 2,359,808
│    │    └─BatchNorm2d: 3-75            1,024
│    └─BasicBlock: 2-16                  --
│    │    └─Conv2d: 3-76                 2,359,808
│    │    └─BatchNorm2d: 3-77            1,024
│    │    └─ReLU: 3-78                   --
│    │    └─Conv2d: 3-79                 2,359,808
│    │    └─BatchNorm2d: 3-80            1,024
├─AvgPool2d: 1-9                         --
├─Linear: 1-10                           513,000
=================================================================
Total params: 21,631,400
Trainable params: 21,631,400
Non-trainable params: 0
=================================================================
聪明乖巧的小狮子
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch-resnet18和resnet50官方预训练模型
08-22
pytroch官网提供的预训练模型：resnet18：resnet18-5c106cde.pth和resnet50：resnet50-19c8e357.pth（两个文件打包在一起）
使用PyTorch搭建ResNet34网络
TTTSEP9TH2244的博客
02-25 6910
ResNet34网络结构 先上图 参照ResNet18的搭建，由于34层和18层几乎相同，叠加卷积单元数即可，所以没有写注释，具体可以参考我的ResNet18搭建中的注释，ResNet34的训练部分也可以参照。 import torch import torch.nn as nn from torch.nn import functional as F class CommonBlock(nn.Module): def __init__(self, in_channel, out_chann
论文阅读：2021.11.23~2021.12.1
m0_43409779的博客
11-23 2943
写在前面：本篇博客只是记录本人在这周看论文的过程中的一些思考，没有一点儿教程或其他意思，由于时间不够，某些细节的部分必然不会那么详细，分享出来就是想着能帮到看到的人也算是一件幸事，想了解细节的小伙伴还是建议去读原文。由于本人也是初学者，如果有理解不到位的地方还请路过的大佬不吝赐教。 Multi-Layer Pseudo-Supervision for Histopathology Tissue Semantic Segmentation using Patch-level Classification La
使用pytorch搭建自己的网络之ResNet
qq_40356092的博客
10-12 1963
一、introduction ResNet是2015年提出来的深度学习网络模型，其主要解决的是网络层数过多导致的退化问题。过去的网络模型层数差不多在十几二十层，随着网络层数的增多，人们发现模型的准确率很难再有较大的提升，甚至会出现准确率下降的情况，而ResNet提出的残差网络有效解决了这一问题，使得网络层数达到了上百层。 更重要的是，这一思想的提出，使得ResNet模型逐渐取代了VGG网络，几乎是当前应用最广泛的CNN特征提取网络，甚至影响了学术界和工业界未来的发展方向。随后提出的Res2Net和Dense
[人工智能-深度学习-38]：卷积神经网络CNN - 常见分类网络- ResNet网络架构分析与详解
文火冰糖（王文兵）的博客
10-24 1万+
作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客 本文网址 第1章 卷积神经网络基础 1.1 卷积神经发展与进化史 AlexNet是深度学习的起点，后续各种深度学习的网络或算法，都是源于AlexNet网络。 [人工智能-深度学习-31]：卷积神经网络CNN - 常见卷积神经网络综合比较大全_文火冰糖（王文兵）的博客-CSDN博客作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客本文网址：第1章 人工智能发展.
pytorch实现ResNet-18
Mr_Wanderer的博客
07-31 3026
文章目录ResNet-18残差学习单元ResNet-18 结构Pytorch构建ResNet-18使用CIFAR10数据集测试ResNet-18CIFAR10数据集介绍使用CIFAR10数据集测试ResNet-18 ResNet-18 残差学习单元 网络层数越多，并不意味着效果越好。当网络深度更深的时候，每一层的误差积累，最终会导致梯度弥散。最后几层能很好的更新，但是前面几层会一直得不到更新。 ResNet设置一个机制，增加短路连接。使30层的网络最差最差也可以退换成22层。 短路连接：如果ch_in和c
pytorch实现resnet18
weixin_43327191的博客
12-20 1162
实现代码 """resnet18的pytorch实现""" import torch import torch.nn as nn import torch.nn.functional as F class basic_block(nn.Module): """基本残差块,由两层卷积构成""" def __init__(self,in_planes,planes,kernel_size=3,stride=1): """ :param in_planes: 输
使用pytorch实现resnet18
qq_35090060的博客
12-18 2008
代码 from torchvision.datasets import ImageFolder from torchvision.transforms import transforms from torch.utils.data.dataloader import DataLoader import torchvision.models as models import torch.nn as nn from torch.cuda import is_available as is_cuda import
Pytorch搭建ResNet18
不加辣椒的博客
06-15 4870
ResNet代码 import torch import torchvision import torch.nn as nn import torch.nn.functional as F import matplotlib.pyplot as plt import numpy as np # define structure class BasicBlock(nn.Module): def __init__(self, in_planes, planes, stride=1):
resnet-使用resnet34+Pytorch实现鸟类分类-算法项目.zip
03-08
resnet resnet_使用resnet34+Pytorch实现鸟类分类_算法项目
pytorch的resnet-18在cifar-10的预训练模型
03-13
pytorch的resnet-18在cifar-10的预训练模型
ResNet-50 PyTorch Pretrained-数据集
03-18
数据集可用语在ImageNet上预训练的PyTorch模型，用于转移学习。如果将此数据集作为附加数据添加，则可以用作基础模型，可以使用转移学习针对特定任务对其进行微调。...ResNet-50 PyTorch Pretrained_datasets.zip
resnet18-tf2:ResNet-18的简单TensorFlow 2实现
04-02
该代码库提供了ResNet-18和ResNet-34的简单（ ）TensorFlow 2实现，直接从PyTorch的torchvision转换而来。 模型输出已经过验证，可与火炬视觉模型的输出以浮点精度匹配。 此代码已使用以下软件包版本进行了测试： ...
ResNet18-CIFAR10-使用Pytorch和CIFAR10数据集训练ResNet18
08-11
ResNet18_CIFAR10-使用Pytorch和CIFAR10数据集训练ResNet18
ResNet
Major_S的博客
03-03 420
迁移学习之——模型Finetune
深度学习——ResNet18 / 34
热门推荐
Dunkle.T的博客
04-06 2万+
ResNet在2015年由微软实验室提出，斩获当年ImageNet竞赛中分类任务第一名，目标检测第一名。获得COCO数据集中目标检测第一名，图像分割第一名。 ResNet34层模型的结构简图： ResNet网络中的亮点： 超深的网络结构（突破1000层） 提出residual模块（残差结构） 使用Batch Normalization加速训练（丢弃dropout） 在ResNet网络提出之前，传统的卷积神经网络都是通过将一系列卷积层与下采样层进行堆叠得到的。但是当堆叠到一定网络深度时，就会出现两个问题
ResNet34之pytorch实现
湛蓝的天空
03-04 8472
我的实现：import torch from torch import nn #因为ResNet34包含重复的单元，故用ResidualBlock类来简化代码 class ResidualBlock(nn.Module): def __init__(self,inchannel,outchannel,stride,shortcut=None): super(Residual...
机器学习笔记 - PyTorch 分布式训练概览
最新发布
学以致用 知行合一
06-01 41
对训练集图像进行数据增强])])加载预训练模型首先，检查我们的硬件是否符合 PyTorch Data Parallel。如果符合我们就将模型传递给模块从而并行化我们的模型。我们使用训练数据加载器循环训练集。进入训练集循环后，我们首先启用混合精度并将输入（数据和标签）加载到 CUDA 设备。最后，让模型执行前向传递并使用损失函数计算损失。在评估过程中，我们将PyTorch切换到评估模式。然后，在训练步骤中，我们循环验证数据加载器并在将数据加载到 CUDA 设备之前启用混合精度。
resnet-v2 pytorch
09-17
您可以根据需要选择不同的ResNet版本，如resnet18、resnet34等。 接下来，您可以使用模型进行推理或微调。下面是一个使用ResNet-50模型进行推理的示例： ```python input = torch.randn(1, 3, 224, 224) # 输入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值