本文主要向大家介绍了如何用C语言浮点数据有损压缩算法，通过具体的内容向大家展示，希望对大家学习C语言有所帮助。

在几年前的时候在做修图APP算法的时候，

曾经一度想过对3D Lut 预设数据进行压缩，

主要用于提升用户体验。

关于3d lut算法开源的资源也挺多的，就不多做科普了。

有兴趣的朋友，可以去查阅下ffmepg项目相关实现代码。

最早接触3d lut算法是2014年逆向 VSCO Cam 胶片算法的时候，

当然一开始我也不知道它的算法是3d lut，

是反反复复编写各个版本，算法优化，

直到有一天我突然想起一个常量特别奇怪，

后来有一段时间在看3d lut算法资料的时候，觉得算法特别熟悉。

后来自然也就知道啥情况了。

那时候在做一款APP，考虑压缩预设资源的时候，

当时由于项目匆忙，采用LZ压缩算法，自然压缩比并不高。

导致预设文件偏大，有点占资源体积。

原来预想要做一下浮点类型的压缩算法的，这一拖，就没后文了。

很多人很好奇胶片滤镜算法，是怎么实现的，

网上流传了很多个版本，作为一名资深安全研究员，我就说一下大概情况。

早期绝大数APP采用了 2d lut去模拟 VSCO Cam的效果，

思路比较简单，就是做一个2D颜色映射表进行插值实现，一般是512*512*3 的颜色表，

GPUImage里面有具体实现，感兴趣的可以去看下，这里也不展开了。

我这边还保留着当年原汁原味的VSCO Cam胶片算法。

再到近些年，深度学习 神经网络大火，笔者在做手机端前向传播的时候，

再一次碰到类似的问题。

模型量化，模型压缩等等。

模型量化的思路其实也挺简单的，例如32位量化到16位，

或者量化到8位，通过降低精度获取一定的性能提升和资源压缩。

就量化一个操作，就可以做到既提升性能又压缩模型体积，

所以肯定是比较不错的方案。

当然在IOS下还可以考虑采用内存映射的方式，

将物理空间映射为内存空间，以减少内存占用之类的。

当然这种方式必须是操作系统的文件类型支持。

毫无疑问，再一次碰到浮点数据的压缩问题。

现在绝大多数深度学习模型都是采用32位浮点进行存储权重的。

但是很奇怪，好像没看到有谁针对浮点数据进行压缩处理。

难不成浮点数据真的没法压缩了？！

不然，不然，在之前做图像算法的时候，俺对频域算法特别感兴趣，

因为这种转换思维角度的处理方式，的确巧妙。

看了网上很多资料，感觉没多少人能用通俗的语言解释频域。

我就大言不惭，大话一番。

其实频域核心是频，也就是符合一定的频次规律。

有点像计数法，举个例子：八个8 可以记为88888888 也可以记为88，也可以直接记为8.

这就是频，而频域是什么？

频域或者说频率，其实就是一种描述特定频率波率概率乃至频域的表达方式。

换句更通俗的话来说，就是 基于特定表达标准进行计数。

而傅里叶变换也好，余弦变换也好，这里的变换其实就是指的一种表达方式。

有点像，你跟你女朋友约定一种暗号，例如抛个媚眼，表达的是，亲爱的，你懂的。

好了，解释暂告一段落，往下就有点儿童不宜了。

而最经典的压缩算法，莫过于jpeg，这个格式已经家喻户晓了。

虽然也有后起之秀 WebP FLIF 等格式，

但jpeg跟mp3一样成为一个时代的默认标记。

而jpeg就是一种基于dct8x8变换的压缩算法。

具体也不展开了，有兴趣可以去看看jpeg编解码相关。

例如:https://github.com/cpuimage/TinyJPEG

这铺垫有点长，所以是不是可以基于dct 8x8 对浮点数据进行有损压缩呢？

答案，没错就是这么简单粗暴。

 数据长度 :8*8*8

按照顺序从 0 - 511 填充数据。

这里给出一个参考数据：

zlib 压缩:
miniz.c version: 10.0.2
Compressed from 2048 to 730 bytes
Decompressed from 730 to 2048 bytes
 

dct+ zlib 压缩:
miniz.c version: 10.0.2
Compressed from 2048 to 116 bytes
Decompressed from 116 to 2048 bytes

如果符合一定的DCT 规律，dct+zlib 的压缩比，极高。

如果填充的数据是没有规律的随机数据，大多数情况下zlib压缩比高一些。

而jpeg编码中有另一个技巧，就是采用颜色空间，

RGB转换为YCBCR空间，来获取更高的压缩比。

当然也会有一定的信息损失，好像说得有点多了。

打住打住。。

附上完整示例代码：

#ifdef __cplusplusextern "C" {#endif

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include "miniz.h"

#include "dct.h"

#include <stdint.h>

int test_miniz(const unsigned char *s_pStr, uLong data_len) {

    int cmp_status;

    uLong src_len = data_len;

    uLong cmp_len = compressBound(src_len);

    uLong uncomp_len = src_len;

    uint8_t *pCmp, *pUncomp;

    printf("miniz.c version: %s\n", MZ_VERSION);

    // Allocate buffers to hold compressed and uncompressed data.

    pCmp = (mz_uint8 *) malloc((size_t) cmp_len);

    pUncomp = (mz_uint8 *) malloc((size_t) src_len);

    if ((!pCmp) || (!pUncomp)) {

        printf("Out of memory!\n");

        return EXIT_FAILURE;

    }

    // Compress the string.

    cmp_status = compress(pCmp, &cmp_len, (const unsigned char *) s_pStr, src_len);

    if (cmp_status != Z_OK) {

        printf("compress() failed!\n");

        free(pCmp);

        free(pUncomp);

        return EXIT_FAILURE;

    }

    printf("Compressed from %u to %u bytes\n", (mz_uint32) src_len, (mz_uint32) cmp_len);

    // Decompress.

    cmp_status = uncompress(pUncomp, &uncomp_len, pCmp, cmp_len);

    if (cmp_status != Z_OK) {

        printf("uncompress failed!\n");

        free(pCmp);

        free(pUncomp);

        return EXIT_FAILURE;

    }

    printf("Decompressed from %u to %u bytes\n", (mz_uint32) cmp_len, (mz_uint32) uncomp_len);

    // Ensure uncompress() returned the expected data.

    if ((uncomp_len != src_len) || (memcmp(pUncomp, s_pStr, (size_t) src_len))) {

        printf("Decompression failed!\n");

        free(pCmp);

        free(pUncomp);

        return EXIT_FAILURE;

    }

    free(pCmp);

    free(pUncomp);

    printf("Success.\n");

    return EXIT_SUCCESS;

}

int test_dct_miniz(float *data, uLong len) {

    uLong nCount = len / 64;

    float *in_data = data;

    for (int i = 0; i < nCount; i++) {

        DCT(in_data, in_data);

        in_data += 64;

    }

    test_miniz((const unsigned char *) data, len * sizeof(float));

    float *out_data = data;

    for (int i = 0; i < nCount; i++) {

        IDCT(out_data, out_data);

        out_data += 64;

    }

}

int main(int argc, char *argv[]) {

    printf("float data loss compression algorithm base DCT 8X8.\n");

    printf("DCT implementation by Thomas G. Lane.\n");

    printf("miniz implementation by Rich Geldreich.\n");

    ////developer.download.nvidia.com/SDK/9.5/Samples/vidimaging_samples.html#gpgpu_dct

    printf("blog://cpuimage.cnblogs.com/\n");

    int is_debug_output = 1;

    const uLong data_len = 8 * 8* 8;// blocksize

    float test_for_miniz[data_len];

    float test_for_dct[data_len];

    for (int i = 0; i < data_len; ++i) {

        test_for_miniz[i] = i;

    }

    memcpy(test_for_dct, test_for_miniz, data_len * sizeof(float));

    printf("\nonly miniz:\n");

    test_miniz((const unsigned char *) test_for_miniz, data_len * sizeof(float));

    printf("\nwith dct:\n");

    test_dct_miniz(test_for_dct, data_len);

    if (is_debug_output) {

        for (int i = 0; i < data_len; ++i) {

            if (test_for_miniz[i] != test_for_dct[i]) {

                printf("index %d: %f != %f \n", i, test_for_miniz[i], test_for_dct[i]);

            }

        }

    }

    printf("\n press any key to exit.\n");

    return EXIT_SUCCESS;

}

#ifdef __cplusplus

}#endif

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标编程语言C/C+频道！