DL_Generacion_de_Texto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bN38aAgnox43"
   },
   "source": [
    "# Generación de texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/institutohumai/talleres/blob/master/DL_Generacion_de_Texto.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bN38aAgnox43"
   },
   "source": [
    "- https://minimaxir.com/apps/gpt2-reddit/\n",
    "- https://lyrics.mathigatti.com/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P3Sy6KcwFL-3"
   },
   "source": [
    "## Ejemplos\n",
    "\n",
    "### Harry Potter en inglés\n",
    "\n",
    "<br/>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Harry saw Dumbledore's Fenix leaving the room. He knew it was time to dance.**\n",
    "\n",
    "<br/>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;When they reached the dance floor, Sirius was already in the middle of\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;fidgeting in his seat. Harry realized he was flirting with him. He swallowed\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;and then decided to throw in a wink.\n",
    "\n",
    "<br/>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Harry rose from his seat, grabbed his bag, and then srode to the door. He\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;opened it and entered the room, locking the door behind him. He could hear\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sirius blushing and glacing over his shoulder. He heard the snore and looked\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;over his shoulder at Sirius again. He was just about to go to the dance floor\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;with some Gryffindor-puffs, but stopped himself. The dance floor was\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;reserved for students.\n",
    "\n",
    "<br/>\n",
    "\n",
    "### Whatsapp en español\n",
    "<br/>\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Estaba todo re infierno y muy extracurricular\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;me parecía que me había que hacer programación\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;tipo apellido de ese plan\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;el final es una vaca\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;bueno, quizás es una vaca - ya fue\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;todo sirve para nacer.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jnqCaMPaHlcQ"
   },
   "source": [
    "# Teoria\n",
    "\n",
    "## Introducción al Machine Learning\n",
    "\n",
    "### La programación clásica\n",
    "\n",
    "Los lenguajes de programación se componen de comandos que le indican a la computadora qué hacer. Normalmente contienen palabras en inglés para facilitar su lectura por humanos.\n",
    "\n",
    "En la programación usual uno le indica exactamente qué hacer a la computadora en cada paso.\n",
    "\n",
    "Ejemplo de un programa que decide si un texto carece vocales.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "qM2FcaNPHuV7",
    "outputId": "1508e2d9-fb18-4fa3-cba8-1b2a3d704981"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'No'"
      ]
     },
     "execution_count": 2,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sin_vocales(palabra):\n",
    "  if \"a\" in palabra:\n",
    "      return \"No\"\n",
    "\n",
    "  if \"e\" in palabra:\n",
    "      return \"No\"\n",
    "\n",
    "  if \"i\" in palabra:\n",
    "      return \"No\"\n",
    "\n",
    "  if \"o\" in palabra:\n",
    "      return \"No\"\n",
    "\n",
    "  if \"u\" in palabra:\n",
    "      return \"No\"\n",
    "\n",
    "  return \"Si\"\n",
    "\n",
    "sin_vocales(\"hola\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g9lkNRREHyIJ"
   },
   "source": [
    "## El aprendizaje automático\n",
    "\n",
    "El ejemplo anterior funciona bien pero uno podría preguntarse si se podrá hacer de otra manera. Si en lugar de describir explicitamente los pasos a seguir se podrá, en vez, mostrar ejemplos y que la computadora se de cuenta sola de la solución al problema.\n",
    "\n",
    "Por ejemplo, podríamos armar un _dataset_ que luzca asi:\n",
    "\n",
    "|Palabra|¿Sin vocales?|\n",
    "|---|---|\n",
    "|hola|No|\n",
    "|wtf|Si|\n",
    "|dm|Si|\n",
    "|cordon|No|\n",
    "|...|...|\n",
    "\n",
    "Luego en base a estos ejemplos la computadora debería implementar un programa que haga lo que queremos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YQrzJgTDH0-X"
   },
   "source": [
    "Machine Learning es el estudio de los procedimientos necesarios para hacer que las máquinas mejoren automáticamente a través de la experiencia.\n",
    "\n",
    "<br/>\n",
    "\n",
    "Aplicar esto a detectar si un texto es _sin_vocales_ es un poco forzado ya que si uno puede resolver un problema indicandole exactamente a la computadora lo que quiere entonces no es necesario esperar a que aprenda en base a ejemplos. Pero hay problemas que son mucho mas dificiles de describir en palabras o instrucciones de computadora, muchas veces son cosas que nosotros hacemos inconcientemente, sin entender demasiado cómo se hacen realmente.\n",
    "\n",
    "<br/>\n",
    "\n",
    "![texto alternativo](https://e00-marca.uecdn.es/assets/multimedia/imagenes/2017/08/26/15037611080600.jpg)\n",
    "\n",
    "<br/>\n",
    "\n",
    "Un ejemplo clásico es el reconocimiento de imágenes. En la foto hay una cara, pero como sabemos eso? Hay dos ojos, una nariz y una boca en posiciones anatomicamente correctas. Pero como describo esto de forma precisa? Debería decribir lo que es una sonrisa, con todas las variedades de color, tamaño y posicion que hay, lo mismo para las demas partes de la cara.\n",
    "\n",
    "\n",
    "![](https://i.imgur.com/4AX2GW0.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v3v7lZYQH4kQ"
   },
   "source": [
    "## Redes Neuronales Artificiales\n",
    "_Una decisión compleja se toma a partir de muchas decisiones simples_\n",
    "\n",
    "### ¿Qué es una neurona?\n",
    "La neurona es la unidad básica de la red. Esta, en base a una serie de valores, toma una decisión, similarmente a cuando tenemos un if en un programa y decidimos si hacer algo o no en base a algunas variables.\n",
    "\n",
    "![texto alternativo](https://www.xeridia.com/sites/default/files/contenidos/blog/neurona_artificial.jpg)\n",
    "\n",
    "\n",
    "### ¿Qué es una Red Neuronal?\n",
    "\n",
    "![Ilustración de un clasificador de imagenes](https://i.imgur.com/n0EC5Xn.gif)\n",
    "\n",
    "![Detalle de los filtros de cada capa de un clasificador de imagenes](https://i.imgur.com/dlN3W0R.jpg)\n",
    "\n",
    "\n",
    "### ¿Cómo es posible esta magia?\n",
    "\n",
    "- [backpropagation](https://es.wikipedia.org/wiki/Propagaci%C3%B3n_hacia_atr%C3%A1s): Un algoritmo eficiente para buscar la configuración optima de las neuronas automáticamente a partir de un _dataset_ de entrenamiento.\n",
    "- [Placas de video](https://es.wikipedia.org/wiki/Tarjeta_gr%C3%A1fica): Componentes baratos y poderosos para realizar miles de calculos matemáticos simultaneamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6wfLAp6LotFg"
   },
   "source": [
    "\n",
    "## Generación de texto y GPT-2\n",
    "\n",
    "Hoy vamos a usar una red neuronal generadora de texto llamada GPT-2. Normalmente un programa que genera texto funciona de a una palabra por vez, o sea basado en las palabras anteriores, piensa cual debería decir luego.\n",
    "\n",
    "Un ejemplo de esto se puede encontrar en el predictor de sus telefonos cuando escriben un mensaje. Una actividad entretenida (Y de profunda introspección(?)) es probar a qué frases llegan utilizando unicamente las palabras que este sugiere.\n",
    "\n",
    "### Transformers\n",
    "\n",
    "La red que vamos a ver hoy utiliza una arquitectura inventada en 2017 llamada **transformer**. Si bien vimos que las redes neuronales son un conjunto de neuronas conectadas entre si, en los últimos años se empezaron a desarrollar modelos mas complejos que son mas como redes de redes. O sea muchas redes con objetivos especificos conectadas entre si para resolver cierta tarea mas compleja. Por ejemplo, en el caso particular del modelo transformer, este tiene un módulo que se encarga especificamente de decidir cuales son las palabras mas importantes en una oración. Ese módulo no resuelve todo el problema, pero resulta muy util para que el resto del programa sepa decidir mejor que palabra elegir próxima, guiandose primero de las palabras mas relevantes.\n",
    "\n",
    "![texto alternativo](https://lilianweng.github.io/lil-log/assets/images/cheng2016-fig1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jHznM3kLzASL"
   },
   "source": [
    "# Practica\n",
    "\n",
    "### ¿Cómo le enseñamos a hablar a la computadora?\n",
    "Entrenar una red compleja como esta lleva mucho tiempo y requiere cantidades de datos muy grandes. Pero debido a que alguien ya hizo ese trabajo por nosotros, entonces podemos utilizar estos modelos ya entrenados.\n",
    "\n",
    "#### Fine tuning\n",
    "El modelo ya entrenado funciona muy bien pero produce texto generico. Podríamos intentar entrenarlo un poco mas para que se especialice en un estilo literario o vocabulario mas especifico. Esta idea de arrancar con un modelo generico ya entrenado y luego entrenarlo un poquito mas para que cumpla cierta tarea especifica se llama _finetuning_.\n",
    "\n",
    "#### Texto en español\n",
    "El modelo provisto sabe hablar inglés, no español, pero es mejor que nada. Podemos utilizar la técnica de finetuning sobre el texto en español que nos interese o traducir primero lo que tenemos a inglés para conseguir mejores resultados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ADQpkFMb5oUw"
   },
   "source": [
    "## Conectarnos a Google Drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "objH57ocz6Nx",
    "outputId": "56c2dc03-e74b-470a-ce3e-d4fdb3622fcd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6QOYJjYn5woc"
   },
   "source": [
    "## Instalando librerias e inicializando variables\n",
    "Hoy vamos a utilizar la libreria gpt-2-simple, ante dudas se puede recurrir a su [documentación](https://minimaxir.com/2019/09/howto-gpt2/) o utilizar el comando _help_ de python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "p7aUT_WPIsEH"
   },
   "outputs": [],
   "source": [
    "!pip install transformers==2.9.1\n",
    "!pip install pytorch-lightning==0.8.4\n",
    "!pip install -q aitextgen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aSQlerdqbUeX"
   },
   "outputs": [],
   "source": [
    "!mkdir -p \"/content/drive/My Drive/gpt2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qsct82E2wTNr"
   },
   "outputs": [],
   "source": [
    "%cd \"/content/drive/My Drive/gpt2\"\n",
    "from aitextgen import aitextgen\n",
    "#Para inicialziar el modelo por primera vez se carga así\n",
    "ai = aitextgen(tf_gpt2=\"124M\", to_gpu=True)\n",
    "\n",
    "#Para continuar un entrenamiento previo se carga el modelo de esta manera\n",
    "#ai = aitextgen(model=\"trained_model/pytorch_model.bin\", config=\"trained_model/config.json\", to_gpu=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uJ4CCOoA5O-I"
   },
   "source": [
    "## Entrenamiento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MSIO933bJRIf"
   },
   "outputs": [],
   "source": [
    "file_path = \"/content/drive/My Drive/gpt2/todojunto.txt\" # Ruta del archivo de texto que usare para entrenar al modelo\n",
    "ai.train(file_path,\n",
    "         line_by_line=False,\n",
    "         num_steps=5000,\n",
    "         generate_every=500,\n",
    "         save_every=100,\n",
    "         learning_rate=1e-4,\n",
    "         batch_size=1, \n",
    "         )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DIVIpAlmJWOL"
   },
   "source": [
    "## Generar texto usando el modelo entrenado\n",
    "\n",
    "Después del entrenamiento podemos generar tanto texto como queramos utilizando el comando `generate`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tsWhR8I60yTM"
   },
   "outputs": [],
   "source": [
    "ai.generate(n=2, temperature=0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fS7-_WmRKECN"
   },
   "outputs": [],
   "source": [
    "# Generar y guardar los textos en test.txt\n",
    "resultados = ai.generate(n=4, temperature=0.7, return_as_list = True)\n",
    "print(resultados)\n",
    "with open(\"test.txt\",'w') as f:\n",
    "  f.write(resultados[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XlHC32wp2jjo",
    "outputId": "ac09ad78-0712-4580-b8b5-bc4fc4908232"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method generate in module aitextgen.aitextgen:\n",
      "\n",
      "generate(n:int=1, prompt:str=None, max_length:int=256, temperature:float=0.7, do_sample:bool=True, return_as_list:bool=False, seed:int=None, **kwargs) -> Union[str, NoneType] method of aitextgen.aitextgen.aitextgen instance\n",
      "    Generates texts using the stored Transformers model.\n",
      "    Currently generates text using the model's generate() function.\n",
      "    \n",
      "    :param n: Numbers of texts to generate.\n",
      "    :param prompt: Text to force the generated text to start with\n",
      "    :param max_length: Maximum length for the generated text\n",
      "    :param temperature: Determines the \"creativity\" of the generated text.\n",
      "    The value range is different for each type of Transformer.\n",
      "    :param do_sample: Samples the text, which is what we want. If False,\n",
      "    the generated text will be the optimal prediction at each time,\n",
      "    and therefore deterministic.\n",
      "    :param return_as_list: Boolean which determine if text should be returned\n",
      "    as a list. If False, the generated texts will be print to console.\n",
      "    :param seed: A numeric seed which sets all randomness, allowing the\n",
      "    generate text to be reproducible if rerunning with same parameters\n",
      "    and model.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ai.generate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4JW-jbNCjz0N"
   },
   "source": [
    "# ¿Cómo recopilo datos para entrenar a mi red?\n",
    "\n",
    "Aplicando web scraping. Por ejemplo desarrollando código como [este](https://gist.github.com/mathigatti/fec92ff0fffefd0a2951ec43f4302f43) que descarga canciones de letras.com\n",
    "\n",
    "\n",
    "![](https://thumbor.forbes.com/thumbor/960x0/https%3A%2F%2Fblogs-images.forbes.com%2Fgilpress%2Ffiles%2F2016%2F03%2FTime-1200x511.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OMQDkl1uNLoG",
    "outputId": "8461d5ae-af32-47ec-f6d7-220c504cd634"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2020-10-28 22:44:09--  https://gist.githubusercontent.com/mathigatti/fec92ff0fffefd0a2951ec43f4302f43/raw/bf27d2ef139c033238255025ed44f7af1d40b736/scrape_letras.py\n",
      "Resolving gist.githubusercontent.com (gist.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...\n",
      "Connecting to gist.githubusercontent.com (gist.githubusercontent.com)|151.101.0.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 1090 (1.1K) [text/plain]\n",
      "Saving to: ‘scrape_letras.py’\n",
      "\n",
      "scrape_letras.py    100%[===================>]   1.06K  --.-KB/s    in 0s      \n",
      "\n",
      "2020-10-28 22:44:09 (36.3 MB/s) - ‘scrape_letras.py’ saved [1090/1090]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Bajemos un programa que sirve para scrapear letras.com\n",
    "!wget https://gist.githubusercontent.com/mathigatti/fec92ff0fffefd0a2951ec43f4302f43/raw/bf27d2ef139c033238255025ed44f7af1d40b736/scrape_letras.py\n",
    "# wget es un comando de bash para descargar el contenido de un sitio web"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ubmoil_9BBAn"
   },
   "outputs": [],
   "source": [
    "# Con este comando ejecuto con el interprete de python el codigo que esta en el archivo \"scrape_letras.py\" y le especifico que quiero descargar canciones de lady-gaga\n",
    "!python scrape_letras.py lady-gaga"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tktzgYb2NmXo"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "\n",
    "def unir_txts(carpeta_con_los_txts):\n",
    "  lista_de_txts = os.listdir(carpeta_con_los_txts) # Esto arma la lista de todos los archivos que estan en ese directorio/carpeta\n",
    "\n",
    "  texto_final = \"\" # Variable donde voy a ir juntando el texto de todos los txts\n",
    "  delimitador = \"==NEW_TEXT==\\n\" # Voy a usar esto como delimitador/separador, para resaltar cuando arranca un nuevo texto\n",
    "\n",
    "  for nombre_del_txt in lista_de_txts: # recorro los archivos uno por una\n",
    "    # uno el nombre de la carpeta con el nombre del archivo para armar la ruta exacta donde el txt se ubica\n",
    "    ruta_al_archivo = carpeta_con_los_txts + \"/\" + nombre_del_txt \n",
    "\n",
    "    # leo el archivo y agrego su texto a \"texto_final\"\n",
    "    with open(ruta_al_archivo,'r') as f:\n",
    "      texto_del_proximo_txt = f.read()\n",
    "      texto_final = texto_final + delimitador + texto_del_proximo_txt.strip() + \"\\n\"\n",
    "\n",
    "  # Escribo todo el texto en un archivo llamado \"archivo_final.txt\"\n",
    "  with open(\"todojunto.txt\",'w') as f:\n",
    "    f.write(texto_final.strip())\n",
    "\n",
    "carpeta_con_los_txts = \"lady-gaga\"\n",
    "unir_txts(carpeta_con_los_txts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "18g3pTOPPRvG"
   },
   "source": [
    "# ¿Cómo descargo datos de otro sitio web?\n",
    "\n",
    "Si te quedaste con ganas de aprender mas sobre como extraer fuentes de datos de internet entonces anotate en el [curso de extracción de Datos](https://ihum.ai/cursos/web) que arranca el 9/11\n",
    "\n",
    "\n",
    "[<img aligned=\"center\" src=\"https://instagram.faep9-2.fna.fbcdn.net/v/t51.2885-15/fr/e15/s1080x1080/121506368_281801079543305_2993402788434074675_n.jpg?_nc_ht=instagram.faep9-2.fna.fbcdn.net&_nc_cat=105&_nc_ohc=uP9mJ5xA_J8AX-qj1SG&oh=e0440f4a2cd8f5404a5800369230cb0e&oe=5FC2E630\" alt=\"Curso scraping\" width=\"500\">](https://ihum.ai/cursos/web)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "bN38aAgnox43",
    "jnqCaMPaHlcQ",
    "DIVIpAlmJWOL",
    "4JW-jbNCjz0N"
   ],
   "name": "Taller de DL - Generacion de Texto.ipynb",
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}