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": "fragment"
    }
   },
   "source": [
    "Avete visto due possibili modelli per la distribuzione dei nucleotidi nel DNA:\n",
    "\n",
    "1) Modello nullo di \"lancio del dato\" in cui la distribuzione di A, C, G, T è casuale con frequenze identiche a quelle che si trovano nel DNA umano (dado a 4 facce con p differenti)\n",
    "\n",
    "2) Modello markoviano con probabilità condizionata di trovare un nucleotide dopo un altro come nel DNA umano (p(A|C), p(A|T), …, p(T|T))\n",
    "\n",
    "<img src=\"https://github.com/UniboDIFABiophysics/PLSBigDataNetworks/raw/master/img/dna_markov_chain.png\" width=\"550\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Il nostro scopo è ricostruire la struttura del DNA: non solo riconoscere il nucelotide successivo ma per esempio identificare delle sequenze con specifiche funzioni biologiche (motifs).\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",
    "Abbiamo rimosso tutto il testo che non è la divina commedia, inclusi i titoli dei vari canti.\n",
    "\n",
    "Questo sarà il nostro testo di riferimento\n",
    "\n",
    "Potete trovare il file sul nostro GitHub:\n",
    "\n",
    "# https://github.com/UniboDIFABiophysics/PLSBigDataNetworks"
   ]
  },
  {
   "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",
    "\n",
    "lista_di_liste = [[1, 2], [3, 4]]\n",
    "\n",
    "for elemento in lista_di_liste:\n",
    "    \n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for lista in lista_di_liste:\n",
    "    \n",
    "    for elemento in lista:\n",
    "        \n",
    "        print(elemento)"
   ]
  },
  {
   "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"
     ]
    }
   ],
   "source": [
    "L = it.chain.from_iterable(lista_di_liste)\n",
    "\n",
    "for elemento in L:\n",
    "    \n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "def\n"
     ]
    }
   ],
   "source": [
    "lista_di_liste = [\"abc\",\"def\"]\n",
    "\n",
    "for elemento in lista_di_liste:\n",
    "            \n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n"
     ]
    }
   ],
   "source": [
    "lista_di_liste = [\"abc\",\"def\"]\n",
    "\n",
    "for lista in lista_di_liste:\n",
    "    \n",
    "    for elemento in lista:\n",
    "        \n",
    "        print(elemento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n"
     ]
    }
   ],
   "source": [
    "L = it.chain.from_iterable(lista_di_liste)\n",
    "\n",
    "for elemento in L:\n",
    "    \n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## itertools.islice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
    "    \n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nel caso di una lista avrei potuto usare semplicemente:\n",
    "\n",
    "    for elemento in lista_lunga[:5]:\n",
    "        print(elemento)\n",
    "\n",
    "`it.islice` però è una funzione più generale che permette di eseguire una sottoselezione a partire da qualsiasi iteratore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Leggiamo la divina commedia:\n",
    "\n",
    "file = './divinacommedia_cleaned.txt'\n",
    "\n",
    "with open(file, 'r') as testo:\n",
    "\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
    "\n",
    "with open(file, 'r') as testo:\n",
    "\n",
    "    head = it.islice(testo, 10)\n",
    "    \n",
    "    for line in head:\n",
    "    \n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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",
    "\n",
    "# devo leggere il file nel suo encoding, in questo caso non standard\n",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "\n",
    "    testo = it.chain.from_iterable(testo)\n",
    "    \n",
    "    head = it.islice(testo, 50)\n",
    "    \n",
    "    result = list(head)\n",
    "    \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": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "\n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    head = it.islice(testo, 50)\n",
    "    \n",
    "    result = list(head)\n",
    "    \n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Iniziamo con il modello più semplice, quello del \"lancio del dado\". \n",
    "\n",
    "$\\rightarrow$ **Generiamo il testo semplicemente ripetendo le lettere in base a quanto sono frequenti**\n",
    "\n",
    "Questo 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": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 4), ('b', 2)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "lettere = [\"a\",\"a\",\"a\",\"a\",\"b\",\"b\"]\n",
    "\n",
    "conteggi = Counter(lettere)\n",
    "\n",
    "conteggi.most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "\n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    head = it.islice(testo, None)\n",
    "    \n",
    "    conteggi = Counter(head)\n",
    "    \n",
    "    print(conteggi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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",
    "\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 viste di frequente.\n",
    "\n",
    "Per far questo, possiamo usare la funzione **choices** della libreria **random**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import choices\n",
    "\n",
    "lettere = ['a', 'b']\n",
    "\n",
    "frequenze = [9, 1]\n",
    "\n",
    "choices(lettere, weights=frequenze, k=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'a', 'a', 'a', 'a', 'b', 'a', 'a', 'b', 'a']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# per chi avesse python 3.5 o più vecchio\n",
    "\n",
    "from numpy.random import choice\n",
    "from numpy import array\n",
    "\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": [
    "Possiamo poi unire tutte le lettere generate usando `join` per ottenere effettivamente un testo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']\n",
      "aaaaaaaaaa\n"
     ]
    }
   ],
   "source": [
    "random = choices(lettere, weights=frequenze, k=10)\n",
    "\n",
    "print(random)\n",
    "\n",
    "testo = str.join('', random)\n",
    "\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": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'a': 4, 'b': 2})\n",
      "dict_keys(['a', 'b']) dict_values([4, 2])\n"
     ]
    }
   ],
   "source": [
    "lettere = \"aaaabb\"\n",
    "\n",
    "conteggi = Counter(lettere)\n",
    "\n",
    "print(conteggi)\n",
    "\n",
    "print(conteggi.keys(), conteggi.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'i', 'a', 'o', ' ', 'm', 'n', 'd']\n",
      "[1, 1, 1, 3, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "lettere = \"ciao mondo\"\n",
    "\n",
    "conteggi = Counter(lettere)\n",
    "\n",
    "lettere = list(conteggi.keys())\n",
    "\n",
    "frequenze = list(conteggi.values())\n",
    "\n",
    "print(lettere)\n",
    "print(frequenze)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'd', 'c', 'o', 'o', 'c', 'm', 'm', 'o', 'a', 'd', 'o', 'c', 'o', 'n', 'n', 'i', 'n', 'a', 'o', 'o', 'o', 'd', 'i', 'a', 'o', 'o', 'o', 'o', 'o', ' ', 'o', 'o', 'i', 'o', 'c', 'o', 'c', 'm', 'm', 'o', 'o', 'n', ' ', ' ', 'm', 'o', 'o', ' ', 'o', ' ', 'o', 'i', 'a', 'm', 'a', 'c', ' ', 'm', 'o', 'a', 'o', 'i', 'o', 'd', 'm', 'o', ' ', 'o', 'o', 'd', 'c', 'o', 'a', ' ', 'd', 'n', 'o', 'o', 'n', 'o', 'o', 'm', ' ', 'o', 'i', ' ', 'o', 'o', 'n', 'o', 'm', 'c', 'd', 'm', 'm', 'i', 'm', ' ', 'n', 'i', 'd', 'i', 'o', 'o', 'a', 'c', 'n', 'i', 'i', 'a', 'o', 'n', 'd', 'o', 'n', 'd', 'i', 'i', 'a', 'c', 'o', 'm', ' ', ' ', 'a', 'o', 'i', ' ', 'i', 'c', 'm', 'o', 'n', 'o', 'o', 'n', 'a', ' ', 'n', 'c', 'a', 'o', 'o', 'i', 'o', 'o', 'd', 'n', 'd', 'd', 'c', 'o', 'c', 'd', 'o', 'c', 'm', 'd', 'c', 'c', 'i', 'c', 'a', 'c', 'o', 'c', 'a', 'o', ' ', 'd', 'n', 'd', 'd', 'o', 'd', ' ', ' ', 'd', 'o', 'o', 'o', 'o', 'c', 'c', 'd', 'n', 'c', 'i', 'o', 'd', 'a', 'o', ' ', 'd', 'i', 'm', 'o', 'a', 'm']\n"
     ]
    }
   ],
   "source": [
    "random = choices(lettere, weights=frequenze, k=200)\n",
    "print(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "idcoocmmoadoconninaooodiaooooo ooiococmmoon  moo o oiamac moaoiodmo oodcoa dnoonoom oi oonomcdmmim nidiooacniiaondondiiacom  aoi icmonoona ncaooioodnddcocdocmdccicacocao dnddod  dooooccdnciodao dimoam\n"
     ]
    }
   ],
   "source": [
    "testo = str.join('', random)\n",
    "\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "noom coonoacdndmcaoooodccaoioc macndmdommoadmio moaooimoadd oaoacdondimcododod ooooomcocioaidniiooo oiooamdmnndoooooaiioo oooocoidood im  miinidc inom onimacnnanmomddid co oa ndicdcnoniodnioi o oodoam\n"
     ]
    }
   ],
   "source": [
    "stringa = \"ciao mondo\"\n",
    "\n",
    "conteggi = Counter(stringa)\n",
    "\n",
    "lettere = list(conteggi.keys())\n",
    "\n",
    "frequenze = list(conteggi.values())\n",
    "\n",
    "random = choices(lettere, weights=frequenze, k=200)\n",
    "\n",
    "testo = str.join('', random)\n",
    "\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "az vdvivaizr o ,tamhrsacaaaoiare aiircuatsaar cromrlaee i nh msar,tecn aésiirertnaec neneeourmca sitavv nv locdziv eiv  drm pmaé zii,daui,l ildcopi ariata\n",
      "drt  ricert \n",
      "aictvsutmseoasoarpsvatto inoeu i\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "\n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    head = it.islice(testo, 100)\n",
    "    \n",
    "    conteggi = Counter(head)\n",
    "    \n",
    "\n",
    "lettere = list(conteggi.keys())\n",
    "\n",
    "frequenze = list(conteggi.values())\n",
    "\n",
    "random = choices(lettere, weights=frequenze, k=200)\n",
    "\n",
    "testo = str.join('', random)\n",
    "\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "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",
    "Invece di generare ogni lettera solo sulla base della sua frequenza nel testo, teniamo conto anche di quale lettera la precede.\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 consideri tutte le possibili lettere seguenti e calcoli la loro frequenza.\n",
    "\n",
    "Per poter fare questo dovremo unire le lettere del testo in coppie consecutive di lettere!\n",
    "\n",
    "Lo faremo usando la libreria esterna, **toolz**, e in particolare la sua funzione **sliding_window**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 23,
   "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",
    "\n",
    "from collections import deque\n",
    "\n",
    "def sliding_window(n, seq):\n",
    "\n",
    "    mazzo = deque(maxlen=n)\n",
    "    \n",
    "    for value in seq:\n",
    "    \n",
    "        mazzo.append(value)\n",
    "        \n",
    "        if len(mazzo)==n:\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": 24,
   "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",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "   \n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    head = it.islice(testo, 30)\n",
    "    \n",
    "    coppie = sliding_window(2, head)\n",
    "    \n",
    "    pprint(list(coppie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Quali sono le coppie più comuni?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    \n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "        \n",
    "    coppie = sliding_window(2, testo)\n",
    "    \n",
    "    conteggi = Counter(coppie)\n",
    "    \n",
    "    pprint(conteggi.most_common(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": [
    "Possiamo calcolare le frequenze delle coppie con \"buona\" precisione a partire dalla divina commedia?\n",
    "\n",
    "Quante combinazioni posso avere?\n",
    "\n",
    "Se consideriamo solo le lettere, gli spazi e le lettere accentate, abbiamo circa 30 caratteri.\n",
    "\n",
    "Tutte le coppie sono date da $30^2 = 900$\n",
    "\n",
    "Se tutte queste coppie fossero equiprobabili e volessimo avere almeno 10 campionamenti per coppia, dovremmo avere circa 10'000 lettere.\n",
    "\n",
    "Quante lettere abbiamo in totale nella nostra divina commedia?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "529770\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    \n",
    "    linee = (linea.lower() for linea in testo)\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    conteggio = sum([1 for c in testo])\n",
    "\n",
    "print(conteggio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Quando useremo le triplette, avremo $30^3 = 27'000$ combinazioni, quindi avremo bisogno di circa 300'000 lettere per avere una buona copertura (cioè una buona stima delle frequenze).\n",
    "\n",
    "\n",
    "Questo ci dice che non potremo davvero andare oltre le triplette, almeno senza renderci le cose difficili."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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",
      "855\n"
     ]
    }
   ],
   "source": [
    "file = './divinacommedia_cleaned.txt'\n",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    \n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    coppie = sliding_window(2, testo)\n",
    "    \n",
    "    conteggi = Counter(coppie)\n",
    "\n",
    "pprint(conteggi.most_common(10))\n",
    "\n",
    "# Quante coppie ci sono?\n",
    "\n",
    "print(len(conteggi)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Anche considerando solo le coppie, non riusciamo a coprire tutti i casi possibili!\n",
    "\n",
    "Però iniziamo già a vedere una prima caratteristica 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",
    "\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": 28,
   "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",
    "\n",
    "print(dizionario.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# Potrei ottenere la lista di tutte le chiavi del dizionario in questo modo:\n",
    "\n",
    "chiavi = [c for c, v in dizionario.items()]\n",
    "\n",
    "print(chiavi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# Oppure selezionare solo alcune chiavi ('b' e 'c') in questo modo:\n",
    "\n",
    "chiavi = [c for c, v in dizionario.items() if c in ['b', 'c']]\n",
    "\n",
    "print(chiavi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c']\n"
     ]
    }
   ],
   "source": [
    "# Equivalente a:\n",
    "\n",
    "chiavi = []\n",
    "\n",
    "for c,v in dizionario.items():\n",
    "    \n",
    "    if c in ['b','c']:\n",
    "        \n",
    "        chiavi.append(c)\n",
    "\n",
    "print(chiavi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c'] [2, 3]\n"
     ]
    }
   ],
   "source": [
    "dizionario = {'a':1, 'b':2, 'c':3}\n",
    "\n",
    "chiavi = [c for c, v in dizionario.items() if c in ['b', 'c']]\n",
    "\n",
    "valori = [v for c, v in dizionario.items() if c in ['b', 'c']]\n",
    "\n",
    "print(chiavi, valori)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'b'), ('a', 'p')]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "\n",
    "lettera = 'a'\n",
    "\n",
    "chiavi = [c for c, v in conteggi_fake.items() if c[0]==lettera]\n",
    "\n",
    "chiavi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def inizia_con(sequence, letter):\n",
    "    \n",
    "    return sequence[0]==letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 'b'), ('a', 'p')]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "\n",
    "lettera = 'a'\n",
    "\n",
    "chiavi = [c for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "\n",
    "chiavi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(['b', 'p'], [1, 3])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteggi_fake = {('a', 'b'):1, ('b', 'c'): 2, ('a', 'p'): 3}\n",
    "\n",
    "lettera = 'a'\n",
    "\n",
    "# c[-1] ritorna l'ultimo elemento di c\n",
    "\n",
    "chiavi = [c[-1] for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "\n",
    "valori = [v for c, v in conteggi_fake.items() if inizia_con(c, lettera)]\n",
    "\n",
    "chiavi, valori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'I', 'X']"
      ]
     },
     "execution_count": 37,
     "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 vettore dei conteggi ottenuto dalla divina commedia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e g\n",
      "e t\n",
      "e s\n",
      "e  \n",
      "e s\n",
      "e i\n",
      "e  \n",
      "e a\n",
      "e s\n",
      "e .\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['e']\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    lettera = nuovo_testo[-1]\n",
    "    \n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    \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": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  q\n",
      "q u\n",
      "u e\n",
      "e  \n",
      "  i\n",
      "i s\n",
      "s u\n",
      "u n\n",
      "n  \n",
      "  s\n",
      "[' ', 'q', 'u', 'e', ' ', 'i', 's', 'u', 'n', ' ', 's']\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = [' ']\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    lettera = nuovo_testo[-1]\n",
    "    \n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    \n",
    "    print(lettera, prossima_lettera)\n",
    "    \n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "\n",
    "print(nuovo_testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " que isun s\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": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " po un l’alibe cara iale’lo l din ssiagas’a ge\n",
      "datumitr lì rte pi iàssca de;\n",
      "\n",
      "lantuno,\n",
      "e, sa\n",
      "crrsiù pralarorevele fichi «pomo d’ li i;\n",
      "\n",
      "\n",
      "che e,\n",
      "peto pe m l rintui mirargiù i?» livene\n",
      "ch’anoggrtelarapi \n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = [' ']\n",
    "\n",
    "for i in range(200):\n",
    "    \n",
    "    lettera = nuovo_testo[-1]\n",
    "    \n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    \n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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",
    "\n",
    "with open(file, 'r', encoding='utf-8-sig') as testo:\n",
    "    \n",
    "    linee = [linea.lower() for linea in testo]\n",
    "    \n",
    "    testo = it.chain.from_iterable(linee)\n",
    "    \n",
    "    coppie = sliding_window(3, testo)\n",
    "    \n",
    "    conteggi = Counter(coppie)\n",
    "\n",
    "print(len(conteggi))\n",
    "\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": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('c', 'h') 'é'\n",
      "('h', 'é') ' '\n",
      "('é', ' ') 'p'\n",
      "(' ', 'p') 'i'\n",
      "('p', 'i') 'ù'\n",
      "('i', 'ù') ' '\n",
      "('ù', ' ') 'b'\n",
      "(' ', 'b') 'u'\n",
      "('b', 'u') 'c'\n",
      "('u', 'c') 'e'\n",
      "ché più buce\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['c', 'h']\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    lettera = tuple(nuovo_testo[-2:])\n",
    "    \n",
    "    lettere = [c[-1] for c, v in conteggi.items() if c[:2]==lettera]\n",
    "    \n",
    "    frequenze = [v for c, v in conteggi.items() if c[:2]==lettera]\n",
    "    \n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    \n",
    "    print(lettera, repr(prossima_lettera))\n",
    "    \n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "    \n",
    "print(str.join('', nuovo_testo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def inizia_con(sequence, letter):\n",
    "    \n",
    "    return sequence[:len(letter)]==letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('c', 'h') 'e'\n",
      "('h', 'e') ' '\n",
      "('e', ' ') 's'\n",
      "(' ', 's') 'o'\n",
      "('s', 'o') ' '\n",
      "('o', ' ') 'p'\n",
      "(' ', 'p') 'r'\n",
      "('p', 'r') 'e'\n",
      "('r', 'e') ' '\n",
      "('e', ' ') 'p'\n",
      "che so pre p\n"
     ]
    }
   ],
   "source": [
    "nuovo_testo = ['c', 'h']\n",
    "\n",
    "for i in range(10):\n",
    "    \n",
    "    lettera = tuple(nuovo_testo[-2:])\n",
    "    \n",
    "    lettere = [c[-1] for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    frequenze = [v for c, v in conteggi.items() if inizia_con(c, lettera)]\n",
    "    \n",
    "    prossima_lettera = choices(lettere, frequenze)[0]\n",
    "    \n",
    "    print(lettera, repr(prossima_lettera))\n",
    "    \n",
    "    nuovo_testo.append(prossima_lettera)\n",
    "    \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": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nel dissile mal piego spescrista;\n",
      "percuote\n",
      "lo forte,\n",
      "là givi de’ mezzo scesso ciaschiar mando, in quel cota ghesensarà ti ancia tanta,\n",
      "\n",
      "amma inver’ ell’ è contende, segno al quando, e foco morta d’un «or\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": 46,
   "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": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vedo sitora inume,\n",
      "percomio rizio ava ti falta te,\n",
      "\n",
      "chia”,\n",
      "te sì che luina ’l gento der temò che no pede dice;\n",
      "\n",
      "e pio dercarvidalto;\n",
      "e mai ai smo ghi guardatti sempiendesmutte ’l milo a che che per mo\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('nel', 2), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " le riche di veatia, per chi fu, al storte\n",
      "sì cam si pa, ma qui onsa;\n",
      "\n",
      "postropossol che nesa ada in d’oglie;\n",
      "coltolsentà riasci le to,\n",
      "fu vosto in mi sandel ma\n",
      "perché no miaredio a lio a subbuolvanici\n"
     ]
    }
   ],
   "source": [
    "testo = str.join(\"\", it.islice(genera_testo('che', 2), 200))\n",
    "print(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " chi maltro a la vità, comico.\n",
      "\n",
      "qualude l’uom sotto,\n",
      "«ben follatorna;\n",
      "le fermare,\n",
      "\n",
      "sor sul che de e quelle,\n",
      "non fu dolce non si stes igura».\n",
      "\n",
      "quando sé ismandi tu verse\n",
      "non saravam là già che hanno ci\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 permette di evitare molti calcoli inutili!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "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",
    "file = './divinacommedia_cleaned.txt'\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": 55,
   "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": [
    "Il risultato è un testo composto da 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 stiamo sottocampionando le varie possibilità.\n",
    "\n",
    "In particolare, con sequenze di tre parole, sto ripescando le frasi orginali per intero perchè ciascuna tripletta di parole si trova spesso una sola volta nel testo."
   ]
  },
  {
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}