【Curie Nano试用】 A5.Curie神经元算法库--CurieNeurons

limale

CurieNeurons，即Curie神经元。Neurons能通过示例学习，不用编程，可以通过数据离线学习。
general vision提供了两个版本可供下载，免费版和收费19美刀的专业版。
下载地址:http://www.general-vision.com/software/curieneurons/


为了尝鲜我们先体验一下免费版吧， CurieNeurons.zip (1.08 MB, 下载次数: 24)

2017-5-16 20:57 上传

点击文件名下载附件
相关的文档：
Curie Final ppt.pdf (9.29 MB, 下载次数: 13)

2017-5-16 21:07 上传

点击文件名下载附件
TM_CurieNeuronsLibrary.pdf (490.75 KB, 下载次数: 9)

2017-5-16 21:07 上传

点击文件名下载附件
TM_NeuroMem_API.pdf (363.66 KB, 下载次数: 7)

2017-5-16 21:07 上传

点击文件名下载附件
TM_NeuroMem_Technology_Reference_Guide.pdf (627.26 KB, 下载次数: 11)

2017-5-16 21:07 上传

点击文件名下载附件





详细的信息可以看文档里的介绍，这里我们就直接切入正题了。
需要的材料很简单，Curie Nano板和一块AD Keyborad板。
这个AD Keyborad DFROBOT商城有卖，不过太贵了买不起，好在提供原理图，我手工做了一个。
5个按键只占用一个模拟IO口，很巧妙的设计。




这里VCC接3.3V，IO口接A5。


示例代码：

1. /*
   
2. Name:                CurieNeurons_andIMU2.0.ino
   
3. Created:        7/21/2016 11:08:34 AM
   
4. Author:        HansYang
   
5. */
   
6. 
   
7. 
   
8. #include <CurieIMU.h>
   
9. #include <BMI160.h>
   
10. #include <CurieNeurons.h>
    
11. #include <stdlib.h>
    
12. #define DEBUG1
    
13. #define ACC_FEATURE_ONLY
    
14. #define MANUAL_SCALING
    
15. 
    
16. #ifdef ACC_FEATURE_ONLY
    
17. #define SAMPLENBR 3  
    
18. #else
    
19. #define SAMPLENBR 6
    
20. #endif // ACC_FEATURE_ONLY
    
21. 
    
22. #define MAX_SAMPLING_TIME 3000//ms
    
23. #define SAMPLING_INTERVAL 50//ms
    
24. #define MAX_VECTOR_LEN 60//MAX_SAMPLING_TIME/SAMPLING_INTERVAL
    
25. 
    
26. #define DOWNSAMPLER_SEGS 10
    
27. 
    
28. //ADkeyboard
    
29. int adc_key_val[5] = { 850,900, 940, 960, 980 };
    
30. #define NUM_KEYS 5
    
31. int adc_key_in;
    
32. int key = -1;
    
33. 
    
34. //CurieNeurons
    
35. CurieNeurons hNN;
    
36. int cat, prevcat;
    
37. int dist, nid;
    
38. 
    
39. //IMU data
    
40. int16_t ax, ay, az;
    
41. int16_t gx, gy, gz;
    
42. 
    
43. int minax, minay, minaz, maxax, maxay, maxaz;
    
44. int mingx, mingy, mingz, maxgx, maxgy, maxgz;
    
45. int Sax, Say, Saz, Sgx, Sgy, Sgz;
    
46. 
    
47. //Others
    
48. uint64_t timer;
    
49. short vector_len;
    
50. byte vector[MAX_VECTOR_LEN*SAMPLENBR];
    
51. byte pattern[SAMPLENBR * 17];
    
52. byte learnflag;
    
53. 
    
54. void feature_extraction(byte* src_vector, int src_len, byte *dst_vector)
    
55. {
    
56.         int seg_len = src_len / (DOWNSAMPLER_SEGS * SAMPLENBR);
    
57.         double res[17 * SAMPLENBR];
    
58.         for (int icol = 0; icol < SAMPLENBR; icol++)
    
59.         {
    
60.                 int sum = 0;
    
61.                 for (int i = 0; i < src_len; i++)
    
62.                 {
    
63.                         sum += src_vector[i*SAMPLENBR + icol];
    
64.                 }
    
65.                 //mean
    
66.                 int aver = sum / src_len;
    
67.                 int e = 0;
    
68.                 int mad = 0;
    
69.                 //int rms = 0;
    
70.                 //byte max = src_vector[icol];
    
71.                 //byte min = src_vector[icol];
    
72.                 int ratiocount[5] = { 0 };
    
73.                 for (int i = 0; i < src_len; i++)
    
74.                 {
    
75.                         e += (src_vector[i*SAMPLENBR + icol] - aver)*(src_vector[i*SAMPLENBR + icol] - aver);
    
76.                         mad += abs(src_vector[i*SAMPLENBR + icol] - aver);
    
77.                         //rms += src_vector[i*SAMPLENBR + icol] * src_vector[i*SAMPLENBR + icol];
    
78.                         //if (src_vector[i*SAMPLENBR + icol] > max)
    
79.                         //        max = src_vector[i*SAMPLENBR + icol];
    
80.                         //if (src_vector[i*SAMPLENBR + icol] < min)
    
81.                         //        min = src_vector[i*SAMPLENBR + icol];
    
82.                         if (src_vector[i*SAMPLENBR + icol] <= 200)
    
83.                         {
    
84.                                 if (src_vector[i*SAMPLENBR + icol] <= 150)
    
85.                                 {
    
86.                                         if (src_vector[i*SAMPLENBR + icol] <= 100)
    
87.                                         {
    
88.                                                 if (src_vector[i*SAMPLENBR + icol] <= 50)
    
89.                                                 {
    
90.                                                         ratiocount[4]++;
    
91.                                                 }
    
92.                                                 else
    
93.                                                         ratiocount[3]++;
    
94.                                         }
    
95.                                         else
    
96.                                                 ratiocount[2]++;
    
97.                                 }
    
98.                                 else
    
99.                                         ratiocount[1]++;
    
100.                         }
     
101.                         else
     
102.                                 ratiocount[0]++;
     
103.                 }
     
104.                 //standard deviation
     
105.                 res[icol] = sqrt(e / (src_len - 1)) * 2;
     
106.                 //MAD
     
107.                 res[icol + 1 * SAMPLENBR] = mad / src_len * 2;
     
108.                 //RMS
     
109.                 //res[icol + 3 * SAMPLENBR] = sqrt(rms / src_len);
     
110.                 for (int i = 0; i < 5; i++)
     
111.                 {
     
112.                         res[icol * 5 + 6 + i] = 0;//ratiocount[i];// * 255 / src_len;
     
113.                 }
     
114. 
     
115.                 for (int iseg = 0; iseg < DOWNSAMPLER_SEGS; iseg++)
     
116.                 {
     
117.                         int sum = 0;
     
118.                         for (int ismp = 0; ismp < seg_len; ismp++)
     
119.                         {
     
120.                                 int offset = icol + (iseg * seg_len + ismp)*SAMPLENBR;
     
121.                                 sum += (int)src_vector[offset];
     
122.                                 src_vector[offset] = 0;
     
123.                         }
     
124.                         res[20 + icol * DOWNSAMPLER_SEGS + iseg] = sum / seg_len;
     
125.                 }
     
126.         }
     
127. 
     
128.         for (int i = 0; i < SAMPLENBR * 17; i++)
     
129.         {
     
130.                 pattern[i] = (int)(res[i] + 0.5) * 0x00FF;
     
131.         }
     
132. 
     
133. #ifdef DEBUG1
     
134.         Serial.print("\n");
     
135.         for (int i = 0; i < SAMPLENBR*17; i++)
     
136.         {
     
137.                 Serial.print(pattern[i]);
     
138.                 Serial.print("\t");
     
139.         }
     
140.         //Serial.print("\n");
     
141. #endif // DEBUG1
     
142. 
     
143. }
     
144. 
     
145. int get_key(unsigned int input)        //1 2 3 4 5
     
146. {
     
147.         int k;
     
148.         for (k = 0; k < NUM_KEYS; k++)
     
149.         {
     
150.                 if (input < adc_key_val[k])
     
151.                 {
     
152.                         return k + 1;
     
153.                 }
     
154.         }
     
155.         if (k >= NUM_KEYS)
     
156.                 k = -1;  // No valid key pressed
     
157.         return k + 1;
     
158. }
     
159. 
     
160. void read_data_once()
     
161. {
     
162.         CurieIMU.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
     
163. 
     
164.         /*int R = sqrt(ax*ax + ay*ay + az*az);
     
165. 
     
166.         double tX = acos(ax / R);
     
167.         double tY = acos(ay / R);
     
168.         double tZ = acos(az / R);
     
169. 
     
170.         ax = ax - 8192 * cos(tX);
     
171.         ay = ay - 8192 * cos(tY);
     
172.         az = ax - 8192 * cos(tZ);*/
     
173.         
     
174.         vector[vector_len*SAMPLENBR + 0] = (byte)(((ax - minax) * 255 / Sax) & 0x00FF);
     
175.         vector[vector_len*SAMPLENBR + 1] = (byte)(((ay - minay) * 255 / Say) & 0x00FF);
     
176.         vector[vector_len*SAMPLENBR + 2] = (byte)(((az - minaz) * 255 / Saz) & 0x00FF);
     
177. #ifndef ACC_FEATURE_ONLY
     
178.         vector[vector_len*SAMPLENBR + 3] = (byte)(((gx - mingx) * 255 / Sgx) & 0x00FF);
     
179.         vector[vector_len*SAMPLENBR + 4] = (byte)(((gy - mingy) * 255 / Sgy) & 0x00FF);
     
180.         vector[vector_len*SAMPLENBR + 5] = (byte)(((gz - mingz) * 255 / Sgz) & 0x00FF);
     
181. #endif // !ACC_FEATURE_ONLY               
     
182. 
     
183.         /*vector[vector_len*SAMPLENBR + 0] = ax;
     
184.         vector[vector_len*SAMPLENBR + 1] = ay;
     
185.         vector[vector_len*SAMPLENBR + 2] = az;
     
186. #ifndef ACC_FEATURE_ONLY
     
187.         vector[vector_len*SAMPLENBR + 3] = gx;
     
188.         vector[vector_len*SAMPLENBR + 4] = gy;
     
189.         vector[vector_len*SAMPLENBR + 5] = gz;
     
190. #endif // !ACC_FEATURE_ONLY                */
     
191. 
     
192.         if (vector_len < (MAX_VECTOR_LEN - 2)*SAMPLENBR ) {
     
193.                 vector_len++;
     
194.                 Serial.print("*");
     
195.         }
     
196.         else
     
197.         {
     
198.                 Serial.print("O");
     
199.         }
     
200. }
     
201. 
     
202. // the setup function runs once when you press reset or power the board
     
203. void setup() {
     
204.         Serial.begin(9600);
     
205.         while (!Serial);
     
206. 
     
207.         Serial.print("CurieNeurons initializing...");
     
208.         hNN.begin();
     
209.         hNN.forget();
     
210.         Serial.println("Done");
     
211. 
     
212.         Serial.print("CurieIMU initializing...");
     
213.         CurieIMU.begin();
     
214.         Serial.println("Done");
     
215. 
     
216.         Serial.println("Initializing IMU device...");
     
217.         CurieIMU.begin();
     
218. 
     
219.         // use the code below to calibrate accel/gyro offset values
     
220.         Serial.println("Internal sensor offsets BEFORE calibration...");
     
221.         Serial.print(CurieIMU.getXAccelOffset());
     
222.         Serial.print("\t"); // -76
     
223.         Serial.print(CurieIMU.getYAccelOffset());
     
224.         Serial.print("\t"); // -235
     
225.         Serial.print(CurieIMU.getZAccelOffset());
     
226.         Serial.print("\t"); // 168
     
227.         Serial.print(CurieIMU.getXGyroOffset());
     
228.         Serial.print("\t"); // 0
     
229.         Serial.print(CurieIMU.getYGyroOffset());
     
230.         Serial.print("\t"); // 0
     
231.         Serial.println(CurieIMU.getZGyroOffset());
     
232. 
     
233.         Serial.println("About to calibrate. Make sure your board is stable and upright");
     
234.         delay(2000);
     
235. 
     
236.         // The board must be resting in a horizontal position for
     
237.         // the following calibration procedure to work correctly!
     
238.         Serial.print("Starting Gyroscope calibration...");
     
239.         CurieIMU.autoCalibrateGyroOffset();
     
240.         Serial.println(" Done");
     
241.         Serial.print("Starting Acceleration calibration...");
     
242.         CurieIMU.autoCalibrateXAccelOffset(0);
     
243.         CurieIMU.autoCalibrateYAccelOffset(0);
     
244.         CurieIMU.autoCalibrateZAccelOffset(1);
     
245.         Serial.println(" Done");
     
246. 
     
247.         Serial.println("Internal sensor offsets AFTER calibration...");
     
248.         Serial.print(CurieIMU.getXAccelOffset());
     
249.         Serial.print("\t"); // -76
     
250.         Serial.print(CurieIMU.getYAccelOffset());
     
251.         Serial.print("\t"); // -2359
     
252.         Serial.print(CurieIMU.getZAccelOffset());
     
253.         Serial.print("\t"); // 1688
     
254.         Serial.print(CurieIMU.getXGyroOffset());
     
255.         Serial.print("\t"); // 0
     
256.         Serial.print(CurieIMU.getYGyroOffset());
     
257.         Serial.print("\t"); // 0
     
258.         Serial.println(CurieIMU.getZGyroOffset());
     
259. 
     
260.         Serial.println("Enabling Gyroscope/Acceleration offset compensation");
     
261.         CurieIMU.setGyroOffsetEnabled(true);
     
262.         CurieIMU.setAccelOffsetEnabled(true);
     
263. 
     
264.         CurieIMU.setAccelerometerRange(4);
     
265.         //hNN.GCR(128);                        //LSUP distance
     
266.         //hNN.MAXIF(600);
     
267. 
     
268. #ifdef MANUAL_SCALING
     
269. 
     
270.         minax = minay = minaz = maxax = maxay = maxaz = -32768;
     
271.         mingx = mingy = mingz = maxgx = maxgy = maxgz = 32767;
     
272.         Sax = Say = Saz = Sgx = Sgy = Sgz = 65535;
     
273. 
     
274. #else
     
275.         Serial.println("\nAssessing the amplitude of motions...Press any key to continue");
     
276.         adc_key_in = analogRead(5);
     
277.         while (adc_key_in > 980)
     
278.         {
     
279.                 adc_key_in = analogRead(5);
     
280.                 CurieIMU.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
     
281.                 if (ax>maxax) maxax = ax; if (ax<minax) minax = ax;
     
282.                 if (ay>maxay) maxay = ay; if (ay<minay) minay = ay;
     
283.                 if (az>maxaz) maxaz = az; if (az<minaz) minaz = az;
     
284.                 if (gx>maxgx) maxgx = gx; if (gx<mingx) mingx = gx;
     
285.                 if (gy>maxgy) maxgy = gy; if (gy<mingy) mingy = gy;
     
286.                 if (gz>maxgz) maxgz = gz; if (gz<mingz) mingz = gz;
     
287.         }
     
288.         Sax = maxax - minax;
     
289.         Say = maxay - minay;
     
290.         Saz = maxaz - minaz;
     
291.         Sgx = maxgx - mingx;
     
292.         Sgy = maxgy - mingy;
     
293.         Sgz = maxgz - mingz;
     
294.         Serial.print("\nSa :\t"); Serial.print(Sax); Serial.print(","); Serial.print(Say); Serial.print(","); Serial.print(Saz);
     
295.         Serial.print("\nSg :\t"); Serial.print(Sgx); Serial.print(","); Serial.print(Sgy); Serial.print(","); Serial.println(Sgz);
     
296. #endif
     
297. 
     
298.         timer = 0;
     
299.         prevcat = 0x7FFF;
     
300.         learnflag = 0;
     
301. 
     
302.         Serial.print("The program will begin in 2 seconds...\n");
     
303.         delay(2000);
     
304.         Serial.println("Start.");
     
305. 
     
306. 
     
307. }
     
308. 
     
309. // the loop function runs over and over again until power down or reset
     
310. void loop() {
     
311. 
     
312.         timer = millis();
     
313.         adc_key_in = analogRead(5);
     
314.         key = get_key(adc_key_in);
     
315. 
     
316.         if (key!=0)
     
317.         {
     
318.                 learnflag = key;
     
319.                 read_data_once();
     
320.         }
     
321.         else if (learnflag != 0)
     
322.         {
     
323.                 read_data_once();
     
324.                 feature_extraction(vector, vector_len, pattern);
     
325.                 //downsampler_means(vector, vector_len, pattern, SAMPLENBR*DOWNSAMPLER_SEGS);
     
326. #ifdef DEBUG
     
327.                 Serial.print("\n");
     
328.                 for (int i = 0; i < SAMPLENBR*DOWNSAMPLER_SEGS; i++)
     
329.                 {
     
330.                         Serial.print(pattern[i]);
     
331.                         Serial.print("\t");
     
332.                 }
     
333.                 Serial.print("\n");
     
334. #endif //DEBUG
     
335.                 if (learnflag != 5)
     
336.                 {
     
337.                         hNN.learn(pattern, SAMPLENBR * 17, learnflag);
     
338.                         Serial.print("\nLearned motion #");
     
339.                         Serial.print(learnflag);
     
340.                         Serial.println("once, please repeat.");
     
341.                 }
     
342.                 else
     
343.                 {
     
344.                         int res = hNN.classify(pattern, SAMPLENBR * 17, &dist, &cat, &nid);
     
345.                         cat &= 0x00FF;
     
346.                         if (res != 0)
     
347.                         {
     
348.                                 Serial.print("\nMotion Detected. #"); Serial.println(cat);
     
349.                         }
     
350.                         else
     
351.                         {
     
352.                                 Serial.println("\nMotion Unknow.");
     
353.                         }
     
354.                 }
     
355.                 learnflag = 0;
     
356.                 vector_len = 0;
     
357.         }
     
358.         while ((millis() - timer) < SAMPLING_INTERVAL);
     
359. }

复制代码

编译示例代码并上传到Curie Nano中，打开串口工具，并将开发板平放等待陀螺仪自动校准。如图所示：


动作学习：
按住黄色、绿色、蓝色或者红色按键做动作，动作完成松手。黄色对应动作1，绿色对应动作2，蓝色对应动作3，红色对应动作4。
每种动作可以多做几次，这样识别的准确率会高一些。
下图是我按住黄色按键1和绿色按键2完成的动作识别。


识别动作:
按住中间的白色按键5，做出刚才的动作，程序会识别属于刚才的哪个动作。
如下图所示，如果做出的动作不是刚才的两种之一会显示未知。


动作的采样时间可以在以下的语句修改，但是时间越来复杂度也就越高，识别的准确率也就越低。

程序说明:
在这个过程中，主要是采用按键按下作为动作的开始，松开表示动作的结束，再将采样的动作进行数据分析，再由CurieNeurons神经网络进行学习。识别动作的方式同理。

slotg

这个有意思，感谢分享。

噗噗熊

这个好有意思！

我叫逗逗

楼主什么时候买收费版，不知道收费版可不可以共享？

limale

slotg 发表于 2017-5-16 23:40
这个有意思，感谢分享。

谢谢支持              

limale

噗噗熊 发表于 2017-5-17 09:37
这个好有意思！

这个板子确实有好多好玩的地方。

limale

我叫逗逗 发表于 2017-5-17 09:46
楼主什么时候买收费版，不知道收费版可不可以共享？

看了一下介绍，专业版识别算法准确率高一些。楼主没有这方面的需求，暂时不会考虑买专业版。