diff --git a/main_tools/ExploitConfidencePass.sh b/main_tools/ExploitConfidencePass.sh index a9c4cb0..7e3281f 100755 --- a/main_tools/ExploitConfidencePass.sh +++ b/main_tools/ExploitConfidencePass.sh @@ -212,10 +212,8 @@ $SIGMUND_BIN/tagLem2xml.pl $INPUT_DIR/$BASENAME.taglem $INPUT_DIR/$BASENAME.doc. rm $INPUT_DIR/$BASENAME.tmp #$INPUT_DIR/$BASENAME.taglem # Lia_topic_seg : bring together sentences into show -cp $INPUT_DIR/$BASENAME.doc.xml 0.xml -java -cp $LIATOPICSEG/bin Test > $INPUT_DIR/show.seg +java -cp $LIATOPICSEG/bin Test $INPUT_DIR/$BASENAME.doc.xml > $INPUT_DIR/show.seg cat $INPUT_DIR/show.seg | $SIGMUND_BIN/toSegEmiss.pl $INPUT_DIR/$BASENAME.show.seg -rm 0.xml $INPUT_DIR/show.seg if [ $CHECK -eq 1 ] then diff --git a/main_tools/OneScriptToRuleThemAll.sh b/main_tools/OneScriptToRuleThemAll.sh index 74d7a3b..a0b0a2d 100755 --- a/main_tools/OneScriptToRuleThemAll.sh +++ b/main_tools/OneScriptToRuleThemAll.sh @@ -142,7 +142,7 @@ fi shift $((OPTIND-1)) # check audio file - First argument -if [ -e $1 ] && [ -s $1 ] +if [ $p1 -eq 0 ] || [[ -e $1 && -s $1 ]] then echo -e "$LORD\n" REP_OUT=$2/$(basename ${1%.*}) diff --git a/tools/SIGMUND/LIA_topic_seg/bin/Test.class b/tools/SIGMUND/LIA_topic_seg/bin/Test.class index 8543d8b5a9e5ccd2975b785821aab63928103aa4..cffd063248d44288fd6369ec0dd8617a0d5e56ff 100755 GIT binary patch literal 1306 zcmZ`(TTc^F5dKctvUFLbT(v3}U5Pj_KZQg*3m@D)?=1KZqjCj?bR2sasSX~~6*YZpu-3iSOy9 zoSU$%Ju@pKu3{EXRXoF-jCmCcSY+s}OG#RVlDnk4Ug8A9P+gS94^2bQCHCntG}CcK z6-x|#b-}B8!ATi*kvl4uu_CamDxPCbMG|XQu@>!;wW}9R!3yDp3Jq&2*0I6RQR~_A zp}`BTX;n5INlI4v>A4uCV^+1yluPtG?>)fum|hCn5`yoHBajqH)k7} zycl$q#HV@8u)fpoMC zWut=T^mz0XY8fpv5`ja~DXtMZB$3nlU!a0uIwS=HWwg!sLw?HGF0RtqL2z=T!tW&i zE1ERAXZML$-w}@KW#aQHUZi&n(2gbylZ{Z-6Bxl9rjfurR_MEmm$VLVk-{$0u<;s4 fFet-2e8LVsQ?!pV1mOFPV;TJt-Qo@fe7O4;-)TZ? literal 1687 zcmaJ>U31e$6g`{Rv8{@d4?^qGK!6bJd^zQ-5YrIiB;Zzrv`$l8O3g+rMqo=GOYVdR zcz_?%XZm2z;F%pMT%~4d5F{f!L<Ml!-V748)KWIBq$vT5r|2RdZ8r*Ob7p z<=L{fC7X_Z|6q&-&m5oGEDe`up1O2gfs>hs)*fsrXgY2+uW?RU#oLv@YdChrSJm8# zdMaDBpy0VrooWJu28J~FKFXz+exT|JjF73<3Is-bi5)Mu!K?vuD_PH*7{$pHPT&iH zWZ?A>1x{qLhk2Mt<13AHN?;^p`DwBQ#sm@#oxR4rjAjm}$ZnZ9gK-0=aaQ1TkKqhcrAU;30Q?Dg)LEuuxiVWygAs>wv$3+7Z$Ov4B47Svc!}b)OvHq5$TR$am z{s^Rx)Yuc<^ce%wm=!n^nfi`w_$AwGDnEgoz%gIBfpTqC@LDb#LID*`itdu;cUfTK zAm~AA`CyYRSJwp`|SyXGi_@v5$$5M@1eFb#1Ca6a5g$*U*Sn*Tes;*-+h(j z)_DGW82nEw#v{ild99|c)*O9ErSv&8r-vHj=;KkQe|`M(WCN#~s~n#~Tc$cly$e4Z zyz9@vXS@Kj=fLMNzNPRvj?=P3 diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Boundaries.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Boundaries.java index 1850b69..f5db466 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Boundaries.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Boundaries.java @@ -1,33 +1,33 @@ package LIA_topic_seg; /** - * Cette interface est dŽdiŽe ˆ la sŽlection des frontires ˆ partir d'un tableau de valeurs - * associŽes ˆ chaque intervalle entre deux unitŽs de traitement. - * La sŽlection peut se faire ˆ partir d'un nombre connu de frontires ou non, l'essentiel Žtant - * de fournir un sous ensemble des intervalles du texte en rŽponse. + * Cette interface est dédiée à la sélection des frontières à partir d'un tableau de valeurs + * associées à chaque intervalle entre deux unités de traitement. + * La sélection peut se faire à partir d'un nombre connu de frontières ou non, l'essentiel étant + * de fournir un sous ensemble des intervalles du texte en réponse. * * */ public interface Boundaries { /** - * retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques - * @return un tableau d'entiers qui sont les frontires thŽmatiques + * retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques + * @return un tableau d'entiers qui sont les frontières thématiques */ public int[] position_boundaries(); /** - * renvoie le nombre de segments thŽmatiques dŽduits + * renvoie le nombre de segments thématiques déduits * @return un nombre */ public int count_segments(); /** - * permet de conna”tre le nombre de frontires thŽmatiques ˆ l'intŽrieur du texte - * Il se peut que ce nombre soit infŽrieur ˆ un nombre initialisŽ. - * @return le nombre de frontires thŽmatiques + * permet de connaître le nombre de frontières thématiques à l'intérieur du texte + * Il se peut que ce nombre soit inférieur à un nombre initialisé. + * @return le nombre de frontières thématiques */ public int count_boundaries(); /** - * Cette fonction permet de suivre l'Žvolution du programme en affichant les valeurs calculŽes - * @return une cha”ne de caractre o chaque ligne est un numŽro de frontire thŽmatique + * Cette fonction permet de suivre l'évolution du programme en affichant les valeurs calculées + * @return une chaîne de caractère où chaque ligne est un numéro de frontière thématique */ public String toString(); } diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultBoundaries.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultBoundaries.java index 93d6f7c..747ac21 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultBoundaries.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultBoundaries.java @@ -3,16 +3,16 @@ package LIA_topic_seg; import java.util.*; /** - * Cette classe implŽmente des calculs de frontires consŽcutifs aux calculs de valeurs des intervalles - * entre les unitŽs de traitement effectuŽs dans DefaultGapScores. - * Elle permet de dŽduire les frontires ˆ partir des similaritŽs cosine, ou des profondeurs de similaritŽs. - * Dans le premier cas on cherchera ˆ minimiser les scores, dans le second ˆ les maximiser. Pour les similaritŽs, - * lissŽes ou non, on peut Žgalement rechercher des minimas locaux dans une certaine fentre, ce qui revient en fait - * ˆ fixer une taille minimale des segments. - * Ces fonctions peuvent retourner un nombre de frontires prŽdŽfini dans le constructeur, ou bien peuvent - * retourner les frontires en deˆ ou au delˆ d'un certain seuil, calculŽ en fonction de la moyenne et l'Žcart type - * de l'ensemble des scores des intervalles entre unitŽs de traitement. - * Toutes les fonctions travaillent directement sur l'attribut topic_boundaries et le mettent ˆ jour. + * Cette classe implémente des calculs de frontières consécutifs aux calculs de valeurs des intervalles + * entre les unités de traitement effectués dans DefaultGapScores. + * Elle permet de déduire les frontières à partir des similarités cosine, ou des profondeurs de similarités. + * Dans le premier cas on cherchera à minimiser les scores, dans le second à les maximiser. Pour les similarités, + * lissées ou non, on peut également rechercher des minimas locaux dans une certaine fenêtre, ce qui revient en fait + * à fixer une taille minimale des segments. + * Ces fonctions peuvent retourner un nombre de frontières prédéfini dans le constructeur, ou bien peuvent + * retourner les frontières en deçà ou au delà d'un certain seuil, calculé en fonction de la moyenne et l'écart type + * de l'ensemble des scores des intervalles entre unités de traitement. + * Toutes les fonctions travaillent directement sur l'attribut topic_boundaries et le mettent à jour. * * */ @@ -24,9 +24,9 @@ public class DefaultBoundaries implements Boundaries { float coef = -1; /** - * Constructeur de la classe avec un nombre prŽdŽfini de frontires thŽmatiques + * Constructeur de la classe avec un nombre prédéfini de frontières thématiques * @param bw : le calcul des scores de tous les intervalles - * @param n : le nombre de frontires ˆ rechercher + * @param n : le nombre de frontières à rechercher */ public DefaultBoundaries(GapsScores bw, int n) { @@ -39,10 +39,10 @@ public class DefaultBoundaries implements Boundaries { /** - * Constructeur de la classe avec un nombre inconnu de frontires thŽmatiques, - * et un coefficient multiplicateur de prise en compte de l'Žcart type + * Constructeur de la classe avec un nombre inconnu de frontières thématiques, + * et un coefficient multiplicateur de prise en compte de l'écart type * @param bw : le calcul des scores de tous les intervalles - * @param c : le seuil de dŽcision sera = moyenne + c*ecart_type + * @param c : le seuil de décision sera = moyenne + c*ecart_type */ public DefaultBoundaries(GapsScores bw, float c) { @@ -52,8 +52,8 @@ public class DefaultBoundaries implements Boundaries { } /** - * Constructeur de la classe avec un nombre inconnu de frontires thŽmatiques, et un coefficient de - * prise en compte de l'Žcart type par dŽfaut + * Constructeur de la classe avec un nombre inconnu de frontières thématiques, et un coefficient de + * prise en compte de l'écart type par défaut * @param bw : le calcul des scores de tous les intervalles */ public DefaultBoundaries(GapsScores bw) { @@ -63,14 +63,14 @@ public class DefaultBoundaries implements Boundaries { } /** - * 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. - * 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Ž. - * @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. + * 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. + * 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é. + * @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. */ public void compute_loc_min(int window){ - //cette fonction est valable pour les calculs basŽs uniquement sur des cosinus ou Žquivalents - //mme fonctionnement que compute_minimas sauf qu'on vŽrifie que la frontire est seule dans une fentre - //la valeur de cette fentre permet de dŽterminer une taille minimale des segments + //cette fonction est valable pour les calculs basés uniquement sur des cosinus ou équivalents + //même fonctionnement que compute_minimas sauf qu'on vérifie que la frontière est seule dans une fenêtre + //la valeur de cette fenêtre permet de déterminer une taille minimale des segments Comparator comparateur = new Comparator() { public int compare(Object i1, Object i2){ @@ -186,13 +186,13 @@ public class DefaultBoundaries implements Boundaries { } /** - * 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, - * ou en sŽlectionnant toutes celles sous un certain seuil (moyenne - ecart-type) sinon. + * 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, + * ou en sélectionnant toutes celles sous un certain seuil (moyenne - ecart-type) sinon. * */ public void compute_min_similarities(){ - //cette fonction renvoie les plus petits scores comme frontires . - //peut tre exŽcutŽe aprs calcul des similaritŽs. + //cette fonction renvoie les plus petits scores comme frontières . + //peut être exécutée après calcul des similarités. Comparator comparateur = new Comparator() { public int compare(Object i1, Object i2){ @@ -257,14 +257,14 @@ public class DefaultBoundaries implements Boundaries { /** - * 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, - * ou en sŽlectionnant toutes celles au dessus un certain seuil (moyenne + ecart-type) sinon. + * 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, + * ou en sélectionnant toutes celles au dessus un certain seuil (moyenne + ecart-type) sinon. * */ public void compute_max_depth(){ - // cette fonction permet de dŽterminer les frontires ˆ partir des depth scores + // cette fonction permet de déterminer les frontières à partir des depth scores //on recherche alors les intervalles candidats ayant les plus grands scores - //le nombre est dŽterminŽ par boundaries ou bien ŽvaluŽ avec la moyenne et l'Žcart type + //le nombre est déterminé par boundaries ou bien évalué avec la moyenne et l'écart type Comparator comparateur = new Comparator() { public int compare(Integer i1, Integer i2){ @@ -324,10 +324,10 @@ public class DefaultBoundaries implements Boundaries { /** - * retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques + * retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques */ public int[] position_boundaries(){ - //retourne les numŽros des phrases aprs lesquelles se trouvent les frontires thŽmatiques + //retourne les numéros des phrases après lesquelles se trouvent les frontières thématiques return topic_boundaries; } @@ -347,7 +347,7 @@ public class DefaultBoundaries implements Boundaries { public String to_string(){ java.io.StringWriter w = new java.io.StringWriter(); - w.write("placement des frontires \n"); + w.write("placement des frontières \n"); for (int i=0 ; i on recherchera les plus petits + * transforme l'attribut gaps_scores en des scores de similarités => on recherchera les plus petits * */ public void compute_cos(){ -// transforme gaps_scores en des scores de similaritŽs => on recherchera les + petits +// transforme gaps_scores en des scores de similarités => on recherchera les + petits gaps_scores = new float[sentence_count-1]; for (int senti = 0 ; senti< sentence_count-1 ; senti++){ float sup = 0; @@ -80,12 +80,12 @@ public class DefaultGapsScores implements GapsScores{ } /** - * Cette fonction opre un lissage sur l'attribut gaps_scores, pour chaque valeur elle la remplace - * par la moyenne avec les valeurs prŽcŽdente et suivante. - * @param w : fentre de lissage : elle est Žgale ˆ 1 quoi qu'il arrive + * Cette fonction opère un lissage sur l'attribut gaps_scores, pour chaque valeur elle la remplace + * par la moyenne avec les valeurs précédente et suivante. + * @param w : fenêtre de lissage : elle est égale à 1 quoi qu'il arrive */ public void compute_smoothing(int w){ - //w est la fentre de lissage + //w est la fenêtre de lissage float[] smooth_cos = new float[gaps_scores.length] ; smooth_cos[0]= (gaps_scores[1]+2*gaps_scores[0])/3; for (int i=1 ; i on recherchera les + grands int count = 0; float[] depth_scores = new float [gaps_scores.length]; @@ -113,7 +113,7 @@ public class DefaultGapsScores implements GapsScores{ depth_scores[gaps_scores.length-1]=0; for (int i=1 ; igaps_scores[i] && gaps_scores[i+1]>gaps_scores[i]){ - // on ne calcule les scores que des candidats, c'est ˆ dire les minimas locaux + // on ne calcule les scores que des candidats, c'est à dire les minimas locaux float lmax = 0; float rmax = 0; diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultInputData.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultInputData.java index d4b169d..575e012 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultInputData.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultInputData.java @@ -10,20 +10,20 @@ import javax.xml.transform.*; import java.util.*; /** - * Cette classe permet de charger les informations du fichier d'entrŽe, ainsi que d'Žditer le rŽsultat de la segmentation. -* Le fichier d'entrŽe doit tre au format XML et les balises utilisŽes sont dŽterminŽes dans le fichier de configuration. + * Cette classe permet de charger les informations du fichier d'entrée, ainsi que d'éditer le résultat de la segmentation. +* Le fichier d'entrée doit être au format XML et les balises utilisées sont déterminées dans le fichier de configuration. */ public class DefaultInputData { //-------------------------------------------------------------------------- /** - * la configuration, et donc les paramtres sont copiŽs dans l'objet + * la configuration, et donc les paramètres sont copiés dans l'objet */ DefaultConfig config; /** - * Le dictionnaire des lemmes est Žgalement portŽ par la reprŽsentation des donnŽes d'entrŽe + * Le dictionnaire des lemmes est également porté par la représentation des données d'entrée */ LemmaDict lemmaDict = new LemmaDict(); private Sentence[] _sentenceList; @@ -71,7 +71,7 @@ public class DefaultInputData } //-------------------------------------------------------------------------- /** - * Cette fonction est utilisŽe principalement pour le dŽbuggage, pour obtenir une trace des donnŽes d'entrŽe. + * Cette fonction est utilisée principalement pour le débuggage, pour obtenir une trace des données d'entrée. */ public String toString() @@ -101,9 +101,9 @@ public class DefaultInputData /** - * Cette fonction permet d'Žditer le rŽsultat de la segmentation au mme format que le fichier d'entrŽe, avec des balises pour dŽlilmiter les segments thŽmatiques - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie. + * Cette fonction permet d'éditer le résultat de la segmentation au même format que le fichier d'entrée, avec des balises pour délilmiter les segments thématiques + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie. */ public String result_complete (Boundaries bounds){ int[] boundaries = bounds.position_boundaries().clone(); @@ -143,10 +143,10 @@ public class DefaultInputData } /** - * Cette fonction permet d'Žditer le rŽsultat de la segmentation format XML, avec des balises pour dŽlilmiter les segments thŽmatiques - * et les mme balises que le fichier d'entrŽe pour dŽlimiter les phrases et leur contenu textuel. - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie. + * Cette fonction permet d'éditer le résultat de la segmentation format XML, avec des balises pour délilmiter les segments thématiques + * et les même balises que le fichier d'entrée pour délimiter les phrases et leur contenu textuel. + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie. */ public String result_text_only(Boundaries bounds){ int[] boundaries = bounds.position_boundaries().clone(); @@ -178,9 +178,9 @@ public class DefaultInputData } /** - * 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) - * @param bounds : il s'agit de l'objet contenant le calcul des frontires thŽmatiques - * @return : La fonction renvoie un objet de type String, qui peut ensuite tre affichŽ ˆ l'Žcran ou bien redirigŽ vers un fichier de sortie. + * 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) + * @param bounds : il s'agit de l'objet contenant le calcul des frontières thématiques + * @return : La fonction renvoie un objet de type String, qui peut ensuite être affiché à l'écran ou bien redirigé vers un fichier de sortie. */ public String result_lines(Boundaries bounds){ int[] boundaries = bounds.position_boundaries().clone(); diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultLexicalChainList.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultLexicalChainList.java index 29c14d9..36715d2 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultLexicalChainList.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/DefaultLexicalChainList.java @@ -3,11 +3,11 @@ package LIA_topic_seg; import java.util.*; /** - * Cette classe prend en charge le calcul des liens lexicaux du texte chargŽ dans un objet de type DefaultInputData - * Les paramtres de calcul sont intŽgrŽs dans la configuration. Ils concernent le type de hiatus utilisŽ, et le - * type de reprŽsentation du texte. - * l'accs aux ŽlŽments dŽcisif du texte se fait pour chaque lemme par un tableau qui indique ˆ chaque phrase si il est - * prŽsent ou non, et le poids (ou la prŽsence) d'un lien lexical. + * Cette classe prend en charge le calcul des liens lexicaux du texte chargé dans un objet de type DefaultInputData + * Les paramètres de calcul sont intégrés dans la configuration. Ils concernent le type de hiatus utilisé, et le + * type de représentation du texte. + * 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 + * présent ou non, et le poids (ou la présence) d'un lien lexical. */ public class DefaultLexicalChainList implements LexicalChainList { @@ -26,9 +26,9 @@ public class DefaultLexicalChainList implements LexicalChainList private ArrayList _lemmaList = new ArrayList(); //-------------------------------------------------------------------------- /** - * Un Lemma est indique la rŽpartition d'un lemme dans le texte, ainsi que la rŽpartition et les - * Žventuelles pondŽration de ses liens lexicaux. - * C'est cette classe qui se charge en rŽalitŽ du calcul des liens lexicaux. + * Un Lemma est indique la répartition d'un lemme dans le texte, ainsi que la répartition et les + * éventuelles pondération de ses liens lexicaux. + * C'est cette classe qui se charge en réalité du calcul des liens lexicaux. */ private class Lemma { @@ -79,9 +79,9 @@ public class DefaultLexicalChainList implements LexicalChainList } //------------------------------------------------------------------------ /** - * Cette fonction permet de pondŽrer un lien lexical en fonction de la densitŽ des occurrences + * Cette fonction permet de pondérer un lien lexical en fonction de la densité des occurrences * du lemme, et du poids du lemme. - * @param lastSentenceIdx : numŽro de la phrase dans laquelle apparait la dernire occurrence + * @param lastSentenceIdx : numéro de la phrase dans laquelle apparait la dernière occurrence * @param chainLength : longueur totale du lien lexical * @param lemmasInChainCount : nombre d'occurrences du lemme dans le llien lexical */ @@ -126,13 +126,13 @@ public class DefaultLexicalChainList implements LexicalChainList if (_computeChains && ll.occurences < 2) continue; Lemma lemma = new Lemma(ll); - if (true) // test à quelles conditions on ajoute le lemme + if (true) // test ‡ quelles conditions on ajoute le lemme _lemmaList.add(lemma); } } //-------------------------------------------------------------------------- /** - * Cette fonction renvoie le code d'un lemme ayant un index donnŽ + * Cette fonction renvoie le code d'un lemme ayant un index donné * @param lemmaIdx : index du lemme * @return : le code du lemme */ @@ -151,10 +151,10 @@ public class DefaultLexicalChainList implements LexicalChainList } //-------------------------------------------------------------------------- /** - * Cette fonction indique si un lemme donnŽ est prŽsent dans le texte initial dans une phrase donnŽe - * @param lemmaIdx : index du lemme ˆ tester - * @param sentenceIdx : numŽro de la phrase - * @return true si le lemme est prŽsent dans la phrase + * Cette fonction indique si un lemme donné est présent dans le texte initial dans une phrase donnée + * @param lemmaIdx : index du lemme à tester + * @param sentenceIdx : numéro de la phrase + * @return true si le lemme est présent dans la phrase * false sinon * */ @@ -164,9 +164,9 @@ public class DefaultLexicalChainList implements LexicalChainList } //-------------------------------------------------------------------------- /** - * Cette fonction permet d'accŽder au poids du lien lexical d'un lemme dans une phrase + * Cette fonction permet d'accéder au poids du lien lexical d'un lemme dans une phrase * @param lemmaIdx : index du lemme - * @param sentenceIdx : numŽro de la phrase + * @param sentenceIdx : numéro de la phrase * @return : valeur du lien lexical du lemme dans la phrase si il y a un lien actif, 0 sinon */ public float weight(int lemmaIdx, int sentenceIdx) @@ -175,7 +175,7 @@ public class DefaultLexicalChainList implements LexicalChainList } //-------------------------------------------------------------------------- /** - * Cette fonction permet d'appeller toString (false, false), une version par dŽfaut de l'affichage. + * Cette fonction permet d'appeller toString (false, false), une version par défaut de l'affichage. */ public String toString() { @@ -183,8 +183,8 @@ public class DefaultLexicalChainList implements LexicalChainList } //-------------------------------------------------------------------------- /** - * Cette fonction permet de tester et d'afficher les liens lexicaux calculŽs - * @param displayWeightZero : true pour affichier les poids mme quand les liens sont absents + * Cette fonction permet de tester et d'afficher les liens lexicaux calculés + * @param displayWeightZero : true pour affichier les poids même quand les liens sont absents * @param displaySentenceContent : truc pour afficher le texte initial * */ diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/GapsScores.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/GapsScores.java index 46f879f..bc1cae5 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/GapsScores.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/GapsScores.java @@ -1,28 +1,28 @@ package LIA_topic_seg; /** - * Cette interface est dŽdiŽe au calcul de probabilitŽ de ruptures entre phrases ou sŽquences de mots. - * elle se fonde sur le rŽsultat de LexicalChainList, qui fournit les lemmes importants de chaque phrase, - * qu'ils constituent un lien lexical ou qu'ils soient juste prŽsents. + * Cette interface est dédiée au calcul de probabilité de ruptures entre phrases ou séquences de mots. + * elle se fonde sur le résultat de LexicalChainList, qui fournit les lemmes importants de chaque phrase, + * qu'ils constituent un lien lexical ou qu'ils soient juste présents. * * */ public interface GapsScores { /** - * La fonction renvoie un tableau des valeurs calculŽes pour tous les intervalles entre 2 unitŽs de traitement - * Il peut s'agir de valeurs ˆ maximiser ou ˆ minimiser. + * La fonction renvoie un tableau des valeurs calculées pour tous les intervalles entre 2 unités de traitement + * Il peut s'agir de valeurs à maximiser ou à minimiser. * @return un tableau de valeurs */ public float[] values(); /** * retourne le score de l'intervalle entre la phrase bound et la phrase bound+1 - * @param bound : numŽro de la phrase prŽcŽdent l'intervalle + * @param bound : numéro de la phrase précédent l'intervalle * @return : un score */ public float bound_value(int bound); /** - * propose une sortie texte des valeurs calculŽes. le format est pour chaque intervalle une ligne : + * propose une sortie texte des valeurs calculées. le format est pour chaque intervalle une ligne : * GAP X-X+1 : valeur - * @return : une chaine de caractres + * @return : une chaine de caractères */ public String to_string(); diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LemmaDict.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LemmaDict.java index 05eff0a..ed30ca6 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LemmaDict.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LemmaDict.java @@ -3,9 +3,9 @@ package LIA_topic_seg; import java.util.*; /** - * Cette classe reprŽsente le contenu d'un dictionnaire de lemmes, chaque lemme Žtant dŽfini par un - * code (numŽro d'index), son contenu textuel, le poids maximal qui lui est attribuŽ dans le texte, - * le nombre de fois o il apparait dans le texte, et la liste des phrases dans lesquelles il apparait. + * Cette classe représente le contenu d'un dictionnaire de lemmes, chaque lemme étant défini par un + * code (numéro d'index), son contenu textuel, le poids maximal qui lui est attribué dans le texte, + * le nombre de fois où il apparait dans le texte, et la liste des phrases dans lesquelles il apparait. * */ class LemmaDict diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LexicalChainList.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LexicalChainList.java index 8a5764c..5178b65 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LexicalChainList.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/LexicalChainList.java @@ -1,44 +1,44 @@ package LIA_topic_seg; /** - * Cette classe gre le calcul des liens lexicaux, et plus gŽnŽralement de la reprŽsentation du texte, - * en se basant sur des valeurs associŽes ˆ chaque lemme du dictionnaire des lemmes sur l'ensemble des phrases - * du texte analysŽ. Un lemme peut tre reprŽsentŽ par n'importe quelle cha”ne de caractres. + * Cette classe gère le calcul des liens lexicaux, et plus généralement de la représentation du texte, + * en se basant sur des valeurs associées à chaque lemme du dictionnaire des lemmes sur l'ensemble des phrases + * du texte analysé. Un lemme peut être représenté par n'importe quelle chaîne de caractères. * */ public interface LexicalChainList { /** * - * @param lemmaIdx : numŽro d'index du lemme + * @param lemmaIdx : numéro d'index du lemme * @return le code du lemme */ int lemmaCode(int lemmaIdx); /** * - * @return le nombre de lemmes recensŽs dans la reprŽsentation du texte. + * @return le nombre de lemmes recensés dans la représentation du texte. */ int lemmaCount(); /** * - * @param lemmaIdx : numŽro d'index du lemme - * @param sentenceIdx : numŽro de la phrase (ou unitŽ de traitement) - * @return : true si le lemme ou est reprŽsentŽ dans la phrase. + * @param lemmaIdx : numéro d'index du lemme + * @param sentenceIdx : numéro de la phrase (ou unité de traitement) + * @return : true si le lemme ou est représenté dans la phrase. */ boolean presence(int lemmaIdx, int sentenceIdx); /** * - * @param lemmaIdx : numŽro d'index du lemme - * @param sentenceIdx : numŽro de la phrase (ou unitŽ de traitement) - * @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. + * @param lemmaIdx : numéro d'index du lemme + * @param sentenceIdx : numéro de la phrase (ou unité de traitement) + * @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. */ float weight(int lemmaIdx, int sentenceIdx); /** - * Cette fonction doit permettre un affichage ˆ l'Žcran ou une sortie fichier pour pouvoir suivre le fonctionnement du programme - * @return : une cha”ne de caractres contenant par exemple pour chaque phrase les lemmes qui lui sont affectŽs, ou l'inverse... + * Cette fonction doit permettre un affichage à l'écran ou une sortie fichier pour pouvoir suivre le fonctionnement du programme + * @return : une chaîne de caractères contenant par exemple pour chaque phrase les lemmes qui lui sont affectés, ou l'inverse... */ public String toString(); diff --git a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Sentence.java b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Sentence.java index 874e209..8bfaf19 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Sentence.java +++ b/tools/SIGMUND/LIA_topic_seg/src/LIA_topic_seg/Sentence.java @@ -3,15 +3,15 @@ package LIA_topic_seg; import java.util.*; /** - * Cette classe reprŽsente les informations contenues dans une phrase, c'est ˆ dire un texte brut - * et un ensemble de lemmes pondŽrŽs. + * Cette classe représente les informations contenues dans une phrase, c'est à dire un texte brut + * et un ensemble de lemmes pondérés. */ class Sentence { //-------------------------------------------------------------------------- /** - * Cette classe permet de conserver les informations sur un lemme, c'est ˆ dire son rang d'accs - * dans le dictionnaire des lemmes, et le poids qui lui est attribuŽ dans le fichier d'entrŽe. + * Cette classe permet de conserver les informations sur un lemme, c'est à dire son rang d'accès + * dans le dictionnaire des lemmes, et le poids qui lui est attribué dans le fichier d'entrée. */ class Lemma { @@ -34,9 +34,9 @@ class Sentence //-------------------------------------------------------------------------- /** - * Cette fonction permet de signaler la prŽsence d'un lemme dans une phrase + * Cette fonction permet de signaler la présence d'un lemme dans une phrase * @param code : le code issu du dictionnaire des lemmes - * @param weight : le poids attribuŽ au lemme dans la phrase + * @param weight : le poids attribué au lemme dans la phrase */ void addLemma(int code, float weight) { //int occurences = 1; @@ -48,8 +48,8 @@ class Sentence } //-------------------------------------------------------------------------- /** - * Cette fonction permet de calculer de manire basique le nombre de mots du texte brut de la phrase - * les sŽparateurs de mots utilisŽs sont les caractres d'espacement. + * Cette fonction permet de calculer de manière basique le nombre de mots du texte brut de la phrase + * les séparateurs de mots utilisés sont les caractères d'espacement. * @return : retourne le nombre de mots de la phrase */ int wordCount() @@ -63,7 +63,7 @@ class Sentence } //-------------------------------------------------------------------------- /** - * Cette fonction renvoie le nombre de lemmes associŽs ˆ la phrase + * Cette fonction renvoie le nombre de lemmes associés à la phrase * @return le nombre de lemmes */ int lemmaCount() @@ -72,8 +72,8 @@ class Sentence } //-------------------------------------------------------------------------- /** - *Cette fonction permet d'accŽder ˆ un lemme de la phrase en fonction de son rang dans la phrase - *@return un objet de type Lemma (dŽfini par un code dans le dictionnaire des lemmes et un poids) + *Cette fonction permet d'accéder à un lemme de la phrase en fonction de son rang dans la phrase + *@return un objet de type Lemma (défini par un code dans le dictionnaire des lemmes et un poids) */ Lemma lemmaObject(int lemmaIdx) diff --git a/tools/SIGMUND/LIA_topic_seg/src/Test.java b/tools/SIGMUND/LIA_topic_seg/src/Test.java index 6d12dd2..1bed455 100755 --- a/tools/SIGMUND/LIA_topic_seg/src/Test.java +++ b/tools/SIGMUND/LIA_topic_seg/src/Test.java @@ -4,8 +4,8 @@ import java.io.*; import java.util.*; /** - * Cet exemple recense la plupart des possibilitŽs pour une utilisation minimale de l'application - * l'exŽcution directe applique les paramtres par dŽfaut. + * Cet exemple recense la plupart des possibilités pour une utilisation minimale de l'application + * l'exécution directe applique les paramètres par défaut. * */ class Test @@ -14,19 +14,19 @@ class Test { try { - //crŽation d'une configuration avec les paramtres par dŽfaut + //création d'une configuration avec les paramètres par défaut DefaultConfig c = new DefaultConfig(); - // lorsque on veut utiliser un fichier de configuration connu ˆ l'avance + // lorsque on veut utiliser un fichier de configuration connu à l'avance //c.load("config3.xml"); - //on peut rŽcupŽrer Žgalement les paramtres en ligne de commande + //on peut récupérer également les paramètres en ligne de commande //en cas de conflit avec le fichier de configuration, c'est la ligne de commande qui est prioritaire - //c.setParamsFromCmdLine(args); // on peut ajouter des paramtres en ligne de commande Žgalement (nom du fichier, nombre de frontires ˆ calculer, ...) + //c.setParamsFromCmdLine(args); // on peut ajouter des paramètres en ligne de commande également (nom du fichier, nombre de frontières à calculer, ...) //c.save("config.xml"); - /* pour passer un fichier de configuration en paramtre + /* pour passer un fichier de configuration en paramètre DefaultConfig cc = new DefaultConfig(); cc.setParamsFromCmdLine(args); DefaultConfig c = new DefaultConfig(); @@ -39,7 +39,8 @@ class Test //-------------------------------------------------------------------------- //InputData input = new InputData(c, c.getParam("file")); - DefaultInputData input = new DefaultInputData(c, "0.xml"); + //DefaultInputData input = new DefaultInputData(c, "0.xml"); + DefaultInputData input = new DefaultInputData(c, args[0]); //-------------------------------------------------------------------------- DefaultLexicalChainList chains = new DefaultLexicalChainList(input); @@ -61,14 +62,14 @@ class Test DefaultGapsScores scores = new DefaultGapsScores(chains, input.sentenceCount()); - // choix du calcul des valeurs affectŽes aux intervalles - // fonction automatiquement lancŽe ˆ l'initialisation : scores.compute_cos(); //similaritŽs cosine + // choix du calcul des valeurs affectées aux intervalles + // fonction automatiquement lancée à l'initialisation : scores.compute_cos(); //similarités cosine System.out.println(scores.to_string()); - //les autres fonctions de calcul des scores sont facultatives, et peuvent tre lancŽes successivement. - scores.compute_smoothing(1); //lissage du calcul des similaritŽs + //les autres fonctions de calcul des scores sont facultatives, et peuvent être lancées successivement. + scores.compute_smoothing(1); //lissage du calcul des similarités System.out.println(scores.to_string()); - //scores.compute_depth_scores(); //calcul des scores de profondeur de similaritŽ, peut s'utiliser avec ou sans lissage + //scores.compute_depth_scores(); //calcul des scores de profondeur de similarité, peut s'utiliser avec ou sans lissage //System.out.println(scores.to_string()); @@ -76,19 +77,19 @@ class Test DefaultBoundaries bound = new DefaultBoundaries(scores, 9); // DefaultBoundaries bound = new DefaultBoundaries(scores, c.getParam("n"); - // choix du systme de calcul des frontires, en fonction du calcul choisi prŽcŽdemment + // choix du système de calcul des frontières, en fonction du calcul choisi précédemment // il faut en choisir 1 parmi les 3 - //bound.compute_min_similarities(); //ˆ utiliser aprs compute_cos et/ou compute_smoothing - bound.compute_loc_min(2); //ˆ utiliser aprs compute_cos et/ou compute_smoothing - // bound.compute_max_depth(); //ˆ utiliser aprs compute_depth_scores + //bound.compute_min_similarities(); //à utiliser après compute_cos et/ou compute_smoothing + bound.compute_loc_min(2); //à utiliser après compute_cos et/ou compute_smoothing + // bound.compute_max_depth(); //à utiliser après compute_depth_scores //-------------------------------------------------------------------------- - //impression du rŽsultat ˆ l'Žcran - System.out.println(bound.to_string()); //numŽros de phrases aprs lesquelles il y a une frontire thŽmatique - System.out.println(input.result_lines(bound)); // sortie pour les application d'Žvaluation - // System.out.println(input.result_complete(bound)); //sortie au mme format que l'entrŽe, avec les mmes informations - // System.out.println(input.result_text_only(bound)); //sortie au format xml, avec uniquement le texte dŽlimitŽ par des balises + //impression du résultat à l'écran + System.out.println(bound.to_string()); //numéros de phrases après lesquelles il y a une frontière thématique + System.out.println(input.result_lines(bound)); // sortie pour les application d'évaluation + // System.out.println(input.result_complete(bound)); //sortie au même format que l'entrée, avec les mêmes informations + // System.out.println(input.result_text_only(bound)); //sortie au format xml, avec uniquement le texte délimité par des balises } diff --git a/tools/scripts/ProcessSOLRQueries.py b/tools/scripts/ProcessSOLRQueries.py index 85841f0..1621d4d 100755 --- a/tools/scripts/ProcessSOLRQueries.py +++ b/tools/scripts/ProcessSOLRQueries.py @@ -10,9 +10,10 @@ from solrinfo import * def obtainSOLRInfos(webName, query): #print 'http://194.57.216.43:8080/' + webName + '/select?q='+ query + '&wt=json' #conn = urlopen('http://194.57.216.43:8080/' + webName + '/select?q='+ query + '&wt=json') - print 'http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json' - conn = urlopen('http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json') + print 'http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json' + ' timeout = 30 ' + conn = urlopen('http://'+machine+':'+port+'/' + webName + '/select?q='+ query + '&wt=json', timeout = 30) rsp = json.load(conn) + conn.close() keywords = "" txts = "" for doc in rsp['response']['docs']: @@ -62,3 +63,4 @@ for query in lines: outKeywords.close() outTxts.close() +inFile.close()