Qiea/stm32-cnn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Qiea:精简项目
Branches Tags
Qiea:main Qiea:Device_1_通过验证 Qiea:Winner_stm32 Qiea:c_cnn
Qiea:可变卷积核 Qiea:完整版 Qiea:精简项目
..
compare: Qiea:可变卷积核
Branches Tags
Qiea:Device_1_通过验证 Qiea:main Qiea:Winner_stm32 Qiea:c_cnn
Qiea:可变卷积核 Qiea:完整版 Qiea:精简项目

13 Commits
精简项目 ... 可变卷积核

Author SHA1 Message Date
Qiea
1c0f3b676f save 2024-11-13 12:30:23 +08:00
Qiea
5ee5304676 添加功能 
scan_files：扫描目录
 2024-11-13 00:38:53 +08:00
Qiea
9566fb0db7 Update cnn_model.c 2024-11-12 15:39:08 +08:00
Qiea
8c9b256242 完善 2024-11-12 14:53:30 +08:00
Qiea
572b24f867 Update main.c 2024-11-12 14:44:20 +08:00
Qiea
354f447ad1 Update cnn_model.h 2024-11-12 13:02:05 +08:00
Qiea
0566df80a2 完善代码 2024-11-12 12:36:57 +08:00
Qiea
15e6a6e1dc 添加功能：sendblock 
验证通过
 2024-11-12 10:59:42 +08:00
Qiea
edd76c2871 移植c-cnn：验证通过 
ok，但代码未精简
 2024-11-12 09:37:42 +08:00
Qiea
8d49d67929 移植c_cnn代码 2024-11-11 18:17:48 +08:00
Qiea
88ab12182e Update main.c 2024-11-09 00:55:46 +08:00
Qiea
85f2a5adec Fix bug 
解决了cnn_run内存溢出的问题
 2024-11-09 00:39:32 +08:00
Qiea
da2ae5ee13 Update README.md 2024-11-08 21:42:42 +08:00
14 changed files with 503 additions and 720 deletions
Expand all files Collapse all files

4
.gitignore vendored Normal file
View File

@@ -0,0 +1,4 @@
/OBJ
*.dbgconf
*.Qi

815
PORTING/CNN/cnn.c
View File

@@ -6,319 +6,224 @@ void _cnn_run(){
isrun = 1;
}
/*<2A><><EFBFBD><EFBFBD><EFBFBD>ô<EFBFBD>ӡ<EFBFBD><D3A1><EFBFBD><EFBFBD>*/
/// @brief <20><>ӡͼ<D3A1><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param array <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param array_num <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ܵĸ<DCB5><C4B8><EFBFBD>
/// @param elements_per_line ÿһ<C3BF>еĸ<D0B5><C4B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>
void PrintfArray(float *array, int array_num, int elements_per_line)
{
for (int i = 0; i < array_num; i++)
{
printf("%f ", array[i]); // <20><>ӡ<EFBFBD><D3A1>ǰԪ<C7B0><D4AA>
// ÿ<><C3BF>ӡ<EFBFBD><D3A1>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>غ<EFBFBD><D8BA><EFBFBD><EFBFBD><EFBFBD>
if ((i + 1) % elements_per_line == 0)
{
printf("\n");
void print_rslt(float* rslt, u8 input_matrix_length, u32 length){
int _tmp = 0;
printf("[0:0]");
for (int i = 0; i < length; i++) {
printf("%f ",rslt[i]);
if ((i + 1) % input_matrix_length == 0) {
printf("\n[%d:%d]",++_tmp,i+1);
}
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>Ԫ<EFBFBD>ز<EFBFBD><D8B2>㣬<EFBFBD>ֶ<EFBFBD><D6B6><EFBFBD><EFBFBD><EFBFBD>
if (array_num % elements_per_line != 0)
{
printf("\n");
}
printf("\r\n");
}
void PrintfResArray(float *array, int array_num, int elements_per_line)
{
for (int i = 0; i < array_num; i++)
{
printf("%f ", array[i]); // <20><>ӡ<EFBFBD><D3A1>ǰԪ<C7B0><D4AA>
// ÿ<><C3BF>ӡ<EFBFBD><D3A1>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>غ<EFBFBD><D8BA><EFBFBD><EFBFBD><EFBFBD>
if ((i + 1) % elements_per_line == 0)
{
printf("\t");
// <20><>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float* expand(const float* old_matrix, int old_matrix_length, int layer){
float* new_matrix = (float *)mymalloc(SRAMEX,sizeof(float)*layer*(old_matrix_length+2)*(old_matrix_length+2));
memset(new_matrix, 0, sizeof(float)*layer*(old_matrix_length+2)*(old_matrix_length+2));
for(int l=0; l < layer; l++){
for (int i = 0; i < old_matrix_length; i++) {
for (int j = 0; j < old_matrix_length; j++) {
new_matrix[(i + 1) * (old_matrix_length+2) + (j + 1) +
l * (old_matrix_length+2) * (old_matrix_length+2)]
= old_matrix[i * old_matrix_length + j +
l * (old_matrix_length) * (old_matrix_length)];
}
}
}
return new_matrix;
}
//model ģ<><C4A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//input_matrix <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
//input_matrix_length <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ı߳<C4B1><DFB3><EFBFBD>102
//c_rl <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ı߳<C4B1><DFB3><EFBFBD>100
//<2F><><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD>
float* convolution(Model model_w, Model model_b, const float* input_matrix, int input_matrix_length){
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int im_l = input_matrix_length;
int cr_l = input_matrix_length - 2;
float conv_temp; // <20><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ洢<DAB4><E6B4A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>м<EFBFBD><D0BC><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD>ںϲ<DABA>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD>飬<EFBFBD><E9A3AC><EFBFBD><EFBFBD>32*64*50*50(<28>ڶ<EFBFBD><DAB6><EFBFBD>)<29>Ĵ<EFBFBD>С
float* _conv_rlst = (float *) mymalloc(SRAMEX,sizeof (float) * model_w.num_kernels * (cr_l * cr_l));
memset(_conv_rlst, 0, sizeof (float) * model_w.num_kernels * (cr_l * cr_l));
//<2F><>ͼ<EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float* conv_rlst = (float *) mymalloc(SRAMEX,sizeof (float) * model_w.num_kernels * (cr_l * cr_l));
memset(conv_rlst, 0, sizeof (float) * model_w.num_kernels * (cr_l * cr_l));
/*<2A><>ά<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD>*/
/// @brief <20><>̬<EFBFBD><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ά<EFBFBD><CEAC><EFBFBD>飬<EFBFBD><E9A3AC><EFBFBD><EFBFBD>ΪelementSize
/// @param depth <20><>ά<EFBFBD><CEAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD><C8A3><EFBFBD>a[depth][]
/// @param num <20><><EFBFBD>ȣ<EFBFBD><C8A3><EFBFBD>a[][num]
/// @param elementSize <20><>ά<EFBFBD><CEAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void **allocate2DArray(int depth, int num, size_t elementSize)
{
void **array = (void **)mymalloc(SRAMEX, depth * sizeof(void *));
for (int d = 0; d < depth; d++)
{
array[d] = mymalloc(SRAMEX, num * elementSize);
}
return array;
}
/// @brief <20>ͷ<EFBFBD>ͨ<EFBFBD><CDA8>allocate2DArray<61><79><EFBFBD><EFBFBD><EFBFBD>Ķ<EFBFBD>ά<EFBFBD><CEAC><EFBFBD><EFBFBD>
/// @param array <20><>ά<EFBFBD><CEAC><EFBFBD><EFBFBD>
/// @param depth <20><><EFBFBD><EFBFBD>
void free2DArray(float **array, int depth)
{
for (int d = 0; d < depth; d++)
{
myfree(SRAMEX, array[d]);
}
myfree(SRAMEX, array);
}
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>غ<EFBFBD><D8BA><EFBFBD>*/
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD>
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param input_size <20><><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>磺100<30><30>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>100<30><30>Ԫ<EFBFBD><D4AA>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void Full(float *inputArray, int input_size, float *outputArray)
{
int i, j;
for (i = 0; i < ((input_size + 2) * (input_size + 2)); i++)
{
outputArray[i] = 0;
}
for (i = 0; i < input_size; i++)
{
for (j = 0; j < input_size; j++)
{
outputArray[(i + 1) * (input_size + 2) + (j + 1)] = inputArray[i * input_size + j];
// <20><><EFBFBD><EFBFBD>30<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>30<EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(int c=0; c < model_w.channel; c++){
for(int k=0; k < model_w.num_kernels; k++){
for(int row = 0; row < cr_l; row++) {
for (int col = 0; col < cr_l; col++) {
conv_temp = 0; // ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>س<EFBFBD>ʼ<EFBFBD><CABC>Ϊ0
// <20><><EFBFBD><EFBFBD>3x3<78>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>Ķ<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ȩ<EFBFBD><C8A8><EFBFBD><EFBFBD><EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD><EFBFBD>ۼӵ<DBBC>conv_temp
conv_temp += input_matrix[(c*im_l*im_l) + (row*(im_l)+col) + (x*(im_l)+y)]
* model_w.array[((c+k*model_w.channel)*3*3) + (x*3+y)];
}
}
_conv_rlst[(k*cr_l*cr_l) + (row*cr_l+col)] = conv_temp;
}
}
}
//<2F>ϲ<EFBFBD><CFB2><EFBFBD>ͼ
for(int k=0; k < model_w.num_kernels; k++) {
for (int row = 0; row < cr_l; row++) {
for (int col = 0; col < cr_l; col++) {
conv_rlst[(k*cr_l*cr_l) + (row*cr_l+col)] += _conv_rlst[(k*cr_l*cr_l) + (row*cr_l+col)];
}
}
}
}
for(int k=0; k < model_w.num_kernels; k++) {
for (int row = 0; row < cr_l; row++) {
for (int col = 0; col < cr_l; col++) {
conv_temp = conv_rlst[(k * cr_l * cr_l) + (row * cr_l + col)];
// <20><><EFBFBD>϶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD>˵<EFBFBD>ƫ<EFBFBD><C6AB>
conv_temp += model_b.array[k];
// <20><><EFBFBD><EFBFBD><EEBAAF><EFBFBD><EFBFBD>ReLU<4C><55><EFBFBD><EFBFBD>С<EFBFBD><D0A1>0<EFBFBD><30>ֵ<EFBFBD><D6B5>Ϊ0<CEAA><30>
if (conv_temp > 0)
conv_rlst[(k * (cr_l * cr_l)) + (row * cr_l) + (col)] = conv_temp; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else
conv_rlst[(k * (cr_l * cr_l)) + (row * cr_l) + (col)] = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0
}
}
}
myfree(SRAMEX,_conv_rlst);
_conv_rlst = NULL;
return conv_rlst;
}
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD>гػ<D0B3><D8BB><EFBFBD>ѡȡkernel_size*kernel_size<7A>ķ<EFBFBD>Χ<EFBFBD><CEA7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊstep
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD>
/// @param input_size <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ĵ<EFBFBD><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param kernel_size <20>ػ<EFBFBD><D8BB>˵ĵ<CBB5><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><EFBFBD><EFBFBD>
/// @param step <20><EFBFBD><EFBFBD><EFBFBD>ֵ
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void Pooling(float *inputArray, int input_size,
int kernel_size, unsigned int step,
float *outputArray)
{
int output_size = (input_size - kernel_size) / step + 1;
for (int i = 0; i < output_size; i++)
//num_kernels <20><><EFBFBD><EFBFBD><EFBFBD>˵ĸ<CBB5><C4B8><EFBFBD><EFBFBD><EFBFBD>32
//area <20>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2*2
//input_matrix <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD>
//input_matrix_length <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ı߳<C4B1><DFB3><EFBFBD>100
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD><EFBFBD>ı߳<EFBFBD><EFBFBD><EFBFBD>50
//<EFBFBD><EFBFBD><EFBFBD>سػ<EFBFBD><EFBFBD>Ľ<EFBFBD><EFBFBD><EFBFBD>
float* pooling(Model model_w, const float* input_matrix, u8 input_matrix_length){
u8 im_l = input_matrix_length;
float pool_temp = 0; // <20><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ洢<DAB4>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
float* pool_rslt = (float *) mymalloc(SRAMEX,sizeof (float)*model_w.num_kernels*im_l*im_l);
memset(pool_rslt, 0, sizeof (float)*model_w.num_kernels*im_l*im_l);
// <20><><EFBFBD><EFBFBD>30<33><30>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬ<EFBFBD><CDAC>
for(u8 n=0; n<model_w.num_kernels; n++)
{
for (int j = 0; j < output_size; j++)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD>ÿһ<C3BF>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD>Ϊ2<CEAA><32>2x2<78>ijػ<C4B3><D8BB><EFBFBD><EFBFBD>ڣ<EFBFBD>
for(u8 row=0; row<im_l; row=row+2)
{
float max_value = 0;
for (int m = 0; m < kernel_size; m++)
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD>ÿһ<C3BF>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD>Ϊ2
for(u8 col=0; col<im_l; col=col+2)
{
for (int n = 0; n < kernel_size; n++)
pool_temp = 0; // ÿ<><C3BF><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>ʼ<EFBFBD><CABC>Ϊ0
// <20><><EFBFBD><EFBFBD>2x2<78><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>
for(u8 x=0; x<2; x++)
{
int input_row = i * step + m;
int input_col = j * step + n;
int input_idx = input_row * input_size + input_col;
if (inputArray[input_idx] > max_value)
for(u8 y=0; y<2; y++)
{
max_value = inputArray[input_idx];
// <20><><EFBFBD>µ<EFBFBD>ǰ<EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
if(pool_temp <= input_matrix[row*im_l+col+x*im_l+y+n*(im_l*im_l)])
pool_temp = input_matrix[row*im_l+col+x*im_l+y+n*(im_l*im_l)];
}
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
pool_rslt[(row/2)*(im_l/2)+col/2+n*((im_l/2)*(im_l/2))] = pool_temp;
}
int output_idx = i * output_size + j;
outputArray[output_idx] = max_value;
}
}
return pool_rslt;
}
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD><D0BE><EFBFBD><EFBFBD><EFBFBD>ѡȡkernel_size*kernel_size<7A>ķ<EFBFBD>Χ<EFBFBD><CEA7><EFBFBD><EFBFBD><EFBFBD>ﲽ<EFBFBD><EFB2BD>Ϊ1
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD>
/// @param input_size <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ĵ<EFBFBD><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param kernel <20><><EFBFBD><EFBFBD><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD>kernel_size * kernel_size<7A>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD>˲<EFBFBD><CBB2><EFBFBD>
/// @param kernel_size <20>ػ<EFBFBD><D8BB>˵ĵ<CBB5><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void Convolution(float *inputArray, int input_size,
float *kernel, int kernel_size,
float *outputArray)
{
int i, j, m, n;
int half_k = kernel_size / 2;
int output_size = input_size - 2 * half_k;
float* hidden(const float* input_matrix){
float affine1_temp; // <20><>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ洢ȫ<EFBFBD><EFBFBD><EFBFBD>Ӳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>м<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float *affine1_rslt = (float *) mymalloc(SRAMEX,sizeof(float)*128);
memset(affine1_rslt, 0, sizeof(float)*128);
for (i = half_k; i < input_size - half_k; i++)
// <20><><EFBFBD><EFBFBD>128<32><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>128<32><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>
for(u8 n=0; n<128; n++)
{
for (j = half_k; j < input_size - half_k; j++)
affine1_temp = 0; // ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>Ϊ0
// <20><><EFBFBD>о<EFBFBD><D0BE><EFBFBD><EFBFBD>˷<EFBFBD><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>չƽΪһά<D2BB><CEAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB><EFBFBD>Ӳ<EFBFBD>Ȩ<EFBFBD>ؽ<EFBFBD><D8BD>е<EFBFBD><D0B5><EFBFBD>
for(int i=0; i<(128*12*12); i++)
{
float sum = 0;
for (m = 0; m < kernel_size; m++)
{
for (n = 0; n < kernel_size; n++)
{
int input_row = i + m - half_k;
int input_col = j + n - half_k;
int input_idx = input_row * input_size + input_col;
int kernel_idx = m * kernel_size + n;
sum += inputArray[input_idx] * kernel[kernel_idx];
}
}
int output_idx = (i - half_k) * output_size + (j - half_k);
outputArray[output_idx] = sum;
affine1_temp = affine1_temp + input_matrix[i] * fc1_weight.array[i+(128*12*12)*n];
}
// <20><><EFBFBD>϶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>ƫ<EFBFBD><C6AB>
affine1_temp = affine1_temp + fc1_bias.array[n];
// <20><><EFBFBD><EFBFBD><EEBAAF><EFBFBD><EFBFBD>ReLU<4C><55><EFBFBD><EFBFBD>С<EFBFBD><D0A1>0<EFBFBD><30>ֵ<EFBFBD><D6B5>Ϊ0<CEAA><30>
if(affine1_temp > 0)
affine1_rslt[n] = affine1_temp; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else
affine1_rslt[n] = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0
}
// print_rslt(affine1_rslt,1,128);
return affine1_rslt;
}
/// @brief <20>Զ<EFBFBD>ά<EFBFBD><CEAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧλ<D3A6><CEBB><EFBFBD><EFBFBD>
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param input_depth <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD><EFBFBD><EFBFBD>a[input_depth][]
/// @param input_size <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ĵ<EFBFBD><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void Combine(float **inputArray, int input_depth, int input_size, float *outputArray)
{
int i, j, k;
int input_idx;
float* output(Model model_w, const float* input_matrix){
u8 num = model_w.num_kernels;
float affine2_temp; // <20><>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ洢<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>м<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float *affine2_rslt = (float *) mymalloc(SRAMEX,(sizeof(float)*num));
memset(affine2_rslt, 0, sizeof(float)*num);
for (i = 0; i < input_size; i++)
// <20><><EFBFBD><EFBFBD>10<31><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>10<31><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(int n=0; n<num; n++)
{
affine2_temp = 0; // <20><>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>Ϊ0
for (j = 0; j < input_size; j++)
// <20><><EFBFBD>о<EFBFBD><D0BE><EFBFBD><EFBFBD>˷<EFBFBD><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ȩ<EFBFBD>ؽ<EFBFBD><D8BD>е<EFBFBD><D0B5><EFBFBD>
for(int i=0; i<128; i++)
{
float sum = 0;
input_idx = i * input_size + j;
for (k = 0; k < input_depth; k++)
{
sum += inputArray[k][input_idx];
}
outputArray[i * input_size + j] = sum;
affine2_temp = affine2_temp + fc2_weight.array[i+128*n] * input_matrix[i];
}
// <20><><EFBFBD>϶<EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>ƫ<EFBFBD><C6AB>
affine2_temp = affine2_temp + fc2_weight.array[n];
affine2_rslt[n] = affine2_temp; // <20>洢<EFBFBD><E6B4A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD>
}
return affine2_rslt;
}
/// @brief չ<><D5B9><EFBFBD><EFBFBD>ά<EFBFBD><CEAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һά<D2BB><CEAC><EFBFBD><EFBFBD>
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param input_depth <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȣ<EFBFBD><C8A3><EFBFBD>a[input_depth][]
/// @param input_size <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ĵ<EFBFBD><C4B5>е<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void Flatten2D(float **inputArray, int input_depth, int input_size, float *outputArray)
{
int i, j, k;
for (k = 0; k < input_depth; k++)
{
for (i = 0; i < input_size; i++)
{
for (j = 0; j < input_size; j++)
{
int input_idx = i * input_size + j;
outputArray[k * input_size * input_size + input_idx] = inputArray[k][input_idx];
}
}
}
}
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD>ÿһλ<D2BB><CEBB><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param input_num <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ܵ<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param bias ƫ<>ú<EFBFBD>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
void AddBias(float *inputArray, int input_num, float bias, float *outputArray)
{
for (int i = 0; i < input_num; i++)
{
outputArray[i] = inputArray[i] + bias;
}
}
/// @brief ȫ<><C8AB><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD><D4AA>ȫ<EFBFBD><C8AB><EFBFBD><EFBFBD>
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param input_num <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ܵ<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param input_w <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ȩ<EFBFBD>غ<EFBFBD>
/// @param input_b <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƫ<EFBFBD>ú<EFBFBD>
/// @return һ<><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>Ľ<EFBFBD><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊfloat
float ConnectedLayer(float *inputArray, int input_num,
float *input_w, float input_b)
void calculate_statistics(Model model, float* value)
{
int i;
value[0] = fabsf(model.array[0]);
float sum = 0;
for (i = 0; i < input_num; i++)
{
sum += inputArray[i] * input_w[i];
}
sum = sum + input_b;
return sum;
}
float sum_sq = 0;
/// @brief ReLU<4C><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>Ƕ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EEA3BA>ֵ<EFBFBD><D6B5><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0
/// @param inputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>
/// @param num <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ܵ<EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param outputArray <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD>
void ReLU1(float *inputArray, int num, float *outputArray)
{
for (int i = 0; i < num; i++) {
outputArray[i] = (inputArray[i] > 0) ? inputArray[i] : 0;
}
}
for (int i = 0; i < model.maxlength; i++) {
float abs_val = fabsf(model.array[i]);
/// @brief ReLU<4C><55><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>Ƕ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EEA3BA>ֵ<EFBFBD><D6B5><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0
/// @param data <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @return <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊfloat
float ReLU2(float data)
{
if (data > 0) {
return data;
}
else {
return 0;
}
}
//<2F><><EFBFBD><EFBFBD>ֵ
/// @brief <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƽ<EFBFBD><C6BD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD>ͱ<EFBFBD>׼<EFBFBD><D7BC>
/// @param arr <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param size <20><><EFBFBD><EFBFBD><EFBFBD>ij<EFBFBD><C4B3><EFBFBD>
/// @param max_val <20><><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>
/// @param mean ƽ<><C6BD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>
/// @param std_dev <20><>׼<EFBFBD><EFBFBD><EEB1A3>
void calculate_statistics(float arr[], int size, float *max_val, float *mean, float *std_dev)
{
*max_val = fabs(arr[0]);
float sum = 0.0;
float sum_sq = 0.0;
for (int i = 0; i < size; i++) {
float abs_val = fabs(arr[i]);
if (abs_val > *max_val) {
*max_val = abs_val;
if (abs_val > value[0]) {
value[0] = abs_val;
}
sum += abs_val;
sum_sq += abs_val * abs_val;
}
*mean = sum / size;
value[1] = sum / (float)model.maxlength;
float variance = (sum_sq / size) - (*mean * *mean);
*std_dev = sqrt(variance);
float variance = (sum_sq / (float)model.maxlength) - (value[1] * value[1]);
value[2] = sqrtf(variance);
}
//<2F>жϷŵ<CFB7>
/// @brief <20>ж<EFBFBD><D0B6>Ƿ<EFBFBD><C7B7>ŵ<EFBFBD>
/// @param arr <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param size <20><><EFBFBD><EFBFBD><EFBFBD>ij<EFBFBD><C4B3><EFBFBD>
/// @param mean ƽ<><C6BD>ֵ
/// @param std_dev <20><>׼<EFBFBD><D7BC>
/// @return <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD>򷵻<EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD><EFBFBD>򷵻<EFBFBD>0
int check_threshold(float arr[], int size, float *mean, float *std_dev)
u8 check_threshold(Model model, const float* value)
{
const float threshold = 20.0;
const float threshold = 20;
for (int i = 0; i < size; i++) {
float K = (arr[i] - *mean) / *std_dev;
for (int i = 0; i < model.maxlength; i++) {
float K = (fabsf(model.array[i]) - value[1]) / value[2];
if (K > threshold) {
return 1;
}
@@ -326,306 +231,166 @@ int check_threshold(float arr[], int size, float *mean, float *std_dev)
return 0;
}
/// @brief <20><><EFBFBD><EFBFBD>100*100<30><30><EFBFBD><EFBFBD>
/// @param get_data <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param Max_value <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
/// @param totalPoints <20>ܵ<EFBFBD><DCB5><EFBFBD><EFBFBD><EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @param CNN_data <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>飨<EFBFBD><E9A3A8>ά<EFBFBD><CEAC>
void generateMatrix(float *get_data, float Max_value, int totalPoints, float CNN_data[100*100])
float* generateMatrix(Model model, const float* value)
{
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
CNN_data[i*100+j] = 0;
}
}
float* CNN_data = (float*) mymalloc(SRAMEX,sizeof(float)*100*100);
memset(CNN_data, 0, sizeof(float)*100*100);
int pointsPerInterval = totalPoints / 100;
float amplitudeStep = Max_value / 100;
u16 x = model.maxlength / 100;
float y = value[0] / 100;
for (int i = 0; i < totalPoints; i++) {
float amplitudeValue = fabsf(get_data[i]);
for (int i = 0; i < model.maxlength; i++) {
float absolutevalue = fabsf(model.array[i]);
if (amplitudeValue == 0.0f) {
if (!absolutevalue) {
continue;
}
int intervalIndex = i / pointsPerInterval;
if (intervalIndex >= 100) intervalIndex = 99;
int xIndex = i / x;
if (xIndex >= 100) xIndex = 99;
int amplitudeIndex = 99 - (int)(amplitudeValue / amplitudeStep);
if (amplitudeIndex < 0) amplitudeIndex = 0;
int yIndex = (int)(absolutevalue / y);
if (yIndex < 0) yIndex = 0;
CNN_data[amplitudeIndex*100+intervalIndex]++;
CNN_data[yIndex * 100 + xIndex]++;
}
return CNN_data;
}
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param input_array <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param output_array <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param input_num <20><><EFBFBD><EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD>
/// @return <20><><EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĭ<EFBFBD><C4AC>+1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>a[0]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>򷵻<EFBFBD>1<EFBFBD><31>
int calculate_probabilities(float *input_array, float *output_array, int input_num)
float calculate_probabilities(Model model_w, float *input_array)
{
float sum = 0.0;
float temp[input_num];
float sum = 0;
u8 input_num = model_w.num_kernels;
float *result = (float *) mymalloc(SRAMEX,sizeof(float)*input_num);
memset(result, 0, sizeof(float)*input_num);
float *temp = (float *) mymalloc(SRAMEX,sizeof(float)*input_num);
memset(temp, 0, sizeof(float)*input_num);
for (int i = 0; i < input_num; i++)
{
temp[i] = exp(input_array[i]);
temp[i] = expf(input_array[i]);
sum = sum + temp[i];
}
for (int j = 0; j < input_num; j++)
{
output_array[j] = temp[j] / sum;
result[j] = temp[j] / sum;
if(isnan(result[j]))result[j] = 1;
}
int max_index = 0;
float max_value = output_array[0];
float max_value = result[0];
for (int k = 1; k < input_num; k++)
{
if (output_array[k] > max_value)
if (result[k] > max_value)
{
max_value = output_array[k];
max_value = result[k];
max_index = k;
}
}
return max_index + 1;
float _tmp = result[max_index] * 100;
myfree(SRAMEX,temp);
temp = NULL;
myfree(SRAMEX,result);
result = NULL;
return _tmp;
}
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǻ<EFBFBD><C7BB><EFBFBD><EFBFBD><EFBFBD>֤<EFBFBD><D6A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ż<EFBFBD>*/
/*ԭʼ<D4AD><CABC><EFBFBD>ݸ<EFBFBD><DDB8><EFBFBD>
*Ŀǰ<C4BF><C7B0><EFBFBD><EFBFBD>֤<EFBFBD>ܷ<EFBFBD><DCB7><EFBFBD><EFBFBD><EFBFBD>Ŀ<EFBFBD><C4BF><EFBFBD>Ե<EFBFBD><D4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC>㣬<EFBFBD>п<EFBFBD><D0BF>ܳ<EFBFBD><DCB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*Ŀǰû<C7B0><C3BB><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>Ԫ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC>㡣
*ԭʼ<D4AD><CABC><EFBFBD>ݸ<EFBFBD><DDB8><EFBFBD><EFBFBD><EFBFBD>ӡ<EFBFBD><D3A1>Ԥ<EFBFBD><D4A4><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>㣬<EFBFBD><E3A3AC><EFBFBD><EFBFBD><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
*/
/// @brief <20><><EFBFBD><EFBFBD><EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD>
/// @param data <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һά<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> --> data.array<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/// @param size ԭʼ<D4AD><CABC><EFBFBD>ݸ<EFBFBD><DDB8><EFBFBD> --> data.maxlength<74><68><EFBFBD><EFBFBD>
void cnn_run()
{
float maxvalue = 0.0; //<2F><><EFBFBD><EFBFBD>ֵ
float meanvalue = 0.0; //ƽ<><C6BD>ֵ
float std_devvalue = 0.0; //<2F><>׼<EFBFBD><D7BC>
int index = 0; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˸<EFBFBD>ɶ<EFBFBD>ģ<EFBFBD>
float *Matrix_data = (float*)mymalloc(SRAMEX, sizeof(float) * 100 * 100); //<2F><><EFBFBD>ɵ<EFBFBD>100*100<30>ľ<EFBFBD><C4BE>󱣴<EFBFBD><F3B1A3B4><EFBFBD><EFBFBD><EFBFBD>
printf("CNNģ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\r\nData<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>Ϊ<EFBFBD><EFBFBD>%s\r\n",data.dname);
DEBUG_PRINTF("data[%d]: %f\r\n",0,data.array[0]);
DEBUG_PRINTF("data[%d]: %f\r\n",1,data.array[1]);
DEBUG_PRINTF("data[%d]: %f\r\n",2,data.array[2]);
DEBUG_PRINTF("data[%d]: %f\r\n",299,data.array[299]);
DEBUG_PRINTF("data[%d]: %f\r\n",300,data.array[300]);
DEBUG_PRINTF("data[%d]: %f\r\n",301,data.array[301]);
DEBUG_PRINTF("data[%d]: %f\r\n",1249997,data.array[1249997]);
DEBUG_PRINTF("data[%d]: %f\r\n",1249998,data.array[1249998]);
DEBUG_PRINTF("data[%d]: %f\r\n",1249999,data.array[1249999]);
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
calculate_statistics(data.array, data.maxlength, &maxvalue, &meanvalue,&std_devvalue);
/*<2A>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ񳬹<C7B7><F1B3ACB9><EFBFBD>ֵ*/
int x = check_threshold(data.array, data.maxlength, &meanvalue, &std_devvalue);
if (x == 1) {
printf("Start\r\n");
//pre <20><>ʼԤ<CABC><D4A4><EFBFBD><EFBFBD>
/*<2A><><EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD>*/
generateMatrix(data.array, maxvalue, data.maxlength, Matrix_data);
float *CNN_data = (float*)mymalloc(SRAMEX, sizeof(float) * 100 * 100);
/*<2A><>ά<EFBFBD><CEAC><EFBFBD><EFBFBD>תһά<D2BB><CEAC><EFBFBD>飬<EFBFBD>Ա<EFBFBD><D4B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
CNN_data[9999 - index++] = Matrix_data[i*100+j];
}
u8 calculate_layer(Model model_w, float *input_array){
u8 input_num = model_w.num_kernels;
u8 predict_num = 0;
float max_temp = -100;
for(int n=0; n<input_num; n++)
{
if(max_temp <= input_array[n])
{
max_temp = input_array[n]; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
predict_num = n; // <20><>¼<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><EFBFBD>Ӧ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
DEBUG_PRINTF("<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>һ<EFBFBD>㣡\r\n");
//1 <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD>*/
float* Full_output1 = (float*)mymalloc(SRAMEX, sizeof(float) * 102 * 102);
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
Full(CNN_data, 100, Full_output1);
float** Convolution_result1_before = (float**)allocate2DArray(32, 100 * 100, sizeof(float));
float** Convolution_result1_relu = (float**)allocate2DArray(32, 100 * 100, sizeof(float));
float** Convolution_result1 = (float**)allocate2DArray(32, 100 * 100, sizeof(float));
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
for (int i = 0; i < 32; i++) {
/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD>û<EFBFBD>Ż<EFBFBD><C5BB><EFBFBD>*/
float conv1_weight_new[9] = {
conv1_weight.array[i*9+0],conv1_weight.array[i*9+1],
conv1_weight.array[i*9+2],conv1_weight.array[i*9+3],
conv1_weight.array[i*9+4],conv1_weight.array[i*9+5],
conv1_weight.array[i*9+6],conv1_weight.array[i*9+7],
conv1_weight.array[i*9+8] };
Convolution(Full_output1, 102, conv1_weight_new, 3, Convolution_result1_before[i]);
}
/*<2A><><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>*/
for (int i = 0; i < 32; i++) {
AddBias(Convolution_result1_before[i], 100 * 100, conv1_bias.array[i], Convolution_result1_relu[i]);
}
/*<2A><>ReLU<4C><55><EFBFBD><EFBFBD>*/
for (int i = 0; i < 32; i++) {
ReLU1(Convolution_result1_relu[i], 100 * 100, Convolution_result1[i]);
}
/*<2A>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>*/
float ** Pooling_result1 = (float**)allocate2DArray(32, 50 * 50, sizeof(float));
for (int i = 0; i < 32; i++) {
Pooling(Convolution_result1[i], 100, 2, 2, Pooling_result1[i]);
}
DEBUG_PRINTF("<EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>\r\n");
//2 <20>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/*<2A>ͷ<EFBFBD><CDB7><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ*/
myfree(SRAMEX, Full_output1);
free2DArray(Convolution_result1_relu,32);
free2DArray(Convolution_result1_before,32);
free2DArray(Convolution_result1,32);
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
float** Full_output2 = (float**)allocate2DArray(32, 52 * 52, sizeof(float));
for (int i = 0; i < 32; i++) {
Full(Pooling_result1[i], 50, Full_output2[i]);
}
/*<2A><><EFBFBD>뱾<EFBFBD><EBB1BE><EFBFBD><EFBFBD>Դ*/
float** Convolution_result_temp_2 = (float**)allocate2DArray(32, 50 * 50, sizeof(float));
float** Convolution_result2_before = (float**)allocate2DArray(64, 50 * 50, sizeof(float));
float** Convolution_result2_relu = (float**)allocate2DArray(64, 50 * 50, sizeof(float));
float** Convolution_result2 = (float**)allocate2DArray(64, 50 * 50, sizeof(float));
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
for (int i = 0; i < 64; i++) {
for (int j = 0; j < 32; j++) {
/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
float conv2_weight_new[9] = {
conv2_weight.array[i*32*9+9*j+0],conv2_weight.array[i*32*9+9*j+1],
conv2_weight.array[i*32*9+9*j+2],conv2_weight.array[i*32*9+9*j+3],
conv2_weight.array[i*32*9+9*j+4],conv2_weight.array[i*32*9+9*j+5],
conv2_weight.array[i*32*9+9*j+6],conv2_weight.array[i*32*9+9*j+7],
conv2_weight.array[i*32*9+9*j+8]
};
Convolution(Full_output2[j], 52, conv2_weight_new, 3, Convolution_result_temp_2[j]);
}
/*ÿһ<C3BF><D2BB><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ϲ<EFBFBD>*/
Combine(Convolution_result_temp_2, 32, 50, Convolution_result2_before[i]);
}
/*<2A><><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>*/
for (int i = 0; i < 64; i++) {
AddBias(Convolution_result2_before[i], 50 * 50, conv2_bias.array[i], Convolution_result2_relu[i]);
}
/*<2A><><EFBFBD><EFBFBD>ReLU<4C><55><EFBFBD><EFBFBD>*/
for (int i = 0; i < 64; i++) {
ReLU1(Convolution_result2_relu[i], 50 * 50, Convolution_result2[i]);
}
/*<2A>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>*/
float** Pooling_result2 = (float**)allocate2DArray(64, 25 * 25, sizeof(float));
for (int i = 0; i < 64; i++) {
Pooling(Convolution_result2[i], 50, 2, 2, Pooling_result2[i]);
}
DEBUG_PRINTF("<EFBFBD>ڶ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>\r\n");
//3 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
/*<2A>ͷ<EFBFBD><CDB7><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ*/
free2DArray(Full_output2,32);
free2DArray(Pooling_result1,32);
free2DArray(Convolution_result_temp_2,32);
free2DArray(Convolution_result2_relu,64);
free2DArray(Convolution_result2_before,64);
free2DArray(Convolution_result2,64);
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
float** Full_output3 = (float**)allocate2DArray(64, 27 * 27, sizeof(float));
for (int i = 0; i < 64; i++) {
Full(Pooling_result2[i], 25, Full_output3[i]);
}
/*<2A><><EFBFBD>뱾<EFBFBD><EBB1BE><EFBFBD><EFBFBD>Դ*/
float** Convolution_result_temp_3 = (float**)allocate2DArray(64, 25 * 25, sizeof(float));
float** Convolution_result3_before = (float**)allocate2DArray(128, 25 * 25, sizeof(float));
float** Convolution_result3_relu = (float**)allocate2DArray(128, 25 * 25, sizeof(float));
float** Convolution_result3 = (float**)allocate2DArray(128, 25 * 25, sizeof(float));
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
for (int i = 0; i < 128; i++) {
for (int j = 0; j < 64; j++) {
float conv3_weight_new[9] = {
conv3_weight.array[i*64*9+9*j+0],conv3_weight.array[i*64*9+9*j+1],
conv3_weight.array[i*64*9+9*j+2],conv3_weight.array[i*64*9+9*j+3],
conv3_weight.array[i*64*9+9*j+4],conv3_weight.array[i*64*9+9*j+5],
conv3_weight.array[i*64*9+9*j+6],conv3_weight.array[i*64*9+9*j+7],
conv3_weight.array[i*64*9+9*j+8]
};
Convolution(Full_output3[j], 27, conv3_weight_new, 3, Convolution_result_temp_3[j]);
}
/*<2A><>ͼ<EFBFBD><CDBC><EFBFBD>ϲ<EFBFBD>*/
Combine(Convolution_result_temp_3, 64, 25, Convolution_result3_before[i]);
}
/*<2A><><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>*/
for (int i = 0; i < 128; i++) {
AddBias(Convolution_result3_before[i], 25 * 25, conv3_bias.array[i], Convolution_result3_relu[i]);
}
/*ReLU<4C><55><EFBFBD><EFBFBD>*/
for (int i = 0; i < 128; i++) {
ReLU1(Convolution_result3_relu[i], 25 * 25, Convolution_result3[i]);
}
/*<2A>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD>*/
float** Pooling_result3 = (float**)allocate2DArray(128, 12 * 12, sizeof(float));
for (int i = 0; i < 128; i++) {
Pooling(Convolution_result3_before[i], 25, 2, 2, Pooling_result3[i]);
}
/*<2A>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>չ<EFBFBD><D5B9><EFBFBD><EFBFBD>һά<D2BB><CEAC><EFBFBD><EFBFBD>*/
float* xi = (float *)mymalloc(SRAMEX, sizeof(float) * 128 * 12 * 12);
Flatten2D(Pooling_result3, 128, 12, xi);
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>\r\n");
//4 <20><>һ<EFBFBD><D2BB><EFBFBD>Ӳ<EFBFBD>
/*<2A>ͷ<EFBFBD><CDB7><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ*/
free2DArray(Full_output3,64);
free2DArray(Pooling_result2,64);
free2DArray(Convolution_result_temp_3,64);
free2DArray(Convolution_result3_relu,128);
free2DArray(Convolution_result3_before,128);
free2DArray(Convolution_result3,128);
/*<2A><><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD>*/
//float yi[128] = {0};
DEBUG_PRINTF("<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD>IJ㣡\r\n");
float* yi = (float *)mymalloc(SRAMEX, 128 * sizeof(float));
memset(yi, 0, 128 * sizeof(float));
for (int i = 0; i < 128; i++) {
float sum = 0;
//float fc1_weight_new[128*12*12];
float* fc1_weight_new = (float*)mymalloc(SRAMEX, sizeof(float) * 128 * 12 * 12);
/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
memcpy(fc1_weight_new,&fc1_weight.array[i*128*12*12],128*12*12 * sizeof(float));
sum = ConnectedLayer(xi, 128 * 12 * 12, fc1_weight_new, fc1_bias.array[i]);
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ReLU<4C><55><EFBFBD><EFBFBD>*/
yi[i] = ReLU2(sum);
myfree(SRAMEX, fc1_weight_new);
}
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>\r\n");
//5 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӳ<EFBFBD>
/*<2A>ͷ<EFBFBD><CDB7><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ*/
free2DArray(Pooling_result3,128);
/*<2A><><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD>*/
float zi[7] = {0};
// float *zi = (float *)mymalloc(SRAMEX, 7 * sizeof(float));
// memset(zi, 0, 7 * sizeof(float));
for (int i = 0; i < 7; i++) {
//float fc2_weight_new[128];
float* fc2_weight_new = (float*)mymalloc(SRAMEX, sizeof(float) * 128);
/*<2A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
memcpy(fc2_weight_new,&fc2_weight.array[i*128],128 * sizeof(float));
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ReLU<4C><55><EFBFBD><EFBFBD>*/
zi[i] = ConnectedLayer(yi, 128, fc2_weight_new, fc2_bias.array[i]);
myfree(SRAMEX, fc2_weight_new);
}
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD>\r\n");
//end <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
float result[7];
int max_probability_idx = calculate_probabilities(zi,result,7);
PrintfResArray(zi,7,7);
PrintfResArray(result,7,7);
printf("%f, Label %d\t", result[max_probability_idx - 1] * 100, max_probability_idx);
myfree(SRAMEX, xi);
myfree(SRAMEX, yi);
myfree(SRAMEX, CNN_data);
myfree(SRAMEX, Full_output1);
myfree(SRAMEX, Matrix_data);
}
else printf("No\r\n");/*<2A><><EFBFBD><EFBFBD>û<EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>ӡ<EFBFBD><D3A1>No<4E><6F>*/
printf("maxvalue is:%f\t",maxvalue);
printf("meanvalue is:%f\t",meanvalue);
printf("std_devvalue is:%f\r\n",std_devvalue);
isrun = 0;
print_rslt(input_array,input_num,input_num);
return predict_num+0;
}
void cnn_run(){
float value[3] = {0};
calculate_statistics(data,&value[0]);
if (check_threshold(data,&value[0])){
//<2F><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>100 * 100 <20><><EFBFBD><EFBFBD>
float* _data = generateMatrix(data,&value[0]);
char kind[50];
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD>⵽<EFBFBD>ŵ磡<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ:%f ƽ<><C6BD>ֵ:%f <20><>׼<EFBFBD><D7BC>:%f\r\n",value[0],value[1],value[2]);
DEBUG_PRINTF("<EFBFBD><EFBFBD>ԭʼ<EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD><EFBFBD><EFBFBD>SD<EFBFBD><EFBFBD><EFBFBD><EFBFBD>\r\n");
SDRAM_TO_SD();
char* _uuid = uuid();
CSTX_4G_RegALiYunIOT(1); //<2F><><EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD>ģ<EFBFBD><C4A3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5>ϱ<EFBFBD>
send_blocks(_data,_uuid);
//<2F><>һ<EFBFBD>㣺<EFBFBD><E3A3BA><EFBFBD><EFBFBD>102 * 102
DEBUG_PRINTF("<EFBFBD><EFBFBD>һ<EFBFBD>㿪ʼ\n");
float* expand_matrix_1 = expand(_data, 100, 1);
float* conv_rlst_1 = convolution(conv1_weight,conv1_bias,expand_matrix_1, 102);
float* pool_rslt_1 = pooling(conv1_weight, conv_rlst_1, 100);
myfree(SRAMEX,_data);
_data = NULL;
myfree(SRAMEX,expand_matrix_1);
expand_matrix_1 = NULL;
myfree(SRAMEX,conv_rlst_1);
conv_rlst_1 = NULL;
//<2F>ڶ<EFBFBD><DAB6>㣺<EFBFBD><E3A3BA><EFBFBD><EFBFBD>32 * 52 * 52
DEBUG_PRINTF("<EFBFBD>ڶ<EFBFBD><EFBFBD>㿪ʼ\n");
float* expand_matrix_2 = expand(pool_rslt_1, 50, 32);
float* conv_rlst_2 = convolution(conv2_weight,conv2_bias,expand_matrix_2, 52);
float* pool_rslt_2 = pooling(conv2_weight, conv_rlst_2, 50);
myfree(SRAMEX,pool_rslt_1);
pool_rslt_1 = NULL;
myfree(SRAMEX,expand_matrix_2);
expand_matrix_2 = NULL;
myfree(SRAMEX,conv_rlst_2);
conv_rlst_2 = NULL;
//<2F><><EFBFBD><EFBFBD><EFBFBD>㣺<EFBFBD><E3A3BA><EFBFBD><EFBFBD> 64 * 27 * 27
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>㿪ʼ\n");
float* expand_matrix_3 = expand(pool_rslt_2, 25, 64);
float* conv_rlst_3 = convolution(conv3_weight,conv3_bias,expand_matrix_3, 27);
float* pool_rslt_3 = pooling(conv3_weight, conv_rlst_3, 25);
myfree(SRAMEX,pool_rslt_2);
pool_rslt_2 = NULL;
myfree(SRAMEX,expand_matrix_3);
expand_matrix_3 = NULL;
myfree(SRAMEX,conv_rlst_3);
conv_rlst_3 = NULL;
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD>IJ㿪ʼ\n");
float* affine1_rslt = hidden(pool_rslt_3);
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>㿪ʼ\r\n");
float* affine2_rslt = output(fc2_weight, affine1_rslt);
DEBUG_PRINTF("<EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD>%f\r\n",calculate_probabilities(fc2_weight, affine2_rslt));
DEBUG_PRINTF("Label is:%d\r\n",calculate_layer(fc2_weight, affine2_rslt));
snprintf(kind, 50,"UUID:%s P:%f Label:%d", _uuid, calculate_probabilities(fc2_weight, affine2_rslt), calculate_layer(fc2_weight, affine2_rslt));
CSTX_4G_ALiYunIOTSenddata_string(kind,"kind_string");
CSTX_4G_RegALiYunIOT(0); //<2F><><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD>ʱ<EFBFBD><CAB1> <20>ź<EFBFBD>
myfree(SRAMEX,pool_rslt_3);
pool_rslt_3 = NULL;
myfree(SRAMEX,affine1_rslt);
affine1_rslt = NULL;
myfree(SRAMEX,affine2_rslt);
affine2_rslt = NULL;
} else{
DEBUG_PRINTF("δ<EFBFBD>ŵ磡<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ:%f ƽ<><C6BD>ֵ:%f <20><>׼<EFBFBD><D7BC>:%f\r\n",value[0],value[1],value[2]);
}
}

35
PORTING/CNN/cnn.h
View File

@@ -1,34 +1,15 @@
#ifndef _CNN_H_
#define _CNN_H_
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "cnn_model.h"
#include "malloc.h"
#include <stdio.h>
#include <math.h>
#include "tools.h"
#include "Function.h"
void cnn_run(void);
void _cnn_run(void);
extern u8 isrun;
void PrintfArray(float *array, int array_num, int elements_per_line);
void **allocate2DArray(int depth, int num, size_t elementSize);
void free2DArray(float **array, int depth);
void Full(float *inputArray, int input_size, float *outputArray);
void Pooling(float *inputArray, int input_size, int kernel_size, unsigned int step, float *outputArray);
void Convolution(float *inputArray, int input_size, float *kernel, int kernel_size, float *outputArray);
void Combine(float **inputArray, int input_depth, int input_size, float *outputArray);
void Flatten2D(float **inputArray, int input_depth, int input_size, float *outputArray);
float ConnectedLayer(float *inputArray, int input_num, float *input_w, float input_b);
void ReLU1(float *inputArray, int num, float *outputArray);
float ReLU2(float data);
void AddBias(float *inputArray, int input_num, float bias, float *outputArray);
int calculate_probabilities(float *input_array, float *output_array, int input_num);
void generateMatrix(float *get_data, float Max_value, int totalPoints, float CNN_data[100*100]);
void calculate_statistics(float arr[], int size, float *max_val, float *mean, float *std_dev);
int check_threshold(float arr[], int size, float *mean, float *std_dev);
void _cnn_run(void);
void cnn_run(void);
void PrintfResArray(float *array, int array_num, int elements_per_line);
#endif

84
PORTING/CNN/cnn_model.c
View File

@@ -14,7 +14,7 @@ Model fc2_bias;
Model fc2_weight;
Model data;
float data_array[DATA_ARRSIZE] __attribute__((at(0XC0009C40)));
float* modelmym_init(char* model_name){
if(conv1_bias.array == NULL && strcmp(model_name, "conv1_bias") == 0)
@@ -37,8 +37,8 @@ float* modelmym_init(char* model_name){
return fc2_bias.array = (float*)mymalloc(SRAMEX, FC2_BIAS_ARRSIZE * sizeof(float));
else if(fc2_weight.array == NULL && strcmp(model_name, "fc2_weight") == 0)
return fc2_weight.array = (float*)mymalloc(SRAMEX, FC2_WEIGHT_ARRSIZE * sizeof(float));
else if(data.array == NULL && strcmp(model_name, "data") == 0)
return data.array = (float*)mymalloc(SRAMEX, DATA_ARRSIZE * sizeof(float));
// else if(data.array == NULL && strcmp(model_name, "data") == 0)
// return data.array = (float*)mymalloc(SRAMEX, DATA_ARRSIZE * sizeof(float));
else if(strcmp(model_name, "all") == 0){
if(conv1_bias.array == NULL)conv1_bias.array = (float*)mymalloc(SRAMEX, CONV1_BIAS_ARRSIZE * sizeof(float));
if(conv1_weight.array == NULL)conv1_weight.array = (float*)mymalloc(SRAMEX, CONV1_WEIGHT_ARRSIZE * sizeof(float));
@@ -50,7 +50,7 @@ float* modelmym_init(char* model_name){
if(fc1_weight.array == NULL)fc1_weight.array = (float*)mymalloc(SRAMEX, FC1_WEIGHT_ARRSIZE * sizeof(float));
if(fc2_bias.array == NULL)fc2_bias.array = (float*)mymalloc(SRAMEX, FC2_BIAS_ARRSIZE * sizeof(float));
if(fc2_weight.array == NULL)fc2_weight.array = (float*)mymalloc(SRAMEX, FC2_WEIGHT_ARRSIZE * sizeof(float));
if(data.array == NULL)data.array = (float*)mymalloc(SRAMEX, DATA_ARRSIZE * sizeof(float));
// if(data.array == NULL)data.array = (float*)mymalloc(SRAMEX, DATA_ARRSIZE * sizeof(float));
}
return NULL;
}
@@ -61,67 +61,67 @@ u8 modelmym_free(char* model_name){
if(conv1_bias.array != NULL && strcmp(model_name, "conv1_bias") == 0){
myfree(SRAMEX,conv1_bias.array);
conv1_bias.array = NULL;
conv1_bias.realength = NULL;
conv1_bias.realength = 0;
return 1;
}
else if(conv1_weight.array != NULL && strcmp(model_name, "conv1_weight") == 0){
myfree(SRAMEX,conv1_weight.array);
conv1_weight.array = NULL;
conv1_weight.realength = NULL;
conv1_weight.realength = 0;
return 1;
}
else if(conv2_bias.array != NULL && strcmp(model_name, "conv2_bias") == 0){
myfree(SRAMEX,conv2_bias.array);
conv2_bias.array = NULL;
conv2_bias.realength = NULL;
conv2_bias.realength = 0;
return 1;
}
else if(conv2_weight.array != NULL && strcmp(model_name, "conv2_weight") == 0){
myfree(SRAMEX,conv2_weight.array);
conv2_weight.array = NULL;
conv2_weight.realength = NULL;
conv2_weight.realength = 0;
return 1;
}
else if(conv3_bias.array != NULL && strcmp(model_name, "conv3_bias") == 0){
myfree(SRAMEX,conv3_bias.array);
conv3_bias.array = NULL;
conv3_bias.realength = NULL;
conv3_bias.realength = 0;
return 1;
}
else if(conv3_weight.array != NULL && strcmp(model_name, "conv3_weight") == 0){
myfree(SRAMEX,conv3_weight.array);
conv3_weight.array = NULL;
conv3_weight.realength = NULL;
conv3_weight.realength = 0;
return 1;
}
else if(fc1_bias.array != NULL && strcmp(model_name, "fc1_bias") == 0){
myfree(SRAMEX,fc1_bias.array);
fc1_bias.array = NULL;
fc1_bias.realength = NULL;
fc1_bias.realength = 0;
return 1;
}
else if(fc1_weight.array != NULL && strcmp(model_name, "fc1_weight") == 0){
myfree(SRAMEX,fc1_weight.array);
fc1_weight.array = NULL;
fc1_weight.realength = NULL;
fc1_weight.realength = 0;
return 1;
}
else if(fc2_bias.array != NULL && strcmp(model_name, "fc2_bias") == 0){
myfree(SRAMEX,fc2_bias.array);
fc2_bias.array = NULL;
fc2_bias.realength = NULL;
fc2_bias.realength = 0;
return 1;
}
else if(fc2_weight.array != NULL && strcmp(model_name, "fc2_weight") == 0){
myfree(SRAMEX,fc2_weight.array);
fc2_weight.array = NULL;
fc2_weight.realength = NULL;
fc2_weight.realength = 0;
return 1;
}
else if(data.array != NULL && strcmp(model_name, "data") == 0){
myfree(SRAMEX,data.array);
data.array = NULL;
data.realength = NULL;
// myfree(SRAMEX,data.array);
memset(data.array, 0 ,data.maxlength);
// data.realength = 0;
return 1;
}
else if(strcmp(model_name, "all") == 0){
@@ -138,7 +138,7 @@ u8 modelmym_free(char* model_name){
modelmym_free("data");
return 2;
}
return NULL;
return 0;
}
@@ -165,14 +165,15 @@ u8 model_write(char* model_name)
u8 _times=0;
u32 _larr = 0;
u8 _len = strlen(model_name);
char _path[_len+1+7+30];
char _path[_len+1+7+35];
char _datapath[_len+1+7+35];
char _fstr[READLENGTH+1] = {0};
char _sstr[2];
int progress;
Model *_model = model(model_name);
if(_model == NULL || strcmp(model_name, "data") == 0){
sprintf(_path, "0:/%s.txt", model_name);
sprintf(_path, "dataset/_data/%s.txt", model_name);
if(f_open(file, (const TCHAR *)_path, 1)){
DEBUG_PRINTF("\r\n<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><EFBFBD>ģ<EFBFBD>ͻ<EFBFBD>Data<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\r\n");
return 199;
@@ -183,8 +184,8 @@ u8 model_write(char* model_name)
}
if(_model -> dname == NULL){
sprintf(_path, "0:/%s.txt", _model -> name);
if(f_open(file, (TCHAR *)_path, 1)){
sprintf(_path, "dataset/%s.txt", _model -> name);
if(f_open(file, (const TCHAR *)_path, 1)){
DEBUG_PRINTF("Ԥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģ<EFBFBD>ͣ<EFBFBD>[%s]\r\n", _path);
return 4;
}
@@ -195,6 +196,13 @@ u8 model_write(char* model_name)
return 200;
}
if(_model -> dname)sprintf(_datapath, "_data/%s", _model -> dname);
sprintf(_path, "dataset/%s.txt", _model -> dname ? _datapath : _model -> name);
if(f_open(file, (const TCHAR *)_path, 1)){
DEBUG_PRINTF("<EFBFBD>ļ<EFBFBD>[%s]<5D>޷<EFBFBD><DEB7><EFBFBD><EFBFBD><EFBFBD>\r\n", _model -> dname ? _model -> dname : _model -> name);
return 199;
}
DEBUG_PRINTF("д<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģ<EFBFBD>Ͳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǣ<EFBFBD>%s\r\n", _model -> name);
if(_model -> dname)DEBUG_PRINTF("д<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Data<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD><EFBFBD>ǣ<EFBFBD>%s\r\n", _model -> dname);
DEBUG_PRINTF("д<EFBFBD><EFBFBD>ģ<EFBFBD>Ͳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>󳤶<EFBFBD>Ϊ<EFBFBD><EFBFBD>%d\r\n", _model -> maxlength);
@@ -239,9 +247,9 @@ u8 model_write(char* model_name)
}
}
DEBUG_PRINTF("\r\nģ<EFBFBD>Ͳ<EFBFBD><EFBFBD><EFBFBD>[%s]<5D><>д<EFBFBD>뵽<EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD>! ģ<>ͳ<EFBFBD><CDB3><EFBFBD>Ϊ %d\r\n",_model -> dname ? _model -> dname : _model -> name,_model -> realength);
return 1;
return 0;
}
return NULL;
return 1;
}
@@ -269,26 +277,26 @@ u8 model_read(char* model_name, u32 start, u32 end, u32 gap){
return 1;
}
}
return NULL;
return 0;
}
u8 model_switchdata(char* data_name){
u8 _len = strlen(data_name);
char _path[_len+1+7];
char _path[_len+1+7+35];
if(data.array != NULL)modelmym_free("data");
sprintf(_path, "0:/%s.txt",data_name);
sprintf(_path, "dataset/_data/%s.txt",data_name);
if(f_open(file,(const TCHAR*)_path,1)){
DEBUG_PRINTF("\r\nData<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>[%s]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\r\n",data_name);
return NULL;
return 0;
}else{
u8 _res = model_write(data_name);
if (_res == NULL) {
if (_res) {
DEBUG_PRINTF("Data<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>[%s]<5D>л<EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD>\r\n",data_name);
return NULL;
return 0;
}
else printf("Data<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>[%s]<5D>л<EFBFBD><D0BB>ɹ<EFBFBD><C9B9><EFBFBD>\r\n",data_name);
else DEBUG_PRINTF("Data<EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>[%s]<5D>л<EFBFBD><D0BB>ɹ<EFBFBD><C9B9><EFBFBD>\r\n",data_name);
DEBUG_PRINTF("data_name<EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><EFBFBD>%d\r\n_path<EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><EFBFBD>%d\r\n_pathΪ<EFBFBD><EFBFBD>%s\r\n",_len,sizeof(_path),_path);
return 1;
}
@@ -321,7 +329,7 @@ u8 model_info(char* model_name){
//if(strcmp(_model -> name, "data") == 0)printf("dataset is: %s\r\n",_model -> dname); <20>⺯<EFBFBD><E2BAAF><EFBFBD><EFBFBD>BUG<55><47><EFBFBD><EFBFBD>model_dataset<65><74><EFBFBD><EFBFBD>
return 1;
}
return NULL;
return 0;
}
@@ -352,6 +360,8 @@ void model_init(){
conv1_weight.name = "conv1_weight";
conv1_weight.array = modelmym_init(conv1_weight.name);
conv1_weight.maxlength = CONV1_WEIGHT_ARRSIZE;
conv1_weight.channel = 1;
conv1_weight.num_kernels = CONV1_BIAS_ARRSIZE;
conv2_bias.name = "conv2_bias";
conv2_bias.array = modelmym_init(conv2_bias.name);
@@ -360,6 +370,8 @@ void model_init(){
conv2_weight.name = "conv2_weight";
conv2_weight.array = modelmym_init(conv2_weight.name);
conv2_weight.maxlength = CONV2_WEIGHT_ARRSIZE;
conv2_weight.channel = 32;
conv2_weight.num_kernels = CONV2_BIAS_ARRSIZE;
conv3_bias.name = "conv3_bias";
conv3_bias.array = modelmym_init(conv3_bias.name);
@@ -368,6 +380,8 @@ void model_init(){
conv3_weight.name = "conv3_weight";
conv3_weight.array = modelmym_init(conv3_weight.name);
conv3_weight.maxlength = CONV3_WEIGHT_ARRSIZE;
conv3_weight.channel = 64;
conv3_weight.num_kernels = CONV3_BIAS_ARRSIZE;
fc1_bias.name = "fc1_bias";
fc1_bias.array = modelmym_init(fc1_bias.name);
@@ -384,10 +398,14 @@ void model_init(){
fc2_weight.name = "fc2_weight";
fc2_weight.array = modelmym_init(fc2_weight.name);
fc2_weight.maxlength = FC2_WEIGHT_ARRSIZE;
fc2_weight.num_kernels = FC2_BIAS_ARRSIZE;
data.name = "data";
data.array = modelmym_init(data.name);
data.array = data_array;
data.maxlength = DATA_ARRSIZE;
data.realength = DATA_ARRSIZE;
data.dname = "data";
memset(data.array, 0, sizeof(float)*DATA_ARRSIZE);
}

143
PORTING/CNN/cnn_model.h
View File

@@ -19,22 +19,29 @@ typedef struct {
float* array;
u32 maxlength;
u32 realength;
u8 channel;
u8 num_kernels;
} Model;
#define READLENGTH 11*10
#define CONV1_BIAS_ARRSIZE 32
#define CONV1_WEIGHT_ARRSIZE 32*1*3*3 //288
#define CONV2_BIAS_ARRSIZE 64
#define CONV2_WEIGHT_ARRSIZE 64*32*3*3 //18432
#define CONV3_BIAS_ARRSIZE 128
#define CONV3_WEIGHT_ARRSIZE 128*64*3*3 //73728
#define FC1_BIAS_ARRSIZE 128
#define FC1_WEIGHT_ARRSIZE 128*18432 //2359296
#define FC2_BIAS_ARRSIZE 7
#define FC2_WEIGHT_ARRSIZE 7*128 //896
#define DATA_ARRSIZE 1250000 //1250000
#define READLENGTH (11*10)
#define CONV1_BIAS_ARRSIZE (32)
#define CONV1_WEIGHT_ARRSIZE (32*1*3*3) //288
#define CONV2_BIAS_ARRSIZE (64)
#define CONV2_WEIGHT_ARRSIZE (64*32*3*3) //18432
#define CONV3_BIAS_ARRSIZE (128)
#define CONV3_WEIGHT_ARRSIZE (128*64*3*3) //73728
#define FC1_BIAS_ARRSIZE (128)
#define FC1_WEIGHT_ARRSIZE (128*18432) //2359296
#define FC2_BIAS_ARRSIZE (4) //4<><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define FC2_WEIGHT_ARRSIZE (4*128)
#define DATA_ARRSIZE (1300000) //ԭʼ<D4AD><CABC><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD> 1300000
@@ -75,116 +82,4 @@ u8 sd_read(u32 length, char* model_name,u32 gap);
//fc1_weight[a*18432+b*1] a:0~127 b:0~18431
//fc2_bias[a*1] a:0~6
//fc2_weight[a*128+b*1] a:0~6 b:0~127
/*--------------------------------
for(u8 a; a<?; a++)
--------------------------------*/
//u8 sd_read(u16 length)
//{
// u8 res=0;
// char _tmp[11] = "";
// float floatArray[32] = {0};
// int _larr = 0;
// printf("\r\nRead file data is:\r\n");
// res=f_read(file,fatbuf,length,&br);
// if(res) //<2F><><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD><EFBFBD><EFBFBD>
// {
// printf("\r\n<><6E><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD><EFBFBD><EFBFBD>:%d\r\n",res);
// }else
// {
// for(int i=0;i<length;i++){
// if(fatbuf[i]==0x0d){
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[string]: %s\r\n",i,_tmp);
// i++;
// float value = atof(_tmp);
// memset(_tmp, 0, sizeof(_tmp));
// floatArray[_larr++] = value;
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[float]: %f\r\n",i,value);
// }else{
// char buffer[2];
// sprintf(buffer, "%c", fatbuf[i]);
// strcat(_tmp, buffer);
// DEBUG_PRINTF("[%d]: %c\r\n",i,fatbuf[i]);
// }
// }
// }
// for (int i=0;i<_larr;i++){
// DEBUG_PRINTF("floatArray[%d]: %f\r\n",i,floatArray[i]);
// }
// return res;
//}
//u8 sd_read(u16 length, char* model)
//{
// float* floatArray = NULL;
// if((floatArray = model_init(model)) == NULL)printf("<22><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
// u8 res=0;
// char _tmp[11] = "";
// u32 _larr = 0;
// length = length*11;
// printf("\r\nRead file data is:\r\n");
// for(int i=0;i<length/512;i++){
// res=f_read(file,fatbuf,512,&br);
// if(res)printf("\r\n<><6E><EFBFBD><EFBFBD><EFBFBD>ݳ<EFBFBD><DDB3><EFBFBD><EFBFBD><EFBFBD>:%d\r\n",res);
// else{
// for(int i=0;i<br;i++){
// if(fatbuf[i]==0x0d){
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[string]: %s\r\n",i,_tmp);
// i++;
// float value = atof(_tmp);
// memset(_tmp, 0, sizeof(_tmp));
// floatArray[_larr++] = value;
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[float]: %f\r\n",i,value);
// }else{
// char buffer[2];
// sprintf(buffer, "%c", fatbuf[i]);
// strcat(_tmp, buffer);
// DEBUG_PRINTF("[%d]: %c\r\n",i,fatbuf[i]);
// }
// }
// }
// }
// if(length%512){
// res=f_read(file,fatbuf,length%512,&br);
// if(res)printf("\r\nRead Error:%d\r\n",res);
// else{
// for(int i=0;i<br;i++){
// if(fatbuf[i]==0x0d){
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[string]: %s\r\n",i,_tmp);
// i++;
// float value = atof(_tmp);
// memset(_tmp, 0, sizeof(_tmp));
// floatArray[_larr++] = value;
// DEBUG_PRINTF("<22>س<EFBFBD>[%d] <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[float]: %f\r\n",i,value);
// }else{
// char buffer[2];
// sprintf(buffer, "%c", fatbuf[i]);
// strcat(_tmp, buffer);
// DEBUG_PRINTF("[%d]: %c\r\n",i,fatbuf[i]);
// }
// }
// }
// }
// for (int i=0;i<_larr/10;i++){
// printf("floatArray[%d]: %f\r\n",i*10,floatArray[i*10]);
// }
// return res;
//}
#endif

25
PORTING/CNN/debug.c
View File

@@ -1,8 +1,9 @@
#include "debug.h"
#include "led.h"
#include "exfuns.h"
u8 _DEBUG = 0;
u8 _DEBUG = 1;
@@ -33,6 +34,26 @@ void SDRAM_USED(){
}
void scan_files(u8 * path)
{
FRESULT res;
res = f_opendir(&dir,(const TCHAR*)path); //<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>Ŀ¼
if (res == FR_OK)
{
printf("\r\n");
while(1)
{
res = f_readdir(&dir, &fileinfo); //<2F><>ȡĿ¼<C4BF>µ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ļ<EFBFBD>
if (res != FR_OK || fileinfo.fname[0] == 0) break; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><>ĩβ<C4A9><CEB2>,<2C>˳<EFBFBD>
//if (fileinfo.fname[0] == '.') continue; //<2F><><EFBFBD><EFBFBD><EFBFBD>ϼ<EFBFBD>Ŀ¼
printf("%s/", path);//<2F><>ӡ·<D3A1><C2B7>
printf("%s\r\n",fileinfo.fname);//<2F><>ӡ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
}
}
}
TIM_HandleTypeDef TIM3_Handler; //<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//ͨ<>ö<EFBFBD>ʱ<EFBFBD><CAB1>3<EFBFBD>жϳ<D0B6>ʼ<EFBFBD><CABC>
@@ -79,6 +100,6 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim==(&TIM3_Handler))
{
LED1=!LED1; //LED1<44><31>ת
LED_R=!LED_R; //LED1<44><31>ת
}
}

1
PORTING/CNN/debug.h
View File

@@ -10,6 +10,7 @@
void DEBUG(void);
void DEBUG_PRINTF(const char *fmt, ...);
void SDRAM_USED(void);
void scan_files(u8 * path);
void TIM3_Init(u16 arr,u16 psc);
#endif

70
PORTING/CNN/tools.c Normal file
View File

@@ -0,0 +1,70 @@
#include "tools.h"
char* uuid(){
static char uuid_str[9];
u32 time_stamp = HAL_GetTick();
u32 random_part = rand();
snprintf(uuid_str, 9, // 16 λ UUID<49><44>8 <20><><EFBFBD>ַ<EFBFBD> + <20><><EFBFBD><EFBFBD>ֹ<EFBFBD><D6B9><EFBFBD><EFBFBD>
"%04lX%04lX",
(unsigned long)(time_stamp & 0xFFFF),
(unsigned long)(random_part & 0xFFFF));
return uuid_str;
}
void send_blocks(float* arr, char* uuid_str){
// <20><><EFBFBD>鴦<EFBFBD><E9B4A6> ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>洢1000<30><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD><EFBFBD>
char* block = (char*) mymalloc(SRAMEX,sizeof(char)*100*100);
memset(block, 0 ,sizeof(char)*100*100);
int block_index = 0;
int _total_len = 0;
int total_len = 0;
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
int n = snprintf(block + block_index, 100 * 100 - block_index, "%.6f|", arr[i * 100 + j]);
block_index += n;
if (block_index >= 7000) {
block_index = 0; // <20><><EFBFBD>ÿ<EFBFBD>
_total_len++;
}
}
}
if (!block_index)_total_len--;
block_index = 0;
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
int n = snprintf(block + block_index, 100*100 - block_index, "%.6f|", arr[i*100+j]);
block_index += n;
if (block_index >= 7000) {
char* _block = (char*) mymalloc(SRAMEX,sizeof(char)*100*100);
memset(_block, 0 ,sizeof(char)*100*100);
block_index = 0; // <20><><EFBFBD>ÿ<EFBFBD>
sprintf(_block, "{\\\"uuid\\\":\\\"%s\\\",\\\"Bid\\\":\\\"%d\\\",\\\"Eid\\\":\\\"%d\\\",\\\"Block\\\":\\\"%s\\\"}\n", uuid_str, total_len++, _total_len, block);
//DEBUG_PRINTF("%s", _block);
CSTX_4G_ALiYunIOTSenddata_string(_block,"data_string");
myfree(SRAMEX,_block);
_block = NULL;
}
}
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>
if (block_index > 0) {
char* _block = (char*) mymalloc(SRAMEX,sizeof(char)*100*100);
memset(_block, 0 ,sizeof(char)*100*100);
block_index = 0;
sprintf(_block, "{\\\"uuid\\\":\\\"%s\\\",\\\"Bid\\\":\\\"%d\\\",\\\"Eid\\\":\\\"%d\\\",\\\"Block\\\":\\\"%s\\\"}\n", uuid_str, total_len, _total_len, block);
//DEBUG_PRINTF("%s", _block);
CSTX_4G_ALiYunIOTSenddata_string(_block,"data_string");
myfree(SRAMEX,_block);
_block = NULL;
}
myfree(SRAMEX,block);
block = NULL;
}

7
PORTING/CNN/tools.h Normal file
View File

@@ -0,0 +1,7 @@
#include "cnn_model.h"
#include "debug.h"
#include "EC800M.h"
char* uuid(void);
void send_blocks(float* arr, char* uuid_str);

1
PORTING/USMART/usmart_config.c
View File

@@ -13,6 +13,7 @@ struct _m_usmart_nametab usmart_nametab[]=
{
(void*)DEBUG,"void DEBUG(void)",
(void*)SDRAM_USED,"void SDRAM_USED(void)",
(void*)scan_files,"void scan_files(u8 * path)",
(void*)modelmym_init,"float* modelmym_init(char* model_name)",
(void*)modelmym_free,"u8 modelmym_free(char* model_name)",

2
README.md
View File

@@ -1,6 +1,6 @@
### 移植代码说明
将需要移植的代码放置在 `../PORTING` 目录下。以下是需要修改的内容及注意事项：
需要移植的代码位于 `../PORTING` 目录下。以下是注意事项：
---

18
USER/FATFS.uvoptx
View File

@@ -723,7 +723,7 @@
<Group>
<GroupName>USMART</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
@@ -767,7 +767,7 @@
<Group>
<GroupName>FATFS</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
@@ -823,7 +823,7 @@
<Group>
<GroupName>CNN</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>
@@ -863,6 +863,18 @@
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>9</GroupNumber>
<FileNumber>52</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\PORTING\CNN\tools.c</PathWithFileName>
<FilenameWithoutPath>tools.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group>
</ProjectOpt>

5
USER/FATFS.uvprojx
View File

@@ -677,6 +677,11 @@
<FileType>1</FileType>
<FilePath>..\PORTING\CNN\cnn.c</FilePath>
</File>
<File>
<FileName>tools.c</FileName>
<FileType>1</FileType>
<FilePath>..\PORTING\CNN\tools.c</FilePath>
</File>
</Files>
</Group>
</Groups>

5
USER/main.c
View File

@@ -18,6 +18,7 @@
#include "cnn_model.h"
#include "debug.h"
#include "cnn.h"
#include "tools.h"
@@ -132,7 +133,9 @@ int main(void)
model_write("all");
printf("初始化完成！\r\n");
//run_dataset();
run_dataset();
SDRAM_USED();
while(1){
if(isrun)cnn_run();
}