基于Yolov8面部七种表情检测与识别C++模型部署

表情识别

七种表情识别是一个多学科交叉的研究领域，它结合了心理学、认知科学、计算机视觉和机器学习等学科的知识和技术。

基本概念

表情的定义：表情是人们在情绪体验时面部肌肉活动的结果，是人类情感交流的基本方式之一。
基本表情理论：心理学家Paul Ekman提出，人类有七种基本情绪，每种情绪都有其特定的面部表情模式。

七种基本表情

快乐：通常与积极情绪相关，特征是嘴角上扬，眼睛周围肌肉收缩。
悲伤：与失落或痛苦相关，特征是眉毛下垂，嘴角下拉。
愤怒：与愤怒或挫败相关，特征是眉毛下压，嘴唇紧闭。
惊讶：与意外或震惊相关，特征是眼睛和嘴巴张开。
恐惧：与害怕或焦虑相关，特征是眼睛瞪大，眉毛提升。
厌恶：与反感或不喜欢相关，特征是上唇提升，嘴角下拉。
轻蔑：与鄙视或不屑一顾相关，特征是嘴角一侧上扬。

应用领域

心理健康监测：通过表情识别来评估个体的情绪状态。
人机交互：使机器人或计算机系统能够理解和响应用户的情绪。
安全监控：在安全检查中识别可疑行为或情绪异常。
娱乐和媒体：在电影、游戏和虚拟现实中生成逼真的虚拟角色表情。

挑战和限制

个体差异：不同人表达相同情绪的方式可能不同。
文化差异：不同文化背景下，表情的表达和解读可能存在差异。
环境因素：光照、遮挡和面部表情的微妙变化可能影响识别的准确性。
实时性要求：在某些应用场景下，如视频监控或实时交互，对系统的处理速度有较高要求。

发展趋势

多模态识别：结合面部表情以外的信息，如语音、心率等，以提高识别的准确性。
迁移学习：利用预训练的深度学习模型来提高小样本学习的性能。
无监督和半监督学习：减少对大量标注数据的依赖，提高模型的泛化能力。

数据集

数据集内容：RAF-DB数据集是一个大规模面部表情数据库，由315名工作人员（大学的学生和教职员工）对表情进行标注。

在对表情的选择上，从一系列表情（例如：微笑，咯咯笑声，哭泣，愤怒，害怕，害怕，恐惧，震惊，惊讶，厌恶，无表情）中，挑选出六种基本情感以及中立情感，一共7种表情进行表情标注。

数据集数量：RAF-DB数据集，包含大约3万张面部图像。除了表情标注外，对每个人脸还有5个特征点标注，人脸边界框，种族，年龄范围和性别等属性的标注。

数据集功能：表情识别、人脸检测、年龄估计

下载链接：http://www.whdeng.cn/RAF/model1.html

在这里插入图片描述

Yolov8目标检测

YOLOv8是YOLO系列的最新迭代产品，它在目标检测领域带来了一系列创新和改进。以下是YOLOv8的一些关键特点和功能：

模型结构：YOLOv8采用了新的SOTA模型，包括不同分辨率的目标检测网络和基于YOLACT的实例分割模型。它在骨干网络和Neck部分可能参考了YOLOv7 ELAN的设计思想，将YOLOv5的C3结构换成了C2f结构，并对不同尺度模型调整了不同的通道数。
Head部分：与YOLOv5相比，YOLOv8的Head部分改动较大，换成了目前主流的解耦头结构，将分类和检测头分离，并且从Anchor-Based换成了Anchor-Free。
Loss计算：YOLOv8采用了TaskAlignedAssigner正样本分配策略，并引入了Distribution Focal Loss，这有助于提高检测过程的准确性和效率。
数据增强：在训练过程中，YOLOv8引入了YOLOX中的最后10个epoch关闭Mosaic增强的操作，这可以有效地提升精度。
训练策略：YOLOv8的模型训练总epoch数从300提升到了500，这导致训练时间增加，但可能有助于进一步提升模型性能。
性能和速度：YOLOv8专注于保持精度与速度之间的最佳平衡，适用于各种应用领域的实时目标检测任务。
预训练模型：YOLOv8提供一系列预训练模型，以满足各种任务和性能要求，从而更容易为您的特定用例找到合适的模型。
支持的任务和模式：YOLOv8系列提供多种模型，每种模型都专门用于计算机视觉中的特定任务，如物体检测、实例分割、姿态/关键点检测等。
性能基准测试：YOLOv8可以进行性能基准测试，以评估在不同导出格式下的速度和准确性。
实战应用：有教程提供了YOLOv8在LabVIEW中的部署，包括模型的导出、图片和视频推理的实现。

环境安装

安装环境：

conda create -n yolov8 python=3.8
activate ylolv8
pip install ultralytics

转onnx

安装完成之后，分割数据进行模型训练。训练完之后把模型转成onnx，使用以下命令将YOLO模型从PyTorch导出为ONNX格式，并设置opset为12：

yolo export model=yolov8s.pt format=onnx dynamic=False opset=12

命令的含义解释如下：

yolo export: 使用YOLO导出功能、
model=yolov8s.pt: 指定PyTorch模型的路径
format=onnx: 导出为ONNX格式
dynamic=False: 关闭动态输入
opset=12: 设置ONNX模型的opset版本为12

转ncnn模型

得到onnx模型之后要转成ncnn的模型，可以使用onnx2ncnn.exe进行模型转换，也可以使用在线的模型转换工具。

模型C++推理部署

ncnn库

从官方下载以编译好的ncnn库，我这里使用的IDE是vs2022,下载对应自己的库。导入lib和include,如果想要指用GPU进行推理，则要编译vulkan库。

C++ 推理代码

#include "FacialEmotion.h"static float fast_exp(float x)
{union {uint32_t i;float f;} v{};v.i = (1 << 23) * (1.4426950409 * x + 126.93490512f);return v.f;
}static inline float sigmoid(float x)
{return 1.0f / (1.0f + fast_exp(-x));
}
static float intersection_area(const Object& a, const Object& b)
{cv::Rect_<float> inter = a.rect & b.rect;return inter.area();
}static void qsort_descent_inplace(std::vector<Object>& faceobjects, int left, int right)
{int i = left;int j = right;float p = faceobjects[(left + right) / 2].prob;while (i <= j){while (faceobjects[i].prob > p)i++;while (faceobjects[j].prob < p)j--;if (i <= j){// swapstd::swap(faceobjects[i], faceobjects[j]);i++;j--;}}//     #pragma omp parallel sections{//         #pragma omp section{if (left < j) qsort_descent_inplace(faceobjects, left, j);}//         #pragma omp section{if (i < right) qsort_descent_inplace(faceobjects, i, right);}}
}static void qsort_descent_inplace(std::vector<Object>& faceobjects)
{if (faceobjects.empty())return;qsort_descent_inplace(faceobjects, 0, faceobjects.size() - 1);
}static void nms_sorted_bboxes(const std::vector<Object>& faceobjects, std::vector<int>& picked, float nms_threshold)
{picked.clear();const int n = faceobjects.size();std::vector<float> areas(n);for (int i = 0; i < n; i++){areas[i] = faceobjects[i].rect.width * faceobjects[i].rect.height;}for (int i = 0; i < n; i++){const Object& a = faceobjects[i];int keep = 1;for (int j = 0; j < (int)picked.size(); j++){const Object& b = faceobjects[picked[j]];// intersection over unionfloat inter_area = intersection_area(a, b);float union_area = areas[i] + areas[picked[j]] - inter_area;// float IoU = inter_area / union_areaif (inter_area / union_area > nms_threshold)keep = 0;}if (keep)picked.push_back(i);}
}
static void generate_grids_and_stride(const int target_w, const int target_h, std::vector<int>& strides, std::vector<GridAndStride>& grid_strides)
{for (int i = 0; i < (int)strides.size(); i++){int stride = strides[i];int num_grid_w = target_w / stride;int num_grid_h = target_h / stride;for (int g1 = 0; g1 < num_grid_h; g1++){for (int g0 = 0; g0 < num_grid_w; g0++){GridAndStride gs;gs.grid0 = g0;gs.grid1 = g1;gs.stride = stride;grid_strides.push_back(gs);}}}
}static void generate_proposals(std::vector<GridAndStride> grid_strides, const ncnn::Mat& pred, float prob_threshold, std::vector<Object>& objects)
{const int num_points = grid_strides.size();const int num_class = 7;const int reg_max_1 = 16;for (int i = 0; i < num_points; i++) //out.h{const float* scores = pred.row(i) + 4 * reg_max_1;// find label with max scoreint label = -1;float score = -FLT_MAX;for (int k = 0; k < num_class; k++){float confidence = scores[k];if (confidence > score){label = k;score = confidence;}}float box_prob = sigmoid(score);if (box_prob >= prob_threshold){ncnn::Mat bbox_pred(reg_max_1, 4, (void*)pred.row(i));{ncnn::Layer* softmax = ncnn::create_layer(ncnn::layer_to_index("Softmax"));
//                ncnn::layer_to_index("Softmax")ncnn::ParamDict pd;pd.set(0, 1); // axis
//                pd.set(1, 1);softmax->load_param(pd);ncnn::Option opt;opt.num_threads = 1;opt.use_packing_layout = false;softmax->create_pipeline(opt);softmax->forward_inplace(bbox_pred, opt);softmax->destroy_pipeline(opt);delete softmax;}float pred_ltrb[4];for (int k = 0; k < 4; k++){float dis = 0.f;const float* dis_after_sm = bbox_pred.row(k);for (int l = 0; l < reg_max_1; l++){dis += l * dis_after_sm[l];}pred_ltrb[k] = dis * grid_strides[i].stride;}float pb_cx = (grid_strides[i].grid0 + 0.5f) * grid_strides[i].stride; float pb_cy = (grid_strides[i].grid1 + 0.5f) * grid_strides[i].stride;float x0 = pb_cx - pred_ltrb[0];float y0 = pb_cy - pred_ltrb[1];float x1 = pb_cx + pred_ltrb[2];float y1 = pb_cy + pred_ltrb[3];Object obj;obj.rect.x = x0;obj.rect.y = y0;obj.rect.width = x1 - x0;obj.rect.height = y1 - y0;obj.label = label;obj.prob = box_prob;objects.push_back(obj);}}
}//调用ncnn转置操作
static void transpose(const ncnn::Mat& in, ncnn::Mat& out)
{ncnn::Option opt;opt.num_threads = 1;opt.use_fp16_storage = false;opt.use_packing_layout = true;ncnn::Layer* op = ncnn::create_layer("Permute");// set paramncnn::ParamDict pd;pd.set(0, 1);// order_type=1op->load_param(pd);op->create_pipeline(opt);op->forward(in,out, opt);op->destroy_pipeline(opt);delete op;
}FacialEmotion::FacialEmotion()
{blob_pool_allocator.set_size_compare_ratio(0.f);workspace_pool_allocator.set_size_compare_ratio(0.f);
}int FacialEmotion::load(std::string parma_path,std::string bin_path,int _target_size,bool use_gpu)
{yolo.clear();blob_pool_allocator.clear();workspace_pool_allocator.clear();ncnn::set_cpu_powersave(2);ncnn::set_omp_num_threads(ncnn::get_big_cpu_count());yolo.opt = ncnn::Option();#if NCNN_VULKANyolo.opt.use_vulkan_compute = use_gpu;
#endifyolo.opt.num_threads = 2;yolo.opt.blob_allocator = &blob_pool_allocator;yolo.opt.workspace_allocator = &workspace_pool_allocator;yolo.load_param(parma_path.c_str());yolo.load_model(bin_path.c_str());target_size = _target_size;return 0;
}int FacialEmotion::detect(const cv::Mat& rgb, std::vector<Object>& objects, float prob_threshold, float nms_threshold)
{int width = rgb.cols;int height = rgb.rows;// pad to multiple of 32int w = width;int h = height;float scale = 1.f;if (w > h){scale = (float)target_size / w;w = target_size;h = h * scale;}else{scale = (float)target_size / h;h = target_size;w = w * scale;}ncnn::Mat in = ncnn::Mat::from_pixels_resize(rgb.data, ncnn::Mat::PIXEL_BGR, width, height, w, h);// pad to target_size rectangleint wpad = (w + 31) / 32 * 32 - w;int hpad = (h + 31) / 32 * 32 - h;ncnn::Mat in_pad;ncnn::copy_make_border(in, in_pad, hpad / 2, hpad - hpad / 2, wpad / 2, wpad - wpad / 2, ncnn::BORDER_CONSTANT, 0.f);in_pad.substract_mean_normalize(0, norm_vals);ncnn::Extractor ex = yolo.create_extractor();ex.input("images", in_pad);std::vector<Object> proposals;ncnn::Mat out;ex.extract("/model.22/Concat_3_output_0", out);ncnn::Mat out1;transpose(out, out1);std::vector<int> strides = {8, 16, 32}; // might have stride=64std::vector<GridAndStride> grid_strides;generate_grids_and_stride(in_pad.w, in_pad.h, strides, grid_strides);generate_proposals(grid_strides, out1, prob_threshold, proposals);qsort_descent_inplace(proposals);// apply nms with nms_thresholdstd::vector<int> picked;nms_sorted_bboxes(proposals, picked, nms_threshold);int count = picked.size();objects.resize(count);for (int i = 0; i < count; i++){objects[i] = proposals[picked[i]];// adjust offset to original unpaddedfloat x0 = (objects[i].rect.x - (wpad / 2)) / scale;float y0 = (objects[i].rect.y - (hpad / 2)) / scale;float x1 = (objects[i].rect.x + objects[i].rect.width - (wpad / 2)) / scale;float y1 = (objects[i].rect.y + objects[i].rect.height - (hpad / 2)) / scale;// clipx0 = std::max(std::min(x0, (float)(width - 1)), 0.f);y0 = std::max(std::min(y0, (float)(height - 1)), 0.f);x1 = std::max(std::min(x1, (float)(width - 1)), 0.f);y1 = std::max(std::min(y1, (float)(height - 1)), 0.f);objects[i].rect.x = x0;objects[i].rect.y = y0;objects[i].rect.width = x1 - x0;objects[i].rect.height = y1 - y0;}// sort objects by areastruct{bool operator()(const Object& a, const Object& b) const{return a.rect.area() > b.rect.area();}} objects_area_greater;std::sort(objects.begin(), objects.end(), objects_area_greater);return 0;
}int FacialEmotion::draw(cv::Mat& rgb, const std::vector<Object>& objects)
{static const char *class_names[] = {"surprise", "fear","disgust","happiness","sadness","anger","neutral"};static const unsigned char colors[19][3] = {{ 54,  67, 244},{ 99,  30, 233},{176,  39, 156},{183,  58, 103},{181,  81,  63},{243, 150,  33},{244, 169,   3},{212, 188,   0},{136, 150,   0},{ 80, 175,  76},{ 74, 195, 139},{ 57, 220, 205},{ 59, 235, 255},{  7, 193, 255},{  0, 152, 255},{ 34,  87, 255},{ 72,  85, 121},{158, 158, 158},{139, 125,  96}};int color_index = 0;for (size_t i = 0; i < objects.size(); i++){const Object& obj = objects[i];const unsigned char* color = colors[color_index % 19];color_index++;cv::Scalar cc(color[0], color[1], color[2]);cv::rectangle(rgb, obj.rect, cc, 2);char text[256];sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);int baseLine = 0;cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);int x = obj.rect.x;int y = obj.rect.y - label_size.height - baseLine;if (y < 0)y = 0;if (x + label_size.width > rgb.cols)x = rgb.cols - label_size.width;cv::rectangle(rgb, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)), cc, -1);cv::Scalar textcc = (color[0] + color[1] + color[2] >= 381) ? cv::Scalar(0, 0, 0) : cv::Scalar(255, 255, 255);cv::putText(rgb, text, cv::Point(x, y + label_size.height), cv::FONT_HERSHEY_SIMPLEX, 0.5, textcc, 1);}return 0;
}