Keras Python (Cómo Funciona Para Desarrolladores)

1. Fácil de usar y modular

Con la frase 'Aprendizaje profundo para humanos', Keras está diseñado para ser fácil de usar, modular y extensible. Los modelos de Keras proporcionan comentarios claros y accionables sobre errores, lo que ayuda a los desarrolladores a depurar y optimizar sus modelos de manera eficiente.

2. Soporte para múltiples backends

Keras puede funcionar sobre varios marcos de aprendizaje profundo, como TensorFlow, Theano y Microsoft Cognitive Toolkit (CNTK). Esta flexibilidad permite a los desarrolladores elegir el backend que mejor se adapte a sus necesidades.

3. Apoyo extensivo para redes neuronales

Keras admite una amplia gama de capas de redes neuronales, incluidas capas convolucionales, capas recurrentes y capas completamente conectadas. También proporciona soporte para arquitecturas complejas como modelos con múltiples entradas y salidas, compartición de capas y compartición de modelos.

4. Utilidades de preprocesamiento

Keras incluye utilidades para el preprocesamiento de datos, como el procesamiento de imágenes y texto, que simplifican la preparación de conjuntos de datos para el entrenamiento de los modelos.

5. Herramientas de visualización y depuración de modelos

Keras ofrece herramientas para visualizar la estructura de las redes neuronales y monitorear el proceso de entrenamiento. Esto es crucial para comprender el comportamiento de los modelos y hacer los ajustes necesarios. El tipo de modelo más sencillo es el modelo Keras Secuencial, que es simplemente una pila lineal de capas.

Construir una red neuronal sencilla con Keras

A continuación se muestra un ejemplo de cómo construir una red neuronal de avance directo simple usando Keras:

import keras
import numpy as np
import matplotlib.pyplot as plt

# Function to read UCR formatted data
def readucr(filename):
    """
    Reads a UCR format file and returns the features and labels.

    Args:
    filename (str): Path to the data file

    Returns:
    x, y: Features and labels as numpy arrays
    """
    data = np.loadtxt(filename, delimiter="\t")
    y = data[:, 0]
    x = data[:, 1:]
    return x, y.astype(int)

# Define the root URL for the dataset
root_url = "https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/"
x_train, y_train = readucr(root_url + "FordA_TRAIN.tsv")
x_test, y_test = readucr(root_url + "FordA_TEST.tsv")

# Get unique classes from the dataset
classes = np.unique(np.concatenate((y_train, y_test), axis=0))

# Plot an example from each class
plt.figure()
for c in classes:
    c_x_train = x_train[y_train == c]
    plt.plot(c_x_train[0], label="class " + str(c))
plt.legend(loc="best")
plt.show()
plt.close()

import keras
import numpy as np
import matplotlib.pyplot as plt

# Function to read UCR formatted data
def readucr(filename):
    """
    Reads a UCR format file and returns the features and labels.

    Args:
    filename (str): Path to the data file

    Returns:
    x, y: Features and labels as numpy arrays
    """
    data = np.loadtxt(filename, delimiter="\t")
    y = data[:, 0]
    x = data[:, 1:]
    return x, y.astype(int)

# Define the root URL for the dataset
root_url = "https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/"
x_train, y_train = readucr(root_url + "FordA_TRAIN.tsv")
x_test, y_test = readucr(root_url + "FordA_TEST.tsv")

# Get unique classes from the dataset
classes = np.unique(np.concatenate((y_train, y_test), axis=0))

# Plot an example from each class
plt.figure()
for c in classes:
    c_x_train = x_train[y_train == c]
    plt.plot(c_x_train[0], label="class " + str(c))
plt.legend(loc="best")
plt.show()
plt.close()

Resultado

1. Clasificación de imágenes

Keras se utiliza ampliamente en tareas de clasificación de imágenes. Por ejemplo, las redes neuronales convolucionales (CNN) construidas con Keras pueden lograr alta precisión en el reconocimiento de objetos en imágenes.

2. Procesamiento del Lenguaje Natural

Keras proporciona herramientas para construir modelos que pueden procesar y comprender el lenguaje humano. Las redes neuronales recurrentes (RNN) y las redes de memoria de largo corto plazo (LSTM) en Keras se utilizan comúnmente para tareas como el análisis de sentimientos y la traducción automática.

3. Modelos Generativos

Keras se puede usar para desarrollar modelos generativos como las Redes Generativas Adversariales (GANs), que se utilizan para generar nuevas muestras de datos que se asemejan a los datos de entrenamiento.

Instalación

pip install ironpdf
pip install keras
pip install tensorflow

pip install ironpdf
pip install keras
pip install tensorflow

Ahora genera la trama del modelo y expórtala a un PDF usando el siguiente código:

import keras
import numpy as np
import matplotlib.pyplot as plt
from ironpdf import License, ImageToPdfConverter

# Apply your license key
License.LicenseKey = "your key goes here"

def readucr(filename):
    """Read and parse UCR formatted data."""
    data = np.loadtxt(filename, delimiter="\t")
    y = data[:, 0]
    x = data[:, 1:]
    return x, y.astype(int)

# Define the root URL for the dataset
root_url = "https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/"
x_train, y_train = readucr(root_url + "FordA_TRAIN.tsv")
x_test, y_test = readucr(root_url + "FordA_TEST.tsv")

# Extract unique classes from the dataset
classes = np.unique(np.concatenate((y_train, y_test), axis=0))

# Plot example data for each class
plt.figure()
for c in classes:
    c_x_train = x_train[y_train == c]
    plt.plot(c_x_train[0], label="class " + str(c))
plt.legend(loc="best")
plt.savefig('data.png') 
plt.show()
plt.close()

# Convert the saved image to a PDF
ImageToPdfConverter.ImageToPdf("data.png").SaveAs("plot.pdf")

import keras
import numpy as np
import matplotlib.pyplot as plt
from ironpdf import License, ImageToPdfConverter

# Apply your license key
License.LicenseKey = "your key goes here"

def readucr(filename):
    """Read and parse UCR formatted data."""
    data = np.loadtxt(filename, delimiter="\t")
    y = data[:, 0]
    x = data[:, 1:]
    return x, y.astype(int)

# Define the root URL for the dataset
root_url = "https://raw.githubusercontent.com/hfawaz/cd-diagram/master/FordA/"
x_train, y_train = readucr(root_url + "FordA_TRAIN.tsv")
x_test, y_test = readucr(root_url + "FordA_TEST.tsv")

# Extract unique classes from the dataset
classes = np.unique(np.concatenate((y_train, y_test), axis=0))

# Plot example data for each class
plt.figure()
for c in classes:
    c_x_train = x_train[y_train == c]
    plt.plot(c_x_train[0], label="class " + str(c))
plt.legend(loc="best")
plt.savefig('data.png') 
plt.show()
plt.close()

# Convert the saved image to a PDF
ImageToPdfConverter.ImageToPdf("data.png").SaveAs("plot.pdf")

Explicación del código

1. Importación de Bibliotecas:

   • El código comienza importando las bibliotecas necesarias:
     • Keras: Una biblioteca popular de aprendizaje profundo.
     • numpy (como np): Usada para operaciones numéricas.
     • matplotlib.pyplot (como plt): Usada para crear gráficos.
     • ironpdf: La biblioteca IronPDF para trabajar con PDFs.

2. Configuración de la Clave de Licencia:

   • La línea License.LicenseKey = "tu clave" establece la clave de licencia para IronPDF.

3. Leyendo Datos:

   • La función readucr lee datos de archivos con un formato específico (valores separados por tabuladores).
   • Extrae etiquetas (y) y características (x) de los datos.

4. Cargando Datos de Entrenamiento y Prueba:

   • El código construye URLs para los archivos de datos de entrenamiento y prueba relacionados con el conjunto de datos "FordA".
   • Carga los datos usando la función readucr.

5. Graficando Datos:

   • El código identifica las clases únicas en el conjunto de datos.
   • Para cada clase, selecciona la primera instancia (c_x_train[0]) y la grafica.
   • La leyenda indica la etiqueta de la clase.

6. Guardando el Gráfico:

   • El gráfico se guarda como un archivo de imagen llamado "data.png".

7. Convirtiendo Imagen a PDF:

   • El ImageToPdfConverter de IronPDF convierte la imagen guardada ("data.png") en un archivo PDF ("plot.pdf").

PDF resultante