• 计算一组Tensor的直方图C算法实现

    Tensor量化中，计算信息度损失的的一个重要算法叫做KL散度算法，关于其介绍请参考博客：

    模型量化中的KL散度扫盲_papaofdoudou的博客-CSDN博客_kl三度

    本文介绍其程序实现：

    首先构造一组TENSOR向量,维度为150528的列向量。

    观察其原始的直方图分布，其分布特点如下图所示：

    程序实现：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
    12. #define min(x,y) ({ \
    13.     typeof(x) _x = (x);    \
    14.     typeof(y) _y = (y);    \
    15.     (void) (&_x == &_y);    \
    16.     _x < _y ? _x : _y; })
    17.  
    18. int get_tensor_from_txt_file(char *file_path, float **buf)
    19. {
    20.     int len = 0;
    21.     static float *memory = NULL;
    22.     static int max_len = 10 * 1024 * 1024;
    23.     FILE *fp = NULL;
    24.  
    25.     if(memory == NULL)
    26.     {
    27.         memory = (float*) malloc(max_len * sizeof(float));
    28.     }
    29.     
    30.     if((fp = fopen(file_path, "r")) == NULL)
    31.     {
    32.         DBG("open tensor error.");
    33.         exit(-1);
    34.     }
    35.  
    36.     while(!feof(fp))
    37.     {
    38.         fscanf(fp, "%f", &memory[len ++]);
    39.     }
    40.  
    41.     *buf = (float*)malloc(len * sizeof(float));
    42.     if(len == 0 || *buf == NULL)
    43.     {
    44.         DBG("read tensor error, len %d, *buf %p", len, *buf);
    45.         exit(-1);
    46.     }
    47.     memcpy(*buf, memory, len * sizeof(float));
    48.  
    49.     fclose(fp);
    50.  
    51.     return len;
    52. }
    53.  
    54. int main(int argc, char **argv)
    55. {
    56.     FILE *file;
    57.  
    58.     DBG("in");
    59.  
    60.     if(argc != 3)
    61.     {
    62.         DBG("input error, you should use this program like that: program tensor binsnum.");
    63.         exit(-1);
    64.     }
    65.  
    66.     int tensor0_len;
    67.     float *tensor0_dat;
    68.     int bins = atoi(argv[2]);
    69.     
    70.     tensor0_len = 0;
    71.     tensor0_dat = NULL;
    72.  
    73.     tensor0_len = get_tensor_from_txt_file(argv[1], &tensor0_dat);
    74.     DBG("tensor len %d.", tensor0_len);
    75.  
    76.     float absmax = 0.f;
    77.     int i = 0;
    78.  
    79.     for(i = 0; i < tensor0_len + 1; i ++)
    80.     {
    81.         if(fabs(tensor0_dat[i]) > absmax)
    82.             absmax = fabs(tensor0_dat[i]);
    83.     }
    84.     
    85.     DBG("abs = %f.", absmax);
    86.  
    87.     int *histogram = malloc(bins * sizeof(int));
    88.     float *histogram_norm = malloc(bins * sizeof(float));
    89.     if(histogram == NULL || histogram_norm == NULL)
    90.     {
    91.         DBG("fatal error, malloc histogram failure.");
    92.         exit(-1);
    93.     }
    94.  
    95.     memset(histogram, 0x00, bins * sizeof(int));
    96.  
    97.     for(i = 0; i < tensor0_len; i ++)
    98.     {
    99.         if (tensor0_dat[i] == 0.f) continue;
    100.  
    101.         const int index = min((int)(fabs(tensor0_dat[i]) / absmax * bins), (bins - 1));
    102.         histogram[index] += 1;
    103.     }
    104.  
    105.     for(i = 0; i < bins; i ++)
    106.     {
    107.         DBG("histogram[%d] = %d.", i, histogram[i]);
    108.     }
    109.  
    110.     //直方图归一化
    111.     int sum = 0;
    112.  
    113.     for(i = 0; i < bins; i ++)
    114.     {
    115.         sum += histogram[i];
    116.         histogram_norm[i] = 0.f;
    117.     }
    118.  
    119.     for(i = 0; i < bins; i ++)
    120.         histogram_norm[i] = (float)((float)histogram[i])/(float)sum;
    121.  
    122.     for(i = 0; i < bins; i ++)
    123.     {
    124.         DBG("histogram[%d] = %f.", i, histogram_norm[i]);
    125.     }
    126.  
    127.     DBG("out");
    128.     return 0;
    129. }

    运行：

    3BINS：

     100BINS：

    100BINS的数据可视化：

     和上面有所差异，原因可能是程序中绝对值的处理，将负值也作为正值处理了。为了验证，我们找到这批数据中的最小值，它是负的，我们将其加上一个偏移，正好变为0，这样所有的值都变为了正数，平移数据范围不会影响直方图的分布，所以我们就可以验证我们的猜测是否正确。

    代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
    12. #define min(x,y) ({ \
    13.     typeof(x) _x = (x);    \
    14.     typeof(y) _y = (y);    \
    15.     (void) (&_x == &_y);    \
    16.     _x < _y ? _x : _y; })
    17.  
    18. int get_tensor_from_txt_file(char *file_path, float **buf)
    19. {
    20.     int len = 0;
    21.     static float *memory = NULL;
    22.     static int max_len = 10 * 1024 * 1024;
    23.     FILE *fp = NULL;
    24.  
    25.     if(memory == NULL)
    26.     {
    27.         memory = (float*) malloc(max_len * sizeof(float));
    28.     }
    29.     
    30.     if((fp = fopen(file_path, "r")) == NULL)
    31.     {
    32.         DBG("open tensor error.");
    33.         exit(-1);
    34.     }
    35.  
    36.     while(!feof(fp))
    37.     {
    38.         fscanf(fp, "%f", &memory[len ++]);
    39.     }
    40.  
    41.     *buf = (float*)malloc(len * sizeof(float));
    42.     if(len == 0 || *buf == NULL)
    43.     {
    44.         DBG("read tensor error, len %d, *buf %p", len, *buf);
    45.         exit(-1);
    46.     }
    47.     memcpy(*buf, memory, len * sizeof(float));
    48.  
    49.     fclose(fp);
    50.  
    51.     return len;
    52. }
    53.  
    54. int main(int argc, char **argv)
    55. {
    56.     FILE *file;
    57.  
    58.     DBG("in");
    59.  
    60.     if(argc != 3)
    61.     {
    62.         DBG("input error, you should use this program like that: program tensor binsnum.");
    63.         exit(-1);
    64.     }
    65.  
    66.     int tensor0_len;
    67.     float *tensor0_dat;
    68.     int bins = atoi(argv[2]);
    69.     
    70.     tensor0_len = 0;
    71.     tensor0_dat = NULL;
    72.  
    73.     tensor0_len = get_tensor_from_txt_file(argv[1], &tensor0_dat);
    74.     DBG("tensor len %d.", tensor0_len);
    75.  
    76.     float absmax = 0.f;
    77.     float min = 0.f;
    78.     int i = 0;
    79.  
    80.     for(i = 0; i < tensor0_len + 1; i ++)
    81. 	{
    82.         tensor0_dat[i] += 87.939552;
    83. 	}
    84.  
    85.     for(i = 0; i < tensor0_len + 1; i ++)
    86.     {
    87.         if(fabs(tensor0_dat[i]) > absmax)
    88.             absmax = fabs(tensor0_dat[i]);
    89.  
    90.         if(tensor0_dat[i] < min)
    91.             min = tensor0_dat[i];
    92.     }
    93.     
    94.     DBG("abs = %f, min %f.", absmax, min);
    95.  
    96.     int *histogram = malloc(bins * sizeof(int));
    97.     float *histogram_norm = malloc(bins * sizeof(float));
    98.     if(histogram == NULL || histogram_norm == NULL)
    99.     {
    100.         DBG("fatal error, malloc histogram failure.");
    101.         exit(-1);
    102.     }
    103.  
    104.     memset(histogram, 0x00, bins * sizeof(int));
    105.  
    106.     for(i = 0; i < tensor0_len; i ++)
    107.     {
    108.         if (tensor0_dat[i] == 0.f) continue;
    109.  
    110.         const int index = min((int)(fabs(tensor0_dat[i]) / absmax * bins), (bins - 1));
    111.         histogram[index] += 1;
    112.     }
    113.  
    114.     for(i = 0; i < bins; i ++)
    115.     {
    116.         DBG("histogram[%d] = %d.", i, histogram[i]);
    117.     }
    118.  
    119.     //直方图归一化
    120.     int sum = 0;
    121.  
    122.     for(i = 0; i < bins; i ++)
    123.     {
    124.         sum += histogram[i];
    125.         histogram_norm[i] = 0.f;
    126.     }
    127.  
    128.     for(i = 0; i < bins; i ++)
    129.         histogram_norm[i] = (float)((float)histogram[i])/(float)sum;
    130.  
    131.     for(i = 0; i < bins; i ++)
    132.     {
    133.         printf("%f\n", histogram_norm[i]);
    134.     }
    135.  
    136.     DBG("out");
    137.     return 0;
    138. }

    这次直方图曲线和本篇开头的直方图符合了：

    数据可视化部分的PYTHON代码：

    1. import numpy as np
    2. import linecache
    3. import matplotlib.pyplot as plt
    4.  
    5. filename = "output.tensor"
    6. cols = 1 # number of column
    7. divided_ch = ' ' # divided_character between numbers
    8.  
    9. def dat_to_matrix(filename):
    10.     file = open(filename)
    11.     lines = file.readlines()
    12.     rows = len(lines)
    13.     # print(rows)
    14.     # print(lines)
    15.     datamat = np.zeros(rows)
    16.     row = 0
    17.  
    18.     for line in lines:
    19.         line = line.strip().split(divided_ch) # strip remove block space in line
    20.         datamat[row:] = line[:]
    21.         row += 1
    22.  
    23.     return datamat
    24.  
    25.  
    26. data = dat_to_matrix(filename)
    27. # print(data)
    28. X=np.linspace(0,1,100)      # X轴坐标数据
    29. plt.figure(figsize=(8,6))   # 定义图的大小
    30. plt.plot(X,data)            # 绘制曲线图
    31. plt.show()

    总结：

    1.直方图平移后会被压缩，但是曲线的变化趋势不变，可以作计算导数的思想实验来验证这一点。

    2.对于AI训练和推理来说，数据本身的分布形状比数据本身要重要的多.

    当OFFSET过大的时候，以山峰高度为例，相当于我们选取的基础海平面太低，以至于无法体现地表山峰的高度趋势了，这个时候，计算的直方图会被压缩。如下图将OFFSET从87改为870

    产生的直方图为,对比上图，可以看到图像形状没有变化，但是被压缩了。

    证明很简单，设n>m>0.a > 0

    \frac{m}{n} \ ?\ \frac{a+m}{a+n}

    ?应该是什么呢？先通分。

    \\ \frac{m(a+n)}{n(a+n)} ? \frac{n(a+m)}{n(a+n)} \\ \because m(a+n)=ma+mn<na+mn=n(a+m) \\ \therefore \frac{m}{n} \ < \ \frac{a+m}{a+n}

    总结：

    很多时候，量化重要的一步是找出tensor的值域边界，得到每层tensor值的上下边界，在此基础上确定threhold。

    参考博客：

    使用NCNN的INT8量化方式进行推理_papaofdoudou的博客-CSDN博客_int8量化 ncnn

    结束 

  • 相关阅读:
    制定项目管理计划
    rsync远程同步
    1行代码提取6种TCGA表达矩阵和临床信息
    常见排序算法之选择排序
    【MATLAB】 辛几何模态分解信号分解+FFT傅里叶频谱变换组合算法
    C++实现轻量级RPC分布式网络通信框架
    校园棒球运动会运营策划案·棒球联盟
    javascript算法排序之希尔排序
    Windows c/c++开发环境安装以及配置VSCode
    MFC随记：AfxBeginThread创建工作线程
  • 原文地址：https://blog.csdn.net/tugouxp/article/details/125900447