Predecir los precios de las acciones mediante el aprendizaje por refuerzo

Contenu

Cet article a été publié dans le cadre de la Blogathon sur la science des données.

introduction

cours de l

Dans ce billet, intentaremos mitigar eso a través de el uso del apprentissage par renforcement.

Técnicas que podemos usar para predecir los precios de las acciones

Al tratarse de una predicción de valores continuos, se puede usar cualquier tipo de técnica de regresión:

  • La regresión lineal le ayudará a predecir valores continuos
  • Los modelos de series de tiempo son modelos que se pueden usar para datos relacionados con el tiempo.
  • ARIMA es uno de esos modelos que se utiliza para predecir predicciones futuristas asociadas con el tiempo.
  • LSTM es además una de esas técnicas que se ha utilizado para las predicciones del precio de las acciones. LSTM se refiere a la memoria a largo plazo y hace uso de redes neuronales para predecir valores continuos. Los LSTM son muy poderosos y son conocidos por retener la memoria a largo plazo.

Malgré cela, hay otra técnica que se puede usar para las predicciones del precio de las acciones y es el aprendizaje por refuerzo.

87552download201-6799798

Qu'est-ce que l'apprentissage par renforcement?

El aprendizaje por refuerzo es otro tipo de aprendizaje automático al mismo tiempo del enseignement supervisé y no supervisado. Se trata de un sistema de aprendizaje basado en agentes en el que el agente realiza acciones en un entorno en el que el objetivo es maximizar el registro. El aprendizaje por refuerzo no necesita el uso de datos etiquetados como el aprendizaje supervisado.

El aprendizaje por refuerzo funciona muy bien con menos datos históricos. Hace uso de la función de valor y la calcula en base a la política que se decida para esa acción.

El aprendizaje por refuerzo se modela como un procedimiento de decisión de Markov (MDP):

  • Un entorno E y estados de agente S

  • Un conjunto de acciones A tomadas por el agente.

  • P (s, s ‘) => P (st + 1 = s’ | st = s, at = a) es la probabilidad de transición de un estado sa s

  • R (s, s ‘): recompensa inmediata por cualquier acción

¿Cómo podemos predecir los precios del mercado de valores usando el aprendizaje por refuerzo?

El concepto de aprendizaje reforzado se puede aplicar a el pronóstico del precio de las acciones para una acción específica, puesto que utiliza los mismos principios fundamentales de requerir datos históricos menores, trabajando en un sistema basado en agentes para predecir rendimientos más altos en función del entorno actual. Veremos un ejemplo de predicción del precio de una acción para una determinada acción siguiendo el modelo de aprendizaje por refuerzo. Hace uso del concepto de aprendizaje Q explicado con más detalle.

Los pasos para diseñar un modelo de aprendizaje por refuerzo son:

  • Importation de bibliothèques
  • Crea el agente que tomará todas las decisiones.
  • Establecer funciones básicas para formatear los valores, función sigmoidea, leer el archivo de datos, etc.
  • Former l’agent
  • Examinar el desempeño del agente

Establecer el entorno de aprendizaje reforzado

MDP para el pronóstico del precio de las acciones:

  • Agent: un agente A que trabaja en el entorno E
  • action – Comprar / Comercializar / Mantener
  • Estados: valores de datos
  • Recompensas: Bénéfices / pertes
42998download-1678374

El papel de QLearning

Q-learning es un algoritmo de aprendizaje por refuerzo sin modelo para conocer la calidad de las acciones y decirle a un agente qué acción tomar en qué circunstancias. Q-learning encuentra una política óptima en el sentido de maximizar el valor esperado de la recompensa total en cualquier paso sucesivo, comenzando desde el estado actual.

Consecución de datos

  1. Ir a Yahoo Finance

  2. Escriba el nombre de la compañía, par exemple. Banco HDFC

  3. Seleccione el período de tiempo para, par exemple, 5 ans

  4. Haga clic en Descargar para descargar el archivo CSV

39120data-6637811

Implementemos nuestro modelo en Python

Importation de bibliothèques

Para construir el modelo de aprendizaje por refuerzo, importe las bibliotecas de Python indispensables para modelar las capas de la neuronal rouge y la biblioteca NumPy para algunas operaciones básicas.

import keras
from keras.models import Sequential
from keras.models import load_model
from keras.layers import Dense
from keras.optimizers import Adam
import math
import numpy as np
import random
from collections import deque

Creando el Agente

El código del agente comienza con algunas inicializaciones básicas para los distintos paramètres. Se definen algunas variables estáticas como gamma, epsilon, epsilon_min y epsilon_decay. Estos son valores de umbral constante que se usan para impulsar todo el procedimiento de compra y venta de acciones y mantener los parámetros con calma. Estos valores mínimos y de caída sirven como valores de umbral en la distribución normal.

El agente diseña el modelo de red neuronal en capas para realizar acciones de compra, venta o retención. Este tipo de acción se lleva a cabo al observar su predicción anterior y además el estado del entorno actual. El método act se utiliza para predecir la próxima acción que se tomará. Si la memoria se llena, existe otro método llamado expReplay diseñado para restablecer la memoria.

Agente de clase:

    def __init__(soi, state_size, is_eval=False, nom_modèle=""):
        self.state_size = state_size # normalized previous days
        self.action_size = 3 # sit, acheter, sell
        self.memory = deque(maxlen=1000)
        self.inventory = []
        self.model_name = model_name
        self.is_eval = is_eval
        self.gamma = 0.95
        self.epsilon = 1.0
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.model = load_model(nom du modèle) if is_eval else self._model()
    def _model(soi):
        modèle = Séquentiel()
        model.ajouter(Dense(units=64, input_dim=self.state_size, activation="reprendre"))
        model.ajouter(Dense(units=32, activation="reprendre"))
        model.ajouter(Dense(units=8, activation="reprendre"))
        model.ajouter(Dense(self.action_size, activation="linéaire"))
        modèle.compile(perte ="mse", optimiseur=Adam(lr=0.001))
        return model
    def act(soi, Etat):
        if not self.is_eval and random.random()<= self.epsilon:
            renvoyer random.randrange(self.action_size)
        options = self.model.predict(Etat)
        retour np.argmax(options[0])
    def expReplay(soi, taille du lot):
        mini_batch = []
        l = len(self.memory)
        pour moi à portée(je - taille du lot + 1, je):
            mini_batch.append(self.memory[je])
        for state, action, récompense, next_state, done in mini_batch:
            target = reward
            if not done:
                target = reward + self.gamma * np.amax(self.model.predict(next_state)[0])
            target_f = self.model.predict(Etat)
            target_f[0][action] = target
            self.model.fit(Etat, target_f, epochs=1, verbeux=0)
        si self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

Establecer funciones básicas

El formatprice () se escribe para estructurar el formato de la moneda. GetStockDataVec () traerá los datos de stock a Python. Defina la función sigmoidea como un cálculo matemático. GetState () está codificado de tal manera que proporciona el estado actual de los datos.

def formatPrice(m):
    revenir("-Rs." si n<0 autre "Rs.")+"{0:.2F}".format(abdos(m))
def getStockDataVec(clé):
    vec = []
    lines = open(key+".csv","r").lire().splitlines()
    pour ligne en lignes[1:]:
        #imprimer(ligne)
        #imprimer(flotter(line.split(",")[4]))
        vec.append(flotter(line.split(",")[4]))
        #imprimer(vec)
    return vec 
def sigmoid(X):
    revenir 1/(1+math.exp(-X))
def getState(Les données, t, m):
    d = t - m + 1
    block = data[ré:t + 1] si d >= 0 else -d * [Les données[0]] + Les données[0:t + 1] # pad with t0
    res = []
    pour moi à portée(m - 1):
        res.append(sigmoïde(bloquer[je + 1] - bloquer[je]))
    retourner np.array([res])

Entrenando al Agente

Dependiendo de la acción que predice el modelo, la llamada de compra / venta suma o resta dinero. Se entrena por medio de múltiples episodios que son los mismos que épocas en el l'apprentissage en profondeur. Ensuite, el modelo se guarda posteriormente.

import sys
stock_name = input("Enter stock_name, window_size, Episode_count")
window_size = input()
episode_count = input()
stock_name = str(stock_name)
window_size = int(window_size)
episode_count = int(episode_count)
agent = Agent(window_size)
data = getStockDataVec(stock_name)
l = len(Les données) - 1
taille_bat = 32
for e in range(episode_count + 1):
    imprimer("Episode " + str(e) + "/" + str(episode_count))
    state = getState(Les données, 0, window_size + 1)
    total_profit = 0
    agent.inventory = []
    pour t dans la gamme(je):
        action = agent.act(Etat)
        # sit
        next_state = getState(Les données, t + 1, window_size + 1)
        reward = 0
        si action == 1: # buy
            agent.inventory.append(Les données[t])
            imprimer("Buy: " + formatPrice(Les données[t]))
        elif action == 2 et len(agent.inventory) > 0: # sell
            bought_price = window_size_price = agent.inventory.pop(0)
            reward = max(Les données[t] - bought_price, 0)
            total_profit += data[t] - bought_price
            print("Sell: " + formatPrice(Les données[t]) + " | Profit: " + formatPrice(Les données[t] - bought_price))
        done = True if t == l - 1 else False
        agent.memory.append((Etat, action, récompense, next_state, done))
        state = next_state
        if done:
            imprimer("--------------------------------")
            imprimer("Bénéfice total: " + formatPrice(total_profit))
            imprimer("--------------------------------")
        si len(agent.memory) > taille du lot:
            agent.expReplay(taille du lot)
    if e % 10 == 0:
        agent.model.save(str(e))

Salida de entraînement al final del primer episodio:

Bénéfice total: Rs.340.03
770801_26xdrhi-alvdafcppjjgjq-5373529
La retroalimentación, En d'autres termes, la recompensa se le da al Agente para su posterior procesamiento.

Évaluation du modèle

Una vez que se haya entrenado el modelo en función de los nuevos datos, podrá probar el modelo para establecer las ganancias / pérdidas que ofrece. En conséquence, puede examinar la credibilidad del modelo.

stock_name = input("Enter Stock_name, Model_name")
model_name = input()
modèle = load_model(nom du modèle)
window_size = model.layers[0].input.shape.as_list()[1]
agent = Agent(window_size, Vrai, nom du modèle)
data = getStockDataVec(stock_name)
imprimer(Les données)
l = len(Les données) - 1
taille_bat = 32
state = getState(Les données, 0, window_size + 1)
imprimer(Etat)
total_profit = 0
agent.inventory = []
imprimer(je)
pour t dans la gamme(je):
    action = agent.act(Etat)
    imprimer(action)
    # sit
    next_state = getState(Les données, t + 1, window_size + 1)
    reward = 0
    si action == 1: # buy
        agent.inventory.append(Les données[t])
        imprimer("Buy: " + formatPrice(Les données[t]))
    elif action == 2 et len(agent.inventory) > 0: # sell
        bought_price = agent.inventory.pop(0)
        reward = max(Les données[t] - bought_price, 0)
        total_profit += data[t] - bought_price
        print("Sell: " + formatPrice(Les données[t]) + " | Profit: " + formatPrice(Les données[t] - bought_price))
    done = True if t == l - 1 else False
    agent.memory.append((Etat, action, récompense, next_state, done))
    state = next_state
    if done:
        imprimer("--------------------------------")
        imprimer(stock_name + " Bénéfice total: " + formatPrice(total_profit))
        imprimer("--------------------------------")
        imprimer ("Total profit is:",formatPrice(total_profit))

Remarques finales

El aprendizaje por refuerzo da resultados positivos para las predicciones de valores. A través de el uso de Q learning, se pueden realizar diferentes experimentos. Más investigación sobre el aprendizaje por refuerzo permitirá la aplicación del aprendizaje por refuerzo en una etapa más segura.

Puedes comunicarte con

Abonnez-vous à notre newsletter

Nous ne vous enverrons pas de courrier SPAM. Nous le détestons autant que vous.