feat(utils): ajout d'une fonction searchScore pour calcul de similarité entre 1 recherche et 1 texte, utilisable dans evaluateExpression (pour plugin readcsv notamment)

Author: eyssette

app/js/markdown/custom/variablesDynamic/evaluateExpression.mjs

@@ -1,6 +1,6 @@
 import { config } from "../../../config.mjs";
 import { tryConvertStringToNumber } from "../../../utils/strings.mjs";
-import { mainTopic } from "../../../utils/nlp.mjs";
+import { mainTopic, normalizeText, searchScore } from "../../../utils/nlp.mjs";
 
 // Opérations autorisées pour le calcul des expressions complexes
 const sanitizeCodeAllowedOperations = [
@@ -50,6 +50,9 @@ const sanitizeCodeAllowedOperations = [
 	"tryConvertStringToNumber",
 	"dynamicVariables",
 	"mainTopic",
+	"normalizeText",
+	"searchScore",
+	"boostWords",
 ];
 
 // Regex pour identifier les parties autorisées dans le code
@@ -154,6 +157,8 @@ export function evaluateExpression(expression, dynamicVariables) {
 			"dynamicVariables",
 			"tryConvertStringToNumber",
 			"mainTopic",
+			"normalizeText",
+			"searchScore",
 			"return " + finalExpression,
 		);
 
@@ -165,5 +170,11 @@ export function evaluateExpression(expression, dynamicVariables) {
 		functionCache.set(finalExpression, fn);
 	}
 
-	return fn(dynamicVariables, tryConvertStringToNumber, mainTopic);
+	return fn(
+		dynamicVariables,
+		tryConvertStringToNumber,
+		mainTopic,
+		normalizeText,
+		searchScore,
+	);
 }

app/js/utils/nlp.mjs

@@ -469,6 +469,84 @@ const stopWords = new Set([
 	"peux",
 ]);
 
+function cosineSimilarityTexts(strA, strB, options = {}) {
+	// Calcul de similarité entre deux chaînes de caractères normalisées
+	const strAnormalized = normalizeText(strA);
+	const strBnormalized = normalizeText(strB);
+
+	// Crée les vecteurs pour les deux chaînes de caractères
+	const vectorA = createVector(strAnormalized, options);
+	const vectorB = createVector(strBnormalized, options);
+
+	let result = cosineSimilarity(vectorA, vectorB);
+
+	const boostWords = options.boostWords ? options.boostWords : [];
+	// On booste le score si des mots spécifiques sont présents dans les deux chaînes de caractères
+	// et on booste encore plus le score si plusieurs mots spécifiques sont présents dans les deux chaînes de caractères
+	let countBoostedWords = 0;
+	for (const word of boostWords) {
+		const wordNormalized = normalizeText(word);
+		if (
+			strAnormalized.includes(wordNormalized) &&
+			strBnormalized.includes(wordNormalized)
+		) {
+			countBoostedWords++;
+			result = result + 1; // On booste de 1 par mot trouvé dans les deux chaînes
+			if (countBoostedWords > 1) {
+				result = result + 1 * (countBoostedWords - 1); // On booste encore plus si plusieurs mots sont trouvés
+			}
+		}
+	}
+
+	// Calcule la similarité cosinus entre les deux vecteurs
+	return result;
+}
+
+function getImportantWords(str) {
+	if (!str || typeof str !== "string") return [];
+	// On supprime les stopwords et les caractères spéciaux
+	const words = str
+		.replace(/[.,!?'’;:]/g, " ")
+		.split(/\s+/)
+		.filter((word) => word && !stopWords.has(word.toLowerCase()));
+	return words;
+}
+
+export function searchScore(baseText, searchText, options = {}) {
+	// Fonction de recherche fondée sur la similarité cosinus et qui prend en compte les mots importants à trouver
+
+	// Récupère les mots importants dans le texte de recherche
+	const importantWords = getImportantWords(searchText);
+	const importantWordCount = importantWords.length;
+	// Ajoute les mots importants à l'option de boostWords pour le calcul de similarité
+	if (!options.boostWords) {
+		options.boostWords = [];
+	}
+	options.boostWords = options.boostWords.concat(importantWords);
+
+	// Calcule la similarité cosinus entre les deux textes
+	let cosineSim = cosineSimilarityTexts(baseText, searchText, options);
+
+	// On réduit le score s'il y avait plusieurs mots spécifiques à trouver et qu'on ne les a pas tous trouvés
+	if (importantWordCount > 1 && options.strictMode) {
+		let foundImportantWordCount = 0;
+		for (const word of importantWords) {
+			const wordNormalized = normalizeText(word);
+			if (normalizeText(baseText).includes(wordNormalized)) {
+				foundImportantWordCount++;
+			}
+		}
+		if (foundImportantWordCount < importantWordCount) {
+			const missingWords = importantWordCount - foundImportantWordCount;
+			const penaltyPerMissingWord = 2.75;
+			const totalPenalty = missingWords * penaltyPerMissingWord;
+			cosineSim = Math.max(0, cosineSim - totalPenalty);
+		}
+	}
+
+	return cosineSim;
+}
+
 export function mainTopic(str, specificExpressionsToRemove = []) {
 	// Extrait le sujet principal d'une chaîne de caractères qui représente une courte phrase
 	if (!str || typeof str !== "string") return "";

app/script.min.js

@@ -10,6 +10,7 @@ import {
 	createVector,
 	cosineSimilarityTextVector,
 	mainTopic,
+	searchScore,
 } from "../../../app/js/utils/nlp.mjs";
 
 describe("longestCommonSubstringWeightedLength", function () {
@@ -623,3 +624,81 @@ describe("mainTopic", function () {
 		expect(result).toBe("impacts changement climatique biodiversité marine");
 	});
 });
+
+describe("searchScore", function () {
+	it("returns a high score when all important words are present", function () {
+		const text = "Le chat est sur le tapis rouge.";
+		const scoreTextWithOneImportantWord = searchScore(text, "chat");
+		expect(scoreTextWithOneImportantWord).toBeGreaterThanOrEqual(1);
+		const scoreTextWithTwoImportantWords = searchScore(text, "chat tapis");
+		expect(scoreTextWithTwoImportantWords).toBeGreaterThanOrEqual(1);
+		const scoreTextWithThreeImportantWords = searchScore(
+			text,
+			"chat tapis rouge",
+		);
+		expect(scoreTextWithThreeImportantWords).toBeGreaterThanOrEqual(1);
+	});
+	it("returns a higher score when all important words are present and the number of important words increases", function () {
+		const text = "Le chat est sur le tapis rouge.";
+		const scoreTextWithOneImportantWord = searchScore(text, "chat");
+		const scoreTextWithTwoImportantWords = searchScore(text, "chat tapis");
+		const scoreTextWithThreeImportantWords = searchScore(
+			text,
+			"chat tapis rouge",
+		);
+		expect(scoreTextWithTwoImportantWords).toBeGreaterThan(
+			scoreTextWithOneImportantWord,
+		);
+		expect(scoreTextWithThreeImportantWords).toBeGreaterThan(
+			scoreTextWithTwoImportantWords,
+		);
+	});
+
+	it("returns a low score for completely different texts", function () {
+		const text1 = "Le chat est sur le tapis.";
+		const text2 = "La voiture roule vite.";
+		const score = searchScore(text1, text2);
+		expect(score).toBeCloseTo(0, 1);
+	});
+
+	it("returns a lower score in strict mode when important words are missing", function () {
+		const baseText =
+			"Le changement climatique affecte la biodiversité et les écosystèmes.";
+		const searchWithImportantWords = [
+			"changement climatique biodiversité ?",
+			{ strictMode: true },
+		];
+		const searchWithoutImportantWords = [
+			"changement climatique pollution",
+			{ strictMode: true },
+		];
+
+		const scoreWithImportantWords = searchScore(
+			baseText,
+			searchWithImportantWords[0],
+			searchWithImportantWords[1],
+		);
+		const scoreWithoutImportantWords = searchScore(
+			baseText,
+			searchWithoutImportantWords[0],
+			searchWithoutImportantWords[1],
+		);
+
+		expect(scoreWithImportantWords).toBeGreaterThan(scoreWithoutImportantWords);
+		expect(scoreWithoutImportantWords).toBeLessThan(1);
+		expect(scoreWithoutImportantWords).toBeGreaterThan(2 / 3 - 0.1);
+		expect(scoreWithoutImportantWords).toBeLessThan(2 / 3 + 0.1);
+	});
+
+	it("penalizes missing important words in the search text", function () {
+		const baseText =
+			"Les énergies renouvelables sont essentielles pour lutter contre le changement climatique.";
+		const searchTextMissingImportantWords = "Parle-moi des énergies fossiles.";
+
+		const score = searchScore(baseText, searchTextMissingImportantWords);
+
+		// Since "énergies" and "changement climatique" are important words in the base text,
+		// their absence in the search text should lead to a lower score.
+		expect(score).toBeLessThan(20); // Arbitrary threshold for low score
+	});
+});