feat: switch to 4 features on 2nd model

core-model-prediction/prediction.py

@@ -56,8 +56,8 @@ def process_instance(data: PredictRequest):
     # Data preparation for 2nd model
     secondary_model_dependencies = SecondaryModelDependencies()
     secondary_model_features = secondary_model_dependencies.calculate_features(
-        answer, main_model_probability, backspace_count, typing_duration,
-        letter_click_counts, gpt35_answer, gpt4o_answer)
+        answer, main_model_probability, backspace_count,
+        letter_click_counts, gpt4o_answer)
 
     # 2nd model prediction
     secondary_model = SecondaryModel()
@@ -67,13 +67,13 @@ def process_instance(data: PredictRequest):
     return {
         "predicted_class": "AI" if secondary_model_probability > 0.57 else "HUMAN",
         "main_model_probability": str(main_model_probability),
-        "secondary_model_probability": secondary_model_probability,
+        "secondary_model_probability": str(secondary_model_probability),
         "confidence": get_confidence(main_model_probability, secondary_model_probability)
     }
 
 
 def get_confidence(main_model_output: float, secondary_model_output: int):
-    threshold = 0.57
+    threshold = 0.54
     if (main_model_output >= 0.8 and secondary_model_output >= threshold) or (main_model_output <= 0.2 and secondary_model_output <= 1 - threshold):
         return 'High Confidence'
     elif (0.5 < main_model_output < 0.8 and secondary_model_output >= threshold) or (0.2 < main_model_output <= 0.5 and secondary_model_output < threshold):

core-model-prediction/secondary_model.py

@@ -9,8 +9,8 @@ class SecondaryModel:
         self.scaler = joblib.load("scalers/secondary_scaler.joblib")
         self.model = joblib.load("models/secondary_weights.joblib")
         self.secondary_model_features = [
-            "machine_probability", "backspace_count_normalized", "typing_duration_normalized",
-            "letter_discrepancy_normalized", "cosine_sim_gpt35", "cosine_sim_gpt4o"
+            "machine_probability", "backspace_count_normalized",
+            "letter_discrepancy_normalized", "cosine_sim_gpt4o"
         ]
 
     def preprocess_input(self, secondary_model_features: List[float]) -> pd.DataFrame:

core-model-prediction/secondary_model_dependencies.py

@@ -7,21 +7,16 @@ class SecondaryModelDependencies:
         self.text_similarity_model = SentenceTransformer(
             'sentence-transformers/all-mpnet-base-v2')
 
-    def calculate_features(self, answer: str, probability: float, backspace_count: int, typing_duration: int,
-                           letter_click_counts: dict[str, int], gpt35_answer: str, gpt4o_answer: str):
+    def calculate_features(self, answer: str, probability: float, backspace_count: int,
+                           letter_click_counts: dict[str, int], gpt4o_answer: str):
         backspace_count_normalized = backspace_count / len(answer)
-        typing_duration_normalized = typing_duration / len(answer)
         letter_discrepancy = self.calculate_letter_discrepancy(
             answer, letter_click_counts)
-
-        cosine_sim_gpt35 = self.calculate_similarity_gpt35(
-            answer, gpt35_answer)
         cosine_sim_gpt4o = self.calculate_similarity_gpt4o(
             answer, gpt4o_answer)
 
         return [
-            probability, backspace_count_normalized, typing_duration_normalized,
-            letter_discrepancy, cosine_sim_gpt35, cosine_sim_gpt4o
+            probability, backspace_count_normalized, letter_discrepancy, cosine_sim_gpt4o
         ]
 
     def calculate_letter_discrepancy(self, text: str, letter_click_counts: dict[str, int]):
@@ -39,14 +34,6 @@ class SecondaryModelDependencies:
 
         return discrepancy_ratio_normalized
 
-    def calculate_similarity_gpt35(self, answer: str, gpt35_answer: str) -> float:
-        embedding1 = self.text_similarity_model.encode(
-            [answer], convert_to_tensor=True)
-        embedding2 = self.text_similarity_model.encode(
-            [gpt35_answer], convert_to_tensor=True)
-        cosine_scores = util.cos_sim(embedding1, embedding2)
-        return cosine_scores.item()
-
     def calculate_similarity_gpt4o(self, answer: str, gpt4o_answer: str) -> float:
         embedding1 = self.text_similarity_model.encode(
             [answer], convert_to_tensor=True)