发表了主题帖： [RV1106&InsightFace]--RV1106开发环境部署及人脸识别实现

本帖最后由 许大锤 于 2025-1-12 13:53 编辑 采用的开发板：**LuckFox Pico Pro/Max**是基于**瑞芯微 RV1106 G3芯片** 官方参考文档：https://wiki.luckfox.com/zh/Luckfox-Pico/Luckfox-Pico-quick-start ## 镜像烧入 按照[官方文档](https://wiki.luckfox.com/zh/Luckfox-Pico/Luckfox-Pico-Flash-burn-image)进行镜像烧入即可。通过SPI NAND Flash无法烧入Ubuntu，我烧入的是Buildroot，感觉很多指令用不了，但也不太影响使用。 ## SSH/Telnet 登录 IPV4地址设置为 172.32.0.100，然后通过SSH登入，具体的配置见[官方文档](https://wiki.luckfox.com/zh/Luckfox-Pico/SSH-Telnet-Login)。 - **Buildroot**   ```text   登录账号：root   登录密码：luckfox   静态IP地址：172.32.0.93   ```    - **Ubuntu**   ```text   登录账号：pico   登录密码：luckfox   静态IP地址：172.32.0.70   ``` ## 连接摄像头 [官方文档](https://wiki.luckfox.com/zh/Luckfox-Pico/CSI-Camera) **确保摄像头排线的金属面朝向开发板芯** 可以用VLC或者PotPlay打开网络串流，输入默认的 IP 地址：rtsp://172.32.0.93/live/0  ## Buildroot配置 先按照教程进行SDK环境部署。就不赘述了，python导入一个pip包就可以。 ## 部署 先查看下python版本。 ```shell [root@luckfox root]# python --version Python 3.11.6 ``` 配置ssh环境 安装相关的包和基础操作见：https://bbs.eeworld.com.cn/thread-1304121-1-1.html ## 视频流识别 还注意要把模型转换以下为rknn,网上有好多帖子，很简单就不说明了。 照这个帖子做，可以调整下输出视频的分辨率，我没调分辨率，新的代码如下： ```python import cv2 import numpy as np import time from rknn.api import RKNN import threading from queue import Queue import os class FaceRecognitionRKNN:     def __init__(self, model_path, face_database, threshold=0.5):         self.model_path = model_path         self.face_database = face_database         self.threshold = threshold         self.rknn = RKNN()         self.processing = True                  # 初始化队列用于多线程处理         self.frame_queue = Queue(maxsize=2)         self.result_queue = Queue(maxsize=2)                  # 加载和初始化模型         self.init_model()              def init_model(self):         """初始化RKNN模型"""         print('Loading RKNN model...')         ret = self.rknn.load_rknn(self.model_path)         if ret != 0:             print('Load RKNN model failed')             exit(ret)                  # 初始化运行时环境         print('Init runtime environment...')         ret = self.rknn.init_runtime()         if ret != 0:             print('Init runtime environment failed')             exit(ret)         print('Init done')     def preprocess_frame(self, frame):         """预处理图像"""         # 根据模型要求调整图像大小和格式         resized = cv2.resize(frame, (112, 112))         normalized = (resized - 127.5) / 128.0         input_data = normalized.reshape(1, 112, 112, 3)         return input_data     def inference(self, input_data):         """执行推理"""         outputs = self.rknn.inference(inputs=[input_data])         return outputs[0]  # 假设只有一个输出     def calculate_similarity(self, embedding1, embedding2):         """计算余弦相似度"""         norm1 = np.linalg.norm(embedding1)         norm2 = np.linalg.norm(embedding2)         return np.dot(embedding1, embedding2) / (norm1 * norm2)     def process_frame(self, frame):         """处理单帧图像"""         # 人脸检测（这里需要添加您的人脸检测逻辑）         # 假设已经有了人脸检测的结果         faces = self.detect_faces(frame)  # 需要实现这个方法                  results = []         for face_img, bbox in faces:             # 预处理             input_data = self.preprocess_frame(face_img)                          # 推理             embedding = self.inference(input_data)                          # 人脸识别             best_match = None             best_similarity = -1                          for name, db_embedding in self.face_database.items():                 similarity = self.calculate_similarity(embedding, db_embedding)                 if similarity > best_similarity:                     best_similarity = similarity                     best_match = name                          if best_similarity > self.threshold:                 results.append({                     'name': best_match,                     'similarity': best_similarity,                     'bbox': bbox                 })                  return results     def process_stream(self, rtsp_url):         """处理视频流"""         cap = cv2.VideoCapture(rtsp_url)         if not cap.isOpened():             print(f"无法打开视频流: {rtsp_url}")             return         print("开始处理视频流...")         try:             while self.processing:                 ret, frame = cap.read()                 if not ret:                     break                 # 处理帧                 results = self.process_frame(frame)                 # 绘制结果                 for result in results:                     bbox = result['bbox']                     name = result['name']                     similarity = result['similarity']                     # 绘制边界框                     cv2.rectangle(frame,                                 (bbox[0], bbox[1]),                                 (bbox[2], bbox[3]),                                 (0, 255, 0), 2)                     # 显示名字和相似度                     text = f"{name} {similarity*100:.1f}%"                     cv2.putText(frame, text,                               (bbox[0], bbox[1] - 10),                               cv2.FONT_HERSHEY_SIMPLEX,                               0.5, (0, 255, 0), 2)                 # 显示结果                 cv2.imshow('Face Recognition', frame)                 if cv2.waitKey(1) & 0xFF == ord('q'):                     break         except Exception as e:             print(f"处理出错: {str(e)}")         finally:             cap.release()             cv2.destroyAllWindows()             self.rknn.release()     def detect_faces(self, frame):         """         人脸检测方法         需要根据您的具体需求实现         返回格式: [(face_img, bbox), ...]         """         # 这里需要实现您的人脸检测逻辑         pass def load_face_database(database_path):     """加载人脸数据库"""     # 实现加载人脸数据库的逻辑     pass if __name__ == "__main__":     try:         # 配置         model_path = 'path/to/your/model.rknn'         database_path = 'path/to/your/face_database.pkl'         rtsp_url = "rtsp://172.32.0.93/live/0"                  # 加载人脸数据库         face_database = load_face_database(database_path)                  # 创建识别器         recognizer = FaceRecognitionRKNN(             model_path=model_path,             face_database=face_database,             threshold=0.5         )                  # 开始处理视频流         recognizer.process_stream(rtsp_url)              except Exception as e:         print(f"程序出错: {str(e)}") ``` 如果只需要实时显示，不需要保存视频，可以将 output_video 设为 None。 视频流截图，带个精度（活动要求），可能老三国视频本来就没那么清晰，加上再用摄像头拍的，然后我在录入人脸时也就录了一张，并且刘备和张飞的分都在百分之50到75之间，这可能是录入人脸时图片选不太好：

发表了主题帖： [RV1106&InsightFace]--InsightFace实现视频中的人脸识别

前文已经实现了本地部署，也实现图片和视频的人脸检测。https://bbs.eeworld.com.cn/thread-1303465-1-1.html#pid3385431 接下来是实现视频中人脸识别。 ## 准备 ```shell pip install torch opencv-python insightface numpy scikit-learn pip install insightface pip install onnxruntime pip install onnxruntime-gpu pip install opencv-contrib-python ``` 为了让输出的视频包含音频，建议安装FFmpeg，具体如何安装网上有很多教程。 接下来是实现视频中人脸识别，但感觉处理速度挺慢的，所以每5帧进行一次识别，中间做的识别框就做插值处理了，还有感觉合成音频也蛮费时间的。 ## 构建人脸数据库 先准备几个人脸图片，修改image_path的路径，name变量是视频中标记的名字，建议用英文，中文可能会出问题。 ```python # 添加新的人脸 image_path = 'img/guanyu.jpg'  # 已知人脸图片路径 name = "Guan Yu"  # 对应的身份名称 ``` 完整代码： ```python import cv2 import insightface import pickle from insightface.app import FaceAnalysis # 初始化 ArcFace 模型 app = FaceAnalysis() app.prepare(ctx_id=0, det_size=(640, 640)) # 数据库路径 database_path = './face_database.pkl' try:     with open(database_path, 'rb') as f:         face_database = pickle.load(f)     print("已加载人脸数据库") except FileNotFoundError:     face_database = {}     print("人脸数据库不存在，创建空数据库") # 添加新的人脸 image_path = 'img/guanyu.jpg'  # 已知人脸图片路径 name = "Guan Yu"  # 对应的身份名称 image = cv2.imread(image_path) faces = app.get(image) if len(faces) == 1:     face = faces[0]     embedding = face.embedding  # 提取特征向量     face_database[name] = embedding     print(f"已添加人脸：{name}") else:     print("未检测到人脸或检测到多张人脸，请检查图片") # 保存数据库 with open(database_path, 'wb') as f:     pickle.dump(face_database, f) print("人脸数据库已保存") ``` ## 视频中人脸识别 ### 代码 ```python import cv2 import pickle import numpy as np from insightface.app import FaceAnalysis from sklearn.metrics.pairwise import cosine_similarity import time import os import subprocess import threading from queue import Queue, Empty from tqdm import tqdm import torch # 检查是否可以使用GPU DEVICE = 'cuda:0' if torch.cuda.is_available() else 'cpu' # 设置 FFmpeg 路径 FFMPEG_PATH = r"C:\ProgramData\chocolatey\lib\ffmpeg\tools\ffmpeg\bin\ffmpeg.exe" class VideoProcessor:     def __init__(self, input_path: str, output_path: str, face_database: dict,                  batch_size: int = 4, num_workers: int = 4):         self.input_path = input_path         self.output_path = output_path         self.temp_output_path = output_path.replace('.mp4', '_temp.mp4')         self.face_database = face_database         self.batch_size = batch_size         self.num_workers = num_workers         # 初始化 InsightFace         self.app = FaceAnalysis(providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])         self.app.prepare(ctx_id=0, det_size=(640, 640))         # 初始化队列         self.frame_queue = Queue(maxsize=30)         self.result_queue = Queue(maxsize=30)         # 获取视频信息         self.cap = cv2.VideoCapture(input_path)         self.fps = self.cap.get(cv2.CAP_PROP_FPS)         self.frame_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))         self.frame_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))         self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))         # 创建视频写入器         self.writer = cv2.VideoWriter(             self.temp_output_path,             cv2.VideoWriter_fourcc(*'mp4v'),             self.fps,             (self.frame_width, self.frame_height)         )         # 存储检测到的人脸信息         self.detected_faces = {}         self.face_lock = threading.Lock()         # 添加处理状态标志         self.processing = True     def read_frames(self):         """读取视频帧的线程函数"""         frame_count = 0         pbar_read = tqdm(total=self.total_frames,                          desc="读取帧",                          position=0,                          leave=True)         while self.processing:             ret, frame = self.cap.read()             if not ret:                 break             self.frame_queue.put((frame_count, frame))             frame_count += 1             pbar_read.update(1)         pbar_read.close()         self.frame_queue.put(None)  # 发送结束信号     def process_frame(self, frame_data):         """处理单个视频帧"""         if frame_data is None:             return None         frame_count, frame = frame_data         current_time = time.time()         # 每5帧处理一次人脸检测         if frame_count % 5 == 0:             faces = self.app.get(frame)             current_faces = {}             for face in faces:                 face_embedding = face.normed_embedding                 bbox = face.bbox.astype(int)                 # 人脸识别                 best_match = None                 best_similarity = -1                 for name, db_embedding in self.face_database.items():                     similarity = cosine_similarity([face_embedding], [db_embedding])[0][0]                     if similarity > best_similarity:                         best_similarity = similarity                         best_match = name                 if best_match is not None and best_similarity > 0.5:                     current_faces[best_match] = {                         'bbox': bbox,                         'last_seen': current_time                     }             # 更新检测到的人脸信息             with self.face_lock:                 self.detected_faces.update(current_faces)                 # 移除超时的人脸                 faces_to_remove = []                 for name, info in self.detected_faces.items():                     if current_time - info['last_seen'] > 0.5:  # 0.5秒超时                         faces_to_remove.append(name)                 for name in faces_to_remove:                     self.detected_faces.pop(name)         # 绘制识别框         with self.face_lock:             for name, info in self.detected_faces.items():                 bbox = info['bbox']                 cv2.rectangle(frame, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)                 cv2.putText(frame, name, (bbox[0], bbox[1] - 10),                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)         return frame_count, frame     def process_frames(self):         """处理视频帧的线程函数"""         while self.processing:             try:                 frame_data = self.frame_queue.get(timeout=1.0)                 if frame_data is None:                     self.result_queue.put(None)                     break                 result = self.process_frame(frame_data)                 if result is not None:                     self.result_queue.put(result)             except Empty:                 continue             except Exception as e:                 print(f"\n处理帧时出错: {str(e)}")                 break     def write_frames(self):         """写入处理后的帧的线程函数"""         processed_frames = {}         next_frame_to_write = 0         remaining_frames = self.total_frames         timeout_counter = 0         pbar_write = tqdm(total=self.total_frames,                           desc="写入帧",                           position=1,                           leave=True)         while remaining_frames > 0 and self.processing:             try:                 result = self.result_queue.get(timeout=1.0)                 if result is None:                     if len(processed_frames) == 0:                         break                     timeout_counter += 1                     if timeout_counter > 10:                         print("\n警告：部分帧可能未处理完成")                         break                     continue                 timeout_counter = 0                 frame_count, frame = result                 processed_frames[frame_count] = frame                 while next_frame_to_write in processed_frames:                     self.writer.write(processed_frames[next_frame_to_write])                     del processed_frames[next_frame_to_write]                     next_frame_to_write += 1                     remaining_frames -= 1                     pbar_write.update(1)             except Empty:                 if len(processed_frames) > 0:                     available_frames = sorted(processed_frames.keys())                     if available_frames[0] == next_frame_to_write:                         self.writer.write(processed_frames[next_frame_to_write])                         del processed_frames[next_frame_to_write]                         next_frame_to_write += 1                         remaining_frames -= 1                         pbar_write.update(1)                 continue             except Exception as e:                 print(f"\n写入帧时出错: {str(e)}")                 break         if processed_frames:             print("\n处理剩余帧...")             for frame_count in sorted(processed_frames.keys()):                 self.writer.write(processed_frames[frame_count])                 pbar_write.update(1)                 remaining_frames -= 1         pbar_write.close()     def combine_audio(self):         """合并视频和音频"""         try:             command = [                 FFMPEG_PATH,                 '-i', self.temp_output_path,                 '-i', self.input_path,                 '-c:v', 'copy',                 '-c:a', 'aac',                 '-strict', 'experimental',                 '-y',                 self.output_path             ]             print("执行音频合并...")             result = subprocess.run(command,                                     stdout=subprocess.PIPE,                                     stderr=subprocess.PIPE,                                     text=True)             if result.returncode == 0:                 print("音频合并成功！")                 return True             else:                 print("FFmpeg 错误:")                 print(result.stderr)                 return False         except Exception as e:             print(f"音频合并出错: {str(e)}")             print(f"临时文件保留在: {self.temp_output_path}")             return False     def process_video(self):         """处理整个视频"""         print(f"\n开始处理视频: {self.input_path}")         print(f"总帧数: {self.total_frames}")         start_time = time.time()         try:             # 创建线程             threads = []             # 读取帧的线程             read_thread = threading.Thread(target=self.read_frames)             threads.append(read_thread)             # 处理帧的线程池             process_threads = []             for _ in range(self.num_workers):                 t = threading.Thread(target=self.process_frames)                 process_threads.append(t)                 threads.append(t)             # 写入帧的线程             write_thread = threading.Thread(target=self.write_frames)             threads.append(write_thread)             # 启动所有线程             for t in threads:                 t.start()             # 设置超时时间（秒）             timeout = 300  # 5分钟             start = time.time()             # 等待所有线程完成             for t in threads:                 remaining = timeout - (time.time() - start)                 if remaining

回复了主题帖： [RV1106&InsightFace]--InsightFace本地部署

Jacktang 发表于 2025-1-3 07:31 最新的insightface库仅支持onnx模型,其他的可以转换过来，用 Insightface 库调用它们，就是转换麻烦不？ 不麻烦，就几行代码，TensorFlow 或 PyTorch转换起来挺简单的。 PyTorch用torch.onnx.export()，TensorFlow也有tf2onnx工具进行转换。

发表了主题帖： [RV1106&InsightFace]--InsightFace本地部署

本帖最后由 许大锤 于 2025-1-3 18:02 编辑 ## InsightFace 和 ArcFace 介绍 **InsightFace** 是一个开源的人脸识别工具集，基于深度学习技术，支持多种人脸检测、对齐和特征提取算法。该项目的核心之一是 **ArcFace**，它是一种用于优化人脸特征嵌入的损失函数。 ------ ### ArcFace 的核心特点 1. **目标**：ArcFace 的目标是生成高判别力的特征嵌入，用于人脸识别和验证。 2. **损失函数**：ArcFace 使用基于角度的加权损失（Additive Angular Margin Loss, AAM），在特征嵌入空间中引入明确的间隔，从而提升分类边界的区分性。 3. **关键公式**：    $$    ArcFace 定义了 \cos(\theta + m)作为优化目标，其中    $$    $$    \theta是类别中心与样本之间的角度，m 是额外的角度边距，用于强化分类边界。    $$ 4. **架构支持**：支持 ResNet 和 MobileFaceNet 等轻量级和高性能网络。 5. **训练和推理**：    - 训练：优化网络生成的特征嵌入，使其在多样化的人脸数据集上具有强区分性。    - 推理：提取特征后，使用余弦相似度或其他度量方法计算相似性。     ------ ### InsightFace 项目的模块 1. **人脸检测**：使用 RetinaFace 等高性能检测算法。 2. **人脸对齐**：提供对齐方法，确保特征提取的一致性。 3. **人脸特征提取**：基于 ArcFace 等方法提取嵌入向量。 4. **工具支持**：InsightFace 提供完整的训练和推理框架，支持 TensorRT、ONNX 和 PyTorch。 ------ ### 参考资料 - [InsightFace GitHub 项目](https://github.com/deepinsight/insightface?tab=readme-ov-file) - [ArcFace 官方网站](https://insightface.ai/arcface) ## InsightFace部署 ### python-package ```shell pip install insightface pip install onnxruntime pip install onnxruntime-gpu pip install opencv-contrib-python  #安装带有GUI的OpenCV ``` > 对于 `insightface > 从`insightface>=0.2`开始，我们使用onnxruntime作为推理后端。 > > 必须手动安装 `onnxruntime-gpu` 才能启用 GPU 推理，或安装 `onnxruntime` 以仅使用 CPU 推理。 手动下载 zip 模型包后，请先将其解压到 `~/.insightface/models/` 下，然后再调用程序。 对于insightface>=0.3.3，一旦我们初始化`app = FaceAnalysis()`实例，模型就会自动下载。 也可以使用**自己训练的模型**。 > 只需在`~/.insightface/models/`下创建一个新的模型目录，并将我们提供的预训练模型替换为您自己的模型。然后调用`app = FaceAnalysis(name='your_model_zoo')`加载这些模型。 > 最新的insightface库仅支持onnx模型。一旦您通过 PyTorch、MXNet 或任何其他框架训练了检测或识别模型，您可以将其转换为 onnx 格式，然后可以使用 Insightface 库调用它们。 ### 代码实现 图片中人物检测 ```python import insightface from insightface.app import FaceAnalysis import cv2 # 初始化 InsightFace 的人脸分析模块 app = FaceAnalysis() app.prepare(ctx_id=0)  # ctx_id=0 使用 GPU，-1 使用 CPU # 读取图像 img = cv2.imread("./img/Big_liar.jpg") # 检查图像是否成功加载 if img is None:     print("Error: Unable to load image. Check file path or file integrity.") else:     # 检测图像中的人脸     faces = app.get(img)     # 打印返回的 faces 列表内容，检查数据结构     print(f"Detected faces: {faces}")     if len(faces) == 0:         print("No faces detected in the image.")     else:         for i, face in enumerate(faces):             print(f"Detected face {i}:")             # 打印所有键，检查返回的字典结构             print(f"  Keys: {face.keys()}")             # 如果包含 'landmark' 键，则打印             if 'landmark' in face:                 print(f"  Landmark: {face['landmark']}")  # 人脸关键点位置             else:                 print("  No landmark detected.")             # 打印其他可能有用的字段，例如 bounding box 和 confidence             print(f"  Bounding box: {face.get('bbox')}")             print(f"  Confidence: {face.get('confidence')}")             # 获取人脸框（bbox）             bbox = face.get('bbox')             # 使用 .any() 来检查 bbox 是否包含有效的边界框数据             if bbox is not None and bbox.any():                 # 绘制人脸框                 cv2.rectangle(img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 0), 2)             else:                 print("  Invalid bounding box.")         # 显示结果         cv2.imshow("Face Detection", img)         cv2.waitKey(0)         cv2.destroyAllWindows() ``` 视频（流）人物检测： ```python import cv2 import insightface from insightface.app import FaceAnalysis import time # 初始化FaceAnalysis应用，使用GPU加速（ctx_id=0 表示使用GPU，-1 表示使用CPU） app = FaceAnalysis() app.prepare(ctx_id=1, det_size=(640, 640))  # 640x640 是输入图像的尺寸 # 读取视频文件或打开摄像头（摄像头为 0） video_path = './video/1.mp4'  # 如果使用摄像头，替换为 0 cap = cv2.VideoCapture(video_path) # 检查视频是否成功打开 if not cap.isOpened():     print("无法打开视频文件")     exit() # 设置视频帧的显示尺寸（可选，减少分辨率有助于提高帧率） cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) # 获取视频的帧率 fps = cap.get(cv2.CAP_PROP_FPS) frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) # 定义输出视频文件的编码格式和输出路径 output_video_path = './video/1_output_video.mp4' fourcc = cv2.VideoWriter_fourcc(*'mp4v') out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height)) frame_count = 0 start_time = time.time() while True:     # 读取一帧     ret, frame = cap.read()     if not ret:         break     frame_count += 1     # 使用 ArcFace 进行人脸检测     faces = app.get(frame)     # 在每个检测到的人脸上绘制矩形框     for face in faces:         bbox = face.bbox         cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 255, 0), 2)         # 标注人脸的置信度分数         if face.score is not None:             cv2.putText(frame, f"Score: {face.score:.2f}",                         (int(bbox[0]), int(bbox[1]) - 10),                         cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)     # 将处理后的帧写入输出视频文件     out.write(frame)     # 计算并显示当前帧率     elapsed_time = time.time() - start_time     fps_current = frame_count / elapsed_time     print(f"当前帧率: {fps_current:.2f} FPS")     # 显示视频帧     cv2.imshow('Video Face Detection', frame)     # 按 'q' 键退出视频显示     if cv2.waitKey(1) & 0xFF == ord('q'):         break # 释放视频捕捉对象和视频写入对象 cap.release() out.release() # 关闭窗口 cv2.destroyAllWindows() print(f"视频处理完成，输出文件：{output_video_path}") ``` ### 参考 https://github.com/deepinsight/insightface/tree/master/python-package

回复了主题帖： 入围名单公布：嵌入式工程师AI挑战营（进阶）的挑战者们，领取板卡啦

个人信息已确认，领取板卡，可继续完成任务。

加入了学习《MIT 6.622 Power Electronics》，观看 DC-DC, Part 2

回复了主题帖： 嵌入式工程师AI挑战营（进阶）：在RV1106部署InsightFace算法的多人实时人脸识别实战

申请理由： InsightFace 主要依赖于 ArcFace 技术，这是一种基于角度度量的人脸识别方法。ArcFace 通过学习特征的角度信息，能够提供更高的识别准确率，尤其是在处理低质量图像或复杂背景时，表现非常出色。 使用 RV1106 的 SDK 和工具链（如 Rockchip 的 RKNN Toolkit）来优化和部署模型。使用 TensorFlow Lite 或 PyTorch，安装 OpenCV 和 dlib 等库用于图像处理和人脸检测。InsightFace 提供了多个预训练模型。选择一个适合实时处理的轻量级模型，如 ResNet 或 MobileFaceNet。 优化模型。使用 TensorFlow Lite 或 ONNX 格式来将模型转换为适合移动端或嵌入式设备的轻量级格式。使用 Quantization（量化）等方法来减少模型大小和计算量，尤其是对于硬件加速的 NPU 可以提高推理速度。使用 RKNN Toolkit 将模型转换为 RV1106 可识别的格式，并利用 NPU 提供的加速。 计划部署的应用： 智能零售与客户分析：在零售店、商场等环境中进行顾客分析，识别回头客、分析顾客行为、统计顾客停留时长等

加入了学习《【DigiKey创意大赛】多通道微型气相色谱采集单元》，观看 多通道微型气相色谱采集单元

发表了主题帖： 【2023 DigiKey大赛参与奖】开箱帖：ESP32 BASIC COER

发表了主题帖： 【STEVAL-WESU1】第二周 基础功能测试

本帖最后由 许大锤 于 2024-2-22 09:28 编辑 由于过年，以及软件不适配等因素，第二周测评姗姗来迟。 APP WESU1有一款手机端软件，但由于这个软件很久没有更新，按照教程无法从谷歌商店中下载（提示手机版Android本太高），IOS端又不支持我所在的地区，本以为项目无法进行下去，但功夫不负有心人我找到了配套App的APK，我将它放在附件中。 初体验 首先是将板子通过USB接通电源   然后通过BLE蓝牙与手机配对，这时弹出提示，说板子程序固件有些低，直接继续就行，体验其基础功能。 点击侧边栏，能看到功能选项，还是十分丰富的。 我先点击了Environment，但发现这里显示的温度高达31.2摄氏度，但目前环境温度为25摄氏度，这个明显不准确，可能需要再程序中调整。 我又对其他功能进行了体验，如下： 能感觉出传感器还是很灵敏的，有些体验需要穿戴到身上才能体验，目前无法进行。 装配 先是剪下方向标尺； 然后安装锂电池； 放入盒子中； 充电； 出现问题 经过了一夜的充电，仍然无法仅仅通过锂电池供电，由于这个产品是2017年的，有可能是锂电池已损坏，也有有可能是我连接问题导致充电失败，由于网上资料甚少，目前该问题无法解决，我准备先买一个同款锂电池，再进行后续研究。 下周计划 个人穿戴体验一周