Entrenamiento en análisis de sentimientos con dataset de Twitter [Parte 3]

En este artículo realizaremos el entrenamiento en análisis de sentimientos con dataset de Twitter. En otros apartados hemos hecho tanta la carga de datos y descarga del dataset como el preprocesamiento y el testing. A continuación nos centraremos en el entrenamiento.

Entrenamiento en análisis de sentimientos con dataset de Twitter

Pasos previos

Hemos tenido que realizar la parte de testing de carpetas:

Dentro de estas carpetas debe haber distintas particiones de ficheros; estas particiones dependen del número de núcleos que hayamos utilizado para ejecutarlas. Si, por ejemplo, tenemos dos CPU, se nos generarán dos ficheros de partición, y sucede lo mismo si tenemos cuatro, ocho, etc.

Train

Antes de realizar el entrenamiento en análisis de sentimientos con dataset de Twitter a través de AI Platform, vamos a ejecutar en local para asegurarnos de que el script funciona y el empaquetado es correcto.

Para una ejecución que sea muy pesada, primero queremos probar sobre una pequeña porción del dataset para verificar la correcta ejecución antes de ejecutar en GCP con el dataset completo.

Ejecuta la siguiente celda para entrenar el modelo localmente:

#Entrenamiento en análisis de sentimientos con dataset de Twitter
# Explicitly tell 'gcloud ai-platform local train' to use Python 3
! gcloud config set ml_engine/local_python $ (which python3)

#This is similar to 'python -m trainer.task --job - dir local - training - output' but is better replicates the AI Platform environment, especially for distributed training (not applicable here).
! gcloud ai - platform local train \
  --package - path trainer \
  --module - name trainer.task \
  -- \
  --work - dir $WORK_DIR \
  --epochs 1

Dentro de la carpeta trainer vamos a crear un fichero con la extensión task.py.

Dentro de este fichero copiaremos el siguiente código:

#Entrenamiento en análisis de sentimientos con dataset de Twitter
from __future__ import absolute_import

import argparse
import multiprocessing as mp
import logging
import tempfile
import os

import pickle
import gensim
import pandas as pd
import numpy as np
import tensorflow as tf

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import (
       Dense,
       Dropout,
       Embedding,
       LSTM,
)

#Entrenamiento en análisis de sentimientos con dataset de Twitter
from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping
from sklearn.preprocessing import LabelEncoder

#WORD2VEC
W2V_SIZE = 300
W2V_WINDOW = 7
#32
W2V_EPOCH = 5
W2V_MIN_COUNT = 10

#KERAS
SEQUENCE_LENGTH = 300

#SENTIMENT
POSITIVE = "POSITIVE"
NEGATIVE = "NEGATIVE"
NEUTRAL = "NEUTRAL"
SENTIMENT_THRESHOLDS = (0.4, 0.7)

#EXPORT
KERAS_MODEL = "model.h5"
WORD2VEC_MODEL = "model.w2v"
TOKENIZER_MODEL = "tokenizer.pkl"
ENCODER_MODEL = "encoder.pkl"


def generate_word2vec (train_df):
       documents = [_text.split () for _text in train_df.text.values]
       w2v_model = gensim.models.word2vec.Word2Vec (
              size = W2V_SIZE,
              window = W2V_WINDOW,
              min_count = W2V_MIN_COUNT,
              workers = mp.cpu_count (),
)
       w2v_model.build_vocab (documents)

       words = w2v_model.wv.vocab.keys ()
       vocab_size = len (words)
       logging.info (f "Vocab size: {vocab_size}")
       w2v_model.train (documents, total_examples = len (documents), epochs = W2V_EPOCH)

       return w2v_model
       
def generate_tokenizer (train_df):
       tokenizer = Tokenizer ()
       tokenizer.fit_on_texts (train_df.text)
       vocab_size = len (tokenizer.word_index) + 1
       logging.info (f "Total words: {vocab_size}")
       return tokenizer, vocab_size

def generate_label_encoder (train_df):
       encoder = LabelEncoder ()
       encoder.fit (train_df.sentiment.tolist ())
       return encoder

def generate embedding (word2vec_model, vocab_size, tokenizer):
       for word, i in tokenizer.word_index .items ():
              if word in word2vec_model.wv:
                     embedding_matrix [i] = word2vec_model.wv [word]
       return Embedding (
              vocab_size,
              W2V_SIZE,
              weights = [embedding_matrix],
              input_length = SEQUENCE_LENGTH,
              trainable = False,
       )


def train_and_evaluate (
       work_dir, train_df, eval_df, batch_size = 1024, epochs = 8, steps = 1000
):

#Entrenamiento en análisis de sentimientos con dataset de Twitter
       " " "
       Trains and evaluates the estimator given.
       The input functions are generated by the preprocessing function.
       " " "
       model_dir = os.path.join (work_dir, "data / model")
       if tf.io.gfile .exusts (model_dir):
              tf.io. gfile.remtree (model_dir)
       tf.io. gfile.mkdir (model_dir)

       #Specify where to store our model
       run_config = tf.estimator.RunConfig ()
       run_config = run_config.replace (model_dir = model_dir)

       #This will give us a more granular visualization of the training
       run_config = run_config.replace (save_summary_steps = 10)

       #Create Word2vec of training data
       logging.info ("---- Generating word2vec model ----")
       word2vec_model = generate_word2vec (train_df)

       #Tokenize training data
       logging.info ("---- Generating tokenizer ----")
       tokenizer, vocab_size = generate_tokenizer (train_df)

       logging.info ("---- Tokenizing train data ----")
       
#Entrenamiento en análisis de sentimientos con dataset de Twitter

if __name__ == "__main__":

       " " "Main function called by AI Platform. " " "

       logging.getLogger().setLevel (logging.INFO)

       parser = argparse.ArgumentParser (
              formatter_class = argparse. ArgumentDefaultsHelpFormatter
       )

       parser.add_argument (
              "-- job - dir",
              help = "Directory for staging trainer files."
              "This can be a Google Cloud Storage path.",
       )

       parser.add_argument (
              "work - dir",
              help = "Directory for staging and working files. "
              "This can be a Google Cloud Storage path",
       )       

       parser.add_argument (
              "--batch - size",
              type = int,
              default = 1024,
              help = "Batch size for training and evaluation.",
       )

       parser.add_argument (
              "--epochs", type = int, default = 8, help = "Number of epochs to train the model", 
       )

       parser.add_argument (
              "--steps",
              type = int,
              default = 1000,
              help = "Number of steps per epochs to train the model",
       )

       args = parser.parse_args ()

       train_data_files = tf.io.gfile.glob (
              os.path.join (args.work_dir, "data/transformed_data/train/part-*")
       )
       eval_data_files =  tf.io.gfile.glob (
              os.path.join (args.work_dir, "data/transformed_data/eval/part-*")
       )

       train_data_files = None

¿Qué seguir avanzando?

Ahora que hemos visto cómo hacer el entrenamiento en análisis de sentimientos con dataset de Twitter, podemos seguir avanzando en nuestra formación. Para ello, KeepCoding te ofrece el Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp, una formación de alta intensidad con la que podrás convertirte en un gran data scientist en pocos meses. ¡Solicita más información y cambia tu futuro!