search by company name

app.py

@@ -115,7 +115,9 @@ y_cdf, _ = dh_app.configura_distr_prob(shape, loc, scale, max_dist, precision_cd
 # Parámetros de la de búsqueda VSS:
 k = semantic_search_params["k"]
 brevity_penalty = semantic_search_params["brevity_penalty"]
+min_length = semantic_search_params["min_length"]
 reward_for_literal = semantic_search_params["reward_for_literal"]
+first_term_reward = semantic_search_params["first_term_reward"]
 partial_match_factor = semantic_search_params["partial_match_factor"]
 print(f"VSS params: k={k}, brevity_penalty={brevity_penalty}, reward_for_literal={reward_for_literal}, partial_match_factor={partial_match_factor}")
 
@@ -187,7 +189,9 @@ def search_theme(theme: str, page: int, *filtros_values) -> Tuple[pd.DataFrame,
         query=query,
         k=k,
         brevity_penalty=brevity_penalty,
+        min_length = min_length,
         reward_for_literal=reward_for_literal,
+        first_term_reward=first_term_reward,
         partial_match_factor=partial_match_factor,
         table_name="vector_table",
         embedding_column="embeddings"

json/semantic_search_params.json

@@ -2,7 +2,9 @@
     "semantic_search_params": {
         "k": 2000,
         "brevity_penalty": 0.1,
+		"min_length": 131,
         "reward_for_literal": 0.03,
+		"first_term_reward": 20,
         "partial_match_factor": 0.8
     }
 }

src/semantic_search.py

@@ -9,7 +9,9 @@ def duckdb_vss_local(
     query: str,
     k: int = 1000,
     brevity_penalty: float = 0.0,
+    min_length: int = 131,
     reward_for_literal: float = 0.0,
+    first_term_reward: float = 20.0,
     partial_match_factor: float = 0.5,
     table_name: str = "maestro_vector_table",
     embedding_column: str = "vec",
@@ -33,10 +35,10 @@ def duckdb_vss_local(
     # Utilizar los parámetros "debug" para mostrar columnas intermedias:
     if brevity_penalty > 0:
         result = penalize_short_summaries(result, factor = brevity_penalty, distance_column = 'distance', 
-                                          summary_column = 'longBusinessSummary', debug = False)
+                                          summary_column = 'longBusinessSummary', min_length=min_length, debug = False)
     if reward_for_literal > 0:
         result = reward_literals(result, query, factor = reward_for_literal, 
-                                 partial_match_factor= partial_match_factor, distance_column = 'distance', 
+                                 partial_match_factor= partial_match_factor, first_term_reward=first_term_reward, distance_column = 'distance', 
                                  summary_column = 'longBusinessSummary', debug = False)
 
     return result
@@ -46,7 +48,8 @@ def penalize_short_summaries(
     factor: float = 0.1,
     distance_column: str = 'distance',
     summary_column: str = 'longBusinessSummary',
-    debug: bool = True
+    debug: bool = True,
+    min_length: int = 131
     ) -> pd.DataFrame:
 
     result_df = df.copy()
@@ -59,10 +62,14 @@ def penalize_short_summaries(
     result_df['percent_shorter'] = result_df['summary_length'].apply(
         lambda x: max(0, (avg_length - x) / avg_length)
     )
+
     result_df['orig_distance'] = result_df[distance_column]
-    # Penalizamos en función del porcentaje en el que el resumen es más corto que la media (multiplicado por el factor)
+
+    # Asignar distancia máxima para resúmenes más cortos que min_length
+    # y aplicar penalización proporcional para el resto
     result_df[distance_column] = result_df.apply(
-        lambda row: min(max_dist, row[distance_column] + (row['percent_shorter'] * factor)),
+        lambda row: max_dist if row['summary_length'] < min_length else 
+                   min(max_dist, row[distance_column] + (row['percent_shorter'] * factor)),
         axis=1
     )
     
@@ -77,6 +84,7 @@ def reward_literals(
     query: str,
     factor: float = 0.1,
     partial_match_factor: float = 0.5,
+    first_term_reward: float = 20.0,
     distance_column: str = 'distance',
     summary_column: str = 'longBusinessSummary',
     debug: bool = True
@@ -89,6 +97,12 @@ def reward_literals(
         if pd.isna(summary):
             return 0
         summary_lower = str(summary).lower()
+        # Extraemos la primera palabra del resumen y la limpiamos de caracteres especiales 
+        # Por ejemplo: "Grifols, S.A. operates as a plasma therapeutic company..." -> Extrae "Grifols", no "Grifols,"
+        first_word = summary_lower.split()[0] if summary_lower.strip() and len(summary_lower.split()) > 0 else ""
+        first_term = re.sub(r'[^\w\s]', '', first_word.lower())
+        # Comprobamos si la primera palabra coincide con la consulta (típicamente el nombre de la empresa)
+        _first_term_reward = first_term_reward if first_term == query_lower else 0
         
         # Cuenta coincidencias exactas (palabras completas)
         exact_pattern = r'\b' + re.escape(query_lower) + r'\b'
@@ -108,7 +122,7 @@ def reward_literals(
         partial_count = partial_count - exact_count
         
         # Penalizamos las coincidencias parciales:
-        return exact_count + (partial_count * partial_match_factor)
+        return _first_term_reward + exact_count + (partial_count * partial_match_factor)
         
     result_df['term_occurrences'] = result_df[summary_column].apply(count_phrase_occurrences)
     result_df['orig_distance'] = result_df[distance_column]