Skip to content
Snippets Groups Projects
Commit 88553a1d authored by Alexis Nasr's avatar Alexis Nasr
Browse files

ajout de slides

parent 3bf253c8
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
slides/tbp_implementation.tex 0 → 100644
+ 1004
− 0
View file @ 88553a1d
\documentclass[serif, professionalfont, 10pt]{beamer}
%% pour impression :
%\documentclass[serif, professionalfont, 10pt, handout]{beamer}
%\usepackage{pgfpages}
%\pgfpagesuselayout{4 on 1}[a4paper,border shrink=5mm, landscape]
\setbeamertemplate{navigation symbols}{}
\usepackage{tikz}
\usepackage[francais]{babel}
\usepackage[utf8]{inputenc}
\usepackage{mathpazo}
\usepackage{xspace}
\usepackage{graphicx}
\usepackage{textcomp}
\usepackage{tikz-dependency}
\usetikzlibrary{automata,positioning}
%\usepackage[pdftex]{graphicx}
\usepackage{epsfig}
\usepackage{epstopdf}
%usepackage{minted}
\usepackage[cache=false]{minted}
\usepackage{comment}
%\usemintedstyle{manni} % mouais
\usepackage{epic}
\usepackage{eepic}
\usepackage{ecltree}
\usepackage{latexsym}
\usepackage{tikz}
\usepackage{tikz-dependency}
\usepackage{algorithm, algorithmic}
\usepackage{qtree}
\setbeamertemplate{items}[square]
\setbeamertemplate{enumerate items}[nop]
\def\red{\color{red}}
\def\blue{\color{blue}}
\newcommand\ra{\rightarrow}
\usepackage{amsmath}
\DeclareMathOperator*{\argmax}{argmax} % thin space, limits underneath in displays
\DeclareMathOperator*{\argmin}{argmin} % thin space, limits underneath in displays
%\DeclareMathOperator*{\argmax}{arg\,max}
\newcommand{\eps}{\ensuremath{\varepsilon}}
\newcommand{\sig}{\ensuremath{\Sigma}}
\newcommand{\mono}{\ensuremath{\Sigma^\ast}}
\newcommand{\al}{\ensuremath{\alpha}}
\newcommand{\be}{\ensuremath{\beta}}
\newcommand{\ga}{\ensuremath{\gamma}}
\newcommand{\re}[2]{\ensuremath{#1 \to #2}}
\newcommand{\vect}[1]{\ensuremath{\overrightarrow{#1}}}
\newcommand{\kleene}[1]{\ensuremath{#1^\ast}}
\newcommand{\mt}[0]{\ensuremath{T}}
\newcommand{\me}[0]{\ensuremath{E}}
\newcommand{\for}[2]{\ensuremath{\alpha(#1, #2)}} %probabilite
\newcommand{\back}[2]{\ensuremath{\beta(#1, #2)}}
\newcommand{\best}[2]{\ensuremath{\delta(#1, #2)}}
\newcommand{\backp}[2]{\ensuremath{\psi(#1, #2)}} %pointeur arriere vers l'etat prec. sur le meilleur chemin
\newcommand{\pe}[2]{\ensuremath{E(#1, #2)}} %probabilites d'emission
\newcommand{\pt}[2]{\ensuremath{T(#1, #2)}} %probabilites de transition
\newcommand{\pet}[2]{\ensuremath{\gamma(#1, #2)}} %probabilite d'etre dans un etat e au temps t
\newcommand{\pini}[1]{\ensuremath{\pi(#1)}} %probabilites initiales
\newcommand{\matrice}[1]{\ensuremath{\textbf{#1}}}
\newcommand{\pile}[1]{\ensuremath{\mathcal{P}_{#1}}}
\newcommand{\face}[1]{\ensuremath{\mathcal{F}_{#1}}}
\newcommand{\derivp}[2]{\ensuremath{\frac{\partial #1}{\partial #2}}}
%\newcommand{\ldep}[1]{\ensuremath{\textsc{\sc left}_{\textsc{#1}}}}
\newcommand{\ldep}[1]{\ensuremath{\textsc{\sc left-}#1}}
%\newcommand{\rdep}[1]{\ensuremath{\textsc{right}_{\textsc{#1}}}}
\newcommand{\rdep}[1]{\ensuremath{\textsc{\sc right-}#1}}
%\newcommand{\reduce}[0]{\ensuremath{\textsc{\sc RED}}}
\newcommand{\reduce}[0]{\ensuremath{\textsc{reduce}}}
\newcommand{\shift}[0]{\ensuremath{\textsc{shift}}}
\newcommand{\racine}[0]{\ensuremath{\textsc{root}}}
\newcommand{\isracine}[1]{\ensuremath{\textsc{root}_{#1}}}
\newcommand{\eos}[0]{\ensuremath{\textsc{eos}}}
\newcommand{\iseos}[1]{\ensuremath{\textsc{eos}_{#1}}}
\newcommand{\emptyseq}[0]{\ensuremath{[]}}
\newcommand{\stack}[1]{\ensuremath{\sigma_{#1}}}
\newcommand{\buf}[1]{\ensuremath{\beta_{#1}}}
\newcommand{\depset}[0]{\ensuremath{\Delta}}
\newcommand{\mdp}[0]{{\sc mdp}}
\usepackage{pgfplots}
\pgfplotsset{width=10cm,compat=1.9}
\usetikzlibrary{arrows.meta,
calc, chains,
quotes,
positioning,
shapes.geometric}
%\input{QobiTree}
%\title[Syntaxe et Sémantique]{Syntaxe et Sémantique}
%\author{Alexis Nasr}
%\institute{}
%\date{}
%\input{LIFabreviations.tex}
\begin{document}
%\newcommand{\stack}[1]{\ensuremath{\sigma_{#1}}}
%\newcommand{\buf}[1]{\ensuremath{\beta_{#1}}}
%\newcommand{\depset}[0]{\ensuremath{\Delta}}
%\newcommand{\blue}[1]{{\color{blue} #1}}
%\newcommand{\red}[1]{{\color{red} #1}}
\newcommand{\fm} [0] {{\color{blue}{\tt fm}}}
\newcommand{\mcf} [0]{{\color{blue}{\tt mcf}}}
\newcommand{\mcd} [0]{{\color{blue}{\tt mcd}}}
\newcommand{\cff} [0]{{\color{blue}{\tt cff}}}
\newcommand{\dico}[0]{{\color{blue}{\tt dico}}}
\newcommand{\cfw} [0]{{\color{blue}{\tt cfw}}}
\newcommand{\FORM} [0]{{\color{blue}{\tt FORM}}}
\newcommand{\CPOS} [0]{{\color{blue}{\tt CPOS}}}
\newcommand{\POS} [0]{{\color{blue}{\tt POS}}}
\newcommand{\LEMMA} [0]{{\color{blue}{\tt LEMMA}}}
\newcommand{\MORPHO} [0]{{\color{blue}{\tt MORPHO}}}
\newcommand{\GOV} [0]{{\color{blue}{\tt GOV}}}
\newcommand{\SLABEL} [0]{{\color{blue}{\tt LABEL}}}
\newcommand{\EOS} [0]{{\color{blue}{\tt EOS}}}
\newcommand{\AZ} [0]{{\color{blue}{\tt A \ldots Z}}}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{}
\begin{center}
{\Large Implémentation d'un analyseur en transitions}
\end{center}
\end{frame}
\frame{\frametitle{Implémentation}\tableofcontents}
\section{Formats de fichiers}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{Formats de fichiers}
\begin{itemize}
\item Multi Column File (\mcf{})
\item Multi Column Description (\mcd{})
\item Feature Model (\fm{})
\item Vocabulaires (\dico{})
\item Class Features File (\cff{})
\end{itemize}
\end{frame}
%\subsection{Multi Column File ({\tt mcf})}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Multi Column File (\mcf{})}
Format de fichier qui permet de représenter les données textuelles et les annotations qui y sont attachées
\begin{itemize}
\item format ``en colonnes''~:
\begin{itemize}
\item chaque ligne correspond à une unité textuelle minimale (token)
\item chaque colonne correspond à un attribut du token (par exemple son genre ou son nombre)
\end{itemize}
\item les colonnes sont séparées les unes des autres par une tabulation
\item le nombre de colonnes est illimité
\item l'interprétation de chaque colonne est décrite dans un fichier \mcd{} (Multi Column Description)
\item les lignes commençant par {\tt \#\#} sont ignorées
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{\mcf{}~: exemple}
\footnotesize
\begin{verbatim}
La det le 1 det 0
diane nc diane 1 suj 0
chantait v chanter 0 root 0
dans prep dans -1 mod 0
la det le 1 det 0
cour nc cour -2 obj 0
des prep des -1 dep 0
casernes nc caserne -1 obj 0
. poncts . -6 eos 1
Et coo et 0 root 0
le det le 1 det 0
vent nc vent 3 suj 0
du prep du -1 dep 0
matin nc matin -1 obj 0
soufflait v souffler -5 dep_coord 0
sur prep sur -1 mod 0
les det le 1 det 0
lanternes nc lanterne -2 obj 0
. poncts . -9 eos 1
\end{verbatim}
\normalsize
\end{frame}
%\subsection{Multi Column Description ({\tt mcd})}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Multi Column Description (\mcd{})}
Un fichier \mcd{} associe une {\bf étiquette} à chaque colonne d'un fichier \mcf{}
\begin{itemize}
\item Chaque ligne du fichier \mcd{} décrit une colonne du fichier \mcf{}.
\item Chaque ligne du fichier \mcd{} est formée de quatre colonnes~:
\begin{enumerate}
\item un entier indiquant la colonne décrite (à partir de {\tt 0})
\item l'étiquette correspondant à la colonne (voir plus loin)
\item le type de la valeur s'y trouvant\\
% \item Deux types sont définis~:
\begin{itemize}
\item {\tt SYM} indique que les valeurs sont des symboles
\item {\tt INT} indique que les valeurs sont des entiers
% \item {\tt EMB} indique que les valeurs sont des vecteurs de réels
\end{itemize}
\item le mot clef {\tt KEEP} ou {\tt IGNORE}
\begin{itemize}
\item {\tt KEEP} indique que la colonne est prise en compte
\item {\tt IGNORE} qu'elle ne l'est pas
\end{itemize}
\end{enumerate}
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Etiquettes}
\begin{itemize}
\item Une étiquette permet de donner un nom explicite à une colonne
\item Elles permettent d'accéder au contenu de la colonne à l'aide de {\it Word Features}
\item On peut créer autant d'étiquettes que l'on veut
\item Conventions
\begin{itemize}
\item {\tt \FORM{}} la forme du token
\item {\tt \POS{}} sa partie de discours
\item {\tt \LEMMA{}} son lemme
\item {\tt \MORPHO{}} traits morphologique (genre, nombre, temps, \ldots)
\item {\tt \GOV{}} la position relative de son gouverneur ($-n$ indique que le gouverneur se trouve n tokens à gauche, $n$ indique qu'il se trouve n tokens à droite)
\item {\tt \SLABEL{}} sa fonction syntaxique
\item {\tt \EOS{}} sa position dans la phrase (1 dernier mot de la phrase, 0 autre)
\end{itemize}
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{\mcd{} exemple}
\begin{itemize}
\item un extrait du fichier \mcf{}
\begin{verbatim}
La det le 1 det 0
diane nc diane 1 suj 0
chantait v chanter 0 root 0
\end{verbatim}
\item le fichier \mcd{} correspondant
\begin{verbatim}
0 FORM SYM KEEP
1 POS SYM KEEP
2 LEMMA SYM IGNORE
3 GOV INT KEEP
4 LABEL SYM KEEP
5 EOS SYM KEEP
\end{verbatim}
\item Convention, on nomme les fichiers \mcd{} selon les colonnes qu'ils définissent, par exemple {\tt FPLGSE.mcd}
\end{itemize}
\end{frame}
%\subsection{Feature Model ({\tt fm})}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Features}
\begin{itemize}
\item Fonctions permettant d'accéder au contenu d'une configuration
\item Deux types de Features~:
\begin{enumerate}
\item Word Features~: attributs des tokens, généralement présentes dans le fichier \mcd{} fourni en entrée à l'analyseur.\\
Exemples~:
\begin{itemize}
\item les parties de discours (\POS{})
\item la fin de phrase (\EOS{})
\item \ldots
\end{itemize}
\item Configuration Features~: features prédites pendant l'analyse ou pendant l'exécution de l'oracle.\\
Exemples~:
\begin{itemize}
\item la distance entre le mot courant ({\tt B0}) et le mot en sommet de pile ({\tt S0})
\item Le nombre d'éléments dans la pile
\item Le nombre de dépendants droits ou gauche du mot en sommet de pile
\item \ldots
\end{itemize}
% \item Syntactic Features~: structure syntaxique déjà construite
% \item Distance Features~: distance entre certains mots
% \item Configurational Features~: autres informations (non linguistiques) sur la configuration
\end{enumerate}
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Word features}
Quadruplets (W, Conteneur, Position, Etiquette)~:
\begin{enumerate}
\item Conteneur~:
\begin{itemize}
\item {\tt B} pour Buffer
\item {\tt S} pour Stack
\end{itemize}
\item Position
\begin{itemize}
\item pour {\tt B}~:
\begin{itemize}
\item {\tt 0} token courant
\item {\tt 1} token directement à droite de {\tt B 0}
\item {\tt 2} token directement à droite de {\tt B 1}
\item {\tt -1} token directement à gauche de {\tt B 0}
\item {\tt -2} token directement à gauche de {\tt B -1}
\item \ldots
\end{itemize}
\item pour {\tt S}
\begin{itemize}
\item {\tt 0} token au sommet de la pile
\item {\tt 1} token au dessous de {\tt S 0} dans la pile
\item \ldots
\end{itemize}
\end{itemize}
\item Etiquette, telle que définie dans un \mcd{}
\end{enumerate}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{Configuration Feature}
\begin{itemize}
\item Quatre type de Configuration Feature
\begin{enumerate}
\item Distance entre un mot du buffer et un mot de la pile (en général mot courant dans le buffer et mot au sommet de pile)
\begin{verbatim}
C DIST B 0 S 0
\end{verbatim}
\item Nombre de dépendants droits ou gauche d'un mot
\begin{verbatim}
C NLDEP S 0
C NRDEP S 0
\end{verbatim}
\item \label{} du dépendant le plus à gauche ou le plus à droite d'un mot
\begin{verbatim}
C LLDEP S 0
C LRDEP S 0
\end{verbatim}
\item taille de la pile
\begin{verbatim}
C SH
\end{verbatim}
\end{enumerate}
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Feature Model (\fm{})}
\begin{itemize}
\item Un fichier \fm{} définit un ensemble de Features qui vont permettre de décrire une configuration
\item Ces Features sont utilisées par le classifieur pour prédire le prochain mouvement
\item Chaque ligne d'un fichier \fm{} définit une Feature
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Exemple de fichier \fm{}}
\begin{verbatim}
W B -2 POS
W B -1 POS
W B 0 POS
W B 1 POS
W B 2 POS
W S 0 POS
W S 1 POS
C DIST B 0 S 0
C NLDEP S 0
C NRDEP S 0
C SH
C LLDEP S 0
C LRDEP S 0
\end{verbatim}
\end{frame}
%%\subsection{Vocabulaires ({\tt dico})}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{frame}[fragile]{Syntactic Features}
% \begin{tabular}{|l|l|}\hline
% \blue{\tt ldep\_s0r} & fonction du dépendant le plus à gauche de \blue{\tt s0}\\ \hline
% \blue{\tt rdep\_s0r} & fonction du dépendant le plus à droite de \blue{\tt s0}\\ \hline
% \blue{\tt ldep\_s1r} & fonction du dépendant le plus à gauche de \blue{\tt s1}\\ \hline
% \blue{\tt rdep\_s1r} & fonction du dépendant le plus à droite de \blue{\tt s1}\\ \hline
% \blue{\tt ndep\_s0} & nombre de dépendants de \blue{\tt s0}\\ \hline
% \end{tabular}
%\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{frame}[fragile]{Distance Features}
%
% \begin{itemize}
% \item \blue{\tt dist\_s0\_b0} linear distance between s0 and b0
% \end{itemize}
%\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{frame}[fragile]{Configurational Features}
%
% \begin{tabular}{|l|l|}\hline
%\blue{\tt sh} & number of elements in the stack\\ \hline \hline
%\blue{\tt t1} & code de la transition menant à la configuration courante\\ \hline
%\blue{\tt t2} & code de la transition précédant t1\\ \hline
%\blue{\tt t3} & code de la transition précédant t2\\ \hline
%\blue{\tt t4} & code de la transition précédant t3\\ \hline \hline
%\blue{\tt mvt0} & code de la première transition de meilleur poids\\ \hline
%\blue{\tt mvt1} & code de la deuxième transition de meilleur poids\\ \hline
%\blue{\tt mvt2} & code de la troisième transition de meilleur poids\\ \hline
%\blue{\tt mvt3} & code de la quatrième transition de meilleur poids\\ \hline \hline
%\blue{\tt delta1} & score(mvt0) - score(mvt1)\\ \hline
%\blue{\tt delta2} & score(mvt0) - score(mvt2)\\ \hline
%\blue{\tt delta3} & score(mvt0) - score(mvt3)\\ \hline
% \end{tabular}
%\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{\dico{}}
\begin{itemize}
\item Dictionnaire permettant de stocker les différentes valeurs possibles d'une Feature, sous la forme de couples (clé, valeur).
\item La clé correspond à une chaîne de caractère et la valeur à un entier (entiers successifs à partir de 0)
\item Un fichier \dico{} est composé~:
\begin{itemize}
\item d'une ligne de la forme {\tt \#\#FEAT} indiquant le début des valeurs possibles de {\tt FEAT}
\item de lignes comportant un symbole (les valeurs possible de {\tt FEAT})
\end{itemize}
\item Un fichier \dico{} peut comporter plusieurs dictionnaires différents.
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Exemple de fichier \dico{}}
\begin{verbatim}
##POS
NOUN
VERB
ADJ
##LABEL
nsubj
root
obj
##EOS
0
1
\end{verbatim}
\end{frame}
%\subsection{Class Features File ({\tt cff})}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Class Features File (\cff{})}
\begin{itemize}
\item Format utilisé pour entraîner les classifieurs de type réseaux de neurones
\item Première ligne : taille de la couche d'entrée
\item Deuxième ligne : taille de la couche de sortie
\item Puis alternance de~:
\begin{itemize}
\item valeur couche d'entrée
\item valeur couche de sortie
\end{itemize}
\item Représentation one-hot~:
\begin{itemize}
\item pour représenter la valeur 2 parmi 4 valeurs possible : {\tt 0 0 1 0}
\end{itemize}
\item Exemple
\begin{verbatim}
8
2
0 1 0 0 0 0 1 0
1 0
1 0 0 0 0 1 0 0
0 1
\end{verbatim}
\end{itemize}
\end{frame}
\section{Les principaux outils}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{Les principaux outils}
\begin{itemize}
\item {\tt mcf2cff}
\item {\tt tbp\_train}
\item {\tt tbp\_decode}
\item {\tt eval\_mcf}
\end{itemize}
\end{frame}
%\subsection{\tt mcf2cff}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{{\tt mcf2cff}}
{\bf description~:}
\begin{itemize}
\item Transforme des arbres syntaxiques en séquences de configurations et de mouvements à l'aide d'un oracle.
\end{itemize}
{\bf entrées~:}
\begin{itemize}
\item un fichier \mcf{} annoté en syntaxe (colonnes \GOV{} et \SLABEL{})
\item un fichier \fm{} décrivant les features utilisées pour la prédiction
\item un fichier \mcd{} décrivant la structure du fichier \mcf{}
\item un fichier \dico{} contenant les vocabulaires correspondant aux features utilisées et le vocabulaire des features du classifieur
\item le nombre minimal de mots à traiter
\end{itemize}
{\bf sorties~:}
\begin{itemize}
\item un fichier \cff{} contenant les données pour l'apprentissage du classifieur
\end{itemize}
\end{frame}
%\subsection{\tt tbp\_train}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{\tt tbp\_train}
{\bf description~:}
\begin{itemize}
\item Apprend un classifieur de type MLP au format keras à partir d'un fichier \cff{}
\item Les hyperparamètres du MLP sont représentés en dur dans le programme
\end{itemize}
{\bf entrées~:}
\begin{itemize}
\item un fichier \cff{}
\end{itemize}
{\bf sorties~:}
\begin{itemize}
\item un modèle au format keras/tensorFlow
\end{itemize}
% {\bf description~:}
% \begin{itemize}
% \item Calcule un poids pour tout couple (couple, feature).
% \item Les poids sont stockés dans le fichier de sortie.
% \end{itemize}
\end{frame}
%\subsection{\tt tbp\_decode}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{{\tt tbp\_decode}}
{\bf description~:}
\begin{itemize}
\item Réalise l'analyse syntaxique de phrases d'un fichier \mcf{}
\end{itemize}
{\bf entrées~:}
\begin{itemize}
\item un fichier \mcf{} contenant le texte à analyser
\item un modèle keras
\item un fichier \dico{} contenant les vocabulaires correspondant aux features utilisées et le vocabulaire des features du classifieur
\item un fichier \fm{} contenant le modèle de features
\item un fichier \mcd{} décrivant la structure du fichier \mcf{}
\item le nombre minimal de mots à traiter
\end{itemize}
{\bf sorties~:}
\begin{itemize}
\item un fichier \mcf{} avec deux colonnes supplémentaires pour \GOV{} et \SLABEL{}
\end{itemize}
\end{frame}
%\subsection{\tt eval\_mcf}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{\tt eval\_mcf}
{\bf description~:}
\begin{itemize}
\item Compare deux fichiers \mcf{} et calcule le Labeled Accuracy Score et le Unlabeled Accuracy Score
\end{itemize}
{\bf entrées~:}
\begin{itemize}
\item un fichier \mcf{} de référence
\item un fichier \mcf{} hypothèse (dont les colonnes \GOV{} et \SLABEL{} ont été prédites)
\item un fichier \mcd{} pour la référence
\item un fichier \mcd{} pour l'hypothèse
\end{itemize}
{\bf sorties~:}
\begin{itemize}
\item LAS et UAS du fichier hypothèse
\end{itemize}
\end{frame}
\section{Les principales classes}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}{Les principales classes}
\begin{itemize}
\item {\tt Word.py}
\item {\tt WordBuffer.py}
\item {\tt Stack.py}
\item {\tt Config.py}
\item {\tt FeatModel.py}
\item {\tt Dico.py}
\item {\tt Dicos.py}
\item {\tt Mcd.py}
\item {\tt Moves.py}
\end{itemize}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Word}
\begin{minted}{python}
def __init__(self):
self.featDic = {} # dictionnaire dans lequel sont stockés les word features
self.leftDaughters = [] # liste des indices des dépendants gauches
self.rightDaughters = [] # liste des indices des dépendants droits
def getFeat(self, featName)
def setFeat(self, featName, featValue)
def addLeftDaughter(self, index)
def addRightDaughter(self, index)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt WordBuffer}
\begin{minted}{python}
def __init__(self, mcfFileName=None, mcd=None):
self.currentIndex = 0
self.array = []
self.mcd = mcd
self.mcfFile = None
def empty(self)
def init(self, mcd)
def addWord(self, w)
def getLength(self)
def getCurrentIndex(self)
def getWord(self, index)
def getCurrentWord(self)
def readNextWord(self)
def readNextSentence(self)
def endReached(self)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Stack}
Les éléments de la pile sont des indices de mots et pas des références à des {\tt Word}
\begin{minted}{python}
def __init__(self):
self.array = []
def isEmpty(self)
def empty(self)
def push(self, elt)
def pop(self)
def top(self)
def getLength(self)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Config}
\begin{minted}{python}
def __init__(self, filename, mcd, dicos):
self.wb = WordBuffer(filename, mcd)
self.st = Stack()
def isFinal(self)
def getStack(self)
def getBuffer(self)
def fwd(self)
def shift(self)
def red(self)
def right(self, label)
def left(self, label)
def applyMvt(self, mvt)
def getWordFeat(self, featTuple)
def extractFeatVec(self, FeatModel)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt FeatModel}
En gros un tableau de features\\
Permet aussi de calculer la taille du vecteur d'entrée du classifieur
\begin{minted}{python}
def __init__(self, featModFilename, dicos):
self.featArray = self.readFeatModelFile(featModFilename)
self.inputVectorSize = self.computeInputSize(dicos)
def computeInputSize(self, dicos)
def getInputSize(self)
def getFeatArray(self)
def getNbFeat(self)
def getFeatContainer(self, featIndex)
def getFeatPosition(self, featIndex)
def getFeatLabel(self, featIndex)
def buildInputVector(self, featVec, dicos)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Dico}
Un {\tt Dico} permet d'associer des symboles et des entiers.
\begin{minted}{python}
def __init__(self, name):
self.name = name
self.hash = {}
self.array = []
def add(self, symbol)
def getCode(self, symbol)
def getSymbol(self, code)
def getSize(self)
def printToFile(self, dicoFile)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Dicos}
Ensemble de \dico{}, chacun étant accessible à partir de son nom
\begin{minted}{python}
def __init__(self, mcd=False, fileName=False):
self.content = {}
if mcd :
self.initializeWithMcd(mcd)
if fileName :
self.initializeWithDicoFile(fileName)
def getDico(self, dicoName)
def addDico(self, dicoName)
def getCode(self, dicoName, symbol)
def getSymbol(self, dicoName, code)
def add(self, dicoName, symbol)
def populateFromMcfFile(self, mcfFilename, mcd)
def printToFile(self, filename)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Mcd}
Chaque colonne d'un {\tt Mcd} est un triplet {\tt (name, type, status)}.
\begin{minted}{python}
def __init__(self, mcdFilename):
self.array = self.readMcdFile(mcdFilename)
def readMcdFile(self, mcdFilename)
def getNbCol(self)
def getColName(self, colIndex)
def getColType(self, colIndex)
def getColStatus(self, colIndex)
def locateCol(self, name)
\end{minted}
\end{frame}
%--------------------------DEBUT SLIDE-----------------------------%
\begin{frame}[fragile]{\tt Moves}
Associe un code à une action\\
Permet aussi de construire le vecteur de sortie pour le classifieur
\begin{minted}{python}
def __init__(self, dicos):
self.dicoLabels = dicos.getDico('LABEL')
if not self.dicoLabels :
print("cannot find LABEL in dicos")
exit(1)
self.nb = 2 * self.dicoLabels.getSize() + 3
def getNb(self)
def mvtCode(self, mvt)
def mvtDecode(self, mvt_Code)
def buildOutputVector(self, mvt)
\end{minted}
\end{frame}
\section{Installation et utilisation}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Dépot GIT}
\begin{itemize}
\item Le code de l'analyseur, ainsi que les données et les scripts permettant de lancer des expériences se trouvent sur le dépôt GIT suivant~:\\
\url{https://gitlab.lis-lab.fr/alexis.nasr/tbp.git}
\item Sa structure est la suivante~:
\begin{itemize}
\item {\tt src} contient tout le code
\item {\tt data} contient les données ( pas sur le git pour l'instant, mais sur la page du cours)
\item {\tt expe}
\begin{itemize}
\item un fichier \fm{} ({\tt basic.fm})
\item un fichier {\tt Makefile} qui permet de lancer une expérience
\item un fichier \mcd{} ({\tt PGLE.mcd})
\end{itemize}
\end{itemize}
\end{itemize}
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Le Makefile (de la mort)}
\footnotesize
\begin{verbatim}
train_conll=../data/train_$(lang).conllu
train_proj_conll=./out/train_$(lang)_proj.conllu
train_mcf=./out/train_$(lang)_pgle.mcf
train_cff=./out/train_$(lang).cff
train_word_limit=40000
dev_conll=../data/dev_$(lang).conllu
dev_proj_conll=./out/dev_$(lang)_proj.conllu
dev_mcf=./out/dev_$(lang)_pgle.mcf
dev_cff=./out/dev_$(lang).cff
dev_word_limit=5000
test_conll=../data/test_$(lang).conllu
test_mcf=./out/test_$(lang)_pgle.mcf
test_mcf_hyp=./out/test_$(lang)_hyp.mcf
test_word_limit=700
feat_model=basic.fm
dicos=./out/$(lang)_train.dic
model=./out/$(lang).keras
results = ./out/$(lang).res
mcd_pgle=PGLE.mcd
\end{verbatim}
\normalsize
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Le Makefile (de la mort)}
\tiny
\begin{verbatim}
eval: $(test_mcf_hyp)
python3 ../src/eval_mcf.py $(test_mcf) $(test_mcf_hyp) $(mcd_pgle) $(mcd_pgle) $(lang) > $(results)
$(test_mcf_hyp): $(test_mcf) $(model)
python3 ../src/tbp_decode.py $(test_mcf) $(model) $(dicos) $(feat_model) $(mcd_pgle) $(test_word_limit) > $(test_mcf_hyp)
$(model): $(train_cff) $(dev_cff)
python3 ../src/tbp_train.py $(train_cff) $(dev_cff) $(model)
$(train_cff): $(train_mcf) $(dicos)
python3 ../src/mcf2cff.py $(train_mcf) $(feat_model) $(mcd_pgle) $(dicos) $(train_cff) $(train_word_limit)
$(dev_cff): $(dev_mcf) $(dicos)
python3 ../src/mcf2cff.py $(dev_mcf) $(feat_model) $(mcd_pgle) $(dicos) $(dev_cff) $(dev_word_limit)
$(train_mcf): $(train_proj_conll)
python3 ../src/conll2mcf.py $(train_proj_conll) $(mcd_pgle) > $(train_mcf)
$(dev_mcf): $(dev_proj_conll)
python3 ../src/conll2mcf.py $(dev_proj_conll) $(mcd_pgle) > $(dev_mcf)
$(test_mcf):
python3 ../src/conll2mcf.py $(test_conll) $(mcd_pgle) > $(test_mcf)
$(train_proj_conll):
python3 ../src/remove_non_projective_sentences_from_conll.py $(train_conll) > $(train_proj_conll)
$(dev_proj_conll):
python3 ../src/remove_non_projective_sentences_from_conll.py $(dev_conll) > $(dev_proj_conll)
$(dicos): $(train_mcf)
python3 ../src/create_dicos.py $(train_mcf) $(mcd_pgle) $(dicos)
\end{verbatim}
\normalsize
\end{frame}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{frame}[fragile]{Utilisation}
pré-requis~:
\begin{itemize}
\item une machine avec python et keras
\item accès à collab
\end{itemize}
Installation et exécution~:
\footnotesize
\begin{verbatim}
git clone https://gitlab.lis-lab.fr/alexis.nasr/tbp.git
cd tbp
wget http://pageperso.lif.univ-mrs.fr/~alexis.nasr/Ens/TLNL/data.tgz
tar xvfz data.tgz
cd expe
make lang=fr
\end{verbatim}
\normalsize
\end{frame}
\end{document}
src/mcf2cff.py
+ 1
− 1
View file @ 88553a1d
......@@ -48,7 +48,7 @@ def prepareData(mcd, mcfFile, featModel, moves, filename, wordsLimit) :
inputVector = featModel.buildInputVector(featVec, dicos)
# np.savetxt(dataFile, inputVector, fmt="%s", delimiter=' ', newline=' ')
# dataFile.write('\n')
np.savetxt(dataFile, [code], fmt="%s", delimiter=' ', newline=' ')
np.savetxt(dataFile, [code], fmt="%s", delimiter=' ', newline='\n')
np.savetxt(dataFile, inputVector, fmt="%s", delimiter=' ', newline=' ')
dataFile.write('\n')
......
src/tbp_train_pytorch.py
+ 1
− 1
View file @ 88553a1d
......@@ -20,7 +20,7 @@ def readData(dataFilename) :
outputSize = int(dataFile.readline())
print("output size = ", outputSize)
inputLine = True
inputLine = True # indicates whether the current line is an input line (configuration) or an output line (movement)
for ligne in dataFile:
# print(ligne)
vector = ligne.split()
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment