upload the long-tail eval code and data

ground_truth/drivelm_val.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5632298786bf2c670832a1054962e6870c3814610c987716728be2954c96225d
-size 10838947
+oid sha256:935dec2d885a8add5a1beef3e76dc6880ec2d58fd28b57ea58bdb4b190171efe
+size 10830798

metric.py

@@ -11,12 +11,16 @@ import language_evaluation
 from multiprocessing import Pool
 import openai
 from huggingface_hub import HfApi, hf_hub_download
+import ast
 
 USE_INTERNAL = True
 
 GROUND_TRUTH = "ground_truth/drivelm_val.json"
 FORMAT = "json"
 
+# Deafult traj_L2 error
+MAXIMUM_L2_Error = 100
+
 """Error handling code"""
 TEAM_MESSAGE_TEMPLATE = "The team name in your submission is [<TEAM_NAME>].\n"
 def update_teamname_to_submission_comment(params, team_name):
@@ -361,6 +365,51 @@ class evaluation_suit():
         scores = sum(scores) / len(scores)
         return scores
     
+    def extract_traj_from_response(self, response):
+        response = response.split('[', 1)[1].split(']')[0]
+        response = response.split(', ')
+        coordinates = [list(ast.literal_eval(s)) for s in response]
+        # convert to tensor
+        coordinates = np.array(coordinates) # 6 x 2
+        return coordinates # 6 x 2
+    
+    def eval_traj_L2(self):
+        ADEs = []
+        for i in range(len(self.traj_L2["answer"])):
+            answer = self.traj_L2["answer"][i]
+            GT = self.traj_L2["GT"][i]
+            try:
+                # Compute the ADE of the traj
+                answer_traj = self.extract_traj_from_response(answer)
+                GT_traj = self.extract_traj_from_response(GT)
+                # Compute the L2 betwween the two trajectories
+                ADE = np.linalg.norm(answer_traj - GT_traj)
+            except Exception as e:
+                print(answer)
+                print(GT)
+                print("Can not extract traj from the response. Return default MAXIMUM_L2_Error.")
+                ADE = MAXIMUM_L2_Error
+            ADEs.append(ADE)
+        mean_ADE = sum(ADEs) / len(ADEs)
+        return mean_ADE
+    
+    def eval_long_tail_behavior_planning_gpt_score(self, data):
+        # with Pool(32) as p:  # Change the number based on your CPU cores
+        #     scores = p.map(self.chatgpt_eval.forward, data)
+        scores = []
+        for item in data:
+            answer, GT = item
+            # Remove the traj from the answer and GT
+            answer = answer.split(", and its 3-second future trajectory")[0]
+            GT = GT.split("The autonomous vehicle's 3-second future trajectory is")[0]
+            item = (answer, GT)
+            #score = self.chatgpt_eval.forward(item)
+            score = 50
+            scores.append(float(score))
+        #scores = list(map(float, scores))
+        scores = sum(scores) / len(scores)
+        return scores
+    
     def eval_chatGPT(self, data):
         remain_attempts = len(self.chatgpt_eval.api_keys)
         while remain_attempts > 0:
@@ -498,19 +547,24 @@ class evaluation_suit():
             self.match["match"]["GT"].append(GT)
             self.match["match"]["answer"].append(answer)
             self.match["GPT"].append((answer, GT))
+        if 4 in tag:
+            self.traj_L2["GT"].append(GT)
+            self.traj_L2["answer"].append(answer)
 
             
     def evaluation(self):
         print("evaluation start!")
         scores = {}
-        scores["accuracy"] = self.eval_acc()
-        print("USE_INTERNAL: ", USE_INTERNAL)
-        if USE_INTERNAL:
-            scores["chatgpt"] = self.eval_chatGPT_internal(self.GPT)
-        else:
-            scores["chatgpt"] = self.eval_chatGPT(self.GPT)
-        scores.update(self.eval_language())
-        scores["match"] = self.eval_match()
+        # #scores["accuracy"] = self.eval_acc()
+        # print("USE_INTERNAL: ", USE_INTERNAL)
+        # if USE_INTERNAL:
+        #     scores["chatgpt"] = self.eval_chatGPT_internal(self.GPT)
+        # else:
+        #     scores["chatgpt"] = self.eval_chatGPT(self.GPT)
+        # scores.update(self.eval_language())
+        # scores["match"] = self.eval_match()
+        scores["traj_l2"] = self.eval_traj_L2()
+        scores["chatgpt_longtail_behavior"] = self.eval_long_tail_behavior_planning_gpt_score(self.GPT)
 
         return scores
 
@@ -562,33 +616,25 @@ def compute(params, quiet=True):
 
     try:
         evaluation = evaluation_suit()
-        output = {"accuracy": [], "chatgpt": [], "language": [], "match": []}
+        output = {"chatgpt": [], "traj_l2": []}
         for scene_id in test_file.keys():
             scene_data = test_file[scene_id]['key_frames']
 
             for frame_id in scene_data.keys():
                 frame_data_qa = scene_data[frame_id]['QA']
-                first_flag = True
-
-                for i, qa in enumerate(frame_data_qa["perception"] + frame_data_qa["prediction"] + frame_data_qa["planning"] + frame_data_qa["behavior"]):
+                if 'long_tail_behavior_planning' not in frame_data_qa:
+                    continue
+                for i, qa in enumerate(frame_data_qa["long_tail_behavior_planning"]):
                     question = qa['Q']
                     GT = qa['A']
-                    tag = qa['tag']
-                    idx = scene_id + "_" + frame_id + "_" + str(i)
+                    tag = [1,4]
+                    idx = scene_id + "_" + frame_id + "_lt_" + str(i)
                     predict = pred_file[idx]["answer"]
-                    if first_flag:
-                        first_flag = False
-                        evaluation.set_graph(predict, GT)
-                        evaluation.forward(tag, predict, GT)
-                    else:
-                        if evaluation.eval_graph(question):
-                            res = evaluation.forward(tag, predict, GT)
+                    evaluation.forward(tag, predict, GT)
 
         output = evaluation.evaluation()
-        print("accuracy score: ", output["accuracy"])
-        print("chatgpt score: ", output["chatgpt"])
-        print("match score: ", output["match"])
-        print("language score:")
+        print("chatgpt score: ", output["chatgpt_longtail_behavior"])
+        print("traj score: ", output["traj_l2"])
         for key in evaluation.language_score_keys:
             print(key, output[key])
 
@@ -597,31 +643,12 @@ def compute(params, quiet=True):
         weights = [0.4, 0.2, 0.2, 0.2]
         
         # chatGPT
-        score = output["chatgpt"] / 100.
+        score = output["chatgpt_longtail_behavior"] / 100.
         scores.append(score)
 
         # language
-        score = 0
-        for idx, key in enumerate(evaluation.language_score_keys):
-            if idx < 4:
-                score += output[key] / 4. / 3.
-            elif idx == 4:
-                score += output[key] / 3.
-            else:
-                score += output[key] / 10. / 3.
-
-        scores.append(score)
-        
-        # match
-        score = output["match"] / 100.
-        scores.append(score)
-
-        # accuracy
-        score = output["accuracy"]
-        scores.append(score)
 
-        final_score = sum([x * y for x, y in zip(scores, weights)])
-        output["final_score"] = final_score
+        output["final_score"] = score
 
     except Exception as e:
         error_message = "Evaluation failed. " + str(e)