基于C语言库进行tensor反量化和文本化几例

已于 2022-08-14 13:13:48 修改
阅读量994 收藏
点赞数 7
分类专栏： 数学 嵌入式系统 文章标签： 目标检测 深度学习 人工智能
于 2021-11-28 09:38:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tugouxp/article/details/121587342
版权

概要：

工作中遇到量化类型和反量化以及数据在二进制和文本形式之间的转换以及持久化操作比较多，核心是字符串类型和数值类型之间的互转，总结记录如下：

字符串转数值型

字符串转数值型分为两种情况：

字符串转整型：

头文件：stdlib.h

原型：

int atoi (const char *); 
long atol (const char *); 
long long atoll (const char *); 

字符串转浮点型：

头文件：stdlib.h

double atof (const char *);

int scanf(const char *__restrict, ...);

int sscanf(const char *__restrict, const char *__restrict, ...);

int fscanf(FILE *__restrict, const char *__restrict, ...);

在musl libc中的声明：

数值类型转字符串：

头文件：stdlib.h

int sprintf(char *__restrict, const char *__restrict, ...); 

int ptsname_r(int, char *, size_t);
char *ecvt(double, int, int *, int *);
char *fcvt(double, int, int *, int *);
char *gcvt(double, int, char *);   

用例：

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    double a = 123.45111111;
    double b = -1234.5666666;
    char ptr[20] = {0};
    int decpt, sign;

    char *str1 = gcvt(a, 20, ptr);
    printf("a value=%s\n", str1);
    char *str2 = gcvt(b, 20, ptr);
    printf("b value=%s\n", str2);

    return 0;
}

VIP模型的反量化操作中的应用如下，反量化公式为：

\\ FP = (Q-ZP)*Scale = Q*Scale +(-ZP)*Scale = Qantum * Scale + FP_{bias}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)

static void dump_memory(uint8_t *buf, int32_t len)
{
    int i;

    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}

static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;

    result = (val - (uint8_t)zeropoint) * scale;

    return result;
}

int main(int argc, char **argv)
{
	FILE *file;
	double scale;
	int zeropoint;

	DBG("in");

	if(argc != 4)
	{
		DBG("input error, you should use this program like that: program xxxx.dat scale zeropoint.");
		exit(-1);
	}

	scale = atof(argv[2]);
	zeropoint = atoi(argv[3]);

	DBG("scale %f, zeropoint %d.", scale, zeropoint);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}

	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);

	unsigned char *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}

	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);

	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}

	dump_memory(p, 32);
	dump_memory(p + filelen - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);

	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}


	// anti-quanlization && convert to text and store.
	
#define BUF_SIZE  32
	int iter;
	double res;
	char buf[BUF_SIZE];
	int count;

	for(iter = 0; iter < filelen; iter ++)
	{
		char *str;

		memset(buf, 0x00, BUF_SIZE);
		res = uint8_to_fp32(p[iter], zeropoint, scale);
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		str[len + 0] = '\r';
		str[len + 1] = '\n';
		str[len + 2] = '\0';
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}

	fflush(outensor);
	fsync(fileno(outensor));

	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

VIP中如果增加后处理节点，节点网络直接出的数据就是浮点类型，这个时候不需要做反量化，只需要文本化就可以了

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(float *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("%f      ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - (uint8_t)zeropoint) * scale;
 
    return result;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	//double scale;
	//int zeropoint;
 
	DBG("in");
 
	if(argc != 2)
	{
		DBG("input error, you should use this program like that: program xxxx.dat.");
		exit(-1);
	}
 
	//scale = atof(argv[2]);
	//zeropoint = atoi(argv[3]);
 
	//DBG("scale %f, zeropoint %d.", scale, zeropoint);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	float *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset((void*)p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 32);
	dump_memory(p + filelen / 4 - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);
 
	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}
 
 
	// anti-quanlization && convert to text and store.
#define BUF_SIZE  32
	int iter;
	float res;
	char buf[BUF_SIZE];
	int count;
 
	for(iter = 0; iter < filelen / 4; iter ++)
	{
		char *str;
 
		memset(buf, 0x00, BUF_SIZE);
		//res = uint8_to_fp32(p[iter], zeropoint, scale);
		res = p[iter];
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		str[len + 0] = '\r';
		str[len + 1] = '\n';
		str[len + 2] = '\0';
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}
 
	fflush(outensor);
	fsync(fileno(outensor));
 
	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

这个时候，浮点数的存储格式就是这样：

如果量化是INT8类型的，需要修改量化函数以和模型对应：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(uint8_t *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - (uint8_t)zeropoint) * scale;
 
    return result;
}

static double int8_to_fp32(int8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;

    result = (val - zeropoint) * scale;

    return result;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	double scale;
	int zeropoint;
 
	DBG("in");
 
	if(argc != 4)
	{
		DBG("input error, you should use this program like that: program xxxx.dat scale zeropoint.");
		exit(-1);
	}
 
	scale = atof(argv[2]);
	zeropoint = atoi(argv[3]);
 
	DBG("scale %f, zeropoint %d.", scale, zeropoint);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	unsigned char *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 32);
	dump_memory(p + filelen - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);
 
	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}
 
 
	// anti-quanlization && convert to text and store.
	
#define BUF_SIZE  32
	int iter;
	double res;
	char buf[BUF_SIZE];
	int count;
 
	for(iter = 0; iter < filelen; iter ++)
	{
		char *str;
 
		memset(buf, 0x00, BUF_SIZE);
#if 0
		res = uint8_to_fp32(p[iter], zeropoint, scale);
#else
		res = int8_to_fp32(p[iter], zeropoint, scale);
#endif
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		if(iter != filelen -1)
		{
		    str[len ++] = '\r';
		    str[len ++] = '\n';
		    str[len ++] = '\0';
		}
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}
 
	fflush(outensor);
	fsync(fileno(outensor));
 
	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

修改点：

INT16类型反量化

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(short *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - (uint8_t)zeropoint) * scale;
 
    return result;
}

static double int8_to_fp32(int8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;

    result = (val - zeropoint) * scale;

    return result;
}

static float int16_to_fp32(int16_t val, int32_t fixed_point_pos)
{
    float result = 0.0f;

    if(fixed_point_pos > 0)
    {
	    result = (float)val * (1.0f/((float)(1 << fixed_point_pos)));
    }
    else
    {
	    result = (float)val * ((float)(1 << -fixed_point_pos));
    }

    return result;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	int fixed_point_pos;
 
	DBG("in");
 
	if(argc != 3)
	{
		DBG("input error, you should use this program like that: program xxxx.dat fixed_point_pos.");
		exit(-1);
	}
 
	fixed_point_pos = atof(argv[2]);
 
	DBG("fixed_point_pos %d.", fixed_point_pos);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	short *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 32);
	dump_memory(p + filelen/2 - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);
 
	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}
 
 
	// anti-quanlization && convert to text and store.
	
#define BUF_SIZE  32
	int iter;
	double res;
	char buf[BUF_SIZE];
	int count;
 
	for(iter = 0; iter < filelen/2; iter ++)
	{
		char *str;
 
		memset(buf, 0x00, BUF_SIZE);
#if 0
		res = uint8_to_fp32(p[iter], zeropoint, scale);
#else
		//res = int8_to_fp32(p[iter], zeropoint, scale);
		res = int16_to_fp32(p[iter], fixed_point_pos);
#endif
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		if(iter != filelen/2 -1)
		{
		    str[len ++] = '\r';
		    str[len ++] = '\n';
		    str[len ++] = '\0';
		}
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}
 
	fflush(outensor);
	fsync(fileno(outensor));
 
	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

UINT8的修复实现，末尾不添加空行：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(uint8_t *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - (uint8_t)zeropoint) * scale;
 
    return result;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	double scale;
	int zeropoint;
 
	DBG("in");
 
	if(argc != 4)
	{
		DBG("input error, you should use this program like that: program xxxx.dat scale zeropoint.");
		exit(-1);
	}
 
	scale = atof(argv[2]);
	zeropoint = atoi(argv[3]);
 
	DBG("scale %f, zeropoint %d.", scale, zeropoint);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	unsigned char *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 32);
	dump_memory(p + filelen - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);
 
	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}
 
 
	// anti-quanlization && convert to text and store.
	
#define BUF_SIZE  32
	int iter;
	double res;
	char buf[BUF_SIZE];
	int count;
 
	for(iter = 0; iter < filelen; iter ++)
	{
		char *str;
 
		memset(buf, 0x00, BUF_SIZE);
		res = uint8_to_fp32(p[iter], zeropoint, scale);
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		if(iter != filelen -1)
		{
			str[len + 0] = '\r';
			str[len + 1] = '\n';
			str[len + 2] = '\0';
		}
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}
 
	fflush(outensor);
	fsync(fileno(outensor));
 
	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

由于通常端侧设备不支持FP16浮点输梳理，必须要基于IEEE754标准进行FP16到FP32的转换，此过程不涉及反量化，但是涉及到浮点格式的转换：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(short *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
static double uint8_to_fp32(uint8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - (uint8_t)zeropoint) * scale;
 
    return result;
}
 
static double int8_to_fp32(int8_t val, int32_t zeropoint, double scale)
{
    double result = 0.0f;
 
    result = (val - zeropoint) * scale;
 
    return result;
}
 
static float int16_to_fp32(int16_t val, int32_t fixed_point_pos)
{
    float result = 0.0f;
 
    if(fixed_point_pos > 0)
    {
	    result = (float)val * (1.0f/((float)(1 << fixed_point_pos)));
    }
    else
    {
	    result = (float)val * ((float)(1 << -fixed_point_pos));
    }
 
    return result;
}

typedef union
{
    unsigned int u;
    float f;
} _fp32_t;

static float fp16_to_fp32(const short in)
{
    const _fp32_t magic = { (254 - 15) << 23 };
    const _fp32_t infnan = { (127 + 16) << 23 };
    _fp32_t o;
    // Non-sign bits
    o.u = (in & 0x7fff ) << 13;
    o.f *= magic.f;
    if(o.f  >= infnan.f)
    {
        o.u |= 255 << 23;
    }
    //Sign bit
    o.u |= (in & 0x8000 ) << 16;
    return o.f;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	int fixed_point_pos;
 
	DBG("in");
 
	if(argc != 2)
	{
		DBG("input error, you should use this program like that: program xxxx.dat fixed_point_pos.");
		exit(-1);
	}
 
	//fixed_point_pos = atof(argv[2]);
 
	//DBG("fixed_point_pos %d.", fixed_point_pos);
	
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	short *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 32);
	dump_memory(p + filelen/2 - 32, 32);
	
	char outputname[255];
	memset(outputname, 0x00, 255);
	memcpy(outputname, argv[1], strlen(argv[1]));
	memcpy(outputname+strlen(argv[1]), ".tensor", 7);
	DBG("output tensor name %s", outputname);
 
	FILE *outensor = fopen(outputname, "w+");
	if(outensor == NULL)
	{
		DBG("fatal error, create output tensor file %s failure, please check the file status.", outputname);
		exit(-1);
	}
 
	// anti-quanlization && convert to text and store.
#define BUF_SIZE  32
	int iter;
	float res;
	char buf[BUF_SIZE];
	int count;
 
	for(iter = 0; iter < filelen/2; iter ++)
	{
		char *str;
 
		memset(buf, 0x00, BUF_SIZE);
#if 0
		res = uint8_to_fp32(p[iter], zeropoint, scale);
#else
		//res = int8_to_fp32(p[iter], zeropoint, scale);
		//res = int16_to_fp32(p[iter], fixed_point_pos);
		res = fp16_to_fp32(p[iter]);
#endif
#if 0
		sprintf(buf, "%f\r\n", res);
		str = buf;
#else
		str = gcvt(res, BUF_SIZE, buf);
		int len = strlen(str);
		if(iter != filelen/2 -1)
		{
		    str[len ++] = '\r';
		    str[len ++] = '\n';
		    str[len ++] = '\0';
		}
#endif
		if((count = fwrite(str, 1, strlen(str), outensor))!= strlen(str))
		{
			DBG("write float to file error, count %d, strlen %ld.", count, strlen(str));
			exit(-1);
		}
	}
 
	fflush(outensor);
	fsync(fileno(outensor));
 
	fclose(outensor);
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

以LENET 模型为例，最后一层是softmax层，十分类，输出为FP16，则总共20个字节，将其FP16转为FP32输出的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
 
#define DBG(fmt, ...)   do { printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while (0)
 
static void dump_memory(short *buf, int32_t len)
{
    int i;
 
    printf("\n\rdump file memory:");
    for (i = 0; i < len; i ++)
    {
        if ((i % 16) == 0)
        {
            printf("\n\r%p: ", buf + i);
        }
        printf("0x%02x ", buf[i]);
    }
    printf("\n\r");
    return;
}
 
typedef union
{
    unsigned int u;
    float f;
} _fp32_t;
 
static float fp16_to_fp32(const short in)
{
    const _fp32_t magic = { (254 - 15) << 23 };
    const _fp32_t infnan = { (127 + 16) << 23 };
    _fp32_t o;
    // Non-sign bits
    o.u = (in & 0x7fff ) << 13;
    o.f *= magic.f;
    if(o.f  >= infnan.f)
    {
        o.u |= 255 << 23;
    }
    //Sign bit
    o.u |= (in & 0x8000 ) << 16;
    return o.f;
}
 
int main(int argc, char **argv)
{
	FILE *file;
	int fixed_point_pos;
 
	DBG("in");
 
	if(argc != 2)
	{
		DBG("input error, you should use this program like that: program xxxx.dat fixed_point_pos.");
		exit(-1);
	}
 
	file = fopen(argv[1], "rb");
	if(file == NULL)
	{
		DBG("fatal error, open file %s failure, please check the file status.", argv[1]);
		exit(-1);
	}
 
	fseek(file, 0, SEEK_END);
	int filelen = ftell(file);
	
	DBG("file %s len %d byets.", argv[1], filelen);
 
	unsigned short *p = malloc(filelen);
	if(p == NULL)
	{
		DBG("malloc buffer failure for %s len %d.", argv[1], filelen);
		exit(-1);
	}
 
	memset(p, 0x00, filelen);
	fseek(file, 0, SEEK_SET);
 
	if(fread(p, 1, filelen, file) != filelen)
	{
		DBG("read file failure, size wrong.");
		exit(-1);
	}
 
	dump_memory(p, 20);
	
	int iter;
	float res;
 
	for(iter = 0; iter < filelen/2; iter ++)
	{
		res = fp16_to_fp32(p[iter]);
		printf("class %d, prob %f.\n", iter, res);
	}
 
	fclose(file);
	free(p);
	DBG("out");
	return 0;
}

验证：

关于各类浮点表示转换的ONNX代码实现：

交叉参考相关博文：

根据欧式距离和余弦相似度来计算tensor之间的相似度的代码实现_tugouxp的专栏-CSDN博客通常情况下，在端侧的模型推理过程中，使用的是量化后的数据来参与各层计算的，而并非原始的float数据类型，通常的量化数据类型有UINT8/INT8/INT16等等，由于数据表示范围的差异，在量化过程中，必然涉及到精度损失，这种同一个模型相同层之间使用量化推理计算得到的数据经过反量化之后和原始goden版的float数据的差异，我们用相似度表示，用图形化描述如下：...https://blog.csdn.net/tugouxp/article/details/122266262?spm=1001.2014.3001.5501

结束！ 

papaofdoudou
关注
专栏目录
c#视觉应用开发中如何使用C#和TensorFlow进行深度学习？
zhangzhechun的专栏
07-12 264
通过以上示例和改进建议，你可以在C#中使用TensorFlow进行深度学习的图像分类任务，并将其集成到一个WPF应用中，为用户提供一个直观的界面。希望这些信息对你有所帮助！好的，接下来我们可以进一步优化和扩展这个示例应用，包括添加更多的功能和改进用户体验。通过以上步骤，我们进一步优化了图像分类应用的性能和用户体验。现在这个应用不仅能高效地进行图像分类，还提供了友好的用户界面和进度指示。希望这些改进和扩展能帮助你更好地使用C#和TensorFlow进行深度学习应用开发。python如何操作word文档。
c#视觉应用开发中如何在C#中进行图像修复？
zhangzhechun的专栏
07-16 74
在C#中进行图像修复通常涉及图像处理技术，如去噪、去除划痕或修复缺失部分。我们可以使用一些开源库，比如Emgu CV（OpenCV的C#封装），来进行这些操作。以下是一个简单的示例，使用Emgu CV库来进行图像去噪和修复。
tensor:用于C ++的快速张量库
05-07
快速的C ++张量库 张量 Tensor是一个C ++张量表达式库。 在设计时要兼顾速度和表达的清晰度。 因此，它旨在提供高水平的性能，但允许对代码中的张量进行的运算与数学上的表现完全一样。 用于将在编译时可以计算的任何工作“分流”到编译器，用于实现将数学表达的代码转换为高性能代码。 已经使用编写了以验证所有已实现组件的“正确性”。 这些测试还有助于说明库的各种组件的用法。 长期目标是根据python theano libray中的张量库开发某些东西，但支持具有CPU和GPU功能的任何等级张量。 文献资料 请参阅以获取文档和用法示例。 当前状态 当前，该库仅是CPU，并且随着开发过程的开始才是单线程的。 但是，该库将被扩展为包括GPU功能（具有CUDA以及可能还有OpenCL）和多线程（因此具有多核CPU-可能具有OpenMP和MPI）。 目前有很多功能在起作用，但是，开发的第一个
C++中tensor数据类型转换
Swayzzu的博客
03-05 2597
主要是将tensor数据类型转为C++可以识别的类型。 拿出tensor.item()之后，还可以继续转，比如C++中不能用if判断torch tensor的类型，但通过tensor.item().toBool()就转为了可以识别的类型了。 同理，也可以to其他类型。 ...
文件操作【C语言】
shuggg的博客
02-23 341
C语言的文件操作相关知识
C11标准的sscanf_s函数用法
icesnowjank的专栏
02-08 979
函数原型： intsscanf_s(constchar*restrictbuffer,constchar*restrictformat, ...); 实际调用的时候如果需要解析字符串的话，需要在buffer后面跟上buffer长度而不是在最后跟buffer长度。 e.g： if (::sscanf_s(item.asCString(), "%s:" _I64FMT_, bitRate, sizeof(bitRate), &dlTime) == 2) //...
STM32 编译错误记录\ARMCC\Bin\..\include\stdio.h(352): error: #20: identifier “size_t“ is undefine....
欲盖弥彰1314
07-20 4810
前一次编译还没有错误，做了一些改动后就编译出错。 以前还出现过很多次类似的情况。 void Delay_Init(void); C:\Keil_v5\ARM\ARMCC\Bin\..\include\stdio.h(352): error: #20: identifier "size_t" is undefined int /*mode*/, size_t /*size*/) __attribute__((__nonnull__(1))); C:\Keil_v
c#视觉应用开发中如何在C#中使用卷积神经网络（CNN）进行图像分类？
zhangzhechun的专栏
07-17 119
通过上述优化和扩展，代码变得更加全面和健壮。使用ImageSharp提高了图像预处理的效率，支持批量图像处理提高了实用性，异常处理增强了代码的健壮性。此方法不仅适用于图像分类，还可以扩展到其他视觉任务，如对象检测和图像分割，只需加载相应的模型并调整预处理和后处理逻辑。通过上述扩展，您可以开发一个功能全面、性能优化的图像分类应用。使用高效的图像处理库、支持批量处理、添加异常处理和集成用户界面，使得应用更加易用和健壮。利用GPU加速推理可以显著提高性能，适用于需要实时处理的应用场景。python解压及压缩文件。
c#视觉应用开发中如何在C#中进行目标检测？
zhangzhechun的专栏
07-12 159
在C#中进行目标检测通常需要利用一些已经存在的计算机视觉库，如OpenCV或Emgu CV（OpenCV的C#封装）。这些库提供了丰富的功能来处理图像和视频，并实现目标检测等复杂任务。下面我们将详细分析如何在C#中进行目标检测，并提供一个使用Emgu CV进行目标检测的示例代码。
智能农业设备软件工程师如何实现农业设备的人工智能和机器学习应用
最新发布
zhangzhechun的专栏
08-12 85
)model.fit(epochs=10,通过上述步骤和示例代码，可以实现一个简单的农业设备AI应用。实际应用中可能需要处理更多复杂性，如更大规模的数据、更复杂的模型以及实时数据处理等。不断迭代和优化模型，并结合具体的农业场景，能够最大化智能农业设备的效能。通过以上步骤和代码示例，可以实现一个完整的农业设备人工智能应用。从数据收集、模型训练到部署和实时推理，每一步都需要精心设计和优化，以确保系统的性能和可靠性。在实际应用中，还需要考虑设备的计算能力、网络连接性和数据隐私等因素。
宏BUF_SIZE_BYTES(buf)和BUF_SIZE_CHARS(buf)计算数组最大容纳字节数和字符数
04-09 2604
//calculate the number of bytes of the max size #define BUF_SIZE_BYTES(buf) (sizeof(buf)-sizeof(buf[0])) //calculate the number of characters of the max size #define BUF_SIZE_CHARS(buf) (sizeof(b
glibc sprintf源码梳理（上）
舍本逐末
03-04 1839
尝试阅读sprint源码 glibc 版本2.11 0. sprintf和snprintf sprintf和snprintf的是字符串格式化方法，可将格式化数据写入字符串中。 snprintf规定了写入字符串的最大长度，避免字符串长度溢出 sprintf和snprintf方法定义在libio/stdio.h中，其声明和方法参数说明如下： /* __s : 字符数组指针，存储拼接后的字符串 __format: 字符串，规定了字符串格式 ... : 可变参数，填充format中的值
snprintf函数用法
热门推荐
crfoxzl的专栏
01-23 14万+
int snprintf(char *restrict buf, size_t n, const char * restrict  format, ...);函数说明:最多从源串中拷贝n－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为n 的话，将不会溢出。函数返回值:若成功则返回欲写入的字符串长度，若出错则返回负值。Result1(推荐的用法)#include #
标准I/O库：stdio.h
qq_46103963的博客
04-15 349
ANSI C标准库包含一些与流相关联的标准 I/O函数和stdio.h头文件。下面列出ANSI中这些函数的原型和简介。stdio.h头文件定义了FILE类型、EOF和NULL的值、标准I/O流（stdin、stdout和stdeer）以及标准I/O库中函数要用到的一些常量。 void clearerr(FILE *); 清除文件结尾和错误指示符 int fclose(FILE *);关闭指定的文...
C：使用sprintf函数
weixin_34060299的博客
01-13 400
2019独角兽企业重金招聘Python工程师标准>>> ...
【TensorRT】2、神经网络中的量化
呆呆的猫的博客
11-18 4220
本文主要介绍神经网络在部署时的量化
【四】数字与字符串介绍
weixin_46395534的博客
02-11 750
python中数字与字符串介绍
数字与字符串
yloveyzcl的博客
08-13 2093
7.1 封装类(装箱与拆箱) 所有的基本类型都有对应的封装类 数字封装类有 Byte,Short,Integer,Long,Float,Double 这些类都是抽象类Number的子类 基本类型与封装类的转换 public class Test {     public static void main(String[] args) {        int i=5;        ...
关于 sprintf (char*, const char*, ...)...
nowhaha的专栏
08-29 3480
这几天学习C++，就用它写个小程序，与着手用api写了个后台服务，b
Python库tensor-utils-1.0.2在PyPI官网发布
如果tensor-utils是一个云原生Python库，它可能提供了在云环境中高效处理数据、执行并行计算或者与云服务进行交互的工具和功能。 从文件名称列表中我们得知，该软件包的文件名是tensor-utils-1.0.2。根据该名称，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

papaofdoudou

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值