Python para el trading algorítmico - página 22
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Visualización de datos con matplotlib en 1 hora
Visualización de datos con matplotlib en 1 hora
En este video, el instructor presenta la importancia de la visualización de datos en el aprendizaje automático y explica cómo puede ayudar a dar sentido a grandes cantidades de datos recopilados. Las dos bibliotecas principales de Python para la visualización de datos, Matplotlib y Seaborn, se tratan en el curso.
El instructor afirma que el curso está diseñado principalmente para ingenieros de aprendizaje automático, ingenieros de datos y científicos de datos que desean aprender Python. Para ilustrar el uso de Matplotlib, se proporciona un ejemplo simple de trazado de una curva. La filosofía de Matplotlib gira en torno a aprovechar el lenguaje existente, Python, que se ha convertido en el estándar para construir modelos de aprendizaje automático y manejar datos. Al combinar Matplotlib con otros paquetes de Python, los usuarios pueden aprovechar los numerosos paquetes disponibles para diversas tareas.
El video enfatiza la importancia de usar el paquete NumPy junto con Matplotlib para la computación científica. Si bien Matplotlib puede funcionar sin NumPy, utilizar NumPy puede ahorrar mucho tiempo y esfuerzo. NumPy proporciona un poderoso objeto de matriz multidimensional y funciones para manipularlo. En el video se muestra un ejemplo, donde se genera una curva con 100 puntos usando NumPy para calcular las coordenadas x e y. Este enfoque demuestra ser mucho más rápido que realizar la operación usando Python puro. Además, el video cubre el trazado de dos curvas en el mismo gráfico para comparar, el trazado de datos de un archivo al extraer y organizar los datos mediante el código Python y el trazado de puntos en lugar de elementos de forma lineal.
El tutorial profundiza en la creación de diferentes tipos de gráficos de barras utilizando la biblioteca Matplotlib. Se introduce la función dedicada a la creación de gráficos de barras, "bar", que toma la coordenada x de cada barra y la altura de cada barra como parámetros de entrada. Al ajustar parámetros opcionales, los usuarios pueden crear varios efectos e incluso generar barras horizontales usando la función "barh". El tutorial también cubre el trazado de múltiples gráficos de barras en el mismo gráfico y la creación de barras apiladas usando un parámetro especial en la función "barra". Además, el video toca brevemente la creación de gráficos circulares utilizando la función "circular".
Varias funciones utilizadas en la visualización de datos con Matplotlib se explican en el tutorial. La primera función cubierta son los histogramas, que son representaciones gráficas de distribuciones de probabilidad. Se analizan la función "hist" y sus parámetros, lo que permite a los usuarios trazar fácilmente datos como histogramas. La segunda función cubierta son los diagramas de caja, que facilitan la comparación de las distribuciones de valores. El video explica los componentes de un diagrama de caja, incluidos los cuartiles, la mediana, la media y las cantidades estadísticas de un conjunto de datos, y demuestra cómo generarlos usando la función "diagrama de caja". Por último, el tutorial cubre la modificación de gráficos mediante el uso de diferentes colores y estilos, como la definición de colores mediante trillizos, cuatrillos o nombres de color HTML, así como la configuración del color de un gráfico de curvas.
El video continúa explicando cómo agregar color a diagramas de dispersión, gráficos de barras y gráficos circulares usando el parámetro "color". Este parámetro permite a los usuarios controlar los colores de puntos individuales o cambiar el color común para todos los puntos. El video también aborda la importación de bibliotecas como módulos, el uso de alias para facilitar la codificación y la aclaración de la representación de variables. Se enfatiza que casi todo en Matplotlib y Python involucra funciones, como la función "pi" y la función "show".
A continuación, el tutorial cubre esquemas de color personalizados y patrones de línea al crear diagramas de caja, marcadores y formas de línea. Demuestra la creación de marcadores personalizados usando formas predefinidas y la definición de marcadores personalizados usando símbolos de texto matemático. Además, explica cómo cambiar fácilmente la configuración predeterminada de Matplotlib utilizando el objeto de configuración centralizado, lo que permite a los usuarios adaptar el estilo visual, como tener un fondo negro y anotaciones en blanco, a diferentes contextos de uso.
El presentador explica cómo guardar un gráfico en un archivo usando la función "savefig" en Matplotlib. También cubren la adición de anotaciones a un gráfico, incluido un título, etiquetas para los ejes x e y, un cuadro delimitado y flechas. El video demuestra el proceso de agregar estas anotaciones para mejorar la claridad visual y la comprensión del gráfico. Además, muestra cómo controlar manualmente el espaciado entre marcas en Matplotlib para realizar ajustes precisos. El video destaca las diversas funciones disponibles en Matplotlib para anotar gráficos y hacerlos más autoexplicativos para los lectores.
Continuando, el instructor analiza la visualización de datos con Matplotlib y presenta Seaborn, una interfaz de alto nivel para Matplotlib. Seaborn proporciona diferentes parámetros y funcionalidades en comparación con Matplotlib. El instructor muestra cómo crear visualizaciones utilizando el conjunto de datos integrado y los mapas de color de Seaborn. El video concluye presentando ejemplos de cómo crear una gráfica de factores y utilizar mapas de colores para graficar datos. A través de estos ejemplos, los espectadores obtienen información sobre el uso de diferentes funciones y herramientas en Matplotlib y Seaborn para mejorar sus habilidades de visualización de datos.
El video explica cómo escalar parcelas usando la función "set_context" de Seaborn. Esta función permite a los usuarios controlar los elementos de la trama, como el tamaño, según el contexto en el que se mostrará la trama. Luego aclara la distinción entre los dos tipos de funciones de Seaborn: funciones de nivel de ejes y funciones de nivel de figura. Las funciones de nivel de ejes operan en el nivel de eje y devuelven el objeto de ejes, mientras que las funciones de nivel de figura crean gráficos que incluyen ejes organizados de manera significativa. Finalmente, el video brinda orientación sobre la configuración de ejes para un gráfico de caja utilizando el objeto de subgráficos de ejes de Matplotlib.
Este completo tutorial en video cubre una amplia gama de temas relacionados con la visualización de datos con Matplotlib y Seaborn. Comienza presentando la importancia de la visualización de datos en el aprendizaje automático y el uso de Matplotlib como una biblioteca poderosa. Demuestra cómo trazar curvas, crear gráficos de barras, generar histogramas y diagramas de caja, y personalizar colores, marcadores y estilos de línea. El tutorial también cubre cómo guardar gráficos, agregar anotaciones y manipular el espaciado entre marcas. Además, presenta Seaborn como una herramienta de visualización alternativa con su propio conjunto de características y funcionalidades. Al seguir este tutorial, los espectadores pueden mejorar sus habilidades de visualización de datos y comunicar de manera efectiva sus hallazgos utilizando estas poderosas bibliotecas de Python.
Tutorial de aprendizaje profundo con Python, TensorFlow y Keras
Tutorial de aprendizaje profundo con Python, TensorFlow y Keras
Saludos a todos y bienvenidos a una actualización muy esperada sobre aprendizaje profundo y Python con TensorFlow, así como a un nuevo tutorial de Chaos. Han pasado más de dos años desde la última vez que cubrí el aprendizaje profundo básico en Python y, durante este tiempo, ha habido avances significativos. Entrar en el aprendizaje profundo y trabajar con modelos de aprendizaje profundo se ha vuelto mucho más simple y accesible.
Si está interesado en profundizar en el código de TensorFlow de nivel inferior y los detalles intrincados, aún puede consultar el video anterior. Sin embargo, si su objetivo es comenzar con el aprendizaje profundo, ya no necesita pasar por eso porque ahora tenemos API de alto nivel fáciles de usar como Chaos que se asientan sobre TensorFlow. Estas API hacen que el aprendizaje profundo sea increíblemente sencillo, lo que permite que cualquier persona, incluso sin conocimientos previos de aprendizaje profundo, pueda seguirlo.
En este tutorial, haremos un repaso rápido de las redes neuronales. Para comenzar, comprendamos los componentes centrales de una red neuronal. El objetivo principal de cualquier modelo de aprendizaje automático, incluidas las redes neuronales, es asignar entradas a salidas. Por ejemplo, dadas las entradas X1, X2 y X3, nuestro objetivo es determinar si la salida corresponde a un perro o un gato. En este caso, la capa de salida consta de dos neuronas que representan la posibilidad de ser un perro o un gato.
Para lograr este mapeo, podemos emplear una sola capa oculta, donde cada entrada, X1, X2 y X3, está conectada a las neuronas en la capa oculta. Cada una de estas conexiones tiene un peso único asociado. Sin embargo, si nos limitamos a una sola capa oculta, las relaciones entre las entradas y la salida serían lineales. Para capturar relaciones no lineales, que son comunes en problemas complejos, necesitamos dos o más capas ocultas. Una red neuronal con dos o más capas ocultas a menudo se denomina red neuronal profunda.
Agreguemos otra capa oculta, conectándola completamente con la capa anterior. Cada conexión entre capas tiene su propio peso único. En última instancia, la salida se deriva de la capa final, donde cada conexión a la capa de salida posee un peso único. En un nivel de neurona individual, la neurona recibe entradas, que podrían ser los valores de la capa de entrada (X1, X2, X3) o entradas de otras neuronas. Estas entradas se suman, considerando sus pesos asociados. Además, se aplica una función de activación para simular el disparo de la neurona o no. Las funciones de activación comunes incluyen la función de paso o la función sigmoidea, que devuelve valores entre 0 y 1. En nuestra red neuronal, la capa de salida utiliza una función de activación sigmoidea, asignando probabilidades a cada clase (perro o gato). A continuación, se utiliza la función Arg max para determinar la clase predicha en función de la probabilidad más alta.
Ahora que tenemos una comprensión básica de las redes neuronales, procedamos a construir una usando TensorFlow. En primer lugar, asegúrese de tener instalado TensorFlow ejecutando el comando "pip install --upgrade tensorflow". Puede importar TensorFlow como "tf" y verificar la versión actual usando "tf.version". Para este tutorial, se recomienda Python 3.6 o superior, aunque se espera que TensorFlow sea compatible con Python 3.7 y versiones posteriores en el futuro.
A continuación, importaremos un conjunto de datos con el que trabajar. Utilizaremos el conjunto de datos MNIST, que consiste en imágenes de 28x28 de dígitos escritos a mano que van del 0 al 9. Estas imágenes se alimentarán a la red neuronal y la red predecirá el dígito correspondiente. Dividiremos el conjunto de datos en variables de entrenamiento y prueba: X_train, Y_train, X_test y Y_test.
Para garantizar un mejor rendimiento, normalizaremos los datos. Los valores de píxel de las imágenes actualmente oscilan entre 0 y 255, por lo que los escalaremos entre 0 y 1 mediante la función TF.keras.utils.normalize.
Para construir el modelo, usaremos la API Chaos de alto nivel, que simplifica el proceso de creación y entrenamiento de redes neuronales en TensorFlow. Chaos proporciona un modelo secuencial llamado Sequential que nos permite apilar capas una tras otra.
Aquí hay un ejemplo de cómo puede crear un modelo de red neuronal usando Chaos:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
En el código anterior, importamos los módulos necesarios de TensorFlow y Chaos. Creamos un modelo secuencial y le agregamos capas usando el método de agregar. La primera capa es una capa Flatten que convierte la entrada 2D (imágenes de 28x28) en una matriz 1D. Luego agregamos una capa densa con 128 neuronas y activación de ReLU. Finalmente, agregamos una capa de salida con 10 neuronas (correspondientes a los 10 dígitos) y activación softmax.
Después de definir el modelo, lo compilamos usando el método de compilación. Especificamos el optimizador (en este caso, 'adam'), la función de pérdida ('sparse_categorical_crossentropy' para clasificación multiclase) y las métricas para evaluar durante el entrenamiento.
Ahora que tenemos nuestro modelo definido y compilado, podemos proceder a entrenarlo en el conjunto de datos MNIST. Usaremos el método de ajuste para entrenar el modelo.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
En el código anterior, pasamos los datos de entrenamiento (X_train y Y_train) al método de ajuste junto con el número de épocas para entrenar. También proporcionamos los datos de validación (X_test e Y_test) para evaluar el rendimiento del modelo en datos no vistos durante el entrenamiento.
Después de entrenar el modelo, podemos hacer predicciones usando el método de predicción:
# Make predictions predictions = model.predict(X_test)
En el código anterior, pasamos los datos de prueba (X_test) al método de predicción y este devuelve las probabilidades previstas para cada clase.
Esta es una breve descripción general de cómo crear y entrenar una red neuronal con Chaos en TensorFlow. Puede explorar más a fondo diferentes capas, funciones de activación, optimizadores y otros parámetros para personalizar su modelo.
técnicas y conceptos adicionales relacionados con la construcción y el entrenamiento de redes neuronales.
Técnicas de Regularización:
Dropout: Dropout es una técnica de regularización utilizada para evitar el sobreajuste. Establece aleatoriamente una fracción de las unidades de entrada en 0 en cada actualización durante el entrenamiento, lo que ayuda a evitar que el modelo dependa demasiado de un conjunto particular de funciones.
Regularización L1 y L2: La regularización L1 y L2 son técnicas que se utilizan para agregar una penalización a la función de pérdida para evitar grandes pesos en la red. La regularización L1 agrega el valor absoluto de los pesos a la función de pérdida, fomentando la escasez, mientras que la regularización L2 agrega los pesos al cuadrado a la función de pérdida, fomentando pesos pequeños.
Funciones de activación avanzadas:
Leaky ReLU: Leaky ReLU es una función de activación que resuelve el problema de "ReLU moribundo" al permitir una pequeña pendiente para entradas negativas. Introduce una pequeña pendiente negativa cuando la entrada es negativa, lo que ayuda a evitar que las neuronas mueran durante el entrenamiento.
Unidad lineal exponencial (ELU): ELU es una función de activación que suaviza la salida para entradas negativas, lo que permite que la activación tome valores negativos. Se ha demostrado que ayuda a mejorar el aprendizaje de las redes neuronales y reduce el sesgo hacia valores positivos.
Swish: Swish es una función de activación que realiza una interpolación suave entre las funciones lineal y sigmoidea. Se ha demostrado que proporciona mejores resultados en comparación con otras funciones de activación como ReLU y sigmoid en ciertos casos.
Transferencia de aprendizaje: la transferencia de aprendizaje es una técnica que aprovecha los modelos previamente entrenados para resolver nuevas tareas o mejorar el rendimiento de un modelo en una tarea relacionada. En lugar de entrenar un modelo desde cero, puede usar un modelo previamente entrenado como punto de partida y ajustarlo en su tarea o conjunto de datos específico. Esto es particularmente útil cuando tiene datos limitados para su tarea específica.
Ajuste de hiperparámetros: los hiperparámetros son parámetros que el modelo no aprende pero afectan el proceso de aprendizaje, como la tasa de aprendizaje, el tamaño del lote, la cantidad de capas, etc. Ajustar estos hiperparámetros puede afectar significativamente el rendimiento del modelo. Se pueden utilizar técnicas como la búsqueda en cuadrícula, la búsqueda aleatoria y la optimización bayesiana para buscar sistemáticamente en el espacio de hiperparámetros y encontrar la mejor combinación.
Evaluación del modelo: evaluar el rendimiento de un modelo es crucial para evaluar su eficacia. Las métricas de evaluación comunes para las tareas de clasificación incluyen exactitud, precisión, recuperación, puntaje F1 y área bajo la curva característica operativa del receptor (ROC AUC). Es importante elegir las métricas adecuadas según el problema en cuestión y la naturaleza de los datos.
Manejo de conjuntos de datos desequilibrados: los conjuntos de datos desequilibrados se producen cuando la distribución de las clases no es igual, lo que puede dar lugar a modelos sesgados. Técnicas como el sobremuestreo de la clase minoritaria, el submuestreo de la clase mayoritaria o el uso de una combinación de ambos pueden ayudar a solucionar este problema. Además, el uso de métricas de evaluación como la precisión, la recuperación y la puntuación F1 puede proporcionar una mejor comprensión del rendimiento del modelo en conjuntos de datos desequilibrados.
Recuerde, construir y entrenar redes neuronales es un proceso iterativo. Implica experimentación, ajuste y mejora continua para lograr los resultados deseados.
Cargar sus propios datos: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.2
Cargar sus propios datos: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.2
Bienvenidos todos a la parte 2 de nuestro tutorial de aprendizaje profundo sobre Python TensorFlow en Karros. En este tutorial, nos centraremos en cargar un conjunto de datos externo. Específicamente, usaremos el conjunto de datos de gatos y perros de Microsoft, originalmente un desafío de Kaggle. El objetivo es entrenar una red neuronal para identificar si una imagen contiene un gato o un perro.
Para comenzar, descargue el conjunto de datos de perros y gatos de Microsoft. Una vez que haya descargado y extraído el conjunto de datos, debería ver dos directorios: "gato" y "perro". Estos directorios contienen imágenes de gatos y perros, respectivamente. Cada directorio debe tener una cantidad sustancial de muestras, alrededor de 12,500, que brinden ejemplos amplios para entrenar nuestro modelo.
Ahora pasemos a la parte de la codificación. Necesitamos importar varias bibliotecas: numpy como np, matplotlib.pyplot como plt y OpenCV como cv2. Si no tiene estas bibliotecas instaladas, puede usar pip para instalarlas.
A continuación, definiremos el directorio de datos donde se encuentra nuestro conjunto de datos. Puede especificar la ruta a su conjunto de datos en consecuencia. También definiremos las categorías como "perro" y "gato" para que coincidan con los directorios en nuestro conjunto de datos.
Recorreremos cada categoría y las imágenes correspondientes usando la biblioteca del sistema operativo. Para cada imagen, la convertiremos a escala de grises utilizando la biblioteca cv2. Elegimos la escala de grises porque creemos que el color no es crucial para diferenciar entre gatos y perros en esta tarea específica.
Para visualizar las imágenes, usaremos matplotlib.pyplot. Mostraremos una imagen de ejemplo usando plt.imshow y el mapa de colores en escala de grises. Este paso nos permite confirmar que las imágenes se cargan correctamente.
Luego de verificar las imágenes, procederemos a redimensionarlas a una forma uniforme. Necesitamos decidir un tamaño objetivo, como 50x50 píxeles, para garantizar la coherencia. Cambiaremos el tamaño de las imágenes usando la función cv2.resize y almacenaremos las matrices de imágenes redimensionadas.
Ahora, crearemos el conjunto de datos de entrenamiento. Inicializamos una lista vacía llamada "training_data" y definimos una función llamada "create_training_data". Dentro de esta función, iteramos a través de las imágenes y asignamos etiquetas numéricas (0 para perros, 1 para gatos) usando el índice de la categoría en la lista de "categorías".
Para cada imagen, la redimensionamos al tamaño de destino elegido. Agregamos la matriz de imágenes redimensionada y su etiqueta correspondiente a la lista de datos de entrenamiento. También manejamos cualquier posible excepción relacionada con imágenes rotas en el conjunto de datos.
Una vez que hemos creado el conjunto de datos de entrenamiento, debemos verificar el balance de los datos. En una tarea de clasificación binaria como esta, es fundamental tener el mismo número de muestras para cada clase (50% perros y 50% gatos). Los datos desequilibrados pueden dar lugar a predicciones sesgadas del modelo. Si sus datos están desequilibrados, puede usar pesos de clase durante el entrenamiento para mitigar este problema.
Para garantizar la aleatoriedad y evitar que el modelo aprenda el orden de las imágenes, mezclamos los datos de entrenamiento mediante la función random.shuffle.
Ahora que nuestros datos están mezclados, podemos empaquetarlos en variables para funciones (X) y etiquetas (Y). Inicializamos listas vacías para X e Y e iteramos a través de los datos de entrenamiento, agregando las funciones y etiquetas a las listas respectivas. Finalmente, convertimos X en una matriz NumPy y le damos nueva forma usando np.array y la forma de cada característica.
En este punto, hemos preparado nuestros datos para entrenar la red neuronal. Ahora estamos listos para continuar con otros pasos, como dividir los datos en conjuntos de entrenamiento y validación, construir el modelo y entrenarlo con TensorFlow.
Negativo 1 es un marcador de posición que calcula automáticamente el tamaño en función de la longitud de la matriz y la forma de cada elemento. Entonces, en este caso, estamos remodelando la matriz X para que tenga una forma de (-1, image_size, image_size). Esto asegura que los datos estén en el formato correcto para ingresar a la red neuronal.
A continuación, necesitamos normalizar los valores de píxel de las imágenes. Actualmente, los valores de píxel oscilan entre 0 y 255, lo que representa la intensidad de la escala de grises. Las redes neuronales generalmente funcionan mejor cuando los datos de entrada se normalizan, lo que significa que los valores se escalan a un rango más pequeño. Podemos lograr esto dividiendo los valores de píxel por 255,0, lo que los escalará entre 0 y 1,0. Esto se puede hacer usando el siguiente código:
x = x / 255.0
Redes neuronales convolucionales: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.3
Redes neuronales convolucionales: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.3
Hola a todos y bienvenidos a la tercera parte de nuestra serie de tutoriales sobre aprendizaje profundo con Python, TensorFlow y Keras. En este video, nos enfocaremos en las redes neuronales convolucionales (CNN) y cómo aplicarlas para clasificar perros versus gatos usando el conjunto de datos que construimos en el video anterior.
Antes de sumergirnos en las CNN, veamos rápidamente cómo funcionan y por qué son útiles para los datos de imágenes. Las CNN implican varios pasos: convolución, agrupación y luego más convolución y agrupación. La idea principal detrás de la convolución es extraer características útiles de una imagen. Usamos una ventana convolucional, típicamente representada como una matriz (por ejemplo, 3x3), para escanear la imagen y simplificar la información dentro de la ventana a un solo valor. Luego, la ventana se desplaza y repite este proceso varias veces. La zancada, que determina cuánto se mueve la ventana, también se puede ajustar.
Con Keras, podemos especificar el tamaño de la ventana y la mayoría de los demás detalles se solucionan automáticamente. Si desea profundizar en las complejidades del aprendizaje profundo, le recomiendo consultar la serie de tutoriales "Aprendizaje automático práctico", donde se explica el funcionamiento interno con más detalle, en particular para el código sin formato de TensorFlow.
La salida de la capa convolucional es un conjunto de características extraídas de la imagen. Luego, estas características generalmente se pasan a través de una capa de agrupación, siendo el tipo más común la agrupación máxima. La agrupación máxima selecciona el valor máximo dentro de una ventana y lo cambia repetidamente, reduciendo efectivamente la muestra de los datos.
La idea de alto nivel detrás de las CNN es que gradualmente extraen características más complejas de la imagen a medida que se profundiza en la red. Las capas iniciales pueden identificar bordes y líneas, mientras que las capas más profundas pueden reconocer formas más complejas como círculos o cuadrados. Eventualmente, la red puede aprender a identificar objetos o patrones específicos.
Para implementar una CNN, necesitamos importar las bibliotecas necesarias. Importamos TensorFlow y los módulos de Keras que usaremos, como Sequential, Dense, Dropout, Activation, Conv2D y MaxPooling2D. También importamos pickle para cargar nuestro conjunto de datos.
Antes de introducir los datos en la red neuronal, deberíamos considerar normalizarlos. En nuestro caso, podemos escalar los datos de píxeles dividiéndolos por 255, ya que los valores de píxeles van de 0 a 255. Alternativamente, podemos usar la función de normalización de chaos.utils para escenarios de normalización más complejos.
A continuación, comenzamos a construir nuestro modelo utilizando la API secuencial. Agregamos una capa Conv2D con 64 unidades y un tamaño de ventana de 3x3. El input_shape se establece dinámicamente usando X.shape. Luego agregamos una capa de activación usando la función de activación lineal rectificada (ReLU). A continuación, agregamos una capa de agrupación máxima con un tamaño de ventana de 2x2.
Repetimos este proceso agregando otra capa Conv2D y una capa de agrupación máxima correspondiente. En este punto, tenemos una red neuronal convolucional 2D.
Para pasar las características extraídas a una capa completamente conectada, necesitamos aplanar los datos. Agregamos una capa Flatten antes de agregar una capa densa final con 64 nodos. Finalmente, agregamos una capa de salida con un solo nodo y especificamos la función de activación, que puede ser categórica o binaria.
Compilamos el modelo especificando la función de pérdida (entropía cruzada categórica o binaria), el optimizador (p. ej., Adam) y las métricas para evaluar el rendimiento del modelo (p. ej., precisión).
Para entrenar el modelo, usamos el método de ajuste, pasando nuestros datos de entrada X y las etiquetas Y. También podemos especificar el tamaño del lote (p. ej., 32).
Usaremos el siguiente código para entrenar el modelo:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Este código entrenará el modelo utilizando los datos de entrada X y las etiquetas Y correspondientes. Establecemos el tamaño del lote en 32, lo que significa que el modelo procesará 32 muestras a la vez durante el entrenamiento. El parámetro validation_split se establece en 0.1, lo que significa que el 10 % de los datos se usará para la validación mientras se entrena el modelo.
Una vez que se entrena el modelo, podemos evaluar su rendimiento utilizando los datos de prueba. Podemos usar el siguiente código para evaluar el modelo:
model.evaluate(X_test, Y_test)
Aquí, X_test y Y_test representan los datos de prueba y las etiquetas, respectivamente. Este código devolverá el valor de pérdida y la precisión del modelo en los datos de prueba.
Después de evaluar el modelo, podemos usarlo para hacer predicciones sobre datos nuevos e invisibles. Podemos usar la función predict() para obtener las etiquetas predichas para los nuevos datos. Aquí hay un ejemplo:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
¡Eso es todo! Ahora ha entrenado un modelo de red neuronal convolucional para clasificar perros y gatos y lo ha usado para hacer predicciones sobre nuevos datos. Recuerde guardar el modelo entrenado para uso futuro si es necesario.
Análisis de modelos con TensorBoard: aprendizaje profundo con Python, TensorFlow y Keras p.4
Análisis de modelos con TensorBoard: aprendizaje profundo con Python, TensorFlow y Keras p.4
Bienvenidos todos a la parte 4 de la serie de tutoriales "Aprendizaje profundo con Python: TensorFlow y Keras". En este video y el siguiente, discutiremos cómo analizar y optimizar nuestros modelos usando TensorBoard. TensorBoard es una poderosa herramienta que nos permite visualizar el entrenamiento de nuestros modelos a lo largo del tiempo. Su objetivo principal es ayudarnos a comprender varios aspectos del rendimiento de nuestro modelo, como la precisión, la precisión de la validación, la pérdida y la pérdida de la validación. Además, hay funciones más avanzadas en TensorBoard que podemos explorar en tutoriales futuros.
Antes de sumergirnos en TensorBoard, abordemos un detalle menor. Aunque no es crucial para este tutorial, quiero señalar que incluso los modelos pequeños tienden a consumir una cantidad significativa de memoria GPU. Si planea ejecutar varios modelos simultáneamente, puede especificar una fracción de la memoria de GPU que debe usar cada modelo. Al hacer esto, puede evitar posibles problemas al ejecutar varios modelos o encontrar limitaciones de memoria. Por ejemplo, normalmente configuro el modelo para que use un tercio de la memoria de la GPU. Este enfoque ha resultado útil cuando se ejecutan varios modelos al mismo tiempo, como en la serie "Python Plays GTA" que involucra la detección de objetos y la conducción autónoma. Es solo un consejo útil que puede ahorrarle algo de tiempo y dolores de cabeza.
Ahora, sigamos con el tema principal. Lo primero que quiero abordar es agregar una función de activación después de la capa densa. Fue un descuido de mi parte no incluirlo inicialmente. Agregar una función de activación es esencial porque sin ella, la capa densa se convierte en una función de activación lineal, que no es adecuada para nuestros propósitos. Queremos evitar la regresión y asegurarnos de que nuestro modelo funcione de manera óptima. Entonces, arreglemos eso rápidamente insertando la función de activación antes de la capa densa.
Con esa corrección hecha, deberíamos observar una mejora significativa en la precisión. Mientras el modelo se entrena, tomemos un momento para explorar la documentación de TensorFlow y aprender sobre las diversas devoluciones de llamada de Keras disponibles. En nuestro caso, usaremos la devolución de llamada de TensorBoard para interactuar con TensorBoard. Sin embargo, vale la pena señalar que existen otras devoluciones de llamada útiles, como la detención anticipada en función de parámetros específicos, la programación de la tasa de aprendizaje y los puntos de control del modelo. Los puntos de control del modelo son particularmente valiosos cuando desea guardar el modelo a intervalos específicos, como la mejor pérdida o precisión de validación. Por ahora, concentrémonos en la devolución de llamada de TensorBoard, pero es posible que mencione brevemente otras devoluciones de llamada en un video futuro.
Para usar la devolución de llamada de TensorBoard, debemos importarla desde el módulo de devolución de llamada Keras de TensorFlow. Agrega la siguiente línea de código para importar TensorBoard:
from tensorflow.keras.callbacks import TensorBoard
Ahora que hemos importado el módulo necesario, realicemos algunas tareas de limpieza. Siempre es una buena práctica dar a su modelo un nombre significativo, especialmente cuando se trabaja con varios modelos. En este caso, podemos nombrar a nuestro modelo algo así como "cats_vs_dogs_CNN_64x2". Además, agreguemos una marca de tiempo al nombre para garantizar la unicidad. Incluir la marca de tiempo es útil cuando se vuelve a entrenar un modelo o se evita cualquier confusión con las versiones del modelo. Entonces, al comienzo de nuestro código, definamos el nombre del modelo y la marca de tiempo de la siguiente manera:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Además, el tablero de tensor nos permite analizar y optimizar nuestros modelos al proporcionar visualizaciones del proceso de capacitación. Se centra principalmente en métricas como precisión, precisión de validación, pérdida y pérdida de validación. Estas métricas nos ayudan a comprender el rendimiento de nuestro modelo a lo largo del tiempo e identificar áreas de mejora. Si bien la precisión y la pérdida se controlan comúnmente, el tablero de tensor ofrece funcionalidades más avanzadas que podemos explorar en el futuro.
Para comenzar a usar el tablero de tensor, primero debemos hacer una pequeña adición a nuestro código. Aunque no es crucial para este tutorial, vale la pena mencionarlo. Al agregar algunas líneas de código, podemos asignar una fracción específica de memoria GPU para nuestro modelo. Esto es beneficioso cuando se ejecutan varios modelos simultáneamente o cuando se encuentran problemas con la VRAM. Nos permite controlar la asignación de GPU y evitar posibles bloqueos o desbordamiento de memoria. En nuestro caso, asignamos un tercio de la GPU para el modelo. Esto asegura una ejecución fluida y evita cualquier conflicto al trabajar con otros modelos o proyectos.
Continuando, concentrémonos en implementar el tablero de tensor. En primer lugar, necesitamos importar las dependencias necesarias. Importamos el módulo "tensorboard" del paquete "tensorflow.keras.callbacks". Este módulo proporciona la funcionalidad de devolución de llamada para la placa de tensor.
A continuación, queremos asignar un nombre significativo a nuestro modelo. Dar a cada modelo un nombre distinto es esencial cuando se trabaja con varios modelos. Nos ayuda a realizar un seguimiento de los experimentos y evitar confusiones. En este caso, llamamos a nuestro modelo "cat's_first_dog_CNN_64x2_good_enough". Además, agregamos una marca de tiempo al nombre usando el valor de tiempo actual. Esto asegura la exclusividad y evita cualquier sobrescritura accidental de modelos.
Después de nombrar nuestro modelo, podemos definir el objeto de devolución de llamada del tablero de tensor. Creamos una instancia de la clase "TensorBoard" y la asignamos a la variable "tensorboard". Pasamos la ruta del directorio de registros al constructor. El directorio de registro es donde Tensor Board almacenará los registros y datos relacionados con nuestro modelo. Usamos formato de cadena para incluir el nombre del modelo en la ruta del directorio de registros.
Una vez que tengamos listo el objeto de devolución de llamada, podemos incorporarlo a nuestro proceso de entrenamiento del modelo. En el método de "ajuste" de nuestro modelo, pasamos el objeto de devolución de llamada al parámetro "devoluciones de llamada" como una lista. En este caso, solo tenemos una devolución de llamada, que es la devolución de llamada de la placa de tensor. Sin embargo, vale la pena señalar que puede incluir varias devoluciones de llamada en la lista si es necesario.
Con la devolución de llamada integrada, ahora podemos entrenar nuestro modelo. Establecemos el número de épocas en 10 para este ejemplo. Sin embargo, no dude en ajustar el número de épocas según sus requisitos. A medida que el modelo se entrena, el tablero de tensor comenzará a generar registros y visualizaciones en función de las métricas especificadas.
Para ver el tablero de tensores en acción, debemos abrir la ventana de comandos o la terminal y navegar hasta el directorio que contiene los archivos de registro. Una vez en el directorio correcto, ejecutamos el comando tensor board escribiendo "tensorboard --logdir logs" en el símbolo del sistema. Este comando inicia el servidor de la placa de tensor y proporciona una URL local donde podemos acceder a la interfaz de la placa de tensor.
Después de iniciar el tablero de tensor, podemos abrir un navegador web e ingresar la URL proporcionada por el símbolo del sistema. Esto mostrará la interfaz del tablero de tensores, donde podemos visualizar el progreso de entrenamiento de nuestro modelo. La interfaz muestra varios gráficos, incluida la precisión dentro de la muestra, la pérdida dentro de la muestra, la precisión fuera de la muestra y la pérdida fuera de la muestra. Analizamos estas métricas para monitorear el rendimiento del modelo y tomar decisiones informadas con respecto a su optimización.
Al observar los gráficos, podemos identificar patrones y tendencias en el comportamiento del modelo. Por ejemplo, si la pérdida de validación comienza a aumentar mientras que la precisión de la validación permanece estable o disminuye, esto indica un sobreajuste. Por otro lado, si tanto la precisión de la validación como la pérdida mejoran con el tiempo, sugiere que el modelo está aprendiendo de manera efectiva.
Tensor Board proporciona una plataforma poderosa para analizar y optimizar modelos. Sus visualizaciones ofrecen información valiosa sobre el proceso de formación y facilitan la toma de decisiones. Al aprovechar el tablero de tensor, podemos optimizar el proceso de desarrollo del modelo y lograr mejores resultados.
En la siguiente parte de esta serie de tutoriales, profundizaremos en las características avanzadas del tablero de tensor, incluidos histogramas, distribuciones e incrustaciones. Estas características brindan mayor granularidad y nos permiten obtener una comprensión más completa de nuestros modelos. Estén atentos para el próximo video, donde exploramos estas emocionantes capacidades.
Eso es todo por este tutorial. ¡Gracias por mirar, y nos vemos en el próximo video!
Optimización con TensorBoard: aprendizaje profundo con Python, TensorFlow y Keras p.5
Optimización con TensorBoard: aprendizaje profundo con Python, TensorFlow y Keras p.5
Hola a todos y bienvenidos a la quinta parte de la serie de tutoriales sobre aprendizaje profundo con Python TensorBoard y Keras. En este tutorial, nos centraremos en TensorBoard y cómo podemos usarlo para optimizar modelos al visualizar diferentes intentos de modelos. ¡Vamos a sumergirnos en él!
Primero, analicemos el modelo e identifiquemos los aspectos que podemos modificar para mejorar su rendimiento. Si bien nuestro modelo actual logró una precisión de alrededor del 79 %, creemos que podemos hacerlo mejor. Algunas áreas potenciales para la optimización incluyen el optimizador, la tasa de aprendizaje, la cantidad de capas densas, las unidades por capa, las unidades de activación, el tamaño del núcleo, la zancada, la tasa de descomposición y más. Con numerosas opciones para explorar, podemos terminar probando miles de modelos. ¿Así que por dónde empezamos?
Para facilitar las cosas, comencemos con las modificaciones más sencillas. Nos centraremos en ajustar el número de capas, nodos por capa y si incluir o no una capa densa al final. Para el número de capas densas, consideraremos cero, uno o dos. Con respecto a los tamaños de capa, usaremos valores de 32, 64 y 128. Estos valores son solo convenciones y puede elegir diferentes según sus preferencias.
Ahora, implementemos estos cambios en nuestro código. Definiremos algunas variables para las elecciones que queremos hacer, como el número de capas densas y los tamaños de las capas. Recorreremos estas variables para crear diferentes combinaciones de modelos. Además, crearemos un nombre para cada modelo que refleje su configuración.
Una vez que tenemos las configuraciones del modelo, podemos proceder a aplicarlas en nuestro código. Actualizaremos la estructura del modelo en consecuencia, teniendo en cuenta la forma de entrada, las capas convolucionales, las capas densas y la capa de salida. También nos aseguraremos de que los tamaños de las capas se ajusten adecuadamente.
Con todos los cambios realizados, es hora de ejecutar el código. Sin embargo, dado que entrenar numerosos modelos puede llevar mucho tiempo, ya ejecuté el código y guardé los resultados. Procedamos a analizar los resultados utilizando TensorBoard.
Cargamos los registros de TensorBoard y observamos las diferentes combinaciones de modelos. Los modelos se organizan en función de su rendimiento, específicamente la pérdida de validación. Nos centramos en los modelos de mejor rendimiento y tomamos nota de sus configuraciones.
A partir de los resultados, se hace evidente que los modelos con tres capas convolucionales y cero capas densas funcionan bien de manera consistente. El número específico de nodos por capa parece menos significativo. Sin embargo, vale la pena señalar que las capas densas más grandes, como 512 o 256 nodos, pueden generar resultados aún mejores. Para verificar esto, puede probar diferentes tamaños de capas densas.
Para resumir, comenzamos explorando varias configuraciones de modelos usando TensorBoard. Descubrimos que los modelos con tres capas convolucionales y sin capas densas funcionaron bien de manera consistente. También identificamos que la cantidad de nodos por capa podría optimizarse aún más. Al probar diferentes tamaños de capas densas, potencialmente podemos mejorar aún más la precisión del modelo.
Tenga en cuenta que este es solo un punto de partida y que hay muchos otros aspectos que puede modificar para optimizar sus modelos. TensorBoard proporciona una herramienta valiosa para visualizar y analizar estas variaciones del modelo, lo que lo ayuda a tomar decisiones informadas para mejorar el modelo.
Cómo usar su modelo entrenado: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.6
Cómo usar su modelo entrenado: conceptos básicos de aprendizaje profundo con Python, TensorFlow y Keras p.6
¡Hola a todos y bienvenidos a la Parte 6 de la serie de tutoriales Aprendizaje profundo en Python con TensorFlow y Keras!
En este video, discutiremos cómo usar nuestro modelo entrenado para hacer predicciones sobre nuevas imágenes. Muchas personas han estado preguntando acerca de esto, ya que han entrenado y probado con éxito sus conjuntos de datos, pero no están seguros de cómo usar el modelo para predecir imágenes externas. Entonces, ¡vamos a sumergirnos en eso!
Primero, necesitamos importar las bibliotecas necesarias. Importaremos cv2 para el procesamiento de imágenes y tensorflow como TF para trabajar con nuestro modelo. También necesitaremos la lista de categorías, que contiene las etiquetas de clase "perro" y "gato" que usamos durante el entrenamiento.
A continuación, definiremos una función llamada preparar que toma una ruta de archivo como parámetro. Esta función se encargará de los pasos de preprocesamiento necesarios para la imagen de entrada. Cambiaremos el tamaño de la imagen a un tamaño específico y la convertiremos a escala de grises. Luego, la imagen se devolverá como una matriz numpy remodelada.
Después de eso, cargaremos nuestro modelo entrenado usando la función TF.keras.models.load_model(). Anteriormente, guardamos nuestro modelo como un "modelo CNN de 64 por 3", por lo que lo cargaremos con el mismo nombre.
Ahora, estamos listos para hacer predicciones. Definiremos una variable llamada predicción y le asignaremos el resultado de llamar a model.predict() en nuestra imagen preparada. Es importante tener en cuenta que el método predict() espera una lista como entrada, incluso si estamos prediciendo en una sola imagen. Entonces, necesitamos pasar la imagen preparada como una lista.
Una vez que tenemos el resultado de la predicción, podemos imprimirlo. Sin embargo, la predicción actualmente tiene la forma de una lista anidada. Para hacerlo más legible, podemos convertir el valor de predicción en un número entero y usarlo como índice para recuperar la etiqueta de clase correspondiente de la lista de categorías.
Finalmente, podemos imprimir la etiqueta de clase predicha, que representa si la imagen se clasifica como un perro o un gato.
En este tutorial, hemos usado dos imágenes externas para probar nuestro modelo: una de un perro con un cono de vergüenza y otra de una criatura desconocida. Estas imágenes no formaban parte de nuestro conjunto de datos de entrenamiento, lo que garantiza que estamos haciendo predicciones sobre datos no vistos.
Para probarlo con sus propias imágenes de perros y gatos, siga los pasos descritos en el código. Tenga en cuenta que la precisión puede variar, pero en promedio, debe ser de alrededor del 80%.
¡Eso es todo por ahora! Quiero agradecer a nuestros patrocinadores recientes: Michael, Nick, Rodrigo y Papasan E. Su apoyo es muy apreciado. Si tiene alguna pregunta, comentario o sugerencia para futuros tutoriales, déjelos a continuación. También estoy abierto a ideas para usar redes neuronales recurrentes, así que si tiene un conjunto de datos simple en mente, hágamelo saber.
Nos vemos en el próximo tutorial, donde exploraremos las redes neuronales recurrentes. Hasta entonces, ¡feliz codificación!
Redes neuronales recurrentes (RNN): aprendizaje profundo con Python, TensorFlow y Keras p.7
Redes neuronales recurrentes (RNN): aprendizaje profundo con Python, TensorFlow y Keras p.7
Hola a todos, y bienvenidos a la Parte 7 de la serie de tutoriales Deep Learning con Python TensorFlow in Chaos. En esta parte, nos centraremos en la red neuronal recurrente (RNN). El propósito de un RNN es capturar el significado y la importancia del orden de los datos. Esto es particularmente relevante en los datos de series temporales, donde los datos se organizan temporalmente, y en el procesamiento del lenguaje natural, donde el orden de las palabras en una oración tiene significado.
Para ilustrar el concepto, consideremos el ejemplo de una oración: "Algunas personas hicieron una red neuronal". Cuando esta oración es procesada por una red neuronal profunda, que típicamente tokeniza los datos dividiéndolos en palabras individuales, la red puede fallar en capturar el significado correcto. Por ejemplo, la oración "Una red neuronal creó a algunas personas" tiene un significado completamente diferente. Esto enfatiza la importancia del orden de las palabras para determinar el significado de una oración.
Ahora, profundicemos en el funcionamiento de una red neuronal recurrente. El bloque de construcción básico de un RNN es la celda recurrente, que a menudo se implementa utilizando una celda de memoria a corto plazo (LSTM). Aunque existen otras opciones como la unidad recurrente cerrada (GRU), la celda LSTM se usa comúnmente. En una RNN, cada celda toma datos secuenciales como entrada y salida a la siguiente capa o a la siguiente celda en la capa recurrente.
La salida de una celda se puede dirigir de diferentes maneras. Puede pasar a la siguiente capa oa la siguiente celda de forma unidireccional o bidireccional. En este tutorial, nos centraremos en un RNN unidireccional básico. Para ilustrar esto, imagina un cuadro verde que representa una celda recurrente. Los datos de la celda anterior ingresan a la celda actual, que realiza operaciones como olvidar información irrelevante del nodo anterior, incorporar nuevos datos de entrada y decidir qué información enviar a la siguiente capa o nodo.
Para visualizar mejor este proceso, consideremos una celda específica en la capa. El cuadro verde representa la celda actual. Los datos fluyen desde la celda anterior, se ajustan y entran en la celda LSTM. Dentro de la celda, hay operaciones para olvidar información del nodo anterior, incorporar nuevos datos de entrada y determinar la salida que se pasará a la siguiente capa o nodo. Estas operaciones colectivamente permiten que la celda LSTM retenga información importante y la transmita a capas o nodos posteriores.
Implementar un RNN puede ser complejo, especialmente cuando se trata de valores escalares. Si está interesado en una explicación detallada de cómo funcionan las células LSTM, le recomiendo consultar una guía completa que las explica en profundidad. He incluido un enlace a esta guía en la versión de texto del tutorial para su referencia.
Ahora, pasemos a construir una red neuronal recurrente básica. En este tutorial, comenzaremos con un ejemplo simple utilizando el conjunto de datos M-NIST. En el próximo tutorial, trabajaremos con datos de series temporales más realistas, centrándonos específicamente en los precios de las criptomonedas.
Para comenzar, importemos las bibliotecas necesarias. Importaremos TensorFlow como tf, el modelo Sequential de tensorflow.keras.models, la capa Dense de tensorflow.keras.layers, así como las celdas Dropout y LSTM. Tenga en cuenta que si usa la versión GPU de TensorFlow, también hay una celda LSTM optimizada llamada celda KU DNN LSTM. Sin embargo, para este tutorial, nos ceñiremos a la celda LSTM regular. Si está utilizando la versión de CPU de TensorFlow, el cálculo puede llevar mucho tiempo.
A continuación, necesitamos cargar el conjunto de datos. Para este ejemplo, usaremos el conjunto de datos M-NIST. Podemos cargarlo fácilmente usando la función tf.keras.datasets.mnist.load_data(), que devuelve los datos de entrenamiento y prueba. Descomprimamos los datos en variables: X_train, Y_train, X_test y Y_test.
Primero, normalicemos los datos de entrada dividiendo cada valor de píxel por 255. Esto escalará los valores de píxel a un rango entre 0 y 1, lo cual es adecuado para el entrenamiento de redes neuronales. Podemos lograr esto dividiendo los datos de entrenamiento y prueba por 255.
X_train = X_train / 255.0 X_test = X_test / 255.0
A continuación, necesitamos convertir las etiquetas de destino en vectores codificados en caliente. En el conjunto de datos M-NIST, las etiquetas son números enteros que van del 0 al 9 y representan los dígitos. La codificación one-hot convierte cada etiqueta en un vector binario de longitud 10, donde el índice correspondiente al dígito se establece en 1 y todos los demás índices se establecen en 0. Podemos usar la función to_categorical de tensorflow.keras.utils para realizar una -codificación en caliente.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Ahora, definamos la arquitectura de nuestra red neuronal recurrente. Usaremos el modelo secuencial de tensorflow.keras.models y le agregaremos capas.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Ahora, compilemos el modelo especificando la función de pérdida, el optimizador y la métrica de evaluación.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Finalmente, entrenemos el modelo usando los datos de entrenamiento y evaluémoslo en los datos de prueba.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
¡Eso es todo! Ahora ha creado una red neuronal recurrente utilizando celdas LSTM para el conjunto de datos M-NIST. Puede experimentar con diferentes arquitecturas, hiperparámetros y conjuntos de datos para explorar más a fondo las capacidades de las RNN.
Introducción a RNN para la predicción de criptomonedas: aprendizaje profundo con Python, TensorFlow y Keras p.8
Introducción a RNN para la predicción de criptomonedas: aprendizaje profundo con Python, TensorFlow y Keras p.8
Hola a todos y bienvenidos a otro video tutorial de aprendizaje profundo con Python. En este video y en los próximos, discutiremos cómo aplicar una red neuronal recurrente (RNN) a un ejemplo más realista de trabajar con datos secuenciales. Específicamente, trabajaremos con un conjunto de datos de series temporales que consta de precios y volúmenes de criptomonedas.
Antes de profundizar en los detalles, quiero aclarar que puede aplicar los mismos conceptos a otros tipos de datos secuenciales, como precios de acciones o datos de sensores. Por lo tanto, incluso si no está interesado en las finanzas, aún puede seguirlo y comprender los conceptos.
El objetivo de este tutorial es utilizar una red neuronal recurrente para predecir el precio futuro de una criptomoneda en función de su precio y volumen anteriores. Nos centraremos en cuatro criptomonedas principales: Bitcoin, Litecoin, Ethereum y Bitcoin Cash. La idea es tomar los últimos 60 minutos de datos de precio y volumen para cada una de estas criptomonedas y usarlos como entrada para predecir el precio de Litecoin, por ejemplo, tres minutos en el futuro.
Este tipo de problema de predicción también se puede aplicar a otros dominios, como la predicción de fallas del servidor o el tráfico del sitio web en función del tiempo y los datos de uso. El objetivo final es predecir una clasificación (p. ej., si el precio subirá o bajará) o realizar una regresión (p. ej., predecir el precio real o el cambio porcentual).
Trabajar con datos secuenciales presenta desafíos únicos. En primer lugar, necesitamos preprocesar los datos y convertirlos en secuencias que la red neuronal recurrente pueda manejar. Además, necesitamos equilibrar y normalizar los datos, considerando que los precios y volúmenes de diferentes criptomonedas pueden tener diferentes escalas. Escalar los datos es más complejo que en otros dominios, como los datos de imágenes, donde simplemente dividimos por 255.
Además, evaluar el desempeño del modelo utilizando datos fuera de la muestra es un desafío diferente cuando se trabaja con datos secuenciales. Hay varios aspectos que debemos cubrir, incluida la preparación, normalización y evaluación de datos.
Para comenzar, le he proporcionado un conjunto de datos para que lo descargue. Puede encontrar el enlace de descarga en la descripción del tutorial. Una vez que extraiga el archivo zip descargado, encontrará cuatro archivos, cada uno correspondiente a los datos de precio y volumen de una criptomoneda.
Usaremos la biblioteca pandas en Python para leer y manipular el conjunto de datos. Si no tiene pandas instalados, puede hacerlo ejecutando el comando pip install pandas en su terminal o símbolo del sistema.
A continuación, leeremos el conjunto de datos usando pandas y examinaremos los datos. Nos centraremos en las columnas de volumen y precio de "cierre" para cada criptomoneda. Para fusionar los datos de diferentes archivos, estableceremos la columna "tiempo" como índice para cada marco de datos. Luego, uniremos los marcos de datos en función de su índice compartido.
Una vez que tenemos el marco de datos fusionado, necesitamos definir algunos parámetros. Estos incluyen la duración de la secuencia (la cantidad de períodos pasados a considerar), el período futuro (la cantidad de períodos en el futuro a predecir) y la proporción a predecir (la criptomoneda que queremos predecir).
En nuestro caso, nos centraremos en predecir el precio futuro de Litecoin (LTC) en función de los últimos 60 minutos de datos, y pronosticaremos tres minutos en el futuro. También definiremos una regla de clasificación, donde clasificamos la predicción como un aumento o disminución de precios en función de los precios actuales y futuros.
Con estos pasos iniciales completados, ahora estamos listos para preprocesar los datos, crear secuencias y entrenar la red neuronal recurrente. Cubriremos estos temas en los próximos videos, así que estén atentos.
Si desea continuar, asegúrese de descargar el conjunto de datos y configurar las bibliotecas necesarias. Puede encontrar el código completo y las instrucciones en la versión basada en texto del tutorial, que está disponible en la descripción.
Tenemos mucho que cubrir, así que lo clasificaremos como 1, lo que indica un aumento de precio. De lo contrario, si el precio futuro es más bajo que el precio actual, lo clasificaremos como 0, lo que indica una caída del precio. Esta es una regla simple que estamos usando para la clasificación, pero puede experimentar con diferentes reglas o incluso usar la regresión para predecir el cambio de precio real.
Ahora, creemos la columna de destino en nuestro DataFrame principal. Usaremos la función de cambio de pandas para cambiar los valores de la columna "LTCUSD_close" por el período futuro. Esto nos dará los precios futuros que compararemos con los precios actuales para determinar la clasificación. Asignaremos el resultado a una nueva columna llamada "objetivo".
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
A continuación, creemos las secuencias de entrada. Recorreremos el DataFrame y crearemos secuencias de secuencia de longitud, que consisten en los precios y volúmenes anteriores de Bitcoin, Litecoin, Ethereum y Bitcoin Cash. Guardaremos estas secuencias en una lista llamada "secuencias".
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Finalmente, convertiremos las secuencias y los objetivos en matrices numpy para facilitar la manipulación y el entrenamiento.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Tenga en cuenta que el código proporcionado aquí es una implementación parcial y se centra en los pasos de preprocesamiento de datos. Deberá seguir desarrollando la arquitectura del modelo, entrenar el modelo y evaluar su rendimiento. Además, es posible que deba ajustar los hiperparámetros y experimentar con diferentes técnicas para mejorar la precisión del modelo.
Recuerde importar las bibliotecas necesarias, manejar los datos faltantes, preprocesar las funciones (normalización, escalado, etc.) y dividir los datos en conjuntos de entrenamiento y prueba antes de entrenar el modelo.
Espero que esto lo ayude a comprender el proceso de trabajar con datos secuenciales y aplicar redes neuronales recurrentes para predecir precios futuros. ¡Buena suerte con tu proyecto de aprendizaje profundo!
Normalización y creación de secuencias Crypto RNN - Aprendizaje profundo con Python, TensorFlow y Keras p.9
Normalización y creación de secuencias Crypto RNN - Aprendizaje profundo con Python, TensorFlow y Keras p.9
Hola a todos y bienvenidos de nuevo a otro episodio de la serie de tutoriales Deep Learning con Python, TensorFlow y Chaos. En este video, continuaremos trabajando en nuestro mini proyecto de implementar una red neuronal recurrente (RNN) para predecir los futuros movimientos de precios de una criptomoneda. Usaremos las secuencias de precios y volúmenes de la moneda, junto con otros tres precios y volúmenes de criptomonedas.
Hasta ahora, hemos obtenido los datos, los hemos fusionado y creado los objetivos. Ahora, pasemos a los siguientes pasos. Necesitamos crear secuencias a partir de los datos y realizar tareas como el equilibrio, la normalización y el escalado. Sin embargo, antes de sumergirse en esas tareas, es crucial abordar el problema de las pruebas fuera de muestra.
Cuando se trata de datos temporales y de series temporales, mezclar y seleccionar aleatoriamente una parte como datos fuera de la muestra puede conducir a un modelo sesgado. En nuestro caso, con secuencias de 60 minutos y una ventana de predicción de 3 minutos, la selección aleatoria de los datos fuera de la muestra podría dar como resultado ejemplos similares presentes en los conjuntos dentro y fuera de la muestra. Esto facilitaría que el modelo se ajuste en exceso y tenga un rendimiento deficiente en datos no vistos.
Para abordar esto, debemos seleccionar cuidadosamente los datos fuera de la muestra. Para los datos de series temporales, se recomienda elegir un fragmento de datos del futuro como conjunto fuera de la muestra. En nuestro caso, tomaremos el último 5% de los datos históricos como nuestros datos fuera de la muestra. Este enfoque simula la construcción del modelo hace un 5 % del tiempo y luego lo prueba.
Ahora, implementemos esta separación de datos fuera de la muestra. Ordenaremos los datos según la marca de tiempo y encontraremos el umbral del último 5% de las veces. Al separar los datos de esta manera, nos aseguramos de que el conjunto fuera de la muestra contenga datos del futuro, evitando la fuga de datos y las pruebas sesgadas. Una vez separados, tendremos los datos de validación y los datos de entrenamiento.
Antes de continuar, es importante tener en cuenta que debemos preprocesar los datos de validación y entrenamiento. Crearemos secuencias, equilibraremos los datos, los normalizaremos, los escalaremos y realizaremos otras tareas necesarias. Para agilizar este proceso, creemos una función llamada preprocess_df que tome un DataFrame como entrada y realice todos estos pasos de preprocesamiento.
Primero, importamos el módulo de preprocesamiento de la biblioteca sklearn. Si no lo tiene instalado, puede hacerlo ejecutando pip install sklearn. Luego, definimos la función preprocess_df que toma un DataFrame como parámetro.
Dentro de la función, comenzamos eliminando la columna de futuro innecesaria del DataFrame. A continuación, iteramos sobre las columnas del DataFrame y aplicamos la transformación de cambio porcentual. Este paso de normalización ayuda a manejar diferentes magnitudes de precios y volúmenes en las criptomonedas.
Después de normalizar los datos, eliminamos las filas que contienen valores NaN, ya que pueden causar problemas durante el entrenamiento. Luego, usamos la función preprocessing.scale para escalar los valores entre 0 y 1. Alternativamente, puede implementar su propia lógica de escala.
Ahora que hemos preprocesado los datos, pasemos al manejo de datos secuenciales. Creamos una lista vacía llamada secuencial_datos e inicializamos un objeto deque llamado prev_days con una longitud máxima de 60. El objeto deque nos permite agregar nuevos elementos de manera eficiente y eliminar automáticamente los antiguos cuando alcanza la longitud máxima.
A continuación, iteramos sobre los valores del DataFrame, que ahora contiene los datos normalizados y escalados. Para cada fila, agregamos los valores a la deque prev_days. Una vez que el deque alcanza una longitud de al menos 60, comenzamos a completar los datos secuenciales.
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
Ahora que hemos generado las secuencias, podemos proceder a equilibrar los datos. El equilibrio es importante para evitar cualquier sesgo hacia una clase específica en nuestros datos de entrenamiento. En este caso, nuestras clases son los diferentes movimientos de precios (hacia arriba o hacia abajo). Para equilibrar los datos, contaremos la cantidad de ocurrencias de cada clase y limitaremos la cantidad de secuencias para que la clase mayoritaria coincida con la clase minoritaria.
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
Después de equilibrar los datos, podemos dividirlos en matrices de características de entrada (X) y etiquetas de destino (y).
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
Ahora que tenemos X como características de entrada e y como etiquetas de destino, podemos proceder a dividir los datos en conjuntos de entrenamiento y validación.
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
En el código anterior, usamos la función train_test_split de scikit-learn para dividir los datos en conjuntos de entrenamiento y validación. Asignamos el 80% de los datos al conjunto de entrenamiento (tren_x y tren_y) y el 20%
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
Con los datos preparados, ahora podemos construir y entrenar el modelo LSTM:
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
Definimos el optimizador como Adam con una tasa de aprendizaje de 0.001 y compilamos el modelo usando entropía cruzada categórica dispersa como función de pérdida y precisión como métrica.
La detención temprana se define mediante la devolución de llamada EarlyStopping para monitorear la pérdida de validación y detener el entrenamiento si no mejora después de 3 épocas.
El modelo se entrena usando la función de ajuste, pasando los datos de entrenamiento (train_x y train_y), los datos de validación (val_x y val_y) y las devoluciones de llamadas definidas. El entrenamiento se realiza durante 20 épocas.
Puede ajustar la arquitectura del modelo, los hiperparámetros y la configuración de entrenamiento según sus requisitos específicos.
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
Luego, usamos el método de evaluación del modelo para calcular la pérdida y la precisión de los datos de prueba. El método de evaluación toma los datos de entrada de la prueba (test_x) y las etiquetas de verdad del terreno correspondientes (test_y). La pérdida y la precisión calculadas se imprimen en la consola.
Recuerda importar los módulos necesarios al comienzo de tu script:
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Este código le permitirá entrenar un modelo LSTM para su tarea de clasificación de compra/venta, normalizar los datos y evaluar el rendimiento del modelo en el conjunto de prueba. Siéntase libre de hacer cualquier ajuste o modificación según sus requisitos específicos.