update

Author: Likecolor

__init__.py

@@ -25,18 +25,17 @@ def default(self, obj):
 
 class Cal_Metrics:
     def __init__(self, config):
-        self.config = config
-        self.source = config.source
-        self.client_conifg = config.client
+        self.config = config.client
+        self.source = config.client.source
+        self.database_config = config.client.database
         self.inference_config = config.server
-        self.database_config = config.database
         self.large_object_detection = Object_Detection(self.inference_config, type='large inference')
 
     def cal_ground_truth(self):
         with VideoProcessor(self.source) as video:
             truth_dict = {}
             video_fps = video.fps
-            interval = self.client_conifg.interval
+            interval = self.config.interval
             logger.info("the video fps is {}".format(video_fps))
             if interval == 0:
                 logger.error("the interval error")
@@ -60,33 +59,38 @@ def cal_ground_truth(self):
 
 
     def cal_mAP(self):
-        interval = self.client_conifg.interval
+        interval = self.config.interval
         with open('truth.json', 'r') as f:
             ground_truths = json.load(f)
         # calculates the mAP for an IOU threshold of 0.5
         database = DataBase(self.database_config)
         database.use_database()
-        result = database.select_result(self.client_conifg.edge_id)
-        total_frame = self.config.max_count / interval
+        result = database.select_result(self.config.edge_id)
+        total_frame = self.source.max_count / interval
         sum_map = 0.0
         sum_delay = 0.0
         filtered_out = 0
         i = 0
         last_result = None
+        logger.debug(len(result))
         while i < len(result):
             index, start_time, end_time, res, log = result[i]
             gap = end_time-start_time
             sum_delay += gap
             result_dict = eval(res)
-            if 'ref' in result_dict.keys:
-                filtered_out += 1
-                res = result[result_dict['ref']][3]
-                pred = eval(res)
-            else:
+            logger.debug(result_dict.keys())
+            if 'lables' in result_dict.keys():
                 pred = eval(res)
                 last_result = pred
+            elif 'ref' in result_dict.keys():
+                filtered_out += 1
+                pred = last_result
+            else:
+                pred = last_result
+            logger.debug(pred)
             ground_truth = ground_truths['{}'.format(index)]
-            map = calculate_map(ground_truth, pred)
+            logger.debug(ground_truth)
+            map = calculate_map(ground_truth, pred, 0.5)
             sum_map += map
 
 
@@ -99,14 +103,11 @@ def cal_mAP(self):
         config = yaml.load(f, Loader=yaml.SafeLoader)
     # provide class-like access for dict
     config = munch.munchify(config)
-    cal_truth = True
+    cal_truth = False
     cal = Cal_Metrics(config)
-    #cal.cal_ground_truth()
-    cal.cal_detection_result()
-    """
     if cal_truth:
         cal.cal_ground_truth()
     cal.cal_mAP()
-    """
+
 
 

cal_metrics.py

@@ -41,6 +41,12 @@ def __init__(self, config):
     def cloud_local(self):
         while True:
             task = self.local_queue.get(block=True)
+            if time.time() - task.start_time >= self.config.wait_thresh:
+                end_time = time.time()
+                task.end_time = end_time
+                task.state = TASK_STATE.TIMEOUT
+                self.update_table(task)
+                continue
             task.frame_cloud = task.frame_edge
             frame = task.frame_cloud
             high_boxes, high_class, high_score = self.large_object_detection.large_inference(frame)
@@ -57,10 +63,15 @@ def cloud_local(self):
 
 
     def update_table(self, task):
+        if task.state == TASK_STATE.FINISHED:
+            state = "Finished"
+        elif task.state == TASK_STATE.TIMEOUT:
+            state = "Timeout"
+        else:
+            state = ""
         detection_boxes, detection_class, detection_score = task.get_result()
-        state = "Finished" if task.state == TASK_STATE.FINISHED else ""
         result = {
-            'lables': detection_class,
+            'labels': detection_class,
             'boxes': detection_boxes,
             'scores': detection_score
         }

cloud_server.py

@@ -2,61 +2,65 @@ client:
  # the source video
  source:
   video_path: ./video_data/dayroad.mp4
-  max_count: 120
+  max_count: 5
   rtsp:
    flag: False
    account: your account
    password: your password
    ip_address: you camera ip
    channel: 1
- #the frame interval
+ # the frame interval
  interval: 2
- #the difference feature (pixel, edge, area, corner).
+ # the difference feature (pixel, edge, area, corner).
  feature: edge
- #the difference flag and thresh
+ # the difference flag and thresh
  diff_flag: True
  diff_thresh: 0.01
- #the queue maxsize
+ # the queue maxsize
  local_queue_maxsize: 10
- #the queue threshold for offloading
+ # the queue threshold for offloading
  queue_thresh: 5
- #Number of worker threads to offloading thread pool
+ # the max wait time
+ wait_thresh: 10
+ # Number of worker threads to offloading thread pool
  offloading_max_worker: 1
  frame_cache_maxsize: 100
  small_model_name: fasterrcnn_mobilenet_v3_large_fpn
- #select the offloading policy
- policy: Edge-Local
- #change frame resolution using frame new height
+ # select the offloading policy
+ policy: Edge-Shortest
+ # change frame resolution using frame new height
  new_height:
-  #offload to another edge node [1080, 720], default 720
+  # offload to another edge node [1080, 720], default 720
   another: 720
-  #option to offload directly to the cloud [1080, 720, 480], default 480
+  # option to offload directly to the cloud [1080, 720, 480], default 480
   directly_cloud: 720
-  #offload to the cloud after local inference [1080, 720, 480], default 720
+  # offload to the cloud after local inference [1080, 720, 480], default 720
   local_cloud: 720
-  #The task from another edge node is offloaded to the cloud after local inference [720, 480], default 720
+  # The task from another edge node is offloaded to the cloud after local inference [720, 480], default 720
   another_cloud: 720
- #the quality of the transmitted frame
+ # the quality of the transmitted frame
  quality:
-  #offload to another edge node [90, 85], default 85
+  # offload to another edge node [90, 85], default 85
   another: 90
-  #Option to offload directly to the cloud [85, 95], default 85
+  # Option to offload directly to the cloud [85, 95], default 85
   directly_cloud: 90
-  #offload to the cloud after local inference [85, 95], default 95
+  # offload to the cloud after local inference [85, 95], default 95
   local_cloud: 90
-  #The task from another edge node is offloaded to the cloud after local inference, default 85.
+  # The task from another edge node is offloaded to the cloud after local inference, default 85.
   another_cloud: 90
- #server_ip
- server_ip: '43.137.51.180:50051'
- #edge nodes
+ # server_ip
+ server_ip: '127.0.0.1:50051'
+ # edge nodes
  edge_id: 1
- destinations: {'id': [2], 'ip':['127.0.0.1:50050']}
- #database config
+ edge_num: 2
+ destinations: {'id': [2], 'ip':['192.168.0.185:50050']}
+ # database config
  database:
-  connection: { 'user': 'root', 'password': 'root', 'host': '43.137.51.180', 'raise_on_warnings': True }
+  connection: { 'user': 'root', 'password': 'root', 'host': '127.0.0.1', 'raise_on_warnings': True }
   database_name: 'mydatabase'
  # retrain
  retrain:
+  flag: False
   num_epoch: 2
   cache_path: './cache'
   collect_num: 10
@@ -65,11 +69,12 @@ client:
 
 server:
  server_id: 0
- edge_ids: [1]
+ edge_ids: [1,2]
  large_model_name: fasterrcnn_resnet50_fpn
  #the queue maxsize
  local_queue_maxsize: 10
- data_queue_maxsize: 10
+ # the max wait time
+ wait_thresh: 10
  #database config
  database:
   connection: { 'user': 'root', 'password': 'root', 'host': '127.0.0.1', 'raise_on_warnings': True }