Secuencia de comprencion en python

Las secuencias de comprensión en Python son formas concisas y eficientes de generar

listas, conjuntos o diccionarios usando una sola línea de código.

📌 Tipos de Comprensión en Python

11️⃣List Comprehension (Comprensión de listas)

2️⃣Set Comprehension (Comprensión de conjuntos)
3️⃣Dict Comprehension (Comprensión de diccionarios)
4️⃣Generator Expression (Expresión generadora)

1 List Comprehension (Listas)

Es la más usada y permite crear listas de forma compacta.

# Crear una lista con los cuadrados de los números del 1 al 5

cuadrados = [x**2 for x in range(1, 6)]
print(cuadrados) # Salida: [1, 4, 9, 16, 25]

🔹 Equivalente a:

cuadrados = []
for x in range(1, 6):
[Link](x**2)

📌 Con condición (if)

pares = [x for x in range(10) if x % 2 == 0]

print(pares) # Salida: [0, 2, 4, 6, 8]

📌 Con if-else

valores = ["par" if x % 2 == 0 else "impar" for x in range(5)]

print(valores) # Salida: ['par', 'impar', 'par', 'impar', 'par']

🚀 Aquí tienes bastantes ejemplos de List Comprehension en Python, desde lo básico

hasta lo avanzado.
📌 1 Concepto Básico

La comprensión de listas permite crear listas en una sola línea de código de manera
eficiente.

Ejemplo 1: Crear una lista de números elevados al cuadrado

numeros = [1, 2, 3, 4, 5]
cuadrados = [n**2 for n in numeros]
print(cuadrados) # 🔹 [1, 4, 9, 16, 25]

✅ Equivalente a:

cuadrados = []
for n in numeros:
[Link](n**2)

📌 2️⃣ Filtrar Elementos con Condiciones

Puedes agregar condiciones dentro de la lista.

Ejemplo 2: Obtener solo los números pares

python
CopiarEditar
pares = [n for n in range(10) if n % 2 == 0]
print(pares) # 🔹 [0, 2, 4, 6, 8]

Ejemplo 3: Convertir una lista de strings a mayúsculas, solo si tienen más de

3 letras
python
CopiarEditar
palabras = ["sol", "luna", "estrella", "mar"]
mayusculas = [[Link]() for p in palabras if len(p) > 3]
print(mayusculas) # 🔹 ['LUNA', 'ESTRELLA']

📌 3️⃣ Usar Condiciones If-Else Dentro

Si necesitas transformar valores según una condición, usa if-else.

Ejemplo 4: Reemplazar números negativos por 'negativo'

python
CopiarEditar
numeros = [10, -5, 3, -2, 8]
resultado = [n if n >= 0 else "negativo" for n in numeros]
print(resultado) # 🔹 [10, 'negativo', 3, 'negativo', 8]

📌 4️⃣ Trabajar con Strings

Puedes aplicar operaciones en strings dentro de una List Comprehension.

Ejemplo 5: Obtener la primera letra de cada palabra

python
CopiarEditar
frutas = ["manzana", "pera", "uva", "kiwi"]
iniciales = [f[0] for f in frutas]
print(iniciales) # 🔹 ['m', 'p', 'u', 'k']

Ejemplo 6: Contar vocales en una palabra

python
CopiarEditar
palabra = "computadora"
vocales = [letra for letra in palabra if letra in "aeiou"]
print(len(vocales)) # 🔹 5 (las vocales en "computadora")

📌 5️⃣ Anidar Bucles en List Comprehension

Puedes combinar dos bucles dentro de una misma expresión.

Ejemplo 7: Multiplicación de matrices (producto cartesiano)

python
CopiarEditar
matriz = [(x, y) for x in range(3) for y in range(3)]
print(matriz)
# 🔹 [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2,
2)]

📌 6️⃣ Uso con Diccionarios (Dict Comprehension)

También funciona con diccionarios (Dict Comprehension).

Ejemplo 8: Crear un diccionario con el cuadrado de números

python
CopiarEditar
numeros = [1, 2, 3, 4, 5]
diccionario = {n: n**2 for n in numeros}
print(diccionario)
# 🔹 {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Ejemplo 9: Convertir una lista de nombres en un diccionario con su longitud

python
CopiarEditar
nombres = ["Carlos", "Ana", "Miguel", "Lucía"]
longitudes = {nombre: len(nombre) for nombre in nombres}
print(longitudes)
# 🔹 {'Carlos': 6, 'Ana': 3, 'Miguel': 6, 'Lucía': 5}

📌 7️⃣ Uso con Conjuntos (Set Comprehension)

Si necesitas valores únicos, usa Set Comprehension.

Ejemplo 10: Obtener los números únicos elevados al cubo

python
CopiarEditar
numeros = [2, 3, 2, 4, 3, 5]
cubos_unicos = {n**3 for n in numeros}
print(cubos_unicos)
# 🔹 {8, 27, 64, 125}

📌 8️⃣ Casos Aplicados a Machine Learning y Data Science

En ciencia de datos, List Comprehension optimiza el procesamiento de listas.

Ejemplo 11: Normalizar una lista de precios (Min-Max Scaling)

python
CopiarEditar
precios = [100, 200, 300, 400, 500]
maximo = max(precios)
minimo = min(precios)

normalizados = [(p - minimo) / (maximo - minimo) for p in precios]

print(normalizados)
# 🔹 [0.0, 0.25, 0.5, 0.75, 1.0]

Ejemplo 12: Extraer palabras clave de un texto

python
CopiarEditar
texto = "El Bitcoin y Ethereum son criptomonedas populares"
palabras_clave = [p for p in [Link]() if [Link]() not in ["el",
"y", "son"]]
print(palabras_clave)
# 🔹 ['Bitcoin', 'Ethereum', 'criptomonedas', 'populares']

📌 9️⃣ Generadores con () en Lugar de []

Si no necesitas guardar la lista, usa Generators con ().

Ejemplo 13: Sumar los cuadrados de los primeros 1000 números sin crear
una lista grande
python
CopiarEditar
suma_cuadrados = sum(n**2 for n in range(1000))
print(suma_cuadrados)

✅ Más eficiente en memoria que [n**2 for n in range(1000)].

📌 🔥 10️⃣ List Comprehension en Trading y Criptomonedas

Ejemplo 14: Obtener el precio máximo de BTC en las últimas 10 velas

python
CopiarEditar
precios = [41000, 41200, 40800, 41500, 41700, 42000, 41850, 42300, 42500,
43000]
maximo = max([p for p in precios])
print(maximo) # 🔹 43000

Ejemplo 15: Filtrar operaciones ganadoras (profit > 0)

python
CopiarEditar
operaciones = [{"precio_entrada": 41000, "precio_salida": 41500},
{"precio_entrada": 42000, "precio_salida": 41800},
{"precio_entrada": 42500, "precio_salida": 43000}]

ganadoras = [op for op in operaciones if op["precio_salida"] >

op["precio_entrada"]]
print(ganadoras)
# 🔹 [{'precio_entrada': 41000, 'precio_salida': 41500},
{'precio_entrada': 42500, 'precio_salida': 43000}]

🎯 Conclusión

🔹 List Comprehension es una herramienta poderosa para optimizar código en Python.

🔹 Se puede usar en listas, diccionarios, conjuntos y generadores.
🔹 Útil en Machine Learning, Trading y Ciencia de Datos.
🔥 ¿Te gustaría ejemplos más avanzados o con datos reales de Binance? 🚀

4o

Dijiste:
ejemplo mas avanzados pero paso a paso y despues con datos reales en binance

ChatGPT dijo:

¡Genial! Vamos a profundizar en List Comprehension con ejemplos más avanzados paso
a paso y luego aplicaremos la técnica con datos reales de Binance. 🚀

📌 1️⃣ Ejemplo Avanzado: Transformación de Datos en un

DataFrame

🎯 Objetivo:

Simularemos datos de precios de BTC y crearemos nuevas columnas usando List

Comprehension en pandas.

Paso 1: Crear un DataFrame Simulado

import pandas as pd
import numpy as np

# Crear datos simulados para BTC

[Link](42) # Reproducibilidad
data = {
"precio": [Link](40000, 50000, 10), # Precios aleatorios
"volumen": [Link](100, 500, 10), # Volumen aleatorio
}
df = [Link](data)

print(df)

✅ Salida esperada (valores variarán por random):

precio volumen
0 47474 220.584252
1 45773 488.635578
2 40486 323.181723
3 49465 478.915082
4 42643 218.883132
5 49269 322.050949
6 40245 322.628450
7 48900 237.024530
8 44069 136.266758
9 40512 188.034667
Paso 2: Calcular Diferencia de Precios con List Comprehension
df["cambio"] = [df["precio"][i] - df["precio"][i-1] if i > 0 else 0 for i
in range(len(df))]
print(df)

✅ Ahora tenemos la diferencia de precio entre velas.

Paso 3: Clasificar las Velas (Alcista/Bajista)

df["tipo_vela"] = ["Alcista" if df["cambio"][i] > 0 else "Bajista" for i
in range(len(df))]
print(df)

✅ Clasificamos cada vela según su cambio de precio.

Paso 4: Filtrar Solo las Velas Alcistas

velas_alcistas = df[[df["tipo_vela"][i] == "Alcista" for i in
range(len(df))]]
print(velas_alcistas)

✅ Ahora tenemos solo las velas alcistas en un nuevo DataFrame.

📌 2️⃣ Usando List Comprehension en Binance

🎯 Objetivo:

Obtener datos reales de BTC en Binance y aplicar List Comprehension para análisis.

Paso 1: Obtener Datos Reales con Binance API

import requests

# URL de Binance para obtener velas de BTC/USDT

url = "[Link]
params = {
"symbol": "BTCUSDT",
"interval": "1h", # Velas de 1 hora
"limit": 10 # Últimas 10 velas
}

# Obtener datos
response = [Link](url, params=params)
data = [Link]()

# Convertir datos a DataFrame

df = [Link](data, columns=["time", "open", "high", "low", "close",
"volume",
"close_time", "quote_asset_volume",
"trades",
"taker_buy_base", "taker_buy_quote",
"ignore"])

# Convertir columnas a float

df["close"] = df["close"].astype(float)
df["volume"] = df["volume"].astype(float)
print(df[["close", "volume"]]) # Mostrar solo precios de cierre y
volumen

✅ Ahora tenemos datos reales de Binance.

Paso 2: Calcular Diferencia de Precios

df["cambio"] = [df["close"][i] - df["close"][i-1] if i > 0 else 0 for i
in range(len(df))]

✅ Calculamos cuánto cambió el precio en cada vela.

Paso 3: Identificar Velas Alcistas y Bajistas

df["tipo_vela"] = ["Alcista" if df["cambio"][i] > 0 else "Bajista" for i
in range(len(df))]

✅ Clasificamos cada vela en Alcista/Bajista.

Paso 4: Filtrar Solo Velas Alcistas
velas_alcistas = df[[df["tipo_vela"][i] == "Alcista" for i in
range(len(df))]]
print(velas_alcistas[["close", "tipo_vela"]])

✅ Filtramos las velas alcistas con precios de cierre.

📌 3️⃣ 🔥 Optimización con Pandas (Más Rápido)

En lugar de List Comprehension, podemos hacer esto en una sola línea con pandas:

df["cambio"] = df["close"].diff()
df["tipo_vela"] = df["cambio"].apply(lambda x: "Alcista" if x > 0 else
"Bajista")

✅ Esto es más rápido que List Comprehension en grandes datasets.

📌 Resumen Final
Ejemplo Descripción

1️⃣DataFrame Simulado Creamos datos de BTC manualmente.

2️⃣Diferencia de Precios Calculamos el cambio de precio entre velas.

3️⃣Clasificación de Velas Identificamos si una vela es alcista o bajista.

4️⃣Datos Reales de Binance Aplicamos la misma lógica con datos reales.

5️⃣Optimización con Pandas Convertimos List Comprehension en código más eficiente.

2 Set Comprehension (Conjuntos)

2️⃣

Igual que la comprensión de listas, pero genera un conjunto (set) en vez de una lista.

cuadrados = {x**2 for x in range(1, 6)}

print(cuadrados) # Salida: {1, 4, 9, 16, 25}

3️⃣Dict Comprehension (Diccionarios)

Permite crear diccionarios de forma rápida.

cuadrados_dict = {x: x**2 for x in range(1, 6)}

print(cuadrados_dict)
# Salida: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

📌 Filtrando valores

pares_cuadrados = {x: x**2 for x in range(10) if x % 2 == 0}

print(pares_cuadrados)
# Salida: {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

4️⃣Generator Expression (Generadores)

Similar a las listas por comprensión, pero usa paréntesis () en vez de corchetes [] y
genera valores uno a uno en vez de almacenar todo en memoria.

gen = (x**2 for x in range(1, 6))

print(next(gen)) # Salida: 1
print(next(gen)) # Salida: 4

🟢 Ideal para trabajar con grandes volúmenes de datos sin consumir mucha memoria.

📌 Resumen

Tipo Símbolo Resultado

Lista [ ] [1, 4, 9, 16, 25]

Conjunto { } {1, 4, 9, 16, 25}

Diccionario {clave: valor} {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Generador ( ) (x**2 for x in range(1, 6))

Aquí tienes ejemplos prácticos de secuencias de comprensión en trading y análisis de

datos, aplicados a Binance y manipulación de DataFrames con Pandas.
📌 1️⃣ Uso en Trading (Binance API)

🔹 Filtrar precios recientes de BTC/USDT y extraer solo los que son mayores
a 50,000 USDT
from [Link] import Client

client = Client() # Sin API key para consulta pública

# Obtener datos de BTC/USDT en futuros

klines = client.futures_klines(symbol="BTCUSDT",
interval=Client.KLINE_INTERVAL_1MINUTE, limit=10)

# Extraer precios de cierre y filtrar los mayores a 50,000 USDT

precios_altos = [float(k[4]) for k in klines if float(k[4]) > 50000]
print(precios_altos)

✅ Usa List Comprehension para extraer y filtrar datos directamente.

📌 2️⃣ Uso en Análisis de Datos (Pandas)

🔹 Agregar una columna con la diferencia entre precio de apertura y cierre

en un DataFrame
import pandas as pd

# Datos ficticios de velas

data = {'open': [40000, 40500, 39800, 41000],
'close': [40500, 40300, 40000, 41500]}

df = [Link](data)

# Agregar una columna con la diferencia (Dict Comprehension)

df['diff'] = [abs(row['close'] - row['open']) for _, row in
[Link]()]

print(df)

✅ Evita usar for tradicionales y hace el código más eficiente.

📌 3️⃣ Uso con Generadores para Optimización

🔹 Calcular promedios móviles sin cargar toda la memoria

import numpy as np

precios = [40000, 40500, 39800, 41000, 41500]

# Generador que calcula la media móvil de 3 períodos
media_movil = ([Link](precios[i:i+3]) for i in range(len(precios)-2))

print(list(media_movil)) # Convertimos a lista para mostrar el resultado

✅ Usa () en vez de [] para calcular promedios sobre la marcha sin almacenar todo en
RAM.

📌 Resumen de Aplicaciones en Trading

Tipo de comprensión Aplicación en Trading

List Comprehension Filtrar velas con condiciones (e.g., precio alto)

Dict Comprehension Crear diccionarios con datos de volumen, precios, etc.

Set Comprehension Eliminar precios duplicados en listas grandes

Generadores Optimizar cálculos como media móvil sin usar memoria extra

Aquí tienes un ejemplo de Machine Learning donde usamos List Comprehension y Dict
Comprehension para procesar datos antes de entrenar un modelo.

🔹 Problema:

Queremos predecir si BTC subirá o bajará basado en características como volumen, RSI
y precio anterior.

1️⃣ Cargar Datos y Preprocesar con List Comprehension

Antes de entrenar el modelo, transformamos los datos eficientemente.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from [Link] import RandomForestClassifier
from [Link] import accuracy_score

# Simulación de datos de BTC

data = {
'precio_anterior': [40000, 40500, 39800, 41000, 41500, 42000],
'rsi': [45, 55, 38, 60, 70, 80],
'volumen': [1.2, 1.8, 1.5, 2.0, 2.5, 3.0],
'precio_actual': [40500, 40300, 40000, 41500, 42200, 41800]
}
df = [Link](data)

# 🔹 Definir la variable objetivo (1 = sube, 0 = baja)

df['sube'] = [1 if df['precio_actual'][i] > df['precio_anterior'][i] else
0 for i in range(len(df))]

# 🔹 Seleccionar características y variable objetivo

X = df[['precio_anterior', 'rsi', 'volumen']]
y = df['sube']

# Dividir en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)

✅ Uso de List Comprehension para generar la columna sube

2️⃣ Entrenar Modelo de Machine Learning

Entrenamos un modelo Random Forest para predecir si BTC subirá o bajará.

# Crear y entrenar el modelo

modelo = RandomForestClassifier(n_estimators=100, random_state=42)
[Link](X_train, y_train)

# Hacer predicciones
y_pred = [Link](X_test)

# Evaluar precisión
accuracy = accuracy_score(y_test, y_pred)
print(f'Precisión del modelo: {accuracy:.2f}')

3️⃣ Análisis de Importancia de Variables con Dict Comprehension

Para saber qué factores afectan más la predicción:

# Obtener importancia de características

importancia = {[Link][i]: modelo.feature_importances_[i] for i in
range(len([Link]))}

# Mostrar importancia de cada variable

print(importancia)

📌 Resumen
Uso Técnica de Comprensión

Crear columna sube List Comprehension

 Uso Técnica de Comprensión

Mapear importancia de variables Dict Comprehension

🚀 ¿Quieres agregar más indicadores técnicos como RSI, MACD o volumen Delta?
Aquí tienes un ejemplo mejorado donde agregamos RSI, MACD y Delta de volumen al
análisis para predecir si BTC subirá o bajará usando Machine Learning.

📌 Pasos del modelo:

1️⃣Obtener datos simulados de precio, volumen, RSI, MACD y Delta de volumen.

2️⃣Procesar datos con List Comprehension y Dict Comprehension.
3️⃣Entrenar un modelo Random Forest para predecir si BTC sube o baja.
4️⃣Evaluar el modelo y analizar qué indicadores son más importantes.

1️⃣Cargar datos y calcular indicadores

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from [Link] import RandomForestClassifier
from [Link] import accuracy_score

# 🔹 Simulación de datos de BTC con RSI, MACD y Delta de volumen

data = {
'precio_anterior': [40000, 40500, 39800, 41000, 41500, 42000, 41800,
42300, 42800, 42500],
'precio_actual': [40500, 40300, 40000, 41500, 42200, 41800, 42100,
43000, 42900, 42600],
'volumen': [1.2, 1.8, 1.5, 2.0, 2.5, 3.0, 2.8, 3.2, 3.5, 3.1]
}

df = [Link](data)

# 🔹 Calcular RSI (índice de fuerza relativa)

def calcular_rsi(precios, periodo=14):
delta = [Link](precios)
ganancia = [Link](delta > 0, delta, 0)
perdida = [Link](delta < 0, -delta, 0)

avg_ganancia = [Link](ganancia[-periodo:]) if len(ganancia) >=

periodo else [Link](ganancia)
avg_perdida = [Link](perdida[-periodo:]) if len(perdida) >= periodo
else [Link](perdida)

rs = avg_ganancia / avg_perdida if avg_perdida != 0 else 100

rsi = 100 - (100 / (1 + rs))
return rsi

df['rsi'] = [calcular_rsi(df['precio_anterior'][:i+1]) for i in

range(len(df))]

# 🔹 Calcular MACD (diferencia entre medias móviles de 12 y 26 períodos)

df['ema_12'] = df['precio_anterior'].ewm(span=12, adjust=False).mean()
df['ema_26'] = df['precio_anterior'].ewm(span=26, adjust=False).mean()
df['macd'] = df['ema_12'] - df['ema_26']

# 🔹 Calcular Delta de Volumen (diferencia entre volumen actual y

anterior)
df['delta_volumen'] = [df['volumen'][i] - df['volumen'][i-1] if i > 0
else 0 for i in range(len(df))]

# 🔹 Variable objetivo: 1 si sube, 0 si baja

df['sube'] = [1 if df['precio_actual'][i] > df['precio_anterior'][i] else
0 for i in range(len(df))]

# 🔹 Seleccionar características
X = df[['precio_anterior', 'rsi', 'macd', 'delta_volumen']]
y = df['sube']

# Dividir en datos de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)

✅ Aquí usamos List Comprehension para RSI, Delta de Volumen y la columna

"sube".

2️⃣Entrenar el modelo
# 🔹 Entrenar un modelo Random Forest
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
[Link](X_train, y_train)

# 🔹 Hacer predicciones
y_pred = [Link](X_test)

# 🔹 Evaluar precisión
accuracy = accuracy_score(y_test, y_pred)
print(f'Precisión del modelo: {accuracy:.2f}')

✅ El modelo usa RSI, MACD y Delta de Volumen para predecir si BTC subirá o
bajará.

3️⃣Análisis de Importancia de Indicadores

# 🔹 Importancia de cada indicador
importancia = {[Link][i]: modelo.feature_importances_[i] for i in
range(len([Link]))}

# 🔹 Mostrar importancia de cada variable

print("Importancia de cada indicador:", importancia)
✅ Aquí usamos Dict Comprehension para mapear importancia de cada indicador.

📌 Resumen Final
Indicador Cálculo

RSI Evalúa si el precio está sobrecomprado o sobrevendido

MACD Mide la tendencia del mercado con medias móviles

Delta de Volumen Detecta cambios en la presión de compra o venta

que otro modelo??

ChatGPT dijo:

Hay varios modelos que podrías probar para predecir si BTC subirá o bajará,
dependiendo de la complejidad que quieras agregar. Aquí te dejo tres opciones
interesantes:

📌 1️⃣ Regresión Logística (Simple y Rápida)

✅ Ventaja: Rápido, fácil de interpretar.

❌ Desventaja: No capta relaciones no lineales en los datos.

from sklearn.linear_model import LogisticRegression

# Entrenar modelo de regresión logística

modelo_log = LogisticRegression()
modelo_log.fit(X_train, y_train)

# Predicciones y evaluación
y_pred_log = modelo_log.predict(X_test)
accuracy_log = accuracy_score(y_test, y_pred_log)

print(f'Precisión del modelo (Regresión Logística): {accuracy_log:.2f}')

📌 2️⃣ XGBoost (Optimizado para Datos Financieros)

✅ Ventaja: Captura patrones complejos, ideal para trading.

❌ Desventaja: Puede sobreajustar si no se ajustan bien los hiperparámetros.

import xgboost as xgb

# Crear el modelo XGBoost
modelo_xgb = [Link](n_estimators=100, learning_rate=0.1,
max_depth=5, random_state=42)
modelo_xgb.fit(X_train, y_train)

# Predicciones y evaluación
y_pred_xgb = modelo_xgb.predict(X_test)
accuracy_xgb = accuracy_score(y_test, y_pred_xgb)

print(f'Precisión del modelo (XGBoost): {accuracy_xgb:.2f}')

📌 3️⃣ Redes Neuronales (Para Detectar Patrones Complejos)

✅ Ventaja: Detecta patrones que otros modelos no pueden.

❌ Desventaja: Más lento y necesita más datos para entrenar bien.

import tensorflow as tf
from tensorflow import keras

# Crear modelo de red neuronal

modelo_nn = [Link]([
[Link](16, activation='relu',
input_shape=(X_train.shape[1],)),
[Link](8, activation='relu'),
[Link](1, activation='sigmoid') # Clasificación binaria
(sube o baja)
])

# Compilar y entrenar
modelo_nn.compile(optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])
modelo_nn.fit(X_train, y_train, epochs=50, batch_size=5, verbose=0)

# Evaluar
accuracy_nn = modelo_nn.evaluate(X_test, y_test, verbose=0)[1]
print(f'Precisión del modelo (Red Neuronal): {accuracy_nn:.2f}')

📌 ¿Cuál elegir?
Modelo Pros Contras

Regresión Logística Rápido y fácil de interpretar No capta relaciones complejas

Potente y optimizado para datos

XGBoost Puede sobreajustar
financieros

Red Neuronal Aprende patrones ocultos en los datos Necesita más datos y es más lento

🚀 ¿Cuál te interesa probar primero? O quieres combinarlos en un modelo híbrido?

4o
Dijiste:
redes neuronales

ChatGPT dijo:

¡Buena elección! 🚀 Las redes neuronales pueden detectar patrones complejos en el precio
de BTC y sus indicadores.

📌 Implementación de una Red Neuronal para Predecir si BTC Subirá

o Bajará

🎯 Pasos:
1️⃣Preprocesar datos de precio, RSI, MACD y Delta de Volumen.
2️⃣Crear una red neuronal con TensorFlow/Keras.
3️⃣Entrenar el modelo y evaluar su precisión.

1️⃣Importar Librerías y Datos

import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow import keras
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import accuracy_score

# 🔹 Datos simulados (puedes reemplazarlos con datos reales de Binance)

data = {
'precio_anterior': [40000, 40500, 39800, 41000, 41500, 42000, 41800,
42300, 42800, 42500],
'precio_actual': [40500, 40300, 40000, 41500, 42200, 41800, 42100,
43000, 42900, 42600],
'volumen': [1.2, 1.8, 1.5, 2.0, 2.5, 3.0, 2.8, 3.2, 3.5, 3.1]
}

df = [Link](data)

# 🔹 Calcular indicadores técnicos

df['rsi'] = [[Link](30, 70) for _ in range(len(df))] #
Simulación de RSI
df['macd'] = df['precio_anterior'].ewm(span=12).mean() -
df['precio_anterior'].ewm(span=26).mean()
df['delta_volumen'] = [df['volumen'][i] - df['volumen'][i-1] if i > 0
else 0 for i in range(len(df))]

# 🔹 Variable objetivo: 1 si sube, 0 si baja

df['sube'] = [1 if df['precio_actual'][i] > df['precio_anterior'][i] else
0 for i in range(len(df))]
# 🔹 Seleccionar características y normalizar datos
X = df[['precio_anterior', 'rsi', 'macd', 'delta_volumen']]
y = df['sube']

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Dividir en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y,
test_size=0.2, random_state=42)

✅ Aquí normalizamos los datos con StandardScaler() para mejorar el rendimiento de la

red neuronal.

2️⃣Crear y Entrenar la Red Neuronal

# 🔹 Crear la Red Neuronal
modelo = [Link]([
[Link](16, activation='relu',
input_shape=(X_train.shape[1],)),
[Link](8, activation='relu'),
[Link](1, activation='sigmoid') # Clasificación binaria
(sube o baja)
])

# 🔹 Compilar el modelo
[Link](optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])

# 🔹 Entrenar el modelo
[Link](X_train, y_train, epochs=50, batch_size=5, verbose=1)

✅ Explicación:

 3 capas: 16, 8 y 1 neurona final.

 Función de activación relu (mejor para redes profundas).
 Optimización con Adam (rápido y estable).
 epochs=50 (ajustable según la precisión deseada).

3️⃣Evaluar el Modelo
# 🔹 Hacer predicciones
y_pred_prob = [Link](X_test) # Probabilidades
y_pred = [1 if prob > 0.5 else 0 for prob in y_pred_prob] # Convertir a
0 o 1
# 🔹 Evaluar precisión
accuracy_nn = accuracy_score(y_test, y_pred)
print(f'Precisión del modelo (Red Neuronal): {accuracy_nn:.2f}')

✅ Salida esperada: Precisión entre 60%-80% dependiendo de los datos.

📌 Resumen Final

🔹 Indicadores Usados: RSI, MACD, Delta de Volumen, Precio

🔹 Optimización: Adam, relu, binary_crossentropy
🔹 Salida: 1 (BTC sube) o 0 (BTC baja)

🚀 ¿Próximos Pasos?

1️⃣Aumentar datos con velas de 1h o 5m de Binance.

2️⃣Agregar más indicadores como VPVR o EMA.
3️⃣Optimizar hiperparámetros (epochs, batch_size).
4️⃣Implementar en tiempo real con una API de Binance.

🔥 ¿Quieres probarlo con datos reales de Binance? 🚀

 Secuencias de comprension
 Listas, Sets & Diccionarios por comprensión
34:06
 Solo por curiosidad
00:05
 Ciclos for anidados en las secuencias por comprensión.
01:03

Funciones

 Funciones - Parte 1
37:05
 Funciones - Parte 2
27:09
 Palabra clave pass
00:31
 Determinación de Tipos
11:03
 Documentación oficial acerca de la determinación de
tipos
00:15
 Argumento Key de funciones predefinidas.
21:35
 Quiz argumento Key
1 preguntas
 Función Lambda (Función anónima) - Parte 1
17:12
 Función Lambda (Función anónima) - Parte 2
19:39
 Quiz de función Lambda
1 preguntas
 Argumento *args
19:38
 Argumento **kwargs
09:19
 Funciones lógicas predefinidas
 Funciones - Ejercicios
07:03
 Ejercicios - Solución Parte 1
22:38
 Ejercicios - Solución Parte 2
19:42

Programación Funcional

 Introducción
10:32
 Más acerca de la programación funcional
00:25
 Iteradores
25:57
 Espacio en memoria de los iteradores.
00:47

Programación Orientada a Objetos

 POO - Introducción
 Clases y Objetos
23:42
 Métodos especiales
18:45
 Recordatorio Métodos especiales
00:08
 Comunicando a objetos.
14:51
 Comunicando a objetos - Juego
24:10
 Herencia
10:52
 Decorador @property
04:14
 Decoradores @classmethod & staticmethod