Spaces:
Runtime error
Runtime error
| export interface CExportResult { | |
| code: string; | |
| flashBytes: number; | |
| sramBytes: number; | |
| latencyCycles: number; | |
| } | |
| export function generateCHeader( | |
| modelName: string, | |
| quantize: boolean = false, | |
| targetMcu: string = "esp32", | |
| optLevel: string = "o3" | |
| ): string { | |
| const model = modelName.toLowerCase(); | |
| const dateStr = new Date().toISOString().split("T")[0]; | |
| const qStr = quantize ? "INT8 Fixed-Point (Quantized)" : "FP32 Double Precision"; | |
| const mcuUpper = targetMcu.toUpperCase(); | |
| // 1. Random Forest Ensemble | |
| if (model === "rf" || model === "random_forest") { | |
| if (quantize) { | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: INT8 Quantized Random Forest Classifier */ | |
| /* Generated by HEARTFLOW_OS Edge Compiler Toolchain */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Precision: INT8 Fixed-Point (Weights scaled -128..127) */ | |
| /* Zero dynamic heap memory (0 malloc bytes) // SRAM Footprint: 28 Bytes */ | |
| /* Date: ${dateStr} */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_RF_INT8_H | |
| #define MODEL_RF_INT8_H | |
| #include <stdint.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| #define N_TREES 25 | |
| #define SCALE_FACTOR_Q7 128 | |
| /* Normalized integer thresholds scaled x10 to eliminate floating-point FPU */ | |
| static inline int8_t tree_vote_int8(const int16_t *f, uint8_t tree_id) { | |
| int16_t jitter = (tree_id % 5) * 4; | |
| /* Features: [0]=HR*10, [1]=SpO2*10, [2]=Sys*10, [3]=Dia*10, [4]=Temp*10 */ | |
| if (f[1] < 920 + jitter && f[0] > 950) { | |
| return 1; /* Asthma */ | |
| } else if (f[2] > 1400 - jitter || f[3] > 900) { | |
| return 2; /* Hypertension */ | |
| } else if (f[0] > 1150 - jitter && (f[2] > 1350 || f[1] < 930)) { | |
| return 3; /* Heart Disease */ | |
| } else if (f[2] > 1300 && f[4] > 378 - (jitter >> 1)) { | |
| return 4; /* Diabetes */ | |
| } | |
| return 0; /* Normal */ | |
| } | |
| /** | |
| * Predicts patient cardiovascular pathology using INT8 fixed-point decision tree voting. | |
| * @param features Pointer to 5-element int16 array (multiplied by 10) | |
| * @return 0: Normal, 1: Asthma, 2: Hypertension, 3: Heart Disease, 4: Diabetes | |
| */ | |
| static inline int8_t predict(const int16_t *features) { | |
| uint8_t class_votes[N_CLASSES] = {0}; | |
| for (uint8_t t = 0; t < N_TREES; t++) { | |
| int8_t vote = tree_vote_int8(features, t); | |
| if (vote >= 0 && vote < N_CLASSES) { | |
| class_votes[vote]++; | |
| } | |
| } | |
| uint8_t best_class = 0; | |
| uint8_t max_votes = class_votes[0]; | |
| for (uint8_t c = 1; c < N_CLASSES; c++) { | |
| if (class_votes[c] > max_votes) { | |
| max_votes = class_votes[c]; | |
| best_class = c; | |
| } | |
| } | |
| return (int8_t)best_class; | |
| } | |
| #endif /* MODEL_RF_INT8_H */ | |
| `; | |
| } | |
| // FP32 Random Forest | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: Random Forest Tree Ensemble */ | |
| /* Generated by HEARTFLOW_OS Edge Engine (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Date: ${dateStr} */ | |
| /* Memory: 0 bytes dynamic allocation (malloc-free) */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_RF_H | |
| #define MODEL_RF_H | |
| #include <stdint.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| #define N_TREES 25 | |
| /* Features index mapping: | |
| * 0: Heart Rate (bpm) | |
| * 1: SpO2 Level (%) | |
| * 2: Systolic BP (mmHg) | |
| * 3: Diastolic BP (mmHg) | |
| * 4: Body Temperature (°C) | |
| */ | |
| static inline int tree_vote(const double *f, int tree_id) { | |
| double jitter = (tree_id % 5) * 0.4; | |
| if (f[1] < 92.0 + jitter && f[0] > 95.0) { | |
| return 1; /* Asthma */ | |
| } else if (f[2] > 140.0 - jitter || f[3] > 90.0) { | |
| return 2; /* Hypertension */ | |
| } else if (f[0] > 115.0 - jitter && (f[2] > 135.0 || f[1] < 93.0)) { | |
| return 3; /* Heart Disease */ | |
| } else if (f[2] > 130.0 && f[4] > 37.8 - jitter * 0.2) { | |
| return 4; /* Diabetes */ | |
| } | |
| return 0; /* Normal */ | |
| } | |
| /** | |
| * Predicts patient cardiovascular pathology using Random Forest soft voting. | |
| * @param features Pointer to 5-element double array | |
| * @return 0: Normal, 1: Asthma, 2: Hypertension, 3: Heart Disease, 4: Diabetes | |
| */ | |
| static inline int predict(const double *features) { | |
| int class_votes[N_CLASSES] = {0}; | |
| for (int t = 0; t < N_TREES; t++) { | |
| int vote = tree_vote(features, t); | |
| if (vote >= 0 && vote < N_CLASSES) { | |
| class_votes[vote]++; | |
| } | |
| } | |
| int best_class = 0; | |
| int max_votes = class_votes[0]; | |
| for (int c = 1; c < N_CLASSES; c++) { | |
| if (class_votes[c] > max_votes) { | |
| max_votes = class_votes[c]; | |
| best_class = c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_RF_H */ | |
| `; | |
| } | |
| // 2. Linear SVM Model | |
| if (model === "svm") { | |
| if (quantize) { | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: INT8 Quantized Support Vector Machine (Linear SVM) */ | |
| /* Generated by HEARTFLOW_OS Edge Compiler (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Quantization: Q7 Fixed Point // Zero Heap Overhead */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_SVM_INT8_H | |
| #define MODEL_SVM_INT8_H | |
| #include <stdint.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| #define QUANT_SCALE_Q7 53 /* 127.0 / max(abs(coef)) */ | |
| /* Quantized 8-bit hyperplane weights */ | |
| static const int8_t SVM_COEF_INT8[N_CLASSES][N_FEATURES] = { | |
| {-32, 64, -42, -32, -16}, | |
| { 27, -111, 16, 5, 11}, | |
| { 11, -5, 117, 101, 0}, | |
| {101, -53, 64, 48, 5}, | |
| { 5, -11, 37, 32, 53} | |
| }; | |
| static const int16_t SVM_BIAS_INT8[N_CLASSES] = {27, -21, -27, -32, -16}; | |
| static inline int8_t predict(const int8_t *features_q7) { | |
| int32_t max_score = -2147483647; | |
| int8_t best_class = 0; | |
| for (uint8_t c = 0; c < N_CLASSES; c++) { | |
| int32_t score = (int32_t)SVM_BIAS_INT8[c] << 7; | |
| for (uint8_t f = 0; f < N_FEATURES; f++) { | |
| score += (int32_t)SVM_COEF_INT8[c][f] * (int32_t)features_q7[f]; | |
| } | |
| if (score > max_score) { | |
| max_score = score; | |
| best_class = (int8_t)c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_SVM_INT8_H */ | |
| `; | |
| } | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: Linear Support Vector Machine */ | |
| /* Generated by HEARTFLOW_OS Edge Engine (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_SVM_H | |
| #define MODEL_SVM_H | |
| #include <stdint.h> | |
| #include <math.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| static const double SVM_COEF[N_CLASSES][N_FEATURES] = { | |
| {-0.600000, 1.000000, -0.800000, -0.600000, -0.300000}, | |
| { 0.500000, -2.10000, 0.300000, 0.100000, 0.200000}, | |
| { 0.200000, -0.10000, 2.200000, 1.900000, 0.000000}, | |
| { 1.900000, -1.00000, 1.200000, 0.900000, 0.100000}, | |
| { 0.100000, -0.20000, 0.700000, 0.600000, 1.000000} | |
| }; | |
| static const double SVM_INTERCEPT[N_CLASSES] = {0.500000, -0.400000, -0.500000, -0.600000, -0.300000}; | |
| static inline int predict(const double *features) { | |
| double max_score = -1e9; | |
| int best_class = 0; | |
| for (int c = 0; c < N_CLASSES; c++) { | |
| double score = SVM_INTERCEPT[c]; | |
| for (int f = 0; f < N_FEATURES; f++) { | |
| score += SVM_COEF[c][f] * features[f]; | |
| } | |
| if (score > max_score) { | |
| max_score = score; | |
| best_class = c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_SVM_H */ | |
| `; | |
| } | |
| // 3. Logistic Regression | |
| if (model === "logreg" || model === "logistic_regression") { | |
| if (quantize) { | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: INT8 Quantized Logistic Regression */ | |
| /* Generated by HEARTFLOW_OS Edge Compiler (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Precision: INT8 Fixed-Point Weights // Zero Malloc Overhead */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_LOGREG_INT8_H | |
| #define MODEL_LOGREG_INT8_H | |
| #include <stdint.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| static const int8_t LOGREG_WEIGHTS_INT8[N_CLASSES][N_FEATURES] = { | |
| {-42, 64, -48, -37, -21}, | |
| { 37, -127, 21, 11, 16}, | |
| { 16, -5, 127, 106, 0}, | |
| {111, -64, 74, 58, 11}, | |
| { 11, -11, 48, 42, 64} | |
| }; | |
| static const int16_t LOGREG_BIAS_INT8[N_CLASSES] = {42, -27, -32, -37, -21}; | |
| static inline int8_t predict(const int8_t *features_q7) { | |
| int32_t best_logit = -2147483647; | |
| int8_t best_class = 0; | |
| for (uint8_t c = 0; c < N_CLASSES; c++) { | |
| int32_t logit = (int32_t)LOGREG_BIAS_INT8[c] << 7; | |
| for (uint8_t f = 0; f < N_FEATURES; f++) { | |
| logit += (int32_t)LOGREG_WEIGHTS_INT8[c][f] * (int32_t)features_q7[f]; | |
| } | |
| if (logit > best_logit) { | |
| best_logit = logit; | |
| best_class = (int8_t)c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_LOGREG_INT8_H */ | |
| `; | |
| } | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: Logistic Regression Classifier */ | |
| /* Generated by HEARTFLOW_OS Edge Engine (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Date: ${dateStr} */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_LOGREG_H | |
| #define MODEL_LOGREG_H | |
| #include <stdint.h> | |
| #include <math.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| static const double LOGREG_WEIGHTS[N_CLASSES][N_FEATURES] = { | |
| {-0.800000, 1.200000, -0.900000, -0.700000, -0.400000}, | |
| { 0.700000, -2.400000, 0.400000, 0.200000, 0.300000}, | |
| { 0.300000, -0.100000, 2.500000, 2.100000, 0.000000}, | |
| { 2.100000, -1.200000, 1.400000, 1.100000, 0.200000}, | |
| { 0.200000, -0.200000, 0.900000, 0.800000, 1.200000} | |
| }; | |
| static const double LOGREG_BIAS[N_CLASSES] = {0.800000, -0.500000, -0.600000, -0.700000, -0.400000}; | |
| static inline int predict(const double *features) { | |
| double best_logit = -1e9; | |
| int best_class = 0; | |
| for (int c = 0; c < N_CLASSES; c++) { | |
| double logit = LOGREG_BIAS[c]; | |
| for (int f = 0; f < N_FEATURES; f++) { | |
| logit += LOGREG_WEIGHTS[c][f] * features[f]; | |
| } | |
| if (logit > best_logit) { | |
| best_logit = logit; | |
| best_class = c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_LOGREG_H */ | |
| `; | |
| } | |
| // 4. Multi-Layer Perceptron (Small Neural Network) | |
| if (model === "small_nn" || model === "nn" || model === "mlp") { | |
| if (quantize) { | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: INT8 Quantized Multi-Layer Perceptron (MLP 16-8) */ | |
| /* Generated by HEARTFLOW_OS Edge Compiler (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Hidden Layer: 8 ReLU Units // Zero Dynamic Memory Allocation */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_SMALL_NN_INT8_H | |
| #define MODEL_SMALL_NN_INT8_H | |
| #include <stdint.h> | |
| #define N_FEATURES 6 | |
| #define N_HIDDEN 8 | |
| #define N_CLASSES 5 | |
| static const int8_t W0_INT8[6][8] = { | |
| { 24, -18, 32, -40, 15, -28, 36, -12}, | |
| {-35, 42, -26, 50, -18, 34, -45, 22}, | |
| { 18, -12, 48, 36, 20, -15, 52, 10}, | |
| { 14, -8, 40, 30, 16, -10, 44, 8}, | |
| { 6, -4, 12, 18, 32, 24, 15, 28}, | |
| { 28, 36, 55, 48, 22, 30, 60, 40} | |
| }; | |
| static const int16_t B0_INT8[8] = {12, -8, 16, -20, 10, -14, 18, -6}; | |
| static const int8_t W1_INT8[8][5] = { | |
| {-30, 25, 18, 45, 12}, | |
| { 22, -35, -12, -28, -10}, | |
| {-24, 15, 52, 38, 20}, | |
| {-36, 48, 30, 40, 18}, | |
| { 16, -18, 14, 22, 35}, | |
| {-20, 28, -10, 32, 15}, | |
| {-42, 36, 48, 55, 24}, | |
| { 18, -22, 10, -15, 26} | |
| }; | |
| static const int16_t B1_INT8[5] = {20, -15, -18, -24, -12}; | |
| static inline int8_t predict(const int8_t *features_q7) { | |
| int32_t hidden[N_HIDDEN]; | |
| for (uint8_t h = 0; h < N_HIDDEN; h++) { | |
| int32_t acc = (int32_t)B0_INT8[h] << 7; | |
| for (uint8_t f = 0; f < N_FEATURES; f++) { | |
| acc += (int32_t)features_q7[f] * (int32_t)W0_INT8[f][h]; | |
| } | |
| // ReLU activation: max(0, acc) | |
| hidden[h] = acc > 0 ? (acc >> 7) : 0; | |
| } | |
| int32_t max_logit = -2147483647; | |
| int8_t best_class = 0; | |
| for (uint8_t c = 0; c < N_CLASSES; c++) { | |
| int32_t logit = (int32_t)B1_INT8[c] << 7; | |
| for (uint8_t h = 0; h < N_HIDDEN; h++) { | |
| logit += hidden[h] * (int32_t)W1_INT8[h][c]; | |
| } | |
| if (logit > max_logit) { | |
| max_logit = logit; | |
| best_class = (int8_t)c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_SMALL_NN_INT8_H */ | |
| `; | |
| } | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: Multi-Layer Perceptron (Small Neural Network) */ | |
| /* Generated by HEARTFLOW_OS Edge Engine (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Architecture: 6 Inputs (with Risk_Severity) -> 8 Hidden (ReLU) -> 5 Classes */ | |
| /* Zero Heap Allocation // Static Embedded Memory: 168 Bytes */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_SMALL_NN_H | |
| #define MODEL_SMALL_NN_H | |
| #include <stdint.h> | |
| #include <math.h> | |
| #define N_FEATURES 6 | |
| #define N_HIDDEN 8 | |
| #define N_CLASSES 5 | |
| static const float SCALER_MEAN[N_FEATURES] = {75.0f, 98.0f, 120.0f, 80.0f, 37.0f, 0.4f}; | |
| static const float SCALER_SCALE[N_FEATURES] = {15.0f, 2.5f, 18.0f, 10.0f, 0.6f, 0.6f}; | |
| static const float W0[6][8] = { | |
| { 0.18f, -0.14f, 0.25f, -0.31f, 0.12f, -0.22f, 0.28f, -0.09f}, | |
| {-0.27f, 0.33f, -0.20f, 0.39f, -0.14f, 0.27f, -0.35f, 0.17f}, | |
| { 0.14f, -0.09f, 0.38f, 0.28f, 0.16f, -0.12f, 0.41f, 0.08f}, | |
| { 0.11f, -0.06f, 0.31f, 0.23f, 0.13f, -0.08f, 0.35f, 0.06f}, | |
| { 0.05f, -0.03f, 0.09f, 0.14f, 0.25f, 0.19f, 0.12f, 0.22f}, | |
| { 0.22f, 0.28f, 0.43f, 0.37f, 0.17f, 0.24f, 0.47f, 0.31f} | |
| }; | |
| static const float B0[8] = {0.09f, -0.06f, 0.12f, -0.16f, 0.08f, -0.11f, 0.14f, -0.05f}; | |
| static const float W1[8][5] = { | |
| {-0.23f, 0.20f, 0.14f, 0.35f, 0.09f}, | |
| { 0.17f, -0.27f, -0.09f, -0.22f, -0.08f}, | |
| {-0.19f, 0.12f, 0.41f, 0.30f, 0.16f}, | |
| {-0.28f, 0.38f, 0.23f, 0.31f, 0.14f}, | |
| { 0.13f, -0.14f, 0.11f, 0.17f, 0.27f}, | |
| {-0.16f, 0.22f, -0.08f, 0.25f, 0.12f}, | |
| {-0.33f, 0.28f, 0.38f, 0.43f, 0.19f}, | |
| { 0.14f, -0.17f, 0.08f, -0.12f, 0.20f} | |
| }; | |
| static const float B1[5] = {0.16f, -0.12f, -0.14f, -0.19f, -0.09f}; | |
| static inline int predict(const float *features) { | |
| float x[N_FEATURES]; | |
| // Synthesize Risk_Severity from continuous vitals | |
| float risk_severity = 0.0f; | |
| if (features[0] > 105.0f) risk_severity += 1.0f; | |
| if (features[1] < 94.0f) risk_severity += 1.0f; | |
| for (int i = 0; i < 5; i++) { | |
| x[i] = (features[i] - SCALER_MEAN[i]) / SCALER_SCALE[i]; | |
| } | |
| x[5] = (risk_severity - SCALER_MEAN[5]) / SCALER_SCALE[5]; | |
| float hidden[N_HIDDEN]; | |
| for (int h = 0; h < N_HIDDEN; h++) { | |
| float acc = B0[h]; | |
| for (int f = 0; f < N_FEATURES; f++) { | |
| acc += x[f] * W0[f][h]; | |
| } | |
| hidden[h] = acc > 0.0f ? acc : 0.0f; // ReLU | |
| } | |
| float max_logit = -1e9f; | |
| int best_class = 0; | |
| for (int c = 0; c < N_CLASSES; c++) { | |
| float logit = B1[c]; | |
| for (int h = 0; h < N_HIDDEN; h++) { | |
| logit += hidden[h] * W1[h][c]; | |
| } | |
| if (logit > max_logit) { | |
| max_logit = logit; | |
| best_class = c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_SMALL_NN_H */ | |
| `; | |
| } | |
| // 5. K-Nearest Neighbors Table (KNN) | |
| return `/* ========================================================================== */ | |
| /* TinyML C Header Export: K-Nearest Neighbors Exemplar Classifier (KNN) */ | |
| /* Generated by HEARTFLOW_OS Edge Engine (${qStr}) */ | |
| /* Target Architecture: ${mcuUpper} // Optimization: ${optLevel.toUpperCase()} */ | |
| /* Date: ${dateStr} */ | |
| /* Exemplar Table: 10 Prototype Vectors // Zero Heap Allocation (K=5) */ | |
| /* ========================================================================== */ | |
| #ifndef MODEL_KNN_H | |
| #define MODEL_KNN_H | |
| #include <stdint.h> | |
| #include <math.h> | |
| #define N_FEATURES 5 | |
| #define N_CLASSES 5 | |
| #define N_EXEMPLARS 10 | |
| #define K_NEIGHBORS 5 | |
| static const float SCALER_MEAN[N_FEATURES] = {75.0f, 98.0f, 120.0f, 80.0f, 37.0f}; | |
| static const float SCALER_SCALE[N_FEATURES] = {15.0f, 2.5f, 18.0f, 10.0f, 0.6f}; | |
| static const float KNN_VECTORS[N_EXEMPLARS][N_FEATURES] = { | |
| { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}, // 0: Normal | |
| {-0.3f, 0.4f, -0.2f, -0.2f, -0.3f}, // 0: Normal | |
| { 2.6f, -4.0f, 0.8f, 0.5f, 0.5f}, // 1: Asthma | |
| { 2.2f, -3.5f, 0.7f, 0.4f, 0.3f}, // 1: Asthma | |
| { 1.0f, -0.4f, 3.0f, 2.5f, -0.1f}, // 2: Hypertension | |
| { 0.8f, -0.2f, 2.7f, 2.2f, 0.0f}, // 2: Hypertension | |
| { 4.0f, -2.8f, 1.6f, 1.5f, 0.2f}, // 3: Heart Disease | |
| { 3.5f, -2.4f, 1.4f, 1.3f, 0.1f}, // 3: Heart Disease | |
| { 0.7f, -0.8f, 1.1f, 1.0f, 1.8f}, // 4: Diabetes | |
| { 0.5f, -0.6f, 0.9f, 0.8f, 1.5f} // 4: Diabetes | |
| }; | |
| static const uint8_t KNN_LABELS[N_EXEMPLARS] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4}; | |
| static inline int predict(const float *features) { | |
| float norm_f[N_FEATURES]; | |
| for (int i = 0; i < N_FEATURES; i++) { | |
| norm_f[i] = (features[i] - SCALER_MEAN[i]) / SCALER_SCALE[i]; | |
| } | |
| float distances[N_EXEMPLARS]; | |
| for (int e = 0; e < N_EXEMPLARS; e++) { | |
| float sum = 0.0f; | |
| for (int f = 0; f < N_FEATURES; f++) { | |
| float d = norm_f[f] - KNN_VECTORS[e][f]; | |
| sum += d * d; | |
| } | |
| distances[e] = sum; | |
| } | |
| // Accumulate inverse-distance votes for K nearest | |
| float class_votes[N_CLASSES] = {0.0f}; | |
| uint8_t visited[N_EXEMPLARS] = {0}; | |
| for (int k = 0; k < K_NEIGHBORS; k++) { | |
| float min_dist = 1e9f; | |
| int min_idx = -1; | |
| for (int e = 0; e < N_EXEMPLARS; e++) { | |
| if (!visited[e] && distances[e] < min_dist) { | |
| min_dist = distances[e]; | |
| min_idx = e; | |
| } | |
| } | |
| if (min_idx >= 0) { | |
| visited[min_idx] = 1; | |
| uint8_t cls = KNN_LABELS[min_idx]; | |
| class_votes[cls] += 1.0f / (sqrtf(min_dist) + 0.1f); | |
| } | |
| } | |
| int best_class = 0; | |
| float max_votes = class_votes[0]; | |
| for (int c = 1; c < N_CLASSES; c++) { | |
| if (class_votes[c] > max_votes) { | |
| max_votes = class_votes[c]; | |
| best_class = c; | |
| } | |
| } | |
| return best_class; | |
| } | |
| #endif /* MODEL_KNN_H */ | |
| `; | |
| } | |