En esta respuesta, he demostrado la aplicación de la técnica de regresión de aprendizaje automático para predecir el precio de uno de los metales preciosos más importantes, el oro.
He creado un modelo simple en Python que toma información de los precios anteriores del ETF de oro y devuelve una predicción del precio del ETF de oro al día siguiente.
Para explicar el modelo, seguiré los siguientes pasos:
- ¿Tener un conocimiento profundo del aprendizaje por refuerzo cambia su perspectiva hacia la vida? ¿Cómo?
- ¿Es legal el raspado web para hacer aprendizaje automático?
- ¿Cómo funciona Hidden Markov compatible con Vector Machine?
- ¿Cuál es la relación entre economía y ciencia de datos?
- ¿Una máquina aprende una ciencia o un arte?
- Importe las bibliotecas y lea los datos del ETF Gold
- Definir variables explicativas.
- Definir variable dependiente
- Dividir los datos en el tren y probar el conjunto de datos
- Crear un modelo de regresión lineal.
- Predecir los precios del oro ETF
Fuente: Predicción del precio del oro con el aprendizaje automático en Python
Importe las bibliotecas y lea los datos del ETF Gold
Lo primero es lo primero: importe todas las bibliotecas necesarias para implementar esta estrategia.
# LinearRegression es una biblioteca de aprendizaje automático para regresión lineal
de sklearn.linear_model import LinearRegression
# pandas y numpy se usan para la manipulación de datos
importar pandas como pd
importar numpy como np
# matplotlib y seaborn se usan para trazar gráficos
importar matplotlib.pyplot como plt
importar seaborn
# fix_yahoo_finance se usa para recuperar datos
importar fix_yahoo_finance como yf
Luego, leemos los últimos 10 años de datos diarios de precios de ETF de oro y los almacenamos en Df. Eliminamos las columnas que no son relevantes y eliminamos los valores de NaN usando la función dropna (). Luego, graficamos el precio de cierre del ETF de oro.
# Leer datos
Df = yf.download (‘GLD’, ‘2008-01-01’, ‘2017-12-31’)
# Solo mantenga columnas cercanas
Df = Df [[‘Cerrar’]]
# Soltar filas con valores faltantes
Df = Df.dropna ()
# Graficar el precio de cierre de GLD
Df.Close.plot (figsize = (10,5))
plt.ylabel (“Precios del ETF de oro”)
plt.show ()
Definir variables explicativas.
Una variable explicativa es una variable que se manipula para determinar el valor del precio del ETF de oro al día siguiente. Simplemente, son las características que queremos usar para predecir el precio del ETF de oro. Las variables explicativas en esta estrategia son los promedios móviles de los últimos 3 días y 9 días. Dejamos caer los valores NaN usando la función dropna () y almacenamos las variables de características en X.
Sin embargo, puede agregar más variables a X que considere útiles para predecir los precios del ETF de oro. Estas variables pueden ser indicadores técnicos, el precio de otro ETF como los mineros de oro ETF (GDX) o Oil ETF (USO), o datos económicos de EE. UU.
Df [‘S_3’] = Df [‘Cerrar’]. Shift (1) .rolling (window = 3) .mean ()
Df [‘S_9’] = Df [‘Cerrar’]. Shift (1) .rolling (ventana = 9) .mean ()
Df = Df.dropna ()
X = Df [[” S_3 ‘,’ S_9 ‘]]
X.head ()
Definir variable dependiente
Del mismo modo, la variable dependiente depende de los valores de las variables explicativas. En pocas palabras, estamos tratando de predecir el precio del ETF de oro. Almacenamos el precio del ETF de oro en y.
y = Df [‘Cerrar’]
y.head ()
Dividir los datos en el tren y probar el conjunto de datos
En este paso, dividimos los predictores y los datos de salida en trenes y datos de prueba. Los datos de entrenamiento se utilizan para crear el modelo de regresión lineal, combinando la entrada con la salida esperada. Los datos de la prueba se utilizan para estimar qué tan bien se ha entrenado el modelo.
- El primer 80% de los datos se usa para capacitación y los datos restantes para pruebas
- X_train y y_train son conjuntos de datos de entrenamiento
- X_test e y_test son conjuntos de datos de prueba
t = .8
t = int (t * len (Df))
# Conjunto de datos del tren
X_train = X [: t]
y_train = y [: t]
# Conjunto de datos de prueba
X_test = X [t:]
y_test = y [t:]
Crear un modelo de regresión lineal.
Ahora crearemos un modelo de regresión lineal. Pero, ¿qué es la regresión lineal?
Si tratamos de capturar una relación matemática entre las variables ‘x’ e ‘y’ que “mejor” explica los valores observados de ‘y’ en términos de valores observados de ‘x’ ajustando una línea a través de diagramas de dispersión, tal ecuación entre x e y se llama análisis de regresión lineal.
Para desglosarlo aún más, la regresión explica la variación en una variable dependiente en términos de variables independientes. La variable dependiente – ‘y’ es la variable que desea predecir. Las variables independientes: ‘x’ son las variables explicativas que utiliza para predecir la variable dependiente. La siguiente ecuación de regresión describe esa relación:
[matemáticas] Y = m1 * X1 + m2 * X2 + C [/ matemáticas]
[matemática] Precio del ETF de oro = m1 * promedio móvil de 3 días + m2 * promedio móvil de 15 días + c [/ matemático]
Luego usamos el método de ajuste para ajustar las variables independientes y dependientes (x’s e y’s) para generar coeficientes y constantes para la regresión.
linear = LinearRegression (). fit (X_train, y_train)
imprima “Precio ETF de oro =”, redondo (linear.coef_ [0], 2), \
“* Promedio móvil de 3 días”, redondo (linear.coef_ [1], 2), \
“* Promedio móvil de 9 días +”, redondo (linear.intercept_, 2)
Salida:
[matemática] Precio del ETF de oro = 1.2 * Promedio móvil de 3 días – 0.2 * Promedio móvil de 9 días + 0.39 [/ matemático]
Predecir los precios del oro ETF
Ahora, es hora de verificar si el modelo funciona en el conjunto de datos de prueba. Predecimos los precios del ETF de oro utilizando el modelo lineal creado utilizando el conjunto de datos del tren. El método de predicción encuentra el precio del ETF de oro (y) para la variable explicativa dada X.
predicted_price = linear.predict (X_test)
predicted_price =
pd.DataFrame (predicted_price, index = y_test.index, columnas = [‘precio’])
predicted_price.plot (figsize = (10,5))
y_test.plot ()
plt.legend ([‘predicted_price’, ‘actual_price’])
plt.ylabel (“Precio del ETF de oro”)
plt.show ()
El gráfico muestra el precio previsto y real del ETF de oro.
Ahora, calculemos la bondad del ajuste usando la función score ().
r2_score = linear.score (X [t:], y [t:]) * 100
flotante (“{0: .2f}”. formato (r2_score))
Salida:
95,81%
Como se puede ver, el R-cuadrado del modelo es 95.81%. R-cuadrado siempre está entre 0 y 100%. Una puntuación cercana al 100% indica que el modelo explica bien los precios del ETF de oro.
Fuentes:
- Aprendizaje automático para el comercio: introducción
- Predicción del precio del oro con el aprendizaje automático en Python
