MGC-AnalyzeSample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Importations\n",
    "- codecs pour les encodages\n",
    "- pandas et numpy pour les calculs sur tableaux\n",
    "- matplotlib pour les graphiques\n",
    "- itertools pour les itérateurs sophistiqués (paires sur liste, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf8 -*-\n",
    "import codecs\n",
    "import features\n",
    "import re\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools as it\n",
    "import pickle\n",
    "#%pylab inline\n",
    "#pd.options.display.mpl_style = 'default'\n",
    "debug=False\n",
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Préparation des matrices de traits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "features.add_config('bdlexique.ini')\n",
    "fs=features.FeatureSystem('phonemes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "validPhonemes=list(fs.supremum.concept.extent)\n",
    "#for phoneme in validPhonemes:\n",
    "#    print (phoneme, [phoneme], \";\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "phonologicalMap=\"\"\n",
    "neutralisationsNORD=(u\"6û\",u\"9ê\")\n",
    "neutralisationsSUD=(u\"e2o\",u\"E9O\")\n",
    "if phonologicalMap==\"-N\":\n",
    "    neutralisations=neutralisationsNORD\n",
    "elif phonologicalMap==\"-S\":\n",
    "    neutralisations=neutralisationsSUD\n",
    "else:\n",
    "    neutralisations=(u\"\",u\"\")\n",
    "    phonologicalMap=(\"-X\")\n",
    "bdlexiqueIn = unicode(u\"èò\"+neutralisations[0])\n",
    "bdlexiqueNum = [ord(char) for char in bdlexiqueIn]\n",
    "neutreOut = unicode(u\"EO\"+neutralisations[1])\n",
    "neutralise = dict(zip(bdlexiqueNum, neutreOut))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def recoder(chaine,table=neutralise):\n",
    "    if type(chaine)==str:\n",
    "        temp=unicode(chaine.decode('utf8')).translate(table)\n",
    "        result=temp.encode('utf8')\n",
    "    elif type(chaine)==unicode:\n",
    "        result=chaine.translate(table)\n",
    "    else:\n",
    "        result=chaine\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Lecture du tableau de VERBES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Lecture du lexique\n",
    "- nomLexique pour le fichier\n",
    "- names pour les noms de colonnes\n",
    "- élimination des lignes dupliquées éventuelles (p.e. dépendre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "filePrefix=\"MGC-150815\"\n",
    "echantillonPrefix=\"-extend-08\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nomLexique=filePrefix+echantillonPrefix+\"-paradigmes.csv\"\n",
    "paradigmes=pd.read_csv(nomLexique,sep=\";\",encoding=\"utf8\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "logfile_name=filePrefix+echantillonPrefix+phonologicalMap+\".log\"\n",
    "logfile = codecs.open(logfile_name,mode='w',encoding=\"utf8\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "casesPrincipales= [\n",
    "        'inf', 'pi1S', 'pi2S', 'pi3S', 'pi1P', 'pi2P', 'pi3P', 'ii1S',\n",
    "        'ii2S', 'ii3S', 'ii1P', 'ii2P', 'ii3P', \n",
    "        'fi1S', 'fi2S', 'fi3S', 'fi1P', 'fi2P',\n",
    "        'fi3P', 'pI2S', 'pI1P', 'pI2P', 'ps1S', 'ps2S', 'ps3S', 'ps1P',\n",
    "        'ps2P', 'ps3P', \n",
    "        'pc1S', 'pc2S', 'pc3S', 'pc1P', 'pc2P', 'pc3P', 'pP',\n",
    "        'ppMS', 'ppMP', 'ppFS', 'ppFP'\n",
    "            ]\n",
    "casesSecondaires= [\n",
    "       'ai1S', 'ai2S', 'ai3S', 'ai1P', 'ai2P', 'ai3P', 'is1S', 'is2S', 'is3S', 'is1P', 'is2P', 'is3P'\n",
    "            ]\n",
    "casesTotales=casesPrincipales+casesSecondaires\n",
    "listeCases=casesTotales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Suppression de la colonne index inutile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "del paradigmes[u\"Unnamed: 0\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sampleCases=paradigmes.columns.tolist()\n",
    "sampleCases.remove(u\"lexeme\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Application de la neutralisation phonologique et stockage des paradigmes neutralisés correspondants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Neutralize all the forms\n",
    "for case in sampleCases:\n",
    "    paradigmes[case]=paradigmes[case].apply(lambda x: recoder(x))\n",
    "\n",
    "#Save neutralized paradigms\n",
    "paradigmes.to_csv(path_or_buf=filePrefix+echantillonPrefix+phonologicalMap+\"-paradigmes.csv\",encoding=\"utf8\",sep=\";\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Préparation du calcul des analogies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Calcul de la différence entre deux formes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def diff(mot1,mot2):\n",
    "    result=[]\n",
    "    diff1=\"\"\n",
    "    diff2=\"\"\n",
    "    same=\"\"\n",
    "    vide=\".\"\n",
    "    lmax=max(len(mot1),len(mot2))\n",
    "    lmin=min(len(mot1),len(mot2))\n",
    "    for index in range(lmax):\n",
    "        if index < lmin:\n",
    "            if mot1[index]!=mot2[index]:\n",
    "                diff1+=mot1[index]\n",
    "                diff2+=mot2[index]\n",
    "                same+=vide\n",
    "            else:\n",
    "                same+=mot1[index]\n",
    "                diff1+=vide\n",
    "                diff2+=vide\n",
    "        elif index < len(mot1):\n",
    "            diff1+=mot1[index]\n",
    "        elif index < len(mot2):\n",
    "            diff2+=mot2[index]\n",
    "    diff1=diff1.lstrip(\".\")\n",
    "    diff2=diff2.lstrip(\".\")\n",
    "#    return (same,diff1,diff2,diff1+\"_\"+diff2)\n",
    "    return (diff1+\"-\"+diff2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Accumulation des paires appartenant à un patron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def rowDiff(row, patrons):\n",
    "    result=diff(row[0],row[1])\n",
    "    if not result in patrons:\n",
    "        patrons[result]=(formesPatron(),formesPatron())\n",
    "    patrons[result][0].ajouterFormes(row[0])\n",
    "    patrons[result][1].ajouterFormes(row[1])\n",
    "    return (result[0],result[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Transformation d'un patron en RegExp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def patron2regexp(morceaux):\n",
    "    result=\"^\"\n",
    "    for morceau in morceaux:\n",
    "        if morceau==\"*\":\n",
    "            result+=\"(.*)\"\n",
    "        elif len(morceau)>1:\n",
    "            result+=\"([\"+morceau+\"])\"\n",
    "        else:\n",
    "            result+=morceau\n",
    "    result+=\"$\"\n",
    "    result=result.replace(\")(\",\"\")\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Substitution de sortie \n",
    "???"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def remplacementSortie(sortie):\n",
    "    n=1\n",
    "    nsortie=\"\"\n",
    "    for lettre in sortie:\n",
    "        if lettre==\".\":\n",
    "            nsortie+=\"\\g<%d>\"%n\n",
    "            n+=1\n",
    "        else:\n",
    "            nsortie+=lettre\n",
    "    return nsortie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class formesPatron:\n",
    "    '''\n",
    "    Accumulateur de formes correspondant à un patron pour calcul de la Généralisation Minimale (cf. MGL)\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.formes=[]\n",
    "\n",
    "#    def __repr__(self):\n",
    "#        return ','.join(self.calculerGM())\n",
    "        \n",
    "    def ajouterForme(self,forme):\n",
    "        self.formes.append(forme)\n",
    "        \n",
    "    def calculerGM(self):\n",
    "        minLongueur=len(min(self.formes, key=len))\n",
    "        maxLongueur=len(max(self.formes, key=len))\n",
    "        if debug: print (minLongueur, maxLongueur, file=logfile)\n",
    "        positions=[]\n",
    "        if maxLongueur>minLongueur:\n",
    "            positions.append(\"*\")\n",
    "        for i in xrange(minLongueur, 0, -1):\n",
    "            phonemes=set([x[-i] for x in self.formes])\n",
    "            if debug: print (phonemes, file=logfile)\n",
    "            if \".\" in phonemes:\n",
    "                positions.append(\".\")\n",
    "            else:\n",
    "                positions.append(\"\".join(fs.lattice[phonemes].extent))\n",
    "        return patron2regexp(positions)\n",
    "\n",
    "class pairePatrons:\n",
    "    '''\n",
    "    Accumulateur de triplets (f1,f2,patron) correspondant à une paire pour calcul des Généralisations Minimales (cf. MGL)\n",
    "    '''\n",
    "    def __init__(self,case1,case2):\n",
    "        self.patrons1={}\n",
    "        self.patrons2={}\n",
    "        self.case1=case1\n",
    "        self.case2=case2\n",
    "\n",
    "#    def __repr__(self):\n",
    "#        return ','.join(self.calculerGM())\n",
    "        \n",
    "    def ajouterFormes(self,forme1,forme2,patron):\n",
    "#        print (forme1,forme2,patron, file=logfile)\n",
    "        patron12=patron\n",
    "        (pat1,pat2)=patron.split(\"-\")\n",
    "        patron21=pat2+\"-\"+pat1\n",
    "#        print (patron12,patron21, file=logfile)\n",
    "        if not patron12 in self.patrons1:\n",
    "            self.patrons1[patron12]=formesPatron()\n",
    "        self.patrons1[patron12].ajouterForme(forme1)\n",
    "        if not patron21 in self.patrons2:\n",
    "            self.patrons2[patron21]=formesPatron()\n",
    "        self.patrons2[patron21].ajouterForme(forme2)\n",
    "        \n",
    "        \n",
    "    def calculerGM(self):\n",
    "        resultat1={}\n",
    "        for patron in self.patrons1:\n",
    "            if debug: print (\"patron1\", patron, file=logfile)\n",
    "            resultat1[patron]=self.patrons1[patron].calculerGM()\n",
    "        resultat2={}\n",
    "        for patron in self.patrons2:\n",
    "            if debug: print (\"patron2\", patron, file=logfile)\n",
    "            resultat2[patron]=self.patrons2[patron].calculerGM()\n",
    "        return (resultat1,resultat2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Classe pour la gestion des patrons, des classes et des transformations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class paireClasses:\n",
    "    def __init__(self,case1,case2):\n",
    "        self.case1=case1\n",
    "        self.case2=case2\n",
    "        self.nom=case1+\"-\"+case2\n",
    "        self.classes1=classesPaire(case1,case2)\n",
    "        self.classes2=classesPaire(case2,case1)\n",
    "\n",
    "    def ajouterPatron(self,n,patron,motif):\n",
    "        if n==1:\n",
    "            self.classes1.ajouterPatron(patron,motif)\n",
    "        elif n==2:\n",
    "            self.classes2.ajouterPatron(patron,motif)\n",
    "        else:\n",
    "            print (\"le numéro de forme n'est pas dans [1,2]\",n, file=logfile)\n",
    "\n",
    "    def ajouterPaire(self,forme1,forme2):\n",
    "        self.classes1.ajouterPaire(forme1,forme2)\n",
    "        self.classes2.ajouterPaire(forme2,forme1)\n",
    "        \n",
    "    def calculerClasses(self):\n",
    "        return(self.classes1,self.classes2)\n",
    "\n",
    "    \n",
    "class classesPaire:\n",
    "    '''\n",
    "    Gestion des patrons, des classes et des transformations\n",
    "    \n",
    "    ajouterPatron : ajoute un patron et son motif associé (MGL)\n",
    "    ajouterPaire : ajoute une paire de formes, calcule la classe de la forme1 et la règle sélectionnée\n",
    "    sortirForme : cacule les formes de sortie correspondant à la forme1 avec leurs coefficients respectifs\n",
    "    '''\n",
    "    def __init__(self,case1,case2):\n",
    "        self.case1=case1\n",
    "        self.case2=case2\n",
    "        self.nom=case1+\"-\"+case2\n",
    "        self.classe={}\n",
    "        self.nbClasse={}\n",
    "        self.patrons={}\n",
    "        self.entree={}\n",
    "        self.sortie={}\n",
    "    \n",
    "    def ajouterPatron(self,patron,motif):\n",
    "        self.patrons[patron]=motif\n",
    "        (entree,sortie)=patron.split(\"-\")\n",
    "        self.entree[patron]=entree.replace(u\".\",u\"(.)\")\n",
    "        self.sortie[patron]=remplacementSortie(sortie)\n",
    "    \n",
    "    def ajouterPaire(self,forme1,forme2):\n",
    "        '''\n",
    "        on calcule la classe de la paire idClasseForme et la règle sélectionnée\n",
    "        on incrémente le compteur de la classe et celui de la règle sélectionnée à l'intérieur de la classe\n",
    "        '''\n",
    "        classeForme=[]\n",
    "        regleForme=\"\"\n",
    "        for patron in self.patrons:\n",
    "            if re.match(self.patrons[patron],forme1):\n",
    "                classeForme.append(patron)\n",
    "                '''\n",
    "                le +\"$\" permet de forcer l'alignement à droite pour les transformations suffixales\n",
    "                '''\n",
    "                if forme2==re.sub(self.entree[patron]+\"$\",self.sortie[patron],forme1):\n",
    "                    regleForme=patron\n",
    "        idClasseForme=\", \".join(classeForme)\n",
    "        if not idClasseForme in self.classe:\n",
    "            self.classe[idClasseForme]={}\n",
    "            self.nbClasse[idClasseForme]=0\n",
    "        if not regleForme in self.classe[idClasseForme]:\n",
    "            self.classe[idClasseForme][regleForme]=0\n",
    "        self.nbClasse[idClasseForme]+=1\n",
    "        self.classe[idClasseForme][regleForme]+=1\n",
    "\n",
    "    def sortirForme(self,forme):\n",
    "        classeForme=[]\n",
    "        sortieForme={}\n",
    "        for patron in self.patrons:\n",
    "            if re.match(self.patrons[patron],forme):\n",
    "                classeForme.append(patron)\n",
    "        if classeForme:\n",
    "            idClasseForme=\", \".join(classeForme)\n",
    "            if idClasseForme in self.nbClasse:\n",
    "                nTotal=self.nbClasse[idClasseForme]\n",
    "                for patron in self.classe[idClasseForme]:\n",
    "                    sortie=re.sub(self.entree[patron]+\"$\",self.sortie[patron],forme)\n",
    "                    sortieForme[sortie]=float(self.classe[idClasseForme][patron])/nTotal\n",
    "            else:\n",
    "                print (forme, file=logfile)\n",
    "                print (\"pas de classe\",idClasseForme, file=logfile)\n",
    "                print (\"%.2f par forme de sortie\" % (float(1)/len(classeForme)), file=logfile)\n",
    "                nTotal=len(classeForme)\n",
    "                for patron in classeForme:\n",
    "                    sortie=re.sub(self.entree[patron]+\"$\",self.sortie[patron],forme)\n",
    "                    sortieForme[sortie]=float(1)/nTotal\n",
    "        else:\n",
    "            print (forme, file=logfile) \n",
    "            print (\"pas de patron\", file=logfile)\n",
    "        return sortieForme\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Appliquer la formule de calcul des différences entre chaines à chaque ligne\n",
    "\n",
    ">si il y a au moins une ligne\n",
    "\n",
    ">>on applique la différence à la ligne\n",
    "\n",
    ">>on calcule les deux patrons par suppression des points initiaux\n",
    "\n",
    ">>on renvoie le groupement par patrons (1&2)\n",
    "\n",
    ">sinon\n",
    "\n",
    ">>on renvoie le paradigme vide d'origine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def OLDrapports(paradigme):\n",
    "    (case1,case2,lexeme)= paradigme.columns.values.tolist()\n",
    "    patrons=pairePatrons(case1,case2)\n",
    "    if len(paradigme)>0:\n",
    "#        for index, row in paradigme.iterrows():\n",
    "#            patrons.ajouterFormes(row[0],row[1],diff(row[0],row[1]))\n",
    "        paradigme.apply(lambda x: patrons.ajouterFormes(x[case1],x[case2],diff(x[case1],x[case2])), axis=1)\n",
    "        (regles1,regles2)=patrons.calculerGM()\n",
    "    return patrons.calculerGM()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def rapports(paradigme):\n",
    "    if len(paradigme.columns.values.tolist())==2:\n",
    "        (case1,lexeme)= paradigme.columns.values.tolist()\n",
    "        case2=case1\n",
    "    else:\n",
    "        (case1,case2,lexeme)= paradigme.columns.values.tolist()\n",
    "    patrons=pairePatrons(case1,case2)\n",
    "    classes=paireClasses(case1,case2)\n",
    "    if len(paradigme)>0:\n",
    "        paradigme.apply(lambda x: patrons.ajouterFormes(x[case1],x[case2],diff(x[case1],x[case2])), axis=1)\n",
    "        (regles1,regles2)=patrons.calculerGM()\n",
    "        for regle in regles1:\n",
    "            classes.ajouterPatron(1,regle,regles1[regle])\n",
    "        for regle in regles2:\n",
    "            classes.ajouterPatron(2,regle,regles2[regle])\n",
    "        paradigme.apply(lambda x: classes.ajouterPaire(x[case1],x[case2]), axis=1)\n",
    "    (classes1,classes2)=classes.calculerClasses()\n",
    "    return (classes1,classes2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Dédoubler les lignes avec des surabondances dans *colonne*\n",
    ">identifier une ligne avec surabondance\n",
    "\n",
    ">>ajouter les lignes correspondant à chaque valeur\n",
    "\n",
    ">>ajouter le numéro de la ligne initiale dans les lignes à supprimer\n",
    "\n",
    ">supprimer les lignes avec surabondance\n",
    "\n",
    "NB : il faut préparer le tableau pour avoir une indexation qui permette l'ajout des valeurs individuelles et la suppression des lignes de surabondances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def splitCellMates(df,colonne):\n",
    "    '''\n",
    "    Calcul d'une dataframe sans surabondance par dédoublement des valeurs\n",
    "    '''\n",
    "    test=df.reset_index()\n",
    "    del test[\"index\"]\n",
    "    splitIndexes=[]\n",
    "    for index,ligne in test.iterrows():\n",
    "        if \",\" in ligne[colonne]:\n",
    "            valeurs=set(ligne[colonne].split(\",\"))\n",
    "            nouvelleLigne=ligne\n",
    "            for valeur in valeurs:\n",
    "                nouvelleLigne[colonne]=valeur\n",
    "                test=test.append(nouvelleLigne,ignore_index=True)\n",
    "            splitIndexes.append(index)\n",
    "    if splitIndexes:\n",
    "        test=test.drop(test.index[splitIndexes])\n",
    "    return test\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Calculer les rapports entre formes pour chaque paire\n",
    "\n",
    ">on fait la liste des cases de *paradigmes*\n",
    "\n",
    ">pour chaque paire du tableau principal\n",
    "\n",
    ">>si la paire fait partie des cases de *paradigmes*\n",
    "\n",
    ">>>on calcule le rapport\n",
    "\n",
    ">>sinon\n",
    "\n",
    ">>>on signale que qu'une des cases n'est pas représentée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def evaluerEchantillon(paradigmes):\n",
    "    result={}\n",
    "    colonnes=paradigmes.columns.values.tolist()\n",
    "    for paire in it.combinations_with_replacement(sampleCases,2):\n",
    "        if debug: print (paire, file=logfile)\n",
    "        if debug1: print (\"-\".join(paire),end=\", \")\n",
    "        paireListe=list(paire)\n",
    "        paireListe.append(\"lexeme\")\n",
    "        if paire[0] in colonnes and paire[1] in colonnes:\n",
    "            paradigmePaire=paradigmes[paireListe].dropna(thresh=3, axis=0).reindex()\n",
    "            if paire[0]==paire[1]:\n",
    "                paireListe[1]=\"TEMP\"\n",
    "                paradigmePaire.columns=paireListe\n",
    "            paradigmePaire=splitCellMates(splitCellMates(paradigmePaire,paireListe[0]),paireListe[1])\n",
    "            result[paire]=rapports(paradigmePaire)\n",
    "        else:\n",
    "            result[paire]=(\"missing pair\", paire)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Boucle de calcul des analogies pour l'échantillon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ai1P-ai1P, ai1P-ai1S, ai1P-ai2P, ai1P-ai2S, ai1P-ai3P, ai1P-ai3S, ai1P-fi1P, ai1P-fi1S, ai1P-fi2P, ai1P-fi2S, ai1P-fi3P, ai1P-fi3S, ai1P-ii1P, ai1P-ii1S, ai1P-ii2P, ai1P-ii2S, ai1P-ii3P, ai1P-ii3S, ai1P-inf, ai1P-is1P, ai1P-is1S, ai1P-is2P, ai1P-is2S, ai1P-is3P, ai1P-is3S, ai1P-pI1P, ai1P-pI2P, ai1P-pI2S, ai1P-pP, ai1P-pc1P, ai1P-pc1S, ai1P-pc2P, ai1P-pc2S, ai1P-pc3P, ai1P-pc3S, ai1P-pi1P, ai1P-pi1S, ai1P-pi2P, ai1P-pi2S, ai1P-pi3P, ai1P-pi3S, ai1P-ppFP, ai1P-ppFS, ai1P-ppMP, ai1P-ppMS, ai1P-ps1P, ai1P-ps1S, ai1P-ps2P, ai1P-ps2S, ai1P-ps3P, ai1P-ps3S, ai1S-ai1S, ai1S-ai2P, ai1S-ai2S, ai1S-ai3P, ai1S-ai3S, ai1S-fi1P, ai1S-fi1S, ai1S-fi2P, ai1S-fi2S, ai1S-fi3P, ai1S-fi3S, ai1S-ii1P, ai1S-ii1S, ai1S-ii2P, ai1S-ii2S, ai1S-ii3P, ai1S-ii3S, ai1S-inf, ai1S-is1P, ai1S-is1S, ai1S-is2P, ai1S-is2S, ai1S-is3P, ai1S-is3S, ai1S-pI1P, ai1S-pI2P, ai1S-pI2S, ai1S-pP, ai1S-pc1P, ai1S-pc1S, ai1S-pc2P, ai1S-pc2S, ai1S-pc3P, ai1S-pc3S, ai1S-pi1P, ai1S-pi1S, ai1S-pi2P, ai1S-pi2S, ai1S-pi3P, ai1S-pi3S, ai1S-ppFP, ai1S-ppFS, ai1S-ppMP, ai1S-ppMS, ai1S-ps1P, ai1S-ps1S, ai1S-ps2P, ai1S-ps2S, ai1S-ps3P, ai1S-ps3S, ai2P-ai2P, ai2P-ai2S, ai2P-ai3P, ai2P-ai3S, ai2P-fi1P, ai2P-fi1S, ai2P-fi2P, ai2P-fi2S, ai2P-fi3P, ai2P-fi3S, ai2P-ii1P, ai2P-ii1S, ai2P-ii2P, ai2P-ii2S, ai2P-ii3P, ai2P-ii3S, ai2P-inf, ai2P-is1P, ai2P-is1S, ai2P-is2P, ai2P-is2S, ai2P-is3P, ai2P-is3S, ai2P-pI1P, ai2P-pI2P, ai2P-pI2S, ai2P-pP, ai2P-pc1P, ai2P-pc1S, ai2P-pc2P, ai2P-pc2S, ai2P-pc3P, ai2P-pc3S, ai2P-pi1P, ai2P-pi1S, ai2P-pi2P, ai2P-pi2S, ai2P-pi3P, ai2P-pi3S, ai2P-ppFP, ai2P-ppFS, ai2P-ppMP, ai2P-ppMS, ai2P-ps1P, ai2P-ps1S, ai2P-ps2P, ai2P-ps2S, ai2P-ps3P, ai2P-ps3S, ai2S-ai2S, ai2S-ai3P, ai2S-ai3S, ai2S-fi1P, ai2S-fi1S, ai2S-fi2P, ai2S-fi2S, ai2S-fi3P, ai2S-fi3S, ai2S-ii1P, ai2S-ii1S, ai2S-ii2P, ai2S-ii2S, ai2S-ii3P, ai2S-ii3S, ai2S-inf, ai2S-is1P, ai2S-is1S, ai2S-is2P, ai2S-is2S, ai2S-is3P, ai2S-is3S, ai2S-pI1P, ai2S-pI2P, ai2S-pI2S, ai2S-pP, ai2S-pc1P, ai2S-pc1S, ai2S-pc2P, ai2S-pc2S, ai2S-pc3P, ai2S-pc3S, ai2S-pi1P, ai2S-pi1S, ai2S-pi2P, ai2S-pi2S, ai2S-pi3P, ai2S-pi3S, ai2S-ppFP, ai2S-ppFS, ai2S-ppMP, ai2S-ppMS, ai2S-ps1P, ai2S-ps1S, ai2S-ps2P, ai2S-ps2S, ai2S-ps3P, ai2S-ps3S, ai3P-ai3P, ai3P-ai3S, ai3P-fi1P, ai3P-fi1S, ai3P-fi2P, ai3P-fi2S, ai3P-fi3P, ai3P-fi3S, ai3P-ii1P, ai3P-ii1S, ai3P-ii2P, ai3P-ii2S, ai3P-ii3P, ai3P-ii3S, ai3P-inf, ai3P-is1P, ai3P-is1S, ai3P-is2P, ai3P-is2S, ai3P-is3P, ai3P-is3S, ai3P-pI1P, ai3P-pI2P, ai3P-pI2S, ai3P-pP, ai3P-pc1P, ai3P-pc1S, ai3P-pc2P, ai3P-pc2S, ai3P-pc3P, ai3P-pc3S, ai3P-pi1P, ai3P-pi1S, ai3P-pi2P, ai3P-pi2S, ai3P-pi3P, ai3P-pi3S, ai3P-ppFP, ai3P-ppFS, ai3P-ppMP, ai3P-ppMS, ai3P-ps1P, ai3P-ps1S, ai3P-ps2P, ai3P-ps2S, ai3P-ps3P, ai3P-ps3S, ai3S-ai3S, ai3S-fi1P, ai3S-fi1S, ai3S-fi2P, ai3S-fi2S, ai3S-fi3P, ai3S-fi3S, ai3S-ii1P, ai3S-ii1S, ai3S-ii2P, ai3S-ii2S, ai3S-ii3P, ai3S-ii3S, ai3S-inf, ai3S-is1P, ai3S-is1S, ai3S-is2P, ai3S-is2S, ai3S-is3P, ai3S-is3S, ai3S-pI1P, ai3S-pI2P, ai3S-pI2S, ai3S-pP, ai3S-pc1P, ai3S-pc1S, ai3S-pc2P, ai3S-pc2S, ai3S-pc3P, ai3S-pc3S, ai3S-pi1P, ai3S-pi1S, ai3S-pi2P, ai3S-pi2S, ai3S-pi3P, ai3S-pi3S, ai3S-ppFP, ai3S-ppFS, ai3S-ppMP, ai3S-ppMS, ai3S-ps1P, ai3S-ps1S, ai3S-ps2P, ai3S-ps2S, ai3S-ps3P, ai3S-ps3S, fi1P-fi1P, fi1P-fi1S, fi1P-fi2P, fi1P-fi2S, fi1P-fi3P, fi1P-fi3S, fi1P-ii1P, fi1P-ii1S, fi1P-ii2P, fi1P-ii2S, fi1P-ii3P, fi1P-ii3S, fi1P-inf, fi1P-is1P, fi1P-is1S, fi1P-is2P, fi1P-is2S, fi1P-is3P, fi1P-is3S, fi1P-pI1P, fi1P-pI2P, fi1P-pI2S, fi1P-pP, fi1P-pc1P, fi1P-pc1S, fi1P-pc2P, fi1P-pc2S, fi1P-pc3P, fi1P-pc3S, fi1P-pi1P, fi1P-pi1S, fi1P-pi2P, fi1P-pi2S, fi1P-pi3P, fi1P-pi3S, fi1P-ppFP, fi1P-ppFS, fi1P-ppMP, fi1P-ppMS, fi1P-ps1P, fi1P-ps1S, fi1P-ps2P, fi1P-ps2S, fi1P-ps3P, fi1P-ps3S, fi1S-fi1S, fi1S-fi2P, fi1S-fi2S, fi1S-fi3P, fi1S-fi3S, fi1S-ii1P, fi1S-ii1S, fi1S-ii2P, fi1S-ii2S, fi1S-ii3P, fi1S-ii3S, fi1S-inf, fi1S-is1P, fi1S-is1S, fi1S-is2P, fi1S-is2S, fi1S-is3P, fi1S-is3S, fi1S-pI1P, fi1S-pI2P, fi1S-pI2S, fi1S-pP, fi1S-pc1P, fi1S-pc1S, fi1S-pc2P, fi1S-pc2S, fi1S-pc3P, fi1S-pc3S, fi1S-pi1P, fi1S-pi1S, fi1S-pi2P, fi1S-pi2S, fi1S-pi3P, fi1S-pi3S, fi1S-ppFP, fi1S-ppFS, fi1S-ppMP, fi1S-ppMS, fi1S-ps1P, fi1S-ps1S, fi1S-ps2P, fi1S-ps2S, fi1S-ps3P, fi1S-ps3S, fi2P-fi2P, fi2P-fi2S, fi2P-fi3P, fi2P-fi3S, fi2P-ii1P, fi2P-ii1S, fi2P-ii2P, fi2P-ii2S, fi2P-ii3P, fi2P-ii3S, fi2P-inf, fi2P-is1P, fi2P-is1S, fi2P-is2P, fi2P-is2S, fi2P-is3P, fi2P-is3S, fi2P-pI1P, fi2P-pI2P, fi2P-pI2S, fi2P-pP, fi2P-pc1P, fi2P-pc1S, fi2P-pc2P, fi2P-pc2S, fi2P-pc3P, fi2P-pc3S, fi2P-pi1P, fi2P-pi1S, fi2P-pi2P, fi2P-pi2S, fi2P-pi3P, fi2P-pi3S, fi2P-ppFP, fi2P-ppFS, fi2P-ppMP, fi2P-ppMS, fi2P-ps1P, fi2P-ps1S, fi2P-ps2P, fi2P-ps2S, fi2P-ps3P, fi2P-ps3S, fi2S-fi2S, fi2S-fi3P, fi2S-fi3S, fi2S-ii1P, fi2S-ii1S, fi2S-ii2P, fi2S-ii2S, fi2S-ii3P, fi2S-ii3S, fi2S-inf, fi2S-is1P, fi2S-is1S, fi2S-is2P, fi2S-is2S, fi2S-is3P, fi2S-is3S, fi2S-pI1P, fi2S-pI2P, fi2S-pI2S, fi2S-pP, fi2S-pc1P, fi2S-pc1S, fi2S-pc2P, fi2S-pc2S, fi2S-pc3P, fi2S-pc3S, fi2S-pi1P, fi2S-pi1S, fi2S-pi2P, fi2S-pi2S, fi2S-pi3P, fi2S-pi3S, fi2S-ppFP, fi2S-ppFS, fi2S-ppMP, fi2S-ppMS, fi2S-ps1P, fi2S-ps1S, fi2S-ps2P, fi2S-ps2S, fi2S-ps3P, fi2S-ps3S, fi3P-fi3P, fi3P-fi3S, fi3P-ii1P, fi3P-ii1S, fi3P-ii2P, fi3P-ii2S, fi3P-ii3P, fi3P-ii3S, fi3P-inf, fi3P-is1P, fi3P-is1S, fi3P-is2P, fi3P-is2S, fi3P-is3P, fi3P-is3S, fi3P-pI1P, fi3P-pI2P, fi3P-pI2S, fi3P-pP, fi3P-pc1P, fi3P-pc1S, fi3P-pc2P, fi3P-pc2S, fi3P-pc3P, fi3P-pc3S, fi3P-pi1P, fi3P-pi1S, fi3P-pi2P, fi3P-pi2S, fi3P-pi3P, fi3P-pi3S, fi3P-ppFP, fi3P-ppFS, fi3P-ppMP, fi3P-ppMS, fi3P-ps1P, fi3P-ps1S, fi3P-ps2P, fi3P-ps2S, fi3P-ps3P, fi3P-ps3S, fi3S-fi3S, fi3S-ii1P, fi3S-ii1S, fi3S-ii2P, fi3S-ii2S, fi3S-ii3P, fi3S-ii3S, fi3S-inf, fi3S-is1P, fi3S-is1S, fi3S-is2P, fi3S-is2S, fi3S-is3P, fi3S-is3S, fi3S-pI1P, fi3S-pI2P, fi3S-pI2S, fi3S-pP, fi3S-pc1P, fi3S-pc1S, fi3S-pc2P, fi3S-pc2S, fi3S-pc3P, fi3S-pc3S, fi3S-pi1P, fi3S-pi1S, fi3S-pi2P, fi3S-pi2S, fi3S-pi3P, fi3S-pi3S, fi3S-ppFP, fi3S-ppFS, fi3S-ppMP, fi3S-ppMS, fi3S-ps1P, fi3S-ps1S, fi3S-ps2P, fi3S-ps2S, fi3S-ps3P, fi3S-ps3S, ii1P-ii1P, ii1P-ii1S, ii1P-ii2P, ii1P-ii2S, ii1P-ii3P, ii1P-ii3S, ii1P-inf, ii1P-is1P, ii1P-is1S, ii1P-is2P, ii1P-is2S, ii1P-is3P, ii1P-is3S, ii1P-pI1P, ii1P-pI2P, ii1P-pI2S, ii1P-pP, ii1P-pc1P, ii1P-pc1S, ii1P-pc2P, ii1P-pc2S, ii1P-pc3P, ii1P-pc3S, ii1P-pi1P, ii1P-pi1S, ii1P-pi2P, ii1P-pi2S, ii1P-pi3P, ii1P-pi3S, ii1P-ppFP, ii1P-ppFS, ii1P-ppMP, ii1P-ppMS, ii1P-ps1P, ii1P-ps1S, ii1P-ps2P, ii1P-ps2S, ii1P-ps3P, ii1P-ps3S, ii1S-ii1S, ii1S-ii2P, ii1S-ii2S, ii1S-ii3P, ii1S-ii3S, ii1S-inf, ii1S-is1P, ii1S-is1S, ii1S-is2P, ii1S-is2S, ii1S-is3P, ii1S-is3S, ii1S-pI1P, ii1S-pI2P, ii1S-pI2S, ii1S-pP, ii1S-pc1P, ii1S-pc1S, ii1S-pc2P, ii1S-pc2S, ii1S-pc3P, ii1S-pc3S, ii1S-pi1P, ii1S-pi1S, ii1S-pi2P, ii1S-pi2S, ii1S-pi3P, ii1S-pi3S, ii1S-ppFP, ii1S-ppFS, ii1S-ppMP, ii1S-ppMS, ii1S-ps1P, ii1S-ps1S, ii1S-ps2P, ii1S-ps2S, ii1S-ps3P, ii1S-ps3S, ii2P-ii2P, ii2P-ii2S, ii2P-ii3P, ii2P-ii3S, ii2P-inf, ii2P-is1P, ii2P-is1S, ii2P-is2P, ii2P-is2S, ii2P-is3P, ii2P-is3S, ii2P-pI1P, ii2P-pI2P, ii2P-pI2S, ii2P-pP, ii2P-pc1P, ii2P-pc1S, ii2P-pc2P, ii2P-pc2S, ii2P-pc3P, ii2P-pc3S, ii2P-pi1P, ii2P-pi1S, ii2P-pi2P, ii2P-pi2S, ii2P-pi3P, ii2P-pi3S, ii2P-ppFP, ii2P-ppFS, ii2P-ppMP, ii2P-ppMS, ii2P-ps1P, ii2P-ps1S, ii2P-ps2P, ii2P-ps2S, ii2P-ps3P, ii2P-ps3S, ii2S-ii2S, ii2S-ii3P, ii2S-ii3S, ii2S-inf, ii2S-is1P, ii2S-is1S, ii2S-is2P, ii2S-is2S, ii2S-is3P, ii2S-is3S, ii2S-pI1P, ii2S-pI2P, ii2S-pI2S, ii2S-pP, ii2S-pc1P, ii2S-pc1S, ii2S-pc2P, ii2S-pc2S, ii2S-pc3P, ii2S-pc3S, ii2S-pi1P, ii2S-pi1S, ii2S-pi2P, ii2S-pi2S, ii2S-pi3P, ii2S-pi3S, ii2S-ppFP, ii2S-ppFS, ii2S-ppMP, ii2S-ppMS, ii2S-ps1P, ii2S-ps1S, ii2S-ps2P, ii2S-ps2S, ii2S-ps3P, ii2S-ps3S, ii3P-ii3P, ii3P-ii3S, ii3P-inf, ii3P-is1P, ii3P-is1S, ii3P-is2P, ii3P-is2S, ii3P-is3P, ii3P-is3S, ii3P-pI1P, ii3P-pI2P, ii3P-pI2S, ii3P-pP, ii3P-pc1P, ii3P-pc1S, ii3P-pc2P, ii3P-pc2S, ii3P-pc3P, ii3P-pc3S, ii3P-pi1P, ii3P-pi1S, ii3P-pi2P, ii3P-pi2S, ii3P-pi3P, ii3P-pi3S, ii3P-ppFP, ii3P-ppFS, ii3P-ppMP, ii3P-ppMS, ii3P-ps1P, ii3P-ps1S, ii3P-ps2P, ii3P-ps2S, ii3P-ps3P, ii3P-ps3S, ii3S-ii3S, ii3S-inf, ii3S-is1P, ii3S-is1S, ii3S-is2P, ii3S-is2S, ii3S-is3P, ii3S-is3S, ii3S-pI1P, ii3S-pI2P, ii3S-pI2S, ii3S-pP, ii3S-pc1P, ii3S-pc1S, ii3S-pc2P, ii3S-pc2S, ii3S-pc3P, ii3S-pc3S, ii3S-pi1P, ii3S-pi1S, ii3S-pi2P, ii3S-pi2S, ii3S-pi3P, ii3S-pi3S, ii3S-ppFP, ii3S-ppFS, ii3S-ppMP, ii3S-ppMS, ii3S-ps1P, ii3S-ps1S, ii3S-ps2P, ii3S-ps2S, ii3S-ps3P, ii3S-ps3S, inf-inf, inf-is1P, inf-is1S, inf-is2P, inf-is2S, inf-is3P, inf-is3S, inf-pI1P, inf-pI2P, inf-pI2S, inf-pP, inf-pc1P, inf-pc1S, inf-pc2P, inf-pc2S, inf-pc3P, inf-pc3S, inf-pi1P, inf-pi1S, inf-pi2P, inf-pi2S, inf-pi3P, inf-pi3S, inf-ppFP, inf-ppFS, inf-ppMP, inf-ppMS, inf-ps1P, inf-ps1S, inf-ps2P, inf-ps2S, inf-ps3P, inf-ps3S, is1P-is1P, is1P-is1S, is1P-is2P, is1P-is2S, is1P-is3P, is1P-is3S, is1P-pI1P, is1P-pI2P, is1P-pI2S, is1P-pP, is1P-pc1P, is1P-pc1S, is1P-pc2P, is1P-pc2S, is1P-pc3P, is1P-pc3S, is1P-pi1P, is1P-pi1S, is1P-pi2P, is1P-pi2S, is1P-pi3P, is1P-pi3S, is1P-ppFP, is1P-ppFS, is1P-ppMP, is1P-ppMS, is1P-ps1P, is1P-ps1S, is1P-ps2P, is1P-ps2S, is1P-ps3P, is1P-ps3S, is1S-is1S, is1S-is2P, is1S-is2S, is1S-is3P, is1S-is3S, is1S-pI1P, is1S-pI2P, is1S-pI2S, is1S-pP, is1S-pc1P, is1S-pc1S, is1S-pc2P, is1S-pc2S, is1S-pc3P, is1S-pc3S, is1S-pi1P, is1S-pi1S, is1S-pi2P, is1S-pi2S, is1S-pi3P, is1S-pi3S, is1S-ppFP, is1S-ppFS, is1S-ppMP, is1S-ppMS, is1S-ps1P, is1S-ps1S, is1S-ps2P, is1S-ps2S, is1S-ps3P, is1S-ps3S, is2P-is2P, is2P-is2S, is2P-is3P, is2P-is3S, is2P-pI1P, is2P-pI2P, is2P-pI2S, is2P-pP, is2P-pc1P, is2P-pc1S, is2P-pc2P, is2P-pc2S, is2P-pc3P, is2P-pc3S, is2P-pi1P, is2P-pi1S, is2P-pi2P, is2P-pi2S, is2P-pi3P, is2P-pi3S, is2P-ppFP, is2P-ppFS, is2P-ppMP, is2P-ppMS, is2P-ps1P, is2P-ps1S, is2P-ps2P, is2P-ps2S, is2P-ps3P, is2P-ps3S, is2S-is2S, is2S-is3P, is2S-is3S, is2S-pI1P, is2S-pI2P, is2S-pI2S, is2S-pP, is2S-pc1P, is2S-pc1S, is2S-pc2P, is2S-pc2S, is2S-pc3P, is2S-pc3S, is2S-pi1P, is2S-pi1S, is2S-pi2P, is2S-pi2S, is2S-pi3P, is2S-pi3S, is2S-ppFP, is2S-ppFS, is2S-ppMP, is2S-ppMS, is2S-ps1P, is2S-ps1S, is2S-ps2P, is2S-ps2S, is2S-ps3P, is2S-ps3S, is3P-is3P, is3P-is3S, is3P-pI1P, is3P-pI2P, is3P-pI2S, is3P-pP, is3P-pc1P, is3P-pc1S, is3P-pc2P, is3P-pc2S, is3P-pc3P, is3P-pc3S, is3P-pi1P, is3P-pi1S, is3P-pi2P, is3P-pi2S, is3P-pi3P, is3P-pi3S, is3P-ppFP, is3P-ppFS, is3P-ppMP, is3P-ppMS, is3P-ps1P, is3P-ps1S, is3P-ps2P, is3P-ps2S, is3P-ps3P, is3P-ps3S, is3S-is3S, is3S-pI1P, is3S-pI2P, is3S-pI2S, is3S-pP, is3S-pc1P, is3S-pc1S, is3S-pc2P, is3S-pc2S, is3S-pc3P, is3S-pc3S, is3S-pi1P, is3S-pi1S, is3S-pi2P, is3S-pi2S, is3S-pi3P, is3S-pi3S, is3S-ppFP, is3S-ppFS, is3S-ppMP, is3S-ppMS, is3S-ps1P, is3S-ps1S, is3S-ps2P, is3S-ps2S, is3S-ps3P, is3S-ps3S, pI1P-pI1P, pI1P-pI2P, pI1P-pI2S, pI1P-pP, pI1P-pc1P, pI1P-pc1S, pI1P-pc2P, pI1P-pc2S, pI1P-pc3P, pI1P-pc3S, pI1P-pi1P, pI1P-pi1S, pI1P-pi2P, pI1P-pi2S, pI1P-pi3P, pI1P-pi3S, pI1P-ppFP, pI1P-ppFS, pI1P-ppMP, pI1P-ppMS, pI1P-ps1P, pI1P-ps1S, pI1P-ps2P, pI1P-ps2S, pI1P-ps3P, pI1P-ps3S, pI2P-pI2P, pI2P-pI2S, pI2P-pP, pI2P-pc1P, pI2P-pc1S, pI2P-pc2P, pI2P-pc2S, pI2P-pc3P, pI2P-pc3S, pI2P-pi1P, pI2P-pi1S, pI2P-pi2P, pI2P-pi2S, pI2P-pi3P, pI2P-pi3S, pI2P-ppFP, pI2P-ppFS, pI2P-ppMP, pI2P-ppMS, pI2P-ps1P, pI2P-ps1S, pI2P-ps2P, pI2P-ps2S, pI2P-ps3P, pI2P-ps3S, pI2S-pI2S, pI2S-pP, pI2S-pc1P, pI2S-pc1S, pI2S-pc2P, pI2S-pc2S, pI2S-pc3P, pI2S-pc3S, pI2S-pi1P, pI2S-pi1S, pI2S-pi2P, pI2S-pi2S, pI2S-pi3P, pI2S-pi3S, pI2S-ppFP, pI2S-ppFS, pI2S-ppMP, pI2S-ppMS, pI2S-ps1P, pI2S-ps1S, pI2S-ps2P, pI2S-ps2S, pI2S-ps3P, pI2S-ps3S, pP-pP, pP-pc1P, pP-pc1S, pP-pc2P, pP-pc2S, pP-pc3P, pP-pc3S, pP-pi1P, pP-pi1S, pP-pi2P, pP-pi2S, pP-pi3P, pP-pi3S, pP-ppFP, pP-ppFS, pP-ppMP, pP-ppMS, pP-ps1P, pP-ps1S, pP-ps2P, pP-ps2S, pP-ps3P, pP-ps3S, pc1P-pc1P, pc1P-pc1S, pc1P-pc2P, pc1P-pc2S, pc1P-pc3P, pc1P-pc3S, pc1P-pi1P, pc1P-pi1S, pc1P-pi2P, pc1P-pi2S, pc1P-pi3P, pc1P-pi3S, pc1P-ppFP, pc1P-ppFS, pc1P-ppMP, pc1P-ppMS, pc1P-ps1P, pc1P-ps1S, pc1P-ps2P, pc1P-ps2S, pc1P-ps3P, pc1P-ps3S, pc1S-pc1S, pc1S-pc2P, pc1S-pc2S, pc1S-pc3P, pc1S-pc3S, pc1S-pi1P, pc1S-pi1S, pc1S-pi2P, pc1S-pi2S, pc1S-pi3P, pc1S-pi3S, pc1S-ppFP, pc1S-ppFS, pc1S-ppMP, pc1S-ppMS, pc1S-ps1P, pc1S-ps1S, pc1S-ps2P, pc1S-ps2S, pc1S-ps3P, pc1S-ps3S, pc2P-pc2P, pc2P-pc2S, pc2P-pc3P, pc2P-pc3S, pc2P-pi1P, pc2P-pi1S, pc2P-pi2P, pc2P-pi2S, pc2P-pi3P, pc2P-pi3S, pc2P-ppFP, pc2P-ppFS, pc2P-ppMP, pc2P-ppMS, pc2P-ps1P, pc2P-ps1S, pc2P-ps2P, pc2P-ps2S, pc2P-ps3P, pc2P-ps3S, pc2S-pc2S, pc2S-pc3P, pc2S-pc3S, pc2S-pi1P, pc2S-pi1S, pc2S-pi2P, pc2S-pi2S, pc2S-pi3P, pc2S-pi3S, pc2S-ppFP, pc2S-ppFS, pc2S-ppMP, pc2S-ppMS, pc2S-ps1P, pc2S-ps1S, pc2S-ps2P, pc2S-ps2S, pc2S-ps3P, pc2S-ps3S, pc3P-pc3P, pc3P-pc3S, pc3P-pi1P, pc3P-pi1S, pc3P-pi2P, pc3P-pi2S, pc3P-pi3P, pc3P-pi3S, pc3P-ppFP, pc3P-ppFS, pc3P-ppMP, pc3P-ppMS, pc3P-ps1P, pc3P-ps1S, pc3P-ps2P, pc3P-ps2S, pc3P-ps3P, pc3P-ps3S, pc3S-pc3S, pc3S-pi1P, pc3S-pi1S, pc3S-pi2P, pc3S-pi2S, pc3S-pi3P, pc3S-pi3S, pc3S-ppFP, pc3S-ppFS, pc3S-ppMP, pc3S-ppMS, pc3S-ps1P, pc3S-ps1S, pc3S-ps2P, pc3S-ps2S, pc3S-ps3P, pc3S-ps3S, pi1P-pi1P, pi1P-pi1S, pi1P-pi2P, pi1P-pi2S, pi1P-pi3P, pi1P-pi3S, pi1P-ppFP, pi1P-ppFS, pi1P-ppMP, pi1P-ppMS, pi1P-ps1P, pi1P-ps1S, pi1P-ps2P, pi1P-ps2S, pi1P-ps3P, pi1P-ps3S, pi1S-pi1S, pi1S-pi2P, pi1S-pi2S, pi1S-pi3P, pi1S-pi3S, pi1S-ppFP, pi1S-ppFS, pi1S-ppMP, pi1S-ppMS, pi1S-ps1P, pi1S-ps1S, pi1S-ps2P, pi1S-ps2S, pi1S-ps3P, pi1S-ps3S, pi2P-pi2P, pi2P-pi2S, pi2P-pi3P, pi2P-pi3S, pi2P-ppFP, pi2P-ppFS, pi2P-ppMP, pi2P-ppMS, pi2P-ps1P, pi2P-ps1S, pi2P-ps2P, pi2P-ps2S, pi2P-ps3P, pi2P-ps3S, pi2S-pi2S, pi2S-pi3P, pi2S-pi3S, pi2S-ppFP, pi2S-ppFS, pi2S-ppMP, pi2S-ppMS, pi2S-ps1P, pi2S-ps1S, pi2S-ps2P, pi2S-ps2S, pi2S-ps3P, pi2S-ps3S, pi3P-pi3P, pi3P-pi3S, pi3P-ppFP, pi3P-ppFS, pi3P-ppMP, pi3P-ppMS, pi3P-ps1P, pi3P-ps1S, pi3P-ps2P, pi3P-ps2S, pi3P-ps3P, pi3P-ps3S, pi3S-pi3S, pi3S-ppFP, pi3S-ppFS, pi3S-ppMP, pi3S-ppMS, pi3S-ps1P, pi3S-ps1S, pi3S-ps2P, pi3S-ps2S, pi3S-ps3P, pi3S-ps3S, ppFP-ppFP, ppFP-ppFS, ppFP-ppMP, ppFP-ppMS, ppFP-ps1P, ppFP-ps1S, ppFP-ps2P, ppFP-ps2S, ppFP-ps3P, ppFP-ps3S, ppFS-ppFS, ppFS-ppMP, ppFS-ppMS, ppFS-ps1P, ppFS-ps1S, ppFS-ps2P, ppFS-ps2S, ppFS-ps3P, ppFS-ps3S, ppMP-ppMP, ppMP-ppMS, ppMP-ps1P, ppMP-ps1S, ppMP-ps2P, ppMP-ps2S, ppMP-ps3P, ppMP-ps3S, ppMS-ppMS, ppMS-ps1P, ppMS-ps1S, ppMS-ps2P, ppMS-ps2S, ppMS-ps3P, ppMS-ps3S, ps1P-ps1P, ps1P-ps1S, ps1P-ps2P, ps1P-ps2S, ps1P-ps3P, ps1P-ps3S, ps1S-ps1S, ps1S-ps2P, ps1S-ps2S, ps1S-ps3P, ps1S-ps3S, ps2P-ps2P, ps2P-ps2S, ps2P-ps3P, ps2P-ps3S, ps2S-ps2S, ps2S-ps3P, ps2S-ps3S, ps3P-ps3P, ps3P-ps3S, ps3S-ps3S, CPU times: user 16min 13s, sys: 8.89 s, total: 16min 22s\n",
      "Wall time: 16min 36s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "debug=False\n",
    "debug1=True\n",
    "resultats=evaluerEchantillon(paradigmes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "classesFinales={}\n",
    "for resultat in resultats:\n",
    "    classesFinales[resultat]=resultats[resultat][0]\n",
    "    classesFinales[(resultat[1],resultat[0])]=resultats[resultat][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "with open(filePrefix+echantillonPrefix+phonologicalMap+'-Regles.pkl', 'wb') as output:\n",
    "   pickle.dump(classesFinales, output, pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{u'm\\xe2Z': 1.0}"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classesFinales[(\"inf\",\"pi3S\")].sortirForme(u\"mâZe\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}