Curso
Ingeniería de características para NLP en Python
4 h
29.6K
Introducción a NLP y PyTorch
El procesamiento del lenguaje natural (NLP) es un componente clave de la IA moderna que permite a las máquinas entender y responder al lenguaje humano. A medida que proliferan las interacciones digitales, su importancia no deja de crecer. PyTorch, una popular biblioteca de aprendizaje automático de código abierto, ofrece herramientas potentes para tareas de NLP gracias a su flexibilidad y a sus eficientes cálculos con tensores. Su grafo computacional dinámico también facilita modificar y crear modelos complejos, lo que la hace ideal para este tutorial.
Si te interesa aprender más sobre NLP, echa un vistazo a nuestro itinerario de habilidades Natural Language Processing in Python; o, si prefieres aprender el arte del NLP en R, visita el curso Introduction to Natural Language Processing in R en DataCamp.
Configuración del entorno
Configurar el entorno de PyTorch puede ser algo complejo según factores como el sistema operativo, el gestor de paquetes, el lenguaje de programación y la plataforma de cómputo. El proceso de instalación puede variar ligeramente en función de estos factores y requerir que ejecutes comandos específicos.
Para obtener el comando de instalación adecuado, visita la página oficial de PyTorch get started, donde podrás seleccionar tus preferencias y recibir las instrucciones necesarias.
Usaremos DataLab en este tutorial. El código completo para entrenar un modelo de análisis de sentimiento con PyTorch está disponible en este cuaderno de DataLab si quieres seguirlo paso a paso.
Introducción a los tensores
Los tensores son estructuras de datos fundamentales en matemáticas y física que generalizan escalares, vectores y matrices. Son arrays multidimensionales capaces de almacenar y manipular grandes volúmenes de datos numéricos de forma eficiente. Los tensores tienen forma, tamaño y tipo de dato definidos, lo que los hace muy versátiles para distintas operaciones computacionales.
En el contexto de PyTorch, los tensores son el bloque básico y el objeto de representación de datos. Se parecen a los arrays de NumPy, pero incorporan funcionalidades y optimizaciones adicionales diseñadas específicamente para el deep learning. Las operaciones con tensores en PyTorch aprovechan la aceleración por hardware, como las GPU, para calcular de forma eficiente redes neuronales complejas.
Los tensores resultan esenciales en tareas de NLP por la naturaleza secuencial y jerárquica de los datos lingüísticos.
NLP implica procesar y comprender información textual. Los tensores permiten representar y manipular texto codificando palabras, frases o documentos como vectores numéricos.
Esta representación numérica permite que los modelos de deep learning procesen y aprendan eficazmente a partir de datos textuales. Los tensores facilitan manejar conjuntos de datos lingüísticos a gran escala, entrenar redes neuronales y aplicar técnicas avanzadas como los mecanismos de atención para lograr modelos de NLP más precisos.
Embeddings de palabras
Los embeddings de palabras son representaciones densas de palabras en un espacio vectorial continuo. Buscan capturar relaciones semánticas y sintácticas entre palabras, lo que permite una mejor comprensión y contextualización del texto. Al representar las palabras como vectores numéricos, los embeddings recogen similitudes y diferencias semánticas y permiten que los algoritmos trabajen con palabras como entradas numéricas con significado.
En pocas palabras, los embeddings son una forma ingeniosa de representar palabras como números. Estos números tienen significados especiales que capturan cómo se relacionan las palabras entre sí. Es como un código secreto que ayuda a los ordenadores a entender y trabajar con palabras más fácilmente.
Word2Vec y GloVe son dos métodos muy populares para generar embeddings. Word2Vec es un modelo basado en redes neuronales que aprende representaciones prediciendo las palabras del entorno dada una palabra objetivo (continuous bag of words - CBOW) o prediciendo la palabra objetivo a partir de su contexto (skip-gram).
GloVe (Global Vectors for Word Representation) es un método basado en conteos que construye vectores a partir de las estadísticas de coocurrencia de palabras en un gran corpus. Captura relaciones globales y suele ofrecer mejor rendimiento en tareas de analogías.
Arquitectura de un modelo de NLP
Ejemplo de arquitectura de modelo para una tarea de análisis de sentimiento.
El análisis de sentimiento es una tarea habitual en NLP cuyo objetivo es entender el sentimiento expresado en un texto, normalmente clasificado como positivo, negativo o neutral. Para abordarla, puede usarse una red neuronal recurrente (RNN) sencilla o una versión más avanzada llamada long short-term memory (LSTM).
RNN
La arquitectura RNN procesa el texto de forma secuencial, introduciendo cada palabra una tras otra. La red mantiene un estado oculto que cambia con cada palabra de entrada y captura la información de la secuencia procesada hasta ese momento.
Este estado oculto actúa como la memoria de la red. Sin embargo, las RNN estándar tienen dificultades con secuencias largas debido al llamado problema del gradiente desvanecido: la contribución de la información decae geométricamente con el tiempo y la red “olvida” entradas anteriores. Puedes saber más sobre redes neuronales recurrentes en nuestro tutorial de RNN.
LSTM
Para resolverlo, se desarrollaron las LSTM, una variante de RNN. Una LSTM mantiene un contexto o "memoria" más larga gracias a una estructura interna más compleja en su estado oculto. Incluye una serie de "puertas" (de entrada, olvido y salida) que controlan el flujo de información hacia y desde el estado de memoria.
La puerta de entrada determina cuánto de la información entrante debe almacenarse en la memoria. La puerta de olvido decide qué información descartar y la puerta de salida define cuánto del estado interno se expone a la siguiente unidad LSTM de la secuencia.
Un modelo RNN o LSTM recibe como entrada una secuencia de palabras de una frase o documento. Cada palabra suele representarse como un vector denso, o embedding, que captura su significado semántico.
La red procesa la secuencia palabra a palabra, actualizando su estado interno en función de la palabra actual y del estado anterior.
El estado final de la red se usa para predecir el sentimiento. Se pasa por una capa totalmente conectada y, después, por una función de activación softmax para obtener una distribución de probabilidad sobre las clases de sentimiento (p. ej., positivo, negativo, neutral).
La clase con mayor probabilidad se elige como la predicción del modelo.
Esta es una configuración básica que puede mejorarse con técnicas como LSTM bidireccionales (que procesan la secuencia en ambas direcciones) y mecanismos de atención (que permiten al modelo centrarse en las partes más relevantes de la secuencia), entre otras.
Entrenar un modelo LSTM en PyTorch para análisis de sentimiento
Ejemplo de código Python de extremo a extremo para construir un modelo de análisis de sentimiento con PyTorch
1. Carga del conjunto de datos
En este ejemplo usaremos el IMDB dataset of 50K Movie reviews. El objetivo es entrenar un modelo LSTM que prediga el sentimiento. Hay dos valores posibles: "positive" y "negative". Por tanto, es una tarea de clasificación binaria.
file_name = 'IMDB Dataset.csv'
df = pd.read_csv(file_name)
df.head()
2. Análisis exploratorio de datos
X,y = df['review'].values,df['sentiment'].values
x_train,x_test,y_train,y_test = train_test_split(X,y,stratify=y)
print(f'train data shape: {x_train.shape}')
print(f'test data shape: {x_test.shape}')
dd = pd.Series(y_train).value_counts()
sns.barplot(x=np.array(['negative','positive']),y=dd.values)
plt.show()
Salida:
>>> train data shape: (37500,)
>>> test data shape: (12500,)
3. Preprocesamiento de texto
El preprocesamiento y la tokenización del texto son un primer paso crucial. Primero, limpiamos el texto eliminando signos de puntuación, espacios extra y números.
Después transformamos las frases en palabras individuales, eliminamos palabras muy comunes ("stop words") y registramos las 1000 palabras más frecuentes del conjunto. A estas palabras se les asigna un identificador único, formando un diccionario para el one-hot encoding.
En esencia, el código convierte las frases originales en secuencias de estos identificadores únicos, traduciendo el lenguaje humano a un formato que un modelo de aprendizaje automático pueda entender.
def preprocess_string(s):
# Remove all non-word characters (everything except numbers and letters)
s = re.sub(r"[^\w\s]", '', s)
# Replace all runs of whitespaces with no space
s = re.sub(r"\s+", '', s)
# replace digits with no space
s = re.sub(r"\d", '', s)
return s
def tokenize(x_train,y_train,x_val,y_val):
word_list = []
stop_words = set(stopwords.words('english'))
for sent in x_train:
for word in sent.lower().split():
word = preprocess_string(word)
if word not in stop_words and word != '':
word_list.append(word)
corpus = Counter(word_list)
# sorting on the basis of most common words
corpus_ = sorted(corpus,key=corpus.get,reverse=True)[:1000]
# creating a dict
onehot_dict = {w:i+1 for i,w in enumerate(corpus_)}
# tokenize
final_list_train,final_list_test = [],[]
for sent in x_train:
final_list_train.append([onehot_dict[preprocess_string(word)] for word in sent.lower().split()
if preprocess_string(word) in onehot_dict.keys()])
for sent in x_val:
final_list_test.append([onehot_dict[preprocess_string(word)] for word in sent.lower().split()
if preprocess_string(word) in onehot_dict.keys()])
encoded_train = [1 if label =='positive' else 0 for label in y_train]
encoded_test = [1 if label =='positive' else 0 for label in y_val]
return np.array(final_list_train), np.array(encoded_train),np.array(final_list_test), np.array(encoded_test),onehot_dict
x_train,y_train,x_test,y_test,vocab = tokenize(x_train,y_train,x_test,y_test)
Analicemos ahora la longitud de los tokens en x_train.
rev_len = [len(i) for i in x_train]
pd.Series(rev_len).hist()
4. Preparación de los datos para el modelo
Dadas las longitudes variables de tokens en cada reseña, es necesario estandarizarlas para mantener la consistencia. Como la mayoría de reseñas contienen menos de 500 tokens, fijaremos 500 como longitud estándar para todas.
def padding_(sentences, seq_len):
features = np.zeros((len(sentences), seq_len),dtype=int)
for ii, review in enumerate(sentences):
if len(review) != 0:
features[ii, -len(review):] = np.array(review)[:seq_len]
return features
x_train_pad = padding_(x_train,500)
x_test_pad = padding_(x_test,500)A continuación utilizamos la clase DataLoader para crear el conjunto de datos final de entrenamiento del modelo.
# create Tensor datasets
train_data = TensorDataset(torch.from_numpy(x_train_pad), torch.from_numpy(y_train))
valid_data = TensorDataset(torch.from_numpy(x_test_pad), torch.from_numpy(y_test))
# dataloaders
batch_size = 50
# make sure to SHUFFLE your data
train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size)
valid_loader = DataLoader(valid_data, shuffle=True, batch_size=batch_size)
# obtain one batch of training data
dataiter = iter(train_loader)
sample_x, sample_y = next(dataiter)
print('Sample input size: ', sample_x.size()) # batch_size, seq_length
print('Sample input: \n', sample_x)
print('Sample output: \n', sample_y)Salida:
5. Definir el modelo LSTM
Esta parte del código define un modelo de análisis de sentimiento con una arquitectura de red neuronal recurrente (RNN), concretamente una Long Short-Term Memory (LSTM), como hemos mencionado antes. La clase SentimentRNN es un modelo de PyTorch que empieza con una capa de embedding, que transforma los índices de palabras en una representación densa que captura el significado semántico. A continuación incorpora una capa LSTM que procesa la secuencia de embeddings.
El estado oculto de la LSTM pasa por una capa de dropout (para regularizar el modelo y evitar sobreajuste) y una capa totalmente conectada, que mapea las salidas de la LSTM a la predicción final. La predicción pasa por una función sigmoide que convierte los valores brutos en probabilidades. El método forward define el paso hacia delante de los datos por la red, y el método init_hidden inicializa los estados ocultos de la LSTM a ceros.
class SentimentRNN(nn.Module):
def __init__(self,no_layers,vocab_size,hidden_dim,embedding_dim,drop_prob=0.5):
super(SentimentRNN,self).__init__()
self.output_dim = output_dim
self.hidden_dim = hidden_dim
self.no_layers = no_layers
self.vocab_size = vocab_size
# embedding and LSTM layers
self.embedding = nn.Embedding(vocab_size, embedding_dim)
#lstm
self.lstm = nn.LSTM(input_size=embedding_dim,hidden_size=self.hidden_dim,
num_layers=no_layers, batch_first=True)
# dropout layer
self.dropout = nn.Dropout(0.3)
# linear and sigmoid layer
self.fc = nn.Linear(self.hidden_dim, output_dim)
self.sig = nn.Sigmoid()
def forward(self,x,hidden):
batch_size = x.size(0)
# embeddings and lstm_out
embeds = self.embedding(x) # shape: B x S x Feature since batch = True
#print(embeds.shape) #[50, 500, 1000]
lstm_out, hidden = self.lstm(embeds, hidden)
lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim)
# dropout and fully connected layer
out = self.dropout(lstm_out)
out = self.fc(out)
# sigmoid function
sig_out = self.sig(out)
# reshape to be batch_size first
sig_out = sig_out.view(batch_size, -1)
sig_out = sig_out[:, -1] # get last batch of labels
# return last sigmoid output and hidden state
return sig_out, hidden
def init_hidden(self, batch_size):
''' Initializes hidden state '''
# Create two new tensors with sizes n_layers x batch_size x hidden_dim,
# initialized to zero, for hidden state and cell state of LSTM
h0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)
c0 = torch.zeros((self.no_layers,batch_size,self.hidden_dim)).to(device)
hidden = (h0,c0)
return hidden Ahora inicializaremos la clase SentimentRNN que definimos arriba con los parámetros necesarios.
no_layers = 2
vocab_size = len(vocab) + 1 #extra 1 for padding
embedding_dim = 64
output_dim = 1
hidden_dim = 256
model = SentimentRNN(no_layers,vocab_size,hidden_dim,embedding_dim,drop_prob=0.5)
#moving to gpu
model.to(device)
print(model)
El último paso antes de empezar el entrenamiento es definir las funciones de pérdida y optimización. Aquí nos centramos en la función de pérdida, el método de optimización y una función de utilidad para calcular la precisión de nuestro modelo de análisis de sentimiento.
La función de pérdida utilizada es Binary Cross-Entropy Loss (nn.BCELoss), habitual en tareas de clasificación binaria como esta. El método de optimización es Adam (torch.optim.Adam), muy popular por su eficiencia y bajo consumo de memoria. La tasa de aprendizaje de Adam se fija en 0.001.
La función acc es un helper diseñado para calcular la precisión de las predicciones del modelo. Redondea las probabilidades predichas al entero más cercano (0 o 1), las compara con las etiquetas reales y calcula el porcentaje de aciertos.
# loss and optimization functions
lr=0.001
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
# function to predict accuracy
def acc(pred,label):
pred = torch.round(pred.squeeze())
return torch.sum(pred == label.squeeze()).item()
6. Comenzar el entrenamiento
Aquí es donde se entrena y valida el modelo de análisis de sentimiento. Cada época (iteración) incluye una fase de entrenamiento y otra de validación. Durante el entrenamiento, el modelo aprende ajustando sus parámetros para minimizar la pérdida.
En la validación se evalúa el rendimiento en un conjunto separado para asegurar que está aprendiendo patrones generalizables y no memorizando los datos de entrenamiento.
El bucle de entrenamiento inicia los estados ocultos de la LSTM y pone el modelo en modo de entrenamiento. En cada lote de datos, las predicciones del modelo se comparan con las etiquetas reales para calcular la pérdida, que se retropropaga para actualizar los parámetros.
Los gradientes se recortan a un valor máximo para evitar que crezcan en exceso, un problema común al entrenar RNN y LSTM.
En el bucle de validación, el modelo se pone en modo de evaluación y se valora su rendimiento con los datos de validación sin actualizar parámetros. En ambas fases, el código registra la pérdida y la precisión por época.
Si la pérdida de validación mejora, se guardan los parámetros actuales del modelo, conservando la mejor versión encontrada durante el entrenamiento.
Por último, tras cada época se imprime la pérdida y la precisión medias, lo que permite seguir el progreso del aprendizaje.
clip = 5
epochs = 5
valid_loss_min = np.Inf
# train for some number of epochs
epoch_tr_loss,epoch_vl_loss = [],[]
epoch_tr_acc,epoch_vl_acc = [],[]
for epoch in range(epochs):
train_losses = []
train_acc = 0.0
model.train()
# initialize hidden state
h = model.init_hidden(batch_size)
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
# Creating new variables for the hidden state, otherwise
# we'd backprop through the entire training history
h = tuple([each.data for each in h])
model.zero_grad()
output,h = model(inputs,h)
# calculate the loss and perform backprop
loss = criterion(output.squeeze(), labels.float())
loss.backward()
train_losses.append(loss.item())
# calculating accuracy
accuracy = acc(output,labels)
train_acc += accuracy
#`clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.
nn.utils.clip_grad_norm_(model.parameters(), clip)
optimizer.step()
val_h = model.init_hidden(batch_size)
val_losses = []
val_acc = 0.0
model.eval()
for inputs, labels in valid_loader:
val_h = tuple([each.data for each in val_h])
inputs, labels = inputs.to(device), labels.to(device)
output, val_h = model(inputs, val_h)
val_loss = criterion(output.squeeze(), labels.float())
val_losses.append(val_loss.item())
accuracy = acc(output,labels)
val_acc += accuracy
epoch_train_loss = np.mean(train_losses)
epoch_val_loss = np.mean(val_losses)
epoch_train_acc = train_acc/len(train_loader.dataset)
epoch_val_acc = val_acc/len(valid_loader.dataset)
epoch_tr_loss.append(epoch_train_loss)
epoch_vl_loss.append(epoch_val_loss)
epoch_tr_acc.append(epoch_train_acc)
epoch_vl_acc.append(epoch_val_acc)
print(f'Epoch {epoch+1}')
print(f'train_loss : {epoch_train_loss} val_loss : {epoch_val_loss}')
print(f'train_accuracy : {epoch_train_acc*100} val_accuracy : {epoch_val_acc*100}')
if epoch_val_loss <= valid_loss_min:
torch.save(model.state_dict(), 'state_dict.pt')
print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(valid_loss_min,epoch_val_loss))
valid_loss_min = epoch_val_loss
print(25*'==')Salida:
7. Evaluación del modelo
Esta parte del código genera dos gráficos para representar visualmente la precisión y la pérdida de entrenamiento y validación durante el proceso. El primer subgráfico muestra una línea con la precisión de entrenamiento y validación tras cada época, útil para observar cómo aprende y generaliza el modelo.
El segundo subgráfico muestra la pérdida de entrenamiento y validación. Esto ayuda a ver si el modelo está sobreajustando, infraajustando o ajustando correctamente.
fig = plt.figure(figsize = (20, 6))
plt.subplot(1, 2, 1)
plt.plot(epoch_tr_acc, label='Train Acc')
plt.plot(epoch_vl_acc, label='Validation Acc')
plt.title("Accuracy")
plt.legend()
plt.grid()
plt.subplot(1, 2, 2)
plt.plot(epoch_tr_loss, label='Train loss')
plt.plot(epoch_vl_loss, label='Validation loss')
plt.title("Loss")
plt.legend()
plt.grid()
plt.show()
Salida:
8. Inferencia / predicción
En esta parte creamos una función predict_text para predecir el sentimiento de un texto dado, y mostramos cómo utilizarla. La función predict_text recibe un texto como entrada, lo transforma en una secuencia de índices de palabras (según un vocabulario predefinido) y lo prepara para el modelo con padding y cambio de forma. Después inicializa los estados ocultos de la LSTM, introduce la entrada en el modelo y devuelve la probabilidad de salida para el texto en bruto.
def predict_text(text):
word_seq = np.array([vocab[preprocess_string(word)] for word in text.split()
if preprocess_string(word) in vocab.keys()])
word_seq = np.expand_dims(word_seq,axis=0)
pad = torch.from_numpy(padding_(word_seq,500))
inputs = pad.to(device)
batch_size = 1
h = model.init_hidden(batch_size)
h = tuple([each.data for each in h])
output, h = model(inputs, h)
return(output.item())
index = 30
print(df['review'][index])
print('='*70)
print(f'Actual sentiment is : {df["sentiment"][index]}')
print('='*70)
pro = predict_text(df['review'][index])
status = "positive" if pro > 0.5 else "negative"
pro = (1 - pro) if status == "negative" else pro
print(f'Predicted sentiment is {status} with a probability of {pro}')
Salida:
Este cuaderno completo se desarrolló en DataLab y puedes acceder a él en este workbook. Ten en cuenta que ejecutar el código puede llevar bastante tiempo si usas CPU. No obstante, con una GPU el tiempo de entrenamiento se reduce de forma significativa.
Próximos pasos / cómo mejorar el modelo
Mejorar un modelo de NLP suele implicar múltiples estrategias adaptadas a los requisitos y limitaciones de la tarea. El ajuste de hiperparámetros es una práctica común que consiste en modificar parámetros como la tasa de aprendizaje, el tamaño de lote o el número de capas de una red neuronal.
Estos hiperparámetros influyen de forma notable en el rendimiento del modelo y suelen optimizarse con técnicas como grid search o random search.
El aprendizaje por transferencia, especialmente con modelos como BERT o GPT, ha demostrado un gran potencial para mejorar tareas de NLP. Estos modelos se preentrenan en grandes corpus de texto y luego se ajustan a una tarea específica, aprovechando la comprensión general del lenguaje adquirida en el preentrenamiento. Este enfoque ha logrado resultados de vanguardia en un amplio abanico de tareas, incluido el análisis de sentimiento.
Aplicaciones reales de NLP con PyTorch
El uso de modelos de procesamiento del lenguaje natural (NLP), en particular los implementados con frameworks como PyTorch, se ha extendido ampliamente en aplicaciones reales y ha revolucionado muchos aspectos de nuestra vida digital.
Los chatbots se han convertido en una pieza fundamental de las plataformas de atención al cliente, aprovechando modelos de NLP para entender y responder a las consultas de las personas usuarias. Estos modelos procesan el lenguaje natural, infieren la intención y generan respuestas cercanas a las humanas, ofreciendo interacciones fluidas.
En el ámbito de los sistemas de recomendación, los modelos de NLP ayudan a analizar reseñas y comentarios para entender preferencias y así mejorar la personalización.
Las herramientas de análisis de sentimiento también dependen en gran medida de NLP. Pueden analizar publicaciones en redes sociales, reseñas de clientes o cualquier texto e inferir el sentimiento subyacente. Las empresas utilizan estas ideas para investigación de mercado o para medir la opinión pública sobre sus productos o servicios, lo que les permite tomar decisiones basadas en datos.
Descubre más casos de uso reales de Google BERT en este Natural Language Processing Tutorial.
Conclusión
PyTorch ofrece una plataforma potente y flexible para crear modelos de NLP. En este tutorial hemos recorrido el proceso de desarrollar un modelo de análisis de sentimiento con una arquitectura LSTM, destacando pasos clave como el preprocesamiento del texto, la construcción del modelo, su entrenamiento y validación, y por último la predicción sobre datos no vistos.
Esto es solo una muestra de lo que es posible con NLP y PyTorch. Las aplicaciones son enormes: desde chatbots y sistemas de recomendación hasta herramientas de análisis de sentimiento y mucho más.
La evolución constante del campo, especialmente con la llegada de modelos de transferencia como BERT y GPT, abre posibilidades aún más interesantes para seguir explorando. Dominar NLP con PyTorch es un reto, pero también muy gratificante, porque abre una nueva forma de entender e interactuar con el mundo que nos rodea.
Si quieres profundizar en PyTorch, echa un vistazo a nuestro curso Deep Learning with PyTorch. Empezarás con una introducción a PyTorch, explorando la biblioteca y sus aplicaciones para redes neuronales y deep learning. Después verás redes neuronales artificiales y aprenderás a entrenarlas con datos reales.
Temas
