diff --git "a/notebook/EDIA_Docs.ipynb" "b/notebook/EDIA_Docs.ipynb" new file mode 100644--- /dev/null +++ "b/notebook/EDIA_Docs.ipynb" @@ -0,0 +1,5183 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# **EDIA**: Estereotipos y Discriminación en Inteligencia Artificial \n", + "\n", + "Notebook con proposito de documentación sobre la herramienta y sus clases.\n", + "\n", + "---" + ], + "metadata": { + "id": "gwgsThogKQzA" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Objetivo general\n", + "\n", + "El objetivo de esta notebook es **familarizarse** con las diferentes clases y funcionalidades que ofrece la herramienta en la **particularización**, **deteccion** y **exposición** de los sesgos presentes en *embeddings* de palabras o sentencias, que, de forma indirecta, afecta a comunidades vulnerables frente a modelos de inteligencia artificial que se basan en ellos para el procesamientos del lenguaje y comunicación." + ], + "metadata": { + "id": "_2LveNCo2_R6" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Descarga o uso on-line\n", + "\n", + "Pueden encontrar tanto repositorios en GitHub como en HuggingFace🤗 para instalar localmente esta herramienta. Además, se cuenta en HuggingFace🤗 con una demo con interfaz grafica para conseguir exponer este trabajos a aquellos sectores con menor nivel de conocimiento pero gran interés en el área.\n", + "\n", + "`GitHub:` [link]\n", + "\n", + "`HuggingFace🤗`: https://huggingface.co/spaces/vialibre/edia\n" + ], + "metadata": { + "id": "PbrlG5V7sB9Y" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Estableciendo el entorno de trabajo\n", + "Para descargar la herramienta, el *dataset* y los paquetes de python requeridos para el correcto funcionamiento, ejecutar la siguiente celda." + ], + "metadata": { + "id": "ajDbRPm825gl" + } + }, + { + "cell_type": "code", + "source": [ + "# Descarga y descomprimir archivo de word embeddings del español\n", + "!wget -q http://dcc.uchile.cl/~jperez/word-embeddings/fasttext-sbwc.100k.vec.gz\n", + "!gzip -d fasttext-sbwc.100k.vec.gz\n", + "\n", + "# Clonar repositorio\n", + "!git clone https://github.com/git-lu/notebook_bias_tools.git\n", + "\n", + "# Crear directorio data/\n", + "!mkdir notebook_bias_tools/data\n", + "\n", + "# Mover word embeddings al directorio data/\n", + "!mv fasttext-sbwc.100k.vec notebook_bias_tools/data/fasttext-sbwc.100k.vec\n", + "\n", + "# Instalar gdown para descargar de Google Drive\n", + "!pip3 -q install --upgrade gdown\n", + "\n", + "# Descargar y mover a direcotrio data/ vocabulario quarter\n", + "!gdown https://drive.google.com/uc?id=1NYgWZTPDhpKsZO9qOsP29mKHviA_gsYW\n", + "!mv quarter_vocab_v6.zip notebook_bias_tools/data/quarter_vocab_v6.zip\n", + "\n", + "# Mover current directory al repo\n", + "%cd notebook_bias_tools/\n", + "\n", + "# Instalar paquetes y librerias requeridas\n", + "!pip -q install -r requirements.txt" + ], + "metadata": { + "id": "SweVWrZFwmYy", + "collapsed": true, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e75cacfa-6ddd-44d8-a2fd-b80a456ecb8a" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Cloning into 'notebook_bias_tools'...\n", + "remote: Enumerating objects: 280, done.\u001b[K\n", + "remote: Counting objects: 100% (280/280), done.\u001b[K\n", + "remote: Compressing objects: 100% (176/176), done.\u001b[K\n", + "remote: Total 280 (delta 161), reused 197 (delta 82), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (280/280), 457.21 KiB | 1.87 MiB/s, done.\n", + "Resolving deltas: 100% (161/161), done.\n", + "Downloading...\n", + "From: https://drive.google.com/uc?id=1NYgWZTPDhpKsZO9qOsP29mKHviA_gsYW\n", + "To: /content/quarter_vocab_v6.zip\n", + "100% 74.6M/74.6M [00:01<00:00, 56.7MB/s]\n", + "/content/notebook_bias_tools\n", + "\u001b[K |████████████████████████████████| 5.8 MB 6.8 MB/s \n", + "\u001b[K |████████████████████████████████| 24.1 MB 2.1 MB/s \n", + "\u001b[K |████████████████████████████████| 647 kB 56.3 MB/s \n", + "\u001b[K |████████████████████████████████| 452 kB 56.5 MB/s \n", + "\u001b[K |████████████████████████████████| 11.6 MB 56.3 MB/s \n", + "\u001b[K |████████████████████████████████| 106 kB 48.4 MB/s \n", + "\u001b[K |████████████████████████████████| 84 kB 3.4 MB/s \n", + "\u001b[K |████████████████████████████████| 54 kB 2.7 MB/s \n", + "\u001b[K |████████████████████████████████| 84 kB 2.8 MB/s \n", + "\u001b[K |████████████████████████████████| 55 kB 3.6 MB/s \n", + "\u001b[K |████████████████████████████████| 278 kB 50.2 MB/s \n", + "\u001b[K |████████████████████████████████| 56 kB 4.8 MB/s \n", + "\u001b[K |████████████████████████████████| 213 kB 57.8 MB/s \n", + "\u001b[K |████████████████████████████████| 2.3 MB 50.1 MB/s \n", + "\u001b[K |████████████████████████████████| 182 kB 46.5 MB/s \n", + "\u001b[K |████████████████████████████████| 7.6 MB 42.8 MB/s \n", + "\u001b[K |████████████████████████████████| 132 kB 67.9 MB/s \n", + "\u001b[K |████████████████████████████████| 213 kB 70.8 MB/s \n", + "\u001b[K |████████████████████████████████| 127 kB 69.9 MB/s \n", + "\u001b[K |████████████████████████████████| 64 kB 2.7 MB/s \n", + "\u001b[K |████████████████████████████████| 80 kB 9.1 MB/s \n", + "\u001b[K |████████████████████████████████| 69 kB 6.1 MB/s \n", + "\u001b[K |████████████████████████████████| 68 kB 6.9 MB/s \n", + "\u001b[K |████████████████████████████████| 68 kB 6.7 MB/s \n", + "\u001b[K |████████████████████████████████| 68 kB 5.9 MB/s \n", + "\u001b[K |████████████████████████████████| 68 kB 5.8 MB/s \n", + "\u001b[K |████████████████████████████████| 50 kB 5.8 MB/s \n", + "\u001b[K |████████████████████████████████| 4.0 MB 66.0 MB/s \n", + "\u001b[K |████████████████████████████████| 593 kB 57.2 MB/s \n", + "\u001b[K |████████████████████████████████| 856 kB 59.0 MB/s \n", + "\u001b[?25h Building wheel for sklearn (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for uuid (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for annoy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for ffmpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for python-multipart (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Exploración de palabras y sesgos presentes\n" + ], + "metadata": { + "id": "blZXG7zyVZuJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Objetivo\n", + "\n", + "Muchos embeddings pre-calculados se obtienen de modelos en cuyos datos de entrenamiento fueron suministrados por **grandes cantidades de ejemplos** de los cuales un porcentaje no despreciable contienen sesgos marcados. Como consecuencia, esto se extrapola en los embeddings de las palabras resultantes.\n", + "\n", + "En muchas ocaciones, al tratarse de vectorizaciones de palabras, podemos tomar una iniciativa matematica y graficarlas en un plano, observarndo así como éstas se relacionan por cercania entre sí. \n", + "\n", + "Esta cercania, nos dá una ligera idea de \"*mismo significado*\", aunque no literal; tan solo se tratan de palabras cuyos contextos lo son, existiendo así de forma latente la posibilidad de intercambiar estas palabras muy cercanas entre sí en el mismo contexto manteniendo la coherencia de la misma." + ], + "metadata": { + "id": "Ck36cV5vbY9A" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase Embedding\n", + "\n", + "La tarea clave de esta clase es la carga de vectores de palabras (*word embeddings*) pre-calculados, estos pueden ser obtenidos a traves de la web o propios.\n", + "\n", + "A traves de ésta es que las siguientes clases que se describen podran contar con un núcleo claro, sencillo y transparente para la obtención de información sobre las palabras, más alla de su embedding.\n", + "\n", + "Para cargar esta clase, ejecutamos la siguiente celda." + ], + "metadata": { + "id": "xZvU428Oz46j" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.model_embbeding import Embedding" + ], + "metadata": { + "id": "AjYjqrsoz8rY" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto, esta clase cuenta con varios parametros a setear para un correcto (y eficiente) funcionamiento en diferentes arquitecturas, examinemos cada uno de ellos:\n", + "\n", + "* `path (str)`: ruta de archivo a embeddings pre-calculados. Por convención, se suele utilizar un archivo de vectores (`.vec`) aunque también se aceptan binarios (`.bin`) con el formato C de gensim.\n", + "* `limit (int)`: *`None` por defecto*. El número de vectores a extraer de `path`.\n", + "* `randomizedPCA (bool)`: *`False` por defecto*. Utilizar una componente alteatoria para el calculo del PCA para mayor eficiencia pero menor exactitud.\n", + "* `max_neighbours (int)`: *`20` por defecto*. Número de vecinos maximos precalculados.\n", + "* `nn_method (str)`: *`'sklearn'` por defecto*. Método para la obtención de los vecinos de las palabras. Las posibilidades son `'sklearn'` para un calculo exacto pero costoso, y `'ann'` para una aproximación rápida pero resultados no exactos.\n", + "\n", + "> **Nota**: Para la carga de embeddings pre-calculados a partir de un binario con otro formato al especificado anteriormente, se puede generar un script para crear el archivo de vectores (`.vec`) a partir de los presentes en el binario de origen.\n", + "\n", + "Si se cuenta con un alto número de embeddings que la arquitectura de base no logra cargar, es aconsejable limitarlos con el parámetro `limit`, si esto no es suficiente, aconsejamos utilizar aproximaciones de resultados estableciendo `randomizedPCA = True` y/o `nn_method = 'ann'`.\n", + "\n", + "En la siguiente celda realizamos una instanciacón de esta clase que nos será de utilidad en las siguientes descripciones." + ], + "metadata": { + "id": "Yq8-1sWNz_hw" + } + }, + { + "cell_type": "code", + "source": [ + "emb = Embedding(\n", + " path='data/fasttext-sbwc.100k.vec',\n", + " limit=100_000,\n", + " randomizedPCA=False,\n", + " max_neighbors=20,\n", + " nn_method='sklearn'\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EMVoJitl0CsR", + "outputId": "e6969ac2-7e17-4472-dea9-3b1840d39c5f" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Preparing fasttext-sbwc.100k.vec embeddings...\n", + "Initializing sklearn method to search for nearby neighbors...\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Como describimos anteriormente, esta clase no se encarga unicamente de conteneder los embeddings de las palabras, si no tambien de realizar pre-calculos de interés para las proximas clases como son la reducción de dimensionalidad a solo dos con el método de [análisis de componentes principales](https://es.wikipedia.org/wiki/An%C3%A1lisis_de_componentes_principales) (*PCA*) o cálculo de vecinos cercanos de todas las palabras." + ], + "metadata": { + "id": "UjV0S2270E4I" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase WordExplorer\n", + "\n", + "Esta clase, instanciada a partir de un objeto `Embedding` del cual extraer la información de interes, cuenta con las funcionalidades para explorar las palabras y graficarlas en el plano." + ], + "metadata": { + "id": "gHHQxKdnXkcL" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_WordExplorer import WordExplorer" + ], + "metadata": { + "id": "sV1D8mkZWUQL" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, solo se requiere un parámetro:\n", + "* `embedding (Embedding)`: Objeto de tipo `Embedding` de la cuál obtener el vocabulario disponible junto a la información del mismo como son los embeddings, PCA o vecinos." + ], + "metadata": { + "id": "ABNagFpi5W9u" + } + }, + { + "cell_type": "code", + "source": [ + "we = WordExplorer(emb)" + ], + "metadata": { + "id": "WXPoPRYX5klX" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método check_oov(...)\n", + "\n", + "Este es un método clave de muchas de las clases de la herramienta **EDIA**, la cuál verifica que todas las palabras que el usuario ingresa estan presentes en el objeto `Embedding` para la extracción de su información.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlists (List[List[str]])`: Lista de listas de palabras a verificar su presencia en el objeto `Embedding` utilizado en la instanciacón actual de la clase `WordExplorer`.\n", + "\n", + "**Salida(s)**:\n", + "* `None` o `str` con mesaje de error explicitando la palabra fuera de vocabulario." + ], + "metadata": { + "id": "AJRgcIHb61sE" + } + }, + { + "cell_type": "markdown", + "source": [ + "Realizamos una prueba con una lista de palabras presentes en el vocabulario." + ], + "metadata": { + "id": "5WBQdtNW9mB2" + } + }, + { + "cell_type": "code", + "source": [ + "palabras_presentes = ['hombre', 'mujer']" + ], + "metadata": { + "id": "AevNgpEJ9x0E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "we.check_oov([palabras_presentes])" + ], + "metadata": { + "id": "kcvgZvO99ugk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Ahora un caso donde una de las listas de palabras contiene varias palabras que no estan presentes en el vocabulario. Probar como al quitar palabras de esta lista, el mensaje de error es acorde y claro a la palabra faltante." + ], + "metadata": { + "id": "hVDWB2V_-Aux" + } + }, + { + "cell_type": "code", + "source": [ + "palabras_no_presentes = ['mujer123', 'lumberjack', 'jajant', 'caipirosca']" + ], + "metadata": { + "id": "WdEGS4KU-Slg" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "we.check_oov([palabras_presentes, palabras_no_presentes])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "5kFvhd1z-fHQ", + "outputId": "4764a531-68ce-4053-8cd3-f8a7d99a0c94" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\"Error: La palabra 'mujer123' no se encuentra en el vocabulario!\"" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Las funciones de interes siempre realizan este chequeo previo, de esta forma no hay una necesidad explicita por parte del usuario de instaciarlo en todas las iteraciones." + ], + "metadata": { + "id": "AYP3hfK6_Wp-" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Método get_neighbours(...)\n", + "\n", + "Este método nos permite obtener las palabras vecinas de una dada.\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: Palabra a la cuál buscar los `n_neighbors` vecinos más cercanos. Debe estar presente en el vocabulario.\n", + "* `n_neighbors (int)`: número de vecinos a buscar (limitado por el parámetro `max_neighbours` del objeto `Embedding` con el cuál se creó el objeto `WordExplorer` actual).\n", + "* `nn_method (str)`: Método de obtención de vecinos. Actualmente los metodos posibles son `'sklearn'` y `'ann'`.\n", + "\n", + "**Salida(s)**:\n", + "* `List[str]`: lista con las palabras vecinas. Notar que es posible que los vecinos encontrados sean menor a los esperados (*i.e* `len(lista_vecinos_encontrados) <= n_neighbours`).\n", + "\n", + "> **Notar**: siempre de base se utiliza el objeto de tipo `Embedding` empleado para la instanciación de esta clase, si el método de obtención de vecinos es distinto al seteado en la creación del objeto `Embedding`, se cargará este nuevo método lo cuál puede llevar un mayor tiempo de obtención de vecinos en la primera ejecución debido a la carga e inicialización del nuevo método." + ], + "metadata": { + "id": "8WoqEw1m_BrW" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos un ejemplo buscando las ocho palabras vecinas de la palabra *mujer*." + ], + "metadata": { + "id": "t3T4rrliB7fi" + } + }, + { + "cell_type": "code", + "source": [ + "we.get_neighbors('mujer', 8, 'sklearn')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "koStaRGACF_s", + "outputId": "35765485-a945-4ac1-ff53-8de8e3d5b1cc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['niña',\n", + " 'mujeres',\n", + " 'hombre',\n", + " 'marido',\n", + " 'muchacha',\n", + " 'adolescente',\n", + " 'embarazada',\n", + " 'anciana']" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Veamos ahora lo que sucede cuando buscamos los vecinos pero empleando otro método de calculo de vecinos." + ], + "metadata": { + "id": "asuLN_msCaNe" + } + }, + { + "cell_type": "code", + "source": [ + "we.get_neighbors('mujer', 8, 'ann')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "je9vbW0-Cide", + "outputId": "60becf82-3a84-4914-93f1-bd0f7dc0d314" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Initializing Annoy method to search for nearby neighbors...\n", + "\tInit tree...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 99723/99723 [00:03<00:00, 28186.63it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3.553600311279297 seg.\n", + "\tBuild tree...\n", + "3.390350103378296 seg.\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['marido',\n", + " 'fémina',\n", + " 'muchachas',\n", + " 'pareja',\n", + " 'nuera',\n", + " 'gitana',\n", + " 'agresora',\n", + " 'adoptiva']" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Ya cargado el nuevo método de obtención de vecinos, podemos obtener vecinos de las demás palabras sin contar ahora con el tiempo de carga incial." + ], + "metadata": { + "id": "w1nEVvEmDQsC" + } + }, + { + "cell_type": "code", + "source": [ + "we.get_neighbors('chancho', 10, 'ann')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IGAeNlgADbnI", + "outputId": "f5f4d258-9791-40de-d825-a918c6805268" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['chicharrón',\n", + " 'cabrito',\n", + " 'puerco',\n", + " 'pelado',\n", + " 'cuy',\n", + " 'gallina',\n", + " 'guiso',\n", + " 'guajolote',\n", + " 'cabritos',\n", + " 'picadillo']" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Notar que si la palabra no está en el vocabulario o si el número de vecinos a extraer es mayor a `max_neighbours` se levanta una aserción." + ], + "metadata": { + "id": "TxpwC5v9Dlmb" + } + }, + { + "cell_type": "code", + "source": [ + "# Palabra fuera de vocabulario (OOV)\n", + "we.get_neighbors('mujer123', 5, 'sklearn')" + ], + "metadata": { + "id": "EyTOqdHtD7cq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# n_neighbour > max_neighbours de clase Embedding\n", + "we.get_neighbors('mujer', 30, 'ann')" + ], + "metadata": { + "id": "aqBMxVf7EFdu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método doesnt_match(...)\n", + "\n", + "Este método es similar al presente en la libreria de [gensim](https://tedboy.github.io/nlps/generated/generated/gensim.models.Word2Vec.doesnt_match.html). El objetivo del mismo es dada una secuencia de palabras obtener aquel que no coincide con la tematica de las demás.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlist (List[str])`: Lista de palabras a evaluar.\n", + "\n", + "**Salida(s)**:\n", + "* `str`: palabra que no concuerda con las demás presentes en `wordlist`.\n" + ], + "metadata": { + "id": "K8Q4Zq3xeh4w" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos un ejemplo con las comidad del dia." + ], + "metadata": { + "id": "x2pRYU5XfdO5" + } + }, + { + "cell_type": "code", + "source": [ + "comidas = ['desayuno', 'merienda', 'cereal', 'cena', 'almuerzo']" + ], + "metadata": { + "id": "Zb_zraeFfiQw" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "we.doesnt_match(comidas)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "ItS77TksfvJ1", + "outputId": "10d37df9-dc17-450e-95d5-6a01741a2ff2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cereal'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método plot_projections_2d(...)\n", + "\n", + "Este es el método que nos permite graficar en un plano (*i.e.* 2 dimensiones) las palabras para explorar las distancias entre ellas y encontrar vecinos de interés.\n", + "\n", + "Recordar que las palabras son representadas con vectores (*word embeddings*) que cuentan, generalmente, con 300 componentes, es por ello que se lleva el cómputo extra de obtener una representación de tan solo dos componentes para graficar mediante la tecnica **PCA** de reduccion de dimensionalidad.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlist_0 (List[str])`: Lista de palabras las cuales graficar en el plano.\n", + "* `wordlist_1 (List[str])`: *`[]` por defecto*. Lista de palabras las cuales graficar en el plano.\n", + "* `wordlist_2 (List[str])`: *`[]` por defecto*. Lista de palabras las cuales graficar en el plano.\n", + "* `wordlist_3 (List[str])`: *`[]` por defecto*. Lista de palabras las cuales graficar en el plano.\n", + "* `wordlist_4 (List[str])`: *`[]` por defecto*. Lista de palabras las cuales graficar en el plano.\n", + "* `kwargs`:\n", + " * `color_wordlist_0 (str)`: *`'#000000'` por defecto*. Valor hexadecimal para colorear e identificar las palabras de `wordlist_0`.\n", + " * `color_wordlist_1 (str)`: *`'#1f78b4'` por defecto*. Valor hexadecimal para colorear e identificar las palabras de `wordlist_1`.\n", + " * `color_wordlist_2 (str)`: *`'#33a02c'` por defecto*. Valor hexadecimal para colorear e identificar las palabras de `wordlist_2`.\n", + " * `color_wordlist_3 (str)`: *`'#e31a1c'` por defecto*. Valor hexadecimal para colorear e identificar las palabras de `wordlist_3`.\n", + " * `color_wordlist_4 (str)`: *`'#6a3d9a'` por defecto*. Valor hexadecimal para colorear e identificar las palabras de `wordlist_4`.\n", + " * `n_neighbors (int)`: *`0` por defecto*. Número de vecinos de las listas de palabras `wordlist_*` a obtener y graficar en el plano.\n", + " * `n_alpha (float)`: *`0.3` por defecto*. Valor alfa (*i.e.* transparencia) en el gráfico de las palabras vecinas calculadas\n", + " * `nn_method (str)`: *`'sklearn` por defecto*. Método para obtener las palabras vecinas. Actualmente los metodos posibles son `'sklearn'` y `'ann'`.\n", + " * `fontsize (int)`: *`18` por defecto*. Tamaño de fuente de las palabras en el gráfico.\n", + " * `figsize (Tuple[int, int])`: *`(20, 15)` por defecto*. Tamaño de la figura final resultante.\n", + "\n", + "**Salida(s)**:\n", + "* `matplotlib.figure.Figure`: Figura del plano con las palabras graficadas.\n", + "\n", + "> **Notar**: siempre de base se utiliza el objeto de tipo `Embedding` empleado para la instanciación de esta clase, si el método de obtención de vecinos es distinto al seteado en la creación del objeto `Embedding`, se cargará este nuevo método lo cuál puede llevar un mayor tiempo de obtención de vecinos en la primera ejecución debido a la carga e inicialización del nuevo método." + ], + "metadata": { + "id": "D7H2ivkNWH01" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos un ejemplo con dos listas de palabras (reducimos el tamaño de la figura para encuadrar en esta *Google colab*)." + ], + "metadata": { + "id": "BVjooQOWa8lY" + } + }, + { + "cell_type": "code", + "source": [ + "lista_pesado = ['gordo', 'gorda']\n", + "lista_belleza = ['lindo', 'linda']" + ], + "metadata": { + "id": "H7p07RoYbLRu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "we.plot_projections_2d(\n", + " wordlist_0 = lista_pesado, \n", + " wordlist_1 = lista_belleza,\n", + " figsize=(10, 10)\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 729 + }, + "id": "LXIxdHn7bWra", + "outputId": "e3d3222c-9435-481c-c53b-a5e2d42ed215" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Como vimos con los parametros que acepta este metodo, podemos cambiar el color de las palabras en `lista_pesado`, aumentar el tamaño de la letra y ver dos vecinos de las palabras ingresadas." + ], + "metadata": { + "id": "bPAWoHfKbuvf" + } + }, + { + "cell_type": "code", + "source": [ + "we.plot_projections_2d(\n", + " wordlist_0 = lista_pesado, \n", + " wordlist_1 = lista_belleza, \n", + " color_wordlist_0 ='#fcba03',\n", + " fontsize = 25,\n", + " n_neighbors = 2,\n", + " figsize = (10, 10)\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 728 + }, + "id": "jo66uYnrb7j8", + "outputId": "12e9585a-aacd-4840-8957-b4d0f1810432" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "> **Notar**: El color de las listas de palabras afecta al color de los vecinos de las palabras dentro de ella para diferenciar su prosedencia.\n", + "\n", + "Si alguna palabra de las listas no esta presente en el vocabulario del objeto `Embedding` utilizado para la instanciación de la clase se levanta una excepción de error indicando el motivo. Esto tambien sucede si todas las listas de palabras estan vacias" + ], + "metadata": { + "id": "Ioiy5nE_cn5f" + } + }, + { + "cell_type": "code", + "source": [ + "# Palabra fuera de vocabulario (OOV)\n", + "we.plot_projections_2d(\n", + " wordlist_0 = palabras_no_presentes,\n", + " figsize = (10, 10)\n", + ")" + ], + "metadata": { + "id": "uuEZ9Ve9dUxV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Sin palabras a graficar\n", + "we.plot_projections_2d(\n", + " wordlist_0 = [],\n", + " figsize = (10, 10)\n", + ")" + ], + "metadata": { + "id": "dXn2jgamdkAG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Sesgo en las palabras" + ], + "metadata": { + "id": "mMizQs6jV6ls" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Objectivo\n", + "\n", + "Muchas palabras cargan consigo sesgos latentes originados de los **grandes volumenes** de ejemplos con los cuales se entrenaron los modelos para calcular las respresentaciones vectoriales de las mismas.\n", + "\n", + "Para identificar la presencia de sesgo en una palabra, se deben definir nucleos de significados opuestos con el objetivo de corroborar la presencia del mismo debido a una tendencia injustificada.\n", + "\n", + "Por ejemplo, si definimos núcleos de significado opuestos como *femenino* y *masculino*, esperariamos que palabras como *profesora*, *esposa* o *mujer* esten más cercanas al núcleo *femenino*, mientras que palabras como *hombre*, *esposo* o *carpintero* más cerca al núcleo *masculino*; sin embargo , palabras neutras como *astronauta* esperariamos que esten equisdistantes de ambos núcleos por no haber un género predilecto para esta palabra de profesión.\n", + "\n", + "Con este ejemplo, queremos dejar en evidencia como las palabras contienen componentes con sesgos latentes (más allá del caracter de género), lo que limita y perjudica la calidad de los modelos de inteligencia artificial y tareas relacionadas al procesamiento del lenguaje natural (PLN)." + ], + "metadata": { + "id": "SdEamam2bqka" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase WordBiasExplorer\n", + "\n", + "Esta clase, instanciada a partir de un objeto `Embedding`, es padre de dos subclases de interes a describir. En sí, esta clase contienen métodos de operaciones de vectores basados en la herramienta `Responsibly` donde se cuenta con una [explicación detallada](https://github.com/ResponsiblyAI/responsibly/blob/master/responsibly/we/bias.py) de los mismos, omitidos aquí." + ], + "metadata": { + "id": "YD9mQycwiguV" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_BiasExplorer import WordBiasExplorer" + ], + "metadata": { + "id": "D1e9ZRlzqbvZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, solo se requiere un parámetro:\n", + "* `embedding (Embedding)`: Objeto de tipo `Embedding` de la cuál obtener el vocabulario disponible junto a la información del mismo como son los embeddings, PCA o vecinos." + ], + "metadata": { + "id": "D3o0qrfaqgp0" + } + }, + { + "cell_type": "code", + "source": [ + "wbe = WordBiasExplorer(emb)" + ], + "metadata": { + "id": "PykhxD7Rqhm1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método check_oov(...)\n", + "\n", + "Verifica que todas las palabras que el usuario ingresa estan presentes en el objeto `Embedding` para la extracción de su información.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlists (List[List[str]])`: Lista de listas de palabras a verificar su presencia en el objeto `Embedding` utilizado en la instanciacón actual de la clase `WordExplorer`.\n", + "\n", + "**Salida(s)**:\n", + "* `None` o `str` con mesaje de error explicitando la palabra fuera de vocabulario." + ], + "metadata": { + "id": "GAW-PZIzkFhq" + } + }, + { + "cell_type": "markdown", + "source": [ + "Ejemplos analogos a los vistos en la clase `WordExplorer`." + ], + "metadata": { + "id": "DquoDCLWkW-e" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase WEBiasExplorer2Spaces\n", + "\n", + "Esta clase hereda de su padre, `WordBiasExplorer`, los métodos requeridos para el cálculo y gráfico de sesgos de palabras frente a dos núcleos de significado (o espacios de significado)." + ], + "metadata": { + "id": "r36tT7q1kc1L" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_BiasExplorer import WEBiasExplorer2Spaces" + ], + "metadata": { + "id": "HI-NPbskqs2s" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, solo se requiere un parámetro:\n", + "* `embedding (Embedding)`: Objeto de tipo `Embedding` de la cuál obtener el vocabulario disponible junto a la información del mismo como son los embeddings, PCA o vecinos." + ], + "metadata": { + "id": "P-5_t4PHq0y7" + } + }, + { + "cell_type": "code", + "source": [ + "wbe_2_nucleos = WEBiasExplorer2Spaces(emb)" + ], + "metadata": { + "id": "sQhfdAiMq28W" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método calculate_bias(...)\n", + "\n", + "Calcula y grafica mediante barras las distancias de palabras de interes frente a dos núcleos de signficado opuestos para comporbar la presencia de sesgo.\n", + "\n", + "Recordar que la presencia y tipo de sesgos depende en gran parte por las palabras con las cuales se define un núcleo de significado y puede requerir un análisis detallado por parte de un experto de dominio para obtener resultados concretos y que expongan de forma clara el sesgo.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlist_to_diagnose (List[str])`: Lista de palabras a evaluar la presencia de sesgo frente a dos núcleos de significado.\n", + "* `wordlist_right (List[str])`: Lista de palabras que definen un núcleo de significado.\n", + "* `wordlist_left (List[str])`: Lista de palabras que definen el otro núcleo de significado (preferentemente opuesto al primero, `wordlist_right`).\n", + "\n", + "**Salida(s)**:\n", + "* `matplotlib.figure.Figure`: Figura de barra con las palabras y sus distancias de ambos núcleos." + ], + "metadata": { + "id": "eC30XpUtlTFQ" + } + }, + { + "cell_type": "markdown", + "source": [ + "Probemos esta funcionalidad con el ejemplo dado previamente." + ], + "metadata": { + "id": "EbeCVNNLqPWm" + } + }, + { + "cell_type": "code", + "source": [ + "palabras_para_evaluar = ['profesora', 'esposa', 'mujer', 'hombre', 'profesor', 'carpintero', 'astronauta']" + ], + "metadata": { + "id": "hoyHc56Yq-Fu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "nucleo_femenino = ['femenino', 'ella', 'mujer', 'chica']" + ], + "metadata": { + "id": "ixAxUQCxrdC8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "nucleo_masculino= ['masculino', 'el', 'hombre', 'chico']" + ], + "metadata": { + "id": "cH-9pMvZrkbM" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "wbe_2_nucleos.calculate_bias(\n", + " wordlist_to_diagnose = palabras_para_evaluar,\n", + " wordlist_right = nucleo_femenino,\n", + " wordlist_left = nucleo_masculino\n", + ")" + ], + "metadata": { + "id": "edXhQlrCrspI" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Observamos como la palabra *astronauta* contiene un ligero sesgo en su componente de género al masculino.\n", + "\n", + "Tener en cuenta que, todas las listas de palabras deben tener al menos una palabra en ellas, todas las palabras deben estar presentes en el vocabulario y la definición de núcleos no deben ser las mismas, de los contrario se arrojaran excepciones de error para cada situación." + ], + "metadata": { + "id": "-RdelGTmsO-x" + } + }, + { + "cell_type": "code", + "source": [ + "# Palabra fuera de vocabulario (OOV)\n", + "wbe_2_nucleos.calculate_bias(\n", + " wordlist_to_diagnose = palabras_no_presentes,\n", + " wordlist_right = nucleo_femenino,\n", + " wordlist_left = nucleo_masculino\n", + ")" + ], + "metadata": { + "id": "nFAO8J8gsv7U" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Listas vacias\n", + "wbe_2_nucleos.calculate_bias(\n", + " wordlist_to_diagnose = palabras_para_evaluar,\n", + " wordlist_right = [],\n", + " wordlist_left = nucleo_masculino\n", + ")" + ], + "metadata": { + "id": "oGgunvo2tARE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Misma definición de núcleos\n", + "# Palabra fuera de vocabulario (OOV)\n", + "wbe_2_nucleos.calculate_bias(\n", + " wordlist_to_diagnose = palabras_para_evaluar,\n", + " wordlist_right = nucleo_femenino,\n", + " wordlist_left = nucleo_femenino\n", + ")" + ], + "metadata": { + "id": "F-yro2wEtJ0I" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Clase WEBiasExplorer4Spaces\n", + "\n", + "Esta clase hereda de su padre, `WordBiasExplorer`, los métodos requeridos y extiende la funcionalidad de la clase `WEBiasExplorer2Spaces` para el cálculo y gráfico de sesgos de palabras frente a cuatro núcleos de significado (o espacios de significado).\n", + "\n", + "En cierta ocaciones, es de interés **subdividir** los dos núcleos de significado propuestos en un inicio en busca de **sesgos más concretos o especificos**. Por ejemplo, en nuestra busqueda de palabras sesgadas por el género *femenino* y *masculino* nos podria ser de interés agregar el componente de edades; de esta forma podriamos conocer aquellas palabras con tendencia por los modelos a conciderarse *femenino* y *joven*, *femenino* y *adulto* o los demás casos." + ], + "metadata": { + "id": "lO4u3Rw0x8E-" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_BiasExplorer import WEBiasExplorer4Spaces" + ], + "metadata": { + "id": "6MjumNlA2HmF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, solo se requiere un parámetro:\n", + "* `embedding (Embedding)`: Objeto de tipo `Embedding` de la cuál obtener el vocabulario disponible junto a la información del mismo como son los embeddings, PCA o vecinos." + ], + "metadata": { + "id": "YHDuzlmi2LNg" + } + }, + { + "cell_type": "code", + "source": [ + "wbe_4_nucleos = WEBiasExplorer4Spaces(emb)" + ], + "metadata": { + "id": "3LMl4TfG2Os1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método calculate_bias(...)\n", + "\n", + "Calcula y grafica un plano subdividido en cuatro cuadrantes (representantes de los núcleos) la posición de las palabras y las distancias a considerar frente a cada núcleo individual.\n", + "\n", + "Recordar que la presencia y tipo de sesgos depende en gran parte por las palabras con las cuales se define un núcleo de significado y puede requerir un análisis detallado por parte de un experto de dominio para obtener resultados concretos y que expongan de forma clara y real el sesgo.\n", + "\n", + "**Entrada(s)**:\n", + "* `wordlist_to_diagnose (List[str])`: Lista de palabras a evaluar la presencia de sesgo frente a dos núcleos de significado.\n", + "* `wordlist_right (List[str])`: Lista de palabras que definen un núcleo de significado.\n", + "* `wordlist_left (List[str])`: Lista de palabras que definen otro núcleo de significado (preferentemente opuesto al primero, `wordlist_right`).\n", + "* `wordlist_top (List[str])`: Lista de palabras que definen otro núcleo de significado que **subdivirá** los núcleos definidos enteriormente (`wordlist_right`, `wordlist_left`).\n", + "* `wordlist_bottom (List[str])`: Lista de palabras que definen otro núcleo de significado que **subdivide** el espacio (preferentemente opuesto al anterior, `wordlist_top`).\n", + "\n", + "**Salida(s)**:\n", + "* `matplotlib.figure.Figure`: Figura de plano dividido en cuadrantes y con puntos etiquetados con las palabras dentro de él." + ], + "metadata": { + "id": "n22BGdGozfBI" + } + }, + { + "cell_type": "markdown", + "source": [ + "Evaluemos el ejemplo dado de dividir la componente de género en edades." + ], + "metadata": { + "id": "cBA5gozy1fqA" + } + }, + { + "cell_type": "code", + "source": [ + "nucleo_joven = ['joven', 'inmaduro', 'niño', 'crio']\n", + "nucleo_adulto = ['viejo', 'maduro', 'anciano', 'adulto']" + ], + "metadata": { + "id": "VYwQcgZq1oOT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "wbe_4_nucleos.calculate_bias(\n", + " wordlist_to_diagnose = palabras_para_evaluar,\n", + " wordlist_right = nucleo_femenino,\n", + " wordlist_left = nucleo_masculino,\n", + " wordlist_top = nucleo_joven,\n", + " wordlist_bottom = nucleo_adulto\n", + " )" + ], + "metadata": { + "id": "bHeGKZZR2RAT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Al igual que sucede con `WEBiasExplorer2Spaces`, todas las listas deben contener al menos una palabra, todas las palabras deben estar presentes en el vocabulario del objeto `Embedding` suministrado como parámetro para la instanciación del objeto y la definición de los núcleos de significado no pueden coincidir.\n", + "\n", + "Para ejemplos concretos referirse a `WEBiasExplorer2Spaces`." + ], + "metadata": { + "id": "5nakMYz32_-0" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Exploración de datos" + ], + "metadata": { + "id": "nt3jk_pC7ob2" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Objetivo\n", + "\n", + "Actualmente existen muchos *datasets* de entrenamiento, algunos de ellos muy populares en el área de PLN, sin embargo, sin contar con estrategias claras de mitigación se sesgo ha llevado a que la mayoria cuenten con ejemplos sesgados por el cual modelos resultantes se ven afectados.\n", + "\n", + "En este apartado, brindamos funcionalidades que permiten **explorar** datasets, concretamente aquellos con los cuales fue entrenado **BETO** y evidenciar sesgos latentes dentro de ellos.\n", + "\n", + "> **Importante**: Actualmente no se cuenta con la funcionalidad de **carga de corpus propios** para la exploración, pero detallaremos la clase `Vocabulary` para dar una idea de la estructura necesaria si se deseara realizar una exploración propia.\n" + ], + "metadata": { + "id": "GL9k5Y0J74IC" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase Vocabulary\n", + "\n", + "El rol de esta clase, similar a `Embedding`, es de ser un **núcleo centralizado de información** necesaria para dar soporte a los requerimientos de información de aquellas clases que la requieran.\n", + "\n", + "Para cargar esta clase, ejecutamos la siguiente celda." + ], + "metadata": { + "id": "btyO7TE8_y3O" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_vocabulary import Vocabulary" + ], + "metadata": { + "id": "CbQcw-s4A9XQ" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Actualmente esta clase se carga suministrando el nombre de partición adecuado, todos disponibles en [GitHub](https://github.com/git-lu/notebook_bias_tools#setup-data). Estas particiones se tratan de archivos `.json` comprimidas dentro de un `.zip`. Es así como para instanciar un objeto de esta clase se requiere:\n", + "* `subset_name (str)`: Nombre de la partición descargada y presente dentro del directorio `data/`." + ], + "metadata": { + "id": "eTtIr5kV8ZG4" + } + }, + { + "cell_type": "code", + "source": [ + "vocab = Vocabulary('quarter')" + ], + "metadata": { + "id": "zIhBYW_s87lz", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ee7fd83e-4af2-4c21-bb03-c5a7836d590a" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Preparing quarter vocabulary...\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "De desear realizar una **exploración propia**, se requiere el archivo `.json` adecuado, para ello explicitaremos en las siguientes lineas las columnas y valores esperados:\n", + "\n", + "El archivo `.json` se compone de cinco columnas:\n", + "* `word`: se asocia un *identificador* (`str`) a cada palabra. De esta forma, toda la información de una palabra se indexa sobre su *identificador*.\n", + "* `freq`: se asocia al *identificador* la frequencia total (`int`) de la palabra dentro del(os) corpus propio(s).\n", + "* `percentile`: se asocia al *identificador* el percentil (`float`) de la palabra dentro del(os) corpus propio(s). Este valor indica porcentualmente que, en terminos de distribución, está por encima de las demás (*i.e* a mayor percentil, mayor es la probabilidad de ocurrencia de la palabra asociada en el corpus).\n", + "* `splits`: Para mayor eficiencia en busqueda sobre corpus de gran volumen ya sean uno o más, aconsejamos particionarlos en bloques (por ejemplo, bloques de 10Mb). Esta columna es un arreglo (`List[str]`) que asigna a cada *identificador* los nombres de bloques donde esta palabra se encuentra.\n", + "* `in_subset`: asocia a cada *identificador* un diccionario (`Dict[str, int]`) donde las llaves son los corpus (`str`), y los valores son la frecuencia total dentro del corpus (`int`).\n", + "\n", + "> **Notar**: La suma de todos los valores del diccionario en `in_subset` de un *identificador* debe ser igual a la frecuancia total presente en `freq` para el mismo identificador.\n", + "\n", + "\n", + "```json\n", + "{\n", + " \"word\": {\n", + " \"1\": \"Hola\",\n", + " [...]\n", + " },\n", + " \"freq\": {\n", + " \"1\": 250000,\n", + " [...]\n", + " },\n", + " \"percentile\": {\n", + " \"1\": 0.8845,\n", + " [...]\n", + " },\n", + " \"splits\": {\n", + " \"1\": [\"Corpus_1_bloque_4\", \"Corpus_1_bloque_2\", \"Corpus_8_bloque_2\"],\n", + " [...]\n", + " },\n", + " \"in_subset\": {\n", + " \"1\": {\n", + " \"Corpus_1\": 150000,\n", + " \"Corpus_8\": 100000\n", + " },\n", + " [...]\n", + " }\n", + "}\n", + "```" + ], + "metadata": { + "id": "c8c4ozHcBD9e" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase Word2Context\n", + "\n", + "Esta clase cuenta con las funcionalidades previstas para la exploración de las palabras dentro del curpus. Podemos conocer frecuencias de las palabras, obtener graficos de nube o de distribución e incluso obtener contextos de una palabra dada para evaluar la presencia de sesgo." + ], + "metadata": { + "id": "ofI_CRDWMSeT" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_word2Context import Word2Context" + ], + "metadata": { + "id": "MtzSiK1xM-A2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Esta clase es de ayuda en ocaciones donde nuestra exploración de palabras y sus sesgos exponen comportamientos extraños, como podria ser la presencia de palabras \"*raras*\" vecinas, aquí la exploración de los contextos de las palabras, tanto la evaluada como la \"*rara*\", nos es de ayuda a entender el suceso presente.\n", + "\n", + "Para instanciar esta clase se requiere:\n", + "* `context_ds_name (str)`: nombre del dataset cargado en HuggingFace🤗.\n", + "* `vocabulary (Vocabulary)`: Objeto de tipo `Vocabulary` del cuál extraer la información requerida. Define el vocabulario disponible para el usuario.\n", + "\n", + "> **Importante**: Para una **exploración propia**, actualmente los bloques generados de los corpus deben cargarse como un dataset a la plataforma HuggingFace🤗. Deben encontrarse dentro de una carpeta `data/` la cuál a su vez debe contener un directorio por corpus con su nombre correspondiente dentro del cuál se encuentran los bloques definidos. [Aquí](https://huggingface.co/datasets/vialibre/splittedspanish3bwc) dejamos un ejemplo.\n", + "\n" + ], + "metadata": { + "id": "kxTQ1CpKNAwK" + } + }, + { + "cell_type": "code", + "source": [ + "w2c = Word2Context('vialibre/splittedspanish3bwc', vocab)" + ], + "metadata": { + "id": "KZV9ZwVBQTFW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método errorChecking(...)\n", + "\n", + "Verifica que la palabra que el usuario ingresa esta presente en el objeto `Vocabulary` para la extracción de su información.\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra a verificar su presencia en el objeto `Vocabulary` utilizado en la instanciacón actual de la clase `Word2Context`.\n", + "\n", + "**Salida(s)**:\n", + "* `str` con mesaje de error explicitando la palabra fuera de vocabulario, o vacio si la palabra se encuentra presente." + ], + "metadata": { + "id": "Jp9IINBeQeiN" + } + }, + { + "cell_type": "code", + "source": [ + "# Palabra presente en ocabulario\n", + "w2c.errorChecking('mujer')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "kJR7lracRMN0", + "outputId": "d7aeac51-22c8-4ceb-d134-bb8de4ba2d8b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "''" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Palabra fuera de vocabulario (OOV)\n", + "w2c.errorChecking('falafel')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "jD_SP6EhRV0J", + "outputId": "231ed03a-164f-41eb-b834-ec1889b7a3ea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\"Error: La palabra 'falafel' no se encuentra en el vocabulario!\"" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Las funciones de interes siempre realizan este chequeo previo, de esta forma no hay una necesidad explicita por parte del usuario de instaciarlo en todas las iteraciones." + ], + "metadata": { + "id": "v5kKa-lRRY9Q" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Método genWordCloudPlot(...)\n", + "\n", + "Genera un [gráfico de nube](https://es.wikipedia.org/wiki/Nube_de_palabras) con la palabra brindada por el usuario y otras asociadas; estas palabras son los diez primeras inmediatamente con mayor frecuencia total y las diez con menor frecuencia total por debjo de la palabra suministrada. \n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra central para la obtención de sus vecinas y generar el gráfico de nube.\n", + "* `figsize (Tuple[int, int])`: *`(9, 3)` por defecto*. Tamaño de la figura final resultante.\n", + "\n", + "**Salida(s)**:\n", + "* `matplotlib.figure.Figure`: Figura de la nube de palabras. Las diez con frencuencia superor a `word` son coloreadas en gris, las diez con frecuencia menor en celeste, y la de interés en naranja." + ], + "metadata": { + "id": "JnFTqScZRjRb" + } + }, + { + "cell_type": "code", + "source": [ + "w2c.genWordCloudPlot('mujer')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 225 + }, + "id": "-36dcC3CUsvV", + "outputId": "fb0dffb4-cbd5-406e-c707-d286bcbf3d1f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método genDistributionPlot(...)\n", + "\n", + "Genera un **gráfico de distribucion** de las palabras utilizando los percentiles, resaltando la brindada por el usuario.\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra brindada por el usuario a resaltar en el gráfico.\n", + "* `figsize (Tuple[int, int])`: *`(6, 1)` por defecto*. Tamaño de la figura final resultante.\n", + "\n", + "**Salida(s)**:\n", + "* `matplotlib.figure.Figure`: Figura de la distribución de las palabras." + ], + "metadata": { + "id": "64X5GjmqTKoe" + } + }, + { + "cell_type": "code", + "source": [ + "w2c.genDistributionPlot('mujer', figsize=(15, 4))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "jWbeC80fUUbJ", + "outputId": "c6796feb-289a-4f94-d97e-cb3fab58a665" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método getSubsetsInfo(...)\n", + "\n", + "Genera un diccionario con los corpus donde la palabra brindada esta presente junto a su frecuencia total y el percentil.\n", + "\n", + "Este diccionario tiene como llave un `str` el cual se compone del nombre del corpus seguido de la frecuencia, y como valor el percentil de la palabra dentro del corpus (`float`). (Ejemplo, `{'Corpus_1 (25000)': 0.08235}`\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra brindada por el usuario para extraer información del objeto `Vocabulary`.\n", + "\n", + "**Salida(s)**:\n", + "* `Tuple[str, Dict[str, float]]` el primer componente de la tupla es codigo HTML para la visualización en HuggingFace🤗, se tratan de las barras de frecuencia por conjunto. La salida de interés es la segunda que contiene el diccionario previamente descripto." + ], + "metadata": { + "id": "Aa16YMtWVdf1" + } + }, + { + "cell_type": "code", + "source": [ + "_, so = w2c.getSubsetsInfo('mujer')\n", + "so" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KyvDXgkbWq4k", + "outputId": "da5e5a2c-5020-4c43-e0db-7066095ea8c0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'OpenSubtitles2018 (634802)': 0.5784895165053073,\n", + " 'multiUN (242211)': 0.2207247681675026,\n", + " 'allwikis (120547)': 0.10985342791321591,\n", + " 'ParaCrawl (60716)': 0.05532996034060422,\n", + " 'EUBookShop (18460)': 0.016822436719934677,\n", + " 'GlobalVoices (5977)': 0.005446787880555232,\n", + " 'Europarl (5733)': 0.005224432812317742,\n", + " 'DOGC (4198)': 0.0038256007232007464,\n", + " 'UN (1841)': 0.0016776872156771259,\n", + " 'TED (704)': 0.0006415490493409541,\n", + " 'EMEA (697)': 0.0006351700104980754,\n", + " 'JRC (523)': 0.0004766053306893736,\n", + " 'NewsCommentary11 (419)': 0.00038183103930945994,\n", + " 'DGT (401)': 0.0003654277965706287,\n", + " 'ECB (115)': 0.00010479849527586609}" + ] + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Este método esta fuertemente relacionado con el siguiente, pues nos dá a conocer los corpus en los cuales la palabra `word` esta presente." + ], + "metadata": { + "id": "Srczk_7JZ8cC" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Método findSplits(...)\n", + "\n", + "Genera un arreglo a partir de los corpus dados para la busqueda de contextos.\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra brindada por el usuario para extraer información del objeto `Vocabulary`.\n", + "* `subsets_list (List[str])`: Lista de nombre de corpus elegidos por el usuario para poder recuperar pequeños bloques aleatorios, que contengan la palabra de interés buscada, `word`. Tales nombres, son tomados del diccionario generado por `getSubsetsInfo(...)`\n", + "\n", + "\n", + "**Salida(s)**:\n", + "* `datasets.iterable_dataset.IterableDataset`, cada componente de este objeto es un bloque tomado aleatoriamente para representar al corpus suministrado en `subsets_list`. Estructura es requerida para la busqueda de contextos. " + ], + "metadata": { + "id": "rJN0HFY_aE5x" + } + }, + { + "cell_type": "code", + "source": [ + "ds = w2c.findSplits('mujer', ['OpenSubtitles2018', 'multiUN'])" + ], + "metadata": { + "id": "PXfUr87fcWpv" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Se omiten aquellos corpus donde la palabra no esta presente." + ], + "metadata": { + "id": "64OycfXKcpL_" + } + }, + { + "cell_type": "code", + "source": [ + "w2c.findSplits('mujer', ['OpenSubtitles2018', 'multiUN', 'corpusImaginario'])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dAiUjrazctF2", + "outputId": "82aac91f-03b0-432d-a756-fea702f85473" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 40 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método getContexts(...)\n", + "\n", + "Genera un arreglo con los contextos aleatorios encontrados de una palabra.\n", + "\n", + "**Entrada(s)**:\n", + "* `word (str)`: palabra brindada por el usuario para buscar contextos. Presente en `Vocabulary`.\n", + "* `n_context (int)`: Número de contextos máximo a retornar.\n", + "* `ds (datasets.iterable_dataset.IterableDataset)`: Estructura de bloques representantes de los corpus. Tipicamente obtenido al llamar el método `fndSplits(...)`.\n", + "\n", + "**Salida(s)**:\n", + "* `List[Tuple(int, str, str)]` Lista de contextos identificados por un entero (`int`), seguido del contexto (`str`) y corpus origen del mismo (`str`)" + ], + "metadata": { + "id": "xMlS_cpqc4VC" + } + }, + { + "cell_type": "code", + "source": [ + "contextos = w2c.getContexts('mujer', 10, ds)\n", + "contextos" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3DMNbX5id01V", + "outputId": "1ea7e850-50db-49c9-aa93-fc49af053f7c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[(0,\n", + " 'nunca conocí una mujer que trabaje en un negocio empresarial.',\n", + " 'OpenSubtitles2018_624'),\n", + " (1,\n", + " 'no conozco a ninguna mujer que dirige una compañía y menos una como usted.',\n", + " 'OpenSubtitles2018_624'),\n", + " (2,\n", + " 'no hay mucho disponible para que la mujer se proteja de un caballero excitado.',\n", + " 'OpenSubtitles2018_624'),\n", + " (3, '¡qué mujer hubiera sido!', 'OpenSubtitles2018_624'),\n", + " (4,\n", + " 'los hombres siempre quieren desahogarse con una mujer sin pensar en las consecuencias, bebés y enfermedades.',\n", + " 'OpenSubtitles2018_624'),\n", + " (5,\n", + " 'bueno, mi hermano no puede decirle nunca que no a una mujer linda y tú eres la más linda del lugar.',\n", + " 'OpenSubtitles2018_624'),\n", + " (6,\n", + " 'la capacidad de una mujer de planificar su vida reproductiva depende de su posibilidad de acceder a todos los métodos anticonceptivos.',\n", + " 'multiUN_6'),\n", + " (7,\n", + " 'en el decenio de 1990 se celebraron diversas conferencias, como la conferencia mundial de derechos humanos, la cuarta conferencia mundial sobre la mujer y la cumbre mundial sobre desarrollo social, en las que se reafirmaron los derechos reproductivos.',\n", + " 'multiUN_6'),\n", + " (8,\n", + " 'quizás es por la mujer que nunca llegó a ser.',\n", + " 'OpenSubtitles2018_624'),\n", + " (9,\n", + " 'el presente informe se centra en las experiencias prácticas de los países y en los progresos realizados en la aplicación del programa de acción de la conferencia internacional sobre la población y el desarrollo1 y las conclusiones del vigésimo primer período extraordinario de sesiones de la asamblea general para revisar y evaluar globalmente la ejecución del programa de acción, especialmente en lo relacionado con el vih/sida y la planificación familiar, la mortalidad materna, las infecciones de transmisión sexual, la salud reproductiva y sexual de los adolescentes, la igualdad entre hombres y mujeres y la emancipación de la mujer.',\n", + " 'multiUN_6')]" + ] + }, + "metadata": {}, + "execution_count": 43 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "> **Notar**: la ejecución iterativa retorna resultados distintos por tratarse de una busqueda aleatoria. Además, debido a esta aleatoriedad los contextos encontrados puede ser **menor** a lo estipulado en el parámetro `n_context`.\n", + "\n", + "Podemos procesar el resultado anterior para observar únicamente los contextos de la palabra *mujer* y eliminar las etiquetas de HTML." + ], + "metadata": { + "id": "FoPgcJKAd-7e" + } + }, + { + "cell_type": "code", + "source": [ + "contextos_procesados = [contexto[1].replace('', '').replace('', '') for contexto in contextos]\n", + "contextos_procesados" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aLPdy8NmeYrH", + "outputId": "8a9c8e9b-53f1-4f19-9e5e-e6c009142257" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['nunca conocí una mujer que trabaje en un negocio empresarial.',\n", + " 'no conozco a ninguna mujer que dirige una compañía y menos una como usted.',\n", + " 'no hay mucho disponible para que la mujer se proteja de un caballero excitado.',\n", + " '¡qué mujer hubiera sido!',\n", + " 'los hombres siempre quieren desahogarse con una mujer sin pensar en las consecuencias, bebés y enfermedades.',\n", + " 'bueno, mi hermano no puede decirle nunca que no a una mujer linda y tú eres la más linda del lugar.',\n", + " 'la capacidad de una mujer de planificar su vida reproductiva depende de su posibilidad de acceder a todos los métodos anticonceptivos.',\n", + " 'en el decenio de 1990 se celebraron diversas conferencias, como la conferencia mundial de derechos humanos, la cuarta conferencia mundial sobre la mujer y la cumbre mundial sobre desarrollo social, en las que se reafirmaron los derechos reproductivos.',\n", + " 'quizás es por la mujer que nunca llegó a ser.',\n", + " 'el presente informe se centra en las experiencias prácticas de los países y en los progresos realizados en la aplicación del programa de acción de la conferencia internacional sobre la población y el desarrollo1 y las conclusiones del vigésimo primer período extraordinario de sesiones de la asamblea general para revisar y evaluar globalmente la ejecución del programa de acción, especialmente en lo relacionado con el vih/sida y la planificación familiar, la mortalidad materna, las infecciones de transmisión sexual, la salud reproductiva y sexual de los adolescentes, la igualdad entre hombres y mujeres y la emancipación de la mujer.']" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Exploración de sesgos en frases" + ], + "metadata": { + "id": "OsplHNluSxTH" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Objetivo\n", + "\n", + "El sesgo presente en las oraciones o frases es el que generalmente solemos identificar con mayor facilidad en textos, por el contexto mismo en el que estan inmersos. Conmunmente, estas frases sesgadas presentan componentes como son un **objetivo**, ya sea *individual* o *colectivo*, y una **propiedad** asiganda a dicho objetivo.\n", + "\n", + "Actualmente, muchos modelos de lenguaje pre-entrenados en grandes volumenes de datos se ven sesgados por la presencia de estos ejemplos negativos, lo cuál interfiere en su aprendizaje. Este último no puede ser evaluado analíticamente como con las palabras, pero si es posible un análisis en base a preferencias de los modelos. De esta forma podemos evaluar la **tendencia de los modelos de lenguaje de generar lenguaje sesgado**." + ], + "metadata": { + "id": "zaAG7swSS48c" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase LanguageModel\n", + "\n", + "Esta clase es sencilla y se encarga de descargar y cargar el modelo de lenguaje deseado disponible en HuggingFace🤗.\n", + "\n", + "Estos modelos son requeridos para la instanciación de las siguientes clases para obtener el modelo en sí y su `tokenizer`." + ], + "metadata": { + "id": "iRKPKNxg_ROs" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_languageModel import LanguageModel" + ], + "metadata": { + "id": "w32mgIfZ_SAZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "Para instanciar un objeto de esta clase, solo se requiere de:\n", + "* `model_name (str)`: Nombre del modelo pre-entrenado basado en **BERT** disponible en la plataforma de [HuggingFace🤗](https://huggingface.co/models?sort=downloads&search=bert).\n", + "\n", + "> Es posible la utilización de modelos **no** basados en **BERT**, pero estos deben poder ser cargados mediante la clase de HuggingFace🤗 `AutoModelForMaskedLM` y método `from_pretrained(...)`.\n", + "\n", + "Cargemos para la utilización y evaluación de las proximas clases el modelo **BETO**." + ], + "metadata": { + "id": "rAojV8639NJg" + } + }, + { + "cell_type": "code", + "source": [ + "beto_lm = LanguageModel(\n", + " model_name = 'dccuchile/bert-base-spanish-wwm-uncased'\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 226, + "referenced_widgets": [ + "dd7ea29cbf45492aa7d9619436257b7a", + "5bb2969e49a7406e927f71b05c3a8b01", + "7eaa9df4df314ae493476b2108c9f4b0", + "1a621b8f37fb4e9d93d1bee764bddc10", + "ad8d626a25174b10907e7c0f0dbfa4e2", + "8d1df935e1514525919c7cb144a9e9bf", + "6208b8b0bd384f9bb4f0700a2e792d99", + "297eb7c5adc54eb8aa296e2156f3c517", + "561fac1acc44444d85efb123894efb3b", + "fbe8cfaf42a54526ab4a140a93ef1ba1", + "61c4bd1bb84f412f832167d185f2d838", + "c0d2e99f38964c3b989959a4e0d6c45f", + "6402e4fd9316464f8fcdd1d1a7b6467a", + "4f79672af44d435ea4c9c52da886c72f", + "91ee29d8037a41b0b77bfa924697a6f1", + "fa30e340cbf845178f1a2cec3ce8fea4", + "84a5687036304b59b7732f6e57519c41", + "0c849f288df74763ae71cc27ca8f6f0e", + "d3e48bc15d9540779409940c982efa73", + "866903d85ec840a1824da788ec33307e", + "202c2d7e7f05406e9577812e2950b15d", + "4f9771efea5048ab9c717ad555a16d8e", + "9785af70e5cb4ce68566d16c49486f1c", + "3336003ca5bf4676956e77de2959d1be", + "095b3ae26524495ca7449f116f155c6c", + "12c88d15946e411391b1ff24bcd7a974", + "a1fe63c2c09d415ebe5d960e35ae0463", + "9508a7d5b8d046d7aeabb1ab8cbd00c0", + "15c46e829d464387ac3d85943f1f3784", + "438f5269cee64873bdd5ce7acf924771", + "e19c435edc4748b9b7b76f05d7d8b67e", + "49293c009052435ba9e6148ef832ec23", + "bcf8aca4dcdd42ae8690a3d085a89756", + "7e5f29c8b1774893b2c90e239d27e812", + "5d5978a1ed4d417ca503f63a5cdb5b6f", + "e2b283be81e84d5aa9ddce2a4f100afd", + "fdefd35d08a04c9496050dadfe760472", + "e091a90cc72343e78073122f880571be", + "5c26e2e4c72b48d890a49d2a5cf2d39d", + "f5561c3264df4ebea20fa2241522ae99", + "f314a82e7f444107b5aa0f31faa2ff4a", + "06949775b9aa4494a0718ad819d7eab6", + "bf9d4ba9f8c543a7b32a16c7ff860b54", + "4bf64c365cba476395463a0771327275", + "4403a625b17e43d48cef297f91f359d8", + "532a0246a2114a46a4c64ccfd920ec09", + "d0f10f02b16b4075b6641d392ad018ea", + "e272fe8c64834f51b0cfb365e59e1b58", + "08f786c6fae04bf8b974c5ad44765d5f", + "0c2f4b6f1c8c49dca165d51956ad351f", + "ed12c8634b594cab8e6a4392076ac827", + "c9f6721eebdc46f9a07464e6cf76d3c7", + "27ae791395b746fd810db9ac97417744", + "2de8ea83c23c4d5cbf73a2f8af90ae60", + "53630686cfd545efafe6af86ad8357ec", + "9c130ae949164699936cac5e35124557", + "4cdadc79fee24b958a7f9880b723eb03", + "a3fa08bb164a4a88bc06833ceb658deb", + "7675f997bad34d5cadceff7ff3166b3b", + "43cf9bf963ac487f8c6e1d718a309c61", + "e63b9d54f8bf4f419d596449eec18913", + "c834e1fa5ae04b77bf0eac066807a5a3", + "af5f095d729c4f7b8fa5556962041418", + "c0f29e6dec094d29be621247fd33d6bb", + "a5ff2c1cefbc4a83949d0ac4465d590a", + "f4a0f1473a85495b9e9819a93f5fd305" + ] + }, + "id": "aB2kDtVT_MZw", + "outputId": "9a41898d-913c-4b73-90b2-df1c510f91fc" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading language model...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Downloading: 0%| | 0.00/310 [00:00 *El caballo blanco de San Martin es de color \\**\n", + "\n", + "podemos deducir claramente que la palabra con mayor probabilidad de tomar el lugar del * es la palabra **blanco**.\n", + "\n", + "De esta forma podemos evaluar al modelo en situaciones concretas para buscar presencia de sesgos, como con la frase:\n", + "\n", + "> *Los * roban*\n" + ], + "metadata": { + "id": "S9bg294JXEk7" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_rankSents import RankSents" + ], + "metadata": { + "id": "zTKfJtG91aBH" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, se requieren los siguientes parámetros:\n", + "* `language_model (LanguageModel)`: Objeto de tipo `LanguageModel` de la cuál obtener el modelo cargado y su `tokenizer` para la realización de las tareas.\n", + "* `lang (str)`: idioma de las frases a evaluar para la tarea de **llenado de mascara**. Actualmente los idiomas posibles son Español (`es`) e Inlgés (`en`)." + ], + "metadata": { + "id": "k_qRVASSB6Q3" + } + }, + { + "cell_type": "code", + "source": [ + "rs = RankSents(\n", + " language_model = beto_lm,\n", + " lang = 'es'\n", + " )" + ], + "metadata": { + "id": "AMnulACbCQQm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Calculo de preferencia de un modelo\n", + "\n", + "Tanto esta clase como la siguiente, `CrowsPairs` rankean las posibles frases " + ], + "metadata": { + "id": "UuBhFPqcuHVe" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Método errorChecking(...)\n", + "\n", + "Verifica que la frase que el usuario ingresa esta correctamente formateada para llevar a cabo la tarea de **llenado de mascara**.\n", + "\n", + "Un formateo correcto implica la presencia de un único simbolo asterisco (' * ') en la frase, este simbolo sera llamado **máscara**. Esa será la posición de palabra que el modelo deberá llenar en su inferencia.\n", + "\n", + "**Entrada(s)**:\n", + "* `sent (str)`: sentencia a verificar su formato.\n", + "\n", + "**Salida(s)**:\n", + "* `str` con mesaje de error explicitando el error de formato en la frase, o vacio si fue correctamente suministrada.\n", + "\n", + "Las funciones de interes siempre realizan este chequeo previo, de esta forma no hay una necesidad explicita por parte del usuario de instaciarlo en todas las iteraciones." + ], + "metadata": { + "id": "r7Vk8k4vDVJ-" + } + }, + { + "cell_type": "markdown", + "source": [ + "Vemos un caso de formateo correcto, como fueron las frases de ejemplo anteriores" + ], + "metadata": { + "id": "OFpswYIPErOI" + } + }, + { + "cell_type": "code", + "source": [ + "frase = 'El caballo blanco de San Martin es de color *'" + ], + "metadata": { + "id": "K_r-pdU1E63F" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "rs.errorChecking(\n", + " sent = frase\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "8K5vegHyE4CT", + "outputId": "e1eeb053-9efb-4f3c-a214-b134713a9474" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "''" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Se retornan `str` de errores cuando la frase es vacia o no cuenta con una única máscara (*i.e.* un único simbolo asterisco, ' * ')." + ], + "metadata": { + "id": "4li8_0BBFCWL" + } + }, + { + "cell_type": "code", + "source": [ + "## Frase vacia\n", + "rs.errorChecking(\n", + " sent = ''\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "frNR0WsxEl90", + "outputId": "abfc0242-0a75-4dcf-f878-e01f9431fa35" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Error: You most enter a sentence!'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "source": [ + "frase_sin_ast = 'El sandwich de pavo y mayonesa es rico'" + ], + "metadata": { + "id": "I5rpHRwUFjnX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## Frase sin máscara\n", + "rs.errorChecking(\n", + " sent = frase_sin_ast\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "U-GkWe00Ff_s", + "outputId": "281333bb-541e-485a-ec5c-e0804e7dab73" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\" Error: The entered sentence needs to contain a ' * ' in order to predict the word!\"" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "frase_mul_masc = '* deberian volver a *'" + ], + "metadata": { + "id": "wmCO-DLLGRZX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## Frase con más de una máscara\n", + "rs.errorChecking(\n", + " sent = frase_mul_masc\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "K3IiG9aPGNeA", + "outputId": "cd9adcc6-cc70-43d0-8def-f5db23d7deea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\" Error: The sentence entered must contain only one ' * '!\"" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "> **Importante**: ciertos modelos de lenguaje pueden contener una **longitud máxima de sentencia**, de cargar un modelo con este limite y superarlo, se retornará un error acorde a esta problematica." + ], + "metadata": { + "id": "ZsHGvVg2Ggk7" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Método rank(...)\n", + "\n", + "Este es el método que permite llevar a cabo la tarea de **llenado de mascara**.\n", + "\n", + "**Entrada(s)**:\n", + "* `sent (str)`: Sentencia enmascarada con un único simbolo asterisco ' * ' a ser llenado por el modelo `language_model` de la instancia. Referirse a `errorChecking(...)` para más información de un formateo correcto.\n", + "* `word_list (List[str])`: *`[]` por defecto*. Lista de palabras de preferencia con las cuales llenar `sent`. Si es `[]`, el modelo retorna las cinco palabras con mayor pseudo probabilidad.\n", + "* `banned_word_list (List[str])`: *`[]` por defecto*. Lista de palabras de a descartar para el llenado de `sent`. Se tomará en cuenta únicamente cuando `wordlist = []`.\n", + "* `articles (bool)`: *`False` por defecto*. Booleano para *filtrar* articulos de las palabras posibles a evaluar por el modelo para el llenado de la máscara.\n", + "* `prepositions (bool)`: *`False` por defecto*. Booleano para *filtrar* preposiciones de las palabras posibles a evaluar por el modelo para el llenado de la máscara.\n", + "* `conjunctions (bool)`: *`False` por defecto*. Booleano para *filtrar* conjunciones de las palabras posibles a evaluar por el modelo para el llenado de la máscara.\n", + "\n", + "\n", + "**Salida(s)**:\n", + "* `Dict[str, float]`: Diccionario donde cada entrada tiene como llave la frase `sent` llenada por el modelo en la máscara con la palabra elegida encapsulada con los simbolos '<' y '>', y como valor, la pseudo probabilidad de elegir dicha palabra para llenar la frase.\n", + "\n", + "> **Notar**: a **mayor valor** de pseudo probabilidad, **mayor es la preferencia** del modelo a utilizar dicha palabra para llenar la `sent` propuesta\n" + ], + "metadata": { + "id": "bPZAFUNgHTf4" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Calculo de pseudo-probabilidad (o proporción)\n", + "\n", + "Este calculo se basa en la metrica de rankeo propuesta por ([Nangia et al. 2020](https://arxiv.org/pdf/2010.00133.pdf)).\n", + "\n", + "Ésta se basa en la sumatoria de los logaritmos de las probabilidades de que cada palabra que compone la frase pertenezca en ella, luego de haber llenado la máscara con una palabra posible." + ], + "metadata": { + "id": "CPcLkk61woFD" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos el ejemplo dado anteriormente sobre el color del caballo de San Martin." + ], + "metadata": { + "id": "pUwwcTptLcsn" + } + }, + { + "cell_type": "code", + "source": [ + "rs.rank(\n", + " sent = frase\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f0zIXQwOKM8g", + "outputId": "17e84bf7-72af-46b0-a82b-445eca49cc65" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'El caballo blanco de San Martin es de color ': -10.883169079199433,\n", + " 'El caballo blanco de San Martin es de color ': -10.19933423679322,\n", + " 'El caballo blanco de San Martin es de color ': -10.48569693043828,\n", + " 'El caballo blanco de San Martin es de color ': -10.992048978805542,\n", + " 'El caballo blanco de San Martin es de color ': -10.273603107780218}" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Observamos así que sin suministar una lista de palabras de interés, el modelo nos retorna las cinco más probables, donde la que tiene mayor probabilidad es la palabra *amarillo*, seguido de la palabra esperada *blanco*." + ], + "metadata": { + "id": "x-4EcZPWLu2X" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos ahora el ejemplo con la frase: \n", + "\n", + "> *Los * roban*" + ], + "metadata": { + "id": "ni63uyy3MK3E" + } + }, + { + "cell_type": "code", + "source": [ + "frase_2 = 'Los * roban'" + ], + "metadata": { + "id": "vLSH-2vEMTfU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "rs.rank(\n", + " sent = frase_2\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sWdcGN4RMWTc", + "outputId": "70687578-6788-4865-c0c1-f1a02bbe94e4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'Los roban': -19.200231552124023,\n", + " 'Los roban': -12.723215758800507,\n", + " 'Los roban': -13.406085014343262,\n", + " 'Los roban': -17.429616510868073,\n", + " 'Los roban': -13.944223910570145}" + ] + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Aquí la palabra con mayor probabilidad de ser elegido por el modelo para el llenado de la frase es *ladrones*.\n", + "\n", + "Observamos que tenemos palabras poco interesantes, como es la conjunción *que* y la palabra *tigres*. Aquí es donde la lista de palabras baneadas (`banned_word_list`) y la posibilidad de excluir tanto articulos como preposiciones o conjunciones es de utilidad." + ], + "metadata": { + "id": "nkiAG51jMZb5" + } + }, + { + "cell_type": "code", + "source": [ + "rs.rank(\n", + " sent = frase_2,\n", + " banned_word_list = ['tigres'],\n", + " conjunctions = True\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r9IJcqjqOVOM", + "outputId": "0fd8f2bc-8b24-4ef3-dc13-1f99910873f6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'Los roban': -12.723215758800507,\n", + " 'Los roban': -13.406085014343262,\n", + " 'Los roban': -17.429616510868073,\n", + " 'Los roban': -14.222050547599792,\n", + " 'Los roban': -15.588627934455872}" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Especifiquemos ahora palabras con las cuales nos gustaria observar la preferencia del modelo, en busca de sesgos con palabras concretas. \n", + "\n", + "Recordar que esta lista no tiene un limite en cuanto a la cantidad de elementos y que no se verá afectada por las palabras dentro de la lista de baneos (`banned_word_list`)." + ], + "metadata": { + "id": "sSBElNCENWuH" + } + }, + { + "cell_type": "code", + "source": [ + "palabras_para_llenar = ['ladrones', 'negros', 'blancos', 'ricos', 'ilegales', 'indocumentados', 'latinos', 'necesitados']" + ], + "metadata": { + "id": "Hlt_mNJxMrSm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "rs.rank(\n", + " sent = frase_2,\n", + " word_list = palabras_para_llenar\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-BQob3FcM-3d", + "outputId": "e13e5f92-9b68-46d7-93a0-210b7a5f0eb1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'Los roban': -12.723215758800507,\n", + " 'Los roban': -12.846588492393494,\n", + " 'Los roban': -15.208646178245544,\n", + " 'Los roban': -12.55654662847519,\n", + " 'Los roban': -17.061036825180054,\n", + " 'Los roban': -23.026785373687744,\n", + " 'Los roban': -16.46145796775818,\n", + " 'Los roban': -18.4329696893692}" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "De todas estas, es la palabra *ricos* la que tiene mayor probabilidad de ser elegida." + ], + "metadata": { + "id": "wVk1qf2XNGRk" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Clase CrowsPairs\n", + "\n", + "Otra forma alternativa de evaluar las preferencias de un modelo sobre la generación de lenguaje sesgado es directamente proveyendo al mismo frases con y sin estereotipos, y evaluando su preferencia sobre éstas.\n", + "\n", + "Por ejemplo, podemos definir dos frases; una con estereotipo y la otra sin:\n", + "\n", + "> \"*Las parejas de <**homosexuales**> no deberían poder casarse*\"\n", + "\n", + "> \"*Las parejas de <**lesbianas**> no deberían poder casarse*\"\n", + "\n", + "Y suministrarlas al modelo para la evaluación de preferencia, de cierta forma podria verse como la tarea llevada a cabo por la clase `RankSents` sobre el **llenado de máscara** (tomando la frase \"*Las parejas de * no deberían poder casarse*\"), con la diferencia de que en esta tarea podemos tener más de una palabra sobre la cual el modelo deba evaluar su preferencia.\n", + "\n", + "Un ejemplo de esto último podría ser comparando las proximas frases con estereotipos:\n", + "\n", + "> \"*No cualquier <**mujer**> con hijos logra ser <**una buena**> profesional*\"\n", + "\n", + "> \"*No cualquier <**hombre**> con hijos logra ser <**un buen**> profesional*\"\n", + "\n", + "> \"*No cualquier <**perro**> con hijos logra ser <**un buen**> profesional*\"\n", + "\n", + "> \"*No cualquier <**perra**> con hijos logra ser <**una buena**> profesional*\"" + ], + "metadata": { + "id": "HxKQS4jlXL2K" + } + }, + { + "cell_type": "code", + "source": [ + "from modules.module_crowsPairs import CrowsPairs" + ], + "metadata": { + "id": "Ew4UY9bIrbwk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Para instanciar un objeto de esta clase, solo se requiere un parámetro:\n", + "* `language_model (LanguageModel)`: Objeto de tipo `LanguageModel` de la cuál obtener el modelo cargado y su `tokenizer` para la realización de las tareas." + ], + "metadata": { + "id": "hgmUfHKzrduP" + } + }, + { + "cell_type": "code", + "source": [ + "cp = CrowsPairs(\n", + " language_model = beto_lm\n", + ")" + ], + "metadata": { + "id": "Dmn3P-EFrqdo" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método errorChecking(...)\n", + "\n", + "Verifica que la frases que el usuario ingresa estan correctamente formateadas para llevar a cabo la tarea propuesta para esta clase.\n", + "\n", + "Un formateo correcto implica la presencia de al menos una palabra encapsulada por los simbolos '<' y '>', correctamente balancedos, sin anidamientos y tampoco emcapsulando toda la frase por completo.\n", + "\n", + "**Entrada(s)**:\n", + "* `sents (List[str])`: Lista de frases a verificar su formateo correcto.\n", + "\n", + "**Salida(s)**:\n", + "* `str` con mesaje de error explicitando el error de formato en la(s) frase(s), o vacio si estan correctamente formateadas.\n", + "\n", + "Las funciones de interes siempre realizan este chequeo previo, de esta forma no hay una necesidad explicita por parte del usuario de instaciarlo en todas las iteraciones." + ], + "metadata": { + "id": "FxJi_5Wpoxw1" + } + }, + { + "cell_type": "markdown", + "source": [ + "Corroboremos el correcto formateo de las frases anteriorer." + ], + "metadata": { + "id": "jHaQTPrFrSU_" + } + }, + { + "cell_type": "code", + "source": [ + "frase_parejas_1 = 'Las parejas de no deberían poder casarse'" + ], + "metadata": { + "id": "XiGKNUgjsRbV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "frase_parejas_2 = 'Las parejas de no deberían poder casarse' " + ], + "metadata": { + "id": "yaHBnTzKsX-C" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cp.errorChecking(\n", + " sent_list = [frase_parejas_1, frase_parejas_2]\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "7RrA0butsd2A", + "outputId": "f89f7e58-c3bb-4ec4-c73e-de76feb26832" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "''" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "En las siguientes celdas, se dejan ejemplos de formateos incorrectos" + ], + "metadata": { + "id": "KRyZnUnOsmOp" + } + }, + { + "cell_type": "code", + "source": [ + "# Sentencia vacia\n", + "cp.errorChecking(\n", + " sent_list = ['']\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "28l0LegbsrG4", + "outputId": "17eab9bf-8420-4f20-ab90-1998bad95964" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Error: The sentence Nº1 can not be empty!'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Sentencia desbalanceada\n", + "cp.errorChecking(\n", + " sent_list = ['Los no deberian no deberian ']\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "T5eR0xJvvOPq", + "outputId": "53a26262-5d00-4664-bf3c-855c00684c0c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Error: The sentence Nº 1 does not have the correct format!.'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Sentencia con encapsulatiemnto completo\n", + "cp.errorChecking(\n", + " sent_list = ['']\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "y0HrRrZCvgnL", + "outputId": "8296e70c-2f14-48f0-9aa1-f15ccde225ea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Error: The sentence Nº 1 does not have the correct format!.'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 15 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Método rank(...)\n", + "\n", + "Este método permite llevar a capo la tarea de **comparar y rankear** las frases.\n", + "\n", + "**Entrada(s)**:\n", + "* `sent_list (List[str])`: Listas de frases a comparar. Referirse a `errorChecking(...)` para más información de un formateo correcto.\n", + "\n", + "\n", + "**Salida(s)**:\n", + "* `Dict[str, float]`: Diccionario asignando a cada frase el valor de pseudo probabilidad calculada.\n", + "\n", + "> **Notar**: a **mayor valor** de pseudo probabilidad, **mayor es la preferencia** del modelo sobre la sentencia." + ], + "metadata": { + "id": "Xf9_v7K-vxFB" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Calculo de pseudo-probabilidad (o proporción)\n", + "\n", + "Este calculo se basa en la metrica de rankeo propuesta por ([Nangia et al. 2020](https://arxiv.org/pdf/2010.00133.pdf)).\n", + "\n", + "Ésta se basa en la sumatoria de los logaritmos de las probabilidades de que cada palabra que compone la frase pertenezca en ella, exceptuando aquellas palabras encapsuladas por los simbolos '<' y '>'." + ], + "metadata": { + "id": "23NX6aVgxjm5" + } + }, + { + "cell_type": "markdown", + "source": [ + "Evaluemos así el primer ejemplo propuesto" + ], + "metadata": { + "id": "EKcpyMAKxPuz" + } + }, + { + "cell_type": "code", + "source": [ + "cp.rank(\n", + " sent_list = [frase_parejas_1, frase_parejas_2]\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UdHiK-bRwYMO", + "outputId": "e8e428cf-e1bc-48df-a41b-ed76a6b31578" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'Las parejas de no deberían poder casarse': -39.680837631225586,\n", + " 'Las parejas de no deberían poder casarse': -38.82312232255936}" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Observamos como la frase \"*Las parejas de <**lesbianas**> no deberían poder casarse*\" presenta una mayor pseudo probabilidad de ser la preferencia del modelo sobre la sentencia con la palabra **homosexuales**." + ], + "metadata": { + "id": "5D59KGSGxT1B" + } + }, + { + "cell_type": "markdown", + "source": [ + "Veamos por último el segundo ejemplo dado, que contiene múltiples frases." + ], + "metadata": { + "id": "zsZugT1yx157" + } + }, + { + "cell_type": "code", + "source": [ + "sentencia_profesional_1 = 'No cualquier con hijos logra ser profesional'" + ], + "metadata": { + "id": "tbceFN2HyFxj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sentencia_profesional_2 = 'No cualquier con hijos logra ser profesional'" + ], + "metadata": { + "id": "o95HOx_oyKyf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sentencia_profesional_3 = 'No cualquier con hijos logra ser profesional'" + ], + "metadata": { + "id": "tZBoqZ_KyLDZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sentencia_profesional_4 = 'No cualquier con hijos logra ser profesional'" + ], + "metadata": { + "id": "hwgMQ7I2yLP9" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cp.rank(\n", + " sent_list = [sentencia_profesional_1, sentencia_profesional_2, sentencia_profesional_3, sentencia_profesional_4]\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NXe3I_sFyeVB", + "outputId": "a1cdd0d0-4861-4401-b16b-be46a776b056" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'No cualquier con hijos logra ser profesional': -26.2485653758049,\n", + " 'No cualquier con hijos logra ser profesional': -28.223704382777214,\n", + " 'No cualquier con hijos logra ser profesional': -34.46490624547005,\n", + " 'No cualquier con hijos logra ser profesional': -27.988837897777557}" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "En este caso, la frase con mayor pseudo probabilidad es la primera: \"*No cualquier <**mujer**> con hijos logra ser <**una buena**> profesional*\", seguido por la frase \"*No cualquier <**perra**> con hijos logra ser <**una buena**> profesional*\"." + ], + "metadata": { + "id": "m4rp6uQTyl8F" + } + }, + { + "cell_type": "markdown", + "source": [ + "---" + ], + "metadata": { + "id": "FM6180BoFUUo" + } + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "dd7ea29cbf45492aa7d9619436257b7a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5bb2969e49a7406e927f71b05c3a8b01", + "IPY_MODEL_7eaa9df4df314ae493476b2108c9f4b0", + "IPY_MODEL_1a621b8f37fb4e9d93d1bee764bddc10" + ], + "layout": "IPY_MODEL_ad8d626a25174b10907e7c0f0dbfa4e2" + } + }, + "5bb2969e49a7406e927f71b05c3a8b01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d1df935e1514525919c7cb144a9e9bf", + "placeholder": "​", + "style": "IPY_MODEL_6208b8b0bd384f9bb4f0700a2e792d99", + "value": "Downloading: 100%" + } + }, + "7eaa9df4df314ae493476b2108c9f4b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_297eb7c5adc54eb8aa296e2156f3c517", + "max": 310, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_561fac1acc44444d85efb123894efb3b", + "value": 310 + } + }, + "1a621b8f37fb4e9d93d1bee764bddc10": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fbe8cfaf42a54526ab4a140a93ef1ba1", + "placeholder": "​", + "style": "IPY_MODEL_61c4bd1bb84f412f832167d185f2d838", + "value": " 310/310 [00:00<00:00, 14.5kB/s]" + } + }, + "ad8d626a25174b10907e7c0f0dbfa4e2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d1df935e1514525919c7cb144a9e9bf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6208b8b0bd384f9bb4f0700a2e792d99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "297eb7c5adc54eb8aa296e2156f3c517": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "561fac1acc44444d85efb123894efb3b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fbe8cfaf42a54526ab4a140a93ef1ba1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "61c4bd1bb84f412f832167d185f2d838": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c0d2e99f38964c3b989959a4e0d6c45f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6402e4fd9316464f8fcdd1d1a7b6467a", + "IPY_MODEL_4f79672af44d435ea4c9c52da886c72f", + "IPY_MODEL_91ee29d8037a41b0b77bfa924697a6f1" + ], + "layout": "IPY_MODEL_fa30e340cbf845178f1a2cec3ce8fea4" + } + }, + "6402e4fd9316464f8fcdd1d1a7b6467a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84a5687036304b59b7732f6e57519c41", + "placeholder": "​", + "style": "IPY_MODEL_0c849f288df74763ae71cc27ca8f6f0e", + "value": "Downloading: 100%" + } + }, + "4f79672af44d435ea4c9c52da886c72f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d3e48bc15d9540779409940c982efa73", + "max": 650, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_866903d85ec840a1824da788ec33307e", + "value": 650 + } + }, + "91ee29d8037a41b0b77bfa924697a6f1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_202c2d7e7f05406e9577812e2950b15d", + "placeholder": "​", + "style": "IPY_MODEL_4f9771efea5048ab9c717ad555a16d8e", + "value": " 650/650 [00:00<00:00, 35.1kB/s]" + } + }, + "fa30e340cbf845178f1a2cec3ce8fea4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "84a5687036304b59b7732f6e57519c41": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c849f288df74763ae71cc27ca8f6f0e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d3e48bc15d9540779409940c982efa73": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "866903d85ec840a1824da788ec33307e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "202c2d7e7f05406e9577812e2950b15d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4f9771efea5048ab9c717ad555a16d8e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9785af70e5cb4ce68566d16c49486f1c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3336003ca5bf4676956e77de2959d1be", + "IPY_MODEL_095b3ae26524495ca7449f116f155c6c", + "IPY_MODEL_12c88d15946e411391b1ff24bcd7a974" + ], + "layout": "IPY_MODEL_a1fe63c2c09d415ebe5d960e35ae0463" + } + }, + "3336003ca5bf4676956e77de2959d1be": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9508a7d5b8d046d7aeabb1ab8cbd00c0", + "placeholder": "​", + "style": "IPY_MODEL_15c46e829d464387ac3d85943f1f3784", + "value": "Downloading: 100%" + } + }, + "095b3ae26524495ca7449f116f155c6c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_438f5269cee64873bdd5ce7acf924771", + "max": 247723, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e19c435edc4748b9b7b76f05d7d8b67e", + "value": 247723 + } + }, + "12c88d15946e411391b1ff24bcd7a974": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_49293c009052435ba9e6148ef832ec23", + "placeholder": "​", + "style": "IPY_MODEL_bcf8aca4dcdd42ae8690a3d085a89756", + "value": " 248k/248k [00:00<00:00, 3.22MB/s]" + } + }, + "a1fe63c2c09d415ebe5d960e35ae0463": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9508a7d5b8d046d7aeabb1ab8cbd00c0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15c46e829d464387ac3d85943f1f3784": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "438f5269cee64873bdd5ce7acf924771": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e19c435edc4748b9b7b76f05d7d8b67e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "49293c009052435ba9e6148ef832ec23": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bcf8aca4dcdd42ae8690a3d085a89756": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7e5f29c8b1774893b2c90e239d27e812": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5d5978a1ed4d417ca503f63a5cdb5b6f", + "IPY_MODEL_e2b283be81e84d5aa9ddce2a4f100afd", + "IPY_MODEL_fdefd35d08a04c9496050dadfe760472" + ], + "layout": "IPY_MODEL_e091a90cc72343e78073122f880571be" + } + }, + "5d5978a1ed4d417ca503f63a5cdb5b6f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5c26e2e4c72b48d890a49d2a5cf2d39d", + "placeholder": "​", + "style": "IPY_MODEL_f5561c3264df4ebea20fa2241522ae99", + "value": "Downloading: 100%" + } + }, + "e2b283be81e84d5aa9ddce2a4f100afd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f314a82e7f444107b5aa0f31faa2ff4a", + "max": 486125, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_06949775b9aa4494a0718ad819d7eab6", + "value": 486125 + } + }, + "fdefd35d08a04c9496050dadfe760472": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bf9d4ba9f8c543a7b32a16c7ff860b54", + "placeholder": "​", + "style": "IPY_MODEL_4bf64c365cba476395463a0771327275", + "value": " 486k/486k [00:00<00:00, 3.77MB/s]" + } + }, + "e091a90cc72343e78073122f880571be": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5c26e2e4c72b48d890a49d2a5cf2d39d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f5561c3264df4ebea20fa2241522ae99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f314a82e7f444107b5aa0f31faa2ff4a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06949775b9aa4494a0718ad819d7eab6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bf9d4ba9f8c543a7b32a16c7ff860b54": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bf64c365cba476395463a0771327275": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4403a625b17e43d48cef297f91f359d8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_532a0246a2114a46a4c64ccfd920ec09", + "IPY_MODEL_d0f10f02b16b4075b6641d392ad018ea", + "IPY_MODEL_e272fe8c64834f51b0cfb365e59e1b58" + ], + "layout": "IPY_MODEL_08f786c6fae04bf8b974c5ad44765d5f" + } + }, + "532a0246a2114a46a4c64ccfd920ec09": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0c2f4b6f1c8c49dca165d51956ad351f", + "placeholder": "​", + "style": "IPY_MODEL_ed12c8634b594cab8e6a4392076ac827", + "value": "Downloading: 100%" + } + }, + "d0f10f02b16b4075b6641d392ad018ea": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c9f6721eebdc46f9a07464e6cf76d3c7", + "max": 134, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_27ae791395b746fd810db9ac97417744", + "value": 134 + } + }, + "e272fe8c64834f51b0cfb365e59e1b58": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2de8ea83c23c4d5cbf73a2f8af90ae60", + "placeholder": "​", + "style": "IPY_MODEL_53630686cfd545efafe6af86ad8357ec", + "value": " 134/134 [00:00<00:00, 5.04kB/s]" + } + }, + "08f786c6fae04bf8b974c5ad44765d5f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c2f4b6f1c8c49dca165d51956ad351f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed12c8634b594cab8e6a4392076ac827": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c9f6721eebdc46f9a07464e6cf76d3c7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "27ae791395b746fd810db9ac97417744": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "2de8ea83c23c4d5cbf73a2f8af90ae60": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "53630686cfd545efafe6af86ad8357ec": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9c130ae949164699936cac5e35124557": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4cdadc79fee24b958a7f9880b723eb03", + "IPY_MODEL_a3fa08bb164a4a88bc06833ceb658deb", + "IPY_MODEL_7675f997bad34d5cadceff7ff3166b3b" + ], + "layout": "IPY_MODEL_43cf9bf963ac487f8c6e1d718a309c61" + } + }, + "4cdadc79fee24b958a7f9880b723eb03": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e63b9d54f8bf4f419d596449eec18913", + "placeholder": "​", + "style": "IPY_MODEL_c834e1fa5ae04b77bf0eac066807a5a3", + "value": "Downloading: 100%" + } + }, + "a3fa08bb164a4a88bc06833ceb658deb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af5f095d729c4f7b8fa5556962041418", + "max": 439621341, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c0f29e6dec094d29be621247fd33d6bb", + "value": 439621341 + } + }, + "7675f997bad34d5cadceff7ff3166b3b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a5ff2c1cefbc4a83949d0ac4465d590a", + "placeholder": "​", + "style": "IPY_MODEL_f4a0f1473a85495b9e9819a93f5fd305", + "value": " 440M/440M [00:08<00:00, 55.2MB/s]" + } + }, + "43cf9bf963ac487f8c6e1d718a309c61": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e63b9d54f8bf4f419d596449eec18913": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c834e1fa5ae04b77bf0eac066807a5a3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "af5f095d729c4f7b8fa5556962041418": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c0f29e6dec094d29be621247fd33d6bb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a5ff2c1cefbc4a83949d0ac4465d590a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f4a0f1473a85495b9e9819a93f5fd305": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file