压缩感知学习笔记（二）——MP与OMP

最新推荐文章于 2023-12-28 12:14:10 发布
最新推荐文章于 2023-12-28 12:14:10 发布
阅读量1.4k 收藏 14
点赞数 1
分类专栏： 压缩感知 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43522927/article/details/107922893
版权

压缩感知初入门小白，如有错误，欢迎指正交流~

匹配追踪（MP）与正交匹配追踪（OMP）

原理

在上篇博文中，指出当前压缩感知中常用的重构算法，其中贪婪算法中有使用广泛的两种算法，即匹配追踪算法（Matching Pursuit，MP）和正交匹配追踪算法（Orthogonal Matching Pursuit，OMP）。本文对以上两种算法进行总结，用于存档~

提出

匹配追踪算法（MP）起初提出是基于稀疏分解，在压缩感知概念还未被提出之前，稀疏分解要解决的问题是在冗余字典A中选出k列，用这k列的线性组合近似表达待稀疏分解信号y，可以表示为y=Aθ，求θ；
而压缩感知所要解决的问题是事先存在一个θ和矩阵A，然后得到y=Aθ（压缩观测），即在已知y和A的情况下要重构θ。二者在解决的问题上基本一致，都是已知y和A求θ。

即：已知传感矩阵A={ai}(i=1,2…N)，其中ai代表的是一个列向量，即每一列称作一个原子。我们认为观测向量y是由A中的原子构成，而θ即可看作是每个原子对y的贡献，即系数。而已知y和A求θ，就是求每个原子对y的贡献程度。

核心思想：二者的核心思想基本一致，即遍历字典A中的每一个原子ai，根据内积最大化的原则找到与贡献最大的原子，作为当前的匹配原子。之后从信号中减去与该原子相近的成分，对剩余部分（即残差）与其他原子求贡献，找到贡献次大的原子，依次迭代，直至满足迭代停止条件（最大次数/迭代阈值等），停止迭代。

区别：二者的区别在于同一个原子的成分是否会被重复选择。OMP保证了残差与所有选择过的原子正交，即同一个原子不会被二次选择。而MP中不能保证正交，所以会有已选择过的原子的相近成分被二次选择，增加了收敛速度。

步骤

匹配追踪（MP）

Input：传感矩阵A（MxN），观测向量y（Mx1）
Output：稀疏系数向量s（Mx1）
Step1：初始化：残差r=y，系数x[N]={0}；
Step2：计算A中每个原子ai与残差r的内积<ai，r>。求出内积最大的原子ai，并记录这个原子对应的索引 i；
Step3：计算θ：系数向量θ的第i个元素θi=<ai，r>。（可以理解为残差在di这个方向上的投影）；
Step4：更新残差r：更新后残差r(i+1)=当前残差ri-di*θi;
Step5：判断迭代终止条件你，不满足则转至Step2。

正交匹配追踪（OMP）

Input：传感矩阵A（MxN），观测向量y（Mx1）
Output：稀疏系数向量s（Mx1）
Step1：初始化：残差r=y，系数x[N]={0}，被选择原子所构成的字典子集S=Ø（每次迭代被选中的原子添加进这个子集作为新的一列）；
Step2：计算A中每个原子ai与残差r的内积<ai，r>。求出内积最大的原子ai，并记录这个原子对应的索引 i。将ai添加到字典子集S中（每迭代一次，S中就会增加一个新的原子，这个加入的新原子就是此次迭代中发现的与残差内积最大的那个原子）；
Step3：计算θ：即y=Sθ的最小二乘解（最小二乘解保证了残差与选择过的原子正交）。计算得到的最小二乘解维度和S一样，是小于稀疏系数θ的维度的，这个只需要把最小二乘解中的各个元素赋值到θ的对应元素就行了（第一步中记录了被选中原子的索引，就是为了实现这个功能）;
最小二乘解
注：区别：MP稀疏系数的计算是每次迭代只计算系数向量θ中的一个元素θi；而OMP中每次都要根据新加入的原子所更新的子集字典S重新计算整个系数向量θ(θ为向量)
Step4：更新残差r：更新后残差r(i+1)=当前残差ri-Sθ;
Step5：判断迭代终止条件你，不满足则转至Step2。

代码实现

MP较为简单，这里只放上了OMP的C语言实现代码：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include <windows.h>
#include <math.h>
#include <assert.h>

//定义矩阵数据类型
typedef struct
{
	double **mat;
	int m, n;
}matrix;

matrix OMP(matrix y, matrix A, int t);

//为矩阵申请存储空间
void initial_mat(matrix *T, int m, int n)
{
	int i;
	(*T).mat = (double**)malloc(m * sizeof(double*));
	for (i = 0; i < m; i++)
	{
		(*T).mat[i] = (double*)malloc(n * sizeof(double));
	}
	(*T).m = m;
	(*T).n = n;
}
//初始化矩阵
void initzero(matrix *T, int m, int n)
{
	int i, j;
	initial_mat(T, m, n);
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			(*T).mat[i][j] = 0;
		}
	}
}
//释放存储空间
void destroy(matrix *T)
{
	int i;
	for (i = 0; i < (*T).m; i++)
	{
		free((*T).mat[i]);
	}
	free((*T).mat);
}
//变换为单位矩阵
void set_identity_matrix(matrix m) {
	int i;
	int j;
	assert(m.m == m.n);
	for (i = 0; i < m.m; ++i) {
		for (j = 0; j < m.n; ++j) {
			if (i == j) {
				m.mat[i][j] = 1.0;
			}
			else {
				m.mat[i][j] = 0.0;
			}
		}
	}
}
//矩阵转置
void transpose_matrix(matrix input, matrix output)
{
	int i, j;
	assert(input.m == output.n);
	assert(input.n == output.m);
	for (i = 0; i < input.m; i++)
	{
		for (j = 0; j < input.n; j++)
		{
			output.mat[j][i] = input.mat[i][j];
		}
	}
}
//矩阵相乘
void multiply_matrix(matrix a, matrix b, matrix output)
{
	int i, j, k;
	assert(a.n == b.m);
	assert(output.m == a.m);
	assert(output.n == b.n);
	//printf("\n");
	for (i = 0; i < output.m; i++)
	{
		for (j = 0; j < output.n; j++)
		{
			output.mat[i][j] = 0.0;
			for (k = 0; k < a.n; k++)
			{
				//printf("a%lf b%lf", a.mat[i][k], b.mat[k][j]);
				output.mat[i][j] += a.mat[i][k] * b.mat[k][j];
			}
			//printf("%lf ", output.mat[i][j]);
		}
		//printf("\n");
	}
}
/* 交换矩阵的两行 */
void swap_rows(matrix m, int r1, int r2) {
	double *tmp;
	assert(r1 != r2);
	tmp = m.mat[r1];
	m.mat[r1] = m.mat[r2];
	m.mat[r2] = tmp;
}
/*矩阵某行乘以一个系数  */
void scale_row(matrix m, int r, double scalar) {
	int i;
	assert(scalar != 0.0);
	for (i = 0; i < m.n; ++i) {
		m.mat[r][i] *= scalar;
	}
}

/* Add scalar * row r2 to row r1. */
void shear_row(matrix m, int r1, int r2, double scalar) {
	int i;
	assert(r1 != r2);
	for (i = 0; i < m.n; ++i) {
		m.mat[r1][i] += scalar * m.mat[r2][i];
	}
}

//矩阵求逆
int matrix_inversion(matrix input, matrix output)
{
	int i, j, r;
	double scalar, shear_needed;
	assert(input.m == input.n);
	assert(input.m == output.m);
	assert(input.m == output.n);

	set_identity_matrix(output);

	/* Convert input to the identity matrix via elementary row operations.
	   The ith pass through this loop turns the element at i,i to a 1
	   and turns all other elements in column i to a 0. */

	for (i = 0; i < input.m; ++i) {

		if (input.mat[i][i] == 0.0) {
			/* We must swap m to get a nonzero diagonal element. */

			for (r = i + 1; r < input.m; ++r) {
				if (input.mat[r][i] != 0.0) {
					break;
				}
			}
			if (r == input.m) {
				/* Every remaining element in this column is zero, so this
				   matrix cannot be inverted. */
				return 0;
			}
			swap_rows(input, i, r);
			swap_rows(output, i, r);
		}

		/* Scale this row to ensure a 1 along the diagonal.
		   We might need to worry about overflow from a huge scalar here. */
		scalar = 1.0 / input.mat[i][i];
		scale_row(input, i, scalar);
		scale_row(output, i, scalar);

		/* Zero out the other elements in this column. */
		for (j = 0; j < input.m; ++j) {
			if (i == j) {
				continue;
			}
			shear_needed = -input.mat[j][i];
			shear_row(input, j, i, shear_needed);
			shear_row(output, j, i, shear_needed);
		}
	}
	return 1;
}
matrix OMP(matrix y, matrix A, int t)
{
	int M = A.m = y.m;
	int N = A.n;
	matrix s;
	initzero(&s, N, 1);
	matrix At;
	initzero(&At, M, t);
	matrix Pos_s;
	initzero(&Pos_s, 1, t);
	matrix r_n;
	initzero(&r_n, M, 1);
	//printf("\nr_n列向量：\n");
	for (int i = 0; i < M; i++)
	{
		r_n.mat[i][0] = y.mat[i][0];
		//printf("%lf ", r_n.mat[i][0]);
	}
	matrix s_ls;
	initzero(&s_ls, t, 1);
	for (int d = 0; d < t; d++)
	{
		matrix A_T;
		initzero(&A_T, N, M);
		transpose_matrix(A, A_T);
		matrix product;
		initzero(&product, N, 1);
		multiply_matrix(A_T, r_n, product);
		/*printf("\n product列向量：\n");
		for (int i = 0; i < N; i++)
		{
			printf("%lf ", product.mat[i][0]);
		}*/
		int pos = 0;
		double max = fabs(product.mat[0][0]);
		for (int i = 1; i < N; i++)
		{
			if (max < fabs(product.mat[i][0]))
			{
				max = fabs(product.mat[i][0]);
				pos = i;
			}
		}//printf("\n pos：%d\n",pos);
		matrix Atd;
		initzero(&Atd, M, d+1);
		for (int i = 0; i < M; i++)
		{
			Atd.mat[i][d] = A.mat[i][pos];
		}
		Pos_s.mat[0][d] = pos;
		for (int i = 0; i < M; i++)
		{
			A.mat[i][pos] = 0;
		}
		matrix Atd_T;
		initzero(&Atd_T, d+1, M);
		transpose_matrix(Atd, Atd_T);
		matrix temp1;
		initzero(&temp1, d+1, d+1);
		multiply_matrix(Atd_T, Atd, temp1);
		/*printf("\n乘积：\n");
		for (int i = 0; i < d+1; i++)
		{
			for (int j = 0; j < d+1; j++)
			{
				printf("%lf ", temp1.mat[i][j]);
			}
		}*/
		matrix temp2;
		initzero(&temp2, d+1, d+1);
		matrix_inversion(temp1, temp2);
		/*printf("\n求逆：\n");
		for (int i = 0; i < d+1; i++)
		{
			for (int j = 0; j < d+1; j++)
			{
				printf("%lf ", temp2.mat[i][j]);
			}
		}*/
		matrix temp3;
		initzero(&temp3, d+1, M);
		multiply_matrix(temp2, Atd_T, temp3);
		/*printf("\n乘ATD_T：\n");
		for (int i = 0; i < d + 1; i++)
		{
			for (int j = 0; j < M; j++)
			{
				printf("%lf ", temp3.mat[i][j]);
			}
		}*/
		matrix s_ls_d;
		initzero(&s_ls_d, d + 1, 1);
		multiply_matrix(temp3, y, s_ls_d);
		/*printf("\ns：\n");
		for (int i = 0; i < d + 1; i++)
		{
			for (int j = 0; j < 1; j++)
			{
				printf("%lf ", s_ls_d.mat[i][j]);
			}
		}*/
		for (int i = 0; i < d + 1; i++)
		{
			s_ls.mat[i][0] = s_ls_d.mat[i][0];
		}
		matrix temp4;
		initzero(&temp4, M, 1);
		multiply_matrix(Atd, s_ls_d, temp4);
		for (int i = 0; i < M; i++)
		{
			r_n.mat[i][0] = y.mat[i][0] - temp4.mat[i][0];
		}
	}
	/*printf("\ns_ls:\n");
	for (int i = 0; i < t; i++)
	{
		printf("%lf ", s_ls.mat[i][0]);
	}*/
	for (int i = 0; i < t; i++)
	{
		int index = Pos_s.mat[0][i];
		//printf("[%d]%lf ", index, Pos_s.mat[0][i]);
		//printf("\n");
		s.mat[index][0] = s_ls.mat[i][0];
		//printf("[%d]%lf ",index, s_ls.mat[i][0]);
	}
	return s;
}
void main()
{
	matrix A;
	initzero(&A, 2, 5);
	A.mat[0][0] = 0.0591; A.mat[0][1] = -1.6258; A.mat[0][2] = 2.6052; A.mat[0][3] = 0.2570; A.mat[0][4] = -1.1464; 
	A.mat[1][0] = -1.4669; A.mat[1][1] = -1.9648; A.mat[1][2] = 0.9724; A.mat[1][3] = -0.9742; A.mat[1][4] = 0.5476; 
	printf("传感矩阵A:\n");
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%lf ", A.mat[i][j]);
		}printf("\n");
	}
	matrix y;
	initzero(&y, 2, 1);
	y.mat[0][0] = 7.9498;
	y.mat[1][0] = 2.9672;
	printf("\n观测值y:\n");
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 1; j++)
		{
			printf("%lf ", y.mat[i][j]);
		}printf("\n");
	}
	int t = 1;
	matrix s;
	initzero(&s, 5, 1);
	s = OMP(y, A, t);
	matrix PSi;
	initzero(&PSi, 5, 5);
	for (int i = 0; i < 5; i++)
	{
		PSi.mat[i][i] = 1;
	}
	printf("\n稀疏基PSi:\n");
	for (int i = 0; i < 5; i++)
	{
		for (int j = 0; j <5; j++)
		{
			printf("%lf ", PSi.mat[i][j]);
		}printf("\n");
	}
	matrix x_r;
	initzero(&x_r, 5, 1);
	multiply_matrix(PSi, s, x_r);

	printf("\ns:\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%lf ", s.mat[i][0]);
	}
	matrix x;
	initzero(&x, 5, 1);
	x.mat[2][0] = 3.0515;
	printf("\n原始信号x:\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%lf ", x_r.mat[i][0]);
	}

	printf("\n恢复信号x_r:\n");
	for (int i = 0; i < 5; i++)
	{
		printf("%lf ", x_r.mat[i][0]);
	}

	getchar();
}

结果

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

参考

【1】一分钟了解”匹配追踪算法（Matching Pursuit，MP） 和 正交匹配追踪算法（Orthogonal Matching Pursuit，OMP）“
【2】匹配追踪MP和正交匹配追踪OMP算法
【3】知乎：正交匹配追踪算法OMP
【4】知乎：匹配追踪算法（match pursuit, MP）实现信号的稀疏表示

公木
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于压缩感知的MP和OMP算法
10-28
基于压缩感知的MP和OMP算法matlab代码实现。
MP算法和OMP算法及其思想
热门推荐
逍遥剑客的专栏
04-17 17万+
主要介绍MP(Matching Pursuits)算法和OMP(Orthogonal Matching Pursuit)算法[1]，这两个算法虽然在90年代初就提出来了，但作为经典的算法，国内文献(可能有我没有搜索到)都仅描述了算法步骤和简单的应用，并未对其进行详尽的分析，国外的文献还是分析的很透彻，所以我结合自己的理解，来分析一下写到博客里，算作笔记。 1. 信号的稀疏表示(sparse re
MP和OMP算法
10-24
匹配追踪MP、正交匹配追踪算法OMP，稀疏表示里的基本算法
压缩感知OMP算法
10-19
压缩感知OMP算法，一个很经典的算法，很容易在上面修改实现类似算法
OMP.zip_OMP 压缩感知_omp_压缩感知 OMP
09-19
压缩感知理论中正交匹配追踪(OMP)算法的程序
MP/OMP
luojiaao的博客
09-27 2705
MP算法是一个贪婪算法 MP的目的：是为了求出用那几个基向量来表示一个向量，并且求出对应的系数。 MP思想：我就疯狂的把向量往基向量上映射，映射一次就得到一个残差，继续把残差往基向量上映射，继续得到残差，继续映射。如果残差足够小，我就把这个东西忽略了，然后把之前在基向量映射过系数的加起来，我们就可以用基向量近似表示一个向量了（前提是忽略了足够小的残差） OMP算法是保证了 ...
匹配追踪MP和正交匹配追踪OMP
aixdm的博客
12-28 903
近期看了一些匹配追踪MP和正交匹配跟踪OMP的相关论文和博文，现在将自己的理解简记于此，仅供参考。
matlab施密特正交化,浅谈压缩感知（十九）：MP、OMP与施密特正交化
weixin_42503456的博客
03-21 761
浅谈压缩感知(十九)：MP、OMP与施密特正交化关于MP、OMP的相关算法与收敛证明，这里仅简单陈述算法流程及二者的不同之处。主要内容：MP的算法流程及其MATLAB实现OMP的算法流程以及MATLAB实现MP与OMP的区别施密特正交化与OMP的关系一、MP(匹配追踪)的算法流程：二、MP的MATLAB实现：%MP：匹配追踪算法%dictionary:超完备字典%x:待表示信号%M=...
8.正交匹配跟踪 Orthogonal Matching Pursuit (OMP)s
alex的博客
08-26 3061
OrthogonalMatchingPursuit and orthogonal_mp 实现了一个用来逼近在非零系数的个数上加约束的线性模型的拟合的OMP算法(比如L 0 pseudo-norm) 和 Least Angle Regression最小角回归 一样，作为一个前向特征选择方法，OMP可以用一个固定非零的数来逼近最优的解向量: 或者说正交匹配算法可以针对一个特殊的误差而不是
正交匹配追踪算法OMP（Orthogonal Matching Pursuit）
赫夫曼树的博客
02-20 1万+
正交匹配追踪算法OMP（Orthogonal Matching Pursuit） 本文主要基于文献《Orthogonal Matching Pursuit for Sparse Signal Recovery With Noise》编写而成。主要讲述OMP算法基本步骤和思想，后续会介绍OMP算法在Bounded noise和Gaussian noise下的终止条件的选择。 Introd...
压缩感知——OMP算法
03-08
MATLAB仿真压缩感知恢复算法，采用OMP算法。文件解压后包含两个文件，OMP.m为OMP算法的函数，OMPtest.m调用OMP函数
压缩感知应用omp算法_压缩感知代码学习_
10-01
简单的压缩感知入门学习代码，希望能帮助到大家
匹配追踪算法（MP）简介
weixin_34342207的博客
10-11 1864
图像的稀疏表征 分割原始图像为若干个\[\sqrt{n} \times \sqrt{n}\]的块. 这些图像块就是样本集合中的单个样本\(y = \mathbb{R}^n\). 在固定的字典上稀疏分解\(y\)后，得到一个稀疏向量. 将所有的样本进行表征一户，可得原始图像的稀疏矩阵. 重建样本\(y = \mathbb{R}^n\)时，通过原子集合即字典\(\mathrm{D} = \{d_i\}...
机器学习强基计划9-1：图解匹配追踪(MP)与正交匹配追踪(OMP)算法
FRIGIDWINTER的博客
06-19 2195
本文串讲字典学习的基本概念：字典学习、稀疏表示、稀疏编码，并介绍了稀疏编码的两种经典算法——匹配追踪MP与正交匹配追踪OMP算法的基本原理
OMP算法笔记
qq_35973773的博客
06-20 3万+
OMP算法笔记欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 OMP算法整理（以...
正交匹配追踪(OMP)算法
xufeifei26的专栏
04-07 1078
压缩观测y=Φx，其中y为观测所得向量M×1，x为原信号N×1（Mx一般不是稀疏的，但在某个变换域Ψ是稀疏的，即x=Ψθ，其中θ为K稀疏的，即θ只有K个非零项。此时y=ΦΨθ，令A=ΦΨ，则y=Aθ。         (1) y为观测所得向量，大小为M×1         (2)x为原信号，大小为N×1         (3)θ为K稀疏的，是信号在x在某变换域的稀疏表示         (
Matlab实现压缩感知重建算法：ROMP正则化的正交匹配追踪算法
qq_41982200的博客
10-21 1734
ROMP正则化的正交匹配追踪算法 ROMP算法是一种贪婪的压缩感知重建算法，在OMP的基础上加入了正则化过程。此外，相比于OMP算法，ROMP在每次迭代过程中选择与残差最相关的m个列向量。下面是Deanna Needell and Roman Vershynin的文章中给出的RMOP的算法。 在正则化过程，需要寻找索引集合的所有子集，在这里可以使用Matlab中的ff2n函数实现。对于正则化条件，只用满足u中的最大元素绝对值小于最小元素绝对值的2倍即可。 本文中用高斯随机矩阵作为测量矩阵，待观测目标信号长
压缩感知笔记——动态模态分解（DMD）
weixin_43522927的博客
08-12 9138
压缩感知初入门小白，如有错误，欢迎指正交流~ 动态模态分解（DMD）前言特征值分解奇异值分解（SVD）动态模态分解（DMD）参考 今天在阅读论文时，文中设计到较多动态模态分解的知识，因此学习了一下，记录一哈~ 前言 动态模态分解DMD其思想与机器学习中的PCA降维比较类似，而PCA中的核心是奇异值分解SVD，奇异值分解是特征值分解的推广，因此本文从特征值分解开始，延伸到动态模态分解。 特征值分解 首先放上数学表示： 【注】A为方阵！其中Q是A的特征向量组成的矩阵，而∑是一个对角矩阵，对角线元素是A的特征值
omp压缩感知python
最新发布
04-09
OMP（Orthogonal Matching Pursuit）是一种压缩感知（Compressed Sensing）算法，用于稀疏信号的恢复。在Python中，可以使用scikit-learn库来实现OMP压缩感知算法。 首先，你需要安装scikit-learn库。可以使用以下命令进行安装： ``` pip install scikit-learn ``` 接下来，你可以使用以下代码示例来实现OMP压缩感知算法： ```python from sklearn.linear_model import OrthogonalMatchingPursuit # 创建OMP对象 omp = OrthogonalMatchingPursuit(n_nonzero_coefs=5) # 设置稀疏系数的数量 # 输入数据 X = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] y = [1, 2, 3] # 使用OMP进行拟合 omp.fit(X, y) # 获取稀疏系数 coef = omp.coef_ print("稀疏系数：", coef) # 预测结果 pred = omp.predict(X) print("预测结果：", pred) ``` 在上述代码中，我们首先导入了`OrthogonalMatchingPursuit`类，然后创建了一个OMP对象。通过设置`n_nonzero_coefs`参数，我们可以指定稀疏系数的数量。接下来，我们输入训练数据`X`和目标值`y`，并使用`fit`方法进行拟合。最后，我们可以通过`coef_`属性获取稀疏系数，并使用`predict`方法进行预测。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值