Compter le nombre de bigrammes avec tokeniseur

Version imprimable

Bonjour,

J'ai fait un tokeniseur qui compte le nombre de fois ou un mot apparait dans un texte(cas unigramme). J'aimerais continuer pour compter le nombre de bigramme aussi pour àprès pour estimer les log probabilités. Est-ce que quelqu'un peut m'expliquer comment continuer sinon me donner un petit coup de main. Voici mon code :

*****classe pour compter le nombre d'occurence************

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
package fil;
 
public class Element {
    private String mot;
    private int nbOcc;
    public Element(String mot) {
        this.mot = new String(mot);
        nbOcc=1;
        }
    public String getMot() {
       return mot;
    }
    public void setMot(String mot) {
        this.mot = mot;
    }
    public int getNbOcc() {
        return nbOcc;
    }
    public void setNbOcc(int nbOcc) {
        this.nbOcc = nbOcc;
    }
    public boolean equals(String unMot){
        return mot.equals(unMot);
       }
    public void inc(){
        nbOcc++;
     }
 
  public void afficher(){
   System.out.println (mot+ "->" +nbOcc);
 
    }
}

*********classe pour le parcours des mots**********

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
package fil;
public class ListeC {
    int queue;
    int max;
    Element[] tab;
    public ListeC(){
                        max=1000000;
                        tab= new Element[max];
                         queue=-1;
                            }
 
    public void adjq(Element v){
                        tab[queue+1]=v;
                        queue=queue+1;
                         }
 
    public void supq(){
                        queue=queue-1;
                         }
 
    public void afficher(){
 
        for(int i=0; i<queue+1; i++){
 
            tab[i].afficher();
               }
        }
   public void ajouter (String mot){
                    int p=0;
                    boolean trouve = false;
                    while (p<=queue && !trouve){
                    if (tab[p].equals(mot)){
                           trouve=true;
                                            }
                    else{
                        p=p+1;
                          }
                                    }
 
        if (trouve) {
 
            tab[p].inc();
 
        }
 
        else {
 
            adjq(new Element(mot));
        }
    }
}

*********classe pour l'ouverture du fichier contenant les mots*************

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
package fil;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.StringTokenizer;
import javax.swing.JFileChooser;
public class tester {
 public static void main(String [] t){
 
        lirefichier();
    }
 
    public static void lirefichier(){
       ListeC l = new ListeC();
        try {
 
       JFileChooser dialogue = new JFileChooser("lexique.fr");
        File fichier;
            if (dialogue.showOpenDialog(null) == JFileChooser.APPROVE_OPTION)
            {
 
               fichier = dialogue.getSelectedFile();
                       }
 
            else{
            fichier = new File("exemple"); //attention si le fichier n'existe pas !!
                 }
            Scanner sc = new Scanner(fichier);
            while (sc.hasNext())
                   {
                String uneligne = sc.nextLine();
              StringTokenizer st = new StringTokenizer(uneligne);
            while (st.hasMoreTokens())
                {
                   l.ajouter(st.nextToken());
 
                }
 
            }
 
        } catch (FileNotFoundException e) {
 
            System.out.println("pas de fichier");
 
            e.printStackTrace();
 
        }
 
        l.afficher();
    }
 
}

04/12/2015, 17h24
francky74

Bonjour,

Déjà en tout premier lieu, la convention de nommage java veut que les noms des classes commencent par une lettre majuscule.

Donc, ici, ta classe ester devrait porter le nom : Tester.

Qu'appelles tu, s'il te plaît les bigrammes ?

les lettre "ph", "ch" etc ??

Je jette un oeil et je te ré-écris ;)
04/12/2015, 20h32
flanojilden

sa me feras vraiment plaisir et donner moi coups de main d'ici le 7(lundi) s'il vous plait
04/12/2015, 20h34
flanojilden

exemple de bigramme: les bigramme d'un texte c'est les mots pris 2 à 2
phrase: je vais a la maison
les bigrammes de cette phrase sont: ''je vais'' ''vais a'' ''a la'' ' 'la maison''

Salut,

L'ordre des mots compte dans un bigramme ? (je, vais) et (vais, je) sont 2 bigrammes distincts ou 1 seul ?

En tout cas, pour la base de ce que tu veux faire, fais d'abord une classe Bigramme, qui a pour attribut les 2 mots. Et la liste sera List<Bigramme> listeDeBigrammes=new ArrayList<>();.

Ensuite, le principe en gros, c'est d'utiliser la même méthode que tu utilises pour créer les unigrammes :

Code:

1
2
3
4
5
6
7
8
StringTokenizer st = new StringTokenizer(uneligne);
            while (st.hasMoreTokens())
                {
                   l.ajouter(st.nextToken());
 
                }
 
            }

Simplement, il faut mémoriser tout token pour l'associer à son suivant, dans une variable.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
String token1 = null;
StringTokenizer st = new StringTokenizer(uneligne);
while (st.hasMoreTokens()) {
     String token2 =  st.nextToken()
 
     // ...
 
     // créer le brgramme
     Bigramme bigramme = new Bigramme( token1, token2 );
     // tester si ce bigramme existe déjà (voir ma question du début)
     if  ( ... ) {
         listeDeBigrammes.ajouter(bigramme);
     }
 
     token1 = token2; // le token courant devient le premier pour le token suivant
 
}

le // ... c'est parce que lors de la récupération du premier token dans token2, on n'a pas encore de premier token pour le bigramme : token1 est null. On ignore donc ce cas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
String token1 = null;
StringTokenizer st = new StringTokenizer(uneligne);
while (st.hasMoreTokens()) {
     String token2 =  st.nextToken()
 
     if( token1!=null) {
 
        // créer le brgramme
        Bigramme bigramme = new Bigrammed( token1, token2 );
        // tester si ce bigramme existe déjà si necessaire (voir ma question du début)
        if  ( ... ) {
            listeDeBigrammes.ajouter(bigramme);
        }
     }
 
     token1 = token2; // le token courant devient le premier pour le token suivant
 
}

04/12/2015, 21h23
flanojilden

on delimite les bigramme dans l'odre dans lequel il est donnée dans le texte meme.
Exemple: je vais a la maison
les bigrammes sont: '' je vais" "vais a " "a la" "la maison"
on compte seulement: je vais => 1 bigramme
vais a=>1 bigramme
a la => 1 bigramme
la maison=> 1 bigramme
(on ne compte pas en sens inverse comme "vais je")

donc dans cette phrase on a 4 bigramme
04/12/2015, 21h56
joel.drigo

Je n'ai pas parlé de sens inverse : j'ai demandé si dans un même texte on avait 2 fois le même couple de mots dans un ordre différent, on comptait ça comme 1 bigramme ou 2 bigrammes distincts ! C'est par phrase ou par texte les bigrammes, parce que les unigrammes c'est par texte dans ton code !

"Je vais à la maison ! Y vais-je seul ?" (je, vais) et (vais, je), un bigramme ou 2 bigrammes ?
"Je cire la chaussure droite à la cire d'abeilles !" (cire, la) et (la, cire), un bigramme ou 2 bigrammes ?
"Je ne peux pas mettre de point de suspension à la fin de cette phrase. C'est une interrogation !" (de, point) (point, de) !
"Je m'effraie de savoir que cette effraie m'irrite à tel point". (m, effraie) et (effraie, m)....
04/12/2015, 23h28
flanojilden

desoler j'avais pas bien c'est saisie oui c'est cas compter comme 2 bigrammes different parceque l'ordre des mots compte donc: "je vais" et "vais je" sont bien 2 bigrammes differents

Ok, tant mieux, parce que c'est le cas le plus simple, et c'est ce que je t'ai montré, sans le test évidemment :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
String token1 = null;
StringTokenizer st = new StringTokenizer(uneligne);
while (st.hasMoreTokens()) {
 
     String token2 =  st.nextToken()
 
     if( token1!=null) {
 
        // créer le brgramme
        Bigramme bigramme = new Bigramme( token1, token2 );
        listeDeBigrammes.ajouter(bigramme);
 
    }
 
    token1 = token2; // le token courant devient le premier pour le token suivant
 
}

Avec une classe Bigramme avec 2 attributs String (et les getters qui correspondent).