dico-rimes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionnaire de rimes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons essayer de construire un dictionnaire de rimes à partir de la ressource [lexique 3.80](http://www.lexique.org/).\n",
    "À l'aide de la fonction 'recherche par propriété' nous avons pu extraire les mots portant la catégorie 'NOM' du lexique et récupérer pour chacun d'entre les informations suivantes : ortho, phon, lemme, cgram, genre, nombre\n",
    "\n",
    "Dans le fichier `noms-lexique.org.txt` nous avons (5 premières lignes) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ortho\tphon\tlemme\tcgram\tgenre\tnombre\n",
      "a\ta\ta\tNOM\tm\n",
      "a priori\tapRijoRi\ta priori\tNOM\tm\n",
      "à-côté\takote\tà-côté\tNOM\tm\ts\n",
      "à-côtés\takote\tà-côté\tNOM\tm\tp\n"
     ]
    }
   ],
   "source": [
    "with open('noms-lexique.org.txt', 'r') as f:\n",
    "    for i in range(0, 5):\n",
    "        line = f.readline()\n",
    "        line = line.rstrip()\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notre dictionnaire de rimes devra *in fine* permettre de trouver les rimes possibles d'un mot c-a-d les noms qui ont la même terminaison phonétique.\n",
    "Pour cela nous devrons conserver deux informations du fichier : ortho et phon  \n",
    "Commençons pour ça."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Extraction des données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons parcourir l'intégralité du fichier et ne récupérer que les informations ortho et phon  \n",
    "C'est un fichier au format `tsv`, les champs sont séparés par une tabulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = []\n",
    "with open('noms-lexique.org.txt', 'r') as f:\n",
    "    f.readline() # première ligne\n",
    "    for line in f:\n",
    "        fields = line.split('\\t')\n",
    "        ortho = fields[0]\n",
    "        phon = fields[1]\n",
    "        words.append((ortho, phon))            \n",
    "          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### On peut synthétiser un peu le code à l'aide des tranches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('à-côtés', 'akote'), ('à-coup', 'aku'), ('à-coups', 'aku')]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words = []\n",
    "with open('noms-lexique.org.txt', 'r') as f:\n",
    "    f.readline() # première ligne\n",
    "    for line in f:\n",
    "        ortho, phon = line.split('\\t')[0:2]\n",
    "        words.append((ortho, phon))\n",
    "words[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hop, on emballe dans une fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract(filename):\n",
    "    \"\"\"Extrait du fichier arguement les deux premiers champs\n",
    "    arg : nom du fichier au format tsv\n",
    "    return : list de tuples (ortho, phon)\n",
    "    \"\"\"\n",
    "    words = []\n",
    "    with open(filename, 'r') as f:\n",
    "        f.readline() # première ligne\n",
    "        for line in f:\n",
    "            ortho, phon = line.split('\\t')[0:2]\n",
    "            words.append((ortho, phon))\n",
    "    return words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'a'),\n",
       " ('a priori', 'apRijoRi'),\n",
       " ('à-côté', 'akote'),\n",
       " ('à-côtés', 'akote'),\n",
       " ('à-coup', 'aku')]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lexique = extract('noms-lexique.org.txt')\n",
    "lexique[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constitution de la structure de données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous voulons classer les noms de notre liste en fonction des phonèmes de terminaison.  \n",
    "Et cela selon trois classements différents : par suite de 3 phonèmes, 2 phonèmes et enfin un phonème.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "dico_3 = {}\n",
    "for item in lexique:\n",
    "    if len(item[1]) >= 3:\n",
    "        rime_3 = item[1][-3:]\n",
    "        #if rime_3 not in dico_3:\n",
    "        #    dico_3[rime_3] = list()\n",
    "        #dico_3[rime_3].append(item[0])\n",
    "        dico_3.setdefault(rime_3, []).append(item[0])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mk_dico(lexique, n):\n",
    "    \"\"\"\n",
    "    Construit un dictionnaire de rimes de longueur n\n",
    "    à partir d'un lexique phonétisé\n",
    "    args : lexique [(ortho, phon)], n int\n",
    "    return : dict {rime : [word1, word2, ..]}\n",
    "    \"\"\"\n",
    "    dico = {}\n",
    "    for item in lexique:\n",
    "        if len(item[1]) >= n:\n",
    "            rime = item[1][-n:]\n",
    "            dico.setdefault(rime, []).append(item[0])\n",
    "    return dico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parcours et recherche dans la structure de données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dico_3 = mk_dico(lexique, 3)\n",
    "dico_2 = mk_dico(lexique, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que nous avons constitué notre dictionnaire des rimes nous allons nous en servir.\n",
    "Le scénario d'utilisation est le suivant, pour un mot donné :  \n",
    "1. trouver la transcription phonétique\n",
    "2. extraire de la transcription les 3 derniers phonèmes (ou 2 le cas échéant)\n",
    "3. trouver dans le dictionnaire la liste des mots du lexique qui ont la même suite de phonèmes finaux\n",
    "4. piocher un mot au hasard dans la liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def ortho2phon(word, words_list):\n",
    "    \"\"\"\n",
    "    Trouve un mot (word) dans une liste (words_list)\n",
    "    et retourne la forme phonétique correspondante\n",
    "    (en cas d'homographe non homophone, retourne le premier trouvé)\n",
    "    args : word (str), words_list [(ortho, phon), (.., ..)]\n",
    "    return : str, \"\" si word ne fait pas partie de la liste\n",
    "    \"\"\"\n",
    "    for item in words_list:\n",
    "        if word == item[0]:\n",
    "            return item[1]\n",
    "    return \"\"\n",
    "\n",
    "def find_rhyme(word, dico, lexique, n=3):\n",
    "    \"\"\"\n",
    "    Pour un mot donné, retourne un mot au hasard dont les n\n",
    "    derniers phonèmes riment\n",
    "    args : word (str), dico (dict) le dictionnaire de rimes, \n",
    "        lexique (list) lexique ortho, phon, n (int) le nombre de phonèmes terminaux\n",
    "    \"\"\"\n",
    "    # 1 trouver la transcription phonétique\n",
    "    phon = ortho2phon(word, lexique)\n",
    "    if not phon:\n",
    "        return None\n",
    "    # 2 extraire de la transcription les 3 derniers phonèmes (ou 2 le cas échéant)\n",
    "    # 3 trouver dans le dictionnaire la liste des mots du lexique qui ont la même suite de phonèmes finaux\n",
    "    if phon[-n:] not in dico:\n",
    "        return None\n",
    "    rhymes = dico[phon[-n:]]\n",
    "    if word in rhymes:\n",
    "        rhymes.remove(word)\n",
    "    # 4. piocher un mot au hasard dans la liste\n",
    "    rand = random.randint(0, len(rhymes) - 1)\n",
    "    return rhymes[rand]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "savoir-vivre\n"
     ]
    }
   ],
   "source": [
    "word = \"livres\"\n",
    "rime = find_rhyme(word, dico_3, lexique)\n",
    "print(rime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exemple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons utiliser notre dictionnaire de rimes pour modifier la première strophe de *Brise Marine* de Mallarmé :  \n",
    "\n",
    "La chair est triste, hélas ! et j'ai lu tous les livres.  \n",
    "Fuir ! là-bas fuir! Je sens que des oiseaux sont ivres  \n",
    "D'être parmi l'écume inconnue et les cieux !  \n",
    "Rien, ni les vieux jardins reflétés par les yeux  \n",
    "Ne retiendra ce coeur qui dans la mer se trempe  \n",
    "Ô nuits ! ni la clarté déserte de ma lampe  \n",
    "Sur le vide papier que la blancheur défend  \n",
    "Et ni la jeune femme allaitant son enfant.  \n",
    "Je partirai ! Steamer balançant ta mâture,  \n",
    "Lève l'ancre pour une exotique nature !  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'idée est remplacer le dernier mot de chaque vers par un mot pioché au hasard dans notre dictionnaire de rimes.\n",
    "On prendra d'abord un mot dans la liste des rimes à 3 phonèmes puis une deuxième version à 2 phonèmes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La chair est triste, hélas ! et j’ai lu tous les savoir-vivre.\n",
      "Fuir ! là-bas fuir! Je sens que des oiseaux sont ivres\n",
      "D’être parmi l’écume inconnue et les vicieux !\n",
      "Rien, ni les vieux jardins reflétés par les yeux\n",
      "Ne retiendra ce coeur qui dans la mer se crampe\n",
      "Ô nuits ! ni la clarté déserte de ma clamp\n",
      "Sur le vide papier que la blancheur défend\n",
      "Et ni la jeune femme allaitant son mi-enfant.\n",
      "Je partirai ! Steamer balançant ta statures,\n",
      "Lève l’ancre pour une exotique cultures !\n",
      "Un Ennui, désolé par les cruels auditoire,\n",
      "Croit encore à l’adieu suprême des ivoire !\n",
      "Et, peut-être, les mâts, invitant les entourages,\n",
      "Sont-ils de ceux qu’un vent penche sur les affacturage\n",
      "Perdus, sans mâts, sans mâts, ni fertiles silo\n",
      "Mais, ô mon coeur, entends le chant des angelots !\n"
     ]
    }
   ],
   "source": [
    "with open('brise-marine.txt', 'r') as f:\n",
    "    for line in f:\n",
    "        line = line.rstrip()\n",
    "        if line == \"\":\n",
    "            continue\n",
    "        words = line.split(\" \")\n",
    "        # traitement ad hoc des fins de ligne\n",
    "        # pour l'exercice ça ira mais c'est moche\n",
    "        if words[-1] == '!':\n",
    "            word = words[-2]\n",
    "        else:\n",
    "            word = words[-1]\n",
    "        if word[-1] == '.' or word[-1] == ',':\n",
    "            word = word[:-1]\n",
    "        rhyme = find_rhyme(word, dico_3, lexique)\n",
    "        if rhyme:\n",
    "            print(line.replace(word, rhyme))\n",
    "        else:\n",
    "            print(line)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}