Actualizado notebook Tarea 2

5c9f714f · Braulio Ríos · 1298b269 · 5c9f714f
Commit 5c9f714f authored Jun 15, 2023 by Braulio Ríos
--- a/Tarea_2/shakespeare_tarea_2.ipynb
+++ b/Tarea_2/shakespeare_tarea_2.ipynb
@@ -43,7 +43,6 @@
    "import matplotlib.pyplot as plt\n",
    "from sqlalchemy import create_engine\n",
    "\n",
-    "# Agregamos scikit-learn como dependencia en requirements.txt\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
@@ -64,7 +63,6 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "# Creamos el directorio Tarea_1/data/shakespeare\n",
    "data_dir = Path(\"data\") / \"shakespeare\"\n",
    "data_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
@@ -128,13 +126,13 @@
   },
   "outputs": [],
   "source": [
-    "# TODO: Actualizar con su versión de clean_text() en la Tarea_1\n",
+    "# TODO: Actualizar con su versión de clean_text() de la Tarea_1\n",
    "\n",
    "def clean_text(df, column_name):\n",
    "    # Convertir todo a minúsculas\n",
    "    result = df[column_name].str.lower()\n",
    "\n",
-    "    # FIXME:\n",
+    "    # FIXME: completar\n",
    "    for punc in [\"[\", \"\\n\", \",\"]:\n",
    "        result = result.str.replace(punc, \" \")\n",
    "    return result\n",

 %% Cell type:markdown id: tags:
 # Introducción a la Ciencia de Datos: Tarea 2
 Este notebook contiene el código de base para realizar la Tarea 2 del curso. Puede copiarlo en su propio repositorio y trabajar sobre el mismo.
 Las **instrucciones para ejecutar el notebook** están en la [página inicial del repositorio](https://gitlab.fing.edu.uy/maestria-cdaa/intro-cd/).
 **Se espera que no sea necesario revisar el código para corregir la tarea**, ya que todos los resultados y análisis relevantes deberían estar en el **informe en formato PDF**.
 %% Cell type:markdown id: tags:
 ## Cargar dependencias
 Para esta tarea, se han agregado algunos requerimientos, asegúrese de instalarlos (puede usar el mismo entorno virtual de la Tarea 1):
 %% Cell type:code id: tags:
 ``` python
 !pip install jupyter pandas "sqlalchemy<2.0" pymysql seaborn pillow scikit-learn
 ```
 %% Cell type:code id: tags:
 ``` python
 from time import time
 from pathlib import Path
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 from sqlalchemy import create_engine
-# Agregamos scikit-learn como dependencia en requirements.txt
 from sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
 from sklearn.naive_bayes import MultinomialNB
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import ConfusionMatrixDisplay
 ```
 %% Cell type:markdown id: tags:
 ## Conexión a la Base y Lectura de Datos
 %% Cell type:code id: tags:
 ``` python
-# Creamos el directorio Tarea_1/data/shakespeare
 data_dir = Path("data") / "shakespeare"
 data_dir.mkdir(parents=True, exist_ok=True)
 def load_table(table_name, engine):
    """
    Leer la tabla con SQL y guardarla como CSV,
    o cargarla desde el CSV si ya existe
    """
    path_table = data_dir / f"{table_name}.csv"
    if not path_table.exists():
        print(f"Consultando tabla con SQL: {table_name}")
        t0 = time()
        df_table = pd.read_sql(f"SELECT * FROM {table_name}", engine)
        t1 = time()
        print(f"Tiempo: {t1 - t0:.1f} segundos")
        print(f"Guardando: {path_table}\n")
        df_table.to_csv(path_table)
    else:
        print(f"Cargando tabla desde CSV: {path_table}")
        df_table = pd.read_csv(path_table, index_col=[0])
    return df_table
 print("Conectando a la base...")
 conn_str = "mysql+pymysql://guest:relational@relational.fit.cvut.cz:3306/Shakespeare"
 engine = create_engine(conn_str)
 # Todos los párrafos de todas las obras
 df_paragraphs = load_table("paragraphs", engine)
 df_characters = load_table("characters", engine)
 df_works = load_table("works", engine)
 df_chapters = load_table("chapters", engine)
 ```
 %% Cell type:code id: tags:
 ``` python
 df_paragraphs
 ```
 %% Cell type:markdown id: tags:
 ## Limpieza de Texto
 %% Cell type:code id: tags:
 ``` python
-# TODO: Actualizar con su versión de clean_text() en la Tarea_1
+# TODO: Actualizar con su versión de clean_text() de la Tarea_1
 def clean_text(df, column_name):
    # Convertir todo a minúsculas
    result = df[column_name].str.lower()
-    # FIXME:
+    # FIXME: completar
    for punc in ["[", "\n", ","]:
        result = result.str.replace(punc, " ")
    return result
 # Creamos una nueva columna CleanText a partir de PlainText
 df_paragraphs["CleanText"] = clean_text(df_paragraphs, "PlainText")
 # Veamos la diferencia
 df_paragraphs[["PlainText", "CleanText"]]
 ```
 %% Cell type:code id: tags:
 ``` python
 # Agregamos personajes, obras y géneros en el mismo dataset
 df_dataset = df_paragraphs.merge(df_chapters.set_index("id")["work_id"], left_on="chapter_id", right_index=True)
 df_dataset = df_dataset.merge(df_works.set_index("id")[["Title", "GenreType"]], left_on="work_id", right_index=True)
 df_dataset = df_dataset.merge(df_characters.set_index('id')["CharName"], left_on="character_id", right_index=True).sort_index()
 df_dataset = df_dataset[["CleanText", "CharName", "Title", "GenreType"]]
 # Usaremos sólo estos personajes
 characters = ["Antony", "Cleopatra", "Queen Margaret"]
 df_dataset = df_dataset[df_dataset["CharName"].isin(characters)]
 df_dataset
 ```
 %% Cell type:code id: tags:
 ``` python
 # Párrafos por cada personaje seleccionado
 df_dataset["CharName"].value_counts()
 ```
 %% Cell type:markdown id: tags:
 ## Dataset y Features de texto
 %% Cell type:code id: tags:
 ``` python
 X = df_dataset["CleanText"].to_numpy()
 y = df_dataset["CharName"].to_numpy()
 ```
 %% Cell type:code id: tags:
 ``` python
 # TODO: Partir train/test 30% estratificados
 # -> Definir X_train, X_test, y_train, y_test
 # X_train, X_test, y_train, y_test = ...
 print(f"Tamaños de Train/Test: {len(X_train)}/{len(X_test)}")
 ```
 %% Cell type:markdown id: tags:
 ### Conteo de palabras y TF-IDF
 %% Cell type:code id: tags:
 ``` python
 count_vect = CountVectorizer(stop_words=None, ngram_range=(1,1))
 X_train_counts = count_vect.fit_transform(X_train)
 X_train_counts
 ```
 %% Cell type:code id: tags:
 ``` python
 tf_idf = TfidfTransformer(use_idf=False)
 X_train_tf = tf_idf.fit_transform(X_train_counts)
 X_train_tf
 ```
 %% Cell type:markdown id: tags:
 ### Reducción de dimensionalidad
 %% Cell type:code id: tags:
 ``` python
 # TODO: Realizar PCA sobre los datos de entrenamiento
 # reductor = ...
 # Transformar train
 X_train_red = reductor.fit_transform(X_train_tf.toarray())
 ```
 %% Cell type:code id: tags:
 ``` python
 # Visualización de las dos primeras componentes de PCA
 fig, ax = plt.subplots(figsize=(6, 6))
 for character in np.unique(y_train):
    mask_train = y_train == character
    ax.scatter(X_train_red[mask_train, 0], X_train_red[mask_train, 1], label=character)
 ax.set_title("PCA por personaje")
 ax.legend()
 ```
 %% Cell type:markdown id: tags:
 ## Modelos de Clasificación
 %% Cell type:code id: tags:
 ``` python
 bayes_clf = MultinomialNB().fit(X_train_tf, y_train)
 # Ver las primeras 10 predicciones de train
 y_pred_train = bayes_clf.predict(X_train_tf)
 y_pred_train[:10]
 ```
 %% Cell type:code id: tags:
 ``` python
 def get_accuracy(y_true, y_pred):
    return (y_true == y_pred).sum() / len(y_true)
 get_accuracy(y_train, y_pred_train)
 ```
 %% Cell type:code id: tags:
 ``` python
 # TODO: Predecir para test y ver la matriz de confusión, y reportar accuracy
 # X_test_counts = ...
 # X_test_tfidf = ...
 # y_test_pred = ...
 ```
 %% Cell type:markdown id: tags:
 ### Búsqueda de hiper-parámetros con Cross-Validation
 %% Cell type:code id: tags:
 ``` python
 from sklearn.model_selection import StratifiedKFold
 # TODO: Agregar más variantes de parámetros que les parezcan relevantes
 param_sets = [{"stop_words": None, "ngram": (1,2), "idf": True},
             {"stop_words": None, "ngram": (1,1), "idf": False}]
 skf = StratifiedKFold(n_splits=4, shuffle=True, random_state=42)
 # Ahora usaremos train/validation/test
 # Por lo tanto le renombramos train+validation = dev(elopment) dataset
 X_dev = X_train
 y_dev = y_train
 # # Para evitar errores
 # del X_train
 # del y_train
 for params in param_sets:
    # Transormaciones a aplicar (featurizers)
    count_vect = CountVectorizer(stop_words=params["stop_words"], ngram_range=params["ngram"])
    tf_idf = TfidfTransformer(use_idf=params["idf"])
    for train_idxs, val_idxs in skf.split(X_dev, y_dev):
        # Train y validation para el split actual
        X_train_ = X_dev[train_idxs]
        y_train_ = y_dev[train_idxs]
        X_val = X_dev[val_idxs]
        y_val = y_dev[val_idxs]
        # Ajustamos y transformamos Train
        X_train_counts = count_vect.fit_transform(X_train_)
        X_train_tf = tf_idf.fit_transform(X_train_counts)
        # TODO: Completar el código para entrenar y evaluar
        # Entrenamos con Train
        # bayes_clf = ...
        # Transformamos Validation
        # X_val_counts = ...
        # X_val_tfidf = ...
        # Predecimos y evaluamos en Validation
        y_pred_val = bayes_clf.predict(X_val_tfidf)
        acc = get_accuracy(y_val, y_pred_val)
        print(f"{acc=:.4f} {params=}")
 ```
 %% Cell type:markdown id: tags:
 ### (Opcional) Comparativa con Fasttext
 %% Cell type:code id: tags:
 ``` python
 !pip install fasttext
 ```
 %% Cell type:code id: tags:
 ``` python
 import fasttext
 y_train_s = np.char.replace(y_train.astype(str), " ", "_").astype(object)
 y_test_s = np.char.replace(y_test.astype(str), " ", "_").astype(object)
 # Convertimos al formato de fasttext: archivo de texto donde cada línea es:
 # __label__<label> TEXTO
 Xytrains = "__label__" + y_train_s.astype(object) + " " + X_train
 Xytests = "__label__" + y_test_s.astype(object) + " " + X_test
 np.savetxt(data_dir / "train.txt", Xytrains, fmt="%s")
 np.savetxt(data_dir / "test.txt", Xytests, fmt="%s")
 Xytests[0]
 ```
 %% Cell type:code id: tags:
 ``` python
 model = fasttext.train_supervised(input=str(data_dir / "train.txt"), epoch=100, wordNgrams=2)
 model.test(str(data_dir / "test.txt"))
 ```
 %% Cell type:code id: tags:
 ``` python
 y_out = model.predict(list(X_test))
 y_pred_test = [y[0].replace("__label__", "") for y in y_out[0]]
 print(get_accuracy(y_test_s, y_pred_test))
 ```
 %% Cell type:code id: tags:
 ``` python
 ```