Discussion :

[Bruno13]

Bonjour à tous,

Est-ce que quelqu'un aurait sous la main une petite fonction qui me permette de sortir de ma TStringList qui contient des mots, un tableau avec les frequences de chaques mots ?

Je suis sûr que quelqu'un à déjà fait cela, alors plutôt que de redevelopper la roue...

D'avance merci pour votre aide
Bruno

[Clorish]

j'eu eu fut un temps une tite fonction qui splite une chaine a partir de separateurs .... masi bon c'ets pas la mer a boire non plus.

Boucle for qui parcours les caracteres, et les concatene a une chaine. Sur detection du caractere de separation, stocker la chaine et la reinitialiser a ''.

Apres un TStringList devrais faire l'affaire : Si le mot n'ets pas present, alors l'ajouter et compter "1" sinon incrementer la variable "compteur".
Cette variable peut etre la property "datas" des TStringList ...

[ShaiLeTroll]

Je ne l'ai pas pour TStringList mais Array of Byte, l'esprit est le même pour une chaine, je vais la transformer ... mais avec une TStringList, un Sorted devrait pour aider à faire un algo très simple

[Bruno13]

Salut Clorish et Le vilain Troll

Merci pour vos conseils, je vais essayer de traduire ma TStringList en Array
mais bon je connais pas trop donc je vais prendre mon temps, sinon si y'a d'autres methodes je suis preneur !

Amitiés,
Bruno

[Gilbert Geyer]

Salut Bruno, Clorish et ShailLeTroll,

Bruno : J'allais justement te faire un message car t'avais mis un peu vite le tag résolu pour l'autre discussion. Comme le thème des stopWords m'intéresse j'ai continué en regroupant les StopWords des 7 langues dans un fichier sur lequel j'ai utilisé mon compteur de fréquences d'occurences histoire de vérifier s'il n'y a pas des redites entre une liste *.stw et toutes les autres.
Eh ben il y'en-a une foultitude !
- y'en a deux mots (la et en) qui apparaissent dans 4 listes
- 5 qui apparaissent dans 3 listes
- et une file de presque deux pages d'écran qui apparaissent dans 2 listes.
Donc pour distinguer des langues c'est pas fameux.

Alors si ça t'intéresse je peux t'envoyer le fichier .doc qui regroupe tout cela et qui contient A) la liste des mots de fréquence > 1 qui sont à supprimer et B) la liste des mots de fréquence = 1 où j'ai repéré les mots des autres langues qui existent dans un dico français car pour pour distinguer clairement les langues il faut également virer ce type de redondance.

Je peux aussi te passer l'unit uVoc qui fait partie d'une de mes applis qui prend un fichier pour en compter les occurences du vocabulaire et qui sort le résultat d'abord dans deux comboBox (l'une avec les fréquences à gauche et le mot à droite, et l'inverse dans la deuxième) avec possibilité de sauver l'une et/ou l'autre sur disque.

Sauf que tout cela dépasse le quota de *.Zips dont j'ai droit sur le forum ...donc si ça t'intéresse il faudra que te l'envoie par e-mail.

A+

[anapurna]

salut

pourquoi ne pas le faire directement lors de l'importation dans ta tstringlist

il existe une methode interessante qui s'appelle addobject

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
TmysStringFreq = Classe
   nom : String;
   Frq  : integer;
   Constructor Create(Aname: string);
 end;
...
TmyForm = Class(Tform)
...
Private
 MyStringList : TstringList;
Procedure AjouteFrequence(Libelle : String);
end;
 
...
Constructor TmysStringFreq.Create(Aname: string);
begin 
  nom := Aname;
  Frq := 1;
end;
...
Procedure TmyForm.AjouteFrequence(Libelle : String);
begin  
  pos := MyStringList.Items.IndexOf(Libelle);
  if pos = -1 Then // L'item nxiste pas 
    MyStringList.Items.AddObject(Libelle,TmysStringFreq.Create(Libelle))
  else 
    (MyStringList.Object[pos] as TmysStringFreq).Frq :=   (MyStringList.Object[pos]as TmysStringFreq).Frq+1;
end;
...

@+ Phil

[ShaiLeTroll]

Bon, voici un deux version d'une fonction qui Compte la Fréquence pour chaque ligne de Source et met le résultat en texte dans Frequencies, on pourrait directement exploité Orderer, si l'on souhaite pas d'affichage mais effectué des calculs ... j'ai essayé un algo avec le CustomSort pour ne faire qu'un balayage via QuickSort mais pas concluant, la version surcharge est plus performante puis qu'il n'y plus qu'un seul parcours de la liste et non pas trois ...

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
48
49
procedure GetFrequencyWord(Source, Frequencies: TStrings);
var
  Orderer: TStringList;
  I, K: Integer;
  S: string;
begin
  if Assigned(Source) and Assigned(Frequencies) then
  begin
    if Source.Count > 1 then
    begin
       Orderer := TStringList.Create();
       try
         Orderer.Capacity := Source.Capacity;
         Orderer.AddStrings(Source);
         Orderer.Sort();
         K := 0;
         S := Orderer.Strings[K];
         Orderer.Objects[K] := Pointer(1);
         for I := 1 to Orderer.Count - 1 do
         begin
           if S = Orderer.Strings[I] then
           begin
             Orderer.Objects[K] := Pointer(Cardinal(Orderer.Objects[K]) + 1);
           end else
           begin
             K := I;
             Orderer.Objects[K] := Pointer(1);
             S := Orderer.Strings[K];
           end;
         end;
 
         Frequencies.BeginUpdate();
         Frequencies.Clear();
         Frequencies.Capacity := Orderer.Capacity;
         for I := 0 to Orderer.Count - 1 do
           if Cardinal(Orderer.Objects[I]) > 0 then
             Frequencies.Add(Format('%s : %d', [Orderer.Strings[I], Cardinal(Orderer.Objects[I])]));
 
         Frequencies.EndUpdate();
       finally
         Orderer.Free();
       end;
    end else
    begin
      if Source.Count > 0 then
        Frequencies.Add(Format('%s : 1', [Source.Strings[0]]));
    end;
  end;
end;

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
type
  TSorterStringList = class(TStringList)
  private
    FOrdored: Boolean;
    procedure SetOrdored(const Value: Boolean);
  public
    function AddObject(const S: string; AObject: TObject): Integer; override;
    property Ordored: Boolean read FOrdored write SetOrdored;
  end;
 
{ TSorterStringList }
 
function TSorterStringList.AddObject(const S: string; AObject: TObject): Integer;
begin
  if Ordored then
  begin
    if Find(S, Result) then
    begin
      Objects[Result] := Pointer(Cardinal(Objects[Result]) + 1);
    end else
      InsertItem(Result, S, Pointer(1));
  end else
    Result := inherited AddObject(S, AObject);
end;
 
procedure TSorterStringList.SetOrdored(const Value: Boolean);
begin
  FOrdored := Value;
  if FOrdored then
  begin
    Sorted := True;
    Duplicates := dupAccept;
  end;
end;
 
procedure GetFrequencyWordV2(Source, Frequencies: TStrings);
var
  Orderer: TSorterStringList;
  I, K: Integer;
  S: string;
begin
  if Assigned(Source) and Assigned(Frequencies) then
  begin
    if Source.Count > 1 then
    begin
       Orderer := TSorterStringList.Create();
       try
         Orderer.Capacity := Source.Capacity;
         Orderer.Ordored := True;
         Orderer.AddStrings(Source);
 
         Frequencies.BeginUpdate();
         Frequencies.Clear();
         Frequencies.Capacity := Orderer.Capacity;
         for I := 0 to Orderer.Count - 1 do
           if Cardinal(Orderer.Objects[I]) > 0 then
             Frequencies.Add(Format('%s : %d', [Orderer.Strings[I], Cardinal(Orderer.Objects[I])]));
 
         Frequencies.EndUpdate();
       finally
         Orderer.Free();
       end;
    end else
    begin
      if Source.Count > 0 then
      begin
        Frequencies.Clear();
        Frequencies.Add(Format('%s : 1', [Source.Strings[0]]));
      end;
    end;
  end;
end;

on peut aussi une variante en remplaçant

Code :

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

1
2
3
         Orderer.Capacity := Source.Capacity;
         Orderer.AddStrings(Source);
         Orderer.Sort();

par

Code :

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

1
2
3
4
         Orderer.Capacity := Source.Capacity;
         Orderer.Sorted := True;
         Orderer.Duplicates := dupAccept;
         Orderer.AddStrings(Source);

mais le gain de perf varie selon la "gueule" de la liste

[Bruno13]

Salut Gilbert, ShaiLeTroll,

A GILBERT : Bien voloentié pour le fichier et l'unité voici mon mail bmannina chez free fr. C'est avec plaisir que je partagerais me résultats avec toi si cela t'interesse.

A ShaiLeTroll : merci pour ces 2 fonctions, je vais les tester toutes les deux et revenir sur ce messages pour te dire ce qu'il en ai.

Merci à tous pour votre aide si précieuse.

Amitiés,
Bruno

[Bruno13]

Bon voilà, il est 4h du mat et effectivement je m'aperçois que ma liste de mots vides n'est pas tout à fait au top, aussi bien pour déterminer la langue mais aussi ensuite pour épurer mon fichier texte de ces mots.

Tu as raison Gilbert...mais bon comme je l'ai déjà dit passons, j'arrive qd même à un résultat assez concluant pour continuer dans mes étapes.

Pour ce qui est de la Fréquences des mots c'est ok, je suis arrivé à intégrer la V2 de GetFrequencyWord, j'y ai même ajouté une variable minFreq pour élaguer les fréquences < minFreq.

J'arrive maintenant à un résultat avec dans certains mots du texte des virgukes, point, point virgules...etc bref tous les caractères de ponctuations certes nécessaires à la compréhension, mais pas pour des stats. J'utilise donc des FastReplace pour corriger cela.

Ce qui me fait arriver à ma prochaine étape : convertir certains mots en leur racine, par exemple maisonnette -> maison ou abandonner -> abandon, etc...
C'est la lématisation. Pour cela j'ai des fichiers qui sont de la forme :

maisonnette maison
maisons maison
etc...

Bref une ligne par racine

Comment puis-je faire pour charger ce fichier dans un tableau pour convertir ensuite chaque mot par sa racine ?

Cela ne doit pas être grand chose mais un loadfromfile sur une tStringList peut-il faire l'affaire ?

Merci encore pour votre aide
Bruno

PS : gilbert tu as mon mail dans le message du dessus

[Clorish]

Oui tu loadFromStream suffit. Tu charge donc dans un TStringList chaques lignes de ton fichier donc chaques elements comporte le couple Racine/mot
Si tu as prevu le coup du doit avoir sous la main un fonction splitStr qui te permet de decouper une chaine en sous chaines via un ou plusieurs separateurs. Donc apres ca deviens facile : Decioupe via " " et selon l'odre d'ecriture Racine/mot, tu as donc ta correspondance.

[ShaiLeTroll]

SplitStr (pourrais-t-on avoir le lien, je ne l'ai pas trouvé sur la recherche forum ni FAQ) ou Explode

[Clorish]

SplitStr (pourrais-t-on avoir le lien, je ne l'ai pas trouvé sur la recherche forum ni FAQ) ou Explode

SplitStr est une fonction qu'il est sensé avoir codé pour faire son decoupage Enfin si a codé proprement ...

Pour la comunautee, voila ma vieille version, qui sans etre parfaite pourra en inspirer plus d'un

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
{==============================================================================}
{  SplitStr  }
{==============================================================================}
// Valeur de retour : Taille du tableau
 
Function SplitStr(VAR StrArray : TStringDynArray; Str, Separators : String) : Integer;
Var i : Integer;
    Size : Integer;
Begin
Size := 1;
SetLength(StrArray, Size);
StrArray[Size-1] := '';
 
For i := 1 to Length(Str) do
    Begin
    If Pos(Str[i], Separators) > 0 Then
       Begin
       Inc(Size);
       SetLength(StrArray, Size);
       StrArray[Size-1] := '';
       End
    Else StrArray[Size-1] := StrArray[Size-1] + Str[i];
    End;
 
Result := Size;
End;

[Gilbert Geyer]

Bonjour,

1) Fichier de lématisation vers StringList : J'aurais plutôt créé dès le lancement de l'appli une 2ème StringList à partir de celle alimentée par la lecture du fichier ce qui aurait donné une sorte de tableau à deux colonnes avec correspondance d'indices, ce qui évite les ralentissements ultérieurs dus à des SplitStr répétitifs superflus en phase d'analyse de texte :

Code :

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

1
2
3
4
5
          StringListMot           StringListRacine 
          maisonnette             maison
          maisons                 maison  
          abandonner              abandon

2) Possibilité d'un gain de vitesse en phase d'identification de langue :
La liste des StopWords anglais est considérablement plus courte que la plupart des autres listes et comme sa longueur semble suffire pour identifier un texte comme étant anglais, je raccourcirais les autres listes en conséquence en retenant les mots d'occurence-max. (on peut estimer que si par exemple 'de' ou 'mon' est très fréquemment utilisé par les français il en est de même avec le 'de' anglais (of) et le 'mon' anglais (my) et leurs traductions dans les autres langues, ce qui permet de calibrer ces listes à partir des occurences-max françaises puisque l'usage de tels mots relève plus du comportement humain que de la science des linguistes ...

3) Bruno : Ok je t'envoie de suite un Zip avec le fichier.doc concernant l'assainissement des StopWords. Pour l'unité je vais l'extraire de mon appli pour la rendre indépendante du reste de l'appli j'espère que ce ne sera pas trop long.
A+

[Gilbert Geyer]

A ShailLeTroll et à Clorish :

Dans une autre discussion en rapport avec le même sujet Bruno13 a écrit (12/06/2007, 16h50) que pour ce qui relevait du traitement des chaines de caractères il utilisait, je cite,

"FastStrings : http://www.droopyeyes.com Vraiment trés rapide les fonctions sur les chaines de caractères".

Il était à ce moment là question de la fonction des FastReplace et je suppose que son SplitStr fait également partie de cette librairie.
A+

[ShaiLeTroll]

J'espère qu'il n'utilise pas cette fonction alors, car si l'on nomme son unité FastStrings, on pourrait espérer que cela soit rapide, alors que c'est très moyen ...

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
//Splits a delimited text line into TStrings (does not account for stuff in quotes but it should)
procedure Split(aValue : string; aDelimiter : Char; var Result : TStrings);
var
  X : Integer;
  S : string;
begin
  if Result = nil then Result := TStringList.Create;
  Result.Clear;
  S := '';
  for X:=1 to Length(aValue) do begin
    if aValue[X] <> aDelimiter then
      S:=S + aValue[X]
    else begin
      Result.Add(S);
      S := '';
    end;
  end;
  if S <> '' then Result.Add(S);
end;

Temps d'Execution sur [0;;1;2!2;333;44!44;55555;666!666;7777777;8888!8888;999999999;00000!00000;"AAA";"BBB";"CCC"] découpé sur ; répété 1000 fois

SplitStrClorish : 118 ms à 130 ms
SplitDroopyEyes : 65 ms à 75 ms
ExplodeLazy : 8 ms
Explode : 10 ms
ExplodeFabriceRouxel : 17 ms
ExtractStrings (Delphi7 : StrUtils) : 17 ms à 22ms

[Bruno13]

Bonjour à tous,

Voilà je me reveille !

A Gilbert : j'ai bien recu le Zip, mille merci

Pour le Split j'utilise celui-là qui ne vient pas de la librairie FastString:

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
PROCEDURE Split( CONST Text : STRING; Delimeter : Char; List : TStrings );
 VAR c, d : PChar;
 BEGIN
  IF (List<>NIL) THEN
   BEGIN
    c:=PChar(Text);
    d:=c;
    WHILE (c^<>#0) DO
     IF (c^=Delimeter) THEN
      BEGIN
       List.Add(Copy(d, 1, c-d));
       Inc(c);
       d:=c;
      END
     ELSE
      Inc(c);
    List.Add(Copy(d, 1, c-d));
   END;
 END; {* PROC Split *}

1) Fichier de lématisation vers StringList : J'aurais plutôt créé dès le lancement de l'appli une 2ème StringList à partir de celle alimentée par la lecture du fichier ce qui aurait donné une sorte de tableau à deux colonnes avec correspondance d'indices, ce qui évite les ralentissements ultérieurs dus à des SplitStr répétitifs superflus en phase d'analyse de texte

C'est une bonne idée, j'y avais d'ailleurs pensé mais comme j'ai plusieurs langues hummm c'est peut etre pas le bon système.

Pour l'instant je vais charger tout simplement la liste à chaque page mais j'utilise en ce moment une ou deux page car je veux avancer et voir ce que cela donne. Je ne suis pas encore à la phase d'optimisation. D'ailleurs je ne sais pas encore si je vais faire le traitement sans l'avis de l'utilisateur et proposer les résultats ou au contraire lui proposer de faire le traitement.

Donc si je résume, je vais faire un loadfromfile dans une stringlist et un split, pour mettre les resultats dans 2 StringLists.

A moins que quelqu'un d'entre vous à une meilleur idée

En tout cas merci à tous pour votre aide !
Bruno

[Gilbert Geyer]

A ShaiLeTroll : Intéressants les résultats des tests comparatifs de vitesse, rien que pour faire des Splits à répétitions ... certaines lenteurs seraient à la limite encore supportables s'il s'agissait d'un Splittage réalisé une fois pour toutes, mais qui plomberaient certainement une appli en cas de Re-Splittages récurrents dans des boucles d'utilisation.
Et mille excuses, j'étais persuadé que Bruno13 effectuait ses Splits avec sa librairie FastString et je viens de découvrir dans son dernier message que ce n'est pas le cas. Dommage que le code de son Split n'ait pas fait partie de tes tests de vitesse pour le situer par rapport aux autres.

A Bruno : Pour convertir chaque mot, de chaque texte dans sa langue, par sa racine t'as pas beaucoup le choix :
- ou bien tu crées des tables de correspondances d'indices dès le début pour obtenir par la suite des conversions quasi-instantanées(*).
- ou alors tu laisses tout dans la même StringList (ou une même structure) et tu passes ensuite le temps à faire des Splits et des conversions.

(*) Cette optimisation par anticipation conduit au scénario suivant :
- au lancement de l'appli on crée les 7 paires de StringListMot StringListRacine, c'est à dire deux Array of TstringList
- au chargement d'un texte-à-ausculter on identifie sa langue : indiceLangue.
- lors de la lématisation de chaque mot de ce texte, StringListMot[indiceLangue].IndexOf(mot) fournit illico l'indice indMot avec lequel on convertit ce mot vers sa racine à l'aide de StringListRacine[indiceLangue][indMot].

Le Zip de l'unité de comptage des occurences est parti.

A+

[ShaiLeTroll]

comme les temps sont variables selon l'étant de la machine, je remet la total

SplitStrClorish : 122 ms à 133 ms
SplitDroopyEyes : 67 ms à 71 ms
ExplodeLazy : 7 à 8 ms
Explode : 11 à 12 ms
ExplodeFabriceRouxel : 16 à 19 ms
ExtractStrings (Delphi7 : StrUtils) : 24 à 29 ms
SplitBruno13 : 26 à 30 ms

[Bruno13]

Bon ben c'est raisonnable pour mon split

Merci ShaiLeTroll pour ces infos

[Gilbert Geyer]

A ShaiLeTroll :
Bonjour et merci pour ces infos.
Je pense que dès ton 1er message relatif aux performances comparées tout le monde s'est fait un copier-coller-rapatrier de ExplodeLazy .