Discussion :

[Bruno13]

Bonjour à tous,

Toujours dans un soucis de déterminer la langue des pages HTML que je
récolte je voudrais votre avis sur ma méthode qui consiste à mettre dans 2
TStringLists :
- Mes mots vides me permettant de déterminer la langue
(le, la, les, un, une, etc...pour le FR)
(the, these, this, that, ... pour le EN)
etc...Biensur mes listes sont bcp plus longues et comportent aussi certains verbes

- Ma page texte à analyzer.
J'ai fait un Split(maPageText, ' ', maStringListResultante)
De cette maniere j'ai tous les mots dans maStringListResultante


Ensuite je fais un InterSecStringList(A, B) qui me renvoie un integer
Mon IntersecList est juste 2 boucles imbriquées (pour l'instant) qui compte
l'occurrence des mots communs


Pourrais-je savoir comment vous auriez fait vous car:
- j'obtiens un résultat sur 500 doc = 370 ok, et le reste KO !
Pourtant les textes sont faciles à analyser et ont été convertir en texte sans balise.
- j'utilise des TstringList mais je ne suis pas fixé sur ce choix

Je suis sûr qu'il doit y avoir moulte façon de faire mais j'aimerai avoir vos avis !
De plus le nombre de mots vides ou de ma page n'a-t-il pas une influence sur le résultat ?

Pour l'instant j'incrémente un entier à chaque fois que je rencontre un mot
vide mais jamais je ne tiens compte de la longueur des 2 fichiers (mots vides
et mon texte)


Merci pour vos conseils et algo à l'occaz :o)

Amicalement,
Bruno

[Gilbert Geyer]

Si le seul objectif est de déterminer la langue de pages de texte de diverses laangues j'opterais pour le scénario suivant :
- pour chaque langue : une stringList-de-mots-identificateurs-de-langue(ceux que tu appelles mots-vides) :
slFR avec 'le','la','les',...,etc.
slEN avec 'the','these','this', ... etc.
slGE avec 'der','die','das', ... etc. ... et ces StringList je les classerais dans l'ordre alpha.

- et une StringListTexteAAusculter;
- et une StringListMotsDuTexteAAusculter alimentée à partir de la précédente avec des LowerCase(mot-extrait-de-chaque-ligne-texte) ... et cette dernière StringList étant alimentée mot par mot je la classerais également dans l'ordre alpha avec tout bêtement les déclarations préalables des propriétés
StringListMotsDuTexteAAusculter.Sorted:=True; et StringListMotsDuTexteAAusculter.Duplicates:=DupIgnore de sorte que le Add n'y ajoute aucun doublon ce qui va aussi raccourcir la longueur de cette liste ce qui est utile pour la suite.

Ensuite dans une boucle de recherche avec IndexOf(string) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
          Francais:=0;  Anglais:= 0; Allemand:=0; Mixte:=0; etc.
          i:=-1;
          Repeat inc(i);
                    motDuTexte := StringListMotsDuTexteAAusculter[i]  
                    if ( slFR.IndexOf( motDuTexte )>=0 ) then  inc(Francais) else
                    if ( slEN.IndexOf( motDuTexte )>=0 ) then  inc(Anglais)   else
                    if ( slGE.IndexOf( motDuTexte )>=0 ) then  inc(Allemand);
          Until (i = StringListMotsDuTexteAAusculter.count-1)
                 or (Francais=10) or (Anglais=10) or (Allemand=10); //< il faudrait avec des tests voir s'il faut augmenter ou réduire ce 10.
         If (Francais>0) and (Anglais>0) 
         or (Francais>0) and (Allemand>0) 
         or (Anglais>0)   and (Allemand>0) then inc(Mixte);

Avec Sorted = True et la suppression préalable des doublons la rapidité des recherches d'identification est optimale.

De plus le nombre de mots vides ou de ma page n'a-t-il pas une influence sur le résultat ?

... ben si forcément, car si les listes des mots vides ne contenaient que quelques mots non utilisés dans le texte à ausculter la langue utilisée ne serait pas identifiable mais avec des mots du style "le", "la", "les" tu peux être tranquille c'est comme si tu voulais compter les "begin" dans un code-Delphi.

jamais je ne tiens compte de la longueur des 2 fichiers (mots vides
et mon texte)

... rassure toi avec la boucle et le if ( slFR.IndexOf( motDuTexte )>=0 ) ) qui cherche jusqu'à la fin de la liste des mots vides c'est réglé ... si t'as la moindre inquiétude tu peux aussi quitter la boucle uniquement avec Until (i = StringListMotsDuTexteAAusculter.count-1) car le "or (Francais=10) or (Anglais=10) or (Allemand=10)" c'est juste pour augmenter la vitesse d'exécution.

[Bruno13]

Bonjour Gilbert,

Tout d'abord merci pour tous ces renseignements mais j'ai une petite contrainte supplémentaire c'est que je veux que mon programme soit modulaire. C'est à dire que l'utilisateur puisse ajouter des fichiers de mots vides d'autres langues. De cette manière en nommant par exemple deutch.stw (stw = stopwords) j'aurais simplement ajouté une nouvelle langue.

Cela dit je peux trés bien m'aider de ce que tu me proposes, mais si quelqu'un vois une autre idée, même sans StringList je suis preneur.

Amicalement,
Bruno

[Gilbert Geyer]

Salut Bruno,

"je veux que ... l'utilisateur puisse ajouter des fichiers de mots vides d'autres langues. De cette manière en nommant par exemple deutch.stw (stw = stopwords) j'aurais simplement ajouté une nouvelle langue" :

Cela change la donne initiale. Mais si le nombre de listes-de-mots-vides est variable il faut carrément remplacer les déclarations de variables slFR (avec 'le','la','les',...,etc) slEN (avec 'the','these','this', ... etc.) et slGE (avec 'der','die','das', ... etc.) par une variable globale par exemple du type array of tStringList c.à.d un tableau dynamique que lon charge au lancement du logiciel avec les fichiers nommés langueX.stw qui sont présents sur le disque ( je suppose que tu livres au début au moins deux à trois langues pour amorcer la pompe et l'utilisateur les enrichit ensuite avec n'importe quel dialecte) :

var ListesDeMotsVides : array of tStringList; //< tableau dynamique
et var LangueDetectee : array of integer; ; //< idem

... dans un premier temps on remplit par exemple une listBoxNomsFichiersSTW avec les noms des fichiers dont l'extension est .stw (si tu veux une routine pour ça dis-le).

... ensuite on dimensionne le tableau dynamique avec setLength(ListesDeMotsVides, listBoxNomsFichiersSTW.count) et idem pour le deuxième tableau : setLength(LangueDetectee, listBoxNomsFichiersSTW.count)

... ensuite on charge les fichiers : for j:=0 to listBoxNomsFichiersSTW.count-1 do ListesDeMotsVides[j].loadFromFile(listBoxNomsFichiersSTW.Items[j];
A ce stade on sait que la liste ListesDeMotsVides[j] est par exemple l'anglais si le nom du fichier correspondant de même indice dans la ListBoxNomsFichiersSTW[j] est par exemple anglais.stw et dans ce cas il faut modifier le code de l'autre jour :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if ( slFR.IndexOf( motDuTexte )>=0 ) then  inc(Francais) else
                    if ( slEN.IndexOf( motDuTexte )>=0 ) then  inc(Anglais)   else
                    if ( slGE.IndexOf( motDuTexte )>=0 ) then  inc(Allemand);

par nouveau code de recherche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
          for j:=0 to High(LangueDetectee) do LangueDetectee[j]:=0; 
          i:=-1; stop:=false; // boolean, i, et j à déclarer au préalable
          Repeat inc(i);
                    motDuTexte := StringListMotsDuTexteAAusculter[i];
                    for j:=0 to High(ListesDeMotsVides) 
                    do if ListesDeMotsVides[j].IndexOf( motDuTexte )>=0 
                        then inc(LangueDetectee[j]);

                    for j:=0 to High(LangueDetectee) 
                    do if LangueDetectee[j]>10 then //< il faudrait avec des tests voir s'il faut augmenter ou réduire ce 10.
                        begin showMessage('Langue détectée = ' + listBoxNomsFichiersSTW.Items[j];
                                Stop:=true;
                        end;                    
          Until (i = StringListMotsDuTexteAAusculter.count-1) or Stop;

... Ensuite pour permettre à l'utilisateur d'ajouter des fichiers de mots vides d'autres langues le plus simple est de lui prévoir un bouton "CréerListeMotsVidesAutreLangue" où un click ouvre :
- d'abord un inputBox où l'on récupère le nom de la langue : NomDeLaLangue:= InputBox('Créer une liste de mots vides ', Donner le nom de la langue, ''); ... (on ajoutera par la suite à ce nom l'extesion .stw pour la sauvegarde sur disque)
- et ensuite un Memo1 dans lequel il pourra taper et naviguer dans sa liste-de-mots-vides
- plus un bouton "Sauver sur disque" qui déclenche un memo1.Lines.SaveToFile(ExtractFilePath(Application.ExeName)+NomDeLaLangue+'.stw');

Voiçi donc pour ce qui est du scénario pour coder ... tu peux remarquer que la partie "permettre à l'utilisateur d'ajouter des fichiers de mots vides d'autres langues" est relativement simple vu que toute la partie du début du présent message n'est que la modification du code de l'autre jour.

Si ce scénario te convient on pourra passer aux fignolages un autre jour.

A+
P.S du 12 juin : Remplacé l'indice "k" qui est évidemment "j" en orange dans le code.

[Bruno13]

Comment dire,

UN GRAND MERCI !!!

Je vais coder tout cela à partir de maintenant et revenir sur le forum pour donner les résultats dans ce message. Je cliquerai ensuite sur le bouton RESOLU grâce à toi !

[Gilbert Geyer]

A Bruno :

Y'aura quelques fignolages a apporter par la suite pour faire un truc clean. Exemples :
- pour l'instant le showMessage renvoie comme langue détectée le nom complet du fichier dans le style c:\MonRepertoire\Anglais.stw on pourra en extraire Anglais tout court,
- ajouter une fonction "ModifierTelFichierDeMotsVides" pour rallonger ou raccourcir un fichier (c'est peut-être pas utile que ces fichiers soient trop longs) car plus ces fichiers sont longs et nombreux plus les temps d'exécution vont augmenter.

A+

[Bruno13]

Salut Gilbert,

Comme mon programme n'est pas basé sur uniquement la detection de la ngue des fichiers que je traite, il faut tout d'abord que je trouve la meilleur solution pour charger les langues et libérer le tout lorsque je ne m'en sers plus.

Mais bon ca c'est pas grand chose à faire.

Au passage, on m'a aussi parlé de la methode par recherche "bigramme" ou "trigramme" qui est bcp plus puissante et rapide (99% de résultats positifs)

[Gilbert Geyer]

A Bruno,

"il faut tout d'abord que je trouve la meilleur solution pour charger les langues et libérer le tout lorsque je ne m'en sers plus" :

1) pour charger on a fait : for j:=0 to listBoxNomsFichiersSTW.count-1 do ListesDeMotsVides[j].loadFromFile(listBoxNomsFichiersSTW.Items[j];

2) pour libérer c'est pas plus compliqué : for j:=0 to listBoxNomsFichiersSTW.count-1 do ListesDeMotsVides[j].free ... suivi par listBoxNomsFichiersSTW.Items.Free

"methode par recherche "bigramme" ou "trigramme" qui est bcp plus puissante et rapide (99% de résultats positifs)" : connais pas, mais on peut chercher sur le net.

[Bruno13]

1) pour charger on a fait : for j:=0 to listBoxNomsFichiersSTW.count-1 do ListesDeMotsVides[j].loadFromFile(listBoxNomsFichiersSTW.Items[j]);

Voilà ça c'est ok !

2) pour libérer c'est pas plus compliqué : for j:=0 to listBoxNomsFichiersSTW.count-1 do ListesDeMotsVides[j].free ... suivi par listBoxNomsFichiersSTW.Items.Free

ok, c'est ce que j'ai fait

"methode par recherche "bigramme" ou "trigramme" qui est bcp plus puissante et rapide (99% de résultats positifs)" : connais pas, mais on peut chercher sur le net.

Oui biensûr ! Mais comme je suis quasiment à la fin j'ai hate de faire des essaies grandeur nature avec plus de 1000 fichiers.

Je te tiens au courant dans quelques minutes sur ce messages !

Amitiés,
Bruno

[Gilbert Geyer]

Sous Google avec bigramme trigramme : 2 pages de réponses à fouiner.
A+

[Bruno13]

Salut Gilbert,

Voilà j'ai fait les tests avec ton explication et le résultat est plus que correct, seul petit hic, le temps il faut compter env. 1s de moyenne par page à analyser pour 7 langues. Mes essais sont avec des corpus de 1000 pages variant de 3Ko à 50ko.

J'ai de tres bons resultats cependant, et donc je peux dire que je suis pleinement satisfait de ce que tu m'as proposé. Encore mille merci, je vais maintenant essayer d'optimiser l'algo car il faut au moins que je tombe à 0,5s / page

Encore merci pour ton aide, les prochaines étapes sont :
- suppression de mots vides
- lématisation du texte (revenir à la racine du mot ou du verbe)
- Et faire quelques stats

le tout pour essayer d'en sortir un theme ou du moins des indices de lecture pour l'utilisateur.


Mais ceci fera l'affaire d'un ou deux messages dans le forums !

Amitiés,
Bruno

[Gilbert Geyer]

Salut Bruno,

Content que cela marche bien.

1) "corpus de 1000 pages variant de 3Ko à 50ko" : je suppose que chaque page fait 3Ko à 50 Ko sinon 50*1024/1000 = 51 octets-max/page.


2) Optimiser l'algo suivant pour des gains de vitesse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Version 1s de moyenne par page à analyser pour 7 langues et essais avec des 
corpus de 1000 pages variant de 3Ko à 50ko : 
          for j:=0 to High(LangueDetectee) do LangueDetectee[j]:=0; 
          i:=-1; stop:=false; 
          Repeat inc(i);
                    motDuTexte := StringListMotsDuTexteAAusculter[i];
                    for j:=0 to High(ListesDeMotsVides) 
                    do if ListesDeMotsVides[j].IndexOf( motDuTexte )>=0 
                        then inc(LangueDetectee[j]);
 
                    for j:=0 to High(LangueDetectee) 
                    do if LangueDetectee[j]>10 then //< il faudrait avec des tests voir s'il faut augmenter ou réduire ce 10.
                        begin showMessage('Langue détectée = ' + listBoxNomsFichiersSTW.Items[j];
                                Stop:=true;
                        end;                    
          Until (i = StringListMotsDuTexteAAusculter.count-1) or Stop;

... Optimisation : comme la dans le code ci-dessus la boucle for j:=0 to High(LangueDetectee) est sollicitée un nombre superflu de fois égal au produit du nombre-de-MotsDuTexteAAusculter*Nombre-de-LangueDetectee on peut déjà commencer par tester le gain apporté en n'effectuant le test if LangueDetectee[j]>10 que dans les cas où l'on inc(LangueDetectee[j]); ce qui donne le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
          for j:=0 to High(LangueDetectee) do LangueDetectee[j]:=0; 
          i:=-1; stop:=false; 
          Repeat inc(i);
                    motDuTexte := StringListMotsDuTexteAAusculter[i];
                    for j:=0 to High(ListesDeMotsVides) 
                    do if ListesDeMotsVides[j].IndexOf( motDuTexte )>=0 then
                        begin inc(LangueDetectee[j]);
                              if LangueDetectee[j]>10 then //< il faudrait avec des tests voir s'il faut augmenter ou réduire ce 10.
                              begin showMessage('Langue détectée = ' + listBoxNomsFichiersSTW.Items[j];
                                    Stop:=true;
                              end;
                         end;                    
          Until (i = StringListMotsDuTexteAAusculter.count-1) or Stop;

3) Au fait, lors des tests, pour obtenir des résultats fiables d'identification de langue, quelle a été la valeur par laquelle tu as éventuellement remplacé le '10' du if LangueDetectee[j]>10 ? Simple curiosité intellectuelle.

4) Suggestion : On pourrait, vu que l'objectif est de sortir des "indices de lecture pour l'utilisateur" par exemple en profiter pour signaler à l'utilisateur qu'il s'agit d'un texte en Allemand avec des citations en Français en ajoutant qq lignes à la suite du Until du code ci-dessus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
         ...................
         Until (i = StringListMotsDuTexteAAusculter.count-1) or Stop;
         if Stop then
         begin sLanguePrincipale:='';
               sLanguesSecondaires:=''; // var sLanguePrincipale, sLanguesSecondaires : string;
               for j:=0 to High(LangueDetectee) do
               begin if LangueDetectee[j]>0 then
                     begin if LangueDetectee[j]>10
                           then sLanguePrincipale:='Langue ppale : '+listBoxNomsFichiersSTW.Items[j]
                           else sLanguesSecondaires:=sLanguesSecondaires+' '+listBoxNomsFichiersSTW.Items[j]
                     end;
               end;
               showMessage(sLanguePrincipale+'(avec citations en'+sLanguesSecondaires+')');
         end;

5) "les prochaines étapes sont ... lématisation du texte (revenir à la racine du mot ou du verbe)" : Ben chapeau ! et de surcroît en 7 langues ! Y'a du pain sur la planche dis-donc !.

6) "sortir un theme ou du moins des indices de lecture pour l'utilisateur" : Nécessite d'éliminer le "bruit-de-fond" qui consitue, pour chaque langue, une liste complémentaire formée par la réunion des "mots-vides-d'identification-de-langue" et des "mots-de-bruit-de-fond". Il est préférable que les listes de "mots-vides-d'identification-de-langue" soient aussi courtes que possible pour la vitesse d'identification et de reléguer les autres mots-vides dans la liste du bruit de fond.

A+

[Bruno13]

Salut Gilbert,

Voici ce que j'utilise : snowboard comme mot clé et 1000 réponses sur Google

Bien, bien bien, alors tout d'abord je vais répondre à ta question numéro 3 qui est :

3) Au fait, lors des tests, pour obtenir des résultats fiables d'identification de langue, quelle a été la valeur par laquelle tu as éventuellement remplacé le '10' du if LangueDetectee[j]>10 ? Simple curiosité intellectuelle.

Tu peux voir que plus l'indice augmente plus le language Unknown augmente. En fait quand je regarde les pages ce sont des pages qui contiennent des descriptions d'articles de sport sans avoir beaucoup de texte.

Ensuite :
Pour l'optimisation, hélas pas de gain significatif, je suppose que l'indexOf prend du temps.

4) Suggestion : On pourrait, vu que l'objectif est de sortir des "indices de lecture pour l'utilisateur" par exemple en profiter pour signaler à l'utilisateur qu'il s'agit d'un texte en Allemand avec des citations en Français en ajoutant qq lignes à la suite du Until du code ci-dessus

En fait je n'en ai pas vraiment l'utilité car je propose à l'utilisation de changer la langue manuellement en affichant la liste des langues disponibles.

5) "les prochaines étapes sont ... lématisation du texte (revenir à la racine du mot ou du verbe)" : Ben chapeau ! et de surcroît en 7 langues ! Y'a du pain sur la planche dis-donc !.

En fait avec les 7 fichiers de langue des Mots Vides, j'ai aussi un dictionnaire de correspondance pour la lématisation. Cela fonctionnera grâce à des FastReplace (librairie trouvée sur le net, si tu veux le lien). J'avoue que je ne sais pas trop ce que cela va donner, je tatonne en ce moment.

6) "sortir un theme ou du moins des indices de lecture pour l'utilisateur" : Nécessite d'éliminer le "bruit-de-fond" qui consitue, pour chaque langue, une liste complémentaire formée par la réunion des "mots-vides-d'identification-de-langue" et des "mots-de-bruit-de-fond". Il est préférable que les listes de "mots-vides-d'identification-de-langue" soient aussi courtes que possible pour la vitesse d'identification et de reléguer les autres mots-vides dans la liste du bruit de fond.

Exactement cela ne va vraiment pas être facile mais j'aime bien le challenge ! Et puis mon soft (http://www.matheo-web.com) se doit de proposer de l'aide à la lecture, du clustering et autres fonctions (cartographie, résumé, ...)

Biensûr tes idées sont les bienvenues !
Encore mille merci pour le temps que tu prends pour écrire ces messages qui sont vraiment soignés et surtout bien détaillés.

Amitiés,
Bruno

[Gilbert Geyer]

Re-Salut,

1) "plus l'indice augmente plus le language Unknown augmente" : Vu, en plus avec Indice=10 le piffomètre n'a pas trop visé à côté.

2) C'est joli tes copies d'écran ... c'est du Win-XP ou du skinné ?

3) J'en profite pour te demander comment t'as fait pour insérer les copies d'écran dans ton message ... car une bonne image c'est souvant plus parlant que de longues explications.

4) "Pour l'optimisation, hélas pas de gain significatif, je suppose que l'indexOf prend du temps" : Ben, on compare, pour chaque texte, N-mots-de-texte à (7 fois P-mots-vides) après avoir en principe, éliminé les doublons et basculé les StringList sur Sorted = true ... mais cela vaut le coup de vérifier dans ton code car si ce n'est pas le cas y'aura du gain de temps.

Pour vérifier : la règle est simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
TStringList.Sorted = True  donne recherches rapides, et insertions lentes 
                            ( indexOf = recherche)
TStringList.Sorted = False donne insertions rapides  , et recherches lentes.
                            ( insertion = tout mode d''ajout de chaînes dans la StringList et pas seulement Insert, il ya Add et LoadFrom)
Et pour avoir la vitesse optimale lors de l''insertion et lors de la recherche
il suffit de basculer de False sur True ou l''inverse avant la manip visée

... au lieu de vérifier ceci rien n'interdirait de rajouter carrément, devant la boucle Repeat inc(i), deux boucles où l'on bascule toutes les strinList sur Sorted = True.

Suite sur message suivant.

[Gilbert Geyer]

Re-Re-Salut,

4-Suite) Optimisation : En supposant que Sorted est déjà à True avant d'entrer dans la boucle des recherches-de-comparaison il reste la possibilité de réduire au strict minimum-utile le contenu des listes-de-mots-vides. Exemple 'lesquels' est un mot-vide de deuxième ordre comparativement à 'le' 'la' 'les' ... et les mots-vides-de-deuxième-ordre relèvent davantage de la liste des mot-de-bruit-de-fond.

5) "dictionnaire de correspondance pour la lématisation. Cela fonctionnera grâce à des FastReplace (librairie trouvée sur le net, si tu veux le lien)" : Ben-oui, passes donc ce lien.

6) "Et puis mon soft (http://www.matheo-web.com) se doit de proposer de l'aide à la lecture ..." : Vu ton site ... pas mal !
Mais à propos d'aide à la lecture ce serait pas mal de traduire ton site en Français ça aiderait bien.
Pour ce qui est du soft je l'ai téléchargé par curiosité, mais ne fonctionnera peut-être pas sous Win-98.

A+

[Bruno13]

Salut Gilbert,

Voici déjà le lien pour FastStrings : http://www.droopyeyes.com
Vraiment trés rapide les fonctions sur les chaines de caractères.

Pour mon soft, oui il fonctionne sous Win98 donc tu pourras le tester et d'ailleurs
me dire ce que tu en penses. Si tu veux je peux même te faire une clé temporaire pour avoir toutes les fonctionnalités actives. Ecrit moi sur mon PM si tu veux une clé.

1) "plus l'indice augmente plus le language Unknown augmente" : Vu, en plus avec Indice=10 le piffomètre n'a pas trop visé à côté.

Exacte, t'as visé juste

2) C'est joli tes copies d'écran ... c'est du Win-XP ou du skinné ?

Skinné avec http://www.link-rank.com

3) J'en profite pour te demander comment t'as fait pour insérer les copies d'écran dans ton message ... car une bonne image c'est souvant plus parlant que de longues explications.

Ben en fait j'ai mis l'image sur le serveur de la société.

Pour les listes triées, je n'ai pas encore eu le temps, d'ailleurs pour les 3 heures qui suivent je ne serais pas devant mon ordi. Donc suite au prochain message...

[Gilbert Geyer]

Re-Salut,

1) Merci pour le lien pour FastStrings et vers l'outil pour skinner.

2) Clé temporaire : A voir éventuellement dans un deuxième temps.

3) "Exact, t'as visé juste" : En fait mon piffomètre était guidé par le vague souvenir de ce qui suit, et que pensais ne pas avoir conservé, mais qui résulte d'un comptage d'occurences, classé dans l'ordre décroissant, du vocabulaire utilisé par un truc qui ressemble à une base de recettes dont le contenu équivaut à un classeur de 500 pages A4 imprimées recto-verso en taille 9 et je n'ai compté que la fréquence d'apparition des mots de 4 caractères et plus. (avec des à a le la les j'aurais envahi la stringList) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
Fréquence	 Vocabulaire
 2514 	 pour
 1757 	 dans
 1451 	 être
 ... // les ... correspondent aux emplacements occupés par des mots spécifiques au domaine des "recettes" c.à.d similaires au mot "sel" de recettes de cuisine.
  651 	 avec
  ...
  611 	 doit
  578 	 soit
  ...
  536 	 cette
  ...
  507 	 faire
  505 	 chaque
  ...
  467 	 devra
  466 	 sont
  ...
  458 	 plus
  ...
  436 	 toute
  ..
  394 	 leur
  ..
  361 	 lors
  360 	 avant
  ...
  351 	 moins
  345 	 tout
  ...
  334 	 entre
  ...
  ...
  322 	 afin
  ...
  314 	 sera
  ...
  299 	 contre
  ...
  282 	 sous
  ...
  270 	 doivent
  ...
  263 	 deux
  ...
  ...

A+

[Gilbert Geyer]

Bonjour,

Au fait, à propos d'optimiser les gains de vitesse :

Lors de la modif introduite pour permettre à l'utilisateur de créer ses propres listes-de-mots-vides, on a introduit un certain nombre de modifs sans remettre en cause l'état d'esprit initial relatif au chargement des textes-à-ausculter c'est à dire avec tout bêtement les déclarations préalables des propriétés StringListMotsDuTexteAAusculter.Sorted:=True; et StringListMotsDuTexteAAusculter.Duplicates:=DupIgnore afin d'obtenir simultanément le tri et l'élimination des doublons lors du chargement par un loadFromFile() avec les conséquences suivantes :
- loadFromFile insère dans la StringList une ligne après l'autre et pour chaque ligne il commence par faire de la recherche-de-comparaison de chaines pour savoir s'il y a doublon sinon à quel indice de ligne il doit insérer la nouvelle ligne dans l'ordre-Alpha-du-tri et s'il doit insérer une ligne il doit décaler toutes les autres lignes qui suivent d'un cran.
- or vu que True donne des recherches rapides, et des insertions lentes on ne bénéficie de la rapidité que dans le cas de doublons sinon on hérite de la lenteur des insertions qui elles sont nombreuses vu que les StringListMotsDuTexteAAusculter sont nettement plus longues que les listes-de-mots-vides
... d'où la suggestion suivante de faire un chargement en mode rapide des StringListMotsDuTexteAAusculter avec Sorted:=False (= ajouts rapides en fin de liste) suivie d'un tri avec Sort suivi d'une boucle d'élimination des doublons suivi d'un basculement sur Sorted:=True avant d'attaquer la boucle repeat qui inclut le if ListesDeMotsVides[j].IndexOf() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
               //Phase de chargement-traitement-préalable de StringListMotsDuTexteAAusculter
                var i, j : integer;
                .... 
                with StringListMotsDuTexteAAusculter do
                begin Clear;
                        Sorted:=FALSE;  // insertion immédiate en fin de liste  
                        LoadFromFile( NomLongFichier);
                        Sort; // tri-Alpha
                end;
                //Boucle de supression des doublons :
                Sorted:=TRUE; 
                i := StringListMotsDuTexteAAusculter.count - 1;
                repeat j:=i-1;
                         if StringListMotsDuTexteAAusculter [i]=StringListMotsDuTexteAAusculter[j] 
                         then StringListMotsDuTexteAAusculter.delete(i);
                         dec(i);
                until i=0;
                ........
                //Suite inchangée :
               for j:=0 to High(LangueDetectee) do LangueDetectee[j]:=0; 
               i:=-1; stop:=false; 
               Repeat inc(i);
               ........

... excuses, j'avais complètement oublié qu'on était dans un cas similaire à un autre où la parade ci-dessus a permis de multiplier par 71 la vitesse globale à la différence près que dans le cas en question ce facteur de 71 résultait en plus du fait que la parade a en même temps permis d'éviter le recours à un if IndexOf(s) donc dans le cas présent le facteur d'accélération sera inférieur à 71 mais cela vaut le coup de faire l'essai.
A+

[Bruno13]

Salut Gilbert,

he ben si tout le monde pouvez m'aider comme ça

Je fais l'essai tout de suite et je te fais un retour dans le message suivant !

Merci bcp!

[Bruno13]

Alors cela va bcp plus vite mais hélas j'ai parfois un indice hors limite pour

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
                i := StringListMotsDuTexteAAusculter.count - 1;
                repeat j:=i-1;
                         if StringListMotsDuTexteAAusculter [i]=StringListMotsDuTexteAAusculter[j] 
                         then StringListMotsDuTexteAAusculter.delete(i);
                         dec(i);
                until i=0;

et le resultat bizarrement me fait tripler le Unknown, je refais un essai...