一、事有蹊跷
        接篇一，前面提到在使用cube.AI生成的c语言神经网络模型API调用时，输入数据数量是24，输出数据数量是4，但上文设想采集了三轴加速度传感器的x/y/z三个各数据，按Jogging(慢跑),Walking(走了)两种态势采集了两组数据.csv，那么在实际中应该是输入数据数量是3（x/y/x-value），输出数据数量是2(Jogging,Walking两种类别)。

        由于模型API是cube.AI基于训练输出的神经网络模型而生成的，想必应该是训练神经网络模型时参数设置问题，因此我们重新回顾HAR训练项目.
* Y: G  f( R' B" w
        进入“STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR”目录，运行 python .\RunMe.py -h命令，查看参数设置指令帮助，可以看到--seqLength和--stepSize参数设置都和input有关，默认数值是24，就可以笃定在API中调用时，输入数据数量是24就来自于此。

1. PS D:\tools\arm_tool\STM32CubeIDE\STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR> python3 .\RunMe.py -h
   # b) s& K7 v; u
2. Using TensorFlow backend.
   4 G3 ?1 N! _' i" w# b
3. usage: RunMe.py [-h] [--model MODEL] [--dataset DATASET] [--dataDir DATADIR]
   + O. `5 P. [  o/ A& }+ `
4.                 [--seqLength SEQLENGTH] [--stepSize STEPSIZE] [-m MERGE]
   
5.                 [--preprocessing PREPROCESSING] [--trainSplit TRAINSPLIT]
   
6.                 [--validSplit VALIDSPLIT] [--epochs N] [--lr LR]
   . J# E' w1 v0 z5 B8 v" z, h
7.                 [--decay DECAY] [--batchSize N] [--verbose N]
   
8.                 [--nrSamplesPostValid NRSAMPLESPOSTVALID]
   - Z5 v& l" k& p& V6 Q) t) e
9. 
   # f! b  z- F- T6 ]8 d  e; ]
10. Human Activity Recognition (HAR) in Keras with Tensorflow as backend on WISDM
    # B" w0 \8 }9 I* @+ S+ ^3 Z7 f
11. and WISDM + self logged datasets
    
12. 
    
13. optional arguments:
    
14.   -h, --help            show this help message and exit
    ( e2 g, x4 d: [8 d4 L. @
15.   --model MODEL         choose one of the two availavle choices, IGN or GMP, (
    # E/ d3 w6 Y; l+ g0 Z7 i
16.                         default = IGN )
    
17.   --dataset DATASET     choose a dataset to use out of two choices, WISDM or
    
18.                         AST, ( default = WISDM )
    1 W9 [) M+ w. t5 V7 W# ~; C8 B
19.   --dataDir DATADIR     path to new data collected using STM32 IoT board
    + X+ v! @  f, H$ t! A
20.                         recorded at 26Hz as sampling rate, (default = )
    $ N- R6 h9 B6 v$ _7 _
21.   --seqLength SEQLENGTH
    7 {) k1 ?# ?# I& `/ i
22.                         input sequence lenght (default:24)
    
23.   --stepSize STEPSIZE   step size while creating segments (default:24, equal
    % G) f: b$ y4 E5 g, X( s
24.                         to seqLen)
    
25.   -m MERGE, --merge MERGE
    
26.                         if to merge activities (default: True)
    
27.   --preprocessing PREPROCESSING
    
28.                         gravity rotation filter application (default = True)
    
29.   --trainSplit TRAINSPLIT
    0 i, a: E) I2 Y: X5 S
30.                         train and test split (default = 0.6 (60 precent for
    
31.                         train and 40 precent for test))
    & \; |6 f4 }& c, y+ h# W
32.   --validSplit VALIDSPLIT
    7 o+ A  Z7 q; @( S: B
33.                         train and validation data split (default = 0.7 (70
    4 Y. t0 ^: i/ H5 X/ k' A) t
34.                         percent for train and 30 precent for validation))
    
35.   --epochs N            number of total epochs to run (default: 20)
    
36.   --lr LR               initial learning rate
    
37.   --decay DECAY         decay in learning rate, (default = 1e-6)
    
38.   --batchSize N         mini-batch size (default: 64)
    
39.   --verbose N           verbosity of training and test functions in keras, 0,
    7 _5 J  ~/ b9 R5 X) ~) i- h
40.                         1, or 2. Verbosity mode. 0 = silent, 1 = progress bar,
    
41.                         2 = one line per epoch (default: 1)
    
42.   --nrSamplesPostValid NRSAMPLESPOSTVALID
    
43.                         Number of samples to save from every class for post
    : R* ^' I, K7 X
44.                         training and CubeAI conversion validation. (default =
    
45.                         2)
    # y3 F: T  [& I# d8 K
46. PS D:\tools\arm_tool\STM32CubeIDE\STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR>

复制代码

) T# g$ f' {  k, M! @        而输出数据数量是4的原因追踪源码可以看到，来自于PrepareDataset.py（数据集预处理源文件），由于在参数--dataset默认设置是WISDM，因此分类输出即为'Jogging', 'Stationary', 'Stairs', 'Walking'，即输出数据数量为4：
- p, K4 J4 `3 \( t5 x! c  i
# S! D1 w. g0 U1 ^' x
2 u! n2 j. b0 l9 x; U
         下面来深入了解HAR（Human Activity Recognition，人类行为识别）案例为何会有这样的设置。

二、HAR训练项目分析
1 z. F6 F7 A/ Z        由于前文仅仅采集Jogging(慢跑),Walking(走了)两种态势数据，但通常Stationary（站立不动）态势更常见和默认姿态，因此本文按篇一方法再采集一组Stationary姿态日志数据。

7 X. J6 v9 P" |/ W2 W% b2 d

         并同样拷贝到HAR/Log_data目录下，数据如下：
% s- @* G) C, w3 h/ Q: L
4 n9 f; u  ^, w' N+ L' i

# j! q& ]& G/ L+ b/ {3 l- e! @1 V         在PrepareDataset.py文件中，read_dataset( self )和preprocess_data( self, data )是用来处理WISDM数据集的，而get_data_from_file( self, fileName, preparedDataFileName )和prepare_self_logged_data( self )函数是用来处理自行采集数据集的。
1 g4 O0 o& I  V6 ^9 w
% G  ?2 d/ z, D" ]. S
8 F: B  r  ^4 M& C4 e
9 w1 ~. c& ?8 o7 M  P% ]' {) {5 U  V+ W7 z         read_dataset会读取WISDM数据集的datasets/WISDM_ar_v1.1_raw.txt文件
+ ~2 W" U, C* Z1 U% h

" W2 f8 e% V* K$ q# l
/ \8 e1 b; y6 o$ j6 b         这些数据是已经做了转换预处理的数据集，见下图红线标注部分。

7 {* c) L9 \$ |  e7 r1 T

         而get_data_from_file( self, fileName, preparedDataFileName )函数读取自行采集数据集(.csv)文件时，做了转换预处理，确保和WISDM数据集一致。

6 o% N7 X' ~+ Z& C
* V% D2 _& O- ^5 u8 ^# c
7 i  Y) P! H) Y         同时项目还把预处理过的自行采集数据集与训练好的模型一并以csv格式输出到目录中，以源数据目录命名，例如Log_data.csv。



         下来就是输入数据数量问题，由于在FP-AI-SENSING1案例项目，数据采集是按一定时间间隔连续实时采集的，采集间隔也很短（毫秒级别）

+ d3 F9 S; R8 ^: p. E/ j2 j* L& A

4 C' M& u5 c9 `0 M7 d  j3 }         因此get_segment_indices和get_data_segments函数就是将采集到的连续数据处理成一个长度为seqLength的窗口的输入数据集，即每次输入数据是一段24组（一组3个数据值，x/y/z）数据，也就对应了我们前文定义输入数据缓存是static ai_float in_data[AI_HAR_IGN_IN_1_SIZE=24*3*1];，共72个float 数据。显然HAR项目做法是通过一组连续数据集作为输入比单个态势数据更能反应人类行为姿态的持续性，更贴近实际。


3 b( z9 \* f' _2 v9 ^5 P8 ~
         在read_dataset函数加入打印读取的WISDM数据集语句。
. L  \+ |3 W- |1 n

: f+ h& V/ G6 S& q
         在prepare_self_logged_data函数加入打印读取自行采集数据集语句



$ c% s" I( @1 p/ s/ W+ P         因为打印输出依据后，后续会打印数据按输入数据长度来分段的信息，暂时保持seqLength和stepSize为默认的24数值，运行python3 .\RunMe.py --dataDir=Log_data命令：

1. PS D:\tools\arm_tool\STM32CubeIDE\STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR> python3 .\RunMe.py --dataDir=Log_data
   
2. Using TensorFlow backend.
   
3. Running HAR on WISDM dataset, with following variables
   8 a' w) L! t4 a* q
4. merge = True
   2 r# i9 f! ~. O7 q/ s3 b
5. modelName = IGN,
   1 i7 X  X2 K% D7 d2 f
6. segmentLength = 24
   . Q' h$ h$ n  _+ e9 l
7. stepSize = 24
   & @: Y; N/ o) }3 {( z; o8 r& c
8. preprocessing = True
   $ N2 O' e: Y. h# e& e
9. trainTestSplit = 0.6
   0 j0 a7 y2 \! L. `
10. trainValidationSplit = 0.7
    9 Y- r, y4 h$ e( P6 p& {/ ~  o3 {
11. nEpochs = 20
      m) L9 ?* H" o9 z0 u9 }
12. learningRate = 0.0005
    $ x5 U. L% G+ M$ T& n% ^
13. decay =1e-06
    
14. batchSize = 64
    0 t% i0 X* W+ T  D$ _& L
15. verbosity = 1
    , _- r0 O  M3 e" p; C" n
16. dataDir = Log_data
    ' q' H0 q2 ], |! E- y# C
17. nrSamplesPostValid = 2
    
18.          User Activity_Label     Arrival_Time         x          y             z
    . [5 z4 r2 O: w7 I9 ]$ w: a5 h
19. 0          33        Jogging   49105962326000 -0.694638  12.680544   0.50395286;
    ( o: F7 j9 b+ ~) p( ?% H3 y7 L
20. 1          33        Jogging   49106062271000  5.012288  11.264028   0.95342433;
    
21. 2          33        Jogging   49106112167000  4.903325  10.882658  -0.08172209;
    ( {/ d- D9 o0 F- p6 G" a$ E
22. 3          33        Jogging   49106222305000 -0.612916  18.496431    3.0237172;
    
23. 4          33        Jogging   49106332290000 -1.184970  12.108489     7.205164;
    
24. ...       ...            ...              ...       ...        ...           ...
    & p, F0 E/ X% @$ C# [$ H, z
25. 1098199    19        Sitting  131623331483000  9.000000  -1.570000         1.69;
    
26. 1098200    19        Sitting  131623371431000  9.040000  -1.460000         1.73;
    
27. 1098201    19        Sitting  131623411592000  9.080000  -1.380000         1.69;
    6 h) N# H7 E+ h. {3 h3 `# h7 y) Q
28. 1098202    19        Sitting  131623491487000  9.000000  -1.460000         1.73;
    
29. 1098203    19        Sitting  131623531465000  8.880000  -1.330000         1.61;
      z# {, q1 O4 z
30. 
    / [$ c5 s1 ?6 f8 u, t0 {4 H" Q
31. [1098204 rows x 6 columns]
    
32. Segmenting Train data
    & m- a( t+ `5 |0 P) C4 A4 C- [
33. Segments built : 100%|███████████████████████████████████████████████████| 27456/27456 [00:28<00:00, 954.67 segments/s]
    
34. Segmenting Test data
    ! D6 {1 @; e0 j+ R# z: \
35. Segments built : 100%|██████████████████████████████████████████████████| 18304/18304 [00:14<00:00, 1298.22 segments/s]
    : H9 c$ ?6 g7 }! U/ e  N$ R
36. Segmentation finished!
    
37. preparing data file from all the files in directory  Log_data
    / u7 n' a* J; \, N1 U# u
38. parsing data from  IoT01-MemsAnn_11_Jan_23_16h_57m_17s.csv
    , g8 k9 c/ }* S( E& {
39. parsing data from  IoT01-MemsAnn_11_Jan_23_16h_57m_53s.csv
    
40. parsing data from  IoT01-MemsAnn_26_Jan_23_15h_51m_01s.csv
    2 F0 J% o- b' b2 ~( p; u" }- `, F; `
41.              x         y         z Activity_Label
    ; R7 V) G- U/ w
42. 0    -1.965414 -0.143890  9.367359        Walking
    
43. 1    -1.629783  0.664754  9.618931        Walking
    & U+ R2 X9 q$ Y- I# L- h9 L/ b
44. 2    -1.720833  0.384629  9.492079        Walking
    
45. 3    -1.681419  0.534637  9.648173        Walking
    # Y8 l" B4 y' Z- w
46. 4    -1.729849  0.421650  9.557259        Walking
    
47. ...        ...       ...       ...            ...
    9 A2 f; G. l- A4 o9 S/ i
48. 2639 -1.171046  0.033572  9.746819     Stationary
    
49. 2640 -1.212873  0.007256  9.759376     Stationary
    : Q) Q+ L: ]; x+ y3 n* E9 s- B
50. 2641 -1.212011  0.019485  9.753982     Stationary
    
51. 2642 -1.172311 -0.004511  9.734770     Stationary
    
52. 2643 -1.175431  0.035787  9.753447     Stationary
    
53. 
    # c# _; Z8 k  |6 J$ b5 ^
54. [2644 rows x 4 columns]
    
55. Segmenting the AI logged Train data
    / [. C# F4 s, D: e
56. Segments built : 100%|████████████████████████████████████████████████████████| 67/67 [00:00<00:00, 2795.31 segments/s]
    3 x* Y# _0 L' N- S7 V+ O) ~
57. Segmenting the AI logged Test data
    % z; a* B( ]- r/ |/ [6 |
58. Segments built : 100%|████████████████████████████████████████████████████████| 45/45 [00:00<00:00, 2370.94 segments/s]
    + B! m  A# U( Y" ~/ V- q
59. Segmentation finished!
    # z: F, ?/ h6 {6 N* Z. i
60. _________________________________________________________________
    
61. Layer (type)                 Output Shape              Param #
    
62. =================================================================
    
63. conv2d_1 (Conv2D)            (None, 9, 3, 24)          408
    8 _, i  U& e+ S# B5 `
64. _________________________________________________________________
    
65. max_pooling2d_1 (MaxPooling2 (None, 3, 3, 24)          0
    
66. _________________________________________________________________
    2 T3 c5 D" ?- w0 c  h
67. flatten_1 (Flatten)          (None, 216)               0
    
68. _________________________________________________________________
    
69. dense_1 (Dense)              (None, 12)                2604
    8 `! x" X6 J$ U8 R8 W! [: u) p
70. _________________________________________________________________
    . O/ d/ C+ c1 z% L, k8 G
71. dropout_1 (Dropout)          (None, 12)                0
    ( p$ ~; u8 ~4 G
72. _________________________________________________________________
    5 g/ D' [0 z$ f" e9 P2 I# n3 P" Q
73. dense_2 (Dense)              (None, 4)                 52
    9 F9 p: E) z' v/ R2 ]
74. =================================================================
    
75. Total params: 3,064
    5 z2 E. c# l) x; X5 I0 p: m
76. Trainable params: 3,064
    
77. Non-trainable params: 0
    
78. _________________________________________________________________
    
79. Train on 19288 samples, validate on 8233 samples
    
80. Epoch 1/20
    " G/ A$ W4 o; [- l% x9 d
81. 2023-01-26 17:12:56.882726: I tensorflow/core/platform/cpu_feature_guard.cc:142] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2
    
82. 19288/19288 [==============================] - 1s 54us/step - loss: 1.2022 - acc: 0.5290 - val_loss: 0.7089 - val_acc: 0.7409
    & A6 E1 t( Q$ c) C& n9 _4 L) I! B
83. Epoch 2/20
    
84. 19288/19288 [==============================] - 1s 41us/step - loss: 0.7520 - acc: 0.7017 - val_loss: 0.5342 - val_acc: 0.7985
    , F% J8 V, u) H% `$ G+ Y! _
85. Epoch 3/20
    % {+ {5 s" J7 I% s0 u
86. 19288/19288 [==============================] - 1s 41us/step - loss: 0.6079 - acc: 0.7571 - val_loss: 0.4573 - val_acc: 0.8153
    - K7 {# B( C. y2 v0 J
87. Epoch 4/20
    8 T) ]  z, v" K0 n2 Y
88. ... ...
    ; u4 l8 a! f5 x
89. 19288/19288 [==============================] - 1s 39us/step - loss: 0.3306 - acc: 0.8899 - val_loss: 0.2669 - val_acc: 0.9113
    2 e+ p# ^" ^! `2 b5 ^5 n  V
90. Epoch 20/20
    . V/ P1 ~' n* r( w& e; ?4 p' h- z
91. 19288/19288 [==============================] - 1s 40us/step - loss: 0.3194 - acc: 0.8913 - val_loss: 0.2646 - val_acc: 0.9168
    + u8 ~7 L/ T/ ?/ Z/ X
92. 12831/12831 [==============================] - 0s 22us/step
    
93. Accuracy for each class is given below.
    $ _8 {# x* \4 ^0 |$ a' R, v5 c
94. Jogging     : 97.51 %
    . f8 N# z/ B" n
95. Stationary  : 98.63 %
    , l$ Q8 U5 c" K+ m3 }' A% ]3 G
96. Stairs      : 70.94 %
    5 ~8 c. ?0 ]) ?; C7 ]
97. Walking     : 81.55 %
    5 |* M# i1 F9 H1 [8 Q/ C- q
98. PS D:\tools\arm_tool\STM32CubeIDE\STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR>

复制代码

        读取到的WISDM数据集大小是1098204≈24*（27456+18304），而27456+18304是按--trainSplit参数默认值0.6：0.4比例切分的。读取到的自行采集数据大小是2644≈24*（67+45）。
. O* B1 J6 v( Z/ T8 v
* p1 a6 E0 P# d- m

5 M; ^. ^* {- i, E* ]8 t6 C 三、工程调整
        从前面分析来看，输入数据数量还是采用默认数值24问题不大（各位粉丝可以自行调整其大小来测试及观察效果），输出数据数量由于有WISDM数据集参与，保持'Jogging', 'Stationary', 'Stairs', 'Walking'是中分类也OK。现注意到，其实输入数据是经过了预处理转换实际加速度值，而非是传感器原始输出数值。

0 J% y, i' E+ I# A        由于自行采集数据增加了Stationary数据文件，因此在cubeMX上采用新的训练模型文件重新生成c语言的神经网络模型。

4 l2 F8 i7 [$ N5 k$ I

         然后调整输入数据及预处理函数acquire_and_process_data，采用真实数据来测试

- W% J" |0 k, @
' P8 }$ v5 j5 T/ I9 {
         该函数有原来的随机赋值，

1. int acquire_and_process_data(void *in_data,int factor)
   
2. {
     I/ g& n' d% T7 g2 E4 o$ I8 k6 }5 G
3.         printf("in_data:");
   6 j: h6 X( Y3 v1 @( M) Z
4.         for (int i=0; i<AI_HAR_IGN_IN_1_SIZE; i++)
   
5.         {
   8 I( _8 E) p- [  ?, H) ^
6.                 switch(i%3){
   3 Y* k% V, H! j3 Y
7.                 case 0:
   , U' o! g" }4 I% v& a1 Y& s
8.                         ((ai_float*)in_data)[i] = -175+(ai_float)(i*factor*1.2)/10.0;
   8 v( q4 V/ d0 S  c3 J, |
9.                         break;
   , d! S& ~! i4 J& n) s( f; b
10.                 case 1:
    : T: n: k$ j4 \2 e2 x! b7 Z
11.                         ((ai_float*)in_data)[i] = 50+(ai_float)(i*factor*0.6)/100.0;
    ) F! K0 I! F+ A! T" w, f, n  L/ ~7 m
12.                         break;
    
13.                 case 2:
    6 A+ t# J- z+ l/ c) j9 R1 i
14.                         ((ai_float*)in_data)[i] = 975-(ai_float)(i*factor*1.8)/100.0;
    
15.                         break;
    
16.                 default:
    
17.                         break;
    
18.                 }
    . e$ F0 J' N, o8 d
19.                 printf("%.4f ",((ai_float*)in_data)[i]);
    5 `  S  |# n2 ]
20.         }
    # P( C  i/ C- o
21.         printf("\n");
    
22. 
    6 ~+ b' F& r0 E$ b1 e  `
23.         return 0;
    * _9 ]6 G5 C& t: B9 f) J, y
24. }

复制代码

2 O, j( x& N8 Y9 H" s2 O  C        调整为
4 C7 [" k3 Z" M1 Q; S- W

1. ai_float in_buf[] =
   
2. {
   
3.                 -1.9654135467252831,-0.14388957575400915,9.36735860765576,
   $ K; h- t+ ~. D# @/ i& J7 M- b) `. ~
4.                 -1.6297827960727935,0.6647544204312931,9.618930851170278,
   1 k: O+ d- c- i+ e# u4 `
5.                 -1.7208332169161387,0.38462856310059845,9.492079217583663,
   8 ~/ J2 X- A  q9 F* h) r
6.                 -1.6814190066807724,0.5346365723749872,9.648173176699613,
   ' L; G, L6 J: }+ h5 h" ^& q
7.                 -1.7298486510592452,0.42164964981080416,9.557259289818587,
   
8.                 -1.7618787694384546,0.45864558999786653,9.653153776935605,
   
9.                 -1.7410197123193858,0.4236369742675384,9.55486293595946,
   . u  U/ R' A" ]3 D
10.                 -1.7600076822930908,0.46214612481362705,9.594426626710453,
    
11.                 -1.5761631958773263,0.3715109598910308,9.436853714636964,
    9 c7 x5 P* D3 y
12.                 -1.5920827364351244,0.37070313540523914,9.66189484448469,
    % ^: U7 l2 G2 ]$ S8 b$ W! S
13.                 -1.6178308849438598,0.37500917334673567,9.695719226290015,
    % _0 t9 h1 }, K, b: r
14.                 -1.4388296833472143,0.6108605310285585,9.464814699883437,
    ! }* q6 K& k  Z# [
15.                 -1.5651621282887258,0.5691273914891515,9.513897717476588,
    : N! Y8 M2 |! d& r
16.                 -1.4637992479412343,0.5105873209777632,9.501636895304161,
    ; L/ `/ V6 ^+ u8 F0 X
17.                 -0.6794677157685166,0.5024637601753793,8.96404801376064,
    
18.                 0.2600149177042748,0.6699546179356337,8.903349009412763,
    
19.                 1.0712686735261918,1.4889662656074603,9.520348132500752,
    . p) q. V1 `2 ]
20.                 0.3914123345764725,1.4210706041563634,10.557387805652848,
    
21.                 1.0779003359396493,1.0582703827741018,10.454469820960814,
    / C- H' j2 B7 a  _9 ~
22.                 0.12433283758079197,-0.27273511643713033,10.328552286632643,
    5 M8 J7 H$ a$ H$ R* f
23.                 -0.010219096051988997,0.2961821896002729,9.483084545625971,
    9 J% g) t& X! k9 n+ r" S# K# E
24.                 -1.6910112286007235,-0.2898761724876157,9.704755735796937,
    1 D' k9 ^) i) [8 C+ l7 R* l
25.                 -2.693651827312974,-0.41126025575408387,9.825328217800239,
    * C) {; D2 T$ p
26.                 -2.8416981790648177,-0.14586229740441406,9.880552703938179
    8 n' A. Y2 V; O2 v) @
27. };
    
28. 
    
29. int acquire_and_process_data(void *in_data,int factor)
    
30. {
    
31.         printf("in_data:");
    
32.         for (int i=0; i<AI_HAR_IGN_IN_1_SIZE; i++)
    : m5 T- H: |  a, p
33.         {
    , w( L7 N1 z7 J4 h3 b0 ^2 `
34.                 ((ai_float*)in_data)[i] =in_buf[i];
    * E5 J; j4 I1 s4 q. @$ T$ v: J
35.                 printf("%.4f ",((ai_float*)in_data)[i]);
    / U8 F- K: I& J/ m8 Y& X8 H
36.         }
    : F9 j4 W- k# O' Y$ z
37.         printf("\n");
    : S( d8 ?! d# a- }! {0 X2 @4 c
38. 
      E' F+ Y, b) R" j  D" o
39.         return 0;
    
40. }

复制代码

        重新编辑及加载到开发板，打开串口助手，输入test*，查看测试效果如下，显然和期待有很大出入：
: Q5 p$ L! g8 w' t. [( ~; G4 w7 G6 r
- s! j+ @) F( A4 D6 W

四、测试有误问题
, p( b2 R, m9 n: z1 u! x        上述结果和HAR项目中的PrepareDataset.py分类似乎并没匹配上，那么就要分析PrepareDataset.py分类和生成后的c语言模型时如何对应的，以及用来测试的数据是否符合模型要求。



        为此，再次回到HAR训练模型项目，在RunMe.py文件中追加以下语句：
/ O# e& g; x( s1 m

1. print("TestX:")
   
2. print(TestX[0:1])
   : }' K* N0 y' o
3. print("TestY:")
   
4. print(TestY[0:1])

复制代码

! A* o! A! B5 M/ @* v: q* E        以获取用来测试的真实模拟数据，再次运行python3 .\RunMe.py --dataDir=Log_data命令，最后部分输出如下：

1. TestX:
   
2. [[[[-3.64077855e-16]
   
3.    [-4.69612372e-16]
   ' m$ |4 ~- G0 S+ A
4.    [ 3.68092310e-10]]
   7 K" x. ~2 R* R  G0 A0 A
5. 
   
6.   [[ 1.02756571e+01]
   
7.    [-1.14305305e+01]
   
8.    [ 2.61872125e+01]]
   
9. 
   / Y6 ^; L9 e( K
10.   [[-2.84181689e+00]
    
11.    [-3.54747048e+00]
    
12.    [-5.51206446e+00]]
    + P! K- k; c/ p
13. 
    $ c; c. n) a$ c5 i
14.   [[-3.82102513e+00]
      u  W4 Z  C* N6 g1 P* X
15.    [-1.41233186e+01]
    
16.    [-4.59900586e+00]]
    
17. 
    
18.   [[ 6.68010824e+00]
    $ Y/ V8 v) W% [: `- u
19.    [ 9.39457601e+00]
    
20.    [-2.96397789e+00]]
    
21. 
    ) P4 z& G4 {& ~( ]( v! o
22.   [[-1.71771782e+01]
    
23.    [ 1.19374149e+01]
    
24.    [ 3.05770680e+00]]
    
25. 
    
26.   [[-6.65782005e+00]
    / L, x* C+ P* `4 a) B. k7 O
27.    [ 2.39062819e+00]
    
28.    [ 3.22844912e+00]]
    % v2 B# J! [8 A5 [% n3 p
29. 
    / d4 S7 p! t1 K( \. h3 [2 d4 t
30.   [[ 4.59021292e+00]
    
31.    [-6.27548028e+00]
    3 J, V3 F% ~# k6 O) w8 |
32.    [-4.92783556e+00]]
    
33. 
    9 Z9 }# i+ E4 S4 j4 p, I' Z+ m8 G
34.   [[ 8.03018658e+00]
    5 [7 B8 x' i$ ^( k  @. l' V
35.    [-2.72208600e+00]
    " D  w0 K2 s, E4 {: |8 Q- j; W6 r* l" v
36.    [-6.35796053e+00]]
    % n- U% [% A0 j- w% ]9 k" c
37. 
    , ^9 k8 O+ U& S! S0 a0 z
38.   [[ 7.73164454e+00]
    
39.    [-6.31879160e+00]
    
40.    [-5.90723810e+00]]
    # B3 E) i1 L/ z% U
41. 
    8 D8 w+ h8 A6 g. A
42.   [[ 8.53803514e-01]
    
43.    [-9.75763211e+00]
    
44.    [ 1.02466115e+01]]
    0 m0 }! X1 p0 R# N/ e
45. 
    7 R5 w/ b. G& X: s0 Z" ~# J& {3 B
46.   [[ 1.11299171e+01]
    
47.    [-1.70658346e+01]
    
48.    [ 2.18511283e+01]]
    
49. 
    
50.   [[ 3.92044994e-01]
    
51.    [ 5.94768181e+00]
    9 L, C' p9 j( U: Y
52.    [ 4.30131750e+00]]
    
53. 
    
54.   [[-5.61807988e+00]
    " c3 p: X8 E* Y, |" Y" v
55.    [ 1.97310400e+01]
      v% M6 U: W8 o% b$ b. S
56.    [-2.22512540e+00]]
    
57. 
    7 r2 T0 w. q7 ~* y6 `& B1 B/ Z8 z
58.   [[ 3.86836548e+00]
    # g' K0 p$ H& h3 i( v( u
59.    [ 1.71617325e+00]
    # z& J; f5 k# {3 A- i! D
60.    [-5.86292387e+00]]
    : y! o/ o2 o- l. x! K  x& N
61. 
    
62.   [[ 7.65913325e+00]
    
63.    [-7.19628424e+00]
    ; v2 j1 f% `! [& @
64.    [ 2.01628025e+00]]
    
65. 
    
66.   [[-7.52357836e+00]
    ( x  y4 k: K- `: @, M9 M! t0 ?
67.    [ 3.68102584e+00]
    
68.    [-1.22753233e+01]]
    4 f1 Z1 n1 k3 ?6 f5 ]0 S/ T4 l& O) r
69. 
    ' c# Y2 A7 t9 N; R% u6 i+ J; ~) j
70.   [[-5.12351958e+00]
    # X2 q+ _% N. Z) y# R
71.    [ 1.23941669e+01]
    * [1 X! L% l5 K% }) R4 Y
72.    [-1.77385540e+00]]
      H0 q6 {% H) W
73. 
    # b- r0 e9 l  a2 ~; ^
74.   [[-4.86155823e-01]
    5 X) C6 W# N; j! P& X& Q+ `: E
75.    [ 1.26333902e+01]
    7 O0 R; [6 H' A& b* t* O$ g
76.    [ 5.93595914e+00]]
    
77. 
    
78.   [[-1.96569165e+01]
    $ Y# \" |/ w. k% i; {1 K
79.    [ 1.00467317e+01]
    ( c( ?/ p9 K7 o: Z, v" G7 _
80.    [ 9.47374003e+00]]
    
81. 
    % Q  `2 \5 j3 ]3 r6 R
82.   [[-4.34050581e+00]
    
83.    [ 5.16311148e-01]
    
84.    [-5.63004156e-01]]
    
85. 
    
86.   [[-3.57974669e+00]
    
87.    [ 4.87240857e-01]
    8 _. h6 F! d" m( \; j
88.    [-9.38271247e-01]]
      {! u- U+ b+ _( ^' a7 a
89. 
    
90.   [[ 6.11930536e+00]
    - X5 c* I# b5 Q
91.    [ 5.99067573e+00]
    , b' C4 D7 ?6 ^* h+ T! v
92.    [-7.68834262e+00]]
    / `# J( y; r$ ^9 V9 W
93. 
    - Q! q! J8 E' M
94.   [[ 1.12153409e+01]
    + k7 i; _1 }3 {5 j; a
95.    [ 2.37168199e+00]
    7 R0 B% l  v* T4 b
96.    [-7.40963357e+00]]]]
    ; L' X0 z+ `& B
97. TestY:
    ! E; Q+ d4 {+ A  A! \, L0 W- o
98. [[1. 0. 0. 0.]]
    7 s- i3 {$ t+ ~
99. PS D:\tools\arm_tool\STM32CubeIDE\STM32CubeFunctionPack_SENSING1_V4.0.3\Utilities\AI_Ressources\Training Scripts\HAR>

复制代码

$ n- U# Q4 F; m* W# Z        显然输入24*3的一组数据，输出结果是[1. 0. 0. 0.]，再将该数据用于测试 c语言模型神经网络模型API调用。
$ Z! u; W$ c* O3 F# t7 O

1. ai_float in_buf[] =
   
2. {
   
3.                 -3.64077855e-16,-4.69612372e-16,3.68092310e-10,
   
4.                 1.02756571e+01,-1.14305305e+01,2.61872125e+01,
   7 C. t5 R; U0 g1 n/ g, p
5.                 -2.84181689e+00,-3.54747048e+00,-5.51206446e+00,
   $ C  J/ U" i* a- R7 p. e+ x( {. y
6.                 -3.82102513e+00,-1.41233186e+01,-4.59900586e+00,
   7 ]1 h. b  Y- ~1 C$ n
7.                 6.68010824e+00, 9.39457601e+00,-2.96397789e+00,
   : T$ A( P* K; z1 D9 G
8.                 -1.71771782e+01,1.19374149e+01,3.05770680e+00,
   : ^( m! z% V/ O# a) D8 z
9.                 -6.65782005e+00,2.39062819e+00,3.22844912e+00,
   
10.                 4.59021292e+00,-6.27548028e+00,-4.92783556e+00,
    
11.                 8.03018658e+00,-2.72208600e+00,-6.35796053e+00,
    , H6 i' c  K7 {9 q9 b1 {
12.                 7.73164454e+00,-6.31879160e+00,-5.90723810e+00,
    
13.                 8.53803514e-01,-9.75763211e+00, 1.02466115e+01,
    
14.                 1.11299171e+01,-1.70658346e+01, 2.18511283e+01,
    0 a0 B6 z, ]! l1 u- S6 M
15.                 3.92044994e-01, 5.94768181e+00, 4.30131750e+00,
    
16.                 -5.61807988e+00, 1.97310400e+01,-2.22512540e+00,
    : [4 V) `* j7 @# c$ e5 i2 L$ m2 o
17.                 3.86836548e+00, 1.71617325e+00,-5.86292387e+00,
    
18.                 7.65913325e+00,-7.19628424e+00, 2.01628025e+00,
    
19.                 -7.52357836e+00, 3.68102584e+00,-1.22753233e+01,
    
20.                 -5.12351958e+00, 1.23941669e+01,-1.77385540e+00,
    
21.                 -4.86155823e-01, 1.26333902e+01, 5.93595914e+00,
    
22.                 -1.96569165e+01, 1.00467317e+01, 9.47374003e+00,
    
23.                 -4.34050581e+00, 5.16311148e-01,-5.63004156e-01,
      w! p3 j& `( z5 ?% [. \
24.                 -3.57974669e+00, 4.87240857e-01,-9.38271247e-01,
    3 C5 q5 N$ o& ~' Y1 T0 n6 z( r- k
25.                 6.11930536e+00, 5.99067573e+00,-7.68834262e+00,
    
26.                 1.12153409e+01, 2.37168199e+00,-7.40963357e+00
    . r" c: U# P6 a) B1 M% m
27. };
    
28. 
    & F  X1 B* {: A7 z$ e
29. int acquire_and_process_data(void *in_data,int factor)
    
30. {
    
31.         printf("in_data:");
    
32.         for (int i=0; i<AI_HAR_IGN_IN_1_SIZE; i++)
    
33.         {
    
34.                 ((ai_float*)in_data)[i] =in_buf[i];
    # L% w" h+ i- \- }2 F) G  Q
35.                 printf("%.4f ",((ai_float*)in_data)[i]);
      }1 K1 E0 u  S/ k) `/ q+ v
36.         }
    / p. D& m7 A' k  K9 c
37.         printf("\n");
    9 P! B, d# h; w! [9 B
38. 
    # p  u+ x  `2 c7 P: q# u# v
39.         return 0;
    
40. }

复制代码

9 z- T# c; \& }0 Z+ |# Y" o; m        再次编译下载程序，采用串口助手测试如下，输出数据为，【0.943687 0.000000 0.000294 0.056019】，而实际数据是[1. 0. 0. 0.]，显然能对应上，只是精度问题：

! \% R3 ?. n4 e" S
+ G% c1 N2 X! b# p6 ?
2 R( y, O0 B0 Q( ?, P0 W9 U% g
1 T/ _) C; |. U: S# W$ ]五、精度问题
        再次回到HAR训练项目上，如前文所述，训练结果按时间生成一个目录进行输出：
4 N$ R! @6 b5 x& `
, z* V/ _4 e. x# D+ g  g

         输出了训练的acc 、loss变化曲线图和混淆矩阵图，观察可以看到，用于训练数据其主要还是来自于WISDM的数据集占据大头，从混淆矩阵也可以看出，为何前面测试时输出结果0.943687 0.000000 0.000294 0.056019】，显然训练过程中，'Jogging'姿态会有一部分判断 'Stairs', 'Walking'姿态。

. R$ ]8 U; m8 k  U' |5 \  Z0 ~
  \2 Z: C, H5 P
3 l7 W; ?9 p% ], O2 {         在训练过程日志显示：


" P. |% r% G6 j$ X. {
/ s: ^& ]: m- L3 v. ?! q        再次改写RunMe.py，加入下面打印语句，查看用于训练、验证及测试的数据集量级：

1. print("TrainX:"+str(len(TrainX)))
   
2. print("TrainY:"+str(len(TrainY)))
   ; L4 W4 `& }" i1 @
3. print("ValidationX:"+str(len(ValidationX)))
   
4. print("ValidationY:"+str(len(ValidationY)))
   
5. print("TestX:"+str(len(TestX)))
   
6. print("TestY:"+str(len(TestY)))

复制代码

        再次运行python3 .\RunMe.py --dataDir=Log_data命令：

8 t6 D: m) U. K
- z+ z! u* Z) p& D* f/ y
% P7 y+ X; Z0 c  K( f! }         通常在实际项目中，不断优化算法模型是主要原因，但相信ST公司及其合作团队应该就算法模型做了足够好，而本文测试验证为何还出现精度相差这么大，应该是以下几点：
. w3 G) P9 o0 o% `        1）本文用于训练模型的数据集不是同一设备，同一批次，统一采集方法获得足够量数据集。
5 ]$ f. B1 w7 D7 ^8 C
% u2 B* @. y3 }# p) e0 U8 d) y; R        2）本文自行采集的数量偏小，可能预WISDM采集数据方法存在差异而出现精确性问题，并加入其中，还是会影响模型训练精度的（若仅采用WISDM采集数据集）。
: R0 z: I! b" o& N8 ]! V
        3）本文仅采用了HAR训练项目建议的默认参数，实际项目中，可能需要我们根据数据集及部署环境，不断尝试不同参数设置来训练和使用神经网络模型。
2 e( @4 i4 Q0 W1 w
3 X- z2 `" d) q4 C9 W        4）cube.AI将keras训练的神经网络模型转换为c语言的神经网络模型虽然损耗极小，但还是存在一定精度损失的。

# P/ {% \) y  X. K+ \! K

+ Q5 i! U$ e) P. B  K         篇一、二，是基于FP-AI-SENSING1案例和配套的B-L475E-IOT01A开发板来使用cube.AI软件包的，那么在实际使用cube.AI时，需要与我们项目实际硬件平台，并基于该硬件平台采集的数据进行数据预处理和神经网络模型构建、训练、验证及测试，然后再通过cubeMX和cube.AI将训练好的神经网络模型转换为c语言支持的AI模型，通过嵌入式程序加载（AI模型+cube.AI）从而实现神经网络计算的前端或边缘端部署，请阅读偏三。
————————————————
版权声明：py_free-物联智能
) I0 c! v3 z  r2 s& G如有侵权请联系删除
1 u- C, H9 p" ?# Y* B+ N