边缘AI使得在嵌入式设备上实时处理传感器数据成为可能。本文介绍如何在资源受限的嵌入式系统中实现机器学习推理。

一、边缘AI系统架构

c

复制

下载

// 神经网络推理引擎
typedef struct {
    const nn_layer_t *layers;      // 网络层
    uint16_t layer_count;          // 层数
    float *input_buffer;           // 输入缓冲区
    float *output_buffer;          // 输出缓冲区
    float *workspace;              // 工作内存
    uint32_t workspace_size;       // 工作内存大小
} neural_network_t;

// 传感器AI特征
typedef struct {
    float mean[3];                 // 均值特征
    float variance[3];             // 方差特征
    float frequency_domain[32];    // 频域特征
    uint8_t activity_class;        // 活动分类
    float confidence;              // 分类置信度
} sensor_ai_features_t;

二、轻量级神经网络推理

c

复制

下载

// 固定点神经网络层
typedef struct {
    int16_t *weights;              // 量化权重
    int16_t *bias;                 // 量化偏置
    uint16_t input_size;           // 输入大小
    uint16_t output_size;          // 输出大小
    uint8_t weight_scale;          // 权重缩放因子
    uint8_t bias_scale;            // 偏置缩放因子
    activation_t activation;       // 激活函数
} quantized_layer_t;

// 固定点矩阵乘法
void quantized_matrix_multiply(const int16_t *input,
                              const int16_t *weights,
                              int16_t *output,
                              uint16_t input_size,
                              uint16_t output_size,
                              uint8_t input_scale,
                              uint8_t weight_scale) {
    
    for (uint16_t i = 0; i < |output_size; i++) {
        int32_t acc = 0;
        
        for (uint16_t j = 0; j < input_size; j++) {
            acc += (int32_t)input[j] * weights[i * input_size + j];
        }
        
        // 重新缩放并饱和到16位
        output[i] = saturate16(acc >> (input_scale + weight_scale - OUTPUT_SCALE));
    }
}

// 神经网络前向传播
void neural_network_infer(neural_network_t *nn,
                         const float *sensor_data,
                         float *output) {
    
    // 预处理传感器数据
    preprocess_sensor_data(sensor_data, nn->input_buffer);
    
    // 逐层推理
    float *current_input = nn->input_buffer;
    
    for (uint16_t i = 0; i < nn->layer_count; i++) {
        const nn_layer_t *layer = &nn->layers[i];
        float *current_output = (i =zb.jinqiulvshi.cn= nn->layer_count - 1) ? 
                               output : &nn->workspace[i * layer->output_size];
        
        // 全连接层
        matrix_multiply(current_input, layer->weights, current_output,
                       layer->input_size, layer->output_size);
        
        // 添加偏置
        vector_add(current_output, layer->bias, layer->output_size);
        
        // 激活函数
        apply_activation(current_output, layer->output_size, layer->activation);
        
        current_input = current_output;
    }
}

三、实时活动识别

c

复制

下载

// 活动识别分类器
typedef struct {
    float thresholds[6];           // 分类阈值
    uint8_t feature_window_size;   // 特征窗口大小
    float feature_buffer[3][32];   // 特征缓冲区
    uint16_t buffer_index;         // 缓冲区索引
    uint32_t activity_count[6];    // 活动计数
} activity_classifier_t;

// 实时活动分类
uint8_t classify_physical_activity(activity_classifier_t *classifier,
                                  const float *accel_data) {
    
    // 更新特征缓冲区
    memcpy(&classifier->feature_buffer[0][classifier->buffer_index], accel_data, 3 * sizeof(float));
    classifier->buffer_index = (classifier->buffer_index + 1) % classifier->feature_window_size;
    
    // 计算时域特征
    sensor_ai_features_t features;
    extract_time_domain_features(classifier->feature_buffer, &features);
    
    // 计算频域特征
    extract_frequency_domain_features(classifier->feature_buffer, &features);
    
    // 神经网络推理
    float nn_input[35]; // 35个特征
    prepare_nn_input(&features, nn_input);
    
    float nn_output[6]; // 6种活动类型
    neural_network_infer(&activity_nn, nn_input, nn_output);
    
    // 选择最可能的活动类型
    uint8_t activity = argmax(nn_output, 6);
    features.confidence = nn_output[activity];
    
    // 更新活动计数
    classifier->activity_count[activity]++;
    
    return activity;
}

四、自适应阈值学习

c

复制

下载

// 在线学习系统
typedef struct {
    float current_thresholds[6];   // 当前阈值
    float learning_rate;           // 学习率
    uint32_t sample_count;         // 样本计数
    float confidence_history[100]; // 置信度历史
    uint16_t history_index;        // 历史索引
} adaptive_learning_t;

void update_thresholds_online(adaptive_learning_t *learner,
                             uint8_t true_activity,
                             uint8_t predicted_activity,
                             float confidence) {
    
    // 保存置信度历史
    learner->confidence_history[learner->history_index] = confidence;
    learner->history_index = (learner->history_index + 1) % 100;
    
    // 仅在学习阶段更新阈值
    if (learner->sample_count < MAX_LEARNING_SAMPLES) {
        if (true_activity == predicted_activity) {
            // 正确分类，适当降低阈值
            learner->current_thresholds[true_activity] -= 
                learner->learning_rate * (1.0f - confidence);
        } else {
            // 错误分类，提高阈值
            learner->current_thresholds[predicted_activity] += 
                learner->learning_rate * confidence;
        }
        
        // 确保阈值在合理范围内
        learner->current_thresholds[true_activity] = 
            fmaxf(0.1f, fminf(0.9f, learner->current_thresholds[true_activity]));
        
        learner->sample_count++;
    }
}