pytorch修改resnet50

于 2023-12-12 19:32:48 发布
阅读量1.1k 收藏 17
点赞数 13
分类专栏： 深度学习 文章标签： pytorch 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73101319/article/details/134957172
版权

使用pytorch修改resnet50，输入通道为为，输出为2：

import torch
import torch.nn as nn
import torchvision.models as models


# 定义自定义的ResNet-50网络
class CustomResNet50(nn.Module):
    def __init__(self, in_channels, num_classes):
        super(CustomResNet50, self).__init__()

        # 加载预训练的ResNet-50模型
        resnet = models.resnet50(pretrained=True)

        # 修改第一个卷积层的输入通道数
        resnet.conv1 = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False)

        # 修改全连接层的输出特征数
        resnet.fc = nn.Linear(2048, num_classes)

        # 将修改后的模型赋值给自定义的ResNet-50网络
        self.model = resnet

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

        features = self.model.layer1(features)
        features = self.model.layer2(features)
        features = self.model.layer3(features)
        features = self.model.layer4(features)

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

        return features, output


# 创建一个ResNet-50网络实例
resnet50 = CustomResNet50(in_channels=1, num_classes=2)

# 打印网络结构
print(resnet50)

# 在输入数据上进行前向传播
input_data = torch.randn(64, 1, 224, 224)  # 假设输入数据尺寸为1x224x224
features, output = resnet50(input_data)
print("前连接层特征尺寸:", features.size())
print("最后输出尺寸:", output.size())

输出结果为：

CustomResNet50(
  (model): ResNet(
    (conv1): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer2): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer3): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (3): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (4): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (5): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (layer4): Sequential(
      (0): Bottleneck(
        (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      (2): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
    )
    (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
    (fc): Linear(in_features=2048, out_features=2, bias=True)
  )
) 

梦里梦见梦不见的497
关注
专栏目录
PyTorch源码解读之torchvision.models
AI之路
01-21 10万+
PyTorch框架中有一个非常重要且好用的包：torchvision，该包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。这3个子包的具体介绍可以参考官网：http://pytorch.org/docs/master/torchvision/index.html。具体代码可以参考github：
pytorch搭建Resnet50实现狗狗120个品种类的分类
weixin_45461433的博客
02-05 2723
此项目出自Kaggle竞赛 项目介绍: 谁是好狗?谁喜欢搔耳朵?好吧，看来那些花哨的深度神经网络并没有解决所有问题。然而，也许它们能回答我们在遇到四条腿的陌生人时普遍会问的问题:这是什么样的好狗狗? 在这个操场竞赛级别中，您将得到ImageNet的一个严格的犬类子集，以便练习细粒度图像分类。你能多好地区分你的诺福克梗和诺威奇梗? 数据集介绍: 你会得到一组训练集和一组狗的图像测试集。每张图片都有一个文件名，这是它唯一的id。该数据集包含120个品种的狗。比赛的目标是创造一个分类器，能够从一张照片决定狗的品种
深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）
最新发布
10-31
深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源主要针对计算机、通信、人工智能、自动化等相关专业的学生、老师或从业者下载使用，亦可作为期末课程设计、课程大作业、毕业设计等。项目整体具有较高的学习借鉴价值！基础能力强的可以在此基础上修改调整，以实现不同的功能。 深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）深度学习ResNet网络-使用Pytorch实现Re
Pytorch迁移学习使用Resnet50进行模型训练预测猫狗二分类
qq_43649937的博客
07-22 8373
pytorch
ResNet 修改
weixin_33682719的博客
12-11 643
https://github.com/tornadomeet/ResNet apache 开源项目 修改如下： 训练模块 import argparse,logging,os import mxnet as mx from symbol_resnet import resnet logger = logging.getLogger() logger.setLevel(log...
pytorch调用库的resnet50网络时修改最后的fc层
你若安好是晴天的博客
04-12 7200
import numpy as np import torchvision.models as models import torch.nn as nn # os.environ["CUDA_VISIBLE_DEVICES"] = "0" model = models.resnet50(pretrained=True) print(model) print("修改前后对比==========================================") # for param in model..
Pytorch加载模型时修改输入通道数
思维缜密的博客
11-04 1727
修改resnet50的输入，将输入改为灰度图。修改vgg16的输入，将输入改为灰度图。
Pytorch修改ResNet模型全连接层进行直接训练实例
09-18
在本篇文章里小编给大家整理的是关于Pytorch修改ResNet模型全连接层进行直接训练相关知识点，有需要的朋友们参考下。
人工智能深度学习-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）
10-31
人工智能深度学习-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源...
pytorch-gradcam-resnet50:CAM图的resnet50版本
05-08
上面的这些理解英语应该能够理解如何使用，我只是将原始的vgg19网络更改为imagenet预训练的resnet50，实际上，对于任何图片的处理仍然可以使用，但是我们在做视频是很麻烦的，因为网络具有更多的一维时间维度，这让...
pytorch resnet 101 模型参数数据
12-29
pytorch resnet 101 模型参数数据 pytorch resnet 101 模型参数数据 pytorch resnet 101 模型参数数据 pytorch resnet 101 模型参数数据 pytorch resnet 101 模型参数数据
【超详细小白必懂】Pytorch 直接加载ResNet50模型和参数实现迁移学习
weixin_52527544的博客
09-30 3万+
【超详细小白必懂】Pytorch 直接加载ResNet50模型和参数实现迁移学习
pytorch resnet50_pytorch 冻结某些层参数不训练
weixin_39616222的博客
11-27 1809
上一篇迁移学习的文章下，有朋友问在fine-tune的时候如何固定某些层不参与训练，下去研究并实验了一下，在这儿总结一下：pytorch中关于网络的反向传播操作是基于Variable对象，Variable中有一个参数requires_grad，将requires_grad=False，网络就不会对该层计算梯度。在用户手动定义Variable时，参数requires_grad默认值是False。而在...
PyTorch微调终极指南1：预训练模型调整
新缸中之脑
11-19 1395
快速总结定义模型浮点精度是指深度学习模型计算时用来表示数值的数据类型。在 PyTroch 中，32 位（float32 或 FP32）和 16 位（float16 或 FP16 或半精度）是两种常用的浮点精度。float32 — 这种精度提供了宽动态范围和高数值精度，允许精确计算，但会消耗更多内存。FP32 使用 32 位来表示数字。float16 — 这种较低的精度可以减少模型的内存占用和计算要求，从而潜在提高效率和速度。然而，它可能会导致数值精度损失，并可能影响模型的准确性或收敛性。
深度学习-第J1周：ResNet-50算法的Pytorch实现及解析
weixin_43397208的博客
06-23 2304
深度残差网络ResNet（deep residual network）在2015年由何恺明等提出，因为它简单与实用并存，随后很多研究都是建立在ResNet-50或者ResNet-101基础上完成的。本文实现了在Pytorch框架下的ResNet50算法。参考文章：Deep Residual Learning for Image Recognition.pdf 【何恺明】数据集：./data/bird_photos/...self,
pytorch修改预训练模型（输入通道数）
weixin_43162240的博客
05-13 3万+
Pytorch修改预训练模型   torchvision模块带有很多预训练模型，具体支持的模型列表可以参看官方文档。   在语义分割中，预训练模型一般是3通道的，但是在实际情况中经常会有输入通道数量不止3个通道，要修改预训练模型的通道数,要么重写模型，要么就复用预训练模型，这里推荐用官方的预训练模型，代码简洁且不容易出错。   步入正题，要调整预训练模型需要两个步骤，首先如下加载预训练模型，并打印模型第一层，然后修改第一层结构的输入通道数即可。 import torchvision.models as mo
keras之-ResNet50
favomj的博客
10-10 1102
理论参考：https://blog.csdn.net/weixin_43624538/article/details/85049699 代码：https://blog.csdn.net/u013093426/article/details/81166751 整体架构图： 其中ID block x3表示该模块是由3个Identity块堆叠构成，该模型各层参数设置如下： Zero-Padd...
resnet修改输出类别
sinat_36059653的博客
06-16 3535
文章目录背景错误尝试一正确尝试二 背景 由于实验要求，需要用resnet18来分类TinyImageNet 为了更快地收敛，利用提前训练好的resnet18模型，但是由于训练好的模型是在数据集ImageNet上训练的，输出类别是1000，而TinyImageNet的类别是200，所以需要修改resnet18的输出。 错误尝试一 通过以下方法修改最后一层fc输出维度为200后，输出模型结构最后是200，但是实际上模型并没有改变。 模型输出： 实际分类结果输出还是1000： 所以以上的修改输出结果的方式是
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
热门推荐
ZhengrongYue的博客
07-04 4万+
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值