moved gram2vec cache files to its won folders ; reduced logging ; commented out unused code

utils/interp_space_utils.py

@@ -25,9 +25,11 @@ from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances
 from sklearn.decomposition import PCA
 
 CACHE_DIR = "datasets/embeddings_cache"
+G2V_CACHE = "datasets/gram2vec_cache"
 ZOOM_CACHE = "datasets/zoom_cache/features_cache.json"
 REGION_CACHE = "datasets/region_cache/regions_cache.pkl"
 os.makedirs(CACHE_DIR, exist_ok=True)
+os.makedirs(G2V_CACHE, exist_ok=True)
 os.makedirs(os.path.dirname(ZOOM_CACHE), exist_ok=True)
 os.makedirs(os.path.dirname(REGION_CACHE), exist_ok=True)
 # Bump this whenever there is a change etc...
@@ -54,8 +56,8 @@ def compute_g2v_features(clustered_authors_df: pd.DataFrame, task_authors_df: pd
         print (f"concatenating task authors and background corpus authors")
         print(f"Number of task authors: {len(task_authors_df)}")
         print(f"task authors author_ids: {task_authors_df.authorID.tolist()}")
-        print(f"task authors -->")
-        print(task_authors_df)
+        # print(f"task authors -->")
+        # print(task_authors_df)
         print(f"Number of background corpus authors: {len(clustered_authors_df)}")
         clustered_authors_df = pd.concat([task_authors_df, clustered_authors_df])
         print(f"Number of authors after concatenation: {len(clustered_authors_df)}")
@@ -63,10 +65,12 @@ def compute_g2v_features(clustered_authors_df: pd.DataFrame, task_authors_df: pd
     # Gather the input texts (preserves list-of-strings if any)
     #texts = background_corpus_df[text_clm].fillna("").tolist()
     author_texts = ['\n\n'.join(x) for x in clustered_authors_df.fullText.tolist()]
-    print('author_text at 0:{}'.format(author_texts[0]))
+    # print('author_text at 0:{}'.format(author_texts[0]))
     print(f"Number of author_texts: {len(author_texts)}")
 
     # Create a reproducible JSON serialization of the texts
+    # why are g2v features going into a new file inside embeddings_cache?
+    # changed to G2V_CACHE
     serialized = json.dumps({
         "col": text_clm,
         "texts": author_texts
@@ -74,15 +78,20 @@ def compute_g2v_features(clustered_authors_df: pd.DataFrame, task_authors_df: pd
 
     # Compute MD5 hash
     digest = hashlib.md5(serialized.encode("utf-8")).hexdigest()
-    cache_path = os.path.join(CACHE_DIR, f"{digest}.pkl")
+    cache_path = os.path.join(G2V_CACHE, f"{digest}.pkl")
 
     # If cache hit, load and return
     if os.path.exists(cache_path):
-        print(f"Cache hit...")
+        # print(f"Cache hit...")
+        # Making this green to make it stand out from rest of the logs
+        print(f"\n\n\n\033[1m\033[92m>>> Cache hit for {cache_path} <<<\033[0m\n")
         with open(cache_path, "rb") as f:
             clustered_authors_df = pickle.load(f)
     
     else: # Else compute and cache
+        # Making this red to make it stand out from rest of the logs
+        print(f"\n\n\n\033[1m\033[91m>>> Cache miss for {cache_path} => Computing fresh!! <<<\033[0m\n")
+
         g2v_feats_df = vectorizer.from_documents(author_texts, batch_size=8)
 
         print(f"Number of g2v features: {len(g2v_feats_df)}")
@@ -116,6 +125,9 @@ def compute_g2v_features(clustered_authors_df: pd.DataFrame, task_authors_df: pd
         
         with open(cache_path, "wb") as f:
             pickle.dump(clustered_authors_df, f)
+            # Making this green to make it stand out from rest of the logs
+            print(f"\n\n\n\033[1m\033[92m>>> Saved to {cache_path} <<<\033[0m\n")
+            # the file generated here contains g2v + style embeddings. 
     
     if task_authors_df is not None:
         task_authors_df = clustered_authors_df[clustered_authors_df.authorID.isin(task_authors_df.authorID.tolist())]
@@ -266,14 +278,14 @@ def cached_generate_style_embedding(background_corpus_df: pd.DataFrame,
 
     # If cache hit, load and return
     if os.path.exists(cache_path):
-        print(f"Cache hit for {model_name} on column '{text_clm}'")
-        print(cache_path)
+        # Making this green to make it stand out from rest of the logs
+        print(f"\n\n\n\033[1m\033[92m>>> Cache hit for {cache_path} for {model_name} on column '{text_clm} <<<\033[0m\n")
         with open(cache_path, "rb") as f:
             background_corpus_df = pickle.load(f)
 
     else:
         # Otherwise, compute, cache, and return
-        print(f"Computing embeddings for {model_name} on column '{text_clm}', saving to {cache_path}")
+        print(f"\n\n\n\033[1m\033[91m>>> Cache miss for {cache_path} for {model_name} on column '{text_clm} <<<\033[0m\n")
         task_and_background_embeddings = generate_style_embedding(background_corpus_df, text_clm, model_name, dimensionality_reduction=False)
         # Create a clean column name from the model name
         col_name = f'{model_name.split("/")[-1]}_style_embedding'
@@ -281,6 +293,7 @@ def cached_generate_style_embedding(background_corpus_df: pd.DataFrame,
 
         with open(cache_path, "wb") as f:
             pickle.dump(background_corpus_df, f)
+            print(f"\n\n\n\033[1m\033[92m>>> Cache saved for {cache_path} for {model_name} on column '{text_clm} <<<\033[0m\n")
     
     if task_authors_df is not None:
         task_authors_df = background_corpus_df[background_corpus_df.authorID.isin(task_authors_df.authorID.tolist())]
@@ -288,163 +301,167 @@ def cached_generate_style_embedding(background_corpus_df: pd.DataFrame,
 
     return background_corpus_df, task_authors_df
 
-def get_style_feats_distribution(documentIDs, style_feats_dict):
-    style_feats = []
-    for documentId in documentIDs:
-        if documentId not in document_to_style_feats:
-            #print(documentId)
-            continue
-
-        style_feats+= document_to_style_feats[documentId]
-
-    tfidf = [style_feats.count(key) * val for key, val in style_feats_dict.items()]
-
-    return tfidf
-
-def get_cluster_top_feats(style_feats_distribution, style_feats_list, top_k=5):
-    sorted_feats = np.argsort(style_feats_distribution)[::-1]
-    top_feats = [style_feats_list[x] for x in sorted_feats[:top_k] if style_feats_distribution[x] > 0]
-    return top_feats
-
-def compute_clusters_style_representation(
-    background_corpus_df: pd.DataFrame,
-    cluster_ids: List[Any],
-    other_cluster_ids: List[Any],
-    features_clm_name: str,
-    cluster_label_clm_name: str = 'cluster_label',
-    top_n: int = 10
-) -> List[str]:
-    """
-    Given a DataFrame with document IDs, cluster IDs, and feature lists,
-    return the top N features that are most important in the specified `cluster_ids`
-    while having low importance in `other_cluster_ids`.
-    Importance is determined by TF-IDF scores. The final score for a feature is
-    (summed TF-IDF in `cluster_ids`) - (summed TF-IDF in `other_cluster_ids`).
-
-    Parameters:
-    - background_corpus_df: pd.DataFrame. Must contain the columns specified by
-                            `cluster_label_clm_name` and `features_clm_name`.
-                            The column `features_clm_name` should contain lists of strings (features).
-    - cluster_ids: List of cluster IDs for which to find representative features (target clusters).
-    - other_cluster_ids: List of cluster IDs whose features should be down-weighted.
-                         Features prominent in these clusters will have their scores reduced.
-                         Pass an empty list or None if no contrastive clusters are needed.
-    - features_clm_name: The name of the column in `background_corpus_df` that
-                         contains the list of features for each document.
-    - cluster_label_clm_name: The name of the column in `background_corpus_df`
-                              that contains the cluster labels. Defaults to 'cluster_label'.
-    - top_n: Number of top features to return.
-    Returns:
-    - List[str]: A list of feature names. These are up to `top_n` features
-                 ranked by their adjusted TF-IDF scores (score in `cluster_ids`
-                 minus score in `other_cluster_ids`). Only features with a final
-                 adjusted score > 0 are included.
-    """
-
-    assert background_corpus_df[features_clm_name].apply(
-        lambda x: isinstance(x, list) and all(isinstance(feat, str) for feat in x)
-    ).all(), f"Column '{features_clm_name}' must contain lists of strings."
-
-    # Compute TF-IDF on the entire corpus
-    vectorizer = TfidfVectorizer(
-        tokenizer=lambda x: x,
-        preprocessor=lambda x: x,
-        token_pattern=None  # Disable default token pattern, treat items in list as tokens
-    )
-    tfidf_matrix = vectorizer.fit_transform(background_corpus_df[features_clm_name])
-    feature_names = vectorizer.get_feature_names_out()
-
-    # Get boolean mask for documents in selected clusters
-    selected_mask = background_corpus_df[cluster_label_clm_name].isin(cluster_ids).to_numpy()
-
-    if not selected_mask.any():
-        return [] # No documents found for the given cluster_ids
-
-    # Subset the TF-IDF matrix using the boolean mask
-    selected_tfidf = tfidf_matrix[selected_mask]
-
-    # Sum TF-IDF scores across documents for each feature in the target clusters
-    target_feature_scores_sum = selected_tfidf.sum(axis=0).A1  # Convert to 1D array
-
-    # Initialize adjusted scores with target scores
-    adjusted_feature_scores = target_feature_scores_sum.copy()
-
-    # If other_cluster_ids are provided and not empty, subtract their TF-IDF sums
-    if other_cluster_ids: # Checks if the list is not None and not empty
-        other_selected_mask = background_corpus_df[cluster_label_clm_name].isin(other_cluster_ids).to_numpy()
-
-        if other_selected_mask.any():
-            other_selected_tfidf = tfidf_matrix[other_selected_mask]
-            contrast_feature_scores_sum = other_selected_tfidf.sum(axis=0).A1
+# Noticed the following function isnt actually referenced anywhere.
+# def get_style_feats_distribution(documentIDs, style_feats_dict):
+#     style_feats = []
+#     for documentId in documentIDs:
+#         if documentId not in document_to_style_feats:
+#             #print(documentId)
+#             continue
+
+#         style_feats+= document_to_style_feats[documentId]
+
+#     tfidf = [style_feats.count(key) * val for key, val in style_feats_dict.items()]
+
+#     return tfidf
+# 
+# Noticed the following function isnt actually referenced anywhere.
+# def get_cluster_top_feats(style_feats_distribution, style_feats_list, top_k=5):
+#     sorted_feats = np.argsort(style_feats_distribution)[::-1]
+#     top_feats = [style_feats_list[x] for x in sorted_feats[:top_k] if style_feats_distribution[x] > 0]
+#     return top_feats
+
+# Noticed the following function isnt actually referenced anywhere.
+# def compute_clusters_style_representation(
+#     background_corpus_df: pd.DataFrame,
+#     cluster_ids: List[Any],
+#     other_cluster_ids: List[Any],
+#     features_clm_name: str,
+#     cluster_label_clm_name: str = 'cluster_label',
+#     top_n: int = 10
+# ) -> List[str]:
+#     """
+#     Given a DataFrame with document IDs, cluster IDs, and feature lists,
+#     return the top N features that are most important in the specified `cluster_ids`
+#     while having low importance in `other_cluster_ids`.
+#     Importance is determined by TF-IDF scores. The final score for a feature is
+#     (summed TF-IDF in `cluster_ids`) - (summed TF-IDF in `other_cluster_ids`).
+
+#     Parameters:
+#     - background_corpus_df: pd.DataFrame. Must contain the columns specified by
+#                             `cluster_label_clm_name` and `features_clm_name`.
+#                             The column `features_clm_name` should contain lists of strings (features).
+#     - cluster_ids: List of cluster IDs for which to find representative features (target clusters).
+#     - other_cluster_ids: List of cluster IDs whose features should be down-weighted.
+#                          Features prominent in these clusters will have their scores reduced.
+#                          Pass an empty list or None if no contrastive clusters are needed.
+#     - features_clm_name: The name of the column in `background_corpus_df` that
+#                          contains the list of features for each document.
+#     - cluster_label_clm_name: The name of the column in `background_corpus_df`
+#                               that contains the cluster labels. Defaults to 'cluster_label'.
+#     - top_n: Number of top features to return.
+#     Returns:
+#     - List[str]: A list of feature names. These are up to `top_n` features
+#                  ranked by their adjusted TF-IDF scores (score in `cluster_ids`
+#                  minus score in `other_cluster_ids`). Only features with a final
+#                  adjusted score > 0 are included.
+#     """
+
+#     assert background_corpus_df[features_clm_name].apply(
+#         lambda x: isinstance(x, list) and all(isinstance(feat, str) for feat in x)
+#     ).all(), f"Column '{features_clm_name}' must contain lists of strings."
+
+#     # Compute TF-IDF on the entire corpus
+#     vectorizer = TfidfVectorizer(
+#         tokenizer=lambda x: x,
+#         preprocessor=lambda x: x,
+#         token_pattern=None  # Disable default token pattern, treat items in list as tokens
+#     )
+#     tfidf_matrix = vectorizer.fit_transform(background_corpus_df[features_clm_name])
+#     feature_names = vectorizer.get_feature_names_out()
+
+#     # Get boolean mask for documents in selected clusters
+#     selected_mask = background_corpus_df[cluster_label_clm_name].isin(cluster_ids).to_numpy()
+
+#     if not selected_mask.any():
+#         return [] # No documents found for the given cluster_ids
+
+#     # Subset the TF-IDF matrix using the boolean mask
+#     selected_tfidf = tfidf_matrix[selected_mask]
+
+#     # Sum TF-IDF scores across documents for each feature in the target clusters
+#     target_feature_scores_sum = selected_tfidf.sum(axis=0).A1  # Convert to 1D array
+
+#     # Initialize adjusted scores with target scores
+#     adjusted_feature_scores = target_feature_scores_sum.copy()
+
+#     # If other_cluster_ids are provided and not empty, subtract their TF-IDF sums
+#     if other_cluster_ids: # Checks if the list is not None and not empty
+#         other_selected_mask = background_corpus_df[cluster_label_clm_name].isin(other_cluster_ids).to_numpy()
+
+#         if other_selected_mask.any():
+#             other_selected_tfidf = tfidf_matrix[other_selected_mask]
+#             contrast_feature_scores_sum = other_selected_tfidf.sum(axis=0).A1
             
-            # Element-wise subtraction; assumes feature_names aligns for both sums
-            adjusted_feature_scores -= contrast_feature_scores_sum
-
-    # Map scores to feature names
-    feature_score_dict = dict(zip(feature_names, adjusted_feature_scores))
-    # Sort features by score
-    sorted_features = sorted(feature_score_dict.items(), key=lambda item: item[1], reverse=True)
-
-    # Return the names of the top_n features that have a score > 0
-    top_features = [feature for feature, score in sorted_features if score > 0][:top_n]
-
-    return top_features
-
-def compute_clusters_style_representation_2(
-        background_corpus_df: pd.DataFrame,
-        cluster_ids: List[Any],
-        cluster_label_clm_name: str = 'cluster_label',
-        max_num_feats: int = 5,
-        max_num_documents_per_author=3,
-        max_num_authors=5):
-    """
-    Call openAI to analyze the common writing style features of the given list of texts
-    """
-    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-    background_corpus_df['fullText'] = background_corpus_df['fullText'].map(lambda x: '\n\n'.join(x[:max_num_documents_per_author]) if isinstance(x, list) else x)
-    background_corpus_df = background_corpus_df[background_corpus_df[cluster_label_clm_name].isin(cluster_ids)]
-    
-    author_texts = background_corpus_df['fullText'].tolist()[:max_num_authors]
-    author_texts = "\n\n".join(["""Author {}:\n""".format(i+1) + text for i, text in enumerate(author_texts)])
-    author_names = background_corpus_df[cluster_label_clm_name].tolist()[:max_num_authors]
-    print(f"Number of authors: {len(background_corpus_df)}")
-    print(author_names)
-    print(author_texts)
-    print(f"Number of authors: {len(author_names)}")
-    print(f"Number of authors: {len(author_texts)}")
-    
-    prompt = f"""First identify a list of {max_num_feats} writing style features that are common between the given texts. Second for every author text and style feature, extract all spans that represent the feature. Output for every author all style features with their spans.
-    Author Texts:
-    \"\"\"{author_texts}\"\"\"
-    """
-
-    # Compute MD5 hash
-    digest = hashlib.md5(prompt.encode("utf-8")).hexdigest()
-    cache_path = os.path.join(CACHE_DIR, f"{digest}.pkl")
-
-    # If cache hit, load and return
-    if os.path.exists(cache_path):
-        print(f"Loading authors writing style from cache ...")
-        with open(cache_path, "rb") as f:
-            parsed_response = pickle.load(f)
-    
-    else: # Else compute and cache
-
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {"role":"assistant","content":"You are a forensic linguistic who knows how to analyze similarites in writing styles."},
-                {"role":"user","content":prompt}],
-            response_format={"type": "json_schema", "json_schema": {"name": "style_analysis_schema", "schema":  to_strict_json_schema(style_analysis_schema)}}
-        )
-
-        parsed_response = json.loads(response.choices[0].message.content)
-
-        with open(cache_path, "wb") as f:
-            pickle.dump(parsed_response, f)
-
-    return parsed_response 
+#             # Element-wise subtraction; assumes feature_names aligns for both sums
+#             adjusted_feature_scores -= contrast_feature_scores_sum
+
+#     # Map scores to feature names
+#     feature_score_dict = dict(zip(feature_names, adjusted_feature_scores))
+#     # Sort features by score
+#     sorted_features = sorted(feature_score_dict.items(), key=lambda item: item[1], reverse=True)
+
+#     # Return the names of the top_n features that have a score > 0
+#     top_features = [feature for feature, score in sorted_features if score > 0][:top_n]
+
+#     return top_features
+
+# Noticed the following function isnt actually referenced anywhere.
+# def compute_clusters_style_representation_2(
+#         background_corpus_df: pd.DataFrame,
+#         cluster_ids: List[Any],
+#         cluster_label_clm_name: str = 'cluster_label',
+#         max_num_feats: int = 5,
+#         max_num_documents_per_author=3,
+#         max_num_authors=5):
+#     """
+#     Call openAI to analyze the common writing style features of the given list of texts
+#     """
+#     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+#     background_corpus_df['fullText'] = background_corpus_df['fullText'].map(lambda x: '\n\n'.join(x[:max_num_documents_per_author]) if isinstance(x, list) else x)
+#     background_corpus_df = background_corpus_df[background_corpus_df[cluster_label_clm_name].isin(cluster_ids)]
+    
+#     author_texts = background_corpus_df['fullText'].tolist()[:max_num_authors]
+#     author_texts = "\n\n".join(["""Author {}:\n""".format(i+1) + text for i, text in enumerate(author_texts)])
+#     author_names = background_corpus_df[cluster_label_clm_name].tolist()[:max_num_authors]
+#     print(f"Number of authors: {len(background_corpus_df)}")
+#     print(author_names)
+#     print(author_texts)
+#     print(f"Number of authors: {len(author_names)}")
+#     print(f"Number of authors: {len(author_texts)}")
+    
+#     prompt = f"""First identify a list of {max_num_feats} writing style features that are common between the given texts. Second for every author text and style feature, extract all spans that represent the feature. Output for every author all style features with their spans.
+#     Author Texts:
+#     \"\"\"{author_texts}\"\"\"
+#     """
+
+#     # Compute MD5 hash
+#     digest = hashlib.md5(prompt.encode("utf-8")).hexdigest()
+#     cache_path = os.path.join(CACHE_DIR, f"{digest}.pkl")
+
+#     # If cache hit, load and return
+#     if os.path.exists(cache_path):
+#         print(f"Loading authors writing style from cache ...")
+#         with open(cache_path, "rb") as f:
+#             parsed_response = pickle.load(f)
+    
+#     else: # Else compute and cache
+
+#         response = client.chat.completions.create(
+#             model="gpt-4o-mini",
+#             messages=[
+#                 {"role":"assistant","content":"You are a forensic linguistic who knows how to analyze similarites in writing styles."},
+#                 {"role":"user","content":prompt}],
+#             response_format={"type": "json_schema", "json_schema": {"name": "style_analysis_schema", "schema":  to_strict_json_schema(style_analysis_schema)}}
+#         )
+
+#         parsed_response = json.loads(response.choices[0].message.content)
+
+#         with open(cache_path, "wb") as f:
+#             pickle.dump(parsed_response, f)
+
+#     return parsed_response 
 
 def generate_cache_key(author_names: List[str], max_num_feats: int) -> str:
     """Generate a unique cache key based on author names and max features"""
@@ -470,10 +487,11 @@ def identify_style_features(author_texts: list[str], author_names: list[str], ma
 
         if cache_key in cache:
             print(f"\nCache hit! Using cached features for authors: {author_names}")
+            print(f"\n\n\n\033[1m\033[92m>>> Cache hit for {cache_key} in {ZOOM_CACHE} <<<\033[0m\n")
             return cache[cache_key]["features"]
         else:
-            print(f"Cache miss. Computing features for authors: {author_names}")
-    
+            print(f"\n\n\n\033[1m\033[91m>>> Cache miss for {cache_key} in {ZOOM_CACHE} \nComputing features for authors: {author_names}<<<\033[0m\n")
+
     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
     prompt = f"""Identify {max_num_feats} writing style features that are common between the authors texts.
     Author Texts:
@@ -481,9 +499,9 @@ def identify_style_features(author_texts: list[str], author_names: list[str], ma
     {author_texts}
     """
 
-    print('==================>>>>>>>>>>')
-    print(prompt)
-    print('==================>>>>>>>>>>')
+    # print('==================>>>>>>>>>>')
+    # print(prompt)
+    # print('==================>>>>>>>>>>')
     def _make_call():
         response = client.chat.completions.create(
             model="gpt-4o",
@@ -510,6 +528,8 @@ def identify_style_features(author_texts: list[str], author_names: list[str], ma
         # save_cache(cache)
         with open(ZOOM_CACHE, 'w') as f:
             json.dump(cache, f, indent=2)
+            print(f"\n\n\n\033[1m\033[92m>>> Cache saved for {cache_key} in {ZOOM_CACHE}<<<\033[0m\n")
+            
 
         print(f"Cached features for authors: {author_names}")
     
@@ -538,7 +558,7 @@ def extract_all_spans(authors_df: pd.DataFrame, features: list[str], cluster_lab
 
     for _, row in authors_df.iterrows():
         author_name = str(row[cluster_label_clm_name])
-        print(author_name)
+        # print(author_name)
         role = f"{author_name}"
         full_text = row['fullText']
         spans = generate_feature_spans_cached(client, full_text, features, role)
@@ -566,15 +586,15 @@ def compute_clusters_style_representation_3(
     author_texts = "\n\n".join(["""Author {}:\n""".format(i+1) + text for i, text in enumerate(author_texts)])
     author_names = background_corpus_df_feat_id[cluster_label_clm_name].tolist()[:max_num_authors]
     print(f"Number of authors: {len(background_corpus_df_feat_id)}")
-    print(author_names)
+    # print(author_names)
     features = identify_style_features(author_texts, author_names, max_num_feats=max_num_feats)
 
-    print("Features: ", features)
+    # print("Features: ", features)
     # STEP 2: Prepare author pool for span extraction
     span_df = background_corpus_df.iloc[:max_authors_for_span_extraction]
     author_names = span_df[cluster_label_clm_name].tolist()[:max_authors_for_span_extraction]
     print(f"Number of authors for span detection : {len(span_df)}")
-    print(author_names)
+    # print(author_names)
     spans_by_author = extract_all_spans(span_df, features, cluster_label_clm_name)
     
     # Filter-in only task authors that are part of the current selection
@@ -619,7 +639,7 @@ def compute_clusters_style_representation_3(
             for feature, spans in feature_map.items():
                 if spans:
                     feature_importance[feature] -= len(spans)
-    print(feature_importance)
+    # print(feature_importance)
     selected_features_ranked = sorted(feature_importance, key=lambda f: -feature_importance[f])[:int(top_k)]
 
     #print('filtered set of features (min coverage', len(author_present_feature_sets), '): ', selected_features_ranked)
@@ -714,68 +734,69 @@ def compute_clusters_g2v_representation(
         key=lambda x: (-feature_span_counts.get(x[0], 0), -x[1])
     )
     
-    print(f"[INFO] Sorted gram2vec features by span frequency: {[(f, feature_span_counts.get(f, 0), z) for f, z in sorted_by_spans[:top_n]]}")
+    # print(f"[INFO] Sorted gram2vec features by span frequency: {[(f, feature_span_counts.get(f, 0), z) for f, z in sorted_by_spans[:top_n]]}")
     
     return sorted_by_spans[:top_n]
 
-def generate_interpretable_space_representation(interp_space_path, styles_df_path, feat_clm, output_clm, num_feats=5):
+# Noticed the following function isnt actually referenced anywhere.
+# def generate_interpretable_space_representation(interp_space_path, styles_df_path, feat_clm, output_clm, num_feats=5):
     
-    styles_df = pd.read_csv(styles_df_path)[[feat_clm, "documentID"]]
+#     styles_df = pd.read_csv(styles_df_path)[[feat_clm, "documentID"]]
 
-    # A dictionary of style features and their IDF
-    style_feats_agg_df = styles_df.groupby(feat_clm).agg({'documentID': lambda x : len(list(x))}).reset_index()
-    style_feats_agg_df['document_freq'] = style_feats_agg_df.documentID
-    style_to_feats_dfreq = {x[0]: math.log(styles_df.documentID.nunique()/x[1]) for x in zip(style_feats_agg_df[feat_clm].tolist(), style_feats_agg_df.document_freq.tolist())}
+#     # A dictionary of style features and their IDF
+#     style_feats_agg_df = styles_df.groupby(feat_clm).agg({'documentID': lambda x : len(list(x))}).reset_index()
+#     style_feats_agg_df['document_freq'] = style_feats_agg_df.documentID
+#     style_to_feats_dfreq = {x[0]: math.log(styles_df.documentID.nunique()/x[1]) for x in zip(style_feats_agg_df[feat_clm].tolist(), style_feats_agg_df.document_freq.tolist())}
     
-    # A list of style features we work with
-    style_feats_list = style_feats_agg_df[feat_clm].tolist()
-    print('Number of style feats ', len(style_feats_list))
+#     # A list of style features we work with
+#     style_feats_list = style_feats_agg_df[feat_clm].tolist()
+#     print('Number of style feats ', len(style_feats_list))
     
-    # A list of documents and what list of style features each has
-    doc_style_agg_df     = styles_df.groupby('documentID').agg({feat_clm: lambda x : list(x)}).reset_index()
-    document_to_feats_dict = {x[0]: x[1] for x in zip(doc_style_agg_df.documentID.tolist(), doc_style_agg_df[feat_clm].tolist())}
+#     # A list of documents and what list of style features each has
+#     doc_style_agg_df     = styles_df.groupby('documentID').agg({feat_clm: lambda x : list(x)}).reset_index()
+#     document_to_feats_dict = {x[0]: x[1] for x in zip(doc_style_agg_df.documentID.tolist(), doc_style_agg_df[feat_clm].tolist())}
     
     
 
-    # Load the clustering information
-    df = pd.read_pickle(interp_space_path)
-    df = df[df.cluster_label != -1]
-    # A cluster to list of documents
-    clusterd_df = df.groupby('cluster_label').agg({
-        'documentID': lambda x: [d_id for doc_ids in x for d_id in doc_ids]
-    }).reset_index()
+#     # Load the clustering information
+#     df = pd.read_pickle(interp_space_path)
+#     df = df[df.cluster_label != -1]
+#     # A cluster to list of documents
+#     clusterd_df = df.groupby('cluster_label').agg({
+#         'documentID': lambda x: [d_id for doc_ids in x for d_id in doc_ids]
+#     }).reset_index()
     
-    # Filter-in only documents that has a style description
-    clusterd_df['documentID'] = clusterd_df.documentID.apply(lambda documentIDs: [documentID for documentID in documentIDs if documentID in document_to_feats_dict])
-    # Map from cluster label to list of features through the document information
-    clusterd_df[feat_clm] = clusterd_df.documentID.apply(lambda doc_ids: [f for d_id in doc_ids for f in document_to_feats_dict[d_id]])
+#     # Filter-in only documents that has a style description
+#     clusterd_df['documentID'] = clusterd_df.documentID.apply(lambda documentIDs: [documentID for documentID in documentIDs if documentID in document_to_feats_dict])
+#     # Map from cluster label to list of features through the document information
+#     clusterd_df[feat_clm] = clusterd_df.documentID.apply(lambda doc_ids: [f for d_id in doc_ids for f in document_to_feats_dict[d_id]])
 
-    def compute_tfidf(row):
-        style_counts = Counter(row[feat_clm])
-        total_num_styles = sum(style_counts.values())
-        #print(style_counts, total_num_styles)
-        style_distribution = {
-            style: math.log(1+count) * style_to_feats_dfreq[style] if style in style_to_feats_dfreq else 0 for style, count in style_counts.items()
-        } #TF-IDF
+#     def compute_tfidf(row):
+#         style_counts = Counter(row[feat_clm])
+#         total_num_styles = sum(style_counts.values())
+#         #print(style_counts, total_num_styles)
+#         style_distribution = {
+#             style: math.log(1+count) * style_to_feats_dfreq[style] if style in style_to_feats_dfreq else 0 for style, count in style_counts.items()
+#         } #TF-IDF
         
-        return style_distribution
+#         return style_distribution
 
-    def create_tfidf_rep(tfidf_dist, num_feats):
-        style_feats = sorted(tfidf_dist.items(), key=lambda x: -x[1])
-        top_k_feats = [x[0] for x in style_feats[:num_feats] if str(x[0]) != 'nan']
-        return top_k_feats
+#     def create_tfidf_rep(tfidf_dist, num_feats):
+#         style_feats = sorted(tfidf_dist.items(), key=lambda x: -x[1])
+#         top_k_feats = [x[0] for x in style_feats[:num_feats] if str(x[0]) != 'nan']
+#         return top_k_feats
 
-    clusterd_df[output_clm +'_dist'] = clusterd_df.apply(lambda row: compute_tfidf(row), axis=1)
-    clusterd_df[output_clm]         = clusterd_df[output_clm +'_dist'].apply(lambda dist: create_tfidf_rep(dist, num_feats))
+#     clusterd_df[output_clm +'_dist'] = clusterd_df.apply(lambda row: compute_tfidf(row), axis=1)
+#     clusterd_df[output_clm]         = clusterd_df[output_clm +'_dist'].apply(lambda dist: create_tfidf_rep(dist, num_feats))
 
         
-    return clusterd_df
+#     return clusterd_df
 
 def compute_predicted_author(task_authors_df: pd.DataFrame, col_name: str) -> int:
     """
     Computes the predicted author based on the style features.
     """
-    print("Computing predicted author using LUAR-MUD-style embeddings...")
+    print("Computing predicted author using embeddings...")
 
     # Extract LUAR embeddings from task authors dataframe
     mystery_embedding = np.array(task_authors_df.iloc[0][col_name]).reshape(1, -1)
@@ -816,11 +837,11 @@ def compute_precomputed_regions(bg_proj, bg_ids, q_proj, c_proj, pred_idx, model
     else:
         cache = {}
     if key in cache:
-        print(f"\nCache hit! Using cached regions.")
+        print(f"\n\n\n\033[1m\033[92m>>> Cache hit for {key} in {REGION_CACHE}: Using cached regions<<<\033[0m\n")
         return cache[key]
     else:
-        print(f"Cache miss. Computing regions.")
-    
+        print(f"\n\n\n\033[1m\033[91m>>> Cache miss for {key} in {REGION_CACHE}: Computing Regions<<<\033[0m\n")
+
     regions = {}
     
     # All points for distance calculation (mystery + candidates + background)
@@ -935,22 +956,23 @@ def compute_precomputed_regions(bg_proj, bg_ids, q_proj, c_proj, pred_idx, model
     response = json.dumps(serializable_regions, default=str)
     cache[key] = response
     with open(REGION_CACHE, 'wb') as f: 
+        print(f"\n\n\n\033[1m\033[92m>>> Cache saved for {key} in {REGION_CACHE} <<<\033[0m\n")
         pickle.dump(cache, f)
 
     return response
 
-if __name__ == "__main__":
-    background_corpus = pd.read_pickle('../datasets/luar_interp_space_cluster_19/train_authors.pkl')
-    print(background_corpus.columns)
-    print(background_corpus[['authorID', 'fullText', 'cluster_label']].head())
-    # # Example: Find features for clusters [2,3,4] that are NOT prominent in cluster [1]
-    # feats = compute_clusters_style_representation(
-    #     background_corpus_df=background_corpus,
-    #     cluster_ids=['00005a5c-5c06-3a36-37f9-53c6422a31d8',],
-    #     other_cluster_ids=[], # Pass the contrastive cluster IDs here
-    #     cluster_label_clm_name='authorID',
-    #     features_clm_name='final_attribute_name'
-    # )
-    # print(feats)
-    generate_style_embedding(background_corpus, 'fullText', 'AnnaWegmann/Style-Embedding')
-    print(background_corpus.columns)
+# if __name__ == "__main__":
+#     background_corpus = pd.read_pickle('../datasets/luar_interp_space_cluster_19/train_authors.pkl')
+#     print(background_corpus.columns)
+#     print(background_corpus[['authorID', 'fullText', 'cluster_label']].head())
+#     # # Example: Find features for clusters [2,3,4] that are NOT prominent in cluster [1]
+#     # feats = compute_clusters_style_representation(
+#     #     background_corpus_df=background_corpus,
+#     #     cluster_ids=['00005a5c-5c06-3a36-37f9-53c6422a31d8',],
+#     #     other_cluster_ids=[], # Pass the contrastive cluster IDs here
+#     #     cluster_label_clm_name='authorID',
+#     #     features_clm_name='final_attribute_name'
+#     # )
+#     # print(feats)
+#     generate_style_embedding(background_corpus, 'fullText', 'AnnaWegmann/Style-Embedding')
+#     print(background_corpus.columns)