Crear una red neuronal para clasificar reseñas de películas como positivas o negativas

Tiempo de lectura: 3 minutos

Hoy os voy a enseñar cómo crear una Red Neuronal aplicada a Inteligencia Artificial (IA) con la que podremos clasificar reseñas de películas como positivas o negativas.

Paso 1: Preparar los datos

En primer lugar, necesitamos obtener los datos para entrenar nuestra red neuronal. En este caso, utilizaremos el conjunto de datos de reseñas de películas de IMDB, que contiene 50,000 reseñas etiquetadas como positivas o negativas.

Podemos obtener este conjunto de datos a través del paquete tf.keras.datasets de TensorFlow, como se muestra a continuación:

import tensorflow as tf

(train_data, train_labels), (test_data, test_labels) = tf.keras.datasets.imdb.load_data(num_words=10000)

Aquí, estamos cargando los datos de entrenamiento y prueba, y limitando el número de palabras a las 10,000 más comunes en el conjunto de datos.

Paso 2: Preprocesar los datos

Una vez que tenemos los datos, necesitamos preprocesarlos antes de alimentarlos a nuestra red neuronal. En este caso, utilizaremos la técnica de padding para asegurarnos de que todas las secuencias de texto tengan la misma longitud.

train_data = tf.keras.preprocessing.sequence.pad_sequences(train_data, maxlen=256)
test_data = tf.keras.preprocessing.sequence.pad_sequences(test_data, maxlen=256)

Paso 3: Definir la arquitectura de la red neuronal

Ahora, podemos definir la arquitectura de nuestra red neuronal. En este ejemplo, utilizaremos una red neuronal densa con dos capas ocultas y una capa de salida.

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 16),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

Aquí, estamos definiendo una capa de embedding, que transforma la entrada (en este caso, secuencias de texto) en vectores densos. Luego, utilizamos una capa de pooling para reducir la dimensionalidad de los vectores, seguida de dos capas densas con funciones de activación ReLU y sigmoide, respectivamente.

Paso 4: Compilar y entrenar la red neuronal

Una vez que hemos definido la arquitectura de la red neuronal, podemos compilarla y entrenarla utilizando el conjunto de datos de entrenamiento.

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
history = model.fit(train_data, train_labels, epochs=10, validation_data=(test_data, test_labels))

Aquí, estamos utilizando el optimizador Adam y la función de pérdida binary cross-entropy para compilar la red neuronal. Luego, entrenamos la red neuronal durante 10 épocas y utilizamos el conjunto de datos de prueba como validación.

Paso 5: Evaluar la red neuronal

Finalmente, podemos evaluar la precisión de nuestra red neuronal utilizando el conjunto de datos de prueba.

loss, accuracy = model.evaluate(test_data, test_labels)
print('Accuracy: {:.2f}%'.format(accuracy * 100))

Ejemplo completo

import tensorflow as tf
from tensorflow import keras

# Cargar el conjunto de datos de IMDB
imdb = keras.datasets.imdb
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

# Preprocesar los datos
train_data = keras.preprocessing.sequence.pad_sequences(train_data, value=0, padding='post', maxlen=256)
test_data = keras.preprocessing.sequence.pad_sequences(test_data, value=0, padding='post', maxlen=256)

# Definir la arquitectura de la red neuronal
model = keras.Sequential()
model.add(keras.layers.Embedding(10000, 16))
model.add(keras.layers.GlobalAveragePooling1D())
model.add(keras.layers.Dense(16, activation=tf.nn.relu))
model.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))

# Compilar y entrenar la red neuronal
model.compile(optimizer=tf.optimizers.Adam(),
              loss='binary_crossentropy',
              metrics=['accuracy'])

history = model.fit(train_data,
                    train_labels,
                    epochs=10,
                    batch_size=512,
                    validation_data=(test_data, test_labels),
                    verbose=1)

# Evaluar la red neuronal
results = model.evaluate(test_data, test_labels)
print('Test accuracy: ', results[1])

En este ejemplo, primero cargamos el conjunto de datos de IMDB utilizando la función load_data() del módulo keras.datasets.imdb. A continuación, preprocesamos los datos utilizando la función pad_sequences() del módulo keras.preprocessing.sequence para asegurarnos de que todas las reseñas tengan la misma longitud.

A continuación, definimos la arquitectura de la red neuronal utilizando la clase Sequential() del módulo keras.models, y agregamos capas utilizando la función add().

Después de definir la arquitectura de la red neuronal, compilamos y entrenamos la red neuronal utilizando la función compile() y la función fit(), respectivamente. En este caso, utilizamos el optimizador Adam y la función de pérdida binary_crossentropy, y entrenamos la red neuronal durante 10 épocas con un tamaño de lote de 512.

Finalmente, evaluamos la precisión de la red neuronal utilizando la función evaluate(), y mostramos la precisión en la consola utilizando la función print().