Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Crea un código python red neuronal profunda avanzada predecir valor acciones

  1. User

    Crea un código python red neuronal profunda avanzada predecir valor acciones

  2. Assistant

    ¡Claro! Puedo ayudarte a crear un código en Python que utilice una red neuronal profunda avanzada para predecir el valor de acciones. Utilizaremos bibliotecas como TensorFlow y Keras para construir y entrenar el modelo. A continuación, te proporcionaré un ejemplo completo.

    Nota importante: Predecir el valor de acciones es una tarea compleja y los resultados pueden no ser precisos debido a la naturaleza volátil y estocástica del mercado financiero. Este ejemplo es puramente educativo y no debe ser utilizado para tomar decisiones de inversión reales.


    Requisitos previos:

    • Python instalado (preferiblemente la versión 3.6 o superior).
    • Bibliotecas necesarias: pandas, numpy, matplotlib, scikit-learn, TensorFlow.

    Puedes instalar las bibliotecas ejecutando:

    pip install pandas numpy matplotlib scikit-learn tensorflow
    

    Paso 1: Importar las bibliotecas necesarias

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.preprocessing import MinMaxScaler
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, LSTM, Dropout
    

    Paso 2: Cargar y preparar los datos

    Asumimos que tienes un archivo CSV llamado accion.csv con datos históricos de precios, que incluye al menos una columna 'Close' con los precios de cierre.

    # Cargar los datos
    df = pd.read_csv('accion.csv')
    
    # Convertir la columna 'Date' a tipo datetime si existe
    if 'Date' in df.columns:
        df['Date'] = pd.to_datetime(df['Date'])
        df.sort_values('Date', inplace=True)
    
    # Seleccionar solo la columna 'Close'
    data = df.filter(['Close'])
    dataset = data.values
    
    # Determinar el número de datos para entrenar (por ejemplo, el 80% del conjunto)
    training_data_len = int(np.ceil(len(dataset) * 0.8))
    
    # Escalar los datos
    scaler = MinMaxScaler(feature_range=(0,1))
    scaled_data = scaler.fit_transform(dataset)
    

    Paso 3: Crear los conjuntos de entrenamiento

    # Crear el conjunto de entrenamiento
    train_data = scaled_data[0:int(training_data_len), :]
    
    # Dividir los datos en x_train y y_train
    x_train = []
    y_train = []
    
    # Usaremos 60 días para predecir el siguiente
    for i in range(60, len(train_data)):
        x_train.append(train_data[i-60:i, 0])
        y_train.append(train_data[i, 0])
    
    # Convertir a numpy arrays y reshape
    x_train, y_train = np.array(x_train), np.array(y_train)
    
    # Reshape para LSTM (samples, time_steps, features)
    x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
    

    Paso 4: Construir y entrenar el modelo

    # Construir el modelo LSTM
    model = Sequential()
    
    model.add(LSTM(units=50, return_sequences=True, input_shape=(x_train.shape[1], 1)))
    model.add(Dropout(0.2))
    
    model.add(LSTM(units=50, return_sequences=False))
    model.add(Dropout(0.2))
    
    model.add(Dense(units=25))
    model.add(Dense(units=1))
    
    # Compilar el modelo
    model.compile(optimizer='adam', loss='mean_squared_error')
    
    # Entrenar el modelo
    model.fit(x_train, y_train, batch_size=32, epochs=50)
    

    Paso 5: Crear el conjunto de prueba

    # Crear los conjuntos de prueba
    test_data = scaled_data[training_data_len - 60:, :]
    
    # Crear los datos x_test e y_test
    x_test = []
    y_test = dataset[training_data_len:, :]
    
    for i in range(60, len(test_data)):
        x_test.append(test_data[i-60:i, 0])
    
    # Convertir a numpy array
    x_test = np.array(x_test)
    
    # Reshape para LSTM
    x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 1))
    

    Paso 6: Hacer predicciones

    # Obtener las predicciones del modelo
    predictions = model.predict(x_test)
    predictions = scaler.inverse_transform(predictions)
    

    Paso 7: Evaluar el modelo

    # Calcular el error medio absoluto (Mean Absolute Error - MAE)
    from sklearn.metrics import mean_absolute_error
    mae = mean_absolute_error(y_test, predictions)
    print(f'Error medio absoluto: {mae}')
    

    Paso 8: Visualizar los resultados

    # Graficar los datos
    train = data[:training_data_len]
    valid = data[training_data_len:]
    valid['Predictions'] = predictions
    
    # Visualizar
    plt.figure(figsize=(16,8))
    plt.title('Modelo')
    plt.xlabel('Fecha', fontsize=18)
    plt.ylabel('Precio de cierre', fontsize=18)
    plt.plot(train['Close'])
    plt.plot(valid[['Close', 'Predictions']])
    plt.legend(['Entrenamiento', 'Valor real', 'Predicciones'], loc='lower right')
    plt.show()
    

    Explicación de los componentes clave:

    • Modelo LSTM: Utilizamos una red LSTM debido a su capacidad para capturar dependencias a largo plazo en datos secuenciales.
    • Dropout: Ayuda a prevenir el sobreajuste al desactivar aleatoriamente neuronas durante el entrenamiento.
    • Optimización: Usamos el optimizador 'adam', que es eficiente y requiere mínima afinación.
    • Función de pérdida: 'mean_squared_error' mide la diferencia cuadrática promedio entre los valores predichos y reales.
    • Visualización: Graficamos los precios reales y las predicciones para evaluar visualmente el rendimiento del modelo.

    Consideraciones adicionales:

    • Datos: La calidad y cantidad de datos son cruciales. Asegúrate de tener suficiente historial para entrenar el modelo.
    • Características adicionales: Puedes mejorar el modelo incorporando más características, como precios de apertura, máximo, mínimo, volumen, o incluso indicadores técnicos.
    • Hiperparámetros: Experimenta con diferentes valores para unidades LSTM, número de épocas, tamaño de batch, etc.
    • Validación cruzada: Implementa técnicas de validación para evaluar el modelo de manera más robusta.

    Advertencia Importante:

    • Riesgos financieros: Este código es un ejemplo educativo y no garantiza predicciones precisas. No debe utilizarse para decisiones de inversión reales.
    • Consulta a profesionales: Siempre busca asesoramiento financiero profesional antes de realizar inversiones.

    Espero que este código te sea de ayuda. Si tienes alguna pregunta o necesitas más detalles sobre algún paso, ¡no dudes en preguntar!