Crea un código python red neuronal profunda avanzada predecir valor acciones
- User
Crea un código python red neuronal profunda avanzada predecir valor acciones
- 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, DropoutPaso 2: Cargar y preparar los datos
Asumimos que tienes un archivo CSV llamado
accion.csvcon 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!