Inteligencia Artificial

Importancia de los modelos de aprendizaje automático

El aprendizaje automático, especialmente el Deep Learning, es actualmente la técnica de inteligencia artificial más utilizada.

A través de modelos de aprendizaje automático llevamos a cabo tareas de procesamiento del lenguaje natural (NLP), Visión por Computador (CV). Estos modelos aprenden a realizar diversas tareas a partir de datos, de manera que nos permite reutilizar datos del pasado para automatizar tareas y mejorar el rendimiento de sistemas inteligentes.

Nuestra ruta de especialista en inteligencia artificial te permitirá conocer en mayor detalle todas las tareas abordables mediante aprendizaje automático.

Relevancia de TensorFlow y Keras

TensorFlow y Keras son dos de las bibliotecas más populares para diseñar, entrenar y evaluar modelos de aprendizaje automático, especialmente en el campo del Deep Learning.

Estas bibliotecas nos permiten diseñar, entrenar y evaluar de forma sencilla redes neuronales, lo que ha llevado a una gran adopción en una variedad de industrias.

Qué es TensorFlow

TensorFlow es una biblioteca open source desarrollada por Google Brain para llevar a cabo tareas de Machine Learning y Deep Learning.

Es una de las librerías de aprendizaje automático más utilizadas a nivel industrial debido a su flexibilidad y escalabilidad.

Principales características

Las tres características principales de TensorFlow son:

• Ofrece varios niveles de abstracción: TensorFlow nos permite crear modelos de aprendizaje automático de manera sencilla mediante Keras y también nos permite controlar hasta el más mínimo detalle de un modelo.
• Despliegue en producción: TensorFlow es la librería de aprendizaje automático que ofrece el camino más directo al despliegue en entornos de producción.
• Funciona en dispositivos móviles: ofrece facilidades para utilizar modelos de inteligencia artificial en dispositivos móviles como tablets, móviles o dispositivos de domótica.

Fundamentos de TensorFlow

TensorFlow se basa en cuatro tareas para llevar a cabo tareas de aprendizaje automático. Estas tareas son fundamentales para construir modelos de aprendizaje automático precisos y escalables.

• Preparación de datos: En la primera tarea se recopilan y preparan los datos para ser utilizados en el modelo de aprendizaje automático. Esto incluye la limpieza, transformación y normalización de los datos.
• Creación del modelo: A continuación, se define la arquitectura del modelo de aprendizaje automático, incluyendo la selección de las capas, las funciones de activación y los parámetros del modelo.
• Entrenamiento y evaluación del modelo: Una vez creado el modelo se entrena con los datos preparados y se evalúa su desempeño utilizando métricas de evaluación sobre un conjunto de datos que no ha visto en la fase de entrenamiento.
• Despliegue del modelo: Finalmente se despliega el modelo entrenado en un entorno de producción.

Estructura y componentes

TensorFlow tiene su funcionalidades gracias al uso de diferentes componentes. Algunos de los componentes clave de TensorFlow incluyen:

• Capas neuronales: Las capas son los bloques de construcción fundamentales de los modelos de aprendizaje automático en TensorFlow. Hay diferentes tipos de capas para las diferentes tareas.
• Modelos: Los modelos en TensorFlow son la representación matemática de un problema de aprendizaje automático.
• Preprocesamiento de datos: El preprocesamiento de datos es un paso crucial en el desarrollo de modelos de aprendizaje automático. TensorFlow proporciona herramientas para la limpieza, transformación y normalización de los datos.
• Algoritmos de entrenamiento: TensorFlow proporciona una variedad de algoritmos de entrenamiento, como el algoritmo de gradient descent, Adam, RMSProp, entre otros, que se utilizan para ajustar los parámetros del modelo durante el entrenamiento.

Datasets dentro de TensorFlow

TensorFlow proporciona acceso a varios conjuntos de datos (datasets) populares para el entrenamiento y evaluación de modelos de aprendizaje automático. Algunos de los datasets más conocidos son:

• MNIST: Un dataset de imágenes de dígitos escritos a mano. Contiene 60000 imágenes en blanco y negro de los dígitos del 0 al 9.
• CIFAR-10: Un dataset de imágenes de diez objetos comunes. Contiene 60000 imágenes en color.
• IMDB: Un dataset de reseñas de películas. Contiene 50000 reseñas etiquetadas como positivas o negativas.
• wiki40b: Un conjunto de datos de artículos de Wikipedia en más de 40 idiomas. Cada idioma tiene un número distinto de artículos y en total el dataset contiene más de 20 GB de datos.

APIs y librerías disponibles

TensorFlow ofrece más de 35 APIs y librerías que permiten a los desarrolladores crear y entrenar modelos de aprendizaje automático de manera eficiente.

Algunas de las librerías y APIs más destacadas incluyen:

• TFX: Una librería que nos permite crear procesos para controlar la ingesta de datos por parte del modelo, analizar su rendimiento y llevar a cabo su implementación en producción.
• TensorFlow Lite: Una versión ligera de TensorFlow que se utiliza para desplegar modelos de aprendizaje automático en dispositivos móviles y otros dispositivos con recursos limitados.
• TensorFlow Probability: Una biblioteca que proporciona funcionalidades para el análisis de probabilidad y la toma de decisiones bajo incertidumbre.
• TensorFlow Quantum: Una biblioteca que proporciona funcionalidades para el desarrollo de modelos de aprendizaje automático cuántico.

Qué es Keras

Keras es una biblioteca de código abierto para el aprendizaje automático y el deep learning. Fue desarrollada por François Chollet y actualmente es mantenida por Google.

Se caracteriza por ser una biblioteca de alto nivel, fácil de usar y flexible, que permite a los desarrolladores crear y entrenar modelos de aprendizaje automático de manera rápida y eficiente.

Características más destacadas

Keras tiene varias características que lo hacen ideal para la construcción de modelos de aprendizaje automático. Algunas de las características más destacadas de Keras incluyen:

• Fácil de usar: Keras tiene una API simple y fácil de usar, lo que la hace accesible para desarrolladores de todos los niveles.
• Rendimiento: Keras es rápido y eficiente, lo que lo hace ideal para el desarrollo de modelos de aprendizaje automático complejos.
• Compatibilidad con frameworks: Keras es una librería de alto nivel que se puede utilizar con JAX, TensorFlow y PyTorch. Permitiéndonos utilizar el framework con el que estemos más familiarizados.

F undamentos de Keras

Keras se basa en un concepto llamado “modelo”, que es un conjunto de capas que se utilizan para construir modelos de aprendizaje automático.

Los modelos en Keras se pueden construir utilizando una variedad de capas, algunas de las capas más comunes las veremos más adelante.

Estructura y componentes

Keras utiliza la misma estructura de componentes que TensorFlow y la amplía. Algunos de los componentes más importantes de Keras incluyen:

• Capas: Las capas son el bloque de construcción fundamental de Keras. Se utilizan para construir modelos de aprendizaje automático.
• Modelos: Los modelos son un conjunto de capas que se utilizan para construir modelos de aprendizaje automático.
• Optimizadores: Los optimizadores se utilizan para ajustar los parámetros de los modelos de aprendizaje automático durante el entrenamiento.
• Callbacks: Los callbacks son funciones que se ejecutan durante el entrenamiento de un modelo, permitiendo la customización del proceso de entrenamiento.
• Métricas: Las métricas son funciones que se utilizan para evaluar el rendimiento de un modelo de aprendizaje automático.

Modelo secuencial y funcional

Keras incluye dos tipos de modelos según las necesidades del desarrollador:

• Modelo secuencial: Un modelo secuencial es adecuado para apilar un conjunto de capas donde cada capa tiene exactamente un tensor de entrada y un tensor de salida. Un modelo secuencial no es adecuado cuando:
  • El modelo tiene múltiples entradas o múltiples salidas.
  • Cualquiera de tus capas tiene múltiples entradas o múltiples salidas.
  • Quieres crear una topología no lineal (por ejemplo, una conexión residual).
• Modelo funcional: La API funcional de Keras es una forma de crear modelos que son más flexibles que los modelos secuenciales. La API funcional puede manejar modelos con topología no lineal, capas compartidas e incluso múltiples entradas o salidas. Permite implementar modelos más complejos y personalizados, pero su uso es más complicado.

Capas y construcción de modelos

TensorFlow y Keras incluyen una variedad de capas que se pueden utilizar para construir modelos de aprendizaje automático. Algunas de las capas más utilizadas son:

• Capas de convolución: Se utilizan para procesar imágenes y otros tipos de datos con representaciones 2D.
• Capas de pooling: Se utilizan para reducir la dimensionalidad de los datos. Su uso más común es reducir el tamaño de los datos con representaciones 2D.
• Capas densas: Es la capa más común en tareas de aprendizaje automático. Esta tarea aprende las relaciones entre datos para poder llevar a cabo la tarea objetivo.
• Capas LSTM (Long Short-Term Memory): Se utilizan para procesar datos secuenciales, como series temporales o textos.
• Capas dropout: Se utilizan para regularizar el modelo y evitar sobreajuste. Concretamente se eliminan un conjunto de neuronas de manera aleatoria durante el entrenamiento.
• Capas de embedding: Se utilizan para convertir datos en representaciones numéricas densas, lo que permite que el modelo aprenda relaciones entre los datos. Generalmente se utilizan en tareas de NLP.

En nuestro curso de aprendizaje automático y PLN podrás conocer en mayor medida en funcionamiento de estas capas.

Integración de TensorFlow y Keras

TensorFlow y Keras se pueden utilizar juntos para construir modelos de aprendizaje automático de alta complejidad.

La integración de TensorFlow y Keras permite a los desarrolladores aprovechar las ventajas de ambas bibliotecas.

Compatibilidad y sinergia entre ambos

La compatibilidad y sinergia entre TensorFlow y Keras permiten a los desarrolladores construir modelos de aprendizaje automático de alta complejidad.

La integración de TensorFlow y Keras permite a los desarrolladores aprovechar las ventajas de ambas bibliotecas, lo que les permite construir modelos de aprendizaje automático más precisos y eficientes.

Aplicaciones prácticas de la integración entre TensorFlow y Keras

A continuación, veremos tres ejemplos prácticos en los que combinamos TensorFlow y Keras para llevar a cabo algunas tareas clásicas de Inteligencia Artificial.

En los tres ejemplos que presentamos a continuación vamos a dividir el proceso de crear y entrenar una red neuronal mediante Keras y TensorFlow en cuatro fases:

• Preparación del entorno: realizaremos los imports necesarios para que nuestro código se ejecute correctamente.
• Preparación de datos: descargamos los datos y los preprocesamos para poder utilizarlos.
• Creación del modelo: definiremos el modelo a utilizar.
• Entrenamiento y evaluación del modelo: entrenaremos y evaluaremos el modelo.

Visión por computador

En primer lugar vamos a utilizar el conjunto de datos MNIST para clasificar imágenes de dígitos escritos a mano. Nuestro objetivo es entrenar un modelo que pueda detectar el número que aparece en cada imagen.

El primer paso es importar las librerías que utilizaremos.

import numpy as np
import keras
from keras import layers

A continuación, normalizamos los datos. Concretamente se reescalamos los grises a una escala con 255 valores.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")


y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

Después crearemos el modelo que utilizaremos para clasificar el dígito de la imagen. Concretamente utilizaremos un modelo secuencial.

num_classes = 10
input_shape = (28, 28, 1)

model = keras.Sequential(
    [
        keras.Input(shape=input_shape),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation="softmax"),
    ]
)

model.summary()

Finalmente entrenaremos el modelo y lo evaluaremos.

batch_size = 128
epochs = 15

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)

score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])

Procesamiento de Lenguaje Natural (NLP)

La segunda tarea a realizar pertenece al campo de NLP. Concretamente utilizaremos el conjunto de datos imdb para clasificar reseñas como positivas o negativas.

import numpy as np
import keras
from keras import layers

Al igual que en la tarea anterior importaremos las librerías anteriores y cargaremos los datos. En esta ocasión la única transformación que llevaremos a cabo es convertir los textos en secuencias. Esto es necesario ya que utilizaremos capas LSTM.

max_features = 20000
maxlen = 200

(x_train, y_train), (x_val_test, y_val_test) = keras.datasets.imdb.load_data(
    num_words=max_features
)
x_val = x_val_test[:int (len(x_val_test)/2)]
y_val = y_val_test[:int (len(y_val_test)/2)]
x_test = x_val_test[int (len(x_val_test)/2):]
y_test = y_val_test[int (len(y_val_test)/2):]
print(len(x_train), "Training sequences")
print(len(x_val), "Validation sequences")
print(len(x_val), "Test sequences")

x_train = keras.utils.pad_sequences(x_train, maxlen=maxlen)
x_val = keras.utils.pad_sequences(x_val, maxlen=maxlen)
x_test = keras.utils.pad_sequences(x_test, maxlen=maxlen)

Una vez tenemos los datos en el formato correcto creamos el modelo.

inputs = keras.Input(shape=(None,), dtype="int32")
x = layers.Embedding(max_features, 128)(inputs)
x = layers.Bidirectional(layers.LSTM(64, return_sequences=True))(x)
x = layers.Bidirectional(layers.LSTM(64))(x)
outputs = layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs, outputs)
model.summary()

Y finalmente entrenamos y evaluamos el modelo.

model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"])
model.fit(x_train, y_train, batch_size=32, epochs=2, validation_data=(x_val, y_val))

score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])

Si quieres seguir conociendo más tareas de NLP en profundidad te recomendamos nuestro curso de introducción al PLN .

Sistemas de recomendación

La última tarea que vamos a analizar es la creación de un sistema de recomendaciones.

Este ejemplo es más complejo que los vistos previamente. Por este motivo realizaremos un preprocesado de los datos más exhaustivo y utilizaremos un modelo funcional.

import pandas as pd
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
from zipfile import ZipFile

import keras
from keras import layers
from keras import ops

Al igual que en los ejemplos anteriores el primer paso es importar las librerías que utilizaremos. Una vez hecho esto procederemos a descargar el conjunto de datos y preprocesarlos.

movielens_data_file_url = (
    "http://files.grouplens.org/datasets/movielens/ml-latest-small.zip"
)
movielens_zipped_file = keras.utils.get_file(
    "ml-latest-small.zip", movielens_data_file_url, extract=False
)
keras_datasets_path = Path(movielens_zipped_file).parents[0]
movielens_dir = keras_datasets_path / "ml-latest-small"

if not movielens_dir.exists():
    with ZipFile(movielens_zipped_file, "r") as zip:
        print("Extracting all the files now...")
        zip.extractall(path=keras_datasets_path)
        print("Done!")

ratings_file = movielens_dir / "ratings.csv"
df = pd.read_csv(ratings_file)

user_ids = df["userId"].unique().tolist()
user2user_encoded = {x: i for i, x in enumerate(user_ids)}
userencoded2user = {i: x for i, x in enumerate(user_ids)}
movie_ids = df["movieId"].unique().tolist()
movie2movie_encoded = {x: i for i, x in enumerate(movie_ids)}
movie_encoded2movie = {i: x for i, x in enumerate(movie_ids)}
df["user"] = df["userId"].map(user2user_encoded)
df["movie"] = df["movieId"].map(movie2movie_encoded)

num_users = len(user2user_encoded)
num_movies = len(movie_encoded2movie)
df["rating"] = df["rating"].values.astype(np.float32)

min_rating = min(df["rating"])
max_rating = max(df["rating"])

print(
    "Number of users: {}, Number of Movies: {}, Min rating: {}, Max rating: {}".format(
        num_users, num_movies, min_rating, max_rating
    )
)

df = df.sample(frac=1, random_state=42)
x = df[["user", "movie"]].values

y = df["rating"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values

train_indices = int(0.9 * df.shape[0])
x_train, x_val, y_train, y_val = (
    x[:train_indices],
    x[train_indices:],
    y[:train_indices],
    y[train_indices:],
)

En el preprocesamiento realizado nos hemos quedado como datos los usuarios y las películas que ha calificado cada usuario. Como etiqueta hemos almacenado el valor de la reseña normalizado.

A partir de estos datos hemos creado un modelo llamado “RecommenderNet” que calcula la recomendación para un usuario.

EMBEDDING_SIZE = 50

class RecommenderNet(keras.Model):
    def __init__(self, num_users, num_movies, embedding_size, **kwargs):
        super().__init__(**kwargs)
        self.num_users = num_users
        self.num_movies = num_movies
        self.embedding_size = embedding_size
        self.user_embedding = layers.Embedding(
            num_users,
            embedding_size,
            embeddings_initializer="he_normal",
            embeddings_regularizer=keras.regularizers.l2(1e-6),
        )
        self.user_bias = layers.Embedding(num_users, 1)
        self.movie_embedding = layers.Embedding(
            num_movies,
            embedding_size,
            embeddings_initializer="he_normal",
            embeddings_regularizer=keras.regularizers.l2(1e-6),
        )
        self.movie_bias = layers.Embedding(num_movies, 1)

    def call(self, inputs):
        user_vector = self.user_embedding(inputs[:, 0])
        user_bias = self.user_bias(inputs[:, 0])
        movie_vector = self.movie_embedding(inputs[:, 1])
        movie_bias = self.movie_bias(inputs[:, 1])
        dot_user_movie = ops.tensordot(user_vector, movie_vector, 2)
        # Add all the components (including bias)
        x = dot_user_movie + user_bias + movie_bias
        # The sigmoid activation forces the rating to between 0 and 1
        return ops.nn.sigmoid(x)

Una vez creado el modelo hemos procedido a entrenarlo y a calcular las 10 películas recomendadas para un usuario.

model = RecommenderNet(num_users, num_movies, EMBEDDING_SIZE)
model.compile(
    loss=keras.losses.BinaryCrossentropy(),
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
)

history = model.fit(
    x=x_train,
    y=y_train,
    batch_size=64,
    epochs=5,
    verbose=1,
    validation_data=(x_val, y_val),
)
movie_df = pd.read_csv(movielens_dir / "movies.csv")


user_id = df.userId.sample(1).iloc[0]
movies_watched_by_user = df[df.userId == user_id]
movies_not_watched = movie_df[
    ~movie_df["movieId"].isin(movies_watched_by_user.movieId.values)
]["movieId"]
movies_not_watched = list(
    set(movies_not_watched).intersection(set(movie2movie_encoded.keys()))
)
movies_not_watched = [[movie2movie_encoded.get(x)] for x in movies_not_watched]
user_encoder = user2user_encoded.get(user_id)
user_movie_array = np.hstack(
    ([[user_encoder]] * len(movies_not_watched), movies_not_watched)
)
ratings = model.predict(user_movie_array).flatten()
top_ratings_indices = ratings.argsort()[-10:][::-1]
recommended_movie_ids = [
    movie_encoded2movie.get(movies_not_watched[x][0]) for x in top_ratings_indices
]

print("Showing recommendations for user: {}".format(user_id))
print("====" * 9)
print("Movies with high ratings from user")
print("----" * 8)
top_movies_user = (
    movies_watched_by_user.sort_values(by="rating", ascending=False)
    .head(5)
    .movieId.values
)
movie_df_rows = movie_df[movie_df["movieId"].isin(top_movies_user)]
for row in movie_df_rows.itertuples():
    print(row.title, ":", row.genres)

print("----" * 8)
print("Top 10 movie recommendations")
print("----" * 8)
recommended_movies = movie_df[movie_df["movieId"].isin(recommended_movie_ids)]
for row in recommended_movies.itertuples():
    print(row.title, ":", row.genres)

Casos de uso en otras industrias

TensorFlow y Keras no solo se utilizan en la industria de la tecnología, sino que también tienen aplicaciones en otras industrias, como:

• Salud: TensorFlow y Keras permiten analizar imágenes médicas, diagnosticar enfermedades y desarrollar tratamientos personalizados.
• Finanzas: Las tareas principales en finanzas son analizar datos financieros, predecir tendencias del mercado y detectar fraude.
• Automoción: La automoción es una de las industrias que utilizan en mayor medida TensorFlow y Keras. Generalmente se utilizan para desarrollar sistemas de conducción autónoma, analizar datos de sensores y mejorar la eficiencia del combustible.

Beneficios de utilizar TensorFlow y Keras

Entre los múltiples beneficios de emplear TensorFlow y Keras queremos destacar tres.

• Flexibilidad y escalabilidad: TensorFlow y Keras ofrecen una gran flexibilidad y escalabilidad, lo que permite a los desarrolladores construir modelos de aprendizaje automático de alta complejidad y escalarlos según sea necesario.

• Eficiencia en el desarrollo de modelos: TensorFlow y Keras ofrecen una gran eficiencia en el desarrollo de modelos, permitiendo construir modelos de aprendizaje automático más rápidamente y con menos esfuerzo.

• Soporte y comunidad activa: TensorFlow y Keras tienen una comunidad activa y un soporte oficial de Google. Una de las consecuencias de este beneficio es que la calidad de la documentación de Keras y TensorFlow es excelsa.

Conclusiones

TensorFlow y Keras son dos de las bibliotecas más populares y poderosas para el aprendizaje automático. Ofrecen una gran flexibilidad y escalabilidad, eficiencia en el desarrollo de modelos y soporte y comunidad activa. Estas bibliotecas tienen aplicaciones en una variedad de industrias y son fundamentales para el desarrollo de modelos de aprendizaje automático de alta complejidad.

Con su continua actualización y soporte, es probable que sigan siendo líderes en el campo del aprendizaje automático durante mucho tiempo.

¿Quieres comenzar a crear redes neuronales? ¡Usa TensorFlow y Keras!