Jean-François Rey / otmedia

Download as
Browse Code »

Commit a564ec1e5b7fd3ebbd26ff5be90d9dc021367622

Authored by Jean-François Rey
1 parent eb3773e12a
Exists in master

bugfix 

update SIGMUND source and bin to take file in argument
update script to request SOLR

Showing 15 changed files with 174 additions and 173 deletions Side-by-side Diff

main_tools/ExploitConfidencePass.sh
Diff comments   View file @ a564ec1
... ... @@ -212,10 +212,8 @@
212 212 rm $INPUT_DIR/$BASENAME.tmp #$INPUT_DIR/$BASENAME.taglem
213 213  
214 214 # Lia_topic_seg : bring together sentences into show
215   -cp $INPUT_DIR/$BASENAME.doc.xml 0.xml
216   -java -cp $LIATOPICSEG/bin Test > $INPUT_DIR/show.seg
  215 +java -cp $LIATOPICSEG/bin Test $INPUT_DIR/$BASENAME.doc.xml > $INPUT_DIR/show.seg
217 216 cat $INPUT_DIR/show.seg | $SIGMUND_BIN/toSegEmiss.pl $INPUT_DIR/$BASENAME.show.seg
218   -rm 0.xml $INPUT_DIR/show.seg
219 217  
220 218 if [ $CHECK -eq 1 ]
221 219 then
main_tools/OneScriptToRuleThemAll.sh
Diff comments   View file @ a564ec1
... ... @@ -142,7 +142,7 @@
142 142  
143 143 shift $((OPTIND-1))
144 144 # check audio file - First argument
145   -if [ -e $1 ] && [ -s $1 ]
  145 +if [ $p1 -eq 0 ] || [[ -e $1 && -s $1 ]]
146 146 then
147 147 echo -e "$LORD\n"
148 148 REP_OUT=$2/$(basename ${1%.*})
tools/SIGMUND/LIA_topic_seg/bin/Test.class
Diff comments   View file @ a564ec1
No preview for this file type
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Boundaries.java
Diff comments   View file @ a564ec1
1 1 package LIA_topic_seg;
2 2  
3 3 /**
4   - * Cette interface est dŽdiŽe ˆ la sŽlection des frontires ˆ partir d'un tableau de valeurs
5   - * associŽes ˆ chaque intervalle entre deux unitŽs de traitement.
6   - * La sŽlection peut se faire ˆ partir d'un nombre connu de frontires ou non, l'essentiel Žtant
7   - * de fournir un sous ensemble des intervalles du texte en rŽponse.
  4 + * Cette interface est dédiée à la sélection des frontières à partir d'un tableau de valeurs
  5 + * associées à chaque intervalle entre deux unités de traitement.
  6 + * La sélection peut se faire à partir d'un nombre connu de frontières ou non, l'essentiel étant
  7 + * de fournir un sous ensemble des intervalles du texte en réponse.
8 8 *
9 9 *
10 10 */
11 11 public interface Boundaries {
12 12 /**
13   - * retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques
14   - * @return un tableau d'entiers qui sont les frontires thŽmatiques
  13 + * retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques
  14 + * @return un tableau d'entiers qui sont les frontières thématiques
15 15 */
16 16 public int[] position_boundaries();
17 17 /**
18   - * renvoie le nombre de segments thŽmatiques dŽduits
  18 + * renvoie le nombre de segments thématiques déduits
19 19 * @return un nombre
20 20 */
21 21 public int count_segments();
22 22 /**
23   - * permet de conna”tre le nombre de frontires thŽmatiques ˆ l'intŽrieur du texte
24   - * Il se peut que ce nombre soit infŽrieur ˆ un nombre initialisŽ.
25   - * @return le nombre de frontires thŽmatiques
  23 + * permet de connaître le nombre de frontières thématiques à l'intérieur du texte
  24 + * Il se peut que ce nombre soit inférieur à un nombre initialisé.
  25 + * @return le nombre de frontières thématiques
26 26 */
27 27 public int count_boundaries();
28 28 /**
29   - * Cette fonction permet de suivre l'Žvolution du programme en affichant les valeurs calculŽes
30   - * @return une cha”ne de caractre o chaque ligne est un numŽro de frontire thŽmatique
  29 + * Cette fonction permet de suivre l'évolution du programme en affichant les valeurs calculées
  30 + * @return une chaîne de caractère où chaque ligne est un numéro de frontière thématique
31 31 */
32 32 public String toString();
33 33 }
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultBoundaries.java
Diff comments   View file @ a564ec1
... ... @@ -3,16 +3,16 @@
3 3 import java.util.*;
4 4  
5 5 /**
6   - * Cette classe implŽmente des calculs de frontires consŽcutifs aux calculs de valeurs des intervalles
7   - * entre les unitŽs de traitement effectuŽs dans DefaultGapScores.
8   - * Elle permet de dŽduire les frontires ˆ partir des similaritŽs cosine, ou des profondeurs de similaritŽs.
9   - * Dans le premier cas on cherchera ˆ minimiser les scores, dans le second ˆ les maximiser. Pour les similaritŽs,
10   - * lissŽes ou non, on peut Žgalement rechercher des minimas locaux dans une certaine fentre, ce qui revient en fait
11   - * ˆ fixer une taille minimale des segments.
12   - * Ces fonctions peuvent retourner un nombre de frontires prŽdŽfini dans le constructeur, ou bien peuvent
13   - * retourner les frontires en deˆ ou au delˆ d'un certain seuil, calculŽ en fonction de la moyenne et l'Žcart type
14   - * de l'ensemble des scores des intervalles entre unitŽs de traitement.
15   - * Toutes les fonctions travaillent directement sur l'attribut topic_boundaries et le mettent ˆ jour.
  6 + * Cette classe implémente des calculs de frontières consécutifs aux calculs de valeurs des intervalles
  7 + * entre les unités de traitement effectués dans DefaultGapScores.
  8 + * Elle permet de déduire les frontières à partir des similarités cosine, ou des profondeurs de similarités.
  9 + * Dans le premier cas on cherchera à minimiser les scores, dans le second à les maximiser. Pour les similarités,
  10 + * lissées ou non, on peut également rechercher des minimas locaux dans une certaine fenêtre, ce qui revient en fait
  11 + * à fixer une taille minimale des segments.
  12 + * Ces fonctions peuvent retourner un nombre de frontières prédéfini dans le constructeur, ou bien peuvent
  13 + * retourner les frontières en deçà ou au delà d'un certain seuil, calculé en fonction de la moyenne et l'écart type
  14 + * de l'ensemble des scores des intervalles entre unités de traitement.
  15 + * Toutes les fonctions travaillent directement sur l'attribut topic_boundaries et le mettent à jour.
16 16 *
17 17 *
18 18 */
19 19  
... ... @@ -24,9 +24,9 @@
24 24 float coef = -1;
25 25  
26 26 /**
27   - * Constructeur de la classe avec un nombre prŽdŽfini de frontires thŽmatiques
  27 + * Constructeur de la classe avec un nombre prédéfini de frontières thématiques
28 28 * @param bw : le calcul des scores de tous les intervalles
29   - * @param n : le nombre de frontires ˆ rechercher
  29 + * @param n : le nombre de frontières à rechercher
30 30 */
31 31 public DefaultBoundaries(GapsScores bw, int n) {
32 32  
33 33  
... ... @@ -39,10 +39,10 @@
39 39  
40 40  
41 41 /**
42   - * Constructeur de la classe avec un nombre inconnu de frontires thŽmatiques,
43   - * et un coefficient multiplicateur de prise en compte de l'Žcart type
  42 + * Constructeur de la classe avec un nombre inconnu de frontières thématiques,
  43 + * et un coefficient multiplicateur de prise en compte de l'écart type
44 44 * @param bw : le calcul des scores de tous les intervalles
45   - * @param c : le seuil de dŽcision sera = moyenne + c*ecart_type
  45 + * @param c : le seuil de décision sera = moyenne + c*ecart_type
46 46 */
47 47 public DefaultBoundaries(GapsScores bw, float c) {
48 48  
... ... @@ -52,8 +52,8 @@
52 52 }
53 53  
54 54 /**
55   - * Constructeur de la classe avec un nombre inconnu de frontires thŽmatiques, et un coefficient de
56   - * prise en compte de l'Žcart type par dŽfaut
  55 + * Constructeur de la classe avec un nombre inconnu de frontières thématiques, et un coefficient de
  56 + * prise en compte de l'écart type par défaut
57 57 * @param bw : le calcul des scores de tous les intervalles
58 58 */
59 59 public DefaultBoundaries(GapsScores bw) {
60 60  
... ... @@ -63,14 +63,14 @@
63 63 }
64 64  
65 65 /**
66   - * Cette fonction calcule les frontires en recherchant les plus petites similaritŽs, puis en vŽrifiant que ces frontires ont une valeur infŽrieurs ˆ leurs voisines.
67   - * Pour cela, on effectue d'abord un tri des frontires en fonction de leurs valeurs, puis on sŽlectionne dans l'ordre celles qui n'ont pas de "proches voisins" dŽjˆ sŽlectionnŽ.
68   - * @param window : fentre dans laquelle on souhaite que les valeurs retenues soient minimales. On peut Žgalement considŽrer ce paramtre comme une taille minimale des segments.
  66 + * Cette fonction calcule les frontières en recherchant les plus petites similarités, puis en vérifiant que ces frontières ont une valeur inférieurs à leurs voisines.
  67 + * Pour cela, on effectue d'abord un tri des frontières en fonction de leurs valeurs, puis on sélectionne dans l'ordre celles qui n'ont pas de "proches voisins" déjà sélectionné.
  68 + * @param window : fenêtre dans laquelle on souhaite que les valeurs retenues soient minimales. On peut également considérer ce paramètre comme une taille minimale des segments.
69 69 */
70 70 public void compute_loc_min(int window){
71   - //cette fonction est valable pour les calculs basŽs uniquement sur des cosinus ou Žquivalents
72   - //mme fonctionnement que compute_minimas sauf qu'on vŽrifie que la frontire est seule dans une fentre
73   - //la valeur de cette fentre permet de dŽterminer une taille minimale des segments
  71 + //cette fonction est valable pour les calculs basés uniquement sur des cosinus ou équivalents
  72 + //même fonctionnement que compute_minimas sauf qu'on vérifie que la frontière est seule dans une fenêtre
  73 + //la valeur de cette fenêtre permet de déterminer une taille minimale des segments
74 74 Comparator comparateur = new Comparator() {
75 75 public int compare(Object i1, Object i2){
76 76  
77 77  
... ... @@ -186,13 +186,13 @@
186 186 }
187 187  
188 188 /**
189   - * Cette fonction dŽduit les frontires thŽmatiques on sŽlectionnant les n plus petites si le nombre de frontires ˆ sŽlectionners est prŽdŽfini,
190   - * ou en sŽlectionnant toutes celles sous un certain seuil (moyenne - ecart-type) sinon.
  189 + * Cette fonction déduit les frontières thématiques on sélectionnant les n plus petites si le nombre de frontières à sélectionners est prédéfini,
  190 + * ou en sélectionnant toutes celles sous un certain seuil (moyenne - ecart-type) sinon.
191 191 *
192 192 */
193 193 public void compute_min_similarities(){
194   - //cette fonction renvoie les plus petits scores comme frontires .
195   - //peut tre exŽcutŽe aprs calcul des similaritŽs.
  194 + //cette fonction renvoie les plus petits scores comme frontières .
  195 + //peut être exécutée après calcul des similarités.
196 196 Comparator comparateur = new Comparator() {
197 197 public int compare(Object i1, Object i2){
198 198  
199 199  
200 200  
... ... @@ -257,14 +257,14 @@
257 257  
258 258  
259 259 /**
260   - * Cette fonction dŽduit les frontires thŽmatiques on sŽlectionnant les n plus grandes valeurs si le nombre de frontires ˆ sŽlectionners est prŽdŽfini,
261   - * ou en sŽlectionnant toutes celles au dessus un certain seuil (moyenne + ecart-type) sinon.
  260 + * Cette fonction déduit les frontières thématiques on sélectionnant les n plus grandes valeurs si le nombre de frontières à sélectionners est prédéfini,
  261 + * ou en sélectionnant toutes celles au dessus un certain seuil (moyenne + ecart-type) sinon.
262 262 *
263 263 */
264 264 public void compute_max_depth(){
265   - // cette fonction permet de dŽterminer les frontires ˆ partir des depth scores
  265 + // cette fonction permet de déterminer les frontières à partir des depth scores
266 266 //on recherche alors les intervalles candidats ayant les plus grands scores
267   - //le nombre est dŽterminŽ par boundaries ou bien ŽvaluŽ avec la moyenne et l'Žcart type
  267 + //le nombre est déterminé par boundaries ou bien évalué avec la moyenne et l'écart type
268 268 Comparator<Integer> comparateur = new Comparator<Integer>() {
269 269 public int compare(Integer i1, Integer i2){
270 270  
271 271  
... ... @@ -324,10 +324,10 @@
324 324  
325 325  
326 326 /**
327   - * retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques
  327 + * retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques
328 328 */
329 329 public int[] position_boundaries(){
330   - //retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques
  330 + //retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques
331 331 return topic_boundaries;
332 332  
333 333 }
... ... @@ -347,7 +347,7 @@
347 347  
348 348 public String to_string(){
349 349 java.io.StringWriter w = new java.io.StringWriter();
350   - w.write("placement des frontires \n");
  350 + w.write("placement des frontières \n");
351 351 for (int i=0 ; i<topic_boundaries.length ; i++){
352 352 w.write(topic_boundaries[i] + "\n");
353 353 }
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultConfig.java
Diff comments   View file @ a564ec1
... ... @@ -11,7 +11,7 @@
11 11 import org.apache.commons.cli.*;
12 12  
13 13 /**
14   - * Cette classe regroupe des paramtres de configuration
  14 + * Cette classe regroupe des paramètres de configuration
15 15 *
16 16 * This product includes software developed by the
17 17 * Apache Software Foundation (http://www.apache.org/)."
18 18  
19 19  
20 20  
21 21  
... ... @@ -57,18 +57,18 @@
57 57 //--------------------------------------------------------------------------
58 58 private void init() throws Exception
59 59 {
60   - // tag "phrase" dans le fichier d'entrée
  60 + // tag "phrase" dans le fichier d'entrÈe
61 61 setParam("inputDataSentenceXmlTag","phr");
62   - // tag "lemme d'une phrase" dans le fichier d'entrée
  62 + // tag "lemme d'une phrase" dans le fichier d'entrÈe
63 63 setParam("inputDataWordsXmlTag", "wd");
64   - // tag "poids d'un lemme dans une phrase" dans le fichier d'entrée
  64 + // tag "poids d'un lemme dans une phrase" dans le fichier d'entrÈe
65 65 setParam("inputDataLemmaXmlTag", "lem");
66   - // tag "poids d'un lemme dans une phrase" dans le fichier d'entrée
  66 + // tag "poids d'un lemme dans une phrase" dans le fichier d'entrÈe
67 67 setParam("inputDataLemmaWeightXmlTag", "poids");
68 68 // mode de calcul du hiatus et de sa prise en compte
69 69 // rien = pas de prise en compte du hiatus
70 70 // un nombre = valeur du hiatus
71   - // ADAPTIV = valeur du hiatus à calculer localement
  71 + // ADAPTIV = valeur du hiatus ‡ calculer localement
72 72 setParam("lexicalChainsHiatus", "11");
73 73 setParam("computeChains", "weight");
74 74 }
... ... @@ -131,8 +131,8 @@
131 131 }
132 132 //--------------------------------------------------------------------------
133 133 /**
134   - * Cette fonction permet d'accŽder aux paramtres, qu'ils aient ŽtŽ mis par dŽfaut, ou passŽs par le fichier de configuration,
135   - * ou encore passŽs en ligne de commande.
  134 + * Cette fonction permet d'accéder aux paramètres, qu'ils aient été mis par défaut, ou passés par le fichier de configuration,
  135 + * ou encore passés en ligne de commande.
136 136 * @param n name of parameter
137 137 * @return content of parameter or null if the parameter does not exist
138 138 */
... ... @@ -142,7 +142,7 @@
142 142 }
143 143 //--------------------------------------------------------------------------
144 144 /**
145   - * Cette fonction permet de rŽcupŽrer les paramtres passŽs en ligne de commande
  145 + * Cette fonction permet de récupérer les paramètres passés en ligne de commande
146 146 * les valeurs sont prioritaires sur le fichier de configuration en cas de conflit.
147 147 */
148 148 public String[] setParamsFromCmdLine(String[] args) throws Exception
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultGapsScores.java
Diff comments   View file @ a564ec1
... ... @@ -2,8 +2,8 @@
2 2  
3 3 import java.util.*;
4 4 /**
5   - * Cette classe permet le calcul de probabililtŽs de rupture ˆ chaque intervalle entre deux phrases, ou unitŽs textuelles.
6   - * Les calculs implŽmentŽs sont la similaritŽ cosine et les profondeurs de dissimilaritŽ.
  5 + * Cette classe permet le calcul de probabililtés de rupture à chaque intervalle entre deux phrases, ou unités textuelles.
  6 + * Les calculs implémentés sont la similarité cosine et les profondeurs de dissimilarité.
7 7 *
8 8 *
9 9 */
10 10  
... ... @@ -15,10 +15,10 @@
15 15 static int SIM_WINDOW = 3;
16 16  
17 17 public DefaultGapsScores (LexicalChainList lcl, int sc){
18   - //crŽation du tableau des probas de rupture pour chaque phrase/sŽquence
  18 + //création du tableau des probas de rupture pour chaque phrase/séquence
19 19 chains = lcl;
20 20 sentence_count = sc;
21   -// System.out.print("nombre de phrases traitŽse : " + sc);
  21 +// System.out.print("nombre de phrases traitése : " + sc);
22 22 compute_cos();
23 23  
24 24 // for (int i= 0 ; i<sc; i++){
... ... @@ -28,7 +28,7 @@
28 28 }
29 29  
30 30 public DefaultGapsScores (LexicalChainList lcl, DefaultInputData in){
31   - //crŽation du tableau des probas de rupture pour chaque phrase/sŽquence
  31 + //création du tableau des probas de rupture pour chaque phrase/séquence
32 32 chains = lcl;
33 33 sentence_count = in.sentenceCount();
34 34 compute_cos();
35 35  
... ... @@ -36,11 +36,11 @@
36 36 }
37 37  
38 38 /**
39   - * transforme l'attribut gaps_scores en des scores de similaritŽs => on recherchera les plus petits
  39 + * transforme l'attribut gaps_scores en des scores de similarités => on recherchera les plus petits
40 40 *
41 41 */
42 42 public void compute_cos(){
43   -// transforme gaps_scores en des scores de similaritŽs => on recherchera les + petits
  43 +// transforme gaps_scores en des scores de similarités => on recherchera les + petits
44 44 gaps_scores = new float[sentence_count-1];
45 45 for (int senti = 0 ; senti< sentence_count-1 ; senti++){
46 46 float sup = 0;
47 47  
... ... @@ -80,12 +80,12 @@
80 80 }
81 81  
82 82 /**
83   - * Cette fonction opre un lissage sur l'attribut gaps_scores, pour chaque valeur elle la remplace
84   - * par la moyenne avec les valeurs prŽcŽdente et suivante.
85   - * @param w : fentre de lissage : elle est Žgale ˆ 1 quoi qu'il arrive
  83 + * Cette fonction opère un lissage sur l'attribut gaps_scores, pour chaque valeur elle la remplace
  84 + * par la moyenne avec les valeurs précédente et suivante.
  85 + * @param w : fenêtre de lissage : elle est égale à 1 quoi qu'il arrive
86 86 */
87 87 public void compute_smoothing(int w){
88   - //w est la fentre de lissage
  88 + //w est la fenêtre de lissage
89 89 float[] smooth_cos = new float[gaps_scores.length] ;
90 90 smooth_cos[0]= (gaps_scores[1]+2*gaps_scores[0])/3;
91 91 for (int i=1 ; i<gaps_scores.length-1 ; i++){
92 92  
93 93  
... ... @@ -93,19 +93,19 @@
93 93  
94 94 }
95 95 smooth_cos[gaps_scores.length-1]=(gaps_scores[gaps_scores.length-2]+gaps_scores[gaps_scores.length-1])/2;
96   - //System.out.print("dernier calculŽ" + smooth_cos[gaps_scores.length-1]);
  96 + //System.out.print("dernier calculé" + smooth_cos[gaps_scores.length-1]);
97 97  
98 98 gaps_scores = smooth_cos.clone();
99 99 }
100 100  
101 101 /**
102   - * Cette fonction, aprs calcul des similaritŽs, permet de sŽlectionner les frontires candidates
103   - * en recherchant les minimas locaux et en leur attribuant des valeurs liŽes ˆ la profondeur
104   - * de dissimilaritŽ.
105   - * Les rŽsultats sont directement reportŽs dans l'attribut gaps_scores
106   - * @return : le nombre de candidats pour lesquels une valeur a ŽtŽ calculŽe.
  102 + * Cette fonction, après calcul des similarités, permet de sélectionner les frontières candidates
  103 + * en recherchant les minimas locaux et en leur attribuant des valeurs liées à la profondeur
  104 + * de dissimilarité.
  105 + * Les résultats sont directement reportés dans l'attribut gaps_scores
  106 + * @return : le nombre de candidats pour lesquels une valeur a été calculée.
107 107 */
108   - public float compute_depth_scores(){ // retourne le nombre de depth calculŽes
  108 + public float compute_depth_scores(){ // retourne le nombre de depth calculées
109 109 //transforme gaps_scores en des scores de profondeur => on recherchera les + grands
110 110 int count = 0;
111 111 float[] depth_scores = new float [gaps_scores.length];
... ... @@ -113,7 +113,7 @@
113 113 depth_scores[gaps_scores.length-1]=0;
114 114 for (int i=1 ; i<gaps_scores.length-1 ; i++){
115 115 if (gaps_scores[i-1]>gaps_scores[i] && gaps_scores[i+1]>gaps_scores[i]){
116   - // on ne calcule les scores que des candidats, c'est ˆ dire les minimas locaux
  116 + // on ne calcule les scores que des candidats, c'est à dire les minimas locaux
117 117 float lmax = 0;
118 118 float rmax = 0;
119 119  
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultInputData.java
Diff comments   View file @ a564ec1
... ... @@ -10,20 +10,20 @@
10 10 import java.util.*;
11 11  
12 12 /**
13   - * Cette classe permet de charger les informations du fichier d'entrŽe, ainsi que d'Žditer le rŽsultat de la segmentation.
14   -* Le fichier d'entrŽe doit tre au format XML et les balises utilisŽes sont dŽterminŽes dans le fichier de configuration.
  13 + * Cette classe permet de charger les informations du fichier d'entrée, ainsi que d'éditer le résultat de la segmentation.
  14 +* Le fichier d'entrée doit être au format XML et les balises utilisées sont déterminées dans le fichier de configuration.
15 15 */
16 16 public class DefaultInputData
17 17 {
18 18 //--------------------------------------------------------------------------
19 19  
20 20 /**
21   - * la configuration, et donc les paramtres sont copiŽs dans l'objet
  21 + * la configuration, et donc les paramètres sont copiés dans l'objet
22 22 */
23 23 DefaultConfig config;
24 24  
25 25 /**
26   - * Le dictionnaire des lemmes est Žgalement portŽ par la reprŽsentation des donnŽes d'entrŽe
  26 + * Le dictionnaire des lemmes est également porté par la représentation des données d'entrée
27 27 */
28 28 LemmaDict lemmaDict = new LemmaDict();
29 29 private Sentence[] _sentenceList;
... ... @@ -71,7 +71,7 @@
71 71 }
72 72 //--------------------------------------------------------------------------
73 73 /**
74   - * Cette fonction est utilisŽe principalement pour le dŽbuggage, pour obtenir une trace des donnŽes d'entrŽe.
  74 + * Cette fonction est utilisée principalement pour le débuggage, pour obtenir une trace des données d'entrée.
75 75 */
76 76 public String toString()
77 77  
... ... @@ -101,9 +101,9 @@
101 101  
102 102  
103 103 /**
104   - * Cette fonction permet d'Žditer le rŽsultat de la segmentation au mme format que le fichier d'entrŽe, avec des balises <seg> pour dŽlilmiter les segments thŽmatiques
105   - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques
106   - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie.
  104 + * Cette fonction permet d'éditer le résultat de la segmentation au même format que le fichier d'entrée, avec des balises <seg> pour délilmiter les segments thématiques
  105 + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques
  106 + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie.
107 107 */
108 108 public String result_complete (Boundaries bounds){
109 109 int[] boundaries = bounds.position_boundaries().clone();
... ... @@ -143,10 +143,10 @@
143 143 }
144 144  
145 145 /**
146   - * Cette fonction permet d'Žditer le rŽsultat de la segmentation format XML, avec des balises <seg> pour dŽlilmiter les segments thŽmatiques
147   - * et les mme balises que le fichier d'entrŽe pour dŽlimiter les phrases et leur contenu textuel.
148   - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques
149   - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie.
  146 + * Cette fonction permet d'éditer le résultat de la segmentation format XML, avec des balises <seg> pour délilmiter les segments thématiques
  147 + * et les même balises que le fichier d'entrée pour délimiter les phrases et leur contenu textuel.
  148 + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques
  149 + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie.
150 150 */
151 151 public String result_text_only(Boundaries bounds){
152 152 int[] boundaries = bounds.position_boundaries().clone();
... ... @@ -178,9 +178,9 @@
178 178 }
179 179  
180 180 /**
181   - * Cette fonction permet d'Žditer le rŽsultat de la segmentation au format utilisŽ dans les expŽriences de F. Choi, ainsi que dans les premires versions des outils d'Žvaluation livrŽs (Segmele et Segeval)
182   - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques
183   - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie.
  181 + * Cette fonction permet d'éditer le résultat de la segmentation au format utilisé dans les expériences de F. Choi, ainsi que dans les premières versions des outils d'évaluation livrés (Segmele et Segeval)
  182 + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques
  183 + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie.
184 184 */
185 185 public String result_lines(Boundaries bounds){
186 186 int[] boundaries = bounds.position_boundaries().clone();
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultLexicalChainList.java
Diff comments   View file @ a564ec1
... ... @@ -3,11 +3,11 @@
3 3 import java.util.*;
4 4  
5 5 /**
6   - * Cette classe prend en charge le calcul des liens lexicaux du texte chargŽ dans un objet de type DefaultInputData
7   - * Les paramtres de calcul sont intŽgrŽs dans la configuration. Ils concernent le type de hiatus utilisŽ, et le
8   - * type de reprŽsentation du texte.
9   - * l'accs aux ŽlŽments dŽcisif du texte se fait pour chaque lemme par un tableau qui indique ˆ chaque phrase si il est
10   - * prŽsent ou non, et le poids (ou la prŽsence) d'un lien lexical.
  6 + * Cette classe prend en charge le calcul des liens lexicaux du texte chargé dans un objet de type DefaultInputData
  7 + * Les paramètres de calcul sont intégrés dans la configuration. Ils concernent le type de hiatus utilisé, et le
  8 + * type de représentation du texte.
  9 + * l'accès aux éléments décisif du texte se fait pour chaque lemme par un tableau qui indique à chaque phrase si il est
  10 + * présent ou non, et le poids (ou la présence) d'un lien lexical.
11 11 */
12 12 public class DefaultLexicalChainList implements LexicalChainList
13 13 {
... ... @@ -26,9 +26,9 @@
26 26 private ArrayList<Lemma> _lemmaList = new ArrayList<Lemma>();
27 27 //--------------------------------------------------------------------------
28 28 /**
29   - * Un Lemma est indique la rŽpartition d'un lemme dans le texte, ainsi que la rŽpartition et les
30   - * Žventuelles pondŽration de ses liens lexicaux.
31   - * C'est cette classe qui se charge en rŽalitŽ du calcul des liens lexicaux.
  29 + * Un Lemma est indique la répartition d'un lemme dans le texte, ainsi que la répartition et les
  30 + * éventuelles pondération de ses liens lexicaux.
  31 + * C'est cette classe qui se charge en réalité du calcul des liens lexicaux.
32 32 */
33 33 private class Lemma
34 34 {
35 35  
... ... @@ -79,9 +79,9 @@
79 79 }
80 80 //------------------------------------------------------------------------
81 81 /**
82   - * Cette fonction permet de pondŽrer un lien lexical en fonction de la densitŽ des occurrences
  82 + * Cette fonction permet de pondérer un lien lexical en fonction de la densité des occurrences
83 83 * du lemme, et du poids du lemme.
84   - * @param lastSentenceIdx : numŽro de la phrase dans laquelle apparait la dernire occurrence
  84 + * @param lastSentenceIdx : numéro de la phrase dans laquelle apparait la dernière occurrence
85 85 * @param chainLength : longueur totale du lien lexical
86 86 * @param lemmasInChainCount : nombre d'occurrences du lemme dans le llien lexical
87 87 */
88 88  
... ... @@ -126,13 +126,13 @@
126 126 if (_computeChains && ll.occurences < 2)
127 127 continue;
128 128 Lemma lemma = new Lemma(ll);
129   - if (true) // test à quelles conditions on ajoute le lemme
  129 + if (true) // test ‡ quelles conditions on ajoute le lemme
130 130 _lemmaList.add(lemma);
131 131 }
132 132 }
133 133 //--------------------------------------------------------------------------
134 134 /**
135   - * Cette fonction renvoie le code d'un lemme ayant un index donnŽ
  135 + * Cette fonction renvoie le code d'un lemme ayant un index donné
136 136 * @param lemmaIdx : index du lemme
137 137 * @return : le code du lemme
138 138 */
... ... @@ -151,10 +151,10 @@
151 151 }
152 152 //--------------------------------------------------------------------------
153 153 /**
154   - * Cette fonction indique si un lemme donnŽ est prŽsent dans le texte initial dans une phrase donnŽe
155   - * @param lemmaIdx : index du lemme ˆ tester
156   - * @param sentenceIdx : numŽro de la phrase
157   - * @return true si le lemme est prŽsent dans la phrase
  154 + * Cette fonction indique si un lemme donné est présent dans le texte initial dans une phrase donnée
  155 + * @param lemmaIdx : index du lemme à tester
  156 + * @param sentenceIdx : numéro de la phrase
  157 + * @return true si le lemme est présent dans la phrase
158 158 * false sinon
159 159 *
160 160 */
161 161  
... ... @@ -164,9 +164,9 @@
164 164 }
165 165 //--------------------------------------------------------------------------
166 166 /**
167   - * Cette fonction permet d'accŽder au poids du lien lexical d'un lemme dans une phrase
  167 + * Cette fonction permet d'accéder au poids du lien lexical d'un lemme dans une phrase
168 168 * @param lemmaIdx : index du lemme
169   - * @param sentenceIdx : numŽro de la phrase
  169 + * @param sentenceIdx : numéro de la phrase
170 170 * @return : valeur du lien lexical du lemme dans la phrase si il y a un lien actif, 0 sinon
171 171 */
172 172 public float weight(int lemmaIdx, int sentenceIdx)
... ... @@ -175,7 +175,7 @@
175 175 }
176 176 //--------------------------------------------------------------------------
177 177 /**
178   - * Cette fonction permet d'appeller toString (false, false), une version par dŽfaut de l'affichage.
  178 + * Cette fonction permet d'appeller toString (false, false), une version par défaut de l'affichage.
179 179 */
180 180 public String toString()
181 181 {
... ... @@ -183,8 +183,8 @@
183 183 }
184 184 //--------------------------------------------------------------------------
185 185 /**
186   - * Cette fonction permet de tester et d'afficher les liens lexicaux calculŽs
187   - * @param displayWeightZero : true pour affichier les poids mme quand les liens sont absents
  186 + * Cette fonction permet de tester et d'afficher les liens lexicaux calculés
  187 + * @param displayWeightZero : true pour affichier les poids même quand les liens sont absents
188 188 * @param displaySentenceContent : truc pour afficher le texte initial
189 189 *
190 190 */
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/GapsScores.java
Diff comments   View file @ a564ec1
1 1 package LIA_topic_seg;
2 2 /**
3   - * Cette interface est dŽdiŽe au calcul de probabilitŽ de ruptures entre phrases ou sŽquences de mots.
4   - * elle se fonde sur le rŽsultat de LexicalChainList, qui fournit les lemmes importants de chaque phrase,
5   - * qu'ils constituent un lien lexical ou qu'ils soient juste prŽsents.
  3 + * Cette interface est dédiée au calcul de probabilité de ruptures entre phrases ou séquences de mots.
  4 + * elle se fonde sur le résultat de LexicalChainList, qui fournit les lemmes importants de chaque phrase,
  5 + * qu'ils constituent un lien lexical ou qu'ils soient juste présents.
6 6 *
7 7 *
8 8 */
9 9 public interface GapsScores {
10 10 /**
11   - * La fonction renvoie un tableau des valeurs calculŽes pour tous les intervalles entre 2 unitŽs de traitement
12   - * Il peut s'agir de valeurs ˆ maximiser ou ˆ minimiser.
  11 + * La fonction renvoie un tableau des valeurs calculées pour tous les intervalles entre 2 unités de traitement
  12 + * Il peut s'agir de valeurs à maximiser ou à minimiser.
13 13 * @return un tableau de valeurs
14 14 */
15 15 public float[] values();
16 16 /**
17 17 * retourne le score de l'intervalle entre la phrase bound et la phrase bound+1
18   - * @param bound : numŽro de la phrase prŽcŽdent l'intervalle
  18 + * @param bound : numéro de la phrase précédent l'intervalle
19 19 * @return : un score
20 20 */
21 21 public float bound_value(int bound);
22 22 /**
23   - * propose une sortie texte des valeurs calculŽes. le format est pour chaque intervalle une ligne :
  23 + * propose une sortie texte des valeurs calculées. le format est pour chaque intervalle une ligne :
24 24 * GAP X-X+1 : valeur
25   - * @return : une chaine de caractres
  25 + * @return : une chaine de caractères
26 26 */
27 27 public String to_string();
28 28  
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LemmaDict.java
Diff comments   View file @ a564ec1
... ... @@ -3,9 +3,9 @@
3 3 import java.util.*;
4 4  
5 5 /**
6   - * Cette classe reprŽsente le contenu d'un dictionnaire de lemmes, chaque lemme Žtant dŽfini par un
7   - * code (numŽro d'index), son contenu textuel, le poids maximal qui lui est attribuŽ dans le texte,
8   - * le nombre de fois o il apparait dans le texte, et la liste des phrases dans lesquelles il apparait.
  6 + * Cette classe représente le contenu d'un dictionnaire de lemmes, chaque lemme étant défini par un
  7 + * code (numéro d'index), son contenu textuel, le poids maximal qui lui est attribué dans le texte,
  8 + * le nombre de fois où il apparait dans le texte, et la liste des phrases dans lesquelles il apparait.
9 9 *
10 10 */
11 11 class LemmaDict
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LexicalChainList.java
Diff comments   View file @ a564ec1
1 1 package LIA_topic_seg;
2 2  
3 3 /**
4   - * Cette classe gre le calcul des liens lexicaux, et plus gŽnŽralement de la reprŽsentation du texte,
5   - * en se basant sur des valeurs associŽes ˆ chaque lemme du dictionnaire des lemmes sur l'ensemble des phrases
6   - * du texte analysŽ. Un lemme peut tre reprŽsentŽ par n'importe quelle cha”ne de caractres.
  4 + * Cette classe gère le calcul des liens lexicaux, et plus généralement de la représentation du texte,
  5 + * en se basant sur des valeurs associées à chaque lemme du dictionnaire des lemmes sur l'ensemble des phrases
  6 + * du texte analysé. Un lemme peut être représenté par n'importe quelle chaîne de caractères.
7 7 *
8 8 */
9 9 public interface LexicalChainList {
10 10 /**
11 11 *
12   - * @param lemmaIdx : numŽro d'index du lemme
  12 + * @param lemmaIdx : numéro d'index du lemme
13 13 * @return le code du lemme
14 14 */
15 15 int lemmaCode(int lemmaIdx);
16 16  
17 17 /**
18 18 *
19   - * @return le nombre de lemmes recensŽs dans la reprŽsentation du texte.
  19 + * @return le nombre de lemmes recensés dans la représentation du texte.
20 20 */
21 21 int lemmaCount();
22 22  
23 23 /**
24 24 *
25   - * @param lemmaIdx : numŽro d'index du lemme
26   - * @param sentenceIdx : numŽro de la phrase (ou unitŽ de traitement)
27   - * @return : true si le lemme ou est reprŽsentŽ dans la phrase.
  25 + * @param lemmaIdx : numéro d'index du lemme
  26 + * @param sentenceIdx : numéro de la phrase (ou unité de traitement)
  27 + * @return : true si le lemme ou est représenté dans la phrase.
28 28 */
29 29 boolean presence(int lemmaIdx, int sentenceIdx);
30 30  
31 31 /**
32 32 *
33   - * @param lemmaIdx : numŽro d'index du lemme
34   - * @param sentenceIdx : numŽro de la phrase (ou unitŽ de traitement)
35   - * @return : le poids du lemme dans la phrase, qui peut tre par exemple un nombre d'occurrences ou le poids d'un llien lexical, ou encore un score d'affinitŽs lexicales.
  33 + * @param lemmaIdx : numéro d'index du lemme
  34 + * @param sentenceIdx : numéro de la phrase (ou unité de traitement)
  35 + * @return : le poids du lemme dans la phrase, qui peut être par exemple un nombre d'occurrences ou le poids d'un llien lexical, ou encore un score d'affinités lexicales.
36 36 */
37 37 float weight(int lemmaIdx, int sentenceIdx);
38 38  
39 39 /**
40   - * Cette fonction doit permettre un affichage ˆ l'Žcran ou une sortie fichier pour pouvoir suivre le fonctionnement du programme
41   - * @return : une cha”ne de caractres contenant par exemple pour chaque phrase les lemmes qui lui sont affectŽs, ou l'inverse...
  40 + * Cette fonction doit permettre un affichage à l'écran ou une sortie fichier pour pouvoir suivre le fonctionnement du programme
  41 + * @return : une chaîne de caractères contenant par exemple pour chaque phrase les lemmes qui lui sont affectés, ou l'inverse...
42 42 */
43 43 public String toString();
44 44  
tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Sentence.java
Diff comments   View file @ a564ec1
... ... @@ -3,15 +3,15 @@
3 3 import java.util.*;
4 4  
5 5 /**
6   - * Cette classe reprŽsente les informations contenues dans une phrase, c'est ˆ dire un texte brut
7   - * et un ensemble de lemmes pondŽrŽs.
  6 + * Cette classe représente les informations contenues dans une phrase, c'est à dire un texte brut
  7 + * et un ensemble de lemmes pondérés.
8 8 */
9 9 class Sentence
10 10 {
11 11 //--------------------------------------------------------------------------
12 12 /**
13   - * Cette classe permet de conserver les informations sur un lemme, c'est ˆ dire son rang d'accs
14   - * dans le dictionnaire des lemmes, et le poids qui lui est attribuŽ dans le fichier d'entrŽe.
  13 + * Cette classe permet de conserver les informations sur un lemme, c'est à dire son rang d'accès
  14 + * dans le dictionnaire des lemmes, et le poids qui lui est attribué dans le fichier d'entrée.
15 15 */
16 16 class Lemma
17 17 {
18 18  
... ... @@ -34,9 +34,9 @@
34 34 //--------------------------------------------------------------------------
35 35  
36 36 /**
37   - * Cette fonction permet de signaler la prŽsence d'un lemme dans une phrase
  37 + * Cette fonction permet de signaler la présence d'un lemme dans une phrase
38 38 * @param code : le code issu du dictionnaire des lemmes
39   - * @param weight : le poids attribuŽ au lemme dans la phrase
  39 + * @param weight : le poids attribué au lemme dans la phrase
40 40 */ void addLemma(int code, float weight)
41 41 {
42 42 //int occurences = 1;
... ... @@ -48,8 +48,8 @@
48 48 }
49 49 //--------------------------------------------------------------------------
50 50 /**
51   - * Cette fonction permet de calculer de manire basique le nombre de mots du texte brut de la phrase
52   - * les sŽparateurs de mots utilisŽs sont les caractres d'espacement.
  51 + * Cette fonction permet de calculer de manière basique le nombre de mots du texte brut de la phrase
  52 + * les séparateurs de mots utilisés sont les caractères d'espacement.
53 53 * @return : retourne le nombre de mots de la phrase
54 54 */
55 55 int wordCount()
... ... @@ -63,7 +63,7 @@
63 63 }
64 64 //--------------------------------------------------------------------------
65 65 /**
66   - * Cette fonction renvoie le nombre de lemmes associŽs ˆ la phrase
  66 + * Cette fonction renvoie le nombre de lemmes associés à la phrase
67 67 * @return le nombre de lemmes
68 68 */
69 69 int lemmaCount()
... ... @@ -72,8 +72,8 @@
72 72 }
73 73 //--------------------------------------------------------------------------
74 74 /**
75   - *Cette fonction permet d'accŽder ˆ un lemme de la phrase en fonction de son rang dans la phrase
76   - *@return un objet de type Lemma (dŽfini par un code dans le dictionnaire des lemmes et un poids)
  75 + *Cette fonction permet d'accéder à un lemme de la phrase en fonction de son rang dans la phrase
  76 + *@return un objet de type Lemma (défini par un code dans le dictionnaire des lemmes et un poids)
77 77 */
78 78  
79 79 Lemma lemmaObject(int lemmaIdx)
tools/SIGMUND/LIA_topic_seg/src/Test.java
Diff comments   View file @ a564ec1
... ... @@ -4,8 +4,8 @@
4 4 import java.util.*;
5 5  
6 6 /**
7   - * Cet exemple recense la plupart des possibilitŽs pour une utilisation minimale de l'application
8   - * l'exŽcution directe applique les paramtres par dŽfaut.
  7 + * Cet exemple recense la plupart des possibilités pour une utilisation minimale de l'application
  8 + * l'exécution directe applique les paramètres par défaut.
9 9 *
10 10 */
11 11 class Test
12 12  
13 13  
14 14  
15 15  
... ... @@ -14,19 +14,19 @@
14 14 {
15 15 try
16 16 {
17   - //crŽation d'une configuration avec les paramtres par dŽfaut
  17 + //création d'une configuration avec les paramètres par défaut
18 18 DefaultConfig c = new DefaultConfig();
19 19  
20   - // lorsque on veut utiliser un fichier de configuration connu ˆ l'avance
  20 + // lorsque on veut utiliser un fichier de configuration connu à l'avance
21 21 //c.load("config3.xml");
22 22  
23   - //on peut rŽcupŽrer Žgalement les paramtres en ligne de commande
  23 + //on peut récupérer également les paramètres en ligne de commande
24 24 //en cas de conflit avec le fichier de configuration, c'est la ligne de commande qui est prioritaire
25   - //c.setParamsFromCmdLine(args); // on peut ajouter des paramtres en ligne de commande Žgalement (nom du fichier, nombre de frontires ˆ calculer, ...)
  25 + //c.setParamsFromCmdLine(args); // on peut ajouter des paramètres en ligne de commande également (nom du fichier, nombre de frontières à calculer, ...)
26 26  
27 27 //c.save("config.xml");
28 28  
29   - /* pour passer un fichier de configuration en paramtre
  29 + /* pour passer un fichier de configuration en paramètre
30 30 DefaultConfig cc = new DefaultConfig();
31 31 cc.setParamsFromCmdLine(args);
32 32 DefaultConfig c = new DefaultConfig();
... ... @@ -39,7 +39,8 @@
39 39  
40 40 //--------------------------------------------------------------------------
41 41 //InputData input = new InputData(c, c.getParam("file"));
42   - DefaultInputData input = new DefaultInputData(c, "0.xml");
  42 + //DefaultInputData input = new DefaultInputData(c, "0.xml");
  43 + DefaultInputData input = new DefaultInputData(c, args[0]);
43 44  
44 45 //--------------------------------------------------------------------------
45 46 DefaultLexicalChainList chains = new DefaultLexicalChainList(input);
46 47  
47 48  
... ... @@ -61,14 +62,14 @@
61 62  
62 63 DefaultGapsScores scores = new DefaultGapsScores(chains, input.sentenceCount());
63 64  
64   - // choix du calcul des valeurs affectŽes aux intervalles
65   - // fonction automatiquement lancŽe ˆ l'initialisation : scores.compute_cos(); //similaritŽs cosine
  65 + // choix du calcul des valeurs affectées aux intervalles
  66 + // fonction automatiquement lancée à l'initialisation : scores.compute_cos(); //similarités cosine
66 67 System.out.println(scores.to_string());
67 68  
68   - //les autres fonctions de calcul des scores sont facultatives, et peuvent tre lancŽes successivement.
69   - scores.compute_smoothing(1); //lissage du calcul des similaritŽs
  69 + //les autres fonctions de calcul des scores sont facultatives, et peuvent être lancées successivement.
  70 + scores.compute_smoothing(1); //lissage du calcul des similarités
70 71 System.out.println(scores.to_string());
71   - //scores.compute_depth_scores(); //calcul des scores de profondeur de similaritŽ, peut s'utiliser avec ou sans lissage
  72 + //scores.compute_depth_scores(); //calcul des scores de profondeur de similarité, peut s'utiliser avec ou sans lissage
72 73 //System.out.println(scores.to_string());
73 74  
74 75  
75 76  
76 77  
... ... @@ -76,19 +77,19 @@
76 77 DefaultBoundaries bound = new DefaultBoundaries(scores, 9);
77 78 // DefaultBoundaries bound = new DefaultBoundaries(scores, c.getParam("n");
78 79  
79   - // choix du systme de calcul des frontires, en fonction du calcul choisi prŽcŽdemment
  80 + // choix du système de calcul des frontières, en fonction du calcul choisi précédemment
80 81 // il faut en choisir 1 parmi les 3
81   - //bound.compute_min_similarities(); //ˆ utiliser aprs compute_cos et/ou compute_smoothing
82   - bound.compute_loc_min(2); //ˆ utiliser aprs compute_cos et/ou compute_smoothing
83   - // bound.compute_max_depth(); //ˆ utiliser aprs compute_depth_scores
  82 + //bound.compute_min_similarities(); //à utiliser après compute_cos et/ou compute_smoothing
  83 + bound.compute_loc_min(2); //à utiliser après compute_cos et/ou compute_smoothing
  84 + // bound.compute_max_depth(); //à utiliser après compute_depth_scores
84 85  
85 86  
86 87 //--------------------------------------------------------------------------
87   - //impression du rŽsultat ˆ l'Žcran
88   - System.out.println(bound.to_string()); //numŽros de phrases aprs lesquelles il y a une frontire thŽmatique
89   - System.out.println(input.result_lines(bound)); // sortie pour les application d'Žvaluation
90   - // System.out.println(input.result_complete(bound)); //sortie au mme format que l'entrŽe, avec les mmes informations
91   - // System.out.println(input.result_text_only(bound)); //sortie au format xml, avec uniquement le texte dŽlimitŽ par des balises <seg>
  88 + //impression du résultat à l'écran
  89 + System.out.println(bound.to_string()); //numéros de phrases après lesquelles il y a une frontière thématique
  90 + System.out.println(input.result_lines(bound)); // sortie pour les application d'évaluation
  91 + // System.out.println(input.result_complete(bound)); //sortie au même format que l'entrée, avec les mêmes informations
  92 + // System.out.println(input.result_text_only(bound)); //sortie au format xml, avec uniquement le texte délimité par des balises <seg>
92 93  
93 94  
94 95 }
tools/scripts/ProcessSOLRQueries.py
Diff comments   View file @ a564ec1
... ... @@ -10,9 +10,10 @@
10 10 def obtainSOLRInfos(webName, query):
11 11 #print 'http://194.57.216.43:8080/' + webName + '/select?q='+ query + '&wt=json'
12 12 #conn = urlopen('http://194.57.216.43:8080/' + webName + '/select?q='+ query + '&wt=json')
13   - print 'http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json'
14   - conn = urlopen('http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json')
  13 + print 'http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json' + ' timeout = 30 '
  14 + conn = urlopen('http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json', timeout = 30)
15 15 rsp = json.load(conn)
  16 + conn.close()
16 17 keywords = ""
17 18 txts = ""
18 19 for doc in rsp['response']['docs']:
... ... @@ -62,4 +63,5 @@
62 63  
63 64 outKeywords.close()
64 65 outTxts.close()
  66 +inFile.close()