Este post fue difundido como parte del Blogatón de ciencia de datos.
Introducción
En este post, intentaremos mitigar eso a través de el uso del aprendizaje por refuerzoEl aprendizaje por refuerzo es una técnica de inteligencia artificial que permite a un agente aprender a tomar decisiones mediante la interacción con un entorno. A través de la retroalimentación en forma de recompensas o castigos, el agente optimiza su comportamiento para maximizar las recompensas acumuladas. Este enfoque se utiliza en diversas aplicaciones, desde videojuegos hasta robótica y sistemas de recomendación, destacándose por su capacidad de aprender estrategias complejas.....
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.
A pesar de esto, hay otra técnica que se puede usar para las predicciones del precio de las acciones y es el aprendizaje por refuerzo.
¿Qué es el aprendizaje por refuerzo?
El aprendizaje por refuerzo es otro tipo de aprendizaje automático al mismo tiempo del aprendizaje supervisadoEl aprendizaje supervisado es un enfoque de machine learning donde un modelo se entrena utilizando un conjunto de datos etiquetados. Cada entrada en el conjunto de datos está asociada a una salida conocida, lo que permite al modelo aprender a predecir resultados para nuevas entradas. Este método es ampliamente utilizado en aplicaciones como la clasificación de imágenes, el reconocimiento de voz y la predicción de tendencias, destacando su importancia en... 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:
- Importación de bibliotecas
- 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.
- Entrena al agente
- Examinar el desempeño del agente
Establecer el entorno de aprendizaje reforzado
MDP para el pronóstico del precio de las acciones:
- Agente: un agente A que trabaja en el entorno E
- Acción – Comprar / Comercializar / Mantener
- Estados: valores de datos
- Recompensas: ganancias / pérdidas
El papel de Q – Learning
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
Ir a Yahoo Finance
Escriba el nombre de la compañía, a modo de ejemplo. Banco HDFC
Seleccione el período de tiempo para, a modo de ejemplo, 5 años
Haga clic en Descargar para descargar el archivo CSV
Implementemos nuestro modelo en Python
Importación de bibliotecas
Para construir el modelo de aprendizaje por refuerzo, importe las bibliotecas de Python indispensables para modelar las capas de la red neuronalLas redes neuronales son modelos computacionales inspirados en el funcionamiento del cerebro humano. Utilizan estructuras conocidas como neuronas artificiales para procesar y aprender de los datos. Estas redes son fundamentales en el campo de la inteligencia artificial, permitiendo avances significativos en tareas como el reconocimiento de imágenes, el procesamiento del lenguaje natural y la predicción de series temporales, entre otros. Su capacidad para aprender patrones complejos las hace herramientas poderosas... 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 parámetrosLos "parámetros" son variables o criterios que se utilizan para definir, medir o evaluar un fenómeno o sistema. En diversos campos como la estadística, la informática y la investigación científica, los parámetros son fundamentales para establecer normas y estándares que guían el análisis y la interpretación de datos. Su adecuada selección y manejo son cruciales para obtener resultados precisos y relevantes en cualquier estudio o proyecto..... 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__(self, state_size, is_eval=False, model_name=""):
self.state_size = state_size # normalized previous days
self.action_size = 3 # sit, buy, 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(model_name) if is_eval else self._model()
def _model(self):
model = Sequential()
model.add(Dense(units=64, input_dim=self.state_size, activation="relu"))
model.add(Dense(units=32, activation="relu"))
model.add(Dense(units=8, activation="relu"))
model.add(Dense(self.action_size, activation="linear"))
model.compile(loss="mse", optimizer=Adam(lr=0.001))
return model
def act(self, state):
if not self.is_eval and random.random()<= self.epsilon:
return random.randrange(self.action_size)
options = self.model.predict(state)
return np.argmax(options[0])
def expReplay(self, batch_size):
mini_batch = []
l = len(self.memory)
for i in range(l - batch_size + 1, l):
mini_batch.append(self.memory[i])
for state, action, reward, 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(state)
target_f[0][action] = target
self.model.fit(state, target_f, epochs=1, verbose=0)
if self.epsilon > self.epsilon_min:
self.epsilon *= self.epsilon_decayEstablecer 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(n):
return("-Rs." if n<0 else "Rs.")+"{0:.2f}".format(abs(n))
def getStockDataVec(key):
vec = []
lines = open(key+".csv","r").read().splitlines()
for line in lines[1:]:
#print(line)
#print(float(line.split(",")[4]))
vec.append(float(line.split(",")[4]))
#print(vec)
return vec
def sigmoid(x):
return 1/(1+math.exp(-x))
def getState(data, t, n):
d = t - n + 1
block = data[d:t + 1] if d >= 0 else -d * [data[0]] + data[0:t + 1] # pad with t0
res = []
for i in range(n - 1):
res.append(sigmoid(block[i + 1] - block[i]))
return 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 aprendizaje profundoEl aprendizaje profundo, una subdisciplina de la inteligencia artificial, se basa en redes neuronales artificiales para analizar y procesar grandes volúmenes de datos. Esta técnica permite a las máquinas aprender patrones y realizar tareas complejas, como el reconocimiento de voz y la visión por computadora. Su capacidad para mejorar continuamente a medida que se le proporcionan más datos la convierte en una herramienta clave en diversas industrias, desde la salud.... A continuación, 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(data) - 1
batch_size = 32
for e in range(episode_count + 1):
print("Episode " + str(e) + "/" + str(episode_count))
state = getState(data, 0, window_size + 1)
total_profit = 0
agent.inventory = []
for t in range(l):
action = agent.act(state)
# sit
next_state = getState(data, t + 1, window_size + 1)
reward = 0
if action == 1: # buy
agent.inventory.append(data[t])
print("Buy: " + formatPrice(data[t]))
elif action == 2 and len(agent.inventory) > 0: # sell
bought_price = window_size_price = agent.inventory.pop(0)
reward = max(data[t] - bought_price, 0)
total_profit += data[t] - bought_price
print("Sell: " + formatPrice(data[t]) + " | Profit: " + formatPrice(data[t] - bought_price))
done = True if t == l - 1 else False
agent.memory.append((state, action, reward, next_state, done))
state = next_state
if done:
print("--------------------------------")
print("Total Profit: " + formatPrice(total_profit))
print("--------------------------------")
if len(agent.memory) > batch_size:
agent.expReplay(batch_size)
if e % 10 == 0:
agent.model.save(str(e))Salida de entrenamientoEl entrenamiento es un proceso sistemático diseñado para mejorar habilidades, conocimientos o capacidades físicas. Se aplica en diversas áreas, como el deporte, la educación y el desarrollo profesional. Un programa de entrenamiento efectivo incluye la planificación de objetivos, la práctica regular y la evaluación del progreso. La adaptación a las necesidades individuales y la motivación son factores clave para lograr resultados exitosos y sostenibles en cualquier disciplina.... al final del primer episodio:
Total Profit: Rs.340.03
Evaluación del modelo
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 consecuencia, puede examinar la credibilidad del modelo.
stock_name = input("Enter Stock_name, Model_name")
model_name = input()
model = load_model(model_name)
window_size = model.layers[0].input.shape.as_list()[1]
agent = Agent(window_size, True, model_name)
data = getStockDataVec(stock_name)
print(data)
l = len(data) - 1
batch_size = 32
state = getState(data, 0, window_size + 1)
print(state)
total_profit = 0
agent.inventory = []
print(l)
for t in range(l):
action = agent.act(state)
print(action)
# sit
next_state = getState(data, t + 1, window_size + 1)
reward = 0
if action == 1: # buy
agent.inventory.append(data[t])
print("Buy: " + formatPrice(data[t]))
elif action == 2 and len(agent.inventory) > 0: # sell
bought_price = agent.inventory.pop(0)
reward = max(data[t] - bought_price, 0)
total_profit += data[t] - bought_price
print("Sell: " + formatPrice(data[t]) + " | Profit: " + formatPrice(data[t] - bought_price))
done = True if t == l - 1 else False
agent.memory.append((state, action, reward, next_state, done))
state = next_state
if done:
print("--------------------------------")
print(stock_name + " Total Profit: " + formatPrice(total_profit))
print("--------------------------------")
print ("Total profit is:",formatPrice(total_profit))Notas 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
