人工智能基础作业_9

最新推荐文章于 2024-06-02 18:21:33 发布
最新推荐文章于 2024-06-02 18:21:33 发布
阅读量56 收藏
点赞数 1
文章标签： 人工智能 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29149761/article/details/130717620
版权

手工实现 卷积-池化-激活：

import numpy as np

x = np.array([[-1, -1, -1, -1, -1, -1, -1, -1, -1],
              [-1, 1, -1, -1, -1, -1, -1, 1, -1],
              [-1, -1, 1, -1, -1, -1, 1, -1, -1],
              [-1, -1, -1, 1, -1, 1, -1, -1, -1],
              [-1, -1, -1, -1, 1, -1, -1, -1, -1],
              [-1, -1, -1, 1, -1, 1, -1, -1, -1],
              [-1, -1, 1, -1, -1, -1, 1, -1, -1],
              [-1, 1, -1, -1, -1, -1, -1, 1, -1],
              [-1, -1, -1, -1, -1, -1, -1, -1, -1]])
print("x=\n", x)
# 初始化 三个 卷积核
Kernel = [[0 for i in range(0, 3)] for j in range(0, 3)]
Kernel[0] = np.array([[1, -1, -1],
                      [-1, 1, -1],
                      [-1, -1, 1]])
Kernel[1] = np.array([[1, -1, 1],
                      [-1, 1, -1],
                      [1, -1, 1]])
Kernel[2] = np.array([[-1, -1, 1],
                      [-1, 1, -1],
                      [1, -1, -1]])

# --------------- 卷积  ---------------
stride = 1  # 步长
feature_map_h = 7  # 特征图的高
feature_map_w = 7  # 特征图的宽
feature_map = [0 for i in range(0, 3)]  # 初始化3个特征图
for i in range(0, 3):
    feature_map[i] = np.zeros((feature_map_h, feature_map_w))  # 初始化特征图
for h in range(feature_map_h):  # 向下滑动，得到卷积后的固定行
    for w in range(feature_map_w):  # 向右滑动，得到卷积后的固定行的列
        v_start = h * stride  # 滑动窗口的起始行（高）
        v_end = v_start + 3  # 滑动窗口的结束行（高）
        h_start = w * stride  # 滑动窗口的起始列（宽）
        h_end = h_start + 3  # 滑动窗口的结束列（宽）
        window = x[v_start:v_end, h_start:h_end]  # 从图切出一个滑动窗口
        for i in range(0, 3):
            feature_map[i][h, w] = np.divide(np.sum(np.multiply(window, Kernel[i][:, :])), 9)
print("feature_map:\n", np.around(feature_map, decimals=2))

# --------------- 池化  ---------------
pooling_stride = 2  # 步长
pooling_h = 4  # 特征图的高
pooling_w = 4  # 特征图的宽
feature_map_pad_0 = [[0 for i in range(0, 8)] for j in range(0, 8)]
for i in range(0, 3):  # 特征图 补 0 ，行 列 都要加 1 (因为上一层是奇数，池化窗口用的偶数)
    feature_map_pad_0[i] = np.pad(feature_map[i], ((0, 1), (0, 1)), 'constant', constant_values=(0, 0))
# print("feature_map_pad_0 0:\n", np.around(feature_map_pad_0[0], decimals=2))

pooling = [0 for i in range(0, 3)]
for i in range(0, 3):
    pooling[i] = np.zeros((pooling_h, pooling_w))  # 初始化特征图
for h in range(pooling_h):  # 向下滑动，得到卷积后的固定行
    for w in range(pooling_w):  # 向右滑动，得到卷积后的固定行的列
        v_start = h * pooling_stride  # 滑动窗口的起始行（高）
        v_end = v_start + 2  # 滑动窗口的结束行（高）
        h_start = w * pooling_stride  # 滑动窗口的起始列（宽）
        h_end = h_start + 2  # 滑动窗口的结束列（宽）
        for i in range(0, 3):
            pooling[i][h, w] = np.max(feature_map_pad_0[i][v_start:v_end, h_start:h_end])
print("pooling:\n", np.around(pooling[0], decimals=2))
print("pooling:\n", np.around(pooling[1], decimals=2))
print("pooling:\n", np.around(pooling[2], decimals=2))


# --------------- 激活  ---------------
def relu(x):
    return (abs(x) + x) / 2


relu_map_h = 7  # 特征图的高
relu_map_w = 7  # 特征图的宽
relu_map = [0 for i in range(0, 3)]  # 初始化3个特征图
for i in range(0, 3):
    relu_map[i] = np.zeros((relu_map_h, relu_map_w))  # 初始化特征图

for i in range(0, 3):
    relu_map[i] = relu(feature_map[i])

print("relu map :\n", np.around(relu_map[0], decimals=2))
print("relu map :\n", np.around(relu_map[1], decimals=2))
print("relu map :\n", np.around(relu_map[2], decimals=2))

这是图片输入矩阵：
在这里插入图片描述

这分别是三个卷积核：
在这里插入图片描述

这是分别用三个卷积核卷积以后得到的特征图：
在这里插入图片描述
从上图中对应卷积核我们可以看出：
第一个特征图由于卷积核的斜对角线是正数，而其他部分是负数，所以卷积之后得出来的特征图同样是对角线是“突出”的，因为在卷积核中需要重点突出的部分，会在之后的卷积过程中不断被强化，累积，形成的特征图自然是累积了突出特征的矩阵。二三知识卷积核不同，对应相应的特征图也可以发现同样的道理。

这是将特征图池化后的图：
原始矩阵大小是7* 7，池化后是4* 4，步长为2，池化的提取窗口为2*2
在这里插入图片描述

将原特征图进行激活函数逐一元素运算得到如下relu_map:
在这里插入图片描述
可以看到relu_map中所有负数的元素都归为0，其余正数不变，这是relu激活函数的特性。

说来惭愧，一开始我以为是将池化后的矩阵进行激活，但是又想到激活好像改变不了图片大小，但是确实pooling和relu_map的尺寸大小又不一样，倒回去看源码发现对特征图的池化和激活这两个操作是分开进行的，他们的输入端都是feature_map。汗…

调用函数完成 卷积-池化-激活(pytorch模块)：

# https://blog.csdn.net/qq_26369907/article/details/88366147
# https://zhuanlan.zhihu.com/p/405242579
import numpy as np
import torch
import torch.nn as nn

x = torch.tensor([[[[-1, -1, -1, -1, -1, -1, -1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, -1, -1, 1, -1, -1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, -1, -1, -1, -1, -1, -1, -1]]]], dtype=torch.float)
print(x.shape)
print(x)

print("--------------- 卷积  ---------------")
conv1 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv1.weight.data = torch.Tensor([[[[1, -1, -1],
                                    [-1, 1, -1],
                                    [-1, -1, 1]]
                                   ]])
conv2 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv2.weight.data = torch.Tensor([[[[1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, 1]]
                                   ]])
conv3 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv3.weight.data = torch.Tensor([[[[-1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, -1]]
                                   ]])

feature_map1 = conv1(x)
feature_map2 = conv2(x)
feature_map3 = conv3(x)

print(feature_map1 / 9)
print(feature_map2 / 9)
print(feature_map3 / 9)

print("--------------- 池化  ---------------")
max_pool = nn.MaxPool2d(2, padding=0, stride=2)  # Pooling
zeroPad = nn.ZeroPad2d(padding=(0, 1, 0, 1))  # pad 0 , Left Right Up Down

feature_map_pad_0_1 = zeroPad(feature_map1)
feature_pool_1 = max_pool(feature_map_pad_0_1)
feature_map_pad_0_2 = zeroPad(feature_map2)
feature_pool_2 = max_pool(feature_map_pad_0_2)
feature_map_pad_0_3 = zeroPad(feature_map3)
feature_pool_3 = max_pool(feature_map_pad_0_3)

print(feature_pool_1.size())
print(feature_pool_1 / 9)
print(feature_pool_2 / 9)
print(feature_pool_3 / 9)

print("--------------- 激活  ---------------")
activation_function = nn.Tanh()

feature_relu1 = activation_function(feature_map1)
feature_relu2 = activation_function(feature_map2)
feature_relu3 = activation_function(feature_map3)
print(feature_relu1 / 9)
print(feature_relu2 / 9)
print(feature_relu3 / 9)

由于特征图一样，卷积核一样，所以卷积结果和库函数的结果应该是一样的，不同的是精度不一样，库函数精确到了四位小数。
这里把激活函数换成了Tann函数，它会把负数转换在[-1,0]区间，把正数转换在[0,1]区间，池化和卷积的过程只是简单换个参数，这里就不全部赘述了，下面给出Tann函数激活转换后的图：
在这里插入图片描述

在这里插入图片描述>

了解数字与图像之间的关系

# https://blog.csdn.net/qq_26369907/article/details/88366147
# https://zhuanlan.zhihu.com/p/405242579
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号 #有中文出现的情况，需要u'内容
x = torch.tensor([[[[-1, -1, -1, -1, -1, -1, -1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, -1, -1, 1, -1, -1, -1, -1],
                    [-1, -1, -1, 1, -1, 1, -1, -1, -1],
                    [-1, -1, 1, -1, -1, -1, 1, -1, -1],
                    [-1, 1, -1, -1, -1, -1, -1, 1, -1],
                    [-1, -1, -1, -1, -1, -1, -1, -1, -1]]]], dtype=torch.float)
print(x.shape)
print(x)
img = x.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('原图')
plt.show()

print("--------------- 卷积  ---------------")
conv1 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv1.weight.data = torch.Tensor([[[[1, -1, -1],
                                    [-1, 1, -1],
                                    [-1, -1, 1]]
                                   ]])
img = conv1.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('Kernel 1')
plt.show()
conv2 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv2.weight.data = torch.Tensor([[[[1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, 1]]
                                   ]])
img = conv2.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('Kernel 2')
plt.show()
conv3 = nn.Conv2d(1, 1, (3, 3), 1)  # in_channel , out_channel , kennel_size , stride
conv3.weight.data = torch.Tensor([[[[-1, -1, 1],
                                    [-1, 1, -1],
                                    [1, -1, -1]]
                                   ]])
img = conv3.weight.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('Kernel 3')
plt.show()

feature_map1 = conv1(x)
feature_map2 = conv2(x)
feature_map3 = conv3(x)

print(feature_map1 / 9)
print(feature_map2 / 9)
print(feature_map3 / 9)

img = feature_map1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('卷积后的特征图1')
plt.show()

print("--------------- 池化  ---------------")
max_pool = nn.MaxPool2d(2, padding=0, stride=2)  # Pooling
zeroPad = nn.ZeroPad2d(padding=(0, 1, 0, 1))  # pad 0 , Left Right Up Down

feature_map_pad_0_1 = zeroPad(feature_map1)
feature_pool_1 = max_pool(feature_map_pad_0_1)
feature_map_pad_0_2 = zeroPad(feature_map2)
feature_pool_2 = max_pool(feature_map_pad_0_2)
feature_map_pad_0_3 = zeroPad(feature_map3)
feature_pool_3 = max_pool(feature_map_pad_0_3)

print(feature_pool_1.size())
print(feature_pool_1 / 9)
print(feature_pool_2 / 9)
print(feature_pool_3 / 9)
img = feature_pool_1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('卷积池化后的特征图1')
plt.show()

print("--------------- 激活  ---------------")
activation_function = nn.ReLU()

feature_relu1 = activation_function(feature_map1)
feature_relu2 = activation_function(feature_map2)
feature_relu3 = activation_function(feature_map3)
print(feature_relu1 / 9)
print(feature_relu2 / 9)
print(feature_relu3 / 9)
img = feature_relu1.data.squeeze().numpy()  # 将输出转换为图片的格式
plt.imshow(img, cmap='gray')
plt.title('卷积 + Relu 后的特征图1')
plt.show()

原图：
在这里插入图片描述
这里是引用
在矩阵中，-1为黑色，1为白色，0为灰色，介于这三个数之间有无数灰度值。上图为原图执行Relu激活函数之后的效果图，在左上到右下这一条直线中1更多，白色也较为明显，这是因为卷积核里左上到右下全为1，原图的1不断被卷积核强化累积，使得图中显示出的“x”的某条直线更加明显，在这种情况下，识别为‘x’的概率当然也就更大。

值得一提的是，我换了一个激活函数，换成了Tanh函数，执行出来的结果如下所示：
在这里插入图片描述这样看来如果当图片分辨率变成很大时，利用Tanh函数来进行识别准确性也应该是可以的。

最后，由于屏幕无法全部显示所有矩阵值与图片的关系，本文就借用老师的图直观查看对应关系了：

  1. 卷积

在这里插入图片描述

  1. 池化
    在这里插入图片描述

3.激活
在这里插入图片描述

无所畏惧monkey
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
人工智能大作业
MrRookieX的博客
11-14 6366
人工智能作业人工智能大作业——讨论手写数字识别的几种实现方法一、实验目的二、实验环境三、实验原理3.1 线性判别(fisher判别)[^1]3.2 集成学习[^2]3.2.1 Baggingrandom forest3.2.2 Boostingadaboost四、实验步骤4.1 线性判别4.2 adaboost五、实验结果参考文献 人工智能大作业——讨论手写数字识别的几种实现方法 一、实验目的 用多种机器学习方法实现手写数字识别，并比较不同。 二、实验环境 2.1 Python 3.7.6 2.2 Anac
人工智能大作业_基于同义词林的语义相似度计算
05-28
人工智能大作业_基于同义词林的语义相似度计算 词义相似度计算在很多领域中都有广泛的应用，例如信息检索、 信息抽取、文本分类、词义排歧、基于实例的机器翻译等等。国内很 多论文主要是基于同义词林和知网来计算的...
人工智能基础作业_UNIT1
qq_29149761的博客
03-14 83
人工智能基础作业1
wwwsssdd的博客
04-30 1436
文章目录一、pycharm和pytorch安装二、pytorch实现反向传播1.链式求导法则2.读入数据总结 一、pycharm和pytorch安装 pycharm在官网https://www.jetbrains.com/pycharm/download/#section=windows进行下载，下载完成后正常安装即可。 pytorch可以在官网https://pytorch.org/get-started/locally/进行安装。 最新的pytorch的windows版本不支持CUDA-10.2，选择
AI+智能服务机器人应用基础（大作业报告）
apple_55903083的博客
10-12 409
（Odometry）的信息，对环境地图进行构建，并且对自身状态进行估计。因此它得输入应当包括激光雷达和里程计的数据，而输出应当有自身位置和地图。则会保存已经做好的地图到目录 ~/map 创建文件夹 mymap ，将生成的 map.pgm 与 map.yaml 存放进 mymap 修改 map.yaml 中map的文件路径为 image: map.pgm。SLAM需要机器人在未知的环境中逐步建立起地图，然后根据地区确定自身位置，从而进一步。在建好的地图之上，跑navigation。
人工智能大作业——五子棋
qq_45043734的博客
08-01 8941
前言： 我这个五子棋作业是参考： https://blog.csdn.net/wudingan/article/details/106812722 （实现了完整的人机对战，通俗易懂。） 我只是在此基础上做修改增加加入进入游戏界面，人人对战，回到主界面，重新开始游戏的一些小功能 使用pygame 主界面效果图 这个主界面嘛都是ps上去的，主要是为了好看，我们需要实现点击人机对战和人人对战两个按钮进入相应的界面，这个就需要在代码中添加这两个按钮对应的x,y范围。 1.导入必要库以及定义一些全局变量 2.定义一
人工智能基础 作业6
Rabbit_Gray的博客
05-24 508
本次来实现XO图形的识别 数据集 数据集要按照一定比例自行划分好训练集training_set和测试集test_set 代码 import torch from torch import nn, optim from torch.utils.data import DataLoader, Dataset from torchvision import datasets, transforms # 模型构建 class Net(nn.Module): def __init__(se
人工智能基础-作业1
m0_53173359的博客
04-28 1777
1.安装pycharm -链接安装pycharm教程 -安装成功页面 安装pytorch 链接微软官方安装pytorch教程 安装中… 安装成功 python实现反向传播 模型为w1xx+w2*x+b 参考代码 import torch x_data = [1, 2, 3] y_data = [2, 4, 6] # 三个tensor w1 = torch.tensor([1.0]) w1.requires_grad = True w2 = torch.tensor([2.0]) w2.requires
人工智能基础 作业3
weixin_59509642的博客
05-09 350
一、使用pytorch复现课上例题 # https://blog.csdn.net/qq_41033011/article/details/109325070 # https://github.com/Darwlr/Deep_learning/blob/master/06%20Pytorch%E5%AE%9E%E7%8E%B0%E5%8F%8D%E5%90%91%E4%BC%A0%E6%92%AD.ipynb # torch.nn.Sigmoid(h_in) import torch x1, x2 =
人工智能python实现pdf_Python人工智能基础.pdf
weixin_39624864的博客
11-28 433
目录Python人工智能基础-Python入门1.基础语法1.1.Python概述(了解)1.2.Python开发环境1.3.注释1.4.变量、标识符、命名、关键字1.5.数据类型及转换1.6.输入、输出、格式化符号1.7.运算符1.8.if条件判断1.9.项目实践1.10.测试1.11.作业2.循环、字符串、列表3.元组、字典4.函数5.文件操作6.面向对象7.异常处理、模块8.正则表达式9.排...
飞桨 AI studio——python基础课程作业实践一
qq_42811373的博客
12-15 984
作业一：输出 9*9 乘法口诀表(注意格式) 注意：提交作业时要有代码执行输出结果。 def table(): for i in range(1,10): for j in range(1,i+1): print('{}*{}={}'.format(j, i, i * j), end='\t') if j == i: print() 作业二：查找特定名称文件 遍历”Day1-homework”目录下文
人工智能期末大作业大合集+人工智能结课作业大合集.zip
06-10
人工智能期末大作业大合集+课程设计+结课作业大合集。根据作业要求，每个算法都有相应的算法介绍、实验代码、实验结果、实验总结。全部使用Python实现。 人工智能作业大合集总共分为三大部分，每部分由几个相关算法...
人工智能大作业/课程设计
12-25
人工智能大作业/课程设计 小白不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该...
人工智能大作业pacman满分代码
06-08
这是我们人工智能课程大作业，pacman吃豆人的代码实现，实测满分通过，代码有注释，易理解，欢迎大家一起学习
UCAS 人工智能基础课程大作业，冬奥会领域问答机器人.zip
03-18
人工智能（Artificial Intelligence，简称AI）是一种前沿的计算机科学技术，其核心目标是通过模拟、延伸和拓展人类智能来构建智能机器与系统。它融合了计算机科学、数学、统计学、心理学、神经科学等多个学科的知识...
从零实现Llama3中文版
wdn blog
05-26 832
从零实现Llama3中文版，该项目能在一台 16G RAM 的笔记本电脑上运行。
强化学习——学习笔记
qq_52302919的博客
05-27 1328
强化学习问题通常可以建模为一个马尔可夫决策过程，包括以下几个要素：1、状态集合 (State Set)：S；2、动作集合 (Action Set)：A；Ps′∣saPs′∣sa，描述在状态s下执行动作a后转移到状态s′s^′s′的概率；Rsas′Rsas′，描述在状态s 下执行动作a并转移到状态s′后获得的奖励。πa∣sπ (a∣s)πa∣s，描述智能体在状态s下选择动作a 的概率。
pytorch学习笔记5
最新发布
drarad的博客
06-02 765
前向钩子（forward hook）在模块的前向传播开始时触发，前向后钩子（forward pre-hook）在前向传播之前触发，反向钩子（backward hook）在反向传播过程中触发。总结来说，钩子提供了一种在 PyTorch 模型的执行过程中插入自定义代码的方法，使得用户可以灵活地调试、监控和扩展模型的功能。作用: 这是一个内部的 C 语言指针，指向张量在底层库（通常是 C++ 实现的 PyTorch 核心）中的具体数据结构。这些钩子可以在张量的梯度计算之前或之后执行自定义的操作。
AI开发初体验：昇腾加持，OrangePi AIpro 开发板
上周的博客
05-27 1277
因为工作需要，以及个人兴趣，本人经常购买开发板进行调试、学习，但具备AI计算的开发板，本人尚未体验过，究其原因，是因为自觉知识储备可能无法胜任AI的开发工作。然而，在体验了OrangePi AIpro 开发板之后，却大大改变了我的看法——AI时代，真的已经来临！OrangePi AIpro 开发板是香橙派联合华为精心打造的高性能 AI 开发板，其内置华为昇腾 AI 处理器，作为国产AI 芯片翘楚，实乃开发板的一大亮点！
cs188人工智能homework2
07-30
CS188人工智能作业2是一个关于搜索算法的作业。在这个作业中，学生将学习并实现一些经典的搜索算法，以解决问题或找到最优解。 作业要求学生实现以下几种搜索算法：深度优先搜索（DFS）、广度优先搜索（BFS）、A*搜索和骑士巡游问题（Knight's Tour Problem）的解决方案。 在深度优先搜索算法中，学生需要以深度优先的方式遍历搜索问题的状态空间，并找到问题的解决方案。在广度优先搜索算法中，学生需要以广度优先的方式进行搜索，逐层遍历状态空间并找到解决方案。在A*搜索算法中，学生需要评估问题状态的代价，并以此为基础进行搜索，以找到最优解决方案。最后，学生需要使用搜索算法来解决骑士巡游问题，即找到骑士遍历国际象棋棋盘上每个方格的路径。 完成作业需要学生具备基本的编程能力和对搜索算法的理解。学生可以使用Python编程语言来实现这些算法，并将结果通过测试用例进行验证。 通过完成CS188人工智能作业2，学生将能够熟练使用搜索算法解决问题，并进一步加深对人工智能领域的理解。这将为学生进一步学习和应用人工智能提供坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值