Discusión sobre el artículo "Redes neuronales: así de sencillo (Parte 57): Stochastic Marginal Actor-Critic (SMAC)"

 

Artículo publicado Redes neuronales: así de sencillo (Parte 57): Stochastic Marginal Actor-Critic (SMAC):

Hoy le proponemos introducir un algoritmo bastante nuevo, el Stochastic Marginal Actor-Critic (SMAC), que permite la construcción de políticas de variable latente dentro de un marco de maximización de la entropía.

Al construir un sistema comercial automatizado, desarrollamos algoritmos para la toma de decisiones secuenciales. Los métodos de aprendizaje por refuerzo tienen por objeto resolver este tipo de problemas. Uno de los retos clave en el aprendizaje por refuerzo es el proceso de exploración, en el que el Agente aprende a interactuar con el entorno. En este contexto, el principio de máxima entropía se usa a menudo para motivar al Agente a realizar acciones con el mayor grado de aleatoriedad. Sin embargo, en la práctica, dichos algoritmos entrenan Agentes simples que solo aprenden cambios locales en torno a una única acción. Esto se debe a la necesidad de calcular la entropía de la política del Agente y usarla como parte del objetivo del entrenamiento.

Al mismo tiempo, un enfoque relativamente sencillo para aumentar la expresividad de la política del Agente sería utilizar variables latentes que proporcionen al Agente su propio procedimiento de inferencia para modelar la estocasticidad en las observaciones, el entorno y las recompensas desconocidas.


La introducción de variables latentes en la política del Agente permitirá abarcar una mayor variedad de escenarios compatibles con la historia de observaciones. Aquí cabe señalar que las políticas con variables latentes no admitirán una expresión sencilla para definir su entropía. Una estimación ingenua de la entropía puede provocar fallos catastróficos en la optimización de las políticas. Además, las actualizaciones estocásticas con alta varianza para maximizar la entropía no distinguen de inmediato entre efectos aleatorios locales y exploración multimodal.

Una de las soluciones a estas deficiencias de las políticas de variables latentes se ofreció en el artículo "Latent State Marginalization as a Low-cost Approach for Improving Exploration". En él, los autores proponen un algoritmo de optimización de políticas sencillo pero eficaz que puede posibilitar una exploración más eficiente y robusta tanto en entornos totalmente observados como parcialmente observados.

Autor: Dmitriy Gizlyk

 
No compilado.
Archivos adjuntos:
 
Tampoco estoy compilando. Es lo mismo.
 
star-ik #:
No compilado.

Se ha actualizado el archivo de ficheros del artículo.

 

Dmitry, gracias por tu duro trabajo. Todo está funcionando.

Recojo ejemplos por Expert Advisor Investigación para 100 pases, entrenar el modelo por Expert Advisor Estudio, prueba con Test. Luego recojo 50 pases de nuevo, entreno durante 10 000 iteraciones, pruebo de nuevo.

Y así sucesivamente hasta que el modelo aprenda. Excepto que tengo hasta ahora Prueba constantemente da resultados diferentes después del ciclo y no siempre positivo. He ejecutado un ciclo, 2-3 pruebas y los resultados son diferentes.

¿En qué ciclo se estabilizará el resultado? ¿O es un trabajo sin fin y el resultado siempre será diferente?

Gracias.

 
Nikolai Fedotov ejemplos con Expert Advisor Research durante 100 pasadas, entreno el modelo con Expert Advisor Study, pruebo con Test. Luego recojo 50 pases de nuevo, entrenar para 10 000 iteraciones, prueba de nuevo.

Y así sucesivamente hasta que el modelo aprenda. Salvo que hasta ahora Test da constantemente resultados diferentes después del ciclo y no siempre positivos. Es decir, ejecuto un ciclo, 2-3 pruebas y los resultados son diferentes.

¿En qué ciclo el resultado será estable? ¿O es un trabajo sin fin y el resultado siempre será diferente?

Gracias.

El Asesor Experto entrena un modelo con una política estocástica. Esto significa que el modelo aprende las probabilidades de maximizar las recompensas por realizar determinadas acciones en determinados estados del sistema. A medida que interactúa con el entorno, las acciones se muestrean con las probabilidades aprendidas. En la fase inicial, las probabilidades de todas las acciones son las mismas y el modelo selecciona una acción al azar. En el proceso de aprendizaje, las probabilidades cambiarán y la elección de las acciones será más consciente.

 

Hola Dmitry, ¿cuántos ciclos te tomó como Nikolay descrito anteriormente para obtener un resultado positivo estable?

Y otra cosa interesante es que si un Asesor Experto aprende para el periodo actual y si por ejemplo dentro de un mes habrá que volver a entrenarlo teniendo en cuenta los nuevos datos, ¿se volverá a entrenar completamente o antes de aprender? ¿El proceso de entrenamiento será comparable al inicial o mucho más corto y rápido? Y también si hemos entrenado un modelo sobre EURUSD, entonces para trabajar sobre GBPUSD ¿se reentrenará tanto como el inicial o será más rápido justo antes de entrenar? Esta pregunta no es acerca de este artículo en particular de los suyos, sino de todos sus asesores expertos que trabajan en el principio de aprendizaje por refuerzo.

 

Buenos días.

Dimitri, gracias por tu trabajo.

Quiero aclarar para todos...

Lo que Dimitri publica no es un "Grial".

Es un ejemplo clásico de problema académico, que implica la preparación para actividades de investigación científica de carácter teórico y metodológico.

Y todo el mundo quiere ver un resultado positivo en su cuenta, aquí y ahora....

Dmitry nos enseña a resolver (nuestro/mío/vuestro/su) problema con todos los métodos presentados por Dmitry.

¡¡¡¡Popular AI (GPT) tiene más de 700 millones de parámetros!!!! ¿Cuánto cuesta esta IA?

Si quieres conseguir un buen resultado, intercambia ideas (añade parámetros), da resultados de pruebas, etc.

Crea una sala de chat separada y "consigue" el resultado allí. Puedes presumir aquí :-), mostrando así la eficacia del trabajo de Dmitry...

 
Oleg_Filatov resultados de pruebas, etc.

Crea una sala de chat separada y "consigue" el resultado allí. Puedes presumir aquí :-), mostrando así la eficacia del trabajo de Dmitry...

Amigo, ¡aquí nadie está esperando el grial! Sólo me gustaría ver que lo que pone Dmitriy funciona de verdad. No por las palabras de Dmitry en sus artículos (todos sus artículos tienen resultados casi positivos), sino en mi ordenador. He descargado su Asesor Experto de este artículo y ya he hecho 63 ciclos de entrenamiento (recopilación de datos -> entrenamiento). Y todavía está perdiendo dinero. Para todos los 63 ciclos sólo había un par de colecciones de datos, cuando de 50 nuevos ejemplos había 5-6 positivos. Todo lo demás es negativo. ¿Cómo puedo ver que realmente funciona?

Le pregunté a Dmitriy en el post anterior, no respondió nada. El mismo problema en otros artículos - no hay resultado por mucho que entrenes.....

Amigo, si usted consiguió un resultado estable, a continuación, escriba cuántos ciclos que hizo antes de resultado estable, por ejemplo en este artículo? Si cambiar, ¿qué cambiar para ver el resultado en el equipo, sólo en el probador? No es un grial, pero al menos para ver que funciona?

 
Oleg_Filatov resultados de pruebas, etc.

Crea un CHAT aparte y "consigue" el resultado allí. Puedes presumir aquí :-), mostrando así la eficacia del trabajo de Dmitry ...

Disfrute <3

Aquí están los Params: (basado en Dmitry y algunas investigaciones.)
// Parámetros de entrada para RSI
grupo de entrada "---- RSI ----"
input int RSIPeriod = 14; // Periodo
input ENUM_APPLIED_PRICE RSIPrice = PRICE_CLOSE; // Precio aplicado

// Parámetros de entrada para CCI
grupo de entrada "---- CCI ----"
input int CCIPeriod = 14; // Periodo
input ENUM_APPLIED_PRICE CCIPrice = PRICE_TYPICAL; // Precio aplicado

// Parámetros de entrada para ATR
grupo de entrada "---- ATR ----"
input int ATRPeriod = 14; // Periodo

// Parámetros de entrada para MACD
grupo de entrada "---- MACD ----"
input int FastPeriod = 12; // Rápido
input int SlowPeriod = 26; // Lento
input int SignalPeriod = 9; // Señal
input ENUM_APPLIED_PRICE MACDPrice = PRICE_CLOSE; // Precio aplicado

// Parámetros de entrada para Momentum
grupo de entrada "---- Momentum ----"
input int MomentumPeriod = 14; // Periodo para Momentum
input ENUM_APPLIED_PRICE AppliedPrice = PRICE_CLOSE; // Precio aplicado para Momentum

// Parámetros de entrada para SAR
grupo de entrada "---- SAR ----"
input float SARStep = 0.02f; // Paso SAR
input float SARMaximum = 0.2f; // SAR Máximo

// Parámetros de entrada para Bandas
grupo de entrada "---- Bandas ----"
input int PeriodoBandas = 20; // Periodo de las Bandas
input int DesviaciónBandas = 2.0; // Desviación Bandas
input int BandsShift = 0; // Desplazamiento de las bandas

#include "FQF.mqh"
//---
#define HistoryBars 72 //Profundidad de la historia
#define BarDescr 14 //Elementos para la descripción de 1 barra
#define AccountDescr 12 //Descripción de la cuenta
#define NActions 6 //Número de Acciones posibles
#define NRewards 5 //Número de recompensas
#define EmbeddingSize 64
#define Buffer_Size 6500
#define FactorDisco 0.99f
#define FileName "zJimReaper_NNM_Neural_Network_"
#define LatentLayer 11
#define LatentCount 2048
#define SamplLatentStates 32
#define MaxSL 1000
#define MaxTP 1000
#define MaxReplayBuffer 500
#define StartTargetIteration 50000
#define fCAGrad_C 0.5f
#define iCAGrad_Iters 15
#define KNN 32
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CreateDescriptions(CArrayObj *actor, CArrayObj *critic, CArrayObj *convolution)
{
//---
CLayerDescription *descr;
//---
if(!actor)
{
actor = new CArrayObj();
if(!actor)
return false;
}
if(!critic)
{
critic = new CArrayObj();
if(!critic)
return false;
}
if(!convolution)
{
convolución = new CArrayObj();
if(!convolution)
return false;
}
//--- Actor
actor.Clear();
//--- Capa de entrada
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
int prev_count = descr.count = (HistoryBars * BarDescr);
descr.activation = None;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 1
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBatchNormOCL;
descr.count = prev_count;
descr.batch = 1000;
descr.activation = None;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 2
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = BarDescr;
descr.window = HistoriaBarras;
descr.step = HistoryBars;
int prev_wout = descr.window_out = HistoryBars / 2;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 3
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = prev_count - 1;
descr.window = 7;
descr.step = 3;
descr.window_out = 32;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 4
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = prev_count - 1;
descr.window = 5;
descr.step = 2;
descr.window_out = 16;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}

La longitud del mensaje no debe superar los 64000 caracteres

 


//--- capa 5
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = prev_count - 1;
descr.window = 3;
descr.step = 1;
descr.window_out = 8;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 6
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = BarDescr;
descr.window = HistoriaBarras;
descr.paso = HistoryBars;
prev_wout = descr.window_out = HistoryBars / 2;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 7
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
prev_count = descr.count = prev_count;
descr.window = prev_wout;
descr.paso = prev_wout;
descr.window_out = 32;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borra descr;
return false;
}
//--- capa 8
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 2 * LatentCount;
descr.optimización = ADAM;
descr.activation = LReLU;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 9
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
prev_count = descr.count = LatentCount;
descr.activación = LReLU;
descr.optimisation = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 10
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConcatenate;
descr.count = 4 * LatentCount;
descr.ventana = recuento_previo;
descr.paso = AccountDescr;
descr.optimización = ADAM;
descr.activation = SIGMOID;
if(!actor.Add(descr))
{
elimina descr;
return false;
}
//--- capa 11
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronVAEOCL;
descr.count = 2 * LatentCount;
descr.optimise = ADAM;
if(!actor.Add(descr))
{
elimina descr;
return false;
}
//--- capa 12
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 2 * LatentCount;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 13
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = LatentCount;
descr.activación = LReLU;
descr.optimisation = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 14
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = LatentCount;
descr.activación = LReLU;
descr.optimisation = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 15
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 2 * NActions;
descr.activación = SIGMOID;
descr.optimización = ADAM;
if(!actor.Add(descr))
{
borrar descr;
return false;
}
//--- capa 16
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronVAEOCL;
descr.count = NActions;
descr.optimise = ADAM;
if(!actor.Add(descr))
{
elimina descr;
return false;
}
//--- Critic
critic.Clear();
//--- Capa de entrada
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
prev_count = descr.count = 2 * LatentCount;
descr.activation = None;
descr.optimisation = ADAM;
if(!critic.Add(descr))
{
borrar descr;
return false;
}
//--- capa 1
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConcatenate;
descr.count = 2 * LatentCount;
descr.ventana = recuento_previo;
descr.paso = NActions;
descr.optimización = ADAM;
descr.activación = LReLU;
if(!critic.Add(descr))
{
borrar descr;
return false;
}
//--- capa 2
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 2 * LatentCount;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!critic.Add(descr))
{
borrar descr;
return false;
}
//--- capa 3
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = LatentCount;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!critic.Add(descr))
{
borrar descr;
return false;
}
//--- capa 4
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = LatentCount;
descr.activación = LReLU;
descr.optimización = ADAM;
if(!critic.Add(descr))
{
borrar descr;
return false;
}
//--- capa 5
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = NRewards;
descr.optimisation = ADAM;
descr.activation = None;
if(!critic.Add(descr))
{
eliminar descr;
return false;
}
//--- Convolución
// Definir parámetros comunes
int tamaño_entrada = (HistorialBarras * BarDescr) + CuentaDescr;
int num_actions = NActions;
int embedding_size = EmbeddingSize;
// Crear una red neuronal
convolution.Clear();
// Capa de entrada 0
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 4 * input_size;
descr.activation = None;
descr.optimisation = ADAM;
if (!convolution.Add(descr))
{
elimina descr;
return false;
}
// Capa 1
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = 2 * LatentCount;
descr.window = 2 * input_size;
descr.step = 2 * num_actions;
descr.activación = SIGMOID;
descr.optimización = ADAM;
if (!convolution.Add(descr))
{
elimina descr;
return false;
}
// Capa 2
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = LatentCount;
descr.window = tamaño_entrada;
descr.paso = num_acciones;
descr.activación = SIGMOID;
descr.optimización = ADAM;
if (!convolution.Add(descr))
{
elimina descr;
return false;
}
// Capas convolucionales
for (int i = 0; i < 6; i++)
{
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronConvOCL;
descr.count = 2 * LatentCount / (1 << i); // Reducir a la mitad el recuento con cada capa.
descr.window = 64;
descr.step = 64;
descr.window_out = 32 / (1 << i); // Reducir a la mitad la ventana_out
descr.activación = LReLU;
descr.optimización = ADAM;
if (!convolution.Add(descr))
{
borra descr;
return false;
}
}
// Capa de salida
if (!(descr = new CLayerDescription())) return false;
descr.type = defNeuronBaseOCL;
descr.count = tamaño_incrustación;
descr.activación = LReLU;
descr.optimisation = ADAM;
if (!convolution.Add(descr))
{
borrar descr;
return false;
}
// Red creada con éxito
return true;
}
#ifndef Estudio
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool IsNewBar(void)
{
===CORTÉ LAS ÚLTIMAS PARTES ya que los Comentarios están limitados a 64000 Caracteres pero ya sabes lo que hay que hacer... =)
La longitud del mensaje no debe superar los 64000 caracteres

-----------------------------------------------------+