[二]深度学习Pytorch-张量的操作：拼接、切分、索引和变换

已于 2022-03-31 21:38:48 修改
阅读量2.3k 收藏 3
点赞数 3
分类专栏： 深度学习Pyrotch 文章标签： python 深度学习 人工智能 pytorch 机器学习
于 2022-03-26 16:33:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanzhiwen2/article/details/123746158
版权

0. 往期内容

[一]深度学习Pytorch-张量定义与张量创建

[二]深度学习Pytorch-张量的操作：拼接、切分、索引和变换

[三]深度学习Pytorch-张量数学运算

[四]深度学习Pytorch-线性回归

[五]深度学习Pytorch-计算图与动态图机制

[六]深度学习Pytorch-autograd与逻辑回归

[七]深度学习Pytorch-DataLoader与Dataset(含人民币二分类实战)

[八]深度学习Pytorch-图像预处理transforms

[九]深度学习Pytorch-transforms图像增强(剪裁、翻转、旋转)

[十]深度学习Pytorch-transforms图像操作及自定义方法

深度学习Pytorch-张量的操作：拼接、切分、索引和变换

1. 张量拼接

1.1 torch.cat(tensors, dim=0)

torch.cat(tensors, dim=0, out=None)

(1)功能：将张量在第dim个维度上进行拼接；
(2)参数：
tensors: 张量序列；
dim: 要拼接的维度；
(3)代码示例：

# ======================================= example 1 =======================================
# torch.cat

# flag = True
flag = False

if flag:
    t = torch.ones((2, 3)) #创建一个2*3的张量

    #dim=0表示在第0个维度上进行拼接，输出为4*3张量，因为2+2=4，拼接的第0个维度：2
    t_0 = torch.cat([t, t], dim=0) 

    #dim=1表示在第1个维度上进行拼接，输出为2*6的张量，因为3+3=6，拼接的是第1个维度：3
    t_1 = torch.cat([t, t, t], dim=1) 

    #dim=1表示在第1个维度上进行拼接，输出为2*9的张量，因为3+3+3=9，拼接的是第1个维度：3
    t_2 = torch.cat([t, t, t], dim=1) 

    print("t_0:{} shape:{}\nt_1:{} shape:{}".format(t_0, t_0.shape, t_1, t_1.shape))

在这里插入图片描述在这里插入图片描述

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497]])
>>> torch.cat((x, x, x), 0)
tensor([[ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497],
        [ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497],
        [ 0.6580, -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497]])
>>> torch.cat((x, x, x), 1)
tensor([[ 0.6580, -1.0969, -0.4614,  0.6580, -1.0969, -0.4614,  0.6580,
         -1.0969, -0.4614],
        [-0.1034, -0.5790,  0.1497, -0.1034, -0.5790,  0.1497, -0.1034,
         -0.5790,  0.1497]])

1.2 torch.stack(tensors, dim=0)

torch.stack(tensors, dim=0, out=None)

(1)功能：将张量在新创建的dim维度上进行拼接；
(2)参数：
tensors: 张量序列；
dim: 新创建的维度，如果维度已经存在，则其他维度顺移；
(3)代码示例：

# ======================================= example 2 =======================================
# torch.stack

# flag = True
flag = False

if flag:
    t = torch.ones((2, 3))

    #在新的维度上进行拼接，dim=2，由于t只有0、1维，因此会创建第2个维度，并在第二个维度进行拼接。
    #输出为2*3*2的张量，最后一个2是新创建的。
    t_stack = torch.stack([t, t], dim=2) 
    
    #由于t中已经存在0维，因此会重新创建第0维，原先的维度顺移（原来的第0维移为第1维，第1维移为第2维）
    #输出为2*2*3,第一个2是新创建的。
    t_stack = torch.stack([t, t], dim=0)

    #由于t中已经存在0维，因此会重新创建第0维，原先的维度顺移（原来的第0维移为第1维，第1维移为第2维）
    #输出为3*2*3,第一个2是新创建的。
    t_stack = torch.stack([t, t, t], dim=0)

    print("\nt_stack:{} shape:{}".format(t_stack, t_stack.shape))

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2. 张量切分

2.1 torch.chunk(input, chunks, dim=0)

torch.chunk(input, chunks, dim=0)

(1)功能：将张量在第dim维度上进行平均切分；
(2)返回值：张量列表；
(3)参数：
input: 要进行切分的张量；
chunks: 要切分的份数；
dim: 要切分的维度；
(4)注意事项：
若不能整除，最后一份张量小于其他张量；
(5)代码示例：

# ======================================= example 3 =======================================
# torch.chunk

# flag = True
flag = False

if flag:
    a = torch.ones((2, 5)) #创建2*5的张量
    list_of_tensors = torch.chunk(a, dim=1, chunks=2) #在第1个维度（5）进行切分，并分为2份。

    for idx, t in enumerate(list_of_tensors):
        #第1个张量：2*3,第二个张量：2*2,这是因为不能整除时，最后一个张量的尺寸会比前面的小，5/2向上取整=3
        print("第{}个张量：{}, shape is {}".format(idx+1, t, t.shape))

    a = torch.ones((2, 7)) #创建2*7的张量
    list_of_tensors = torch.chunk(a, dim=1, chunks=3) #在第1个维度（7）进行切分，并分为3份。

    for idx, t in enumerate(list_of_tensors):
        #第1个张量：2*3,第二个张量：2*3,第三个张量：2*1，这是因为不能整除时，最后一个张量的尺寸会比前面的小，7/3向上取整=3
        print("第{}个张量：{}, shape is {}".format(idx+1, t, t.shape))

在这里插入图片描述在这里插入图片描述

>>> torch.arange(11).chunk(6)
(tensor([0, 1]),
 tensor([2, 3]),
 tensor([4, 5]),
 tensor([6, 7]),
 tensor([8, 9]),
 tensor([10]))
>>> torch.arange(12).chunk(6)
(tensor([0, 1]),
 tensor([2, 3]),
 tensor([4, 5]),
 tensor([6, 7]),
 tensor([8, 9]),
 tensor([10, 11]))
>>> torch.arange(13).chunk(6)
(tensor([0, 1, 2]),
 tensor([3, 4, 5]),
 tensor([6, 7, 8]),
 tensor([ 9, 10, 11]),
 tensor([12]))

2.4 torch.split(tensor, split_size_or_sections, dim=0)

torch.split(tensor, split_size_or_sections, dim=0)

(1)功能：将张量在第dim维度上进行切分；
(2)返回值：张量列表；
(3)参数：
input: 要进行切分的张量；
split_size_or_sections: 为int时，表示每一份的长度；为list时，按照list中的元素进行切分；
dim: 要切分的维度；
(4)代码示例：

# ======================================= example 4 =======================================
# torch.split

# flag = True
flag = False

if flag:
    t = torch.ones((2, 5))

    #把张量t在第一个维度（5）上切成每份长度为2的张量，2+2+1=5
    #第一个张量：2*2，第二个张量：2*2，第三个张量：2*1
    list_of_tensors = torch.split(t, 2, dim=1)  
    for idx, t in enumerate(list_of_tensors):
        print("第{}个张量：{}, shape is {}".format(idx+1, t, t.shape))

    #根据list来决定每份的长度，因此第一个张量长度为2，第二个为1，第三个为2，2+1+2=5，即list的元素之和一定等于要切维度的大小，否则会报错。
    #第一个张量：2*2，第二个张量：2*1，第三个张量：2*2
    list_of_tensors = torch.split(t, [2, 1, 2], dim=1)
    for idx, t in enumerate(list_of_tensors):
        print("第{}个张量：{}, shape is {}".format(idx, t, t.shape))

在这里插入图片描述在这里插入图片描述

>>> a = torch.arange(10).reshape(5,2)
>>> a
tensor([[0, 1],
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9]])

>>> torch.split(a, [1,4])
(tensor([[0, 1]]),
 tensor([[2, 3],
         [4, 5],
         [6, 7],
         [8, 9]]))

3. 张量索引

3.1 torch.index_select(input, dim, index)

torch.index_select(input, dim, index, out=None)

(1)功能：在维度dim上，按照index索引数据；
(2)返回值：根据index索引数据拼接成的张量；
(3)参数：
input: 要索引的张量；
dim: 要索引的维度；
index: 要索引数据的序号；
(4)注意事项：索引的数据类型必须是torch.long;
(5)代码示例：

# ======================================= example 5 =======================================
# torch.index_select

# flag = True
flag = False

if flag:
    t = torch.randint(0, 9, size=(3, 3)) #生成数值为[0,9)均匀分布的整数，大小为3*3的张量
    #t=[[4,5,0], [5,7,1], [2,5,8]]
    idx = torch.tensor([0, 2], dtype=torch.long)    # 生成[0,2]张量，索引的数据类型必须是torch.long

    #在第0个维度上找idx（第0个、第2个）的张量，输出为[[4,5,0],[2,5,8]]
    t_select = torch.index_select(t, dim=0, index=idx)
    print("t:\n{}\nt_select:\n{}".format(t, t_select))

在这里插入图片描述

>>> x = torch.randn(3, 4)
>>> x
tensor([[ 0.1427,  0.0231, -0.5414, -1.0009],
        [-0.4664,  0.2647, -0.1228, -1.1068],
        [-1.1734, -0.6571,  0.7230, -0.6004]])
>>> indices = torch.tensor([0, 2])
>>> torch.index_select(x, 0, indices)
tensor([[ 0.1427,  0.0231, -0.5414, -1.0009],
        [-1.1734, -0.6571,  0.7230, -0.6004]])
>>> torch.index_select(x, 1, indices)
tensor([[ 0.1427, -0.5414],
        [-0.4664, -0.1228],
        [-1.1734,  0.7230]])

3.2 torch.masked_select(input, mask)

torch.masked_select(input, mask, out=None)

(1)功能：按照mask中的True来索引元素；
(2)返回值：一维张量；
(3)参数：
input: 要索引的张量；
mask: 与input同形状的布尔型张量；
(4)代码示例：

# ======================================= example 6 =======================================
# torch.masked_select

# flag = True
flag = False

if flag:

    t = torch.randint(0, 9, size=(3, 3)) #t=[[4,5,0], [5,7,1], [2,5,8]]

    #ge大于等于，gt大于，le小于等于，lt小于
    mask = t.ge(5)  #d大于等于5返回True，小于5返回False
    #mask=[[False, True, False],[True, True, False],[False, True, True]]
    t_select = torch.masked_select(t, mask)
    print("t:\n{}\nmask:\n{}\nt_select:\n{} ".format(t, mask, t_select))
    #t_select=[5,5,7,5,8]

在这里插入图片描述

>>> x = torch.randn(3, 4)
>>> x
tensor([[ 0.3552, -2.3825, -0.8297,  0.3477],
        [-1.2035,  1.2252,  0.5002,  0.6248],
        [ 0.1307, -2.0608,  0.1244,  2.0139]])
>>> mask = x.ge(0.5)
>>> mask
tensor([[False, False, False, False],
        [False, True, True, True],
        [False, False, False, True]])
>>> torch.masked_select(x, mask)
tensor([ 1.2252,  0.5002,  0.6248,  2.0139])

4. 张量变换

4.1 torch.reshape(input, shape)

torch.reshape(input, shape)

(1)功能：变换张量的形状；
(2)注意事项：当张量在内存中是连续时，新张量与input共享数据内存；
(3)参数：
input: 要变换的张量；
shape: 新张量的形状；
(4)代码示例：

# ======================================= example 7 =======================================
# torch.reshape

# flag = True
flag = False

if flag:
    t = torch.randperm(8) #生成从0到7的随机数列
    #t为张量[5,4,2,6,7,3,1,0]

    t_reshape = torch.reshape(t, (2, 4))    #重新形状为2*4的张量
    print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
    #t_reshape为张量[[5,4,2,6],[7,3,1,0]]

    #重新形状为第0维*4的张量，第0维的数值自动计算，第0维=8/4=2
    t_reshape = torch.reshape(t, (-1, 4))    
    print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
    #t_reshape为张量[[5,4,2,6],[7,3,1,0]]

    #重新形状为第0维*2*2的张量，第0维的数值自动计算，第0维=8/2/2=2
    t_reshape = torch.reshape(t, (-1, 2, 2))    
    print("t:{}\nt_reshape:\n{}".format(t, t_reshape))
    #输出为[[[5,4],[2,6]],[[7,3],[1,0]]]

    t[0] = 1024 #t的第0个数值改为1024
    print("t:{}\nt_reshape:\n{}".format(t, t_reshape)) 
    #t为张量[1024,4,2,6,7,3,1,0]
    #输出为[[[1024,4],[2,6]],[[7,3],[1,0]]]

    #两者的内存地址一样，是共享的
    print("t.data 内存地址:{}".format(id(t.data)))
    print("t_reshape.data 内存地址:{}".format(id(t_reshape.data)))

在这里插入图片描述在这里插入图片描述在这里插入图片描述

>>> a = torch.arange(4.)
>>> torch.reshape(a, (2, 2))
tensor([[ 0.,  1.],
        [ 2.,  3.]])
>>> b = torch.tensor([[0, 1], [2, 3]])
>>> torch.reshape(b, (-1,))
tensor([ 0,  1,  2,  3])

4.2 torch.transpose(input, dim0, dim1)

torch.transpose(input, dim0, dim1)

(1)功能：交换张量的两个维度；
(2)*参数：
input: 要交换的张量；
dim0: 要交换的维度；
dim1: 要交换的维度；
(3)代码示例：

# ======================================= example 8 =======================================
# torch.transpose

# flag = True
flag = False

if flag:
    # torch.transpose
    t = torch.rand((2, 3, 4)) #数值为(0,1)均匀分布，大小为2*3*4的张量

    #输出为2*4*3，交换第一维和第二维
    t_transpose = torch.transpose(t, dim0=1, dim1=2) 
    print("t shape:{}\nt_transpose shape: {}".format(t.shape, t_transpose.shape))

在这里插入图片描述

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 1.0028, -0.9893,  0.5809],
        [-0.1669,  0.7299,  0.4942]])
>>> torch.transpose(x, 0, 1)
tensor([[ 1.0028, -0.1669],
        [-0.9893,  0.7299],
        [ 0.5809,  0.4942]])

4.3 torch.t(input)

torch.t(input)

(1)功能：用于2维张量转置，等价于torch.transpose(input, 0, 1)；
(2)代码示例：

>>> x = torch.randn(())
>>> x
tensor(0.1995)
>>> torch.t(x)
tensor(0.1995)
>>> x = torch.randn(3)
>>> x
tensor([ 2.4320, -0.4608,  0.7702])
>>> torch.t(x)
tensor([ 2.4320, -0.4608,  0.7702])
>>> x = torch.randn(2, 3)
>>> x
tensor([[ 0.4875,  0.9158, -0.5872],
        [ 0.3938, -0.6929,  0.6932]])
>>> torch.t(x)
tensor([[ 0.4875,  0.3938],
        [ 0.9158, -0.6929],
        [-0.5872,  0.6932]])

4.4 torch.squeeze(input)

torch.squeeze(input, dim=None, out=None)

(1)功能：移除长度为1的维度（轴）；
(2)*参数：
dim: 若dim=None，则移除所有长度为1的轴；若指定dim，当且仅当该轴长度为1时，移除对应的dim；
(3)代码示例：

# ======================================= example 9 =======================================
# torch.squeeze

# flag = True
flag = False

if flag:
    t = torch.rand((1, 2, 3, 1)) #创建1*2*3*1的张量
    t_sq = torch.squeeze(t) #dim=None，所以移除所有长度为1的轴，输出为2*3
    t_0 = torch.squeeze(t, dim=0) #第0维为1维则移除第0维，输出为2*3*1
    t_1 = torch.squeeze(t, dim=1) #第1为不是1维则不移除，输出为1*2*3*1
    print(t.shape)
    print(t_sq.shape)
    print(t_0.shape)
    print(t_1.shape)

在这里插入图片描述

>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])

4.5 torch.unsqueeze(input, dim)

torch.unsqueeze(input, dim)

(1)功能：根据dim扩展维度；
(2)*参数：
dim: 要扩展的维度；
(3)代码示例：

>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1,  2,  3,  4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],
        [ 2],
        [ 3],
        [ 4]])

在这里插入图片描述在这里插入图片描述

yanzhiwen2
关注
专栏目录
pytorch-3dunet:用pytorch编写的用于体积语义分割的3D U-Net模型
05-05
该代码允许对U-Net进行以下方面的训练：语义分割（二进制和多类）和回归问题（例如降噪，学习解卷积）。二维U网也可以训练标准2D U-Net，有关示例配置，请参见 。 只需确保将单例z维保留在H5数据集中（即(1, Y, X)...
【深度学习】特征融合的重要方法 | 张量的拼接 | torch.cat()函数 | torch.add(函数
weixin_46274756的博客
11-15 9610
【深度学习】特征融合的重要方法 | 张量的拼接 | torch.cat()函数 | torch.add(函数
深度学习入门：张量拼接操作
apprentice_eye的博客
04-24 1068
简单的介绍一下张量的拼接操作
深度学习张量拼接，索引操作
最新发布
DGFfdAf的博客
08-11 361
torch.stack 函数可以将两个张量根据指定的维度叠加起来.torch.cat 函数可以将两个张量根据指定的维度拼接起来.
PyTorch常用张量切割和拼接方法（torch.chunk、torch.split、torch.cat和torch.stack用法详解）
m0_60882889的博客
10-22 9803
1、torch.chunk 首先看官方文档的解释： 功能：尝试将张量拆分为指定数量的数据块，每个数据块都是输入张量的一个视图。 例子： >>> torch.arange(5).chunk(3) (tensor([0, 1]), tensor([2, 3]), tensor([4])) >>> torch.arange(6).chunk(3) (tensor([0, 1]), tensor([2, 3]), tensor([4, 5])) >
【pytorch + matplotlib】将若干张图像拼接成一张图像（附代码，以FashionMNIST为例）（subplot 和 subplots区别）
热门推荐
miracleoa的博客
04-21 1万+
文章目录一、在pytorch中紧凑画出子图（1）在一行里画出多张图像和对应标签1）代码2）效果展示色偏原因分析：（2）以矩阵的形式展示多张图片1）代码2）效果展示二、在matplotlib中紧凑画出子图（1）区分 subplot 和 subplots（2）代码（3）效果展示 一、在pytorch中紧凑画出子图 （1）在一行里画出多张图像和对应标签 1）代码 import matplotlib.py...
基于深度学习的图像全景拼接算法综述
Littro Innovations
12-20 2012
然而，仍然存在许多问题和挑战需要进一步解决，如特征提取的准确性和鲁棒性、拼接缝的处理、运算效率和计算资源消耗等。在图像拼接中，注意力机制可以用于提高特征提取的准确性和鲁棒性，进而提高拼接结果的准确性和鲁棒性。在RNN模型中，可以通过引入注意力机制来提高特征提取的准确性和鲁棒性，进而提高拼接结果的准确性和鲁棒性。本文将对基于深度学习的图像全景拼接算法进行综述，介绍不同算法的原理、优缺点和应用场景，并展望未来的研究方向。基于特征的算法通过提取图像中的特征点，并利用特征点之间的匹配关系进行图像配准和拼接。
pytorch-YOLOv4:YOLOv4的PyTorch，ONNX和TensorRT实现
03-19
pytorch-YOLOv4 YOLOv4的最小PyTorch实现。 Paper Yolo v4： ： 源代码： : 更多详细信息： : 推理 火车 莫卡奇 ├── README.md ├── dataset.py dataset ├── demo.py demo to run pytorch --> tool/...
pytorch-doc-zh：Pytorch中文文档
02-05
PyTorch中文教程 PyTorch是一个针对深度学习，并且使用GPU和CPU来优化的张量库（张量库）介绍欢迎任何人参与和完善：一个人可以走的很快，但是一群人却可以走的更远。组织重建[网站] GitHub Pages（国外）： : Gitee...
pytorch-tutorial：面向深度学习研究人员的PyTorch教程
02-04
该存储库提供了用于深度学习研究人员学习教程代码。 在本教程中，大多数模型都是用不到30行代码实现的。 在开始本教程之前，建议您先完成《 。 目录 1.基础 2.中级 3.进阶 4.公用事业 入门 $ git clone ...
pytorch-Deep-Learning：深度学习（使用PyTorch）
02-03
深度学习（使用PyTorch） 现在，此笔记本存储库有一个，可以在该以视频和文本格式找到所有课程资料。 入门为了能够进行练习，您将需要一台装有Miniconda（Anaconda的最小版本）和几个Python软件包的笔记本电脑。 ...
毕业设计：基于深度学习的全景图像拼接系统 人工智能 算法
Hai_Lang_IT的博客
02-15 2598
毕业设计：基于深度学习的全景图像拼接系统采用深度学习算法对多张图像进行特征提取和匹配，实现了全景图像的自动拼接。通过训练深度神经网络模型，系统能够学习到图像之间的空间关系和变换参数，从而精确地将图像拼接在一起。该系统可广泛应用于各种场景的全景图像拼接任务，有效提升了拼接的准确性和效率。为计算机毕业设计提供了一个创新的方向，结合了深度学习和图像处理技术，为计算机专业、软件工程专业、人工智能专业、大数据专业的毕业生提供了一个具有挑战性和创新性的研究课题。
【论文笔记】用于图像拼接的基于深度学习的图像矩形化算法
prask的博客
05-24 3158
图像拼接矩形化的目的是解决图像拼接后产生不规则边界的问题。现有的图像拼接矩形化方法通常分为两个阶段：第一个阶段是搜索一个初始网格，也就是在拼接图像上放置一个规则的网格，用来描述图像上每个点的位置；第二个阶段是优化一个目标网格，也就是在初始网格的基础上进行一些变形，使得网格边缘尽可能地与矩形边界对齐。然后，通过将拼接图像从初始网格变换到目标网格，就可以得到矩形图像。这个过程叫做网格变形或网格扭曲。
深度学习pytorch——拼接与拆分（持续更新）
2201_76139143的博客
03-17 793
使用条件：合并的dim的size可以不同，但是其它的dim的size必须相同。语法：cat([tensor1,tensor2],dim = n) # 将tensor1和tensor2的第n个维度合并。
python-OpenCV图像拼接（两张有重叠部分的图像拼接）
1900的博客
06-02 6842
opencv、图像拼接
毕业设计：基于深度学习的视频图像拼接系统
Hai_Lang_IT的博客
04-12 1410
毕业设计：基于ORB的视频图像拼接系统通过结合深度学习和计算机视觉技术，实现了自动化的视频片段拼接和全景图像生成。我们使用ORB算法进行关键特征点提取和匹配，通过准确的图像配准和融合算法，将多个视频片段拼接成连贯的全景图像。为计算机毕业设计提供了一个创新的方向，结合了深度学习和计算机视觉技术，为毕业生提供了一个有意义的研究课题。对于计算机专业、软件工程专业、人工智能专业、大数据专业的毕业生而言，提供了一个具有挑战性和创新性的研究课题。
pytorch拼接函数：torch.stack()和torch.cat()详解
sweet_tea_的博客
01-04 4168
pytorch拼接函数：torch.stack()和torch.cat()详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值