稀疏表示中KL1p库的配置及Demo

最新推荐文章于 2022-10-05 21:39:04 发布
最新推荐文章于 2022-10-05 21:39:04 发布
阅读量2.6k 收藏 5
点赞数 2
分类专栏： 图像处理 工具 文章标签： Kl1p 稀疏表示 压缩感知 L1求解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/computerme/article/details/50087299
版权

最近打算在研究中尝试稀疏编码。稀疏表示的理论知识这里不具体补充，有兴趣的可以查看下面这篇用稀疏表示做人脸识别的文章，讲得很清楚。
http://blog.csdn.net/xiaoshengforever/article/details/14002843

稀疏表示中的关键是求解L2范数或者L1范数。L2范数的求解很简单，一个公式就搞定了; L1范数的求解就要复杂多了，求解的方式也有很多种。笔者做了实验后发现用L1求解出的结果确实比用L2求解出的结果稀疏多了。
通常求解L1范数都要借助第三方包。网上求解L1的MATLAB包比较多，但是C++包却相对很少，搜索后发现了KL1p这个好东西。

kl1p是一个压缩感知方面的C++库，里面封装了很多压缩感知方法，在稀疏表（SRC）示中主要是借助它来求取l1范数最小化问题。它的官方：http://kl1p.sourceforge.net/home.html 目前的版本是0.4.2

KL1p的配置

  1. 下载
    从上述官网下载KL1p包，不能访问的话可以从这里下载。下载后解压到D:\KL1p-0.4.2目录下。
  2. 编译生成库文件
    在目录D:\KL1p-0.4.2\build\win下用VS2010打开KLab.vcxproj文件进行编译，注意在Debug模式和Release模式下都要进行编译。编译成功后在D:\KL1p-0.4.2\bin\win目录会生成两个库文件，分别是KLab.lib和KLab_d.lib。带_d的库文件表示用于Debug。
    这里写图片描述
  3. 配置VS
    配置主要分为头文件配置和库文件配置。
    配置头文件：新建一个项目，然后点击项目属性，在“配置属性->C/C++->常规”中找到附加包含目录。然后添加如下图所示的几个目录。
    这里写图片描述
    配置库文件： 在属性对话框“配置属性->连接器->常规”中找到“附加库目录”，在其中加入以下条目：D: \KL1p-0.4.2\bin\win；
    这里写图片描述
    然后在属性对话框“配置属性->链接器->输入”的“附加依赖项”中，加入以下条目：
    KLab_d.lib（Release中则用KLab.lib）
    至此，配置已经完成，可以直接编代码测试了！！！
  4. 修改运行时库（可选）
    在完成前面三部的配置后，有可能编译代码时出现链接错误，编译不成功的情况。此时还需要修改一下运行时库。在属性对话框中“配置属性->C/C++ ->代码生成”中找到“运行库“，选择“多线程调试 (/MTd)”
    这里写图片描述

说明：从KL1p的配置可以看到，在KL1p在求解矩阵时实际上是通过Armadillo库来实现的，关于Armadillo库的矩阵操作手册可在这个网站查询：
http://arma.sourceforge.net/docs.html

最后给一个完整Demo程序 

//KL1p Demo
#include"armadillo"
#include <KL1pInclude.h>
#include <KL1p.h>

using namespace std;
using namespace kl1p;
using namespace arma;
int main()
{
    arma::mat featureMat;   //839*156
    featureMat.load("LBPPCANorFeatures.csv",csv_ascii);  
    arma::mat x0;          //1*156
    x0.load("test.csv",csv_ascii);
    //在读取的两个csv文件中，一个样本的特征占一行，所以需要取转置
    arma::mat A1 = featureMat.t(); 
    arma::mat y = x0.t();

    std::cout<<"Start of KL1p compressed-sensing example."<<std::endl;
    std::cout<<"Try to determine a sparse vector x "<<std::endl;
    std::cout<<"from an underdetermined set of linear measurements y=A*x, "<<std::endl;
    std::cout<<"where A is a random gaussian i.i.d sensing matrix."<<std::endl;

    klab::UInt32 n = A1.n_rows;     // Size of the original signal x0.
    klab::DoubleReal alpha = 0.5;   // Ratio of the cs-measurements.
    klab::DoubleReal rho = 0.1;     // Ratio of the sparsity of the signal x0.
    klab::UInt32 m = klab::UInt32(alpha*n); // Number of cs-measurements.
    klab::UInt32 k = klab::UInt32(rho*n);   // Sparsity of the signal x0 (number of non-zero elements).
    klab::UInt64 seed = 0;                  // Seed used for random number generation (0 if regenerate random numbers on each launch).
    bool bWrite = true;                 // Write signals to files ?


    // Display signal informations.
    std::cout<<"=============================="<<std::endl;
    std::cout<<"N="<<n<<" (signal size)"<<std::endl;
    std::cout<<"M="<<m<<"="<<std::setprecision(5)<<(alpha*100.0)<<"% (number of measurements)"<<std::endl;
    std::cout<<"K="<<k<<"="<<std::setprecision(5)<<(rho*100.0)<<"% (signal sparsity)"<<std::endl;
    std::cout<<"=============================="<<std::endl;

    kl1p::TMatrixOperator<klab::DoubleReal> * matrix = new kl1p::TMatrixOperator<klab::DoubleReal>(A1);
    klab::TSmartPointer<kl1p::TOperator<klab::DoubleReal, klab::DoubleReal> > * A2 =new klab::TSmartPointer<kl1p::TOperator<klab::DoubleReal, klab::DoubleReal> >(matrix);
    klab::TSmartPointer<kl1p::TOperator<klab::DoubleReal, klab::DoubleReal> >  A = *A2;

    klab::DoubleReal tolerance = 1e-3;  // Tolerance of the solution.
    arma::Col<klab::DoubleReal> x;      // Will contain the solution of the reconstruction.

    klab::KTimer timer;

    // Compute Basis-Pursuit.
    std::cout<<"[BasisPursuit] Start."<<std::endl;
    timer.start();
    kl1p::TBasisPursuitSolver<klab::DoubleReal> bp(tolerance);
    bp.solve(y, A, x);
    timer.stop();
    std::cout<<"[BasisPursuit] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<bp.iterations()<<std::endl;
    if(bWrite)
        x.save("BasisPursuit-Signal.csv",csv_ascii);  // Write solution to a file.

    // Compute OMP.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[OMP] Start."<<std::endl;
    timer.start();
    kl1p::TOMPSolver<klab::DoubleReal> omp(tolerance);
    omp.solve(y, A, k, x);
    timer.stop();
    std::cout<<"[OMP] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<omp.iterations()<<std::endl;
    if(bWrite)
        x.save("OMP-Signal.csv",csv_ascii);  // Write solution to a file.

    // Compute ROMP.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[ROMP] Start."<<std::endl;
    timer.start();
    kl1p::TROMPSolver<klab::DoubleReal> romp(tolerance);
    romp.solve(y, A, k, x);
    timer.stop();
    std::cout<<"[ROMP] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<romp.iterations()<<std::endl;
    if(bWrite)
        x.save("ROMP-Signal.csv",csv_ascii);  // Write solution to a file.

    // Compute CoSaMP.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[CoSaMP] Start."<<std::endl;
    timer.start();
    kl1p::TCoSaMPSolver<klab::DoubleReal> cosamp(tolerance);
    cosamp.solve(y, A, k, x);
    timer.stop();
    std::cout<<"[CoSaMP] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<cosamp.iterations()<<std::endl;
    if(bWrite)
        x.save("CoSaMP-Signal.csv",csv_ascii);  // Write solution to a file.

    // Compute Subspace-Pursuit.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[SubspacePursuit] Start."<<std::endl;
    timer.start();
    kl1p::TSubspacePursuitSolver<klab::DoubleReal> sp(tolerance);
    sp.solve(y, A, k, x);
    timer.stop();
    std::cout<<"[SubspacePursuit] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<sp.iterations()<<std::endl;
    if(bWrite)
        x.save("SubspacePursuit-Signal.csv",csv_ascii);     // Write solution to a file.

    // Compute SL0.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[SL0] Start."<<std::endl;
    timer.start();
    kl1p::TSL0Solver<klab::DoubleReal> sl0(tolerance);
    sl0.solve(y, A, x);
    timer.stop();
    std::cout<<"[SL0] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<sl0.iterations()<<std::endl;
    if(bWrite)
        x.save("SL0-Signal.csv",csv_ascii); // Write solution to a file.

    // Compute AMP.
    std::cout<<"------------------------------"<<std::endl;
    std::cout<<"[AMP] Start."<<std::endl;
    timer.start();
    kl1p::TAMPSolver<klab::DoubleReal> amp(tolerance);
    amp.solve(y, A, x);
    timer.stop();
    std::cout<<"[AMP] Done - SNR="<<std::setprecision(5)<<klab::SNR(x, x0)<<" - "
        <<"Time="<<klab::UInt32(timer.durationInMilliseconds())<<"ms"<<" - "
        <<"Iterations="<<amp.iterations()<<std::endl;
    if(bWrite)
        x.save("AMP-Signal.csv",csv_ascii); // Write solution to a file

    system("pause");
    return 0;
}

程序的执行结果如下：
这里写图片描述
从结果可以看到，不同的算法所需的求解时间不同。
下面详细看看不同算法求解出的结果。
BasicPursuit的计算结果：
Basis Pursuit
OMP的求解结果：
这里写图片描述
ROMP的求解结果：
这里写图片描述
CoSaMP的求解结果：
这里写图片描述
SubspacePursuit的求解结果：
这里写图片描述
SL0的求解结果：
这里写图片描述
AMP的求解结果：
这里写图片描述

从以上结果可以看到，不同的算法求解出的结果稀疏度有较大的差别。

完成Demo程序及数据下载地址：
http://download.csdn.net/detail/computerme/9309285

Reference:
http://blog.csdn.net/jianjian1992/article/details/49387477 例子讲解
http://blog.csdn.net/u013088062/article/details/44566667 配置过程
http://blog.csdn.net/xiaoshengforever/article/details/14002843 人脸识别

IT修道者
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KL1p Demo程序
11-29
KL1p求解稀疏表示的Demo程序，里面包括测试的数据。详细的介绍参考博客http://blog.csdn.net/computerme/article/details/50087299
kl1p-0.4.2-sources
11-29
其中，KL1p是一个在C++编程语言中实现的压缩感知库，它专门用于解决稀疏表示问题，特别是通过求解l1范数最小化问题来实现。 首先，我们要理解稀疏表示的概念。在信号处理领域，稀疏表示是指寻找一个信号的简洁表示...
稀疏表示中压缩感知库Kl1p的配置方法
陈俊岭的程序员之路（公众号求关注，方便交流）
03-23 4030
如果觉得这篇文章对您有所启发，欢迎关注我的公众号，我会尽可能积极和大家交流，谢谢。 1 浅谈稀疏表示和压缩感知写这篇博客是应为需要用稀疏表示做人脸识别（当时还没有做完，效果也还不清楚），要求用C++实现，理所应当想到应该借用opencv这个开源工具，可惜发现仅仅opencv还是不够，需要用到压缩感知，详见：http://blog.csdn.net/hechenghai/article/detail...
稀疏优化L1范数最小化问题求解之基追踪准则(Basis Pursuit)——原理及其Python实现
程序必须为人类阅读而编写，并且仅仅碰巧可以让机器执行
04-04 6192
文章目录一、前言二、问题重述三、构造 ℓ1\ell_1ℓ1​ 范数四、ℓ1\ell_1ℓ1​ 范数最小化问题转换为线性规划问题五、基于linprog的基追踪Python代码六、运行测试七、总结 一、前言 本文针对压缩重构感知中的稀疏优化问题，实现了对其 L1 范数最小化问题 的求解，文章内容较长，请耐心看完，代码部分在本文第五章。 二、问题重述 考虑线性方程组求解问题： Ax=b(1) Ax = b \tag{1} Ax=b(1) 其中向量 x∈Rn×1, b∈Rm×1x \in R^{n\t
压缩感知重构算法综述-学习笔记
崔洪振367
03-11 2万+
作者：李珅、马彩文、李艳、陈萍 压缩感知理论：对于稀疏或可压缩的信号，能够以远低于奈奎斯特频率对其进行采样，并通过设计重构算法来精确的恢复信号。 文章工作： 1、介绍压缩感知理论的基本框架，讨论该理论关于信号压缩的采样过程； 2、综述了压缩感知理论的重构算法，，比较了最优化算法和贪婪算法； 3、讨论了压缩感知理论重构算法未来的研究重点。 问题一：一般来说，压缩感知涉及三个比较重要的层面 1、信号稀疏域的选取，是压缩感知理论的基础和前提； 2、观测矩阵的选取；（已证明：大部分具有一致分布.
[python刷题模板] 稀疏表（ST）
最新发布
liuliangcan的博客
10-05 1290
st模板
计算机视觉-稀疏表示MATLAB源码
04-05
稀疏表示（Sparse Representation）也叫作稀疏编码（Sparse Coding）,就是用字典中元素的线性组合去表示测试样本。 信号的稀疏表示并不是新的东西。很早就一直有在利用这一特性。例如，最简单的JPEG图像压缩算法。...
宽带信号的稀疏表示及检测.m
07-03
利用MATLAB实现了宽带信号的稀疏表示，用分数级傅里叶变换实现宽带LFM信号的稀疏表示，并且用正交匹配追踪（OMP）算法实现信号的检测
chapter2_稀疏表示_
10-03
综上所述，"chapter2_稀疏表示_"这一章节将带领我们深入学习小波和小波包在图像稀疏表示中的应用，了解它们如何帮助我们理解和处理图像数据。通过理解和掌握这些理论与技术，我们可以更好地设计和实现图像处理算法，...
压缩感知重构算法之基追踪(Basis Pursuit, BP)
彬彬有礼的专栏
07-21 6万+
题目：压缩感知重构算法之基追踪(Basis Pursuit, BP)         除匹配追踪类贪婪迭代算法之外，压缩感知重构算法另一大类就是凸优化算法或最优化逼近方法，这类方法通过将非凸问题转化为凸问题求解找到信号的逼近，其中最常用的方法就是基追踪(Basis Pursuit, BP)，该方法提出使用l1范数替代l0范数来解决最优化问题，以便使用线性规划方法来求解[1]。
基于稀疏表示的高光谱图像分类omp算法demo
03-26
基于稀疏表示的高光谱图像分类omp算法demo
python计算稀疏表示的TF-IDF
Bryan__的专栏
04-02 4112
使用sklean的计算方法，这种结果是稠密矩阵，如果数据集太大，计算结果将会占满内存，或者直接报MemeryError的错误。 tfidf详细计算参考：https://blog.csdn.net/Eastmount/article/details/50323063 import jieba import jieba.posseg as pseg import os import ...
python实现稀疏矩阵+代码注释
weixin_42259833的博客
04-07 940
直接上代码： #!/usr/bin/env python # -*- coding:utf-8 -*- # 序列转为稀疏矩阵 # 输入：序列 # 输出：indices非零坐标点，values数据值，shape稀疏矩阵大小 import numpy as np def sparse_tuple_from(sequences, dtype=np.int32): indices = [] values = [] for n, seq in enumerate(sequences)
安装Python的稀疏表示软件包SPORCO和SPAMS
Zzhoudao的博客
04-19 2780
SPORCO是一个卷积稀疏编码软件包 安装起来也是相当简单apt-get install libfftw3-dev apt-get install python3-tk pip3 install sporco安装完可以测试一下cd /usr/local/share/doc/sporco-0.1.4/examples python3 demo_elnet.py SPAMS是一个解决众多稀疏模型的优化软件包
稀疏表示
golden_kangaroo的专栏
10-13 1230
稀疏域模型(Sparse-Land Model)即信号的稀疏表示，它意欲用尽可能少的非0系数表示信号的主要信息，从而简化信号处理问题的求解过程。稀疏域模型可如表达式(1)所示，其中y∈R^n为待处理信号，A∈R^(n×m)为基函数字典，x∈R^m为稀疏表示向量， ||x||_0≪m。||x||_0为x的稀疏度，它表示x中非0稀疏的个数。                   y=Ax       
Python Sklearn库常用操作
丑小鸭
08-10 2万+
  Python sklearn库是一个丰富的机器学习库，里面包含内容太多，这里对一些工程里常用的操作做个简要的概述，以后还会根据自己用的进行更新。 1、LabelEncoder 简单来说 LabelEncoder 是对不连续的数字或者文本进行按序编号，可以用来生成属性/标签 from sklearn.preprocessing import LabelEncoder encoder=La...
KL散度的含义与性质
热门推荐
最佳损友
06-09 8万+
       在概率论或信息论中，KL散度( Kullback–Leibler divergence)，又称相对熵（relative entropy)，是描述两个概率分布P和Q差异的一种方法。它是非对称的，这意味着D(P||Q) ≠ D(Q||P)。特别的，在信息论中，D(P||Q)表示当用概率分布Q来拟合真实分布P时，产生的信息损耗，其中P表示真实分布，Q表示P的拟合分布。有人将KL散度称为KL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值