Calcul de nombre d'occurrences

Bonsoir,
Je dois calculer le nombre d'occurrence d'une liste de mots dans un corpus (peuvent être composer de plusqu'un mot): exemple "letter", "a letter", "this ozone-depleting".
j'ai mis les chaines de mots à calculer das une liste "listeMots" et j'ai parcouru le corpus; je vous présente une partie de code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

while ( (ligne= fp.readLine())!=null) {   for(int j=0; j<listeMots.size();j++) { if(ligne.contains(listeMots.get(j))) { listeNbre.set(j, listeNbre.get(j)+1);   }     } }

---

Mais dans le cas où la ligne contient plusqu'une fois une chaine à cherceher, le code va l'ignorer!
dans ce cas par quoi je dois remplacer "contains"??
merci

Utilise la méthode indexOf(String,startIndex), chaque fois que tu trouve quelque chose, tu recommence à chercher après ce quelque chose, jusqu'à ce que indexOf te retourne -1.

j'ai essayé de travailler le code autrement: avec les pattern,

Code:

---

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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

import java.io.*; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern;   public class Occurrence { static String chaine=""; static String ligne1=""; static List <String> listeMots =new ArrayList<String>(); static List <Integer> listeNbre =new ArrayList<Integer>(); public static void main(String[] args)throws IOException{ lecture("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\test.txt",listeMots); p("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\NombreOccurrenceTrigramFinal.txt",listeMots); } public static void lecture (String fichier,List <String> ListeM){ try{   InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); BufferedReader br=new BufferedReader(ipsr); String ligne; while ((ligne=br.readLine())!=null ){ listeMots.add(ligne); listeNbre.add(0); } } catch (Exception e){ System.out.println(e.toString()); } } public static void p(String out,List <String> ListeM) { try{ OutputStream ips=new FileOutputStream(out,true); OutputStreamWriter ipsr=new OutputStreamWriter(ips); BufferedWriter fp=new BufferedWriter(ipsr); String texte=recText("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\corpus-test.txt"); fp.flush(); for (int i = 0; i < listeMots.size(); i++) { int probM1=calculeOcc1(texte,listeMots.get(i)); listeNbre.set(i, probM1); } fp.flush(); for(int j=0; j<listeMots.size();j++) { System.out.println("***"+listeMots.get(j)+"***"+listeNbre.get(j)); fp.append("***"+listeMots.get(j)+"***"+listeNbre.get(j)); fp.append("\n"); } fp.close(); }catch (Exception e){ System.out.println(e.toString()); } } public static String recText(String fichier){ try{ InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); BufferedReader br=new BufferedReader(ipsr); String ligne;int i=0; while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; System.out.println(i++); } br.close(); } catch (Exception e){ System.out.println(e.toString()); } return ligne1; }   public static int calculeOcc1(String texte, String mot){ Pattern pattern = Pattern.compile(mot); Matcher matcher = pattern.matcher(texte); int occ = 0; while (matcher.find()) { occ++; // System.out.println(occ++);   }   return occ; }       }

---

le fichier test.txt

Citation:

---

a letter
letter
an letter
another letter
any letter
one letter
some letter
something letter
among bird
bird
this ozone-depleting from
this ozone-depleting of
this ozone-depleting regard
this ozone-depleting by

---

et le fichier corpus-test.txt

Citation:

---

resumption of the session a letter a letter
you have request a debate on this subject in the course of the next few day during this part-session a letter
Please rise then for this minute s silence bird
the House rise and observe a minute s silence
madam president on a point of order
you will be aware from the press and television that there have be a number of bomb explosion and killing in Sri Lanka
yes Mr Evans I feel an initiative of the type you have just suggest would be entirely appropriate
if the House agree I shall do as Mr Evans have suggest
madam president on a point of order
I would like your advice about rule @card@ concern inadmissibility
my question relate to something that will come up on Thursday and which I will then raise again
it say that this should be do despite the principle of relative stability
that be precisely the time when you may if you wish raise this question ie on Thursday prior to the start of the presentation of the report
at the request of a French member Mr Zimeray a petition have already be present which many people sign include myself
this be all in accordance with the principle that we have always uphold
thank you Mr segno I shall do so gladly
Indeed it be quite in keep with the position this House have always adopt
madam president I should like to draw your attention to a case in which this Parliament have consistently show an interest
it be the case of Alexander Nikitin
now however he be to go before the court once more because the public prosecutor be appeal
yes Mrs Schroedter I shall be please to look into the fact of this case when I have receive your letter
but madam president my personal request have not be meet
I would therefore once more ask you to ensure that we get a Dutch channel as well
Mrs Plooij-van Gorsel I can tell you that this matter be on the agenda for the Quaestors meeting on Wednesday
it will I hope be examine in a positive light
madam president can you tell me why this Parliament do not adhere to the health and safety legislation that it actually pass
why have no air quality test be do on this particular building since we be elect
why have there be no health and safety Committee meeting since @card@
why have there be no fire drill either in the Brussels Parliament building or the Strasbourg Parliament building
why be there no fire instruction
why have the staircase not be improve since my accident
why be no-smoke area not enforce

---

Il foctionne tres bien et correctement. Mais vous voyez que c'est bien optimisé pour le lancer avec un corpus de milliers de lignes????

Réponse de Normand: tu teste et tu évalue si les temps de réponse correspondent à tes attentes. Si ce n'est pas la cas, tu essaie d'identifier comment améliorer.

Citation:

---

Envoyé par Wim88

Bonsoir,
Je dois calculer le nombre d'occurrence d'une liste de mots dans un corpus (peuvent être composer de plusqu'un mot): exemple "letter", "a letter", "this ozone-depleting".
j'ai mis les chaines de mots à calculer das une liste "listeMots" et j'ai parcouru le corpus; je vous présente une partie de code:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

while ( (ligne= fp.readLine())!=null) {   for(int j=0; j<listeMots.size();j++) { if(ligne.contains(listeMots.get(j))) { listeNbre.set(j, listeNbre.get(j)+1);   }     } }

---

Mais dans le cas où la ligne contient plusqu'une fois une chaine à cherceher, le code va l'ignorer!
dans ce cas par quoi je dois remplacer "contains"??
merci

---

visiblement, tu cherches quelque chose comme cela:

http://commons.apache.org/proper/com...lang.String%29

Citation:

---

Envoyé par Wim88

j'ai essayé de travailler le code autrement: avec les pattern,

Code:

---

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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

import java.io.*; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern;   public class Occurrence { static String chaine=""; static String ligne1=""; static List <String> listeMots =new ArrayList<String>(); static List <Integer> listeNbre =new ArrayList<Integer>(); public static void main(String[] args)throws IOException{ lecture("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\test.txt",listeMots); p("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\NombreOccurrenceTrigramFinal.txt",listeMots); } public static void lecture (String fichier,List <String> ListeM){ try{   InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); BufferedReader br=new BufferedReader(ipsr); String ligne; while ((ligne=br.readLine())!=null ){ listeMots.add(ligne); listeNbre.add(0); } } catch (Exception e){ System.out.println(e.toString()); } } public static void p(String out,List <String> ListeM) { try{ OutputStream ips=new FileOutputStream(out,true); OutputStreamWriter ipsr=new OutputStreamWriter(ips); BufferedWriter fp=new BufferedWriter(ipsr); String texte=recText("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\corpus-test.txt"); fp.flush(); for (int i = 0; i < listeMots.size(); i++) { int probM1=calculeOcc1(texte,listeMots.get(i)); listeNbre.set(i, probM1); } fp.flush(); for(int j=0; j<listeMots.size();j++) { System.out.println("***"+listeMots.get(j)+"***"+listeNbre.get(j)); fp.append("***"+listeMots.get(j)+"***"+listeNbre.get(j)); fp.append("\n"); } fp.close(); }catch (Exception e){ System.out.println(e.toString()); } } public static String recText(String fichier){ try{ InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); BufferedReader br=new BufferedReader(ipsr); String ligne;int i=0; while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; System.out.println(i++); } br.close(); } catch (Exception e){ System.out.println(e.toString()); } return ligne1; }   public static int calculeOcc1(String texte, String mot){ Pattern pattern = Pattern.compile(mot); Matcher matcher = pattern.matcher(texte); int occ = 0; while (matcher.find()) { occ++; // System.out.println(occ++);   }   return occ; }       }

---

le fichier test.txt

et le fichier corpus-test.txt

Il foctionne tres bien et correctement. Mais vous voyez que c'est bien optimisé pour le lancer avec un corpus de milliers de lignes????

---

En java 8, tu peux créer un Stream sur un BufferedReader. En écrivant le bon filtre et/ou mapper, (en utilisant la méthode de commons apache) et avec la bonne fonction d'agrégation (Collectors.groupingBy ou autre, à voir..), tu dois pouvoir obtenir directement une Map<String,Integer> avec comme clé: les mots-clés et en valeur, le nombre de leur occurrence respective .

http://docs.oracle.com/javase/8/docs...tion.Function-

De plus, si ton document Corpus-texte.txt est très grand, tu peux faire un traitement multicoeur avec un parallelStream() à la place de Stream().

http://docs.oracle.com/javase/tutori...rallelism.html

Le traitement multicoeur ne va pas tous le temps accélérer le programme. Il faut voir si le traitements de données si prête et adapter l'algorithme: à voir....

Bonjour,
Votre réponse est arrivée dans le temps nécessaire!! Ce c'est arrivé que j'ai patienté 5 jours et le programme tourne hier le soir est arrêté d'une erreur "java heap space" . Il a arrivé à la fin! mais malheureusement n'a pas etteint la fin :( :( :( . Je vais vois les liens que vous m'avez envoyé . J'ai cru que mon code est bien optimisé! mais il y'a toujours des choses inattendus :aie:

Citation:

---

Envoyé par Wim88

J'ai cru que mon code est bien optimisé! mais il y'a toujours des choses inattendus :aie:

---

tu parles un peu plus haut d'un corpus de milliers de lignes: Si on le peut, et ici c'est la cas, il ne faut pas stocker toutes ces données sous forme d'une String dans ton programme. Il faut faire un traitement soit ligne par ligne ou via un Stream pour ne pas saturer les ressources de la jvm.

Il serait bien aussi que tu utilises try-with-resources

http://docs.oracle.com/javase/tutori...urceClose.html


tu utilises la séquence suivante:

Code:

---

1 2 3 4

while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; System.out.println(i++); }

---

avec ligne1 et ligne qui sont des String. C'est très pénalisant. Il faut opter pour un StringBuilder (ou StringBuffer dans un environnement concurrent)


http://docs.oracle.com/javase/7/docs...ingBuffer.html


Autre précision: tu as les patterns "a letter" et "letter".

Quand tu trouves, "a letter", tu incrémentes l'occurrence de "a letter" et celle de "letter" ou, seulement celle de "a letter" ?

chacun tout seul, j'incremente "letter" toute seule et "a letter" tout seul
Le corpus est de 100M et contient 1.150.437 lignes
System.out.println(i++); c'est juste pour voir l'avancement dans le console

Citation:

---

Envoyé par Wim88

chacun tout seul, j'incremente "letter" toute seule et "a letter" tout seul
Le corpus est de 100M et contient 1.150.437 lignes
System.out.println(i++); c'est juste pour voir l'avancement dans le console

---

Ce n'est pas :

Code:

---

System.out.println(i++);

---

qui pose problème, c'est

Code:

---

1 2 3 4

while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; }

---

Avec cette concantenation de String à chaque itération ( 1.150.437 lignes !!!). De toute façon, il ne faut pas stocker ces 1.150.437 lignes dans une variable. Il faut traiter ligne par ligne.

Citation:

---

De toute façon, il ne faut pas stocker ces 1.150.437 lignes dans une variable. Il faut traiter ligne par ligne.

---

je vais voir comment faire ça :?

Si je fait le traitement ligne par ligne, donc pour chaque ligne je fait le parcourt de toute la liste??

Bonjour, j'ai changer la partie de code

Code:

---

1 2 3 4

while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; System.out.println(i++); }

---

par

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

while ((ligne=br.readLine())!=null){ if(nb<1001){ nb++; ligne1+=ligne; System.out.println(nb); } else{ listeLignes.add(ligne1); nb++; System.out.println(nb); } }

---

Dans le but de ne pas mettre tout le corpus dans une seule variable. Mais juste une question le parcour de la liste listeLignes je le fai dans la méthode calculeOcc1 ou p ? merci de m'aider d'avoir la meilleur optimisation :/

Salut,

Citation:

---

Envoyé par plawyx

Il serait bien aussi que tu utilises try-with-resources

---

+1 en plus aucun flux n'est fermé !

Citation:

---

Envoyé par plawyx

tu utilises la séquence suivante:

Code:

---

1 2 3 4

while ((ligne=br.readLine())!=null){ ligne1+=ligne+"\n"; System.out.println(i++); }

---

avec ligne1 et ligne qui sont des String. C'est très pénalisant. Il faut opter pour un StringBuilder

---

+1000

Je dirais même que l'utilisation de l'opérateur + dans une boucle est vraiment une très grossière erreur !

Citation:

---

Envoyé par plawyx

(ou StringBuffer dans un environnement concurrent)

---

Je dirais plutôt : ou StringBuffer pour les versions de Java antérieur à Java 5.0 (car StringBuilder n'existait pas).

Le coté thread-safe de StringBuilder ne sert pas à grand chose...



a++

Salut,
j'ai ajouté ce bout de code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

catch (Exception e) { e.printStackTrace(); } finally { close(br); } return ligne1; }   private static void close(Closeable closable) { if (closable != null) { try { closable.close(); } catch (IOException e) { e.printStackTrace(); } } }

---

pour "try-with-resources"
et j'ai pas bien compris franchement dit qui est la meilleur? StringBuffer ou StringBuilder: D'apres ce que j'ai compris que d'utiliser StringBuffer:

Code:

---

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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

import java.io.*; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern;   public class NombreOccurrence { static String chaine=""; static StringBuffer ligne1 =new StringBuffer(); static List <StringBuffer> listeLignes =new ArrayList<StringBuffer>(); static List <String> listeMots =new ArrayList<String>(); static List <Integer> listeNbre =new ArrayList<Integer>(); public static void main(String[] args)throws IOException{ lecture("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\test-test.txt",listeMots); p("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\NombreOccurrenceTrigramFinal.txt",listeMots,listeLignes); } public static void lecture (String fichier,List <String> ListeM){ try{   InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); BufferedReader br=new BufferedReader(ipsr); String ligne; while ((ligne=br.readLine())!=null ){ listeMots.add(ligne); listeNbre.add(0); } } catch (Exception e){ System.out.println(e.toString()); } } public static void p(String out,List <String> ListeM,List <StringBuffer> ListeL) { try{ OutputStream ips=new FileOutputStream(out,true); OutputStreamWriter ipsr=new OutputStreamWriter(ips); BufferedWriter fp=new BufferedWriter(ipsr); StringBuffer texte=recText("C:\\Users\\HP\\workspace\\testModif\\ptitCorpusApprentissageLemmatisé.txt"); fp.flush(); for (int j = 0; j < listeLignes.size(); j++) { for (int i = 0; i < listeMots.size(); i++) { int probM1=calculeOcc1(listeLignes.get(j),listeMots.get(i)); listeNbre.set(i, probM1); }} fp.flush(); for(int j=0; j<listeMots.size();j++) { System.out.println("***"+listeMots.get(j)+"***"+listeNbre.get(j)); fp.append(listeMots.get(j)+"="+listeNbre.get(j)); fp.append("\n"); } fp.close(); }catch (Exception e){ System.out.println(e.toString()); } } public static StringBuffer recText(String fichier){ BufferedReader br = null; try{ InputStream ips=new FileInputStream(fichier); InputStreamReader ipsr=new InputStreamReader(ips); br=new BufferedReader(ipsr); String ligne; int nb = 0; while ((ligne=br.readLine())!=null){ if(nb<1001){ nb++; ligne1.append(ligne+"\n"); //System.out.println(nb); } else{ listeLignes.add(ligne1); nb++; //System.out.println(nb); } } br.close(); } catch (Exception e) { e.printStackTrace(); } finally { close(br); } return ligne1; }   private static void close(Closeable closable) { if (closable != null) { try { closable.close(); } catch (IOException e) { e.printStackTrace(); } } } public static int calculeOcc1(StringBuffer texte, String mot){ Pattern pattern = Pattern.compile(mot); Matcher matcher = pattern.matcher(texte); int occ = 0; while (matcher.find()) { occ++; // System.out.println(occ++);   }   return occ; }       }

---

La classe fonctionne correctement mais j'ai pas remarqué une grande amélioration surtout que le parcourt de listeLignes prend du temps en exécution: :( :( :(

Pièce jointe 143040
Je vous joins l'erreur de la premiere version de code. Je vous rappel mes amis que j'ai un grand corpus en entrée c'est pour ce la je veux l'optimiser le max, même si vous voyez que mon code non optimiser du à mes compétences limitées.:oops:

Citation:

---

Envoyé par Wim88

et j'ai pas bien compris franchement dit qui est la meilleur? StringBuffer ou StringBuilder: D'apres ce que j'ai compris que d'utiliser StringBuffer:

---

Perdu c'est StringBuilder... mais c'est pas bien grave du moment que tu n'utilises pas l'opérateur + dans une boucle...

Mais apparemment tu ne peux pas t'en empêcher :

Code:

---

ligne1.append(ligne+"\n");

---

:arrow:

Code:

---

ligne1.append(ligne).append("\n");

---

Sinon avant de penser "optimisation" tu devrais plutôt travailler sur un code clair et lisible :

• Le code super mal indenté c'est illisible...
• On a dit pas de + dans une boucle : ligne1.append(ligne+"\n") :arrow: ligne1.append(ligne).append("\n")
• Ces quoi toutes ces variables déclarées en static ???
• Et pourquoi plusieurs des paramètres des méthodes ne sont pas utilisés ?
• La libération des ressources, c'est pour toutes les ressources, et non pas une seule...

Franchement j'ai essayé de lire ton code, mais je n'ai pas réussi à comprendre ce qu'il faisait !

• Quel est l'objectif de la méthode p() ? Et pourquoi ignore-t-elle 2 de ses arguments ?
• Que fait recText() exactement ? Elle lit les 1000 premières lignes dans un StringBuffer, puis place ce même StringBuffer dans une liste pour chaque nouvelle ligne ? Pourquoi ???
• Et Pourquoi sa valeur de retour est ignoré ?
• Que fait calculeOcc1() ? Compter le nombre d’occurrence d'un mot ? Les Pattern me semble disproportionné pour cela.
  Un indexOf() me semblerait plus approprié

a++

Mouais, en plus du fait que ce code soit tres moche et impossible à maintenir, il ne faut pas esperer des gains de performance en faisant la meme chose. La, tu ne fais que fermer les flux donc c'est un peu moins moche. Mais le code qui prend du temps est le meme.

Si tu veux un gain de performance, c'est l'algo qu'il faut changer. Si j'ai bien suivi, ce que tu veux, c'est compter le nombre d'occurences de différents mots. Ce qu'il faudrait faire, c'est donc creer la liste de mots puis lire le fichier ligne par ligne. Mais au lieu de concatener ta chaine, il faudrait directement chercher tous les mots. Ca eviterait d'utiliser inutilement une grosse quantité de mémoire (puisque tu dis toi meme que ton fichier est gros) et de faire le travail en 2 fois.

Et sur la fome, pour eviter les variables static dans tous les sens, il faudrait creer une classe et l'instancier dans ton main. Ensuite, faire le traitement. Ca ferait un peu moins code en C qui s'est perdu dans java.
Par ailleurs, tu passes à tes fonctions en parametre les listes sur lesquelles elles sont sensées travailler. Puis tu utilises directement les variables de la classe. Faut bien comprendre qu'en plus de gacher des ressources, ca rend ce code difficile à lire parce qu'on voit bien que tu avances par itération sans comprendre ce que tu fais. Au final, ca va peut etre tomber en marche sur un malentendu mais ce code gagnerait à etre refait...

L'objectif en général c'est de calculer le nombre d'occurrence de chaque pattern dans un corpus.

Citation:

---

adiGuba : Ces quoi toutes ces variables déclarées en static ???

---

j'ai pas cru que les variables statique peuvent poser un problème!

Citation:

---

Quel est l'objectif de la méthode p() ?

---

l'bjectif c'est de parcourir la liste des pattern et faire appel à la méthode recText et calculeOcc1

Citation:

---

Que fait recText() exactement ? Elle lit les 1000 premières lignes dans un StringBuffer, puis place ce même StringBuffer dans une liste pour chaque nouvelle ligne ? Pourquoi ???

---

c'est de mettre chaque 1000 lignes dans une variable pour éviter de mettre tout le corpus dans une seule variable

Citation:

---

Et Pourquoi sa valeur de retour est ignoré ?

---

:oops:

Citation:

---

Que fait calculeOcc1() ? Compter le nombre d’occurrence d'un mot ? Les Pattern me semble disproportionné pour cela.
Un indexOf() me semblerait plus approprié

---

oui de calculer le nombre d'occurrence , oui ils sont disproportionnés, je vais voir avec l'indexOf

Citation:

---

hwoarang : Faut bien comprendre qu'en plus de gacher des ressources, ca rend ce code difficile à lire parce qu'on voit bien que tu avances par itération sans comprendre ce que tu fais. Au final, ca va peut etre tomber en marche sur un malentendu mais ce code gagnerait à etre refait...

---

Vous avez raison mes amis , je vais refaire le code , et je vais essayer de le faire correctement :calim2: :calim2:
merci
A+++

Citation:

---

Envoyé par Wim88

l'bjectif c'est de parcourir la liste des pattern et faire appel à la méthode recText et calculeOcc1

---

la méthode static StringUtils.countMatches de apache.commons. fait cela en un seule appel.

Citation:

---

Envoyé par Wim88

c'est de mettre chaque 1000 lignes dans une variable pour éviter de mettre tout le corpus dans une seule variable

---

tu as nécessaire beaucoup moins de mots clés que de mots de la corpus. C'est donc l'inverse qu'il faut faire.

Citation:

---

Envoyé par Wim88

oui de calculer le nombre d'occurrence , oui ils sont disproportionnés, je vais voir avec l'indexOf

---

StringUtils.countMatches

Peut-être, pour optimiser, créer un espèce de graphe à partir de la liste de mots à rechercher :koi: :koi:

Exemple: :mrgreen:
Liste de mots à rechercher: ["a letter", "letter", "an letter", "another letter", "any letter", "one letter", "some letter", "something letter", "among bird", "bird", "this ozone-depleting from", "this ozone-depleting of", "this ozone-depleting regard", "this ozone-depleting by"]

1) Extraire tous les mots de la liste de mots en découpant à partir des espaces (il faut voir si plusieurs espaces sont acceptés entre 2 mots ou pas)
["a", "letter", "an", "another", "any", "one", "some", "something", "among", "bird", "this", "ozone-depleting", "from", "of", "regard", "by"]

2) Générer un tableau associatif [préfixe/ suffixe] avec la liste des mots trouvés, -1 si aucun
PS: pour l'exemple, je prends l'indice, mais on peut prendre ce qu'on veut
["letter": [0, -1], [-1, -1], [2, -1], [3, -1], [4, -1], [5, -1], [6, -1], [7, -1]
"bird": [8, -1], [-1, -1]
"ozone-depleting": [10, 12], [10, 13], [10, 14], [10, 15]]

Un truc: Lorsqu'on va découper notre liste de mots, maintenir une collection (qu'on pourra peut-être réutilisée) qui nous permet de savoir si un mot existe ou pas
Et ainsi créer au fil de l'eau un tableau qui nous permet de simplifier l'étape 2:
Liste de mots à rechercher (*): [0 1], [1], [2 1], [3 1], [4 1], [5 1], [6 1], [7 1], [8 9], [9], [10 11 12], [10 11 13], [10 11 14], [10 11 15]
Et peut-être que ce tableau peut permettre de fusionner l'étape 2 et 3 :mrgreen:

3) Simplifier ce tableau associatif , sûrement en récursif:
On s'aperçoit que pour le mot "ozone-depleting", le préfixe "this" (10) apparait plusieurs fois
["letter": [0, -1], [-1, -1], [2, -1], [3, -1], [4, -1], [5, -1], [6, -1], [7, -1]
"bird": [8, -1], [-1, -1]
"this ozone-depleting": [-1, 12], [-1, 13], [-1, 14], [-1, 15]]

Maintenant, on peut simplement rechercher "letter", "bird", "this ozone-depleting".
Si on en trouve un, on prendre la liste de [préfixe/ suffixe] pour rechercher avant ou après, en faisant attention aux espaces évidemment :mouarf:
:langue2: :langue2:

Après je ne dis pas que c'est simple, réellement utile, que les associations préfixe/ suffixe c'est ce qu'il faut utiliser (on peut trouver autre chose **), ou même ... que c'est une optimisation réalisable :whistle:

** -> Lorsqu'on voit (*), on s'aperçoit qu'on a plusieurs graphes de mots déconnectés [0, 1, 2, 3, 4, 5, 6, 7], [8, 9], [10, 11, 12, 13, 14, 15] (<- il n'y a pas les arêtes) et qu'il faut trouver pour chacun, le graphe de mots "interne central" le plus grand possible (même 1 mot)
[0, 1, 2, 3, 4, 5, 6, 7] -> 1
[8, 9] -> 9
[10, 11, 12, 13, 14, 15] -> 10 - 11

Citation:

---

Envoyé par plawyx

la méthode static StringUtils.countMatches de apache.commons. fait cela en un seule appel.
tu as nécessaire beaucoup moins de mots clés que de mots de la corpus. C'est donc l'inverse qu'il faut faire.
StringUtils.countMatches

---

Voila j'ai pris en considération tes conseils et ça va c'est bon il calcule avec un temps de réponse très court ;)

Code:

---

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

import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; import java.util.List;   import org.apache.commons.lang.StringUtils; import org.apache.commons.io.FileUtils; public class CalculNombrePattern { public static void main(String[] args) throws IOException { BufferedReader fListe = new BufferedReader(new FileReader("C:\\Users\\HP\\Desktop\\28Mars-Calcul\\combinaisons-selectionnées\\Trigram-Doublons-Supprimés.txt")); List <String> listeMots =new ArrayList<String>(); List <Integer> listeNbre =new ArrayList<Integer>(); String ligneL; while ((ligneL=fListe.readLine())!=null ){ listeMots.add(" "+ligneL+" "); listeNbre.add(0); } // str : corpus String str = FileUtils.readFileToString(new File("C:\\Users\\HP\\workspace\\testModif\\PartieCorpusApprentissageLemmatisé.txt")); // parcour de listeMots des patern à calculer for(int i=0; i<listeMots.size();i++) { int wordFound = StringUtils.countMatches(str,listeMots.get(i)); System.out.println("Nombre Occurrence '" + listeMots.get(i) + "' ="+wordFound); }   } }

---

juste une chose que j'ai remarqué que par exemple pour un mot "layer", il va même calculer le chaine qui existe dans un mot "player" . c'est pour cela j'ai ajouter des espaces dans

Code:

---

listeMots.add(" "+ligneL+" ");

---

et même dans le corpus texte j'ai fait un espace au début de chaque ligne pour pourvoir calculer le premier mot. Tu vas la trouver une idée trop banal , parce que j'ai pas trouver une autre!
Merci de me dire vos remarques a ce nouveau code
j'attends vos remarques ;)

foetus : merci pour ton idée , j'ai fait une autre idée tu peut l'avoir et donner ton avis ;)

Citation:

---

Envoyé par Wim88

Code:

---

1 2 3 4 5 6 7 8

List <String> listeMots =new ArrayList<String>(); List <Integer> listeNbre =new ArrayList<Integer>(); String ligneL; while ((ligneL=fListe.readLine())!=null ){ listeMots.add(" "+ligneL+" "); listeNbre.add(0); }

---

---

Une Map<String,Integer> est plus adapter à ton problème. Les mots clés seront les clés de ta Map et les valeurs seront les occurrences que tu incrémenteras par le résultat de StringUtils.countMatches

Citation:

---

Envoyé par Wim88

Code:

---

1 2 3

// str : corpus String str = FileUtils.readFileToString(new File("C:\\Users\\HP\\workspace\\testModif\\PartieCorpusApprentissageLemmatisé.txt"));

---

---

une nouvelle fois, tu stockes l'intégralité (voir doc) de ton corpus, qui visiblement peut-être assez important, dans une chaîne plutôt que de lire ton corpus ligne par ligne et d'appliquer ta cherche via StringUtils.countMatches à cette "petite chaîne" et ensuite d'incrémenter son occurrence.

http://commons.apache.org/proper/com...ava.io.File%29

Dans le doute, regarde le résultat de la commande ci-dessous et tu verras :

Code:

---

System.out.printf("Valeur de str : %s \nSa longueur est: %d\n",str, str.length());

---

De plus, la méthode readFileToString est annotée "Deprecated".

Citation:

---

Envoyé par plawyx

Une Map<String,Integer> est plus adapter à ton problème. Les mots clés seront les clés de ta Map et les valeurs seront les occurrences que tu incrémenteras par le résultat de StringUtils.countMatches

---

Pour le coup, l'objectif de la liste est d'etre parcourue pour trouver le nombre d'occurence de chaque mot. Une liste semble donc plus adaptée qu'une map. Meme si on pourrait se fendre d'un objet contenant String + int qui permettrait de faire les calculs (et qui eviterait de gaspiller les integer).

Pour revenir au probleme, comme pas mal de monde te l'a fait remarquer maintenant, il ne faut pas lire le fichier dans un string. Il faut, dans l'ordre :
1 - creer la liste de mots
2 - parcourir chaque ligne du fichier ou rechercher et incrementer le compteur en fonction de la présence de chacun des mots

Donc, il ne faut pas creer un string qui contient 1000 lignes. Il ne faut pas non plus creer un string qui contient tout le fichier. De maniere générale, il ne faut jamais faire ca. On n'est jamais sur de la taille du fichier qui sera ouvert et on risque de saturer la mémoire.

Citation:

---

Envoyé par Wim88

j'ai pas cru que les variables statique peuvent poser un problème!

---

Il n'y a aucun problème avec les attributs statiques... pour des données statiques !

Là tu les utilisais pour "passer" les variables d'une méthode à l'autre... bref à la place de paramètre ce qui est incorrect (et en plus cela rend le tout illisible) !

Citation:

---

Envoyé par Wim88

Voila j'ai pris en considération tes conseils et ça va c'est bon il calcule avec un temps de réponse très court ;)

---

C'est déjà bien mieux ! Et beaucoup plus lisible !
On peut désormais commencer à améliorer le code.

• Tu oublies toujours de libérer les ressources, soit via des try/finally (Java 6 et inférieur), soit via un try-with-ressource (à partir de Java 7).
  Cela peut paraitre anodin dans une application avec une si courte durée de vie, mais si tu inclus ton code dans une application qui va tourner plus longtemps (comme un serveur par exemple), cela risque de poser divers problèmes difficile à déceler.
  
• Comme plawyx et hwoarang te l'ont signalé, la double List n'est pas très pratique.
  Il serait plus approprié de créer un objet pour cela et une seule liste...
  
• Tu utilises FileUtils.readFileToString() qui lit tout le fichier en mémoire...
  C'est certes rapide mais également très consommateur en mémoire si tu as de gros fichiers comme tu le dit.
  Vue que tu ne sembles pas avoir besoin du fichier par la suite, une lecture ligne par ligne serait plus approprié.
  
• StringUtils.countMatches() avec un espace au début et à la fin ne marchera pas non plus pour les mots en début ou fin de ligne, ou séparé par des signes de ponctuations.
  Il serait préférable d'écrire son propre code plutôt que d'utiliser quelque chose qui fait "pas tout à fait" ce que l'on veut.
  Surtout que c'est pas bien méchant à faire (une boucle sur indexOf()), et que du coup on peut faire les vérifications supplémentaires selon notre besoin (vérifier qu'il n'y ait pas une lettre avant ou après le mot).

Bref pour moi cela donnerait ceci (en Java 6) :

Code:

---

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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

class WordCount { private final String word; private int count;   public WordCount(String word) { this.word = word; }   public String getWord() { return word; }   public int getCount() { return count; }   /**          * Scan d'un texte afin de compter le nombre d'occurence du mot.          */ public void scan(String text) { final int len = this.word.length(); int startIndex = 0;   // On recherche l'index de l'occurence suivante du mot : while ((startIndex = text.indexOf(this.word, startIndex)) >= 0) { int endIndex = startIndex + len; // On vérifie que le caractère précédent ne soit pas une lettre : boolean prevCharIsOK = (startIndex == 0) || !Character.isLetter(text.charAt(startIndex - 1)); // On vérifie que le caractère suivant ne soit pas une lettre : boolean nextCharIsOK = (endIndex == text.length()) || !Character.isLetter(text.charAt(endIndex));   // Si les caractères précédent et suivant sont correct : if (prevCharIsOK && nextCharIsOK) { // on incrémente le compteur : this.count++; } // puis on incrémente l'index pour passer à la suite : startIndex += len; } }   /**          * Lecture des mots dans un fichier (ligne par ligne)          */ private static List<WordCount> readWordCounts(String fileName) throws IOException { List<WordCount> list = new ArrayList<WordCount>(); BufferedReader reader = new BufferedReader(new FileReader(fileName)); try { String line; while ((line = reader.readLine()) != null) { list.add(new WordCount(line.trim())); } } finally { reader.close(); } return list; }   /**          * Recherche du nombre d'occurence des mots du fichier 'wordFileName', dans          * le texte contenu dans le fichier 'fileName',          */ public static List<WordCount> searchWords(String fileName, String wordFileName) throws IOException { List<WordCount> words = readWordCounts(wordFileName); BufferedReader reader = new BufferedReader(new FileReader(fileName)); try { String line; while ((line = reader.readLine()) != null) { for (WordCount word : words) { word.scan(line); }   } } finally { reader.close(); } return words; }   public static void main(String[] args) throws IOException {   List<WordCount> words = searchWords("corpus.txt", "test.txt");   for (WordCount word : words) { System.out.println(word.getWord() + " = " + word.getCount()); } } }

---

a++

adiGuba

j'ai une petite question: je suis en train de bossser les Stream et lambdas de java8. grâce à la méthode inLines(), on peut créér un Stream sur un objet BufferedReader. Pour stocker les Mots clés, on peut rapidement:

Code:

---

1 2 3

final Stream<String>streamTest = FichierMotsCles.lines(); final Map<String,Integer> mapMotsCles = streamTest.collect(Collectors.toMap(s -> s, s -> 0));

---

idem pour le stream sur le corpus

Code:

---

Stream<String>streamCorpus = FichCorpus.lines();

---

L'obtention avec le bon filter (ex: filter(s -> s.contains("pipo))) (lambdas simple qui ne correspond pas complètement au cas de la discussion général) pour un mot clé et son occurrence avec un Collectors se fait sans trop de problème. Par contre, je sèche un peu pour réaliser tout le traitement en un seule ligne de code du style:

Code:

---

Map<String, Long> ResMotsCles = streamCorpus.filter(??).flatMap(???).collect(Collectors.groupingBy(String::toString,Collectors.counting()));

---

Dans le but aussi d'utiliser parallelStream().


Si tu as une idée, une piste.

Merci d'avance.

Citation:

---

Envoyé par plawyx

Si tu as une idée, une piste.

---

Ta piste est bonne : il faut bien utiliser collect() !
Par contre c'est trop spécifique, et tu ne trouveras pas de Collector tout fait, et il faudra coder le tiens ou le créer via Collector.of().
Bref ca tiendra pas en une ligne ;)





Un Collector simple peut se composer de trois fonctions :

• Le supplier qui va créer les objets de codans lequel seront stocké les données (Map<String,Integer> dans notre cas).
  Je dis bien les objets car en parallèle plusieurs Map<String,Integer> pourront être créées (j'y reviens plus bas).
  
• Un accumulator, qui consiste à prendre les données brutes (une ligne du fichier dans notre cas), pour l'insérer dans l'objet de collecte (la Map).
  Dans notre cas c'est cette méthode qui devra compter les occurrences des mots pour renseigner la Map...
  
• Un combiner, qui consiste à combiner les données de deux collectes en un seul objet.
  Dans notre cas cela consistera donc à fusionner deux Map<String,Integer> en une seule.
  Pourquoi cela ? Pour l'exécution parallèle !
  Lorsqu'on exécute la collecte en parallèle, chaque thread aura sa propre Map qu'il renseignera petit à petit (sans soucis de synchronisation du coup).
  Et à la fin le combiner sera utiliser pour regrouper les données...

Au final cela pourrait donner quelque chose comme cela :

Code:

---

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 73 74 75 76 77 78 79 80 81 82

public class Main {   public static void main(String... args) throws Exception { // On lit chaque ligne du fichier des mots dans une liste. // On peut directement passer par readAllLines() // (pas besoin de Stream) List<String> keywords = Files.readAllLines(Paths.get("test.txt"));   // On lit le fichier content le texte : try (BufferedReader br = Files.newBufferedReader(Paths.get("corpus.txt"))) { // On traite le fichier ligne par ligne, via l'API de Stream // Et on utilise un Collector pour obtenir le résultat : Map<String, Integer> result = br.lines() .collect(Collector.of( HashMap::new, // Supplier (map, line) -> accumulate(keywords, map, line), // Accumulator Main::combine) // Combiner );   // On affiche le résultat result.forEach((k, v) -> System.out.println(k + " = " + v)); } }   /**      * Méthode permettant de compléter la map avec le nombre d’occurrence des mots.      *      * @param keywords La liste des mots-clef à rechercher.      * @param map La map à compléter.      * @param text Le texte à analyser.      */ private static void accumulate(Iterable<String> keywords, Map<String, Integer> map, String text) { // Pour chacun des mots de notre liste : for (String word : keywords) { // On compte le nombre d'occurence du mot dans le texte : int count = scan(text, word); // Et on ajoute cela dans la Map // merge() permet de gérer le cas où la Map comporte déjà une valeur. map.merge(word, count, Integer::sum); } }   /**      * Méthode permettant de regrouper les données de deux map en une seule.      */ private static Map<String, Integer> combine(Map<String, Integer> map1, Map<String, Integer> map2) { map2.forEach((k, v) -> { map1.merge(k, v, Integer::sum); });   return map1; }     // J'ai copié/collé et un peu adapté le code de la méthode scan() posté plus haut, // Pour compter le nombre d’occurrence d'un mot dans un texte : private static int scan(String text, String word) { final int len = word.length(); int startIndex = 0;   int count = 0; // On recherche l'index de l'occurence suivante du mot : while ((startIndex = text.indexOf(word, startIndex)) >= 0) { int endIndex = startIndex + len; // On vérifie que le caractère précédent ne soit pas une lettre : boolean prevCharIsOK = (startIndex == 0) || !Character.isLetter(text.charAt(startIndex - 1)); // On vérifie que le caractère suivant ne soit pas une lettre : boolean nextCharIsOK = (endIndex == text.length()) || !Character.isLetter(text.charAt(endIndex));   // Si les caractères précédent et suivant sont correct : if (prevCharIsOK && nextCharIsOK) { // on incrémente le compteur : count++; } // puis on incrémente l'index pour passer à la suite : startIndex += len; } return count; } }

---

A noter qu'on peut améliorer un peu plus notre Collector en spécifiant qu'il n'est pas ordonné :

Code:

---

1 2 3 4 5

.collect(Collector.of( HashMap::new, // Supplier (map, line) -> accumulate(keywords, map, line), // Accumulator Main::combine, // Combiner Characteristics.UNORDERED)

---

En effet dans notre cas l'ordre des données importe peu, puisque la lecture d'une ligne avant ou après l'autre n'aura aucun impact sur le résultat final.
En déclarant notre collector comme UNORDERED, on dit à la méthode collect() qu'elle n'a pas à se soucier de respecter l'ordre des données...



a++

Citation:

---

Envoyé par adiGuba

[list][*] Tu oublies toujours de libérer les ressources, soit via des try/finally (Java 6 et inférieur), soit via un try-with-ressource (à partir de Java 7).
Cela peut paraitre anodin dans une application avec une si courte durée de vie, mais si tu inclus ton code dans une application qui va tourner plus longtemps (comme un serveur par exemple), cela risque de poser divers problèmes difficile à déceler.

---

oui oui J'ai modifié le code :) et j'ai ajouté le try/finally
et pour le code que tu m'a envoyé , il est très intéressant et je vais l'exploiter prochainement ;)
Grand merci :) :) :)

Citation:

---

Envoyé par plawyx

Une Map<String,Integer> est plus adapter à ton problème. Les mots clés seront les clés de ta Map et les valeurs seront les occurrences que tu incrémenteras par le résultat de StringUtils.countMatches

---

J'ai essayé de tester le code avec la totalité de corpus pour voir à quel point je dois le modifier , l'autre fois , il a resté des Jours à tourner sans résultat, cette fois , il a resté 2 heures et il a donné de résultats et j'ai atteint le but désuré :ptdr:
Pour l'utilisation de Map , j'ai la pas utilisé cette fois , mais je suis sure que je vais l'utiliser dans mon prochain code et j'ai noté tous vos remarques et je vais les prendre en considération :)
Vraiment vous m'avez donné la motivation d'améliorer mes compétences :)
Merci plawyx
Merci à Vous tous, surtout de votre patience avec moi
Vous êtes super :)

Citation:

---

Envoyé par Wim88

Pour l'utilisation de Map , j'ai la pas utilisé cette fois

---

La fonction de la Map est d'associer 1 objet qui représente un contenu à un objet qui représente un identifiant. Ca permet de chercher beaucoup plus rapidement que dans une liste l'objet à partir de son identifiant. Le cas d'école, c'est la base de données dans laquelle tu inseres tes villes. La base attribue un ID à chaque ville. Tu mets dans la Map toutes tes villes en utilisant comme identifiant l'ID. Et quand tu fais un traitement sur l'une d'elles, tu va les recuperer via l'ID.
Mais dans ton cas, la liste de mots a vocation à etre parcourue dans l'ordre à chaque fois. La liste est donc bien plus adaptée.

Concernant ton probleme, si tu as fait tout ce qu'il a été dit, c'est difficile de faire mieux simplement. Apres, si tu as beaucoup de mots, il y a la solution d'essayer de ne pas parcourir chaque ligne de ton fichier pour chaque mot. Par exemple en stockant tes mots dans une structure de type arbre. Mais bon, c'est pas le meme niveau de complexité. Pour qu'un algo s'execute plus vite, c'est souvent un compromis entre complexité/consommation mémoire. A voir si tu as besoin de ca...