{ "cells": [ { "cell_type": "markdown", "id": "2d01c1fb", "metadata": {}, "source": [ "# Ciencia de Datos y Lenguaje Natural - **Notebook 3** \n", "## Redes Neuronales y Word Embeddings" ] }, { "cell_type": "markdown", "id": "ae579df6", "metadata": {}, "source": [ "En este notebook se trabajará con redes neuronales y word embeddings. El objetivo es indicar si una oración expresa un juicio positivo o negativo, al igual que en el notebook anterior, pero en este caso utilizando word embeddings y clasificadores basados redes neuronales. \n", "\n", "Al igual que en el notebook 2 se trabajará con el corpus CDLN-Senti formado por oraciones simples anotadas según su orientación semántica (positiva, 0; negativa, 1). El corpus se generó a partir de comentarios de usuarios en los sitios de Amazon, IMDB y Yelp. Se encontraba disponible en inglés y fue traducido al español por Google translate. \n", "\n", "Se resolverá el problema propuesto por 3 estrategias distintas según el tratamiento de secuencias y el tipo de la red utilizado. En el primero se debe utilizar una red completamente conectada *feed forward* y la entrada debe representarse como un vector mediante una operación de los vectores de las palabras (ej. centroide). En el segundo enfoque se debe utilizar una red recurrente para la entrada. Finalmente, en el tercer enfoque se debe utilizar una red de tipo transformer. Se deben reportar los resultados obtenidos. \n", "\n", "\n", "#### Indique nombre, número de cédula y que carrera está cursando" ] }, { "cell_type": "code", "execution_count": null, "id": "c469b9d8", "metadata": {}, "outputs": [], "source": [ "__author__ = \"Nombre Apellido\"\n", "__cedula__ = \"1.234.567-8\"\n", "__origen__ = \"Grado. Ing. Computación\"" ] }, { "cell_type": "markdown", "id": "20b39a60", "metadata": {}, "source": [ "## Lectura de datos (corpus y léxicos)\n", "\n", "Se dispone de dos léxicos para el español, uno de palabras positivas (palabras-pos.txt) y otro de palabras negativas (palabras-neg.txt). Descarguelos del eva del curso. (Los léxicos fueron extraídos de: https://www.kaggle.com/datasets/rtatman/sentiment-lexicons-for-81-languages?resource=download)\n", "\n", "Se dispone además de un corpus con los datos de las opiniones en el formato \"frase|valor\", donde \"frase\" es la frase a analizar (Ej. \"Me encantó. Volveré.\") y \"valor\" es 0 o 1. Este coprpus se encuentra fraccionado en entrenamiento (senti-train.csv), validación (senti-val.csv) y test (senti-test.csv). \n", "\n", "En el siguiente bloque de código se leen y cargan en memoria los léxicos y el corpus de análisis de sentimiento. Estos recursos serán utilizados a lo largo de todo el notebook. " ] }, { "cell_type": "code", "execution_count": null, "id": "327e0631", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import os\n", "import csv\n", "import sklearn\n", "\n", "def read_data(path):\n", " import csv\n", " rows=[]\n", " with open(path, encoding='utf-8') as doc:\n", " csvreader = csv.reader(doc, delimiter ='|', quoting=csv.QUOTE_NONE)\n", " for i,row in enumerate(csvreader):\n", " rows.append(row)\n", " if len(rows)>0 and len(rows[0])==1:\n", " rows = [r[0] for r in rows]\n", " return rows\n", "\n", "\n", "dtrain = read_data('./senti-train.csv')\n", "dval = read_data('./senti-val.csv')\n", "dtest = read_data('./senti-test.csv')\n", "lexpos = read_data('./palabras-pos.txt')\n", "lexneg = read_data('./palabras-neg.txt')" ] }, { "cell_type": "markdown", "id": "5da57cff", "metadata": {}, "source": [ "**Cantidad de elementos de corpus y léxicos**\n", "\n", "En el siguiente bloque de código se despliega la cantidad de entradas positivas y negativas en cada partición (train, val, test) del corpus; y la cantidad de elementos de los léxicos (positivo y negativo)." ] }, { "cell_type": "code", "execution_count": null, "id": "24c53497", "metadata": {}, "outputs": [], "source": [ "lenx = lambda x: (len(x), len([d for d in x if d[1]=='0']), len([d for d in x if d[1]=='1']))\n", "print('Train (tot,neg,pos):', lenx(dtrain))\n", "print('Val (tot,neg,pos):', lenx(dval))\n", "print('Test (tot,neg,pos):', lenx(dtest))\n", "print('Lex Pos:', len(lexpos))\n", "print('Lex Neg:', len(lexneg))" ] }, { "cell_type": "markdown", "id": "bb8ce59b", "metadata": {}, "source": [ "# Word Embeddings\n", "\n", "Un *word embedding* es una representación vectorial del significado de las palabras obtenida a partir del uso del lenguaje. Los métodos para obtener *word embeddings* principalmente usan dos tipos de información:\n", "- el contexto de uso de las palabras (coocurrencia de palabras)\n", "- composición de la palabra (*subword*)\n", "\n", "Una palabra puede tener varios significados (homonímia y polisemia). Al usar el lenguaje, inferimos el significados adecuado de cada palabra a partir del contexto. En cuanto refiere a los *word embeddings*, existen dos tipos:\n", "- Estáticos: se tiene un único vector que representa todos los significados de la palabra.\n", "- Dinámicos o contextualizados: se tiene un vector por cada ocurrencia de la palabra, distintos usos de las palabras son representados por vectores distintos. \n", "\n", "En esta parte experimentaremos con *word embeddings* estáticos. " ] }, { "cell_type": "markdown", "id": "820e5184", "metadata": {}, "source": [ "##### Instalar librería y cargar modelo preentrenado\n", "\n", "Escoja un modelo de *word embeddings* preentrenado que esté disponible públicamente (Ej. https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.es.300.bin.gz) y una librería para su manipulación (Ej. https://fasttext.cc/docs/en/python-module.html). Además, puede implementar rutinas auxiliares que considere necesarias.\n", "\n", "A continuación escriba los comandos necesarios para instalar la librería y descargar el modelo. En caso de implementar alguna funcionalidad también escribila a continuación. " ] }, { "cell_type": "code", "execution_count": null, "id": "9dc9cb74", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO\n", "\n", "#Ejemplo: \n", "#!wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.es.300.bin.gz\n", "#pip install fasttext" ] }, { "cell_type": "markdown", "id": "94b20699", "metadata": {}, "source": [ "##### Cargar modelo\n", "\n", "A continuación escriba el código para cargar el modelo en memoria. Utilice el nombre de variable 'wemb' para este modelo, será utilizado en las siguientes secciones. \n" ] }, { "cell_type": "code", "execution_count": null, "id": "2f0299f6", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO\n", "\n", "#Ejemplo:\n", "#import fasttext\n", "#wemb = fasttext.load_model(\"./cc.es.300.bin\")" ] }, { "cell_type": "markdown", "id": "a5b2deaf", "metadata": {}, "source": [ "##### Caclcular la similitud coseno entre \n", "\n", "Con un modelo de *word embeddings* es posible obtener la similitud semántica entre palabras utilizando funciones distancia o similitud entre vectores. Un tipo de similitud entre vectores habitual es la similitud coseno: \n", "\n", "
$simcos(\\vec{x},\\vec{y}) = \\frac{\\vec{x}.\\vec{y}} {||x||.||y||} = cos(\\theta) $
\n", "\n", "donde $\\theta$ es el ángulo entre los vectores. \n", "\n", "Codifique a continuación una función que devuelva la similitud coseno entre las representaciones vectoriales de dos palabras." ] }, { "cell_type": "code", "execution_count": null, "id": "576fab53", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO\n", "\n", "from sklearn.metrics.pairwise import cosine_similarity\n", "\n", "def cosine_we(w1,w2, wemb=wemb):\n", " # ...\n", " " ] }, { "cell_type": "markdown", "id": "1296651c", "metadata": {}, "source": [ "A continuación se despliega la similitud coseno entre los vectores de los siguientes pares de palabras:\n", "- ('perro','canino'), ('perro','chihuahua'),('perro','gato'), ('perro','tortuga'), ('perro','ballena'), ('tortuga','ballena'), ('perro','blanco'), ('pregunta','ballena'),('pregunta','respuesta'),('pregunta','interrogante')" ] }, { "cell_type": "code", "execution_count": null, "id": "976f5bbb", "metadata": {}, "outputs": [], "source": [ "pares = [('perro','canino'), ('perro','chihuahua'),('perro','gato'), ('perro','tortuga'), \n", " ('perro','ballena'), ('tortuga','ballena'), ('perro','blanco'), \n", " ('pregunta','ballena'),('pregunta','respuesta'),('pregunta','interrogante')]\n", "\n", "for w1,w2 in pares:\n", " print(w1,w2,cosine_we(w1,w2))" ] }, { "cell_type": "markdown", "id": "96bccbdc", "metadata": {}, "source": [ "Despliegue a continuación la similitud coseno de pares palabras que considere interesantes:" ] }, { "cell_type": "code", "execution_count": null, "id": "4b25295e", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "57bc5be7", "metadata": {}, "source": [ "##### Palabras más similares: \n", "\n", "A continuación despliegue las 5 palabras más similares a las siguientes palabras:\n", "- 'perro', 'ballena', 'pregunta', 'selva', 'Ibarborou', 'Turing'\n", "\n", "Mida el tiempo de ejecución de la celda usando %%timeit." ] }, { "cell_type": "code", "execution_count": null, "id": "4b3172ca", "metadata": {}, "outputs": [], "source": [ "%%timeit -r 1 -n 1\n", "\n", "palabras = ['perro', 'ballena', 'pregunta', 'selva', 'Ibarbourou', 'Turing'] \n", "\n", "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "19637a75", "metadata": {}, "source": [ "Despliegue a continuación las 10 palabras más similares a palabras que considere interesantes. " ] }, { "cell_type": "code", "execution_count": null, "id": "d55d4221", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "a4e044b0", "metadata": {}, "source": [ "##### Analogías de palabras:\n", "\n", "Los *word embeddings* representan analogías entre pares de palabras mediante la diferencia de vectores. Por ejemplo, si consideramos que 'ver' es a 'viendo' como 'ir' a 'yendo' (notación ver:viendo::ir:yendo) se tiene que\n", "\n", "$(\\vec{x}_{ver} - \\vec{x}_{viendo}) \\sim (\\vec{x}_{ir} - \\vec{x}_{yendo})$\n", "\n", "y por lo tanto\n", "\n", "$ \\vec{x}_{ir} + (\\vec{x}_{viendo} - \\vec{x}_{ver}) \\sim \\vec{x}_{yendo}$\n", "\n", "es decir que con las representaciones de 'ir', 'ver' y 'viendo' se puede intentar recuperar/responder 'yendo'. \n", "\n", "\n", "\n", "A continuación despliegue las 5 palabras más próximas como respuesta las siguientes preguntas de analogías de palabras:\n", "- hombre:mujer::rey:?\n", "- saltar:saltando::correr:?\n", "- ver:viendo::ir:?\n", "- francia:parís::uruguay:?\n", "- francia:parís::alemania:?\n", "\n", "Mida el tiempo de ejecución de la celda usando %%timeit." ] }, { "cell_type": "code", "execution_count": null, "id": "47ac4d04", "metadata": {}, "outputs": [], "source": [ "%%timeit -r 1 -n 1\n", "\n", "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "3fd6b179", "metadata": {}, "source": [ "##### Correlación de rangos de Spearman en conjuntos de palabras similares o relacionadas \n", "\n", "\n", "Calcule la correlación de rangos de Spearman del *word embedding* utilizado, en los siguientes conjuntos:\n", "\n", "- es-ws353: https://github.com/Lambda-3/Gold-Standards/blob/master/SemR-11/Multilingual_Wordpairs/es-ws353.dataset\n", "- es-simlex: https://github.com/Lambda-3/Gold-Standards/blob/master/SemR-11/Multilingual_Wordpairs/es-simlex.dataset\n", "\n", "\n", "Sugerencia: Considere la función 'spearmanr' de 'scipy.stats'\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "581f8cb2", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "76ac101d", "metadata": {}, "source": [ "##### Distancia entre textos usando centroide:\n", "\n", "En esta sección calcularemos la distancia entre dos textos a partir de una operación (ej. centroide) entre los vectores de sus palabras. \n", "\n", "Defina una función para vectorizar un texto con los siguientes tres modos: \n", "\n", "- mean : retorna el promedio de los vectores de palabras (centroide)\n", "- max : retorna el máximo de los vectores de palabras componente a componente\n", "- list: retorna la lista de vectores de palabras (puede resultar útil para modelos de RNN)\n" ] }, { "cell_type": "code", "execution_count": null, "id": "fc954236", "metadata": {}, "outputs": [], "source": [ "from nltk.tokenize import word_tokenize\n", "\n", "def vectorize_sentence(sent, wemb=wemb, mod='mean'):\n", " l = [wemb[w] for w in word_tokenize(sent)]\n", " if mod == 'mean':\n", " # ESCRIBA AQUI SU CODIGO\n", " elif mod == 'max':\n", " return np.max(l, axis=0)\n", " elif mod == 'list':\n", " # ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "2aca804c", "metadata": {}, "source": [ "Codifique la siguiente función que recibe dos oraciones y devuelve la distancia coseno de las representaciones de máximo o centroide definidas anteriormente:" ] }, { "cell_type": "code", "execution_count": null, "id": "1381f5f5", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from sklearn.metrics.pairwise import cosine_similarity\n", "\n", "def sentence_sim(sent1, sent2, mod='mean'):\n", " # ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "667f9a99", "metadata": {}, "source": [ "Obtenga la similitud coseno entre los siguientes pares de oraciones usando el máximo y el centroide de los vectores de las palabras de cada oración:\n", "\n", "- 'me gustó mucho', 'es muy buena'\n", "- 'no me gustó mucho', 'es muy buena'\n", "- 'me gustó mucho', 'es muy mala'\n", "- 'me gustó mucho', 'me encantó'\n", "- 'me gustó mucho', 'mañana quizá llueva'\n", "- 'estuvo soleado hoy', 'mañana quizá llueva'\n" ] }, { "cell_type": "code", "execution_count": null, "id": "fc458bb9", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "eee2403b", "metadata": {}, "source": [ "###### Pregunta\n", "\n", "¿Qué observa respecto a la similitud de oraciones usando centroide o máximo ? ¿Cómo se podrían mejorar los resultados?\n", "\n", "**Respuesta:**" ] }, { "cell_type": "markdown", "id": "b9a9ac28", "metadata": {}, "source": [ "***Escriba aquí su respuesta***" ] }, { "cell_type": "markdown", "id": "2cdea8a8", "metadata": {}, "source": [ "# Neural Netowrks: Multi-layer Feedforward Network\n", "\n", "En esta parte experimentará con los *word embeddings* preentrenados cargados en la parte anterior y modelos de redes neuronales completamente conectadas de tipo *feedforward*. Este tipo de modelo recibe un vector como entrada, por lo tanto para ser utilizados con secuencias de vectores como entrada (por ejemplo para clasificar texto) **es necesario tranformar una secuencia de vectores de largo variable a un vector de una dimensión predeterminada**. \n", "\n", "Para esto existen varias alternativas, por ejemplo considerar un tamaño máximo de oración y **concatenar** los vectores de la entrada, truncando en caso de que supere el tamaño máximo o rellenando en caso de que el largo sea menor (*padding*). Otra alternativa es considerar una **operación numérica** de los vectores como el promedio (**centroide**) o **máximo** elemento a elemento. \n" ] }, { "cell_type": "markdown", "id": "f13743c0", "metadata": {}, "source": [ "##### Preparar datos y definición del modelo\n", "\n", "Defina un modelo de red neuronal para clasificar sentimiento que use como entrada una representación vectorial del texto (ej. centroide). Utilice la función para vectorizar usando centroido o máximo definida anteriormente para preparar los datos para ser utilizados por el modelo definido.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "2092a9f1", "metadata": {}, "outputs": [], "source": [ "import torch.utils.data\n", "\n", "batch_size = 64\n", "\n", "dtrain_vec = # ESCRIBA AQUI SU CODIGO\n", "dval_vec = # ESCRIBA AQUI SU CODIGO\n", "dtest_vec = # ESCRIBA AQUI SU CODIGO\n", "\n", "train_loader = torch.utils.data.DataLoader(dtrain_mean, batch_size=batch_size, shuffle=True)\n", "val_loader = torch.utils.data.DataLoader(dval_mean, batch_size=1, shuffle=True)\n", "test_loader = torch.utils.data.DataLoader(dtest_mean, batch_size=1, shuffle=False)" ] }, { "cell_type": "code", "execution_count": null, "id": "e7055950", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", "\n", "class Net(nn.Module):\n", "\n", " def __init__(self):\n", " super(Net, self).__init__()\n", " self.fc1 = nn.Linear(300, 50)\n", " self.fc2 = nn.Linear(50, 1)\n", " self.drop = nn.Dropout(0.2)\n", " \n", "\n", " def forward(self, x):\n", " x = F.relu(self.fc1(x))\n", " x = self.drop(x)\n", " x = F.self.fc2(x)\n", " return x\n" ] }, { "cell_type": "markdown", "id": "7e8c703f", "metadata": {}, "source": [ "##### Entrenar modelo\n", "\n", "Instancie el modelo definido anteriormente." ] }, { "cell_type": "code", "execution_count": null, "id": "5e308162", "metadata": {}, "outputs": [], "source": [ "net = Net()\n", "print(net)" ] }, { "cell_type": "markdown", "id": "5f7cfa9c", "metadata": {}, "source": [ "Función de pérdida y optimizador:" ] }, { "cell_type": "code", "execution_count": null, "id": "9fb3c921", "metadata": {}, "outputs": [], "source": [ "import torch.optim as optim\n", "\n", "criterion = nn.BCEWithLogitsLoss()\n", "optimizer = optim.Adam(net.parameters(), lr=0.001)\n" ] }, { "cell_type": "markdown", "id": "9076c386", "metadata": {}, "source": [ "Ciclo de entrenamiento:" ] }, { "cell_type": "code", "execution_count": null, "id": "467a4711", "metadata": {}, "outputs": [], "source": [ "best_val = None\n", "\n", "for epoch in range(1,20): \n", " # train\n", " running_loss = 0.0\n", " for i, (inputs, labels) in enumerate(train_loader):\n", " # forward pass\n", " outputs = net(inputs)\n", " # backward pass\n", " optimizer.zero_grad()\n", " loss = criterion(outputs, labels.unsqueeze(1))\n", " loss.backward()\n", " optimizer.step()\n", " \n", " # print (every 10 mini-batches)\n", " running_loss += loss.item()\n", " if i % 10 == 9: \n", " print(f'{epoch} [{i+1:3d}] loss: {running_loss / 10:.3f} ')\n", " running_loss = 0.0\n", " \n", " # validation loss\n", " running_loss_val = 0.0\n", " i_val = 0\n", " net.eval() \n", " for x_val, y_val in val_loader:\n", " i_val += 1\n", " output_val = net(x_val)\n", " loss_val = criterion(output_val, y_val.unsqueeze(1))\n", " running_loss_val += loss_val.item()\n", " loss_val = running_loss_val / i_val\n", " best_val = loss_val if (best_val is None) else best_val \n", " print(f'{epoch} [ ] val_loss: {loss_val :.3f}')\n", "\n", " # checkpoint (save)\n", " if loss_val <= best_val:\n", " best_val = loss_val\n", " torch.save({\n", " 'epoch': epoch,\n", " 'model_state_dict': net.state_dict(),\n", " 'loss': loss.item(),\n", " }, './chckpoint.tmp.pt')\n", " print(f'Checkpoint ({loss_val:.3f})')\n", "\n", "# load checkpoint\n", "print('Cargando checkpoint...')\n", "checkpoint = torch.load('./chckpoint.tmp.pt')\n", "print(f'Checkpoint epoch {checkpoint[\"epoch\"]}')\n", "net.load_state_dict(checkpoint['model_state_dict'])\n", " \n", "print('Fin entrenamiento')" ] }, { "cell_type": "markdown", "id": "0fae154e", "metadata": {}, "source": [ "##### Evaluar modelo\n", "\n", "Utilice la siguiente función para reportar los resultados obtenidos. Utilice los conjuntos train y val para ajustar los hiperparámetros de su modelo." ] }, { "cell_type": "code", "execution_count": null, "id": "06652fae", "metadata": {}, "outputs": [], "source": [ "from sklearn.metrics import classification_report\n", "\n", "def evaluate_model(model, corpus):\n", " x,y = zip(*corpus)\n", " x = torch.tensor(np.array(x))\n", " y = np.array(y)\n", " model.eval()\n", " with torch.no_grad():\n", " y_pred = model(x)\n", " y_pred = torch.sigmoid(y_pred)\n", " y_pred = torch.round(y_pred)\n", " y_pred = y_pred.detach().numpy()\n", " print(classification_report(y, y_pred))\n" ] }, { "cell_type": "code", "execution_count": null, "id": "77511f85", "metadata": {}, "outputs": [], "source": [ "# Resultados en train y val\n", "print(\"Resultados train:\")\n", "evaluate_model(net, dtrain_mean)\n", "\n", "print(\"Resultados val:\")\n", "evaluate_model(net, dval_mean)" ] }, { "cell_type": "markdown", "id": "42b22de8", "metadata": {}, "source": [ "##### Resultados\n", "\n", "Reporte los resultados obtenidos con su modelo en test (luego de elegir hiperparámetros).\n" ] }, { "cell_type": "code", "execution_count": null, "id": "b2e4fdb1", "metadata": {}, "outputs": [], "source": [ "print(\"Resultados test:\")\n", "evaluate_model(net, dtest_mean)" ] }, { "cell_type": "markdown", "id": "806dea97", "metadata": {}, "source": [ "# Neural Netowrks: RNN (Opcional)\n", "\n", "Extienda los experimentos realizados en la parte anterior utilizando un modelo de red neuronal recurrente (ej. LSTM). " ] }, { "cell_type": "markdown", "id": "76fb6962", "metadata": {}, "source": [ "##### Preparar datos y definición del modelo" ] }, { "cell_type": "code", "execution_count": null, "id": "2e3fab7a", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "03578480", "metadata": {}, "source": [ "##### Entrenar modelo" ] }, { "cell_type": "code", "execution_count": null, "id": "e7f089c0", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "88b1aa60", "metadata": {}, "source": [ "##### Evaluar modelo" ] }, { "cell_type": "code", "execution_count": null, "id": "e9a00372", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "5c8d617e", "metadata": {}, "source": [ "# Neural Networks: Transformer (Robertuito)\n", "\n", "En esta sección abordará la tarea con un transformer preentrenado. \n", "\n", "Utilizaremos Robertuito:\n", "- https://huggingface.co/pysentimiento/robertuito-sentiment-analysis?text=Te+quiero.+Te+amo.\n", " " ] }, { "cell_type": "markdown", "id": "541f7803", "metadata": {}, "source": [ "###### Instalación\n", "\n", "Instale Robertuito:" ] }, { "cell_type": "code", "execution_count": null, "id": "6d6f3ebf", "metadata": {}, "outputs": [], "source": [ "!pip install pysentimiento" ] }, { "cell_type": "markdown", "id": "f2403538", "metadata": {}, "source": [ "###### Instanciación\n", "\n", "Instancie Robertuito para realizar análisis de sentmiento en español:" ] }, { "cell_type": "code", "execution_count": null, "id": "20c6a701", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "06cd0ca8", "metadata": {}, "source": [ "###### Preparación de datos\n", "\n", "Prepare el conjunto de datos para ser etiquetado por Robertuito:" ] }, { "cell_type": "code", "execution_count": null, "id": "f4675668", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "20cdde6c", "metadata": {}, "source": [ "###### Ejecución de Robertuito\n", "\n", "Detecte el sentimiento utilizando Robertuito en el dataset impartido. Realice una interpretación de la salida de Robertuito que considere conveniente para etiquetar los datos en el formato adecuado." ] }, { "cell_type": "code", "execution_count": null, "id": "b88af0d5", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] }, { "cell_type": "markdown", "id": "2d5b7a73", "metadata": {}, "source": [ "###### Resultados obtenidos\n", "\n", "Reporte los resultados obtenidos." ] }, { "cell_type": "code", "execution_count": null, "id": "a61e3254", "metadata": {}, "outputs": [], "source": [ "# ESCRIBA AQUI SU CODIGO" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.8" } }, "nbformat": 4, "nbformat_minor": 5 }