From f36e6564c2a14d24fcabd671dc855255ef44db76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=97=AB=E6=B5=A9=E9=9C=96?= <2103200855@qq.com>
Date: Mon, 26 Aug 2024 16:50:02 +0800
Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20=E4=B8=9C=E5=8C=97?=
 =?UTF-8?q?=E5=A4=A7=E5=AD=A6=E7=A7=A6=E7=9A=87=E5=B2=9B=E5=88=86=E6=A0=A1?=
 =?UTF-8?q?=5F=E7=99=BD=E5=A1=94=E5=B2=AD143=E9=98=9F=5F=E7=99=BE=E5=BA=A6?=
 =?UTF-8?q?=E6=99=BA=E6=85=A7=E4=BA=A4=E9=80=9A.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...Œ—大学秦皇岛分校_白塔岭143队_百度智慧交通.md | 240 +++++++++++++++++-
 1 file changed, 237 insertions(+), 3 deletions(-)

diff --git a/东北大学秦皇岛分校_白塔岭143队_百度智慧交通.md b/东北大学秦皇岛分校_白塔岭143队_百度智慧交通.md
index 2b2bf4b..b50f66f 100644
--- a/东北大学秦皇岛分校_白塔岭143队_百度智慧交通.md
+++ b/东北大学秦皇岛分校_白塔岭143队_百度智慧交通.md
@@ -81,12 +81,14 @@ z 轴使用带�尔编�器的蜗�电机，该电机�速机具有自�特
 
 在程�实际�行中，我们�现当推�开�时，一个模型的进程需��用 2G 左�的内存，�使是在代�中开�了内存优化，并且指定大�，实际�用并没有明显区别。当开�多个推�进程时，会导致内存�满，使得�些进程被 kill 掉。由于规则�制最大�能使用 8G 内存的 nano ��，所以挂载了一个较大的 swap 分区，使用�盘缓存���会出现物�内存�用过高的情况，实际测试下，未�明显的性能影�。
 
-此外，为了��开机自�的效果，我们构建了一个守护进程，使用 systemctl 管�。
+此外，为了��开机自�的效果，我们构建了一个守护进程，使用 systemctl 管�我们的人机交互程�。
 
 ### 上�机程�总体设计
 
 为了��程�的高效�行，上�机程�总体采用“生产者-消费者�模型，所有进程由守护进程管�，首先由图�采集进程采集图�并储存在缓冲区中；推�进程从缓冲区获�图�，推�完��将推�结果储存；控制线程需�推�结果时，�推��务器请求暂存的推�结果��，所有进程间请求�使用 zmq 的 “请求-应答� 模�。通过上述的结构模�，�以��获�数�最新且请求速度较快。
 
+![](/Users/snow/Desktop/百度智慧交通/TechDoc-BC2024/无标题-2024-08-26-1601.png)
+
 ### 执行机构接�程�设计
 
 执行机构接�作为 python 模�导入控制进程的程�中，本体基于 C 编译�动�链接库，然�通过 cython 构建� python 模�。
@@ -95,15 +97,247 @@ z 轴使用带�尔编�器的蜗�电机，该电机�速机具有自�特
 
 ### 图�采集�务器程�设计
 
-图�采集�务器程�基于 C/C++ 编写，是一个独立的进程。该进程使用 opencv 读�摄�头图�，�个摄�头对象构造一个采集和应答线程，��获�和�应的图�最新。
+图�采集�务器程�基于 C/C++ 编写，是一个独立的进程。该进程使用 opencv 读�摄�头图�，�个摄�头对象构造一个采集和应答线程，��获�和�应的图�最新。使用了多语言支�的zeromq消�传递库建立一个请求-�应模型的 socket �务器。相关代�如下：
+
+```c++
+cap = new cv::VideoCapture(index, cv::CAP_V4L2);
+sleep(2);
+cap->set(cv::CAP_PROP_FRAME_WIDTH, width);
+cap->set(cv::CAP_PROP_FRAME_HEIGHT, height);
+cap->set(cv::CAP_PROP_FPS, fps);
+
+context = new zmq::context_t(1);
+socket = new zmq::socket_t(*context, ZMQ_REP);
+char zmq_bind_port[10] = {0};
+sprintf(zmq_bind_port, "%d", port);
+strcat(zmq_bind_addr, zmq_bind_port);
+log_info("设置 %d zmq 地� %s", index, zmq_bind_addr);
+socket->bind(zmq_bind_addr);
+```
+
+
 
 ### 推��务器程�设计
 
+在备赛过程中，我们注�到在�车通过岔路�时需�使用目标检测检测�方的转�牌从而确定下一步�哪一方��进，�时巡线模型还需��断请求��摄�头以获�转�分�数�，为了解决这���的深度模型需�请求��的图��的问题，我们设计了推��务器层。
+
+![](无标题-2024-08-26-1600.png)
+
+以lane_infer巡线推� server 为例，相关代�如下：
+
+```python
+while True:
+    camera_socket.send_string("")
+    message = camera_socket.recv()
+    np_array = np.frombuffer(message, dtype=np.uint8)
+    frame = cv2.imdecode(np_array, cv2.IMREAD_COLOR)
+    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+    result = predictor.infer(frame)
+    with lock:
+        response['data'] = result
+```
+
+```python
+# 处� server �应数�
+def server_resp(lane_infer_port):
+    global response
+    logger.info("lane server thread init success")
+    
+    context = zmq.Context()
+    socket = context.socket(zmq.REP)
+    socket.bind(f"tcp://*:{lane_infer_port}")
+    logger.info("lane infer server init success")
+    while True:
+        message = socket.recv_string()
+        with lock:
+            socket.send_pyobj(response)
+```
+
+对于yolo_infer目标检测server，有一个切�摄�头�的过程，相关代�如下：
+
+```python
+def server_resp(yolo_infer_port):
+    logger.info("yolo server thread init success")
+    global response
+    global src_camera_id
+
+    context = zmq.Context()
+    socket = context.socket(zmq.REP)
+    socket.bind(f"tcp://*:{yolo_infer_port}")
+    logger.info("yolo infer server init success")
+    while not exit_event.is_set():
+        try:
+            message = socket.recv_string()
+            if message != '':
+                with lock1:
+                    logger.error(message)
+                    src_camera_id = int(message)
+                    logger.info("switch camera")
+                    socket.send_pyobj(response) 
+            else:
+                with lock2:
+                    socket.send_pyobj(response)
+                    response['data'] = np.array([])
+        except zmq.Again:
+            time.sleep(0.01)
+
+    socket.close()
+    context.term()
+
+while not exit_event.is_set():
+    with lock1:
+        try:
+            if src_camera_id == 1:
+                camera1_socket.send_string("")
+                message = camera1_socket.recv()
+            else:
+                camera2_socket.send_string("")
+                message = camera2_socket.recv()
+            np_array = np.frombuffer(message, dtype=np.uint8)
+            with lock3:
+                frame = cv2.imdecode(np_array, cv2.IMREAD_COLOR)
+                start = True
+        except:
+            time.sleep(0.01)
+```
+
+模型推�，我们使用原生 PaddleInference，以目标检测为例，官方的 PaddleDection 套件带有许多冗余代�，�低执行效率，所以我们自己实现预处�-推�等过程。
+
+```python
+import paddle.inference as paddle_infer
+import numpy as np
+import cv2
+class Yolo_model_infer:
+    def __init__(self, model_dir="./ppyoloe_plus_crn_t_auxhead_320_300e_coco", target_size=[320, 320]):
+        # �始化 paddle 推�
+        self.model_dir = model_dir
+        self.config = paddle_infer.Config(model_dir + "/model.pdmodel", model_dir + "/model.pdiparams")
+        self.config.disable_glog_info()
+        self.config.enable_use_gpu(500, 0)
+        self.config.enable_memory_optim()
+        self.config.switch_ir_optim()
+        self.config.switch_use_feed_fetch_ops(False)
+        self.predictor = paddle_infer.create_predictor(self.config)
+        self.input_names = self.predictor.get_input_names()
+        self.input_handle = self.predictor.get_input_handle(self.input_names[0])
+        self.input_handle1 = self.predictor.get_input_handle(self.input_names[1])
+        self.output_names = self.predictor.get_output_names()
+        self.output_handle = self.predictor.get_output_handle(self.output_names[0])
+
+        self.target_size = target_size
+        origin_shape = (240, 320)
+        resize_h, resize_w = self.target_size
+        self.im_scale_y = resize_h / float(origin_shape[0])
+        self.im_scale_x = resize_w / float(origin_shape[1])
+        self.scale_info = np.array([[self.im_scale_y, self.im_scale_x]]).astype('float32')
+    def infer(self,src) -> np.ndarray:
+        image = self.preprocess(src)
+        self.input_handle.copy_from_cpu(image)
+        self.input_handle1.copy_from_cpu(self.scale_info)
+        self.predictor.run()
+        results = self.output_handle.copy_to_cpu()
+        return results
+    def preprocess(self,src):
+        # resize
+        # keep_ratio=0
+        img = cv2.resize(
+            src,
+            None,
+            None,
+            fx=self.im_scale_x,
+            fy=self.im_scale_y,
+            interpolation=2)
+        # NormalizeImage
+        img = img.astype(np.float32, copy=False)
+        scale = 1.0 / 255.0
+        img *= scale
+        # Permute
+        img = img.transpose((2, 0, 1))
+        img = np.array((img, ))
+        # .astype('float32')
+        return img
+        
+```
+
 ### 赛�线回归模型概述
 
+官方采用的方案是采集摄�头第一视角+�控器数��实现深度巡线，但实际上模型很难通过图�数�学习到�控器数�的特�，并且官方采用的模型结构过于简�：�有简�的�积层�池化层，�对��的光线�件模型的泛化能力较差。我们的上�机选用Jetson Orin Nano，内存和 GPU 推�能力都很强，因此�需�过于担心模型�数太大的问题，所以应当采用模型�数更大和结构更加先进的网络，�对��的光线环境�能有较好的效果。
+
+
+
+我们设计了一个网络，输入的图片�过特���层和全连接层�输出两个值：跟踪点的横纵�标，回归出�车需�跟踪的赛�中点的 [x, y]�标。因为中点�标和图�数�有�强相关的特�，相比�控器数�，更加容易被模型学习到这个特�。并且使用 paddlepaddle，�以�常方便的使用很多性能更好的 backbone。
+
+```python
+import paddle.vision.models as models
+feature_extractor = models.resnet18(pretrained=True,num_classes=0)
+feature_extractor = models.resnet34(pretrained=True,num_classes=0)
+feature_extractor = models.mobilenet_v3_large(pretrained=True,num_classes=0)
+```
+
+我们使用性能更好的模型的特���层作为我们网络的 backbone，并且通过 paddle �以自动加载预训练�数，在训练网络时�以加快收敛。
+
+数�集的制作过程比较��，首先需�实现�控�车的功能，�时打开摄�头�存�一帧的图片。利用�存的图片和我们实现的打标软件标注赛�跟踪点。
+
+![](iShot_2024-08-26_15.18.21.png)
+
+导出的 json 格�如下所示[{"img_path": "200.jpg", "state": [126, 191]}, {"img_path": "201.jpg", "state": [128, 191]}]
+
+�过多次�试��的特���层以���的超�数，最�选择mobilenet_v3_large作为特���层，在模型�数�和模型性能上�得最平衡的效果。
+
 ### 任务主程�设计
 
 任务主程�将�个任务�装�对象，根�实际需求放入队列。程�执行时，任务对象�次出队。任务的执行按照 “�寻-执行-�处�� 的方��行，当执行�一任务时，先循环�寻任务标志，待�寻到�以进入任务的�件�，进入任务执行函数，函数内执行校准�夹��伸展等任务。执行完��，进入�处�阶段，该阶段�以设置下一任务的相关�数，并将执行机构�动到下一任务的预备�置。如果该任务�被开�，则执行一个任务�开�时�调用的函数，使执行机构�动到中立�置，��下一任务开�时�会�生冲撞。
 
-### 守护和交互程�设计
+### 交互程�设计
+
+为了满足日常调试的远程开��关闭和日志实时查看以�正�比赛时的自动�动等需求，我们基于 python flask �vue 和 element ui 开�了人机交互程�，功能包括推��务器的日志查看�开�和关闭以�任务程�的日志查看�开�和关闭等功能。
+
+推��务器和任务程�的开�和关闭通过管�进程实现，相关代�如下：
+
+```python
+elif data['type'] == 'operate_task':
+    # 任务函数
+    if data['content'] == 'run':
+        task_run_flag.set()
+        # 开� task 进程�先关闭所有历�进程
+        if task_process != None:
+            task_process.terminate()
+        time_record = time.perf_counter()
+        task_process = Process(target=main_func, args=(task_run_flag,queue))
+        task_process.start()
+        logger.info("开� task")
+    elif data['content'] == 'stop':
+        task_run_flag.clear()
+        if task_process != None:
+            task_process.terminate()
+        logger.info(f"任务结� 用时{time.perf_counter() - time_record}s")
+        logger.info("关闭  task")
+    elif data['content'] == 'restart':
+        pass
+```
+
+我们通过�定�loguru日志库，并且通过 WebSocket 实现多人�时查看的实时日志系统，��进程之间使用内存安全的共享队列传输日志信�，相关代�如下：
+
+```python
+class Handler(logging.Handler):
+    def emit(self, record):
+        log_entry = self.format(record)
+        _queue.put({'level': record.levelname.lower(), 'content': log_entry})
+logger.remove()
+handler = Handler()
+logger.add(handler, format="{time:MM-DD HH:mm:ss} {message}", level="DEBUG")
+```
+
+```python
+def thread_function():
+    global queue
+    while True:
+        try:
+            log = queue.get()
+            socketio.emit('log', log)
+        except multiprocessing.Queue.Empty:
+            pass
+```
+
+