Spaces:
Runtime error
fix(recherche): la passe floue compare les titres mot par mot
Browse files« peine de mort au cameroun » rendait en tete des decrets de pret, a
egalite (0,959), devant les 11 articles du Code penal sur la peine de
mort. La passe floue sur les titres, faite pour rattraper les fautes de
frappe, comparait la requete ENTIERE : « de », « au » et « cameroun »
font plus de la moitie de ses trigrammes, et tout titre en « ... de ...
au Cameroun » passait le seuil (0,516 pour 0,5). Etiquetes correspondance
de titre, ces decrets passaient devant toute correspondance d'article.
- Chaque mot significatif (sans mots vides, ni « cameroun », « loi »,
« decret »...) doit se retrouver dans le titre, meme mal orthographie.
Les fautes de frappe (« nominaton », « code miner ») restent rattrapees.
- Le mode entre dans la cle du cache : une recherche texte et une
recherche hybride de la meme requete se servaient l'une l'autre.
- scripts/eval/evaluer_recherche.py rejoue la requete de la page sur les
102 questions relues et 10 requetes temoins.
Mesure (102 questions), mode hybride : hit@1 0,402 -> 0,441, hit@10
0,824 -> 0,863, 9 questions ameliorees, aucune degradee. Mode texte :
hit@1 0,098 -> 0,137 ; une question degradee (rang 13 -> absente).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
@@ -25,6 +25,8 @@ Version: 3.0.0 (PostgreSQL native)
|
|
| 25 |
import hashlib
|
| 26 |
import json
|
| 27 |
import logging
|
|
|
|
|
|
|
| 28 |
from datetime import datetime, timedelta, timezone
|
| 29 |
from typing import Any, Dict, List, Optional, Sequence
|
| 30 |
|
|
@@ -67,11 +69,18 @@ MAX_CHUNKS_PER_LAW = 3
|
|
| 67 |
CACHE_SCHEMA_VERSION = "v4"
|
| 68 |
|
| 69 |
|
| 70 |
-
def _make_cache_key(
|
| 71 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 72 |
filters_dict = filters.model_dump() if filters else {}
|
| 73 |
raw = (
|
| 74 |
-
f"{CACHE_SCHEMA_VERSION}|{query}|"
|
| 75 |
f"{json.dumps(filters_dict, sort_keys=True)}|{limit}|{offset}"
|
| 76 |
)
|
| 77 |
return hashlib.sha256(raw.encode()).hexdigest()[:64]
|
|
@@ -697,6 +706,34 @@ def _rows_to_chunks(rows: Sequence[Any], source: str) -> List[ChunkResult]:
|
|
| 697 |
return chunks
|
| 698 |
|
| 699 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 700 |
async def search_titles_trgm_pg(
|
| 701 |
db: AsyncSession,
|
| 702 |
query: str,
|
|
@@ -722,8 +759,29 @@ async def search_titles_trgm_pg(
|
|
| 722 |
`apply_trigram_threshold`) : l'operateur `%>` filtre sur le reglage de
|
| 723 |
session, si bien qu'un predicat `word_similarity(...) >= 0.5` ajoute ici
|
| 724 |
serait du code mort — rien sous le defaut de 0,6 ne lui parviendrait.
|
| 725 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 726 |
params: Dict[str, Any] = {"query": query, "limit": limit}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 727 |
where_extra = _law_filter_clauses(filters, params)
|
| 728 |
|
| 729 |
sql = text(f"""
|
|
@@ -745,13 +803,13 @@ async def search_titles_trgm_pg(
|
|
| 745 |
c.name AS category_name,
|
| 746 |
TRUE AS title_match,
|
| 747 |
GREATEST(
|
| 748 |
-
|
| 749 |
word_similarity(immutable_unaccent(:query), immutable_unaccent(l.reference))
|
| 750 |
) AS rank
|
| 751 |
FROM laws l
|
| 752 |
LEFT JOIN categories c ON c.id = l.category_id
|
| 753 |
WHERE (
|
| 754 |
-
|
| 755 |
OR immutable_unaccent(l.reference) %> immutable_unaccent(:query)
|
| 756 |
)
|
| 757 |
{where_extra}
|
|
|
|
| 25 |
import hashlib
|
| 26 |
import json
|
| 27 |
import logging
|
| 28 |
+
import re
|
| 29 |
+
import unicodedata
|
| 30 |
from datetime import datetime, timedelta, timezone
|
| 31 |
from typing import Any, Dict, List, Optional, Sequence
|
| 32 |
|
|
|
|
| 69 |
CACHE_SCHEMA_VERSION = "v4"
|
| 70 |
|
| 71 |
|
| 72 |
+
def _make_cache_key(
|
| 73 |
+
query: str, filters: Optional[SearchFilters], limit: int, offset: int, mode: str
|
| 74 |
+
) -> str:
|
| 75 |
+
"""
|
| 76 |
+
Génère une clé de cache SHA-256 déterministe.
|
| 77 |
+
|
| 78 |
+
Le mode en fait partie : sans lui, une recherche « text » et une recherche
|
| 79 |
+
« hybrid » de la meme requete se servaient l'une l'autre pendant tout le TTL.
|
| 80 |
+
"""
|
| 81 |
filters_dict = filters.model_dump() if filters else {}
|
| 82 |
raw = (
|
| 83 |
+
f"{CACHE_SCHEMA_VERSION}|{mode}|{query}|"
|
| 84 |
f"{json.dumps(filters_dict, sort_keys=True)}|{limit}|{offset}"
|
| 85 |
)
|
| 86 |
return hashlib.sha256(raw.encode()).hexdigest()[:64]
|
|
|
|
| 706 |
return chunks
|
| 707 |
|
| 708 |
|
| 709 |
+
# Mots ignores par la passe floue sur les titres : les mots vides, et ceux que
|
| 710 |
+
# presque tous les titres du corpus contiennent. Ils ne designent aucun texte.
|
| 711 |
+
MOTS_SANS_POIDS_TITRE = frozenset({
|
| 712 |
+
"les", "des", "aux", "une", "par", "pour", "sur", "dans", "avec", "sans",
|
| 713 |
+
"que", "qui", "quoi", "est", "sont", "son", "ses", "leur", "leurs", "entre",
|
| 714 |
+
"cameroun", "camerounais", "camerounaise", "republique",
|
| 715 |
+
"loi", "lois", "decret", "decrets", "ordonnance", "arrete", "portant",
|
| 716 |
+
"relatif", "relative", "the", "and", "law",
|
| 717 |
+
})
|
| 718 |
+
|
| 719 |
+
|
| 720 |
+
def mots_significatifs(query: str) -> List[str]:
|
| 721 |
+
"""
|
| 722 |
+
Les mots de la requete qui doivent se retrouver dans un titre : sans
|
| 723 |
+
accents, en minuscules, d'au moins trois caracteres, hors
|
| 724 |
+
MOTS_SANS_POIDS_TITRE, sans doublon.
|
| 725 |
+
"""
|
| 726 |
+
sans_accents = "".join(
|
| 727 |
+
c for c in unicodedata.normalize("NFD", query.lower())
|
| 728 |
+
if unicodedata.category(c) != "Mn"
|
| 729 |
+
)
|
| 730 |
+
mots: List[str] = []
|
| 731 |
+
for mot in re.findall(r"[a-z0-9]+", sans_accents):
|
| 732 |
+
if len(mot) >= 3 and mot not in MOTS_SANS_POIDS_TITRE and mot not in mots:
|
| 733 |
+
mots.append(mot)
|
| 734 |
+
return mots
|
| 735 |
+
|
| 736 |
+
|
| 737 |
async def search_titles_trgm_pg(
|
| 738 |
db: AsyncSession,
|
| 739 |
query: str,
|
|
|
|
| 759 |
`apply_trigram_threshold`) : l'operateur `%>` filtre sur le reglage de
|
| 760 |
session, si bien qu'un predicat `word_similarity(...) >= 0.5` ajoute ici
|
| 761 |
serait du code mort — rien sous le defaut de 0,6 ne lui parviendrait.
|
| 762 |
+
|
| 763 |
+
MOT PAR MOT, ET NON LA REQUETE ENTIERE. Comparee d'un bloc, une requete de
|
| 764 |
+
plusieurs mots passait le seuil sur ses mots les plus banals : dans
|
| 765 |
+
« peine de mort au cameroun », « de », « au » et « cameroun » font plus de
|
| 766 |
+
la moitie des trigrammes, et tout titre en « ... de ... au Cameroun »
|
| 767 |
+
sortait a 0,516 — des decrets de pret, classes en tete comme
|
| 768 |
+
correspondances de titre, devant les 11 articles du Code penal sur la
|
| 769 |
+
peine de mort. Chaque mot significatif (`mots_significatifs`) doit
|
| 770 |
+
desormais se retrouver, meme mal orthographie, dans le titre. Sans mot
|
| 771 |
+
significatif, la passe ne rend rien. La reference, elle, garde la
|
| 772 |
+
comparaison d'un bloc : c'est un identifiant, pas une phrase.
|
| 773 |
+
"""
|
| 774 |
+
mots = mots_significatifs(query)
|
| 775 |
+
if not mots:
|
| 776 |
+
return []
|
| 777 |
params: Dict[str, Any] = {"query": query, "limit": limit}
|
| 778 |
+
for i, mot in enumerate(mots):
|
| 779 |
+
params[f"mot_{i}"] = mot
|
| 780 |
+
titre = "immutable_unaccent(l.title)"
|
| 781 |
+
chaque_mot = " AND ".join(f"{titre} %> :mot_{i}" for i in range(len(mots)))
|
| 782 |
+
similarite_titre = " + ".join(
|
| 783 |
+
f"word_similarity(:mot_{i}, {titre})" for i in range(len(mots))
|
| 784 |
+
)
|
| 785 |
where_extra = _law_filter_clauses(filters, params)
|
| 786 |
|
| 787 |
sql = text(f"""
|
|
|
|
| 803 |
c.name AS category_name,
|
| 804 |
TRUE AS title_match,
|
| 805 |
GREATEST(
|
| 806 |
+
({similarite_titre}) / {len(mots)},
|
| 807 |
word_similarity(immutable_unaccent(:query), immutable_unaccent(l.reference))
|
| 808 |
) AS rank
|
| 809 |
FROM laws l
|
| 810 |
LEFT JOIN categories c ON c.id = l.category_id
|
| 811 |
WHERE (
|
| 812 |
+
({chaque_mot})
|
| 813 |
OR immutable_unaccent(l.reference) %> immutable_unaccent(:query)
|
| 814 |
)
|
| 815 |
{where_extra}
|
|
@@ -277,7 +277,8 @@ class SearchService:
|
|
| 277 |
# Check PostgreSQL cache
|
| 278 |
if self.use_cache:
|
| 279 |
cache_key = _make_cache_key(
|
| 280 |
-
request.query, request.filters, request.limit, request.offset
|
|
|
|
| 281 |
)
|
| 282 |
# Le cache est une optimisation, pas une dependance : si query_cache
|
| 283 |
# est absente ou injoignable, on doit degrader, pas renvoyer 500.
|
|
|
|
| 277 |
# Check PostgreSQL cache
|
| 278 |
if self.use_cache:
|
| 279 |
cache_key = _make_cache_key(
|
| 280 |
+
request.query, request.filters, request.limit, request.offset,
|
| 281 |
+
request.mode,
|
| 282 |
)
|
| 283 |
# Le cache est une optimisation, pas une dependance : si query_cache
|
| 284 |
# est absente ou injoignable, on doit degrader, pas renvoyer 500.
|
|
@@ -0,0 +1,184 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Mesure le classement de la PAGE DE RECHERCHE, document par document.
|
| 3 |
+
|
| 4 |
+
La page /search envoie une recherche en mode « text », filtree sur
|
| 5 |
+
status=published, 20 resultats par page. Ce script rejoue exactement cette
|
| 6 |
+
requete, sans cache et sans journaliser d'evenement de recherche (lecture
|
| 7 |
+
seule), et mesure le rang de la loi attendue :
|
| 8 |
+
|
| 9 |
+
- les 102 questions relues de tests/fixtures/eval/retrieval_eval_v1.json
|
| 10 |
+
(loi attendue : expected_law_id) : hit@1, hit@3, hit@10, MRR@20 ;
|
| 11 |
+
- des requetes TEMOINS, chacune avec ce qu'on attend d'elle : la requete qui
|
| 12 |
+
a revele le defaut (« peine de mort au cameroun »), et celles qui fondent la
|
| 13 |
+
passe floue sur les titres (fautes de frappe : « nominaton », « code miner »).
|
| 14 |
+
|
| 15 |
+
Usage:
|
| 16 |
+
python -m scripts.eval.evaluer_recherche
|
| 17 |
+
python -m scripts.eval.evaluer_recherche --modes text hybrid --sortie data/eval_runs/recherche.json
|
| 18 |
+
"""
|
| 19 |
+
|
| 20 |
+
import argparse
|
| 21 |
+
import asyncio
|
| 22 |
+
import json
|
| 23 |
+
import sys
|
| 24 |
+
import unicodedata
|
| 25 |
+
from pathlib import Path
|
| 26 |
+
from typing import Any, Callable, Dict, List, Optional, Sequence
|
| 27 |
+
|
| 28 |
+
RACINE = Path(__file__).resolve().parents[2]
|
| 29 |
+
sys.path.insert(0, str(RACINE))
|
| 30 |
+
|
| 31 |
+
from app.core.database import AsyncSessionLocal
|
| 32 |
+
from app.schemas.search import SearchFilters, SearchRequest
|
| 33 |
+
from app.services.search_service import SearchService
|
| 34 |
+
|
| 35 |
+
JEU = RACINE / "tests" / "fixtures" / "eval" / "retrieval_eval_v1.json"
|
| 36 |
+
TAILLE_PAGE = 20 # TAILLE_PAGE_RECHERCHE du front (src/lib/pagination.ts)
|
| 37 |
+
|
| 38 |
+
CODE_PENAL, JUSTICE_MILITAIRE = 2236, 2085
|
| 39 |
+
CODES_MINIERS = {2210, 2228}
|
| 40 |
+
|
| 41 |
+
|
| 42 |
+
def _sans_accents(texte: str) -> str:
|
| 43 |
+
return "".join(c for c in unicodedata.normalize("NFD", texte.lower())
|
| 44 |
+
if unicodedata.category(c) != "Mn")
|
| 45 |
+
|
| 46 |
+
|
| 47 |
+
def _titres_contiennent(mot: str, n: int) -> Callable[[Dict[str, Any]], bool]:
|
| 48 |
+
"""Les n premiers titres contiennent tous `mot` (sans accents)."""
|
| 49 |
+
def verifier(reponse: Dict[str, Any]) -> bool:
|
| 50 |
+
titres = [_sans_accents(r["title"]) for r in reponse["results"][:n]]
|
| 51 |
+
return len(titres) == n and all(mot in t for t in titres)
|
| 52 |
+
return verifier
|
| 53 |
+
|
| 54 |
+
|
| 55 |
+
def _rang_parmi(ids: set, n: int) -> Callable[[Dict[str, Any]], bool]:
|
| 56 |
+
"""Une des lois `ids` figure dans les n premiers resultats."""
|
| 57 |
+
def verifier(reponse: Dict[str, Any]) -> bool:
|
| 58 |
+
return any(r["law_id"] in ids for r in reponse["results"][:n])
|
| 59 |
+
return verifier
|
| 60 |
+
|
| 61 |
+
|
| 62 |
+
def _navigation_directe(ids: set) -> Callable[[Dict[str, Any]], bool]:
|
| 63 |
+
def verifier(reponse: Dict[str, Any]) -> bool:
|
| 64 |
+
return bool(reponse["direct_navigation"]) and reponse["target_law_id"] in ids
|
| 65 |
+
return verifier
|
| 66 |
+
|
| 67 |
+
|
| 68 |
+
# (requete, attente lisible, verification)
|
| 69 |
+
TEMOINS: List[tuple] = [
|
| 70 |
+
("peine de mort au cameroun", "Code penal ou justice militaire dans le top 3",
|
| 71 |
+
_rang_parmi({CODE_PENAL, JUSTICE_MILITAIRE}, 3)),
|
| 72 |
+
("peine de mort", "Code penal ou justice militaire dans le top 3",
|
| 73 |
+
_rang_parmi({CODE_PENAL, JUSTICE_MILITAIRE}, 3)),
|
| 74 |
+
("justice militaire", "Code de justice militaire premier",
|
| 75 |
+
_rang_parmi({JUSTICE_MILITAIRE}, 1)),
|
| 76 |
+
("code pénal", "Code penal (loi 2236 ou decret 1769) dans le top 2",
|
| 77 |
+
_rang_parmi({CODE_PENAL, 1769}, 2)),
|
| 78 |
+
("code minier", "un code minier dans le top 2", _rang_parmi(CODES_MINIERS, 2)),
|
| 79 |
+
("code miner", "faute de frappe : un code minier dans le top 3", _rang_parmi(CODES_MINIERS, 3)),
|
| 80 |
+
("cod minier", "faute de frappe : un code minier dans le top 3", _rang_parmi(CODES_MINIERS, 3)),
|
| 81 |
+
("nominaton", "faute de frappe : les 5 premiers titres parlent de nomination",
|
| 82 |
+
_titres_contiennent("nomination", 5)),
|
| 83 |
+
("avancment", "faute de frappe : les 3 premiers titres parlent d'avancement",
|
| 84 |
+
_titres_contiennent("avancement", 3)),
|
| 85 |
+
("article 35 du code minier", "navigation directe vers un code minier",
|
| 86 |
+
_navigation_directe(CODES_MINIERS)),
|
| 87 |
+
]
|
| 88 |
+
|
| 89 |
+
|
| 90 |
+
async def rejouer(service: SearchService, requete: str, mode: str) -> Dict[str, Any]:
|
| 91 |
+
"""La requete de la page, sans cache ni journal d'evenement."""
|
| 92 |
+
demande = SearchRequest(
|
| 93 |
+
query=requete, mode=mode, limit=TAILLE_PAGE, offset=0,
|
| 94 |
+
filters=SearchFilters(status="published"),
|
| 95 |
+
)
|
| 96 |
+
chunks = await service._execute_search_by_mode(demande)
|
| 97 |
+
reponse = await service._build_search_response(demande, chunks, 0)
|
| 98 |
+
return {
|
| 99 |
+
"results": [{"law_id": r.law_id, "title": r.title, "score": round(r.relevance_score, 3),
|
| 100 |
+
"portee": r.match_scope} for r in reponse.results],
|
| 101 |
+
"total": reponse.total,
|
| 102 |
+
"direct_navigation": reponse.direct_navigation,
|
| 103 |
+
"target_law_id": reponse.target_law_id,
|
| 104 |
+
}
|
| 105 |
+
|
| 106 |
+
|
| 107 |
+
def _rang(reponse: Dict[str, Any], law_id: int) -> Optional[int]:
|
| 108 |
+
for position, r in enumerate(reponse["results"], start=1):
|
| 109 |
+
if r["law_id"] == law_id:
|
| 110 |
+
return position
|
| 111 |
+
return None
|
| 112 |
+
|
| 113 |
+
|
| 114 |
+
def synthese(rangs: Sequence[Optional[int]]) -> Dict[str, Any]:
|
| 115 |
+
n = len(rangs) or 1
|
| 116 |
+
return {
|
| 117 |
+
"n": len(rangs),
|
| 118 |
+
"hit@1": round(sum(1 for r in rangs if r and r <= 1) / n, 3),
|
| 119 |
+
"hit@3": round(sum(1 for r in rangs if r and r <= 3) / n, 3),
|
| 120 |
+
"hit@10": round(sum(1 for r in rangs if r and r <= 10) / n, 3),
|
| 121 |
+
"mrr@20": round(sum(1 / r for r in rangs if r) / n, 3),
|
| 122 |
+
"aucun_resultat": None,
|
| 123 |
+
}
|
| 124 |
+
|
| 125 |
+
|
| 126 |
+
async def evaluer(modes: Sequence[str]) -> Dict[str, Any]:
|
| 127 |
+
items = json.loads(JEU.read_text(encoding="utf-8"))["items"]
|
| 128 |
+
sortie: Dict[str, Any] = {"modes": {}}
|
| 129 |
+
async with AsyncSessionLocal() as session:
|
| 130 |
+
service = SearchService(session, use_cache=False)
|
| 131 |
+
for mode in modes:
|
| 132 |
+
par_item, rangs, vides = [], {"keyword": [], "paraphrase": [], "tous": []}, 0
|
| 133 |
+
for item in items:
|
| 134 |
+
reponse = await rejouer(service, item["question"], mode)
|
| 135 |
+
rang = _rang(reponse, item["expected_law_id"])
|
| 136 |
+
vides += not reponse["results"]
|
| 137 |
+
rangs["tous"].append(rang)
|
| 138 |
+
rangs.setdefault(item.get("difficulty", "?"), []).append(rang)
|
| 139 |
+
par_item.append({"question": item["question"], "attendu": item["expected_law_id"],
|
| 140 |
+
"rang": rang, "total": reponse["total"]})
|
| 141 |
+
temoins = []
|
| 142 |
+
for requete, attente, verifier in TEMOINS:
|
| 143 |
+
reponse = await rejouer(service, requete, mode)
|
| 144 |
+
temoins.append({"requete": requete, "attente": attente, "ok": verifier(reponse),
|
| 145 |
+
"top5": [f"{r['law_id']} {r['portee']} {r['score']} {r['title'][:70]}"
|
| 146 |
+
for r in reponse["results"][:5]]})
|
| 147 |
+
resume = {cle: synthese(valeurs) for cle, valeurs in rangs.items() if valeurs}
|
| 148 |
+
resume["tous"]["aucun_resultat"] = vides
|
| 149 |
+
sortie["modes"][mode] = {"synthese": resume, "temoins": temoins, "items": par_item}
|
| 150 |
+
return sortie
|
| 151 |
+
|
| 152 |
+
|
| 153 |
+
def afficher(sortie: Dict[str, Any]) -> None:
|
| 154 |
+
for mode, donnees in sortie["modes"].items():
|
| 155 |
+
print(f"\n=== mode {mode}")
|
| 156 |
+
for cle, s in donnees["synthese"].items():
|
| 157 |
+
print(f" {cle:10} n={s['n']:3} hit@1 {s['hit@1']:.3f} hit@3 {s['hit@3']:.3f} "
|
| 158 |
+
f"hit@10 {s['hit@10']:.3f} mrr@20 {s['mrr@20']:.3f}"
|
| 159 |
+
+ (f" sans resultat {s['aucun_resultat']}" if s["aucun_resultat"] is not None else ""))
|
| 160 |
+
ok = sum(t["ok"] for t in donnees["temoins"])
|
| 161 |
+
print(f" temoins : {ok}/{len(donnees['temoins'])}")
|
| 162 |
+
for t in donnees["temoins"]:
|
| 163 |
+
print(f" [{'ok' if t['ok'] else 'KO'}] {t['requete']!r} : {t['attente']}")
|
| 164 |
+
if not t["ok"]:
|
| 165 |
+
for ligne in t["top5"]:
|
| 166 |
+
print(f" {ligne}")
|
| 167 |
+
|
| 168 |
+
|
| 169 |
+
def main(argv: Optional[Sequence[str]] = None) -> int:
|
| 170 |
+
parseur = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
|
| 171 |
+
parseur.add_argument("--modes", nargs="+", default=["text"], choices=["text", "semantic", "hybrid"])
|
| 172 |
+
parseur.add_argument("--sortie", type=Path, help="Ecrit le detail en JSON")
|
| 173 |
+
args = parseur.parse_args(argv)
|
| 174 |
+
sortie = asyncio.run(evaluer(args.modes))
|
| 175 |
+
afficher(sortie)
|
| 176 |
+
if args.sortie:
|
| 177 |
+
args.sortie.parent.mkdir(parents=True, exist_ok=True)
|
| 178 |
+
args.sortie.write_text(json.dumps(sortie, ensure_ascii=False, indent=1), encoding="utf-8")
|
| 179 |
+
print(f"\nDetail : {args.sortie}")
|
| 180 |
+
return 0
|
| 181 |
+
|
| 182 |
+
|
| 183 |
+
if __name__ == "__main__":
|
| 184 |
+
sys.exit(main())
|
|
@@ -778,6 +778,21 @@ class TestCaching:
|
|
| 778 |
rows = await db_session.execute(sa_text("SELECT count(*) FROM query_cache"))
|
| 779 |
assert rows.scalar() == 0
|
| 780 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 781 |
|
| 782 |
# ============================================================================
|
| 783 |
# Test Edge Cases
|
|
|
|
| 778 |
rows = await db_session.execute(sa_text("SELECT count(*) FROM query_cache"))
|
| 779 |
assert rows.scalar() == 0
|
| 780 |
|
| 781 |
+
def test_the_mode_is_part_of_the_key(self):
|
| 782 |
+
"""
|
| 783 |
+
Sans le mode dans la cle, une recherche « text » et une recherche
|
| 784 |
+
« hybrid » de la meme requete se servaient l'une l'autre pendant tout le
|
| 785 |
+
TTL : la page (text) et le chat (hybrid) se renvoyaient leurs resultats.
|
| 786 |
+
"""
|
| 787 |
+
from app.services.postgres_search_service import _make_cache_key
|
| 788 |
+
|
| 789 |
+
cles = {
|
| 790 |
+
_make_cache_key("peine de mort", None, 20, 0, mode)
|
| 791 |
+
for mode in ("text", "semantic", "hybrid")
|
| 792 |
+
}
|
| 793 |
+
|
| 794 |
+
assert len(cles) == 3
|
| 795 |
+
|
| 796 |
|
| 797 |
# ============================================================================
|
| 798 |
# Test Edge Cases
|
|
@@ -32,6 +32,7 @@ from app.schemas.search import SearchRequest
|
|
| 32 |
from app.services.legal_domain_classifier import AFFAIRES
|
| 33 |
from app.services.postgres_search_service import (
|
| 34 |
MAX_CHUNKS_PER_LAW,
|
|
|
|
| 35 |
search_articles_pg,
|
| 36 |
)
|
| 37 |
from app.services.search_service import SearchService
|
|
@@ -195,6 +196,83 @@ class TestTypoTolerance:
|
|
| 195 |
assert results[0].relevance_score >= max(r.relevance_score for r in results)
|
| 196 |
|
| 197 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 198 |
class TestPerLawCap:
|
| 199 |
@pytest.mark.asyncio
|
| 200 |
async def test_one_law_cannot_take_the_whole_budget(self, db_session, ranking_corpus):
|
|
|
|
| 32 |
from app.services.legal_domain_classifier import AFFAIRES
|
| 33 |
from app.services.postgres_search_service import (
|
| 34 |
MAX_CHUNKS_PER_LAW,
|
| 35 |
+
mots_significatifs,
|
| 36 |
search_articles_pg,
|
| 37 |
)
|
| 38 |
from app.services.search_service import SearchService
|
|
|
|
| 196 |
assert results[0].relevance_score >= max(r.relevance_score for r in results)
|
| 197 |
|
| 198 |
|
| 199 |
+
class TestMotsSignificatifs:
|
| 200 |
+
"""La passe floue compare chaque mot qui designe quelque chose, et eux seuls."""
|
| 201 |
+
|
| 202 |
+
@pytest.mark.parametrize("requete, attendus", [
|
| 203 |
+
("peine de mort au cameroun", ["peine", "mort"]),
|
| 204 |
+
("Loi portant Code Minier du Cameroun", ["code", "minier"]),
|
| 205 |
+
("nominaton", ["nominaton"]),
|
| 206 |
+
("Fonction Publique : statut général", ["fonction", "publique", "statut", "general"]),
|
| 207 |
+
("code code minier", ["code", "minier"]),
|
| 208 |
+
("de la République du Cameroun", []),
|
| 209 |
+
("", []),
|
| 210 |
+
])
|
| 211 |
+
def test_mots_retenus(self, requete, attendus):
|
| 212 |
+
assert mots_significatifs(requete) == attendus
|
| 213 |
+
|
| 214 |
+
|
| 215 |
+
# Loi 300 : titre en « ... de Base au Cameroun », sans rapport avec la requete.
|
| 216 |
+
# Loi 301 : les articles parlent de la peine de mort.
|
| 217 |
+
DECRET_DE_PRET, CODE_PENAL = 300, 301
|
| 218 |
+
|
| 219 |
+
|
| 220 |
+
@pytest.fixture
|
| 221 |
+
async def peine_corpus(db_session, category_ids):
|
| 222 |
+
from sqlalchemy import text as sql_text
|
| 223 |
+
|
| 224 |
+
db_session.add_all([
|
| 225 |
+
Law(
|
| 226 |
+
id=DECRET_DE_PRET, reference="PRC-10703",
|
| 227 |
+
# Titre reel du corpus : word_similarity avec la requete entiere,
|
| 228 |
+
# 0,516, au-dessus du seuil de 0,5.
|
| 229 |
+
title=("Décret N°2026/176 du 4 mai 2026 ratifiant l'Accord de Prêt pour le "
|
| 230 |
+
"financement du Projet d'Appui à l'Education de Base au Cameroun (PAEBC)"),
|
| 231 |
+
content="Est ratifié l'Accord de Prêt conclu entre la République du Cameroun et la Banque.",
|
| 232 |
+
type="décret", language="fr", status="published",
|
| 233 |
+
category_id=category_ids["Fonction Publique"], publication_date=date(2026, 5, 4),
|
| 234 |
+
),
|
| 235 |
+
Law(
|
| 236 |
+
id=CODE_PENAL, reference="LOI-2016-007",
|
| 237 |
+
title="Loi N° 2016/007 du 12 juillet 2016 portant Code Pénal",
|
| 238 |
+
content="Au Cameroun, la peine de mort est exécutée par les armes.",
|
| 239 |
+
type="loi", language="fr", status="published",
|
| 240 |
+
category_id=category_ids[AFFAIRES], publication_date=date(2016, 7, 12),
|
| 241 |
+
),
|
| 242 |
+
])
|
| 243 |
+
await db_session.flush()
|
| 244 |
+
db_session.add(Article(
|
| 245 |
+
law_id=CODE_PENAL, number="22", order=1, kind="article", embed=True,
|
| 246 |
+
content="Au Cameroun, la peine de mort est exécutée par les armes ou par pendaison.",
|
| 247 |
+
))
|
| 248 |
+
await db_session.commit()
|
| 249 |
+
await db_session.execute(sql_text(REINDEX_LAWS_SQL))
|
| 250 |
+
await db_session.execute(sql_text(REINDEX_ARTICLES_SQL))
|
| 251 |
+
await db_session.commit()
|
| 252 |
+
|
| 253 |
+
|
| 254 |
+
class TestPhraseRequest:
|
| 255 |
+
@pytest.mark.asyncio
|
| 256 |
+
async def test_common_words_do_not_make_a_title_match(self, service, peine_corpus):
|
| 257 |
+
"""
|
| 258 |
+
Requete reelle. Comparee d'un bloc, elle passait le seuil sur « de »,
|
| 259 |
+
« au » et « cameroun » : le decret de pret sortait PREMIER, comme
|
| 260 |
+
correspondance de titre, devant le Code penal.
|
| 261 |
+
"""
|
| 262 |
+
results = await service.text_search("peine de mort au cameroun", limit=20)
|
| 263 |
+
|
| 264 |
+
assert results, "aucun resultat"
|
| 265 |
+
assert results[0].law_id == CODE_PENAL
|
| 266 |
+
assert DECRET_DE_PRET not in {r.law_id for r in results}
|
| 267 |
+
|
| 268 |
+
@pytest.mark.asyncio
|
| 269 |
+
async def test_a_typo_in_a_phrase_is_still_caught(self, service, peine_corpus):
|
| 270 |
+
"""Mot par mot, la tolerance aux fautes reste : « penal » mal ecrit."""
|
| 271 |
+
results = await service.text_search("code penall", limit=20)
|
| 272 |
+
|
| 273 |
+
assert results and results[0].law_id == CODE_PENAL
|
| 274 |
+
|
| 275 |
+
|
| 276 |
class TestPerLawCap:
|
| 277 |
@pytest.mark.asyncio
|
| 278 |
async def test_one_law_cannot_take_the_whole_budget(self, db_session, ranking_corpus):
|