from abc import abstractmethod,ABC from shapely.geometry import Point, Polygon from myutils.ConfigManager import myCongif from myutils.MyLogger_logger import LogHandler import numpy as np import cv2 import time import queue from datetime import datetime, timedelta import threading import ast if myCongif.get_data("model_platform") == "acl": import acl import platform #-----acl相关------ SUCCESS = 0 # 成功状态值 FAILED = 1 # 失败状态值 ACL_MEM_MALLOC_NORMAL_ONLY = 2 # 申请内存策略, 仅申请普通页 class ModelRunData: def __init__(self): self.channel_id = None class ModelBase(ABC): def __init__(self,path,mMM): ''' 模型类实例化 :param path: 模型文件本身的路径 :param threshold: 模型的置信阈值 ''' self.model_path = path # 模型路径 self.mMM = mMM # ModelManager self.mylogger = LogHandler().get_logger("ModelManager") self.name = None #基于name来查询，用户对模型的配置参数，代表着模型名称需要唯一 2024-6-18 -逻辑还需要完善和验证 self.version = None self.model_type = None # 模型类型 1-图像分类，2-目标检测（yolov5)，3-分割模型，4-关键点 self.system = myCongif.get_data("model_platform") #platform.system() #获取系统平台 #--2024-7-12调整规则，一个视频通道只允许配置一个算法模型，一个算法模型可以配置给多路通道 self.channel_list = [] #该模型需要处理的视频通道 self.cid_copy_list = [] #基于channel_list的备份，提供给遍历线程 self.channel_data_list =[] #该模型，针对每个通道配置的执行参数 ChannelData --包含了输入和输出数据 self.cda_copy_list = [] #基于channel_data_list的备份，提供给遍历线程 self.frame_interval = 1.0 / int(myCongif.get_data("verify_rate")) self.init_ok = False #启动推理线程 -- 实例化后是否启动工作线程 -- acl这么搞 self.run = False #创建线程锁 self.list_lock = threading.Lock() #list修改锁 self.copy_lock = threading.Lock() #副本拷贝锁 self.read_lock = threading.Lock() #遍历线程锁 self.readers = 0 #并发读个数 def __del__(self): print("资源释放") def addChannel(self,channel_id,channel_data): #这两个参数有点重复，后续考虑优化 bfind = False with self.list_lock: for cid in self.channel_list: if cid == channel_id: bfind = True if not bfind: self.channel_data_list.append(channel_data) self.channel_list.append(channel_id) #复制备份 self.set_copy_list() def delChannel(self,channel_id):#调用删除通道的地方，若channel为空，则停止线程，删除该模型对象 with self.list_lock: for i,cid in enumerate(self.channel_list): if cid == channel_id: self.channel_list.remove(channel_id) #self.channel_data_list[i].cleardata() #释放内存 self.channel_data_list.pop(i) # 复制备份 self.set_copy_list() def set_copy_list(self): #把list拷贝一个副本 with self.copy_lock: self.cid_copy_list = self.channel_list.copy() self.cda_copy_list = self.channel_data_list.copy() # copy使用读写锁，这样能避免三个遍历线程间相互竞争 def acquire_read(self): with self.read_lock: self.readers += 1 if self.readers == 1: self.copy_lock.acquire() def release_read(self): with self.read_lock: self.readers -= 1 if self.readers == 0: self.copy_lock.release() def get_copy_list(self): #线程中拷贝一个本地副本 其实读线程里面执行的时间复杂度也不高，直接用copy锁一样 self.acquire_read() local_id = self.cid_copy_list.copy() local_data = self.cda_copy_list.copy() self.release_read() return local_id,local_data def strop_th(self): '''停止该模型的工作线程''' self.run = False time.sleep(1) #确认下在哪执行 #删除list del self.channel_list def start_th(self): #要确保三个线程对channel_data的读取和修改是线程安全的，或是独立分开的。 #预处理 # th_pre = threading.Thread(target=self.th_prework) # 一个视频通道一个线程，线程句柄暂时部保留 # th_pre.start() #推理 th_infer = threading.Thread(target=self.th_startwork) # 一个视频通道一个线程，线程句柄暂时部保留 th_infer.start() #后处理 # th_post = threading.Thread(target=self.th_postwork) # 一个视频通道一个线程，线程句柄暂时部保留 # th_post.start() def th_sleep(self,frame_interval,last_time): # 控制帧率 -- 推理帧率必须所有模型一致，若模型推理耗时一致，该方案还算可以。 current_time = time.time() elapsed_time = current_time - last_time if elapsed_time < frame_interval: time.sleep(frame_interval - elapsed_time) # 若小于间隔时间则休眠 def is_in_schedule(self,channel_data): '''判断当前时间是否在该通道的工作计划时间内''' # 验证检测计划，是否在布防时间内 now = datetime.now() # 获取当前日期和时间 weekday = now.weekday() # 获取星期几，星期一是0，星期天是6 hour = now.hour if channel_data.schedule[weekday][hour] == 1: # 不在计划则不进行验证，直接返回图片 return 0 else: next_hour = (now + timedelta(hours=1)).replace(minute=0, second=0, microsecond=0) seconds_until_next_hour = (next_hour - now).seconds return seconds_until_next_hour def th_prework(self): last_pre_time = time.time() while self.run: #start_do_time = time.time() # 控制帧率 -- 推理帧率必须所有模型一致， self.th_sleep(self.frame_interval, last_pre_time) last_pre_time = time.time() #拷贝副本到线程本地 with self.copy_lock: #local_cid = self.cid_copy_list.copy() local_cdata = self.cda_copy_list.copy() for channel_data in local_cdata: # 如果没有视频通道结束线程 #判断是否在布防计划内 sleep_time = self.is_in_schedule(channel_data) if sleep_time == 0: #判断是否工作计划内-- 后来判断下是否推理和后处理线程需要休眠 channel_data.bModel = True else: channel_data.bModel = False time.sleep(sleep_time) continue # 读取图片进行推理 ret, img = channel_data.cap.read() if not ret: continue #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #这个要确认下什么模式输入进预处理 #？ preimg,scale_ratio, pad_size = self.prework(img) #子类实现-根据每个模型的需要进行预处理 if not channel_data.preimg_q.full(): channel_data.preimg_q.put(preimg) channel_data.img_q.put(img) channel_data.set_in_cale_ratio(scale_ratio, pad_size) else: self.mylogger.debug("preimg_q--预处理队列满了！ infer线程处理过慢！") #end_do_time = time.time() # # 计算执行时间（秒） # execution_time = end_do_time - start_do_time # # 输出执行时间 # print(f"预处理代码执行时间为：{execution_time:.6f} 秒") def th_startwork(self): '''模型工作线程 由于有多输入通道，需要将执行任务降低到最少''' self._init_acl() #创建context if not self._init_resource(): #加载模型文件 -- 正常来说这里不应该失败--上层函数暂时都认为是成功的！需完善 self.mylogger.error("模型文件初始化加载失败！") return last_infer_time = time.time() #开始工作--- 尽量精简！ while self.run: #start_do_time = time.time() # 控制帧率 -- 推理帧率必须所有模型一致， self.th_sleep(self.frame_interval, last_infer_time) last_infer_time = time.time() # 拷贝副本到线程本地 with self.copy_lock: # local_cid = self.cid_copy_list.copy() local_cdata = self.cda_copy_list.copy() for channel_data in local_cdata: #如果没有视频通道可以结束线程#？ if channel_data.preimg_q.empty(): continue img = channel_data.preimg_q.get() src_img = channel_data.img_q.get() #就执行推理，针对结果的逻辑判断交给后处理线程处理。-- 需要确认除目标识别外其他模型的执行方式 output = self.execute([img,])[0] # 执行推理 if len(output) > 0: if not channel_data.output_q.full(): channel_data.output_q.put(output) channel_data.infer_img_q.put(src_img) #原图交给后处理线程 else: self.mylogger.debug("output_q--后处理队列满了！后处理过慢！") # end_do_time= time.time() # # 计算执行时间（秒） # execution_time = end_do_time - start_do_time # # 输出执行时间 # print(f"****************推理代码执行时间为：{execution_time:.6f} 秒") #结束工作-开始释放资源 self.release() self._del_acl() def th_postwork(self): warn_interval = int(myCongif.get_data("warn_interval")) last_out_time = time.time() while self.run: # 控制帧率 -- 推理帧率必须所有模型一致， self.th_sleep(self.frame_interval, last_out_time) last_out_time = time.time() # 拷贝副本到线程本地 with self.copy_lock: local_cid = self.cid_copy_list.copy() local_cdata = self.cda_copy_list.copy() for i, channel_data in enumerate(local_cdata): # 控制帧率 -- 推理帧率必须所有模型一致，若模型推理耗时一致，该方案还算可以。 if channel_data.output_q.empty(): continue #执行后处理 output = channel_data.output_q.get() img = channel_data.infer_img_q.get() cale_ratio = channel_data.cale_ratio pad_size = channel_data.pad_size if len(output) <1: continue filtered_pred_all, bwarn, warn_text = self.postwork(img,output,channel_data.in_check_area, channel_data.in_polygon,cale_ratio,pad_size) #子类实现--具体的报警逻辑 #img的修改应该在原内存空间修改的 channel_data.result.pop(0) #先把最早的结果推出数组，保障结果数组定长 if bwarn: # 整个识别有产生报警 #根据模型设定的时间和占比判断是否 # 绘制报警文本 cv2.putText(img, warn_text, (50,50),cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2) channel_data.result.append(1) else: #没有产生报警也需要记录，统一计算占比 channel_data.result.append(0) # 处理完的图片后返回-bgr模式 --一头一尾是不是抵消了，可以不做处理#？ #img_bgr_ndarray = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # 在线程里面完成应该可以减少网页端处理时间 ret, frame_bgr_webp = cv2.imencode('.jpg', img) if not ret: buffer_bgr_webp = None else: buffer_bgr_webp = frame_bgr_webp.tobytes() # 分析图片放入内存中 #channel_data.add_deque(img_bgr_ndarray) # 缓冲区大小由maxlen控制 超上限后，删除最前的数据 channel_data.add_deque(img) channel_data.increment_counter() # 帧序列加一 # 一直更新最新帧,提供网页端显示 channel_data.update_last_frame(buffer_bgr_webp) # print(f"{channel_id}--Frame updated at:",time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) # 验证result_list -是否触发报警要求 --遍历每个模型执行的result if bwarn: result = channel_data.result #最近的检测记录 proportion = channel_data.proportion #判断报警的占比 count_one = float(sum(result)) # 1,0 把1累加的和就是1的数量 ratio_of_ones = count_one / len(result) # self.logger.debug(result) if ratio_of_ones >= proportion: # 触发报警 # 基于时间间隔判断 current_time = time.time() elapsed_time = current_time - channel_data.warn_last_time if elapsed_time < warn_interval: continue #处理报警 channel_data.warn_last_time = current_time model_name = channel_data.model_name w_s_count = channel_data.warn_save_count #上次保存的缓冲帧序号 buffer_count = channel_data.get_counter() #线程？ self.mMM.save_warn(model_name, w_s_count, buffer_count, channel_data.copy_deque(), channel_data.cap.width, channel_data.cap.height, local_cid[i], self.mMM.FPS, self.mMM.fourcc) self.mMM.send_warn() # 更新帧序列号 channel_data.warn_save_count = buffer_count # 结果记录要清空 for i in range(len(result)): result[i] = 0 def draw_polygon(self, img, polygon_points,color=(0, 255, 0)): self.polygon = Polygon(ast.literal_eval(polygon_points)) points = np.array([self.polygon.exterior.coords], dtype=np.int32) cv2.polylines(img, points, isClosed=True, color=color, thickness=2) def is_point_in_region(self, point): '''判断点是否在区域内，需要先执行draw_polygon''' if self.polygon: return self.polygon.contains(Point(point)) else: return False #acl ----- 相关----- def _init_acl(self,device_id=0): self.context, ret = acl.rt.create_context(device_id) # 显式创建一个Context if ret: raise RuntimeError(ret) print('Init TH-Context Successfully') def _del_acl(self): device_id = 0 # 线程释放context ret = acl.rt.destroy_context(self.context) # 释放 Context if ret: raise RuntimeError(ret) print('Deinit TH-Context Successfully') def _init_resource(self): ''' 初始化模型、输出相关资源。相关数据类型: aclmdlDesc aclDataBuffer aclmdlDataset''' print("Init model resource") # 加载模型文件 #self.model_path = "/home/HwHiAiUser/samples/yolo_acl_sample/yolov5s_bs1.om" self.model_id, ret = acl.mdl.load_from_file(self.model_path) # 加载模型 if ret != 0: print(f"{self.model_path}---模型加载失败！") return False self.model_desc = acl.mdl.create_desc() # 初始化模型信息对象 ret = acl.mdl.get_desc(self.model_desc, self.model_id) # 根据模型ID获取该模型的aclmdlDesc类型数据(描述信息） print("[Model] Model init resource stage success") # 创建模型输出 dataset 结构 ret = self._gen_output_dataset() # 创建模型输出dataset结构 if ret !=0: print("[Model] create model output dataset fail") return False return True def _gen_output_dataset(self): ''' 组织输出数据的dataset结构 ''' ret = SUCCESS self._output_num = acl.mdl.get_num_outputs(self.model_desc) # 根据aclmdlDesc类型的数据，获取模型的输出个数 self.output_dataset = acl.mdl.create_dataset() # 创建输出dataset结构 for i in range(self._output_num): temp_buffer_size = acl.mdl.get_output_size_by_index(self.model_desc, i) # 获取模型输出个数 temp_buffer, ret = acl.rt.malloc(temp_buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY) # 为每个输出申请device内存 dataset_buffer = acl.create_data_buffer(temp_buffer, temp_buffer_size) # 创建输出的data buffer结构,将申请的内存填入data buffer _, ret = acl.mdl.add_dataset_buffer(self.output_dataset, dataset_buffer) # 将 data buffer 加入输出dataset（地址) if ret == FAILED: self._release_dataset(self.output_dataset) # 失败时释放dataset return ret print("[Model] create model output dataset success") return ret def _gen_input_dataset(self, input_list): ''' 组织输入数据的dataset结构 ''' ret = SUCCESS self._input_num = acl.mdl.get_num_inputs(self.model_desc) # 获取模型输入个数 self.input_dataset = acl.mdl.create_dataset() # 创建输入dataset结构 for i in range(self._input_num): item = input_list[i] # 获取第 i 个输入数据 data_ptr = acl.util.bytes_to_ptr(item.tobytes()) # 获取输入数据字节流 size = item.size * item.itemsize # 获取输入数据字节数 dataset_buffer = acl.create_data_buffer(data_ptr, size) # 创建输入dataset buffer结构, 填入输入数据 _, ret = acl.mdl.add_dataset_buffer(self.input_dataset, dataset_buffer) # 将dataset buffer加入dataset if ret == FAILED: self._release_dataset(self.input_dataset) # 失败时释放dataset #print("[Model] create model input dataset success") def _unpack_bytes_array(self, byte_array, shape, datatype): ''' 将内存不同类型的数据解码为numpy数组 ''' np_type = None # 获取输出数据类型对应的numpy数组类型和解码标记 if datatype == 0: # ACL_FLOAT np_type = np.float32 elif datatype == 1: # ACL_FLOAT16 np_type = np.float16 elif datatype == 3: # ACL_INT32 np_type = np.int32 elif datatype == 8: # ACL_UINT32 np_type = np.uint32 else: print("unsurpport datatype ", datatype) return # 将解码后的数据组织为numpy数组,并设置shape和类型 return np.frombuffer(byte_array, dtype=np_type).reshape(shape) def _output_dataset_to_numpy(self): ''' 将模型输出解码为numpy数组 ''' dataset = [] # 遍历每个输出 for i in range(self._output_num): buffer = acl.mdl.get_dataset_buffer(self.output_dataset, i) # 从输出dataset中获取buffer data_ptr = acl.get_data_buffer_addr(buffer) # 获取输出数据内存地址 size = acl.get_data_buffer_size(buffer) # 获取输出数据字节数 narray = acl.util.ptr_to_bytes(data_ptr, size) # 将指针转为字节流数据 # 根据模型输出的shape和数据类型,将内存数据解码为numpy数组 outret = acl.mdl.get_output_dims(self.model_desc, i)[0] dims = outret["dims"] # 获取每个输出的维度 # print(f"name:{outret['name']}") # print(f"dimCount:{outret['dimCount']}") ''' dims = { "name": xxx, #tensor name "dimCount":xxx，#shape中的维度个数 "dims": [xx, xx, xx] # 维度信息 --- 取的这个 } ''' datatype = acl.mdl.get_output_data_type(self.model_desc, i) # 获取每个输出的数据类型 --就数据类型float16,int8等 output_nparray = self._unpack_bytes_array(narray, tuple(dims), datatype) # 解码为numpy数组 dataset.append(output_nparray) return dataset def execute(self, input_list): '''创建输入dataset对象, 推理完成后, 将输出数据转换为numpy格式''' self._gen_input_dataset(input_list) # 创建模型输入dataset结构 ret = acl.mdl.execute(self.model_id, self.input_dataset, self.output_dataset) # 调用离线模型的execute推理数据 if ret: self.mylogger.error(f"acl.mdl.execute fail!--{ret}") self._release_dataset(self.input_dataset) # 失败时释放dataset --创建输入空间失败时会释放。 return None out_numpy = self._output_dataset_to_numpy() # 将推理输出的二进制数据流解码为numpy数组, 数组的shape和类型与模型输出规格一致 self._release_dataset(self.input_dataset) # 释放dataset -- 要不要执行需要验证 return out_numpy def release(self): ''' 释放模型相关资源 ''' if self._is_released: return print("Model start release...") self._release_dataset(self.input_dataset) # 释放输入数据结构 self.input_dataset = None # 将输入数据置空 self._release_dataset(self.output_dataset) # 释放输出数据结构 self.output_dataset = None # 将输出数据置空 if self.model_id: ret = acl.mdl.unload(self.model_id) # 卸载模型 if self.model_desc: ret = acl.mdl.destroy_desc(self.model_desc) # 释放模型描述信息 self._is_released = True print("Model release source success") #测试使用 #self._del_acl() def _release_dataset(self, dataset): ''' 释放 aclmdlDataset 类型数据 ''' if not dataset: return num = acl.mdl.get_dataset_num_buffers(dataset) # 获取数据集包含的buffer个数 for i in range(num): data_buf = acl.mdl.get_dataset_buffer(dataset, i) # 获取buffer指针 if data_buf: ret = acl.destroy_data_buffer(data_buf) # 释放buffer ret = acl.mdl.destroy_dataset(dataset) # 销毁数据集 @abstractmethod def prework(self, image): # 预处理 pass @abstractmethod def verify(self,image,data,isdraw=1): # ''' :param image: 需要验证的图片 :param data: select t1.model_id,t1.check_area,t1.polygon ,t2.duration_time,t2.proportion,t2.model_path :param isdraw: 是否需要绘制线框：0-不绘制，1-绘制 :return: detections,bwarn,warntext bwarn:0-没有识别到符合要求的目标，1-没有识别到符合要求的目标。 ''' pass @abstractmethod def postwork(self,image,output,check_area,polygon,scale_ratio, pad_size): # 后处理 pass if __name__ =="__main__": pass