Muy buenas, me llamo Miguel y hoy les traigo otro post.
Índice
Sugerencia: no utilice las funciones de pérdida tradicionales
Nota de los editores de Towards Data Science: Si bien permitimos que los autores independientes publiquen artículos de acuerdo con nuestras reglas y pautas, no respaldamos la contribución de cada autor. No debe confiar en las obras de un autor sin buscar asesoramiento profesional. Consulte nuestros Términos para lectores para obtener más detalles.
Cuando observo el ocasional «Predicción del precio de las acciones utilizando LSTM», la medida de precisión y rentabilidad es la pérdida, generalmente la función de error cuadrático medio. Todo esto está muy bien para los conjuntos de datos en los que la precisión del valor predicho es el objetivo final.
En el caso de la negociación de acciones, la rentabilidad es el objetivo final. Entonces, ¿cómo podemos cuantificar este valor?
Concepto
El valor óptimo para evaluar el modelo debe estar directamente relacionado con el objetivo final del programa, la rentabilidad. Entonces sabemos que el guión debería poder evaluar la rentabilidad estimada.
Además, para hacer el estimador de rentabilidad, el programa tiene que trabajar con datos que nunca antes había visto. Esto significa que tenemos que tomar una muestra de prueba de los datos para verificar cuánto dinero se ganaría.
Con los dos rasgos más importantes del programa de estimación de ganancias, comencemos a crear el programa.
El código
He preparado tres scripts diferentes para diferentes tipos de operaciones:
- Trading a tiempo fijo
- Negociación de acciones normal
- Comercio de opciones binarias
TimeTrading fijo:
def trading_simulator(trade_time,trade_value,close_price,sma_one,sma_two): intersections,insights = intersection(sma_1,sma_2) profit = 0 logs = [] for i in range(len(insights)): index = intersections[i] if insights[i] == buy: if index+trade_time < len(fx_data): if fx_data[index][-1] < fx_data[index+trade_time][-1]: profit += trade_value * 0.8 logs.append(trade_value*0.8) elif fx_data[index][-1] > fx_data[index+trade_time][-1]: profit -= trade_value logs.append(-trade_value) elif insights[i] == sell: if index+trade_time <= len(fx_data): if fx_data[index][-1] > fx_data[index+trade_time][-1]: profit += trade_value * 0.8 logs.append(trade_value*0.8) elif fx_data[index][-1] < fx_data[index+trade_time][-1]: profit -= trade_value logs.append(-trade_value) profit = profit return profit,logs
Este programa de negociación utiliza la intersección de dos valores de SMA para probar cuánto dinero se ganaría si se abriera una operación en función del conocimiento de la intersección de dos valores de SMA definidos, junto con la precisión: la cantidad de operaciones rentables de todas vientos alisios.
Este programa basa la estimación de beneficios en función de la negociación de tiempo fijo: una estrategia de negociación en la que predice en el próximo período de tiempo si el precio aumentará o disminuirá. Puede adaptar el programa o simplemente copiar el script completo desde aquí para probar la estimación de ganancias:
import requests import numpy as np from matplotlib import pyplot as plt import datetime API_KEY = 'YOURAPIKEYHERE' from_symbol = 'EUR' to_symbol = 'USD'def sell(): pyautogui.click(1350,320) def buy(): pyautogui.click(1350,250) def SMA(prices,value): means = [] count = 0 while value+count <= len(prices): pre_val = prices[count:value+count] count +=1 means.append(np.mean(pre_val)) return meansdef intersection(lst_1,lst_2): intersections = [] insights = [] if len(lst_1) > len(lst_2): settle = len(lst_2) else: settle = len(lst_1) for i in range(settle-1): if (lst_1[i+1] < lst_2[i+1]) != (lst_1[i] < lst_2[i]): if ((lst_1[i+1] < lst_2[i+1]),(lst_1[i] < lst_2[i])) == (True,False): insights.append(buy) else: insights.append(sell) intersections.append(i) return intersections,insightsdef trading_simulator(trade_time,trade_value,close_price,sma_one,sma_two): intersections,insights = intersection(sma_1,sma_2) profit = 0 logs = [] for i in range(len(insights)): index = intersections[i] if insights[i] == buy: if index+trade_time < len(fx_data): if fx_data[index][-1] < fx_data[index+trade_time][-1]: profit += trade_value * 0.8 logs.append(trade_value*0.8) elif fx_data[index][-1] > fx_data[index+trade_time][-1]: profit -= trade_value logs.append(-trade_value) elif insights[i] == sell: if index+trade_time <= len(fx_data): if fx_data[index][-1] > fx_data[index+trade_time][-1]: profit += trade_value * 0.8 logs.append(trade_value*0.8) elif fx_data[index][-1] < fx_data[index+trade_time][-1]: profit -= trade_value logs.append(-trade_value) profit = profit return profit,logsclose_price = [] r = requests.get( 'https://www.alphavantage.co/query?function=FX_INTRADAY&from_symbol=' + from_symbol + '&to_symbol=' + to_symbol + '&interval=1min&outputsize=full&apikey=' + API_KEY) jsondata = json.loads(r.content) pre_data = list(jsondata['Time Series FX (1min)'].values()) fx_data = [] for data in pre_data: fx_data.append(list(data.values())) fx_data.reverse() for term in fx_data: close_price.append(float(term[-1]))sma_1 = SMA(close_price,2) sma_2 = SMA(close_price,1) profit,logs = trading_simulator(1,10,close_price,sma_1,sma_2) profit
Para que el programa funcione, debe reemplazar el parámetro de clave API con su propia clave API de Alphavantage.
Comercio normal
La negociación normal es cuando se compran o venden varias acciones y la ganancia obtenida es la diferencia en el precio de las acciones.
def estimate_profits(standard_qty,model,data,close,open_,high,low): close_prices = close open_prices = open_ low_prices = low high_prices = high pred_close = list() pred_open = list() orders = list() profits = list() for i in range(len(data)): pred = model.predict(data[i])[0] open_price,close_price = pred if open_price > close_price: side = -1 elif open_price < close_price: side = 1 qty = standard_qty orders.append([side,qty]) pred_close.append(close_price) pred_open.append(open_price) for i in range(len(data)): sign = 0 mult = 0 side,qty = orders[i][0],orders[i][1] dif = close_prices[i] - open_prices[i] if dif > 0: sign = 1 else: sign = -1 if sign == side: mult = 1 else: mult = -1 profit = dif*mult*qty profits.append(profit) return profits
Este programa calcula la diferencia entre el activo entre el momento en que se ha realizado y el siguiente. Multiplica esta diferencia por la cantidad de acciones para calcular la ganancia. Puede adaptar los pasos de tiempo para probar estrategias comerciales de períodos más largos.
Comercio de opciones binarias:
def trading_simulator(open_prices):
profit = 0
insights = []
logs = []
for i in range(len(pred)):
if float(open_prices[i]) > pred[i][0]:
insights.append('sell')
elif float(open_prices[i]) < pred[i][0]:
insights.append('buy')
for i in range(len(insights)):
if insights[i] == 'sell':
if float(open_prices[i]) > y[i]:
profit += 8
logs.append(8)
else:
profit -= 10
logs.append(-10)
if insights[i] == 'buy':
if float(open_prices[i]) < y[i]:
profit += 8
logs.append(8)
else:
profit -= 10
logs.append(-10)
return profit,logs
Esta función calcula las ganancias, considerando una ganancia fija del 80% del monto de la operación. Calcula la diferencia entre el valor actual y el valor para el siguiente paso de tiempo.
Conclusión
Realmente espero que la gente pueda utilizar la rentabilidad del programa para evaluar su modelo a fin de obtener una visión real de si el algoritmo de negociación funciona.
Gracias por leer mi artículo.
Añadir comentario