VGG16

最新推荐文章于 2024-09-25 09:42:07 发布
最新推荐文章于 2024-09-25 09:42:07 发布
阅读量2.9k 收藏 3
点赞数 3
分类专栏： Caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raby_gyl/article/details/79428737
版权

Models from the BMVC-2014 paper “Return of the Devil in the Details: Delving Deep into Convolutional Nets”

The models are trained on the ILSVRC-2012 dataset. The details can be found on the project page or in the following BMVC-2014 paper:

Return of the Devil in the Details: Delving Deep into Convolutional
Nets K. Chatfield, K. Simonyan, A. Vedaldi, A. Zisserman British
Machine Vision Conference, 2014 (arXiv ref. cs1405.3531)

Please cite the paper if you use the models.

Models:

VGG_CNN_S: 13.1% top-5 error on ILSVRC-2012-val
VGG_CNN_M: 13.7% top-5 error on ILSVRC-2012-val
VGG_CNN_M_2048: 13.5% top-5 error on ILSVRC-2012-val
VGG_CNN_M_1024: 13.7% top-5 error on ILSVRC-2012-val
VGG_CNN_M_128: 15.6% top-5 error on ILSVRC-2012-val
VGG_CNN_F: 16.7% top-5 error on ILSVRC-2012-val

Models used by the VGG team in ILSVRC-2014
The models are the improved versions of the models used by the VGG team in the ILSVRC-2014 competition. The details can be found on the project page or in the following arXiv paper:

Very Deep Convolutional Networks for Large-Scale Image Recognition K.
Simonyan, A. Zisserman arXiv:1409.1556

Please cite the paper if you use the models.

Models:

16-layer: 7.5% top-5 error on ILSVRC-2012-val, 7.4% top-5 error on ILSVRC-2012-test
19-layer: 7.5% top-5 error on ILSVRC-2012-val, 7.3% top-5 error on ILSVRC-2012-test

In the paper, the models are denoted as configurations D and E, trained with scale jittering. The combination of the two models achieves 7.1% top-5 error on ILSVRC-2012-val, and 7.0% top-5 error on ILSVRC-2012-test.

VGG16 for face recognition: caffemodel,
http://www.robots.ox.ac.uk/~vgg/software/vgg_face/

注释：
gist.github.com 被墙无法访问解决办法
windows下 打开C:\Windows\System32\drivers\etc\hosts文件
编辑器打开，在最后行添加192.30.253.118 gist.github.com
保存。

从头开始训练，将参数的“gaussian”初始方式 修改为“xavier”, 否则训练的时候可能不会收敛。参数的初始化方式很重要。

train.prototxt

layer {
  name: "data"
  type: "Python"
  top: "Features"
  top: "Headposes"
  python_param {
    module: "python_read_data_for_softmax"
    layer: "AllDataLayer"
    param_str: "{\'phase\': \'train\', \'dataset_name\': \'lfw\', \'data_type\': \'image\',\'batch_size\': 48,\'cross_id\':0}"
  }
}

layer {  
  bottom: "Features"  
  top: "conv1_1"  
  name: "conv1_1"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 64  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv1_1"  
  top: "conv1_1"  
  name: "relu1_1"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv1_1"  
  top: "conv1_2"  
  name: "conv1_2"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 64  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv1_2"  
  top: "conv1_2"  
  name: "relu1_2"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv1_2"  
  top: "pool1"  
  name: "pool1"  
  type: "Pooling"  
  pooling_param {  
    pool: MAX  
    kernel_size: 2  
    stride: 2  
  }  
}  
layer {  
  bottom: "pool1"  
  top: "conv2_1"  
  name: "conv2_1"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 128  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv2_1"  
  top: "conv2_1"  
  name: "relu2_1"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv2_1"  
  top: "conv2_2"  
  name: "conv2_2"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 128  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv2_2"  
  top: "conv2_2"  
  name: "relu2_2"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv2_2"  
  top: "pool2"  
  name: "pool2"  
  type: "Pooling"  
  pooling_param {  
    pool: MAX  
    kernel_size: 2  
    stride: 2  
  }  
}  
layer {  
  bottom: "pool2"  
  top: "conv3_1"  
  name: "conv3_1"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 256  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv3_1"  
  top: "conv3_1"  
  name: "relu3_1"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv3_1"  
  top: "conv3_2"  
  name: "conv3_2"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 256  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv3_2"  
  top: "conv3_2"  
  name: "relu3_2"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv3_2"  
  top: "conv3_3"  
  name: "conv3_3"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 256  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv3_3"  
  top: "conv3_3"  
  name: "relu3_3"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv3_3"  
  top: "pool3"  
  name: "pool3"  
  type: "Pooling"  
  pooling_param {  
    pool: MAX  
    kernel_size: 2  
    stride: 2  
  }  
}  
layer {  
  bottom: "pool3"  
  top: "conv4_1"  
  name: "conv4_1"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv4_1"  
  top: "conv4_1"  
  name: "relu4_1"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv4_1"  
  top: "conv4_2"  
  name: "conv4_2"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv4_2"  
  top: "conv4_2"  
  name: "relu4_2"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv4_2"  
  top: "conv4_3"  
  name: "conv4_3"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv4_3"  
  top: "conv4_3"  
  name: "relu4_3"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv4_3"  
  top: "pool4"  
  name: "pool4"  
  type: "Pooling"  
  pooling_param {  
    pool: MAX  
    kernel_size: 2  
    stride: 2  
  }  
}  
layer {  
  bottom: "pool4"  
  top: "conv5_1"  
  name: "conv5_1"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv5_1"  
  top: "conv5_1"  
  name: "relu5_1"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv5_1"  
  top: "conv5_2"  
  name: "conv5_2"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv5_2"  
  top: "conv5_2"  
  name: "relu5_2"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv5_2"  
  top: "conv5_3"  
  name: "conv5_3"  
  type: "Convolution"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  convolution_param {  
    num_output: 512  
    pad: 1  
    kernel_size: 3  
    weight_filler {  
      type: "xavier"  
      std: 0.01  
    }  
    bias_filler {  
      type: "constant"  
      value: 0  
    }  
  }  
}  
layer {  
  bottom: "conv5_3"  
  top: "conv5_3"  
  name: "relu5_3"  
  type: "ReLU"  
}  
layer {  
  bottom: "conv5_3"  
  top: "pool5"  
  name: "pool5"  
  type: "Pooling"  
  pooling_param {  
    pool: MAX  
    kernel_size: 2  
    stride: 2  
  }  
}  
layer {  
  bottom: "pool5"  
  top: "fc6"  
  name: "fc6"  
  type: "InnerProduct"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  inner_product_param {  
    num_output: 4096  
    weight_filler {  
      type: "xavier"  
      std: 0.005  
    }  
    bias_filler {  
      type: "constant"  
      value: 0.1  
    }  
  }  
}  
layer {  
  bottom: "fc6"  
  top: "fc6"  
  name: "relu6"  
  type: "ReLU"  
}  
layer {  
  bottom: "fc6"  
  top: "fc6"  
  name: "drop6"  
  type: "Dropout"  
  dropout_param {  
    dropout_ratio: 0.5  
  }  
}  
layer {  
  bottom: "fc6"  
  top: "fc7"  
  name: "fc7"  
  type: "InnerProduct"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  inner_product_param {  
    num_output: 4096  
    weight_filler {  
      type: "xavier"  
      std: 0.005  
    }  
    bias_filler {  
      type: "constant"  
      value: 0.1  
    }  
  }  
}  
layer {  
  bottom: "fc7"  
  top: "fc7"  
  name: "relu7"  
  type: "ReLU"  
}  
layer {  
  bottom: "fc7"  
  top: "fc7"  
  name: "drop7"  
  type: "Dropout"  
  dropout_param {  
    dropout_ratio: 0.5  
  }  
}  
layer {  
  bottom: "fc7"  
  top: "fc8"  
  name: "fc8"  
  type: "InnerProduct"  
  param {  
    lr_mult: 1  
    decay_mult: 1  
  }  
  param {  
    lr_mult: 2  
    decay_mult: 0  
  }  
  inner_product_param {  
    num_output: 5  
    weight_filler {  
      type: "xavier"  
      std: 0.005  
    }  
    bias_filler {  
      type: "constant"  
      value: 0.1  
    }  
  }  
}  

layer {  
  bottom: "fc8"  
  bottom: "Headposes"  
  top: "headposeloss1"  
  name: "headposeloss1"  
  type: "SoftmaxWithLoss"  
}

solver.prototxt:

train_net: "ZOO_VGG16/train2.prototxt"
base_lr: 0.01
display: 20
max_iter: 100000
lr_policy: "step"
gamma: 0.1
momentum: 0.9
weight_decay: 0.0005
stepsize: 50000
snapshot: 5000
snapshot_prefix: "snapshots_pointing04_vgg16_klLoss/cross1/vgg_"
random_seed: 831486
iter_size: 1

参考文献：

  1. https://github.com/NVIDIA/DIGITS/issues/159#issuecomment-247707549
  2. https://github.com/NVIDIA/DIGITS/issues/535
  3. https://stackoverflow.com/questions/42652903/caffe-net-not-converging-when-replacing-alexnet-with-vgg16-but-everything-else?rq=1
  4. https://github.com/BVLC/caffe/wiki/Model-Zoo
  5. https://www.cnblogs.com/ryans/p/8196151.html
机器学习的小学生
关注
专栏目录
vgg16_VGG16_
10-01
VGG16是一种深度卷积神经网络（Convolutional Neural Network, CNN）模型，由英国牛津大学的Visual Geometry Group（VGG）在2014年的ImageNet竞赛中提出。该模型以其深而窄的架构闻名，拥有16个处理层，其中13层是卷...
探索VGG Face Caffe Model：深度学习中的脸部识别利器
gitblog_00037的博客
04-23 962
探索VGG Face Caffe Model：深度学习中的脸部识别利器 去发现同类优质开源项目:https://gitcode.com/ 该项目是一个基于Caffe框架的VGG Face模型实现，用于深度学习的脸部识别任务。通过这个开源库，开发者和研究人员可以利用强大的预训练模型进行精确的人脸检测和识别。 项目简介 VGG Face模型由牛津大学视觉几何组（Oxford VGG）开发，它在超过2,...
vgg-16网络
qq_42220290的博客
02-18 343
为了简洁、明了地理解vgg-16网络： 参考：https://blog.csdn.net/nanhuaibeian/article/details/100546458 https://blog.csdn.net/qq_34823656/article/details/92410152 1.网络总体结构图 2.官方网络说明 3.参数计算过程 ...
神经网络（三）：VGG16
最新发布
悟兰因的博客
09-25 1431
VGG是为ImageNet分类挑战训练的，这是一个带有1000个类的对象识别问题，最后的全连接层（4096x1000）为每个输入图像输出一个长度为1000的向量，softmax层将这个长度为1000的向量转换为1000个类。从网络结构中可看出，VGG均全部使用3×3大小、步长为1的小卷积核，3×3卷积核同时也是最小的能够表示上下左右中心的尺寸。
【深度学习】全面理解VGG16模型
florrie
06-18 3万+
全面理解VGG16模型VGG16的结构层次介绍结构图VGG16模型所需要的内存容量介绍卷积中的基本概念1.从input到conv1：2.从conv1到conv2之间的过渡：3.conv2到conv3：4.进入conv3：5.从conv3到conv4之间的过渡：6.最后到三层全连接FC层结论 VGG16的结构层次 vgg16总共有16层，13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后...
卷积神经网络模型之——VGG-16网络结构与代码实现
1+1=王的博客
07-18 9784
VGG原文：Very deep convolutional networks for large-scale image recognition：https://arxiv.org/pdf/1409.1556.pdf VGG在2014年由牛津大学Visual GeometryGroup提出，获得该年lmageNet竞赛中Localization Task(定位任务)第一名和 Classification Task (分类任务)第二名。VGG与AlexNet相比，它采用几个连续的3x3的卷积核代替AlexNe
深度学习——VGG16模型详解
热门推荐
橙子的博客
03-02 10万+
1、网络结构 VGG16模型很好的适用于分类和定位任务，其名称来自牛津大学几何组（Visual Geometry Group）的缩写。 根据卷积核的大小核卷积层数，VGG共有6种配置，分别为A、A-LRN、B、C、D、E，其中D和E两种是最为常用的VGG16和VGG19。 介绍结构图： conv3-64 ：是指第三层卷积后维度变成64，同样地，conv3-128指的是第三层卷积后维度变成128； input（224x224 RGB image） ：指的是输入图片大小为224244的彩色图像，通道为
Vgg16 model
03-25
vgg16 模型 用于初始训练，准确率非常高，可以直接将其封装到云平台中！
vgg16-397923af.pth
08-17
VGG16是一个著名的卷积神经网络（CNN）模型，由英国剑桥大学的Visual Geometry Group（VGG）在2014年的ImageNet Large Scale Visual Recognition Challenge (ILSVRC) 中提出。这个模型因其深度和准确性而备受关注，...
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
VGG16是一种深度卷积神经网络（Deep Convolutional Neural Network, DCNN），由英国牛津大学的Visual Geometry Group（VGG）在2014年的ImageNet竞赛中提出。该模型以其深且窄的架构闻名，拥有16个处理层，其中13层是...
VGG16.rar_VGG16模型详解_vgg16 python_vgg16模型_vgg16模型结构_wish154
07-14
VGG16模型是深度学习领域的一个里程碑，由牛津大学视觉几何组（Visual Geometry Group）的研究员在2014年的ImageNet Large Scale Visual Recognition Challenge（ILSVRC）上提出。模型以其深且窄的网络结构而闻名，...
神经网络模型1——VGG16(2014年)
weixin_44364299的博客
03-26 626
提示：最近在学习bubbliiiiig大博主的神经网络教程，为了避免忘记，本文仅限于个人知识学习记录。 文章目录一、网络模型一、特点1.引入库2.读入数据总结 一、网络模型 1、一张原始图片被resize到(224,224,3)。 2、conv1两次[3,3]卷积网络，输出的特征层为64，输出为(224,224,64)，再2X2最大池化，输出net为(112,112,64)。 3、conv2两次[3,3]卷积网络，输出的特征层为128，输出net为(112,112,128)，再2X2最大池化，输出ne
VGG16模型详解
m0_62919535的博客
08-09 5147
VGG16作为深度学习发展历程中的重要里程碑，强调了通过增加网络深度和一致性设计来提取图像特征。它的成功启发了后续更复杂的网络架构和方法，并在图像分类等任务中取得了重要成就。通过研究和实践，我们可以更好地理解VGG16的原理，并将其应用于实际问题中。VGG16是一种深度卷积神经网络，由牛津大学的研究团队于2014年开发。
VGG-16详解
weixin_40893448的博客
09-03 2759
VGG-16示例理解：不易理解的地方：扩充：结合VGG-16视频及文档学习 Vgg11-19 理解： 输入图像为2242243，大小为：224224，深度为：3（通道数） 3364卷积：33表示卷积核大小，64为图像深度，即卷积核的个数 卷积核：只改变图像的深度（即卷积核的个数），不改变图像的大小 池化：只改变图像的大小,不改变图像的深度 Tensor： 就像ndarray一样,一维Tensor叫Vector，二维Tensor叫Matrix，三维及以上称为Tensor 不易理解的地方： 参数说明：其中的
VGG-16网络结构详解
qq_45998041的博客
03-10 3万+
VGG，又叫VGG-16，顾名思义就是有16层，包括13个卷积层和3个全连接层，是由Simonyan 和Zisserman在文献**《Very Deep Convolutional Networks for Large Scale Image Recognition》**中提出卷积神经网络模型，其名称来源于作者所在的牛津大学视觉几何组(Visual Geometry Group)的缩写。 该模型参加2014年的 ImageNet图像分类与定位挑战赛，取得了优异成绩：在分类任务上排名第二，在定位任务上排名第一
VGG：Very Deep Convolutional Networks for Large-Scale Image Recognition阅读笔记
XZZPPP的博客
08-19 9452
论文原文：Very Deep Convolutional Networks forLarge-Scale Image Recognition 网络模型名字：VGG-16、VGG-19 1、简介     2014年ImageNet亚军。本文主要研究了卷积神经网络深度对大尺度图像识别精度的影响。在现有网络结构的基础上，不断增加3*3卷积核，当深度增加到16-19层时，识别效果有较
VGG16结构解析、代码详解（pytorch）及应用实例-基于CIFAR-10数据集实现分类
weixin_42905252的博客
10-08 9100
VGG16结构解析、代码详解（pytorch）及应用实例-基于CIFAR-10数据集实现分类 论文链接：https://arxiv.org/pdf/1409.1556.pdf VGG16由牛津大学工程科学系视觉几何小组（Visual Geometry Group, Department of Engineering Science, University of Oxford ）提出，这是VGG名字的由来，16表示它的卷积层以及全连接层加起来共有16层。首先来看一下结构图（为更直观，未采用原文中结构）： 可
深入理解VGG16模型与代码实现
u012661539的博客
06-21 1万+
VGG16基本架构与了解
VGG论文原文重点提炼解析
馒头Lynn的博客
02-23 1万+
原论文地址：Very Deep Convolutional Networks for Large-Scale Image Recognition 摘要：    主要研究了深度对卷积网络在大规模图像识别中的准确率的影响。主要贡献是：对使用很小的卷积核（3*3）来增加深度的网络进行了评估，表明通过将深度提升到16-19个权重层，能得到很好的性能。 介绍：    随着卷积网络在计算机视觉领域的应...
VGG16 pyhthon
09-15
VGG16是一种流行的卷积神经网络（CNN）架构，最初由牛津大学的视觉几何组（Visual Geometry Group）在2014年的论文中提出，用于图像识别任务。VGG16模型在2014年ImageNet大规模视觉识别挑战赛（ILSVRC）中取得了优异...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值