#!/bin/csh
  
  setenv LIA_PHON_REP /usr/tools/lia_phon
  
  setenv LIA_TAGG_LANG=french
  setenv LIA_TAGG=/labo/Tools/lia_ltbox/lia_tagg/
  setenv LIA_PHON_REP=/labo/Tools/lia_ltbox/lia_phon/
  setenv SRILM_BIN=/labo/Tools/SRI-LM-1.4.2/bin/i686
  setenv LIA_BIGLEX=/labo/Tools/lia_ltbox/lia_biglex/ 
  #
  #   RECETTE POUR OBTENIR UN MODELE DE LANGAGE ET UN LEXIQUE PHONETISE AVEC LES OUTILS LIA
  #
  #   FRED 1205
  #
  #   Voici un petit exemple, ou l'on part du corpus data.raw pour aller vers un modele de
  #   langage data.sort.arpa et un lexique phonetise data.phon.speeral
  #
  #   Le prealable a ce traitement est de disposer d'un corpus brut 'raw' c'est a dire pas forcement tres
  #   propre, mais quand meme ne contenant que du texte (les balises et autres joyeusetes ont ete enlevees).
  #   Par exemple le corpus 'data.raw'.
  #
  
  
  # 1) Premiere etape : le nettoyage
  #    Tout d'abord nettoyage dit "au karcher" du corpus de base (c'est a dire tres violent et sans etat d'ame ..)
  # 
  #  premier passage en douceur, on se contente de couper en phrase avec 'lia_clean.biglex',
  #  puis on passe aux choses serieuses avec 'lia_clean_corpus'
  #  enfin on enleve toutes les ponctuations avec 'lia_rm_ponct'
  #
  echo 'Nettoyage du corpus'
  cat data.raw | \
  	csh $LIA_BIGLEX/script/lia_clean.biglex |\
  	csh $LIA_BIGLEX/script/lia_clean_corpus $LIA_BIGLEX/biglex |\
  	$LIA_TAGG/bin/lia_rm_ponct > data.clean
  echo '		-> done'
  
  # 2) Deuxieme etape : la constitution du lexique
  #    On peut partir du petit lexique d'environ 27K mots donne en exemple : lex_20k.lst
  #    mais on peut partir de n'importe quelle liste de mots.
  #    Ensuite on produit un "rapport" sur la couverture de cette liste sur le corpus nettoye.
  #    Pour cela on effectue la commande :
  
  echo 'Production du rapport de couverture'
  $LIA_TAGG/bin/stat_corpus lex_20k.lst report < data.clean
  echo '		-> done'
  
  #    Il faut ensuite editer le fichier : 'report.oov'
  #    Ce fichier contient la liste des mots hors-vocabulaire, tries par frequence, trouves
  #    dans le corpus nettoye.
  #    Il y a trois attitudes possibles face a un mot hors vocabulaire :
  #      1) on le veut, on s'en veut de l'avoir oublie, on l'ajoute au lexique en cours
  #      2) c'est une erreur (de formatage, de frappe, de ce qu'on veut), a ce moment la on 
  #         a la possibilite de le corriger dans le corpus en editant le fichier de correction
  #         donne en exemple : 'correction.rules'. Chaque ligne de ce fichier contient 2 champs
  #         separe par un '#'. Le premier champs et le mot ou le groupe de mots a corriger,
  #         le deuxieme champs est le mot ou groupe de mots apres correction. Quelques symboles
  #         joker sont permis dans ces reecriture, ils seront documentes dans une autre vie, pour le
  #         moment il suffit d'editer le code C ....
  #         Par exemple, pour corriger la forme inconnue 'Etats_Unis' presente 1121 fois dans 'data.clean',
  #         le fichier 'correction.rules' contient la ligne: Etats_Unis # États_Unis
  #         car la forme accentuee 'États_Unis' est dans le lexique de base.
  #         Il faut donc modifier 'correction.rules' pour le faire correspondre a ses desirs.
  #      3) le mepris : ce mot est inconnu et il le restera, tant pis pour lui, il n'y a dans ce
  #         cas la, rien a faire ....
  #
  #    Dans notre exemple, imaginons que nous voulions rajouter les termes 'polyglotte', 'checklist'
  #    'multisupport' et 'FTSE' a notre lexique de base, puis le corriger avec les
  #    regles 'correction.rules', il faut faire les choses suivantes:
  echo 'Ajout de mots a lex_20k.lst et creation de mon_nouveau_lexique.lst'
  cp lex_20k.lst mon_nouveau_lexique.lst
  echo 'polyglotte' >> mon_nouveau_lexique.lst
  echo 'checklist' >> mon_nouveau_lexique.lst
  echo 'multisupport' >> mon_nouveau_lexique.lst
  echo 'FTSE' >> mon_nouveau_lexique.lst
  echo '		-> done'
  echo 'Formatage du corpus selon ce nouveau lexique et les regles correction.rules'
  cat data.clean | \
  	csh $LIA_BIGLEX/script/lia_clean_corpus mon_nouveau_lexique.lst correction.rules > data.clean.2
  echo '		-> done'
  
  #    On repart maintenant dans la constitution d'un nouveau rapport de couverture et on itere
  #    l'etape 2 jusqu'a ce qu'on soit tres fatigue ou tres content du lexique obtenu.
  echo 'Production du rapport de couverture'
  $LIA_TAGG/bin/stat_corpus mon_nouveau_lexique.lst report.mon_nouveau_lexique < data.clean.2
  
  #    Ah, oui, avant que j'oublie, il faut nettoyer les lexique compile apres chaque ajout dans 'mon_nouveau_lexique.lst'
  #    en effectuant un : rm mon_nouveau_lexique.lst.*
  rm mon_nouveau_lexique.lst.*
  echo '		-> done'
  
  
  # 3) Troisieme etape : l'apprentissage du modele de langage
  #    Une fois que le lexique et le corpus sont satisfaisant, on peut entrainer un modele
  #    ngramme avec le SRILM toolkit. Pour cela on peut utiliser le script '$LIA_BIGLEX/script/make_arpa_sri.csh'
  #    que l'on peut editer bien sur pour customiser les options. Ce script prend en parametre 3 elements :
  #    le lexique, le corpus (qui doit avoir ete tokeniser selon le lexique, donc apres un passage avec 'lia_clean_corpus'
  #    avec la derniere version du lexique), et enfin l'ordre du ngramme.
  #    Donc sur l'exemple precedent, ca donne :
  #
  echo 'Apprentissage du trigramme'
  csh $LIA_BIGLEX/script/make_arpa_sri.csh mon_nouveau_lexique.lst data.clean.2 3
  echo '		-> done'
  
  # 4) Quatrieme etape : la production d'un lexique phonetise
  #    La derniere etape consiste a produire un lexique avec des formes phonetises et des variantes.
  #    Cette etape consiste tout d'abord a recupere dans un lexique deja phonetise, et a peu pres
  #    propre, les formes existantes. On le fait avec la commande 'sublex' de la maniere suivante,
  #    en utilisant le lexique phonetis de base present dans LIA_BIGLEX :
  #
  echo 'Production du lexique phonetise'
  $LIA_TAGG/bin/sublex mon_nouveau_lexique.lst -noid < \
  	$LIA_BIGLEX/lex_ester_mai05.phon.fmt > mon_nouveau_lexique.1.phon.fmt
  #
  #    Cette liste de mots deja phonetise en stokee dans 'mon_nouveau_lexique.1.lst'
  #
  cut -f1 mon_nouveau_lexique.1.phon.fmt | sort -u > mon_nouveau_lexique.1.lst
  
  #    Maintenant on cherche le complement (ce qui reste a phonetiser)
  #
  $LIA_TAGG/bin/intersec mon_nouveau_lexique.1.lst mon_nouveau_lexique.lst -e > mon_nouveau_lexique.2.lst
  #    C'est le fichier mon_nouveau_lexique.2.lst qui contient ce qu'il reste a phonetiser, dans cet exemple
  #    il s'agit des deux mots :
  #    multisupport
  #    FTSE
  #
  #    La phonetisation s'effectue avec la commande $LIA_PHON/script/lia_lex2phon_variante
  #    on l'utilise de la maniere suivante :
  #
  
  #$LIA_PHON_REP/script/lia_lex2phon_variante < mon_nouveau_lexique.2.lst | \
  #	cut -d"[" -f1 | sort -u > mon_nouveau_lexique.2.phon
  
  #
  #    Ce script surgenere volontairement des variantes, par exemple, a partir des 2 mots on
  #    obtient :
  #    FTSE   aifftteiaisseu
  #    FTSE   ffttss
  #    FTSE   ffttssei
  #    multisupport   mmuullttiizzuuppoorr
  #    multisupport   mmuullttiizzuuppoorrtt
  #
  #    Il faut ensuite a la main enlever les formes erronee (ou les laisser si on a la flemme,
  #    mais ca augmente l'espace de recherche et les confusions). Dans cet exemple, il faudrait
  #    supprimer les formes : FTSE   ffttss et FTSE   ffttssei
  #    et remplacer le 'zz' par un 'ss' pour le mot multisupport.
  #    Pour plus de detail sur l'alphabet phonetique, se reporter au README de LIA_PHON
  #
  #    Une fois les formes phonetiques corrigee, on peut formater le lexique par la commande :
  #
  
  #$LIA_TAGG/bin/format_lex < mon_nouveau_lexique.2.phon > mon_nouveau_lexique.2.phon.fmt
  
  #
  #    Enfin il ne reste plus qu'a concatener les deux parties de lexique phonetise et de leur
  #    rajouter des IDs pour pouvoir etre utilise par SPEERAL. Cela se fait par la commande :
  
  #cat mon_nouveau_lexique.1.phon.fmt mon_nouveau_lexique.2.phon.fmt | \
  	#sort -u | $LIA_TAGG/bin/add_code_to_lex_phon > mon_nouveau_lexique.phon.speeral
  #echo '		-> done'
  
  #
  # Et voila, bravo, c'est fini !! avec le fichier '.sort.arpa' et '.phon.speeral', on peut utiliser la
  # moulinette SPEERAL qui compile tout ca en binaire pour pouvoir etre utiliser par le moteur.
  # Voir Pascal Nocera pour plus de details.
  #