merge tested changes for math word cloud

handler.py

@@ -40,7 +40,7 @@ class Utterance:
             self.unit_measure = endtime - starttime
         else:
             self.unit_measure = None
-        self.aggregate_unit_measure = endtime
+        self.aggregate_unit_measure = endtime  
         self.num_math_terms = None
         self.math_terms = None
 
@@ -151,7 +151,7 @@ class Transcript:
         avg_student_length = student_words / student_utt_count if student_utt_count > 0 else 0
         return {'teacher': teacher_percentage, 'student': student_percentage}, {'teacher': avg_teacher_length, 'student': avg_student_length}
 
-    def get_word_cloud_dicts(self):
+    def get_word_clouds(self):
         teacher_dict = {}
         student_dict = {}
         uptake_teacher_dict = {}
@@ -232,7 +232,7 @@ class QuestionModel:
                                                                max_length=self.max_length,
                                                                input_str=True)
                     output = self.get_prediction(instance)
-                    print(output)
+                    # print(output)
                     utt.question = np.argmax(
                         output["is_question_logits"][0].tolist())
 
@@ -377,6 +377,7 @@ def load_math_terms():
 def run_math_density(transcript):
     math_terms, math_terms_dict = load_math_terms()
     sorted_terms = sorted(math_terms, key=len, reverse=True)
+    math_word_cloud = {}
     for i, utt in enumerate(transcript.utterances):
         text = utt.get_clean_text(remove_punct=False)
         num_matches = 0
@@ -387,12 +388,21 @@ def run_math_density(transcript):
             # Filter out matches that share positions with longer terms
             matches = [match for match in matches if not any(match.start() in range(existing[0], existing[1]) for existing in matched_positions)]
             if len(matches) > 0:
+                if math_terms_dict[term] not in math_word_cloud:
+                    math_word_cloud[math_terms_dict[term]] = 0
+                math_word_cloud[math_terms_dict[term]] += len(matches)
                 match_list.append(math_terms_dict[term])
             # Update matched positions
             matched_positions.update((match.start(), match.end()) for match in matches)
             num_matches += len(matches)
         utt.num_math_terms = num_matches
         utt.math_terms = match_list
+    dict_list = []
+    for word in math_word_cloud.keys():
+        dict_list.append(
+            {'text': word, 'value': math_word_cloud[word]})
+    sorted_dict_list = sorted(dict_list, key=lambda x: x['value'], reverse=True)
+    return sorted_dict_list[:50]
 
 class EndpointHandler():
     def __init__(self, path="."):
@@ -427,34 +437,38 @@ class EndpointHandler():
         uptake_speaker = params.pop("uptake_speaker", None)
         uptake_model.run_inference(transcript, min_prev_words=params['uptake_min_num_words'],
                                    uptake_speaker=uptake_speaker)
+        del uptake_model
+        
         # Reasoning
         reasoning_model = ReasoningModel(
             self.device, self.tokenizer, self.input_builder)
         reasoning_model.run_inference(transcript, uptake_speaker=uptake_speaker)
-
+        del reasoning_model
+        
         # Question
         question_model = QuestionModel(
             self.device, self.tokenizer, self.input_builder)
         question_model.run_inference(transcript)
-
+        del question_model
+        
         # Focusing Question
         focusing_question_model = FocusingQuestionModel(
             self.device, self.tokenizer, self.input_builder)
         focusing_question_model.run_inference(transcript, uptake_speaker=uptake_speaker)
-
-        run_math_density(transcript)
-
+        del focusing_question_model
+        
+        math_cloud = run_math_density(transcript)
         transcript.update_utterance_roles(uptake_speaker)
         transcript.calculate_aggregate_word_count()
-        return_dict = {'talkDistribution': None, 'talkLength': None, 'talkMoments': None, 'commonTopWords': None, 'uptakeTopWords': None}
+        return_dict = {'talkDistribution': None, 'talkLength': None, 'talkMoments': None, 'commonTopWords': None, 'uptakeTopWords': None, 'mathTopWords': None}
         talk_dist, talk_len = transcript.get_talk_distribution_and_length(uptake_speaker)
         return_dict['talkDistribution'] = talk_dist
         return_dict['talkLength'] = talk_len
         talk_moments = transcript.get_talk_timeline()
         return_dict['talkMoments'] = talk_moments
-        word_cloud, uptake_word_cloud = transcript.get_word_cloud_dicts()
+        word_cloud, uptake_word_cloud = transcript.get_word_clouds()
         return_dict['commonTopWords'] = word_cloud
         return_dict['uptakeTopWords'] = uptake_word_cloud
-
+        return_dict['mathTopWords'] = math_cloud
 
         return return_dict