beleata74 commited on
Commit
9cc39c3
·
verified ·
1 Parent(s): c2ec9f4

Delete SaraNet_Pico/SaraNet_Pico.ino with huggingface_hub

Browse files
Files changed (1) hide show
  1. SaraNet_Pico/SaraNet_Pico.ino +0 -398
SaraNet_Pico/SaraNet_Pico.ino DELETED
@@ -1,398 +0,0 @@
1
- #pragma GCC optimize("Ofast")
2
- #pragma GCC optimize("unroll-loops")
3
-
4
- #include <Arduino.h>
5
- #include <math.h>
6
- #include "saranet_weights_qat_int8.h"
7
- #include "saranet_audio_frontend.h"
8
-
9
- #include "pico/stdlib.h"
10
- #include "hardware/clocks.h"
11
- #include "hardware/vreg.h"
12
-
13
- // Глобални буфери за инференс (ping-pong буфери)
14
- // Този път използваме int8_t!
15
- // Максималният размер е 32768 елемента (32KB всеки буфер, общо 64KB)
16
- int8_t buffer_A[32768];
17
- int8_t buffer_B[32768];
18
-
19
- const char* class_names[] = {
20
- "backward", "down", "follow", "forward", "go", "left",
21
- "marvin", "no", "off", "on", "right", "sheila", "stop", "up", "visual", "yes", "UNKNOWN/NOISE"
22
- };
23
-
24
- // Функция за нормален Conv2d 3x3 с чисто целочислено умножение (INT8)
25
- void conv2d_3x3_int8(const int8_t* in_data, int in_c, int h, int w,
26
- const int8_t* weight, const int8_t* bias,
27
- float in_scale, float w_scale, float b_scale, float out_scale,
28
- int out_c, int8_t* out_data) {
29
- float multiplier = (in_scale * w_scale) / out_scale;
30
- float bias_multiplier = b_scale / out_scale;
31
-
32
- for (int oc = 0; oc < out_c; oc++) {
33
- float b = bias ? (bias[oc] * bias_multiplier) : 0.0f;
34
- for (int y = 0; y < h; y++) {
35
- for (int x = 0; x < w; x++) {
36
- int32_t sum = 0;
37
- if (y > 0 && y < h - 1 && x > 0 && x < w - 1) {
38
- for (int ic = 0; ic < in_c; ic++) {
39
- int w_idx_base = ((oc * in_c) + ic) * 9;
40
- const int8_t* w_ptr = &weight[w_idx_base];
41
- const int8_t* in_ptr = &in_data[(ic * h + y) * w + x];
42
-
43
- sum += in_ptr[-w - 1] * w_ptr[0];
44
- sum += in_ptr[-w] * w_ptr[1];
45
- sum += in_ptr[-w + 1] * w_ptr[2];
46
- sum += in_ptr[-1] * w_ptr[3];
47
- sum += in_ptr[0] * w_ptr[4];
48
- sum += in_ptr[1] * w_ptr[5];
49
- sum += in_ptr[w - 1] * w_ptr[6];
50
- sum += in_ptr[w] * w_ptr[7];
51
- sum += in_ptr[w + 1] * w_ptr[8];
52
- }
53
- } else {
54
- for (int ic = 0; ic < in_c; ic++) {
55
- int w_idx_base = ((oc * in_c) + ic) * 9;
56
- for (int ky = -1; ky <= 1; ky++) {
57
- for (int kx = -1; kx <= 1; kx++) {
58
- int in_y = y + ky;
59
- int in_x = x + kx;
60
- if (in_y >= 0 && in_y < h && in_x >= 0 && in_x < w) {
61
- int8_t val = in_data[(ic * h + in_y) * w + in_x];
62
- int8_t w_val = weight[w_idx_base + (ky + 1) * 3 + (kx + 1)];
63
- sum += val * w_val;
64
- }
65
- }
66
- }
67
- }
68
- }
69
- float out_float = b + (sum * multiplier);
70
- int out_int = (int)round(out_float);
71
- if (out_int > 127) out_int = 127;
72
- if (out_int < -128) out_int = -128;
73
- out_data[(oc * h + y) * w + x] = (int8_t)out_int;
74
- }
75
- }
76
- }
77
- }
78
-
79
- // Функция за SaraConv2d (Огледален слой) в INT8
80
- void sara_conv2d_3x3_int8(const int8_t* in_data, int in_c, int h, int w,
81
- const int8_t* w_pos, const int8_t* w_neg, const int8_t* bias,
82
- float in_scale, float wp_scale, float wn_scale, float b_scale, float out_scale,
83
- int out_c, int8_t* out_data) {
84
- float mult_pos = (in_scale * wp_scale) / out_scale;
85
- float mult_neg = (in_scale * wn_scale) / out_scale;
86
- float bias_multiplier = b_scale / out_scale;
87
-
88
- for (int oc = 0; oc < out_c; oc++) {
89
- float b = bias ? (bias[oc] * bias_multiplier) : 0.0f;
90
- for (int y = 0; y < h; y++) {
91
- for (int x = 0; x < w; x++) {
92
- int32_t sum_pos = 0;
93
- int32_t sum_neg = 0;
94
- if (y > 0 && y < h - 1 && x > 0 && x < w - 1) {
95
- for (int ic = 0; ic < in_c; ic++) {
96
- int w_idx_base = ((oc * in_c) + ic) * 9;
97
- const int8_t* wp_ptr = &w_pos[w_idx_base];
98
- const int8_t* wn_ptr = &w_neg[w_idx_base];
99
- const int8_t* in_ptr = &in_data[(ic * h + y) * w + x];
100
-
101
- int8_t v;
102
-
103
- v = in_ptr[-w - 1];
104
- if (v > 0) sum_pos += v * wp_ptr[0]; else sum_neg += v * wn_ptr[0];
105
-
106
- v = in_ptr[-w];
107
- if (v > 0) sum_pos += v * wp_ptr[1]; else sum_neg += v * wn_ptr[1];
108
-
109
- v = in_ptr[-w + 1];
110
- if (v > 0) sum_pos += v * wp_ptr[2]; else sum_neg += v * wn_ptr[2];
111
-
112
- v = in_ptr[-1];
113
- if (v > 0) sum_pos += v * wp_ptr[3]; else sum_neg += v * wn_ptr[3];
114
-
115
- v = in_ptr[0];
116
- if (v > 0) sum_pos += v * wp_ptr[4]; else sum_neg += v * wn_ptr[4];
117
-
118
- v = in_ptr[1];
119
- if (v > 0) sum_pos += v * wp_ptr[5]; else sum_neg += v * wn_ptr[5];
120
-
121
- v = in_ptr[w - 1];
122
- if (v > 0) sum_pos += v * wp_ptr[6]; else sum_neg += v * wn_ptr[6];
123
-
124
- v = in_ptr[w];
125
- if (v > 0) sum_pos += v * wp_ptr[7]; else sum_neg += v * wn_ptr[7];
126
-
127
- v = in_ptr[w + 1];
128
- if (v > 0) sum_pos += v * wp_ptr[8]; else sum_neg += v * wn_ptr[8];
129
- }
130
- } else {
131
- for (int ic = 0; ic < in_c; ic++) {
132
- int w_idx_base = ((oc * in_c) + ic) * 9;
133
- for (int ky = -1; ky <= 1; ky++) {
134
- for (int kx = -1; kx <= 1; kx++) {
135
- int in_y = y + ky;
136
- int in_x = x + kx;
137
- if (in_y >= 0 && in_y < h && in_x >= 0 && in_x < w) {
138
- int8_t val = in_data[(ic * h + in_y) * w + in_x];
139
- int8_t pos_val = (val > 0) ? val : 0;
140
- int8_t neg_val = (val < 0) ? val : 0;
141
-
142
- int8_t wp = w_pos[w_idx_base + (ky + 1) * 3 + (kx + 1)];
143
- int8_t wn = w_neg[w_idx_base + (ky + 1) * 3 + (kx + 1)];
144
-
145
- sum_pos += pos_val * wp;
146
- sum_neg += neg_val * wn;
147
- }
148
- }
149
- }
150
- }
151
- }
152
- float out_float = b + (sum_pos * mult_pos) + (sum_neg * mult_neg);
153
- int out_int = (int)round(out_float);
154
- if (out_int > 127) out_int = 127;
155
- if (out_int < -128) out_int = -128;
156
- out_data[(oc * h + y) * w + x] = (int8_t)out_int;
157
- }
158
- }
159
- }
160
- }
161
-
162
- // MaxPool2d за INT8
163
- void maxpool2d_2x2_int8(const int8_t* in_data, int channels, int in_h, int in_w, int8_t* out_data) {
164
- int out_h = in_h / 2;
165
- int out_w = in_w / 2;
166
- for (int c = 0; c < channels; c++) {
167
- for (int y = 0; y < out_h; y++) {
168
- for (int x = 0; x < out_w; x++) {
169
- int8_t max_val = -128;
170
- for (int ky = 0; ky < 2; ky++) {
171
- for (int kx = 0; kx < 2; kx++) {
172
- int8_t val = in_data[(c * in_h + y * 2 + ky) * in_w + x * 2 + kx];
173
- if (val > max_val) max_val = val;
174
- }
175
- }
176
- out_data[(c * out_h + y) * out_w + x] = max_val;
177
- }
178
- }
179
- }
180
- }
181
-
182
- // Linear Layer (Съдията) за INT8
183
- void linear_int8(const int8_t* in_data, int in_features, const int8_t* weight, const int8_t* bias,
184
- float in_scale, float w_scale, float b_scale, int out_features, float* out_data) {
185
- // Тук изходът е float (logits), няма нужда да го мачкаме пак в INT8
186
- for (int o = 0; o < out_features; o++) {
187
- int32_t sum = 0;
188
- for (int i = 0; i < in_features; i++) {
189
- sum += in_data[i] * weight[o * in_features + i];
190
- }
191
- float out_float = (sum * in_scale * w_scale);
192
- if (bias) out_float += (bias[o] * b_scale);
193
- out_data[o] = out_float;
194
- }
195
- }
196
-
197
- // Helper: вземане на семпъл с reflect padding
198
- int16_t get_audio_sample_int(const int16_t* audio, int idx, int length) {
199
- if (idx < 0) {
200
- idx = -idx; // reflect
201
- } else if (idx >= length) {
202
- idx = length - 2 - (idx - length); // reflect
203
- }
204
- return audio[idx];
205
- }
206
-
207
- // Генериране на Мел-Спектрограма от сурово аудио (за специфични рамки)
208
- void compute_mel_spectrogram_partial(const int16_t* audio, int8_t* out_spectro, int start_frame, int end_frame) {
209
- int n_fft_half = N_FFT / 2;
210
-
211
- for (int t = start_frame; t < end_frame; t++) {
212
- int center_idx = t * HOP_LENGTH;
213
- int start_idx = center_idx - n_fft_half;
214
-
215
- // 1. Оконен прозорец (Windowing)
216
- int16_t windowed[400]; // N_FFT е 400
217
- for (int n = 0; n < N_FFT; n++) {
218
- int32_t val = (int32_t)get_audio_sample_int(audio, start_idx + n, 16000) * hann_window[n];
219
- windowed[n] = (int16_t)(val >> 15);
220
- }
221
-
222
- // 2. Fast Integer DFT (Magnitude Squared)
223
- float power[201]; // N_FREQS е 201
224
- for (int k = 0; k < N_FREQS; k++) {
225
- int64_t re_int = 0;
226
- int64_t im_int = 0;
227
- int angle_idx = 0;
228
- for (int n = 0; n < N_FFT; n++) {
229
- int32_t w = windowed[n];
230
- re_int += w * dft_cos_table[angle_idx];
231
- im_int -= w * dft_sin_table[angle_idx];
232
- angle_idx += k;
233
- if (angle_idx >= N_FFT) {
234
- angle_idx -= N_FFT;
235
- }
236
- }
237
-
238
- float re = (float)re_int / 1073676289.0f; // 32767.0 * 32767.0
239
- float im = (float)im_int / 1073676289.0f;
240
-
241
- power[k] = (re * re) + (im * im);
242
- }
243
-
244
- // 3. Mel Filterbank Multiplication & Log2
245
- for (int m = 0; m < N_MELS; m++) {
246
- float mel_val = 0.0f;
247
- for (int k = 0; k < N_FREQS; k++) {
248
- if (mel_fb[m][k] > 0.0f) {
249
- mel_val += mel_fb[m][k] * power[k];
250
- }
251
- }
252
-
253
- // Log2 нормализация
254
- mel_val = log2f(mel_val + 1e-9f);
255
-
256
- // 4. Квантизиране до INT8
257
- float scaled = mel_val / act_scale_input;
258
- if (scaled > 127.0f) scaled = 127.0f;
259
- if (scaled < -128.0f) scaled = -128.0f;
260
-
261
- out_spectro[m * 32 + t] = (int8_t)roundf(scaled);
262
- }
263
- }
264
- }
265
-
266
- // Синхронизация за Ядро 1
267
- volatile bool core1_start_audio = false;
268
- volatile bool core1_done_audio = false;
269
- volatile int16_t* core1_raw_audio = nullptr;
270
- volatile int8_t* core1_spectro = nullptr;
271
-
272
- // Инициализация на Ядро 1 (изпълнява се автоматично от Arduino ядрото за Pico)
273
- void setup1() {
274
- }
275
-
276
- // Безкраен цикъл на Ядро 1
277
- void loop1() {
278
- if (core1_start_audio) {
279
- // Ядро 1 обработва рамки от 16 до 32
280
- compute_mel_spectrogram_partial((const int16_t*)core1_raw_audio, (int8_t*)core1_spectro, 16, 32);
281
- core1_start_audio = false;
282
- core1_done_audio = true;
283
- }
284
- }
285
-
286
- void setup() {
287
- vreg_set_voltage(VREG_VOLTAGE_1_15);
288
- delay(10);
289
- set_sys_clock_khz(266000, true);
290
-
291
- Serial.begin(115200);
292
- Serial.setTimeout(5000);
293
- while (!Serial) { delay(10); }
294
- Serial.println("SaraNet Pico INT8 + Audio Frontend е готов! Чакам RAW AUDIO...");
295
- }
296
-
297
- // Сурово 16-битово аудио: 1 секунда на 16000 Hz = 32000 байта
298
- int16_t raw_audio[16000];
299
- // Буфер за спектрограмата вече се пълни автоматично от микроконтролера
300
- int8_t spectro[2048];
301
-
302
- void loop() {
303
- if (Serial.available() > 0) {
304
- // Четем точно 32000 байта
305
- size_t read_bytes = Serial.readBytes((char*)raw_audio, 32000);
306
-
307
- if (read_bytes == 32000) {
308
- long start_time = millis();
309
-
310
- // 3. Audio Frontend (Mel-Spectrogram 64x32) с ДВЕ ЯДРА!
311
- unsigned long t_audio_start = millis();
312
-
313
- // Задаваме указателите за Ядро 1
314
- core1_raw_audio = raw_audio;
315
- core1_spectro = spectro;
316
-
317
- // Стартираме Ядро 1 да смята рамки от 16 до 32
318
- core1_done_audio = false;
319
- core1_start_audio = true;
320
-
321
- // Ядро 0 смята рамки от 0 до 16
322
- compute_mel_spectrogram_partial(raw_audio, spectro, 0, 16);
323
-
324
- // Изчакваме Ядро 1 да приключи
325
- while (!core1_done_audio) {
326
- // изчакване
327
- }
328
-
329
- unsigned long t_audio_end = millis();
330
-
331
- // 1. Входен слой: Conv2d(1, 16)
332
- int8_t* temp_layer = buffer_B;
333
- conv2d_3x3_int8(spectro, 1, 64, 32,
334
- input_layer_weight, input_layer_bias,
335
- act_scale_input, input_layer_weight_scale, input_layer_bias_scale, act_scale_input_layer,
336
- 16, temp_layer);
337
-
338
- // 1.1 MaxPool(2) -> записва в buffer_A
339
- maxpool2d_2x2_int8(temp_layer, 16, 64, 32, buffer_A);
340
- // Забележка: MaxPool не променя мащаба! Следователно подаваме act_scale_input_layer на следващия слой
341
-
342
- // 2. Огледален Слой 1 -> записва в buffer_B
343
- sara_conv2d_3x3_int8(buffer_A, 16, 32, 16,
344
- mirror1_pos_weight, mirror1_neg_weight, mirror1_bias,
345
- act_scale_input_layer, mirror1_pos_weight_scale, mirror1_neg_weight_scale, mirror1_bias_scale, act_scale_mirror1,
346
- 32, buffer_B);
347
-
348
- // 2.1 MaxPool(2) -> записва в buffer_A
349
- maxpool2d_2x2_int8(buffer_B, 32, 32, 16, buffer_A);
350
- // MaxPool не променя мащаба -> подаваме act_scale_mirror1
351
-
352
- // 3. Boardroom -> записва в buffer_B
353
- conv2d_3x3_int8(buffer_A, 32, 16, 8,
354
- boardroom_weight, boardroom_bias,
355
- act_scale_mirror1, boardroom_weight_scale, boardroom_bias_scale, act_scale_boardroom,
356
- 32, buffer_B);
357
-
358
- // 4. Огледален Слой 2 -> записва в buffer_A
359
- sara_conv2d_3x3_int8(buffer_B, 32, 16, 8,
360
- mirror2_pos_weight, mirror2_neg_weight, mirror2_bias,
361
- act_scale_boardroom, mirror2_pos_weight_scale, mirror2_neg_weight_scale, mirror2_bias_scale, act_scale_mirror2,
362
- 64, buffer_A);
363
-
364
- // 4.1 MaxPool(2) -> записва в buffer_B
365
- maxpool2d_2x2_int8(buffer_A, 64, 16, 8, buffer_B);
366
- // MaxPool не променя мащаба -> подаваме act_scale_mirror2
367
-
368
- // 5. Съдията
369
- float logits[17];
370
- linear_int8(buffer_B, 2048,
371
- judge_weight, judge_bias,
372
- act_scale_mirror2, judge_weight_scale, judge_bias_scale,
373
- 17, logits);
374
-
375
- long end_time = millis();
376
-
377
- int best_idx = 0;
378
- float best_val = logits[0];
379
- for(int i=1; i<17; i++){
380
- if(logits[i] > best_val) {
381
- best_val = logits[i];
382
- best_idx = i;
383
- }
384
- }
385
-
386
- Serial.print(best_idx);
387
- Serial.print("|");
388
- Serial.print(class_names[best_idx]);
389
- Serial.print("|");
390
- Serial.print(t_audio_end - t_audio_start); // Време за Аудио спектрограма
391
- Serial.print("|");
392
- Serial.println(end_time - start_time); // Общо време
393
- } else {
394
- // Изчистваме буфера при разминаване
395
- while(Serial.available() > 0) Serial.read();
396
- }
397
- }
398
- }