Lezione 2 - ricostruire la divina commedia con le catene di Markov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ricostruire la divina commedia con le catene di Markov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il nostro scopo è ricostruire la struttura del DNA.\n",
    "\n",
    "Il problema è che non sappiamo cosa stiamo cercando!\n",
    "\n",
    "Come possiamo capire se e quanto i nostri metodi funzionano in modo appropriato, e quali features catturano?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Per fare questo, possiamo usare un dataset di prova, che conosciamo bene, per testare se e quanto il nostro metodo sia affidabile e preciso.\n",
    "\n",
    "Nel nostro caso, useremo la divina commedia come sostituto del DNA.\n",
    "\n",
    "* sappiamo riconoscere al volo suoni simili all'italiano\n",
    "* sappiamo distinguere italiano moderno da quello antico\n",
    "* sappiamo che ha strutture quasi locali (endecasillabo, rima alternata) e così via.\n",
    "\n",
    "Possiamo testare uno o più modelli per capire come e quanto riproduce queste caratteristiche."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Useremo una versione della divina commedia fornita gratuitamente dal [progetto Gutenberg](https://www.gutenberg.org/).\n",
    "\n",
    "Ho rimosso tutto il testo che non è la divina commedia, inclusi i titoli dei vari canti.\n",
    "\n",
    "Questo sarà il nostro testo di riferimento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Vogliamo unire tutto il testo in un unico flusso di caratteri stampabili.\n",
    "\n",
    "Per far questo ci dobbiamo appoggiare alla libreria di python chiamata *itertools* che ci fornisce gli strumenti per manipolare gli iteratori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import itertools as it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "useremo due funzioni principali:\n",
    "    \n",
    "* **itertools.chain.from_iterable** per combinare le linee in un flusso unico\n",
    "* **itertools.islice** per selezionare soltanto una parte del nostro testo invece che tutto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## itertools.chain.from_iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "import itertools as it\n",
    "lista_di_liste = [[1, 2], [3, 4]]\n",
    "for elemento in lista_di_liste:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for lista in lista_di_liste:\n",
    "    for elemento in lista:\n",
    "        print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "L = it.chain.from_iterable(lista_di_liste)\n",
    "for elemento in L:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## itertools.islice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "lista_lunga = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "for elemento in it.islice(lista_lunga, 5):\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Per le liste potrei farlo anche in modo più semplice, ma in generale gli iteratore non mi supportano la sottoselezione in modo semplice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r') as testo:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "﻿Nel mezzo del cammin di nostra vita\n",
      "\n",
      "mi ritrovai per una selva oscura,\n",
      "\n",
      "ché la diritta via era smarrita.\n",
      "\n",
      "\n",
      "\n",
      "Ahi quanto a dir qual era è cosa dura\n",
      "\n",
      "esta selva selvaggia e aspra e forte\n",
      "\n",
      "che nel pensier rinova la paura!\n",
      "\n",
      "\n",
      "\n",
      "Tant’ è amara che poco è più morte;\n",
      "\n",
      "ma per trattar del ben ch’i’ vi trovai,\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf8') as testo:\n",
    "    head = it.islice(testo, 10)\n",
    "    for line in head:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['N', 'e', 'l', ' ', 'm', 'e', 'z', 'z', 'o', ' ', 'd', 'e', 'l', ' ', 'c', 'a', 'm', 'm', 'i', 'n', ' ', 'd', 'i', ' ', 'n', 'o', 's', 't', 'r', 'a', ' ', 'v', 'i', 't', 'a', '\\n', 'm', 'i', ' ', 'r', 'i', 't', 'r', 'o', 'v', 'a', 'i', ' ', 'p', 'e']\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "# devo leggere il file nel suo encoding, in questo caso non standard\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    testo = it.chain.from_iterable(testo)\n",
    "    head = it.islice(testo, 50)\n",
    "    result = list(head)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Per rendere più semplice la nostra analisi, convertiamo tutto in minuscolo, in modo che le maiuscole non vengano viste come lettere differenti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['n', 'e', 'l', ' ', 'm', 'e', 'z', 'z', 'o', ' ', 'd', 'e', 'l', ' ', 'c', 'a', 'm', 'm', 'i', 'n', ' ', 'd', 'i', ' ', 'n', 'o', 's', 't', 'r', 'a', ' ', 'v', 'i', 't', 'a', '\\n', 'm', 'i', ' ', 'r', 'i', 't', 'r', 'o', 'v', 'a', 'i', ' ', 'p', 'e']\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    head = it.islice(testo, 50)\n",
    "    result = list(head)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ora iniziamo con il nostro modello più semplice: generiamo il testo semplicemente ripetendo le lettere in base a quanto sono frequenti.\n",
    "\n",
    "Questo ci richiede per prima cosa di valutare la frequenza di queste lettere!\n",
    "\n",
    "Per far questo, abbiamo uno strumento giù predisposo, la classe **Counter**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 2)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "lettere = \"aaaabb\"\n",
    "conteggi = Counter(lettere)\n",
    "conteggi.most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({' ': 83019, 'e': 46680, 'a': 42412, 'i': 39559, 'o': 37610, 'n': 26487, 'r': 25922, 'l': 23498, 't': 22761, 's': 22631, 'c': 20821, '\\n': 19053, 'd': 15006, 'u': 13451, 'm': 12086, 'p': 11263, ',': 8513, 'v': 8168, '’': 7623, 'g': 7320, 'h': 7111, 'f': 5127, 'q': 3353, '.': 3275, 'b': 2981, 'z': 1855, ';': 1628, 'ì': 1383, 'ù': 1080, '«': 1062, '»': 1062, ':': 988, 'ò': 938, 'è': 927, 'é': 903, 'à': 855, 'ï': 428, '?': 278, '!': 232, '‘': 109, 'ë': 85, 'ü': 55, '“': 51, '”': 51, 'ó': 30, '—': 18, 'ä': 8, 'x': 3, '(': 3, ')': 3, 'j': 2, 'ö': 1, 'y': 1, '-': 1})\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    head = it.islice(testo, None)\n",
    "    conteggi = Counter(head)\n",
    "    print(conteggi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(' ', 83019),\n",
      " ('e', 46680),\n",
      " ('a', 42412),\n",
      " ('i', 39559),\n",
      " ('o', 37610),\n",
      " ('n', 26487),\n",
      " ('r', 25922),\n",
      " ('l', 23498),\n",
      " ('t', 22761),\n",
      " ('s', 22631),\n",
      " ('c', 20821),\n",
      " ('\\n', 19053),\n",
      " ('d', 15006),\n",
      " ('u', 13451),\n",
      " ('m', 12086),\n",
      " ('p', 11263),\n",
      " (',', 8513),\n",
      " ('v', 8168),\n",
      " ('’', 7623),\n",
      " ('g', 7320)]\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "pprint(conteggi.most_common(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ora vogliamo estrarre le lettere a caso in modo proporzionale a quanto le abbiamo visto di frequente.\n",
    "\n",
    "Per far questo, possiamo usare la funzione **choices** della libreria **random**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 'a', 'a', 'a', 'a', 'b', 'a', 'a', 'a', 'a']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import choices\n",
    "\n",
    "lettere = ['a', 'b']\n",
    "frequenze = [9, 1]\n",
    "\n",
    "choices(lettere, weights=frequenze, k=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'a', 'a', 'a', 'a', 'a', 'a', 'b', 'a', 'a']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# per chi avesse python 3.5 o più vecchio\n",
    "from numpy.random import choice\n",
    "from numpy import array\n",
    "def choices(lista, weights, k=1):\n",
    "    weights = array(weights)/sum(weights)\n",
    "    res = choice(lista, k, p=weights)\n",
    "    return list(res)\n",
    "\n",
    "lettere = ['a', 'b']\n",
    "frequenze = [9, 1]\n",
    "\n",
    "choices(lettere, weights=frequenze, k=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "se volessimo usarlo per generare il testo, possiamo unire tutte queste lettere con un join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaabaaaaaa\n"
     ]
    }
   ],
   "source": [
    "random = choices(lettere, weights=frequenze, k=10)\n",
    "testo = str.join('', random)\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Possiamo usare **choices** in combinazione con **Counter** in modo semplice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['a', 'b']) dict_values([4, 2])\n"
     ]
    }
   ],
   "source": [
    "lettere = \"aaaabb\"\n",
    "conteggi = Counter(lettere)\n",
    "print(conteggi.keys(), conteggi.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ccooc oomincmoooooa o aocnmcnomao adi  inanco ooiaomodaooadaoiaoo cdioon iioc ooomo a oo o coomoaooocoo ocdaooidomoimiammaman aooaimnamonnoo oiimaomdnomooo daa idmco a mdi onma do aonoi ooooidoomad no\n"
     ]
    }
   ],
   "source": [
    "lettere = \"ciao mondo\"\n",
    "conteggi = Counter(lettere)\n",
    "lettere = list(conteggi.keys())\n",
    "frequenze = list(conteggi.values())\n",
    "random = choices(lettere, weights=frequenze, k=200)\n",
    "testo = str.join('', random)\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tav  ualidéua rr \n",
      "ért tua n nr  trnetoact mvlnuaciitiiaronetivevoumvd\n",
      "mm ci s aasami ai aadacs  mns \n",
      "limon  r ris ce r ahre a artlaiizt tam \n",
      "o reerrluei\n",
      "v mcz\n",
      "écret erv\n",
      "acoorho ioa l railiael\n",
      "eseauaaé\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    head = it.islice(testo, 100)\n",
    "    conteggi = Counter(head)\n",
    "    \n",
    "lettere = list(conteggi.keys())\n",
    "frequenze = list(conteggi.values())\n",
    "random = choices(lettere, weights=frequenze, k=200)\n",
    "testo = str.join('', random)\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"markov_0_lettere.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join('', choices(lettere, weights=frequenze, k=10000))\n",
    "    print(testo, file=outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il risultato è chiaramente deludente.\n",
    "\n",
    "Non solo non assomiglia ad una frase italiana...non sembrano neppure parole!\n",
    "\n",
    "Cosa sta succedendo?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "Sappiamo che nell'italiano le parole non sono composte semplicemente dai suoni, ma da come i suoni i susseguono l'un l'altro.\n",
    "\n",
    "Per rappresentare questa conoscenza, possiamo utilizzare un metodo della fisica matematica chiamato Catene di Markov."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Le catene di Markov\n",
    "\n",
    "L'idea è semplice: invece di generare ogni lettere sulla base della sua frequenza nel testo, facciamo un passaggio leggermente più intelligente.\n",
    "\n",
    "* Guardo l'ultima lettera del testo che ho generato finora.\n",
    "* Considero nel testo originale quanto spesso ciascuna lettera segue la lettera che ho scelto.\n",
    "* Genero la mia nuova lettera sulla base di questa **probabilità condizionata**.\n",
    "* Ricomincio usando l'ultima lettera generata come punto di partenza."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo metodo è lo stesso (di base) usato dai cellulari per il suggerimento delle parole.\n",
    "\n",
    "Se scrivete spesso \"buona notte\", \"buona mattina\" e \"buona cena\", una volta che inserite la parola \"buona\" da tastiera, il software sa che probabilmente dopo andrete ad inserire \"notte\", \"mattina\" o \"cena\".\n",
    "\n",
    "Se non ha a disposizione un buon campione personalizzato, utilizza quelli delle persone della stessa lingua.\n",
    "\n",
    "Questo ha creato non poco imbarazzo nel caso di frasi volgari o razziste, inserite dall'algoritmo come proposte per via del loro uso frequente (vedi il caso recente dell'IPhone che suggeriva la frase \"Vesuvio lavali col fuoco\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Per ciascuna lettera dell'alfabeto dovremo quindi avere un **Counter** che mi tenga conto di quali lettere potranno seguire.\n",
    "\n",
    "Per poter fare questo devo unire le lettere del mio testo in coppie consecutive di lettere!\n",
    "\n",
    "Per fare questo uso una libreria esterna, **toolz**, che mi fornisce la funzione **sliding_window** che fa proprio questo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e'), ('e', 'f'), ('f', 'g')]\n"
     ]
    }
   ],
   "source": [
    "from toolz import sliding_window\n",
    "\n",
    "lettere = \"abcdefg\"\n",
    "\n",
    "coppie = sliding_window(2, lettere)\n",
    "\n",
    "print(list(coppie))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e')]\n"
     ]
    }
   ],
   "source": [
    "# per chi non potesse importare toolz\n",
    "from collections import deque\n",
    "def sliding_window(n, seq):\n",
    "    mazzo = deque(maxlen=n)\n",
    "    for value in seq:\n",
    "        mazzo.append(value)\n",
    "        if len(mazzo)==n:\n",
    "            yield tuple(mazzo)\n",
    "\n",
    "coppie = sliding_window(2, \"abcde\")\n",
    "\n",
    "print(list(coppie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## WARNING\n",
    "\n",
    "Useremo degli algoritmi assolutamente non ottimali!\n",
    "\n",
    "In questo caso ci servono solo per capire il procedimento, nella vita reale sono troppo lenti per funzionare davvero!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('n', 'e'),\n",
      " ('e', 'l'),\n",
      " ('l', ' '),\n",
      " (' ', 'm'),\n",
      " ('m', 'e'),\n",
      " ('e', 'z'),\n",
      " ('z', 'z'),\n",
      " ('z', 'o'),\n",
      " ('o', ' '),\n",
      " (' ', 'd'),\n",
      " ('d', 'e'),\n",
      " ('e', 'l'),\n",
      " ('l', ' '),\n",
      " (' ', 'c'),\n",
      " ('c', 'a'),\n",
      " ('a', 'm'),\n",
      " ('m', 'm'),\n",
      " ('m', 'i'),\n",
      " ('i', 'n'),\n",
      " ('n', ' '),\n",
      " (' ', 'd'),\n",
      " ('d', 'i'),\n",
      " ('i', ' '),\n",
      " (' ', 'n'),\n",
      " ('n', 'o'),\n",
      " ('o', 's'),\n",
      " ('s', 't'),\n",
      " ('t', 'r'),\n",
      " ('r', 'a')]\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    head = it.islice(testo, 30)\n",
    "    coppie = sliding_window(2, head)\n",
    "    pprint(list(coppie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "quali sono le coppie più comuni?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(('e', ' '), 17397),\n",
      " (('a', ' '), 13949),\n",
      " (('i', ' '), 11636),\n",
      " (('o', ' '), 10906),\n",
      " ((' ', 'c'), 9579),\n",
      " ((' ', 's'), 8676),\n",
      " ((' ', 'l'), 7659),\n",
      " ((' ', 'd'), 6975),\n",
      " (('e', 'r'), 6524),\n",
      " (('c', 'h'), 6523)]\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    #head = it.islice(testo, 300)\n",
    "    coppie = sliding_window(2, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "    pprint(conteggi.most_common(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    coppie = sliding_window(1, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "    total = sum(conteggi.values())\n",
    "    with open(\"statistica_singoli_caratteri.tsv\", 'w', encoding='utf8') as outfile:\n",
    "        for [element], count in conteggi.most_common():\n",
    "            print(repr(element), count, count/total, file=outfile, sep='\\t')\n",
    "\n",
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    coppie = sliding_window(2, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "    total = sum(conteggi.values())\n",
    "    with open(\"statistica_coppie_caratteri.tsv\", 'w', encoding='utf8') as outfile:\n",
    "        for (element1, element2), count in conteggi.most_common():\n",
    "            print(repr(element1), repr(element2), count, count/total, file=outfile, sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "quante combinazioni posso avere?\n",
    "\n",
    "per semplificare, consideriamo solo le lettere, gli spazi e le lettere accentate. \n",
    "\n",
    "Otteniamo circa 30 caratteri.\n",
    "\n",
    "tutte le coppie sono date da $30^2 = 900$\n",
    "\n",
    "Se tutte queste coppie fossero equiprobabili e ne volessimo avere almeno 10 campionamenti per coppia, dovremmo avere circa 10'000 lettere.\n",
    "\n",
    "Quando useremo le triplette, avremo $30^3 = 27'000$ combinazioni, quindi avremo bisogno di circa 300'000 lettere per avere una buona copertura.\n",
    "\n",
    "quante lettere abbiamo in totale nella nostra divina commedia?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "529770\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    conteggio = sum(1 for c in testo)\n",
    "print(conteggio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Questo ci dice che non potremo davvero andare oltre le triplette, almeno senza renderci le cose difficili."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "855\n",
      "[(('e', ' '), 17397),\n",
      " (('a', ' '), 13949),\n",
      " (('i', ' '), 11636),\n",
      " (('o', ' '), 10906),\n",
      " ((' ', 'c'), 9579),\n",
      " ((' ', 's'), 8676),\n",
      " ((' ', 'l'), 7659),\n",
      " ((' ', 'd'), 6975),\n",
      " (('e', 'r'), 6524),\n",
      " (('c', 'h'), 6523)]\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    coppie = sliding_window(2, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "print(len(conteggi))\n",
    "pprint(conteggi.most_common(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "possiamo vedere come in realtà, anche con le sole coppie, non riusciamo a coprire tutti i casi possibili!\n",
    "\n",
    "Però iniziamo già a vedere una prima feature della lingua italiana: le parole finiscono spesso con delle vocali.\n",
    "\n",
    "Vediamo ora come possiamo sfruttare questo dizionario di conteggi per generare il nostro testo.\n",
    "\n",
    "Dobbiamo partire da un seme, un elemento di testo iniziale.\n",
    "Nel nostro caso, per cercare di rimanere il più generici possibile, useremo uno spazio vuoto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "per poter generare la nuova lettera a partire dalla vecchia, dovremo selezionare soltanto quella parte del nostro dizionario che contiene la nostra lettera come parte iniziale.\n",
    "\n",
    "Possiamo usare la funzione **item** dei dizionari per avere la sequenza delle coppie chiave valore, e filtrarle in base al loro punto di inizio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('a', 1), ('b', 2), ('c', 3)])\n"
     ]
    }
   ],
   "source": [
    "dizionario = {'a':1, 'b':2, 'c':3}\n",
    "print(dizionario.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c'] [2, 3]\n"
     ]
    }
   ],
   "source": [
    "chiavi = [c for c, v in dizionario.items() if c in ['b', 'c']]\n",
    "valori = [v for c, v in dizionario.items() if c in ['b', 'c']]\n",
    "print(chiavi, valori)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'b'), ('a', 'p')]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "lettera = 'a'\n",
    "chiavi = [c for c, v in conteggi_fake.items() if c[0]==lettera]\n",
    "chiavi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inizia_con(sequence, letter):\n",
    "    return sequence[0]==letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'b'), ('a', 'p')]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "lettera = 'a'\n",
    "chiavi = [c for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "chiavi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['b', 'p'], [1, 3])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "lettera = 'a'\n",
    "chiavi = [c[-1] for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "valori = [v for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "chiavi, valori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['X', 'I', 'I', 'I', 'X', 'X', 'X', 'X', 'X', 'X']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'I'):1, ('b', 'c'): 2, ('a', 'X'): 3}\n",
    "lettera = 'a'\n",
    "chiavi = [c[-1] for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "valori = [v for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "choices(chiavi, valori, k=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ora possiamo fare lo stesso con il nostro vettore dei conteggi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e  \n",
      "e  \n",
      "e n\n",
      "e r\n",
      "e r\n",
      "e ;\n",
      "e n\n",
      "e r\n",
      "e l\n",
      "e b\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['e']\n",
    "for i in range(10):\n",
    "    lettera = nuovo_testo[-1]\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    print(lettera, prossima_lettera)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "ci siamo dimenticati di attaccare l'ultima lettera generata al nostro testo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  e\n",
      "e  \n",
      "  g\n",
      "g u\n",
      "u o\n",
      "o n\n",
      "n a\n",
      "a  \n",
      "  l\n",
      "l  \n",
      "[' ', 'e', ' ', 'g', 'u', 'o', 'n', 'a', ' ', 'l', ' ']\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = [' ']\n",
    "for i in range(10):\n",
    "    lettera = nuovo_testo[-1]\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    print(lettera, prossima_lettera)\n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "print(nuovo_testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " e guona l \n"
     ]
    }
   ],
   "source": [
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "proviamo ora un testo più lungo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fi rr se fogin dessonun queso, gndedosiù, sé stuacher de cavidaen maieme ’.\n",
      "\n",
      "n vo siur,\n",
      "\n",
      "\n",
      "\n",
      "ce è se ertrsì vedo\n",
      "ino: fo soron mma, pinoma in mompe vi ssisueltera dontecuero a;\n",
      "stossa, sti da,\n",
      "cotidivia\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = [' ']\n",
    "for i in range(200):\n",
    "    lettera = nuovo_testo[-1]\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "il risultato lascia ancora a desiderare...\n",
    "\n",
    "proviamo ad estendere alle triplette: in questo caso consideriamo le coppie di lettere come punto di partenza e la nuova lettera sulla base di queste.\n",
    "\n",
    "Dobbiamo però ricostruire il nostro intero dataset dei conteggi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6059\n",
      "[((' ', 'c', 'h'), 4036),\n",
      " (('c', 'h', 'e'), 3871),\n",
      " (('h', 'e', ' '), 3630),\n",
      " ((' ', 'd', 'i'), 3338),\n",
      " (('.', '\\n', '\\n'), 3171)]\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    coppie = sliding_window(3, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "print(len(conteggi))\n",
    "pprint(conteggi.most_common(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "il procedimento per generare il testo è assolutamente identico, ma il controllo sarà sulle ultime due lettere e non soltanto sull'ultima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('c', 'h') 'i'\n",
      "('h', 'i') ' '\n",
      "('i', ' ') 'a'\n",
      "(' ', 'a') ' '\n",
      "('a', ' ') 'g'\n",
      "(' ', 'g') 'u'\n",
      "('g', 'u') 'a'\n",
      "('u', 'a') 'i'\n",
      "('a', 'i') ' '\n",
      "('i', ' ') 't'\n",
      "chi a guai t\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['c', 'h']\n",
    "for i in range(10):\n",
    "    lettera = tuple(nuovo_testo[-2:])\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if c[:2]==lettera]\n",
    "    frequenze = [v for c, v in conteggi.items() if c[:2]==lettera]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    print(lettera, repr(prossima_lettera))\n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inizia_con(sequence, letter):\n",
    "    return sequence[:len(letter)]==letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('c', 'h') 'i'\n",
      "('h', 'i') 'u'\n",
      "('i', 'u') 'd'\n",
      "('u', 'd') 'i'\n",
      "('d', 'i') 'c'\n",
      "('i', 'c') 'e'\n",
      "('c', 'e') 'r'\n",
      "('e', 'r') ' '\n",
      "('r', ' ') 'l'\n",
      "(' ', 'l') 'a'\n",
      "chiudicer la\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['c', 'h']\n",
    "for i in range(10):\n",
    "    lettera = tuple(nuovo_testo[-2:])\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    print(lettera, repr(prossima_lettera))\n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Possiamo facilmente estendere questo procedimento ad ancora più lettere.\n",
    "\n",
    "Vedremo che con l'aumentare della lunghezza della sequenza avrò parole sempre più simili all'italiano, ma il numero di casi disponibili calerà sensibilmente!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nel mosse: «che,\n",
      "che l’ora.\n",
      "\n",
      "ma tutti\n",
      "li a bollo!».\n",
      "\n",
      "e ’l vuo’ caccompiovannotto\n",
      "è farfare vedea teso alla con differinciò: «comme come prodo colli a grinare a ne colà giustizia di che sarvi?\n",
      "\n",
      "se naturir\n"
     ]
    }
   ],
   "source": [
    "L = 3\n",
    "file = './divinacommedia_cleaned.txt'\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    coppie = sliding_window(L+1, testo)\n",
    "    conteggi = Counter(coppie)\n",
    "    \n",
    "nuovo_testo = ['n', 'e', 'l']\n",
    "for i in range(200):\n",
    "    lettera = tuple(nuovo_testo[-L:])\n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "posso generalizzare questo procedimento con una funzione per generare dei testi lunghi a piacere, usando una funzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def genera_testo(nuovo_testo='nel', lunghezza=2):\n",
    "    L = lunghezza\n",
    "    nuovo_testo = list(nuovo_testo)\n",
    "    file = './divinacommedia_cleaned.txt'\n",
    "    with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "        linee = (linea.lower() for linea in testo)\n",
    "        testo = it.chain.from_iterable(linee)\n",
    "        coppie = sliding_window(L+1, testo)\n",
    "        conteggi = Counter(coppie)\n",
    "\n",
    "    while True:\n",
    "        lettera = tuple(nuovo_testo[-L:])\n",
    "        lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "        frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "        prossima_lettera = choices(lettere, frequenze)[0]\n",
    "        nuovo_testo.append(prossima_lettera)\n",
    "        nuovo_testo = nuovo_testo[1:]\n",
    "        yield prossima_lettera\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lorme abbenti, di favei forte l’oce sti,\n",
      "d’unti ce, e ditto ta; e inne posustor cionviegli sì puresto ved un di; e ne so\n",
      "e tu dia nessandendo ra parda seggerede tutto,\n",
      "sì vil prodasce anta;\n",
      "ma le e fa\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('nel', 2), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " e ’l no qua me sper gio gio chiempocche e suognor cato di parò co.\n",
      "\n",
      "ovo, ‘di sareando udi che che vida tredire la e destor anco che si lode gio\n",
      "rititto spove\n",
      "graziasper e là non li miaro;\n",
      "e il que fa\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('che', 2), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " caccorda,\n",
      "vuo’ era\n",
      "pose di che notermo di ch’altre cui colui nulla,\n",
      "«a tutti sì si da strava questolse chiatteracco vedistre beati l’odor vidi marolessi, avero da in tre abbi in dissi che dima vicion\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('nel', 3), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ciglia,\n",
      "ci ad ogne la la giù, non stipa;\n",
      "«e or veroìs, trifon mi volli è di piè cupido segue e di morta parrebber li pieta.\n",
      "\n",
      "e stesso guado.\n",
      "\n",
      "l’odïernol, ch’altro frutto pome.\n",
      "\n",
      "così divizia donai.\n",
      "\n",
      "lo\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('nel ', 4), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "di santa zita!\n",
      "mette».\n",
      "\n",
      "ed elli scese,\n",
      "contenne.\n",
      "\n",
      "ma del viso ch’io era conforma un che ti smarrito riso;\n",
      "ma più tenem per cui dischiude,\n",
      "non pur l’ombra, li staman, quale ha posso\n",
      "com’ esser monferr\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('onore', 5), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"markov_2_lettere.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\"\", it.islice(genera_testo('onore', 2), 10000))\n",
    "    print(testo, file=outfile)\n",
    "    \n",
    "with open(\"markov_3_lettere.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\"\", it.islice(genera_testo('onore', 3), 10000))\n",
    "    print(testo, file=outfile)\n",
    "    \n",
    "with open(\"markov_4_lettere.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\"\", it.islice(genera_testo('onore', 4), 10000))\n",
    "    print(testo, file=outfile)\n",
    "    \n",
    "with open(\"markov_5_lettere.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\"\", it.islice(genera_testo('onore', 5), 10000))\n",
    "    print(testo, file=outfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Possiamo vedere come il testo generato assomigli all'italiano in modo superficiale, ma le frasi non hanno senso.\n",
    "\n",
    "Potremmo usare la nostra conoscenza dell'esistenza delle parole per generare delle frasi più sensate, ma saremmo sempre ciechi alle strutture di ordine superiore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## extra: Generazione Markoviana delle parole\n",
    "\n",
    "uso lo stesso algoritmo di prima, ma divido il testo in parole invece che in singole lettere.\n",
    "\n",
    "Per la generazione devo evitare di ricalcolare ogni volta tutti i conteggi, ma li salvo di volta in volta in modo che se trovo due parole uguali ricarico il valore vecchio.\n",
    "Questo non è ancora perfetto, ma almeno mi salvo molti calcoli inutili!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({('nel', 'mezzo'): 1, ('mezzo', 'del'): 1, ('del', 'cammin'): 1, ('cammin', 'di'): 1, ('di', 'nostra'): 1, ('nostra', 'vita'): 1, ('vita', 'mi'): 1, ('mi', 'ritrovai'): 1, ('ritrovai', 'per'): 1, ('per', 'una'): 1, ('una', 'selva'): 1, ('selva', 'oscura,'): 1, ('oscura,', 'ché'): 1, ('ché', 'la'): 1, ('la', 'diritta'): 1, ('diritta', 'via'): 1, ('via', 'era'): 1, ('era', 'smarrita.'): 1, ('smarrita.', 'ahi'): 1, ('ahi', 'quanto'): 1})\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "L = 2\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    caratteri = it.chain.from_iterable(linee)\n",
    "    gruppi = it.groupby(caratteri, lambda s: s in string.whitespace)\n",
    "    parole = (gruppo for (is_whitespace, gruppo) in gruppi if not is_whitespace)\n",
    "    testo = (str.join('', parola) for parola in parole)\n",
    "    coppie = sliding_window(L, testo)\n",
    "    head = it.islice(coppie, 20)\n",
    "    conteggi = Counter(head)\n",
    "print(conteggi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def genera_testo_parole(nuovo_testo=['nel'], lunghezza=2):\n",
    "    L = lunghezza\n",
    "    nuovo_testo = list(nuovo_testo)\n",
    "    file = './divinacommedia_cleaned.txt'\n",
    "    with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "        linee = (linea.lower() for linea in testo)\n",
    "        caratteri = it.chain.from_iterable(linee)\n",
    "        gruppi = it.groupby(caratteri, lambda s: s in string.whitespace)\n",
    "        parole = (gruppo for (is_whitespace, gruppo) in gruppi if not is_whitespace)\n",
    "        testo = (str.join('', parola) for parola in parole)\n",
    "        coppie = sliding_window(L+1, testo)\n",
    "        conteggi = Counter(coppie)\n",
    "\n",
    "    coppie_memoize = dict()\n",
    "    while True:\n",
    "        lettera = tuple(nuovo_testo[-L:])\n",
    "        try:\n",
    "            coppie = coppie_memoize[lettera]\n",
    "        except KeyError:\n",
    "            coppie = [(c[-1], v) for c, v in conteggi.items() if c[:L]==lettera]\n",
    "            coppie_memoize[lettera] = coppie\n",
    "        \n",
    "        lettere = [c for c, v in coppie]\n",
    "        frequenze = [v for c, v in coppie]\n",
    "        prossima_lettera = choices(lettere, frequenze)[0]\n",
    "        nuovo_testo.append(prossima_lettera)\n",
    "        nuovo_testo = nuovo_testo[1:]\n",
    "        yield prossima_lettera\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s’avvivava, e d’ogne parte i pesi. e se’ or sotto l’emisperio giunto ch’è contraposto a quel ch’i’ dico, gloria di latin», disse, «per cui mostrò ciò che cela ’l vapor che ’l guasco l’alto arrigo inganni, parran faville de la pietra non diversi. e poi fui famiglia del buon gherardo e guido di carpigna? oh romagnuoli tornati in bastardi! quando in faenza un bernardin di fosco, verga gentil di picciola gente; sì che tu per certo verria meno per lo natural costume, le pole insieme, al cominciar ne lagrimai. diverse lingue, orribili favelle, parole di gran voce, sì ch’ogne musa ne sarebbe schiva. qual è quei che diceva pria, «tu parli d’arno». e l’altro foro aiutò sì che ’n sì distesa lingua lo dicer mio, ch’al tuo sentir si sterna, ove dinanzi dissi: “u’ ben s’impingua, se non fosse umilïato ad incarnarsi. or per empierti bene ogne disio, ritorno a compiér lo cammin corto parte lo secondo giron dal terzo, e dove sile e cagnan s’accompagna, tal signoreggia e va con la lancia e coi remi, quantunque può, ciascun pinger sua barca»; dritto sì come il fiammeggiar ti manifesta. ma l’alta carità, che fa la ragna. piangerà feltro ancora la\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\" \", it.islice(genera_testo_parole(['nel', 'mezzo'], 2), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cammin di nostra vita dipartille. poscia ch’io ebbi rotta la persona di due punte mortali, io mi rendei, piangendo, a quei che volontier perdona. orribil furon li peccati miei; ma la bontà infinita ha sì gran braccia, che prende ciò che si vuole, e avea galigaio dorata in casa sua già l’elsa e ’l pome. grand’ era già la colonna del vaio, sacchetti, giuochi, fifanti e barucci e galli e quei ch’arrossan per lo staio. lo ceppo di che nacquero i calfucci era già grande, e già eran tratti a le curule sizii e arrigucci. oh quali io vidi quei che son disfatti per lor superbia! e le palle de l’oro fiorian fiorenza in tutt’ i suoi gran fatti. così facieno i padri di coloro che, sempre che la vostra miseria non mi tange, né fiamma d’esto ’ncendio non m’assale. donna è gentil nel ciel che più si spieghi di nostra condizion com’ ell’ è ora; e se rimane, dite come, poi che sarete visibili rifatti, esser porà ch’al veder non vi nòi». «donna del ciel, di queste cose accorta», rispuose ’l mio maestro sorrise di tanto; e più d’onore ancora assai mi fenno, ch’e’ sì mi fecer de la\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\" \", it.islice(genera_testo_parole(['nel', 'mezzo', 'del'], 3), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se vado a guardare il risultato, risulta essere pezzi di frasi uniche mescolati insieme in base ai pezzi in comune (le congiunzioni).\n",
    "Questo capita perchè le possibili combinazioni di parole sono così tante che anche con tutta la divina commedia, sto sottocampionando le varie possibilità.\n",
    "\n",
    "In particolare, con sequenze di tre parole, sto ripescando le frasi orginali per intero perchè data una tripletta di parole sono praticamente uniche."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"markov_2_parole.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\" \", it.islice(genera_testo_parole([\"certo\", \"verria\", \"meno\"], 2), 1000))\n",
    "    print(testo, file=outfile)\n",
    "    \n",
    "with open(\"markov_3_parole.txt\", 'w', encoding='utf8') as outfile:\n",
    "    testo = str.join(\" \", it.islice(genera_testo_parole([\"certo\", \"verria\", \"meno\"], 3), 1000))\n",
    "    print(testo, file=outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}