English Русский Português
preview
Métodos de muestreo MCMC: Algoritmo de muestreo por cortes (Slice sampling)

Métodos de muestreo MCMC: Algoritmo de muestreo por cortes (Slice sampling)

MetaTrader 5 — Estadística y análisis |
28 0
Evgeniy Chernish
Evgeniy Chernish

Introducción

Los métodos de Monte Carlo basados en cadenas de Markov (MCMC) se utilizan ampliamente para realizar muestreos a partir de distribuciones multidimensionales complejas, especialmente en la estadística bayesiana. Los algoritmos clásicos, como el muestreo de Gibbs o el algoritmo de Metropolis, suelen requerir una configuración previa minuciosa. En el primer caso, es necesario obtener expresiones analíticas para todas las distribuciones condicionales completas, mientras que en el segundo hay que ajustar cuidadosamente la escala y la forma de la distribución de propuesta. Esto dificulta su uso rápido y eficaz en la práctica diaria.

En este artículo analizaremos el método de muestreo por cortes (slice sampling), una variante adaptativa de MCMC. Su principal ventaja radica en que se adapta automáticamente a las características de la distribución objetivo, lo que elimina la necesidad de ajustar manualmente parámetros como la anchura de paso.

Tras una descripción detallada del algoritmo y su implementación en el entorno MQL5, lo pondremos a prueba en modelos bayesianos de regresión lineal y logística, comparando los resultados con los métodos frecuentistas clásicos, que proporcionan estimaciones puntuales de los parámetros.


Métodos de muestreo por cortes

Una de las principales dificultades de los algoritmos MCMC, como el algoritmo de Metropolis, es la elección de una escala de paso adecuada. Un paso demasiado pequeño ralentiza el movimiento de la cadena, lo que aumenta la autocorrelación entre las muestras y requiere numerosas iteraciones para obtener muestras independientes. Un paso demasiado grande provoca el rechazo frecuente de los puntos propuestos, lo que reduce la eficacia del algoritmo.

Para resolver este problema, se propuso la técnica de muestreo por cortes (Neal, 2003), que solo requiere poder evaluar la densidad no normalizada f(x). Estos métodos pueden clasificarse en dos tipos, según el enfoque que se adopte respecto a las distribuciones multidimensionales:

  • muestreo unidimensional por cortes con actualización sucesiva de las coordenadas,
  • muestreo multidimensional por cortes, que implica la actualización directa y simultánea de todo el vector de variables.


Muestreo unidimensional por cortes

El muestreo unidimensional por cortes se utiliza bien para distribuciones objetivo unidimensionales, bien para la actualización sucesiva de las coordenadas de un vector multidimensional x = (x₁, …, xₙ), de forma similar al muestreo de Gibbs. Analicemos el funcionamiento de este algoritmo.

La actualización del punto actual x0 a un nuevo valor x1 consta de tres pasos principales:

  • (a) Definición del corte: elegimos una variable auxiliar y ∼ Uniform (0, f(x0)) y definimos el corte horizontal S = {x: f(x) > y} (es decir, el conjunto de puntos x para los que el valor de la densidad es mayor que el valor de la variable auxiliar y).
  • (b) Construcción del intervalo: se determina un intervalo (L, R) de anchura w, situado aleatoriamente en torno a x0. El intervalo se amplía en pasos de w (procedimiento de expansión) hasta que ambos extremos del intervalo queden fuera del corte.
  • (c) Selección de un nuevo punto: el nuevo punto x1 se obtiene mediante una selección aleatoria uniforme en el intervalo (L, R). Si el punto se encuentra fuera del corte, el intervalo se contrae (procedimiento de contracción) y la selección se repite hasta que el punto x1 quede dentro del corte.

En la práctica, resulta más cómodo trabajar con una escala logarítmica:

g(x) = log⁡ (f(x)), z = log(y) = g(x₀) − e,

donde e ∼ Exp (1) es una variable aleatoria con distribución exponencial cuya esperanza matemática es igual a la unidad. Entonces, el corte es S = {x: g(x) > z}.

Los procedimientos de expansión y contracción, propuestos por Radford Neal (Neal, 2003), reconocido especialista en el campo del aprendizaje automático y los métodos MCMC, garantizan un muestreo eficaz y correcto en el caso unidimensional. En la figura 1 se muestra una representación gráfica de este algoritmo.

Muestreo por cortes

Fig. 1. Actualización mediante muestreo por cortes en una dimensión usando los procedimientos de "expansión" (stepping-out) y "contracción" (shrinkage).

Más abajo, podemos ver una animación del funcionamiento del algoritmo en el caso unidimensional ejecutando el siguiente script, que muestra el proceso de muestreo a partir de una distribución multimodal (fig. 2).

//+------------------------------------------------------------------+
//|                                                       PlotMM.mq5 |
//|                                                           Eugene |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Eugene"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property script_show_inputs

#include <Math\Stat\Exponential.mqh>
#include <Math\Stat\Normal.mqh> 
#include <Math\Stat\Uniform.mqh> 
#include <Math\Stat\Math.mqh>
#include <Graphics\Graphic.mqh>

input int time_ = 700;     // Velocidad de la animación (cuanto menor, más rápida)

// Definición del tipo de función para logpdf
typedef double (*LogPdfFunction)(vector &x);

// Comprobación de si un punto se encuentra dentro del corte
bool inside(vector &x, double th, LogPdfFunction logpdf) {
   return logpdf(x) > th;
}

// densidad objetivo
double pdf(double x) {
   return MathExp(-x * x / 2.0) * (1.0 + MathPow(MathSin(3.0 * x), 2)) * (1.0 + MathPow(MathCos(5.0 * x), 2));
}

// log(pdf)
double logpdf(vector &x) {
   return MathLog(pdf(x[0]));
}

//+--------------------------------------------------------+
//| Slice sampling                                         |
//+--------------------------------------------------------+
void slicesample(vector &initial_, int nsamples_, vector &width_, int burnin_, int thin_, matrix &rnd, double &neval, LogPdfFunction logpdf) {
   // Comprobación de los parámetros de entrada
   if (burnin_ < 0 || thin_ <= 0) {
      Print("Error: burnin debe ser >= 0, thin > 0");
      return;
   }
  
   // Inicialización
   int dim = (int)initial_.Size();
   rnd.Resize(nsamples_, dim);
   rnd.Fill(0.0);
   int maxiter = 200;
   vector x0 = initial_;
   neval = nsamples_;

   // Generación de números aleatorios con distribuciones exponencial y uniforme
   double e[];
   MathRandomExponential(1.0, nsamples_ * thin_ + burnin_, e);
   matrix rw = matrix::Random(nsamples_ * thin_ + burnin_, dim, 0.0, 1.0);
   matrix rd = matrix::Random(nsamples_ * thin_ + burnin_, dim, 0.0, 1.0);

   //---------------------------
   ChartSetInteger(0, CHART_SHOW, false);
   CGraphic graphic;
   ulong w = ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
   ulong h = ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   graphic.Create(0, "SliceSampling", 0, 0, 0, (int)w, (int)h);
   graphic.BackgroundMain("Slice Sampling");
   graphic.BackgroundMainSize(20);
   graphic.XAxis().Name("x"); 
   graphic.XAxis().NameSize(20); 
   graphic.YAxis().Name("f(x)");
   graphic.YAxis().NameSize(20); 

   // === 1. Gráfico de la densidad objetivo ===
   int steps = 200;
   double x_density[], y_density[];
   MathSequenceByCount(-4,4,200,x_density);
   ArrayResize(y_density, steps);
   for (int i = 0; i < steps; i++) {
      y_density[i] = pdf(x_density[i]);  
   }

   CCurve *density = graphic.CurveAdd(x_density, y_density, clrRed, CURVE_LINES);
   density.LinesWidth(2);
   graphic.CurvePlotAll(); 
   graphic.Update();

   static string prev_slice_name = "";
   static string prev_interval_name = "";
   static string prev_point_name = "";

   // Ciclo principal
   for (int i = 1 - burnin_; i <= nsamples_ * thin_; i++) {   
      // === 2. Punto de partida x0  ===
      double px_axis[] = {x0[0]}, py_axis[] = {0.0};
      CCurve *point_x0_axis = graphic.CurveAdd(px_axis, py_axis, clrRed, CURVE_POINTS);
      point_x0_axis.PointsType(POINT_CIRCLE);
      point_x0_axis.PointsSize(10);
      graphic.CurvePlotAll(); 
      graphic.Update();
      Sleep(time_);

      // === 3. f(x0) ===
      double logf_x0 = logpdf(x0);
      double f_x0    = MathExp(logf_x0);

      double px[] = {x0[0]}, py[] = {f_x0};
      CCurve *point_x0 = graphic.CurveAdd(px, py, clrBlue, CURVE_POINTS);
      point_x0.PointsType(POINT_CIRCLE);
      point_x0.PointsSize(10);
      graphic.CurvePlotAll(); 
      graphic.Update();
      Sleep(time_);

      // === 4. Corte vertical ===
      double x_line[] = {x0[0], x0[0]}, y_line[] = {0.0, f_x0};
      CCurve *vert_line = graphic.CurveAdd(x_line, y_line, clrBlue, CURVE_LINES);
      vert_line.LinesStyle(STYLE_DOT);
      vert_line.LinesWidth(2);
      graphic.CurvePlotAll();
      graphic.Update();
      Sleep(time_);
   
      // === 5. Corte horizontal z = logf(x0) - e ===
      double z = logpdf(x0) - e[i + burnin_ - 1];
      double xz[] = {-4, 4}, yz[] = {MathExp(z), MathExp(z)};  
      string current_slice_name = "slice_" + (string)i;

      if (prev_slice_name != "") {
         graphic.CurveRemoveByName(prev_slice_name);
      }

      CCurve *slice_z = graphic.CurveAdd(xz, yz, clrBlack, CURVE_LINES, current_slice_name);
      slice_z.LinesWidth(2);
      graphic.CurvePlotAll();
      graphic.Update();
      Sleep(time_);

      // Guardamos el nombre de la curva actual
      prev_slice_name = current_slice_name;

      // === 6. Intervalo [xl, xr] ===
      vector r = width_ * rw.Row(i + burnin_ - 1);
      vector xl = x0 - r;
      vector xr = xl + width_;
      int iter = 0;

      double x_slice[] = {xl[0], xr[0]}, y_slice[] = {MathExp(z), MathExp(z)};
      string current_interval_name = "interval_" + (string)i;

      if (prev_interval_name != "") {
         graphic.CurveRemoveByName(prev_interval_name);
      }
      CCurve *horiz_slice = graphic.CurveAdd(x_slice, y_slice, clrOrange, CURVE_LINES,current_interval_name);
      horiz_slice.LinesWidth(4);
      graphic.CurvePlotAll(); 
      graphic.Update();
      Sleep(time_);  
      
      prev_interval_name = current_interval_name;

      //--- expansión 
      if (dim == 1) {
         while (inside(xl, z, logpdf) && iter < maxiter) {
            xl -= width_;
            iter++;
            double xs[] = {xl[0], xr[0]}, ys[] = {MathExp(z), MathExp(z)};
            horiz_slice.Update(xs, ys);
            graphic.CurvePlotAll();
            graphic.Update();
            Sleep(time_);
         }
         if (iter >= maxiter) {
            Print("Error: demasiadas iteraciones en stepping-out (left)");
            return;
         }
         neval += iter;

         iter = 0;
         while (inside(xr, z, logpdf) && iter < maxiter) {
            xr += width_;
            iter++;
            double xs[] = {xl[0], xr[0]}, ys[] = {MathExp(z), MathExp(z)};
            horiz_slice.Update(xs, ys);
            graphic.CurvePlotAll();
            graphic.Update();
            Sleep(time_);
         }
         if (iter >= maxiter) {
            Print("Error: demasiadas iteraciones en stepping-out (right)");
            return;
         }
         neval += iter;
      }   
      Sleep(time_); 

      // === 8. xp: punto dentro del corte ===
      vector xp = rd.Row(i + burnin_ - 1) * (xr - xl) + xl;
      double p_xp[] = {xp[0]}, p_yp[] = {MathExp(z)};
      string current_point_name = "point" + (string)i;

      if (prev_point_name != "") {
         graphic.CurveRemoveByName(prev_point_name);
      }
      CCurve *point_xp = graphic.CurveAdd(p_xp, p_yp, clrMagenta, CURVE_POINTS,current_point_name);
      point_xp.PointsType(POINT_SQUARE);
      point_xp.PointsSize(4);
      point_xp.PointsFill(true);
      graphic.CurvePlotAll();
      graphic.Update();
      Sleep(time_); 
      
      prev_point_name = current_point_name;

      // === 9. Shrinking ===
      iter = 0;
      while (!inside(xp, z, logpdf) && iter < maxiter) {
         for (int d = 0; d < dim; d++) {        
            if (xp[d] > x0[d]) xr[d] = xp[d];
            else xl[d] = xp[d];
            double xs[] = {xl[0], xr[0]}, ys[] = {MathExp(z), MathExp(z)};
            horiz_slice.Update(xs, ys);          
         }
         vector new_rand = vector::Random(dim, 0.0, 1.0);
         xp = new_rand * (xr - xl) + xl;
         double pxp[] = {xp[0]}, pyp[] = {MathExp(z)};
         point_xp.Update(pxp, pyp);
         graphic.CurvePlotAll(); 
         graphic.Update();
         Sleep(time_);
         iter++;
      }
      if (iter >= maxiter) {
         Print("Error: demasiadas iteraciones en shrinking");
         return;
      }
      neval += iter;
          
      x0 = xp;
      if (i > 0 && i % thin_ == 0) {
         rnd.Row(xp, i / thin_ - 1);
      }
   }

   neval /= (nsamples_ * thin_ + burnin_);

   Sleep(3000);
   graphic.Destroy();
   ChartSetInteger(0, CHART_SHOW, true);
   ChartRedraw(0);
}

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   vector start = {1.5};
   int n = 10;
   vector w = {1};
   int burn = 0;
   int thin = 1;
   matrix samples;
   double neval;

   slicesample(start, n, w, burn, thin, samples,neval, logpdf);  
  }
//+------------------------------------------------------------------+

Slice sampling multimodal

Fig. 2. Muestreo por cortes para una distribución unidimensional

En el gráfico se muestran el punto inicial x0 (marcado con un círculo azul claro) y el valor de la densidad en ese punto, f(x0) (círculo rojo). El corte vertical resultante se representa con una línea discontinua roja. De este corte se selecciona uniformemente un punto z que define el corte horizontal (la línea negra fina). El intervalo de anchura w, situado aleatoriamente alrededor de x0, se amplía en pasos de w hasta que sus extremos queden fuera del corte (el intervalo se representa con una línea gruesa de color azul claro). Luego se seleccionan sucesivamente puntos x1 de manera uniforme en este intervalo hasta encontrar uno dentro del corte. Los puntos seleccionados fuera del corte se usan para reducir el intervalo. En el gráfico se muestra precisamente un nuevo punto candidato, x1 (cuadrado rojo), que el algoritmo rechaza porque se encuentra fuera del corte.


Muestreo por cortes multidimensional

En lugar de actualizar sucesivamente cada coordenada del vector x = (x1,…, xn), se puede aplicar la idea del muestreo por cortes directamente a una distribución multidimensional. En este caso, el intervalo unidimensional (L, R) se sustituye por un hiperrectángulo H = {x: Li < xi < Ri, i = 1, …, n}, donde Li y Ri definen los límites a lo largo de cada eje.

El procedimiento para hallar el siguiente estado x1=(x1,1,…,x1,n) a partir del estado actual x0=(x0,1,…,x0,n) es análogo al del caso unidimensional:

  • (a) Elegir y de manera uniforme en el intervalo (0, f(x0)), definiendo el corte S = {x: y < f(x)}
  • (b) Hallar un hiperrectángulo H = (L1, R1) ×⋯× (Ln, Rn) que rodee a x0 y que, a ser posible, contenga la mayor parte del corte.
  • (c) Seleccionar un nuevo punto x1 de manera uniforme en la parte del corte situada dentro de H. Si el punto se encuentra fuera del corte, el hiperrectángulo se contrae (procedimiento de contracción, "shrinkage").

A diferencia del caso unidimensional, el procedimiento de expansión resulta muy complejo en un espacio multidimensional, ya que requiere comprobar 2^n vértices del hiperrectángulo, lo que supone un gran esfuerzo computacional cuando n es grande. Por eso, a menudo se usa un enfoque simplificado: el hiperrectángulo se coloca aleatoriamente alrededor de x0 sin llevar a cabo el procedimiento de expansión. La contracción del hiperrectángulo se realiza de forma independiente en cada eje hasta que se encuentre un punto dentro del corte. Este método es más sencillo de implementar, pero menos eficiente que el muestreo unidimensional. En la actualización secuencial, cada coordenada se contrae exactamente lo necesario, teniendo en cuenta las características locales de la densidad. En el caso multidimensional, todos los ejes se contraen simultáneamente, lo que puede dar lugar a una contracción excesiva en las direcciones en las que la densidad varía lentamente.

En el código que se muestra a continuación, el procedimiento de expansión se utiliza únicamente para el caso unidimensional. Para la distribución multidimensional se utiliza un enfoque simplificado sin expansión, basado en la colocación aleatoria del hiperrectángulo y su posterior contracción.

//+------------------------------------------------------------------+
//|                                                           SS.mqh |
//|                                                           Eugene |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Eugene"
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Math\Stat\Exponential.mqh>
#include <Math\Stat\Math.mqh>

// Definición del tipo de función para logpdf
typedef double (*LogPdfFunction)(vector &x);

// Comprobación de si un punto se encuentra dentro del corte
bool inside(vector &x, double th, LogPdfFunction logpdf) {
   return logpdf(x) > th;
}

//+--------------------------------------------------------+
//| Slice sampling                                         |
//+--------------------------------------------------------+
void slicesample(vector &initial_, int nsamples_, vector &width_, int burnin_, int thin_, matrix &rnd, double &neval, LogPdfFunction logpdf) {
   // Comprobación de los parámetros de entrada
   if (burnin_ < 0 || thin_ <= 0) {
      Print("Error: burnin debe ser >= 0, thin > 0");
      return;
   }

   // Inicialización
   int dim = (int)initial_.Size();
   rnd.Resize(nsamples_, dim);
   rnd.Fill(0.0);
   int maxiter = 200; // Número máximo de iteraciones para cada paso
   vector x0 = initial_;
   neval = nsamples_; 

   // Generación de números aleatorios exponenciales
   double e[];
   MathRandomExponential(1.0, nsamples_ * thin_ + burnin_, e);
   // variables aleatorias uniformes para aleatorizar la escala del paso w  
   matrix rw = matrix::Random(nsamples_ * thin_ + burnin_, dim, 0.0, 1.0);
   //variables aleatorias uniformes para seleccionar un punto dentro del intervalo 
   matrix rd = matrix::Random(nsamples_ * thin_ + burnin_, dim, 0.0, 1.0); 

   // Ciclo principal de muestreo por cortes
   for (int i = 1 - burnin_; i <= nsamples_ * thin_; i++) {
      double z = logpdf(x0) - e[i + burnin_ - 1]; // corte horizontal S = {x: log f(x) > z}
 
       // Intervalo inicial:
      vector r = width_ * rw.Row(i + burnin_ - 1); 
      vector xl = x0 - r;
      vector xr = xl + width_;
      int iter = 0;

//--- step out solo para la distribución unidimensional -----------
      if (dim == 1) {
         // step out to the left
         while (inside(xl, z, logpdf) && iter < maxiter) {
            xl -= width_;
            iter++;
         }
         if (iter >= maxiter) {
            Print("Error: demasiadas iteraciones en stepping-out");
            return;
         }
         neval += iter;

         iter = 0;
         // step out to the right
         while (inside(xr, z, logpdf) && iter < maxiter) {
            xr += width_;
            iter++;
         }
         if (iter >= maxiter) {
            Print("Error: demasiadas iteraciones en stepping-out");
            return;
         }
         neval += iter;
      }     
 //--- Shrinking ---
      vector xp = rd.Row(i + burnin_ - 1) * (xr - xl) + xl;
// Contraemos el intervalo (o hiperrectángulo) si se selecciona un punto fuera de la región de densidad
      iter = 0;
      while (!inside(xp, z, logpdf) && iter < maxiter) {
         for (int d = 0; d < dim; d++) {        
           if (xp[d] > x0[d]) xr[d] = xp[d]; // Si xp[d] > x0[d], contraemos el intervalo por el extremo derecho
           else xl[d] = xp[d]; // De lo contrario, si xp[d] <= x0[d], contraemos el intervalo por el extremo izquierdo
         }
         vector new_rand = vector::Random(dim, 0.0, 1.0);
         xp = new_rand * (xr - xl) + xl;
         iter++;
      }
      if (iter >= maxiter) {
         Print("Error: demasiadas iteraciones en shrinking");
         return;
      }
      neval += iter;

      x0 = xp; // Actualizamos el estado actual
      if (i > 0 && i % thin_ == 0) {
         rnd.Row(xp, i / thin_ - 1);
      }
   }
   neval /= (nsamples_ * thin_ + burnin_);
}


Ejemplo n.º 1. Entrenamiento de la regresión lineal bayesiana

En este ejemplo, analizaremos el uso del algoritmo de muestreo por cortes (slice sampling) para obtener una muestra de la distribución a posteriori de los parámetros en una regresión lineal bayesiana. Para aplicar el teorema de Bayes, definiremos un modelo de datos estableciendo la función de verosimilitud. Para no complicar demasiado el modelo, supongamos que los datos y siguen una distribución normal en torno a la combinación lineal de características Xw:

P(y ∣ w, σ²) = N(y | Xw, σ² * I)

donde:

  • I — matriz identidad,
  • σ² — varianza del ruido, que, por simplicidad, daremos por conocida.

En este modelo, los parámetros w son desconocidos. En el marco del enfoque bayesiano, todas las magnitudes desconocidas se consideran variables aleatorias. Por consiguiente, debemos establecer la distribución de estas variables aleatorias. Esta distribución se denomina "a priori", ya que la establecemos antes de que el modelo vea los datos. Para ello, se puede usar una distribución normal multivariante con media nula y matriz de covarianzas Σw.

P(w) = N (w | 0, Σw)

Una vez obtenidos los datos, actualizamos nuestras creencias a priori sobre los parámetros calculando la distribución a posteriori como el producto de la verosimilitud y la distribución a priori:

p(w | X, y) ∝ p(y | Xw, σ²) ⋅ p(w)

En el código, la función LogPosterior se encarga de calcular la distribución a posteriori, y se la pasamos a nuestro muestreador para que genere muestras.

Antes de comenzar el muestreo, crearemos datos sintéticos con parámetros conocidos w_true = [1.0, 2.0, 2.0], una desviación estándar del ruido σ = 0,5 y un tamaño de muestra igual a 100.

Luego configuraremos los siguientes parámetros para nuestro muestreador:

  • nsamples 10000 - número de muestras generadas,
  • burnin 1000 - periodo de calentamiento de la cadena,
  • thin 10 - intervalo de adelgazamiento,
  • width 0.5 - anchura inicial del hiperrectángulo

//+------------------------------------------------------------------+
//|                                                           LR.mq5 |
//|                                                           Eugene |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Eugene"
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Math\Stat\Exponential.mqh>
#include <Math\Stat\Normal.mqh>
#include <MCMC\SS.mqh>
#include <Math\Stat\Math.mqh>

// Estructura para el almacenamiento de datos 
struct BayesianLinearRegression
  {
   matrix            X;           // Matriz de características (n x (d+1))
   vector            y;           // Datos de salida (n)
   double            sigma;       // Desviación estándar del ruido
   vector            mu_w;        // Media a priori para w = [b, w_1, ..., w_d]
   matrix            Sigma_w;     // Matriz de covarianza a priori para w
   matrix            Sigma_w_inv; // Matriz de covarianza inversa 
   double            log_det_Sigma_w; // Logaritmo del determinante de Sigma_w 
  };

BayesianLinearRegression model;

//+------------------------------------------------------------------+
//| Logaritmo de la densidad de una distribución normal multivariante        |
//+------------------------------------------------------------------+
double multivariate_normal_logpdf(vector &x, vector &mu, matrix &Sigma_inv, double log_det, int dim)
  {
   vector diff = x - mu;
   double quad_form = diff @ Sigma_inv @ diff;
   return -0.5 * (quad_form + log_det + dim * MathLog(2 * M_PI));
  }

//+------------------------------------------------------------------+
//| Densidad objetivo: distribución a posteriori                  |
//+------------------------------------------------------------------+
double LogPosterior(vector &params, BayesianLinearRegression &mdl)
  {
   int d = (int)mdl.X.Cols(); // Número de columnas en X (d+1, incluida la columna de unos)
   int n = (int)mdl.X.Rows(); // Calcular el número de observaciones
   
  //---- Logaritmo de la verosimilitud (Gaussian likelihood) ------------------------------------
// 1.  vector de predicciones
   vector y_pred = mdl.X @ params;
// 2.  vector de errores
   vector residuals = mdl.y - y_pred;
// 3. cuadrado de la norma del vector de errores (e^T e)
   double sum_sq_errors = residuals @ residuals; 
// 4. logaritmo de la verosimilitud
   double log_likelihood_quad_term = -0.5 * sum_sq_errors / MathPow(mdl.sigma, 2);
   double log_likelihood_const_term = n * (-MathLog(mdl.sigma) - 0.5 * MathLog(2 * M_PI));
   double log_likelihood = log_likelihood_quad_term + log_likelihood_const_term;
//-----------------------------------------------------------------------------------------------
// Logaritmo de la distribución a priori (distribución normal multivariante a priori)
   double log_prior = multivariate_normal_logpdf(params, model.mu_w, model.Sigma_w_inv,
                      model.log_det_Sigma_w, d);

// distribución a posteriori = verosimilitud * distribución a priori
   return log_likelihood + log_prior;
  }

double LogPost(vector &params)
  {
   return LogPosterior(params, model);
  }

//+------------------------------------------------------------------+
//| Estimaciones de los parámetros mediante mínimos cuadrados ordinarios |
//+------------------------------------------------------------------+
void OLS(matrix &X, vector &y, vector &w_ols)
  {
// OLS: w_ols = (X^T X)^(-1) X^T y
   matrix XtX_inv = (X.Transpose() @ X).Inv();
   w_ols = XtX_inv @ X.Transpose() @ y;
  }

//+------------------------------------------------------------------+
//| Inicialización de la BLR y muestreo mediante SS                   |
//+------------------------------------------------------------------+
void BayesianLinearRegressionSample(matrix &X, vector &y,
                                    double sigma, vector &mu_w, matrix &Sigma_w,
                                    int nsamples, vector &initial, vector &width,
                                    int burnin, int thin, matrix &samples)
  {
   int d = (int)X.Cols(); 

// Calculamos previamente la matriz inversa y el logaritmo del determinante 
   matrix Sigma_w_inv = Sigma_w.Inv();
   double det = Sigma_w.Det();
   double log_det = MathLog(det);

// Inicialización del modelo
   model.X = X;
   model.y = y;
   model.sigma = sigma;
   model.mu_w = mu_w;
   model.Sigma_w = Sigma_w;
   model.Sigma_w_inv = Sigma_w_inv; 
   model.log_det_Sigma_w = log_det; 

   // Cálculo del número de evaluaciones de logpdf y del tiempo de ejecución
   double neval = 0;
   ulong start_time = GetMicrosecondCount(); 
   slicesample(initial, nsamples, width, burnin, thin, samples, neval, LogPost);
   ulong end_time = GetMicrosecondCount(); 
   double time_ms = (end_time - start_time) / 1000.0; // Tiempo en milisegundos
   Print("Average number of logpdf evaluations per sample: ", neval);
   Print("Slice sampling execution time: ", time_ms, " ms");
  }

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Generación de datos sintéticos
   int n = 100;  // Número de observaciones
   int d = 2;    // Número de características 
   matrix X = matrix::Random(n, d+1,0,10); // Matriz de características X
   X.Col(vector::Ones(n),0);  
   vector y(n);

   vector true_w(d + 1); // w = [b, w_1, w_2] Parámetros verdaderos
   true_w[0] = 1.0;      
   for(int i = 1; i < d + 1; i++)
     {
      true_w[i] = 2.0;   
     }

// Centrado de los predictores 
   for(int j = 1; j < d + 1; j++)
     {
      vector col = X.Col(j); 
      double mean = col.Mean(); 
      for(int i = 0; i < n; i++)
        {
         X[i,j] -= mean; 
        }
     }

// formación del vector y
   double sigma = 0.5; // Desviación estándar del ruido
   int err;
   for(int i = 0; i < n; i++)
     {
      double y_pred =  X.Row(i) @ true_w ;
      y[i] = y_pred + MathRandomNormal(0.0, sigma, err);
     }

//--- Parámetros a priori
   vector mu_w = vector::Zeros(d + 1); // Media a priori para w = [b, w_1, w_2]
   matrix Sigma_w = matrix::Identity(d + 1,d + 1);
   Sigma_w = 10*Sigma_w; // Matriz de covarianza diagonal (varianza = 10)
   
//--- Parámetros de muestreo
   int nsamples = 10000;
   int burnin = 1000;
   int thin = 10;
   vector initial(d + 1);
   initial.Fill(1.0); // Valores iniciales [b, w_1, w_2]
   vector width(d + 1);
   width.Fill(0.5);   // Anchura de paso para el muestreo por cortes

//--- Enfoque frecuentista: estimaciones de los parámetros mediante el método OLS
   Print("------------   Frequency approach -----------------");
   vector w_ols;
   OLS(X, y, w_ols);
   Print("OLS estimator w: ", w_ols, " (Expected values [1.0 , 2.0, 2.0])");

   vector lower_ci_freq, upper_ci_freq, se_ols;
   double sigma_hat;
   // Intervalos de confianza
   ConfidenceIntervals(X, y, w_ols, 0.05, lower_ci_freq, upper_ci_freq, se_ols, sigma_hat);
   Print("95% Confidence intervals:");
   for(int i = 0; i < (int)lower_ci_freq.Size(); i++)
     {
      Print("w_", i, ": [", lower_ci_freq[i], ", ", upper_ci_freq[i], "]");
     }
 
   Print("------------   Bayesian approach -----------------");
   matrix samples;
   BayesianLinearRegressionSample(X, y, sigma, mu_w, Sigma_w,
                                  nsamples, initial, width, burnin, thin, samples);
   vector mean_w(d + 1);
   for(int i = 0; i < d + 1; i++)
     {
      mean_w[i] = samples.Col(i).Mean();
     }
   Print("Average Posterior w: ", mean_w, " (Expected values [1.0 , 2.0, 2.0])");
                                  
   vector lower_ci_bayes, upper_ci_bayes;
   // Intervalos de confianza
   CredibleIntervals(samples, 0.05, lower_ci_bayes, upper_ci_bayes);
   Print("95% Credible intervals:");
   for(int i = 0; i < (int)lower_ci_bayes.Size(); i++)
     {
      Print("w_", i, ": [", lower_ci_bayes[i], ", ", upper_ci_bayes[i], "]");
     }

   MatrixToCSV("SS/LR_samples.csv", samples);
  }

//+------------------------------------------------------------------+
//|Intervalos de confianza, enfoque frecuentista                         |
//+------------------------------------------------------------------+
void ConfidenceIntervals(matrix &X, vector &y, vector &w_ols, double alpha, vector &lower, vector &upper, vector &se, double &sigma_hat)
  {
   int n = (int)X.Rows();
   int d = (int)X.Cols();

// 1. Cálculo de los residuos y de sigma^2
   vector y_pred = X @ w_ols;
   vector residuals = y - y_pred;
   double sigma2 = (residuals @ residuals) / (n - d); // Estimación de la varianza
   sigma_hat = MathSqrt(sigma2); // Estimación de la desviación estándar del ruido

// 2. Matriz de covarianza
   matrix XtX_inv = (X.Transpose() @ X).Inv();
   matrix cov_matrix = sigma2 * XtX_inv;

// 3. Errores estándar
   se = cov_matrix.Diag();
   se = MathSqrt(se);

// 4. Valor crítico de la distribución t
   double t_crit = 1.96; // Para un intervalo de confianza del 95 % 

// 5. Intervalos de confianza
   lower = w_ols - t_crit * se;
   upper = w_ols + t_crit * se;
  }

//+------------------------------------------------------------------+
//| Intervalos de confianza, enfoque bayesiano                      |
//+------------------------------------------------------------------+
void CredibleIntervals(matrix &samples, double alpha, vector &lower, vector &upper)
  {
   int d = (int)samples.Cols(); 
   lower.Resize(d);
   upper.Resize(d);

   for(int j = 0; j < d; j++)
     {      
      vector col = samples.Col(j);
      int n = (int)col.Size(); 

      double temp[];
      col.Swap(temp);

      // Array de probabilidades para los cuantiles
      double probs[] = {alpha / 2, 1 - alpha / 2}; // {0.025, 0.975} para el intervalo del 95 %
      double quantiles[];

      MathQuantile(temp, probs, quantiles);

      lower[j] = quantiles[0]; // Cuantil alpha/2
      upper[j] = quantiles[1]; // Cuantil 1-alpha/2
     }
  }

//+------------------------------------------------------------------+
//|  Guardar la matriz en formato CSV                                        |
//+------------------------------------------------------------------+
bool MatrixToCSV(string file_name, const matrix &m)
  {
   if(m.Rows() == 0 || m.Cols() == 0)
     {
      Print("Error: Matriz vacía");
      return false;
     }
   int file_handle = FileOpen(file_name, FILE_WRITE | FILE_TXT | FILE_ANSI);
   if(file_handle == INVALID_HANDLE)
     {
      Print("Error de apertura/creación del archivo: ", GetLastError());
      return false;
     }
   int rows = (int)m.Rows();
   int cols = (int)m.Cols();
   for(int i = 0; i < rows; i++)
     {
      string line = "";
      for(int j = 0; j < cols; j++)
        {
         line += DoubleToString(m[i][j], 10);
         if(j < cols - 1)
           {
            line += ",";
           }
        }
      FileWriteString(file_handle, line + "\n");
     }
   FileClose(file_handle);
   Print("Matriz guardada con éxito en el archivo: ", file_name);
   return true;
  }
//+------------------------------------------------------------------+

En el enfoque frecuentista, los parámetros se estiman mediante el método de los mínimos cuadrados ordinarios (Ordinary Least Squares), y los intervalos de confianza se calculan a partir de la distribución t.

En el enfoque bayesiano, las estimaciones puntuales se obtienen como la media de la distribución a posteriori (media de las muestras), mientras que la incertidumbre se refleja en los intervalos de confianza del 95 %, calculados mediante la función CredibleIntervals para los cuantiles 0,025 y 0,975.

Una vez finalizado el muestreo MCMC, compararemos las estimaciones de los enfoques frecuentista y bayesiano. Los resultados obtenidos demuestran que hemos realizado con éxito un muestreo a partir de la distribución a posteriori de los parámetros, y que las estimaciones obtenidas concuerdan estrechamente con las estimaciones frecuentistas, lo cual es de esperar cuando se utiliza una distribución a priori poco informativa (normalmente se trata de distribuciones con gran varianza, como en nuestro caso).

Los valores medios obtenidos mediante el muestreador son prácticamente idénticos a las estimaciones OLS. Esto demuestra que el algoritmo ha convergido y ha explorado correctamente la región de densidad de la distribución a posteriori. Aunque todas las estimaciones se desvían ligeramente de los valores verdaderos [1,0; 2,0; 2,0], esto es normal en una muestra tan pequeña, de tamaño N = 100, y teniendo en cuenta la presencia de ruido. Al ejecutar el script, las estimaciones variarán ligeramente debido a la generación de nuevos números aleatorios.

Parámetro Valor verdadero OLS SS
w_0 (sesgo, b) 1 0,91847 0,91852
w_1 2 1,97694 1,97688
w_2 2 2,02333 2,02320

Los intervalos de confianza bayesianos (Credible intervals) también son muy similares a los intervalos de confianza frecuentistas (Confidence intervals).

Parámetro Intervalos de confianza del 95 % (enfoque frecuentista) Intervalos de confianza del 95 % (enfoque bayesiano)
w_0 (sesgo, b) [0,8220; 1,0149] [0,8227; 1,0175]
w_1 [1,9415; 2,0123] [1,9409; 2,0128]
w_1 [1,9892; 2,0574] [1,9883; 2,0585]

La eficiencia del algoritmo "slicesample" se evalúa en función del número medio de llamadas a la función objetivo log⁡f(x). Con estos ajustes, el parámetro "neval" de la función "slicesample" fue de aproximadamente 5,365.

Para ajustar este indicador, es necesario modificar el valor del parámetro "width". Debemos tener en cuenta que, si el valor de "width" es demasiado pequeño, el algoritmo realizará un número excesivo de evaluaciones de la función para determinar el tamaño del corte. Si, por el contrario, la anchura es demasiado grande, el algoritmo se verá obligado a reducir con frecuencia el intervalo hasta un tamaño adecuado, lo que también provocará un número excesivo de evaluaciones de la función.

Además de evaluar neval, para realizar un análisis completo de la calidad del muestreo es necesario examinar el gráfico de traza de las muestras y la función de autocorrelación (ACF), así como elaborar histogramas para cada parámetro del modelo.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.graphics.tsaplots import plot_acf

# Ruta de acceso al archivo
slice_file = "C:/Program Files/MetaTrader 5/MQL5/Files/SS/LR_samples.csv"

# Carga de datos
slice_logpdf_data = pd.read_csv(slice_file, header=None)
samples = slice_logpdf_data.values  # Matriz de nsamples × 3
dim = samples.shape[1]  # Número de dimensiones (3: b, w₁, w₂)

# Valores esperados de los parámetros
expected_values = [1.0] + [2.0] * (dim - 1)  # [1,0; 2,0; 2,0]

# Estadísticas
def print_stats(samples, dim, expected_values):
    print("=========================================")
    print(f"MCMC Samples Analysis (Bayesian Linear Regression, {dim}D):")
    print(f"Number of samples: {samples.shape[0]}")
    for i in range(dim):
        param_name = "b" if i == 0 else f"w_{i}"
        print(f"Mean {param_name}: {np.mean(samples[:, i]):.4f} (expected {expected_values[i]:.4f})")
        print(f"Std. deviation {param_name}: {np.std(samples[:, i]):.4f}")
    # Covarianza entre b y w_1 (a modo de ejemplo)
    print(f"Covariance (b, w_1): {np.cov(samples[:, 0], samples[:, 1])[0, 1]:.4f}")
    print("=========================================")

print_stats(samples, dim, expected_values)

# Generación de gráficos de traza y de ACF
fig, axes = plt.subplots(dim, 2, figsize=(12, 4 * dim))
fig.suptitle('Trace Plots and ACF for Bayesian Linear Regression Parameters', fontsize=16)

for i in range(dim):
    param_name = "b" if i == 0 else f"w_{i}"
    # Gráfico de traza
    axes[i, 0].plot(samples[:, i])
    axes[i, 0].set_title(f'Trace Plot ({param_name})')
    axes[i, 0].set_xlabel('Iteration')
    axes[i, 0].set_ylabel(param_name)
    axes[i, 0].grid(True)
    # Añadimos una línea horizontal para el valor esperado
    axes[i, 0].axhline(y=expected_values[i], color='r', linestyle='--', label=f'Expected {expected_values[i]}')
    axes[i, 0].legend()

    # ACF Plot
    plot_acf(samples[:, i], lags=50, ax=axes[i, 1], title=f'ACF ({param_name})')
    axes[i, 1].set_xlabel('Lags')
    axes[i, 1].set_ylabel('Correlation')

plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

# Elaboración de histogramas de distribuciones a posteriori
fig, axes = plt.subplots(1, dim, figsize=(12, 3))
fig.suptitle('Posterior Distributions for Bayesian Linear Regression Parameters', fontsize=16)

for i in range(dim):
    param_name = "b" if i == 0 else f"w_{i}"
    axes[i].hist(samples[:, i], bins=30, density=True, alpha=0.7, color='skyblue')
    axes[i].set_title(f'Posterior ({param_name})')
    axes[i].set_xlabel(param_name)
    axes[i].set_ylabel('Density')
    # Añadimos una línea vertical para el valor esperado
    axes[i].axvline(x=expected_values[i], color='r', linestyle='--', label=f'Expected {expected_values[i]}')
    axes[i].legend()

plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()

En la figura 3 se muestra el gráfico de la densidad a posteriori del parámetro de sesgo w0.

Linear Posterior

Fig. 3. Densidad a posteriori del parámetro de sesgo del modelo de regresión lineal


Ejemplo n.º 2. Entrenamiento de la regresión logística bayesiana

En este ejemplo aplicamos el algoritmo de muestreo por cortes (slice sampling) para modelar resultados binarios y ∈ {0,1} en un problema de regresión logística bayesiana. Generaremos datos sintéticos con los parámetros verdaderos w_true = [0.0, 1.0, −1.0] y, a continuación, intentaremos recuperar esos valores verdaderos mediante métodos frecuentistas y bayesianos.

En primer lugar, definamos el modelo de datos, es decir, la verosimilitud. La verosimilitud adopta la forma de una distribución de Bernoulli, parametrizada por la función sigmoide del predictor lineal Xw:

Bernoulli loglikelihood

Como distribución a priori para los parámetros w, tomaremos una distribución normal multivariante:

P(w) = N (w | 0, 10 * I)

Al igual que en el ejemplo anterior, elegiremos una distribución a priori poco informativa con una varianza bastante grande. Recordemos que, en la estadística bayesiana, una distribución a priori se considera poco informativa si ejerce una influencia mínima en la distribución a posteriori, permitiendo que la verosimilitud desempeñe el papel principal en la formulación de conclusiones.

En cuanto al enfoque frecuentista clásico, en este caso las estimaciones puntuales pueden obtenerse mediante el algoritmo IRLS (mínimos cuadrados reponderados iterativamente). El IRLS es un método iterativo para la resolución numérica de problemas de optimización, muy adecuado para el modelo de regresión logística. Minimiza la función de pérdida logarítmica, lo que equivale a maximizar la verosimilitud. La actualización de los parámetros w se calcula mediante la fórmula:

w new IRLS

donde:

  • X - matriz de características (n×(d+1)), que incluye una columna de unos para el sesgo,
  • W - matriz diagonal de pesos de tamaño n×n, cuyos elementos diagonales son wii = pi (1 − pi), donde pi = σ(Xiw) son las probabilidades calculadas mediante la función sigmoide,
  • z = Xw + (y − p) / p*(1 − p) es la denominada variable de trabajo, donde y es el vector de respuestas binarias observadas y p es el vector de probabilidades predichas
  • X'WX - matriz de información de Fisher, utilizada para calcular la matriz de covarianza y los errores estándar de los parámetros.
Los intervalos de confianza se calculan a partir de la matriz de información de Fisher. Los compararemos con las estimaciones bayesianas que obtendremos mediante nuestro muestreador.
Parámetros del muestreador:
  • nsamples 10000 - número de muestras generadas,
  • burnin 1000 - periodo de calentamiento de la cadena,
  • thin 10 - intervalo de adelgazamiento,
  • width 1 - anchura inicial del hiperrectángulo.
//+------------------------------------------------------------------+
//|                                                    LogisticR.mq5 |
//|                                                           Eugene |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Eugene"
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Math\Stat\Math.mqh>
#include <Math\Stat\Normal.mqh>
#include <Math\Stat\Uniform.mqh>
#include <MCMC\SS.mqh>

// Estructura para el almacenamiento de datos 
struct BayesianLogisticRegression
  {
   matrix            X;           // Matriz de características (n x (d+1))
   vector            y;           // Respuestas binarias (n)
   vector            mu_w;        // Media a priori para w = [b, w_1, w_2]
   matrix            Sigma_w;     // Matriz de covarianza a priori para w
   matrix            Sigma_w_inv; // Matriz de covarianza inversa 
   double            log_det_Sigma_w; // Logaritmo del determinante de Sigma_w
  };

BayesianLogisticRegression model;

//+------------------------------------------------------------------+
//| Función sigmoide                                               |
//+------------------------------------------------------------------+
double sigmoid(double z)
  {
   return 1.0 / (1.0 + MathExp(-z));
  }

//+------------------------------------------------------------------+
//| Logaritmo de la densidad de una distribución normal multivariante        |
//+------------------------------------------------------------------+
double multivariate_normal_logpdf(vector &x, vector &mu, matrix &Sigma_inv, double log_det, int dim)
  {
   vector diff = x - mu;
   double quad_form = diff @ Sigma_inv @ diff;
   return -0.5 * (quad_form + log_det + dim * MathLog(2 * M_PI));
  }

//+------------------------------------------------------------------+
//| Densidad objetivo: distribución a posteriori                  |
//+------------------------------------------------------------------+
double LogPosterior(vector &params, BayesianLogisticRegression &mdl)
{
    int d = (int)model.X.Cols(); // Número de parámetros (incluido el sesgo)
   
    // --- 1. Logaritmo de la verosimilitud ---
    int n = (int)model.X.Rows();
    
    // Cálculo del predictor lineal: eta = X * w
    vector eta = model.X @ params; 
    
    // Cálculo del vector de probabilidades p = sigmoid(eta)
    vector p(n);
    eta.Activation(p, AF_SIGMOID);
   
    // Cálculo del vector log(p)
    vector log_p(n);
    log_p =  MathLog(p);
    
    // Cálculo del vector log(1-p)
    vector one_minus_p_log(n);
    one_minus_p_log = MathLog(1.0 - p);
    
    // Cálculo del logaritmo de la verosimilitud: L = sum( y * log(p) + (1-y) * log(1-p) )
    vector term_1 = mdl.y * log_p;
    vector term_2 = (1.0 - mdl.y) * one_minus_p_log;
    double log_likelihood = (term_1 + term_2).Sum(); 

    // --- 2. Logaritmo de la distribución a priori (distribución normal multivariante a priori) ---
    double log_prior = multivariate_normal_logpdf(params, mdl.mu_w, mdl.Sigma_w_inv,
                                                 mdl.log_det_Sigma_w, d);
    // Distribución posterior 
    return log_likelihood + log_prior;
}

// Envoltura para cumplir con la firma de LogPdfFunction
double LogPost(vector &params)
  {
   return LogPosterior(params, model);
  }
  
//+---------------------------------------------------------------------+
//|Cálculo de estimaciones mediante el método IRLS (Iteratively Reweighted Least Squares) |
//+---------------------------------------------------------------------+
void IRLS(matrix &X, vector &y, vector &w_irls, vector &se_irls)
{
    int n = (int)X.Rows(); // Número de observaciones
    int d = (int)X.Cols(); // Número de parámetros (incluido el sesgo)

    // --- Parámetros del algoritmo ---
    double convergence_threshold = 1e-6; // Umbral para comprobar la convergencia de los pesos 
    int max_iterations = 20;             // Número máximo de iteraciones
    int iterations_used = 0;             // Número de iteraciones realmente utilizadas

    w_irls.Resize(d);
    w_irls.Fill(0.0);      // Aproximación inicial de los pesos w 
    vector w_old = w_irls; // Vector para almacenar los pesos de la iteración anterior

    // Fórmula para actualizar los parámetros: w_new = (X^T W X)^(-1) X^T W z
    matrix W_final(n, n);
    W_final.Fill(0.0);

    for(int iter = 0; iter < max_iterations; iter++)
    {
        iterations_used = iter + 1;
        vector p(n);    // Vector de probabilidades p_i = sigmoid(eta_i)
        vector z(n);    // Vector de la variable de trabajo 
        matrix W_current(n, n); // Matriz diagonal de pesos W
        W_current.Fill(0.0);

        // 1. Cálculo del predictor lineal: eta = X * w
        vector eta = X @ w_irls;

        // 2. Cálculo de probabilidades: p = sigmoid(eta)
        eta.Activation(p, AF_SIGMOID);

        // 3. Cálculo del vector diagonal de pesos: w_diag = p * (1 - p)
        vector w_diag = p * (1.0 - p);

        // 4. Creación de la matriz diagonal de pesos W_current
        W_current.Diag(w_diag); 

        // 5. Cálculo de la variable de trabajo z
        vector diff = y - p;
        z = eta + diff / w_diag; 

        // Guardamos la matriz W actual para utilizarla en el cálculo de los errores estándar
        W_final = W_current; 

        // 6. Actualización de los pesos (IRLS step)
        matrix XtW = X.Transpose() @ W_current;

        // Cálculo de XtWX (matriz de información de Fisher)
        matrix XtWX = XtW @ X;

        // Solución para w: w = (XtWX)^-1 @ XtW @ z
        w_old = w_irls; // Guardamos w para comprobar la convergencia
        w_irls = XtWX.Inv() @ XtW @ z;

        // 7. Comprobación de la convergencia
        // Calculamos la norma L2 de la diferencia entre los pesos
        double diff_norm = (w_irls - w_old).Norm(VECTOR_NORM_P, 2);
        double w_norm = w_old.Norm(VECTOR_NORM_P, 2);
        
        double relative_change = (w_norm > 0.0) ? diff_norm / w_norm : diff_norm;

        if (relative_change < convergence_threshold)
        {
          Print("IRLS: Convergence achieved on iteration ", iterations_used, ". Relative change: ", DoubleToString(relative_change, 8));
          break;
        }
        
    }
    
    if (iterations_used < max_iterations)
    {
      Print("IRLS: Algorithm completed successfully (convergence). Iterations used: ", iterations_used, " out of ", max_iterations);
    }
    else
    {
      Print("IRLS: Algorithm terminated due to maximum iteration limit (", max_iterations, "). Convergence check: not achieved.");
    }

    // --- Cálculo de los errores estándar (SE) ---   
    // Cálculo de XtWX (matriz de información de Fisher) con los pesos finales W_final
    matrix XtWX_final = X.Transpose() @ W_final @ X; 

    // Matriz de covarianza Cov(w) = (X^T W_final X)^-1
    matrix cov_matrix = XtWX_final.Inv(); 

   // errores estándar 
    se_irls = cov_matrix.Diag();
    se_irls = MathSqrt(se_irls);
}

//+---------------------------------------------------------------------+
//| Inicialización de la regresión logística y muestreo con SS  |
//+---------------------------------------------------------------------+
void BayesianLogisticRegressionSample(matrix &X, vector &y,
                                      vector &mu_w, matrix &Sigma_w,
                                      int nsamples, vector &initial, vector &width,
                                      int burnin, int thin, matrix &samples)
  {
   int d = (int)X.Cols();

// Cálculo previo de la matriz inversa y del logaritmo del determinante
   matrix Sigma_w_inv = Sigma_w.Inv();
   double det = Sigma_w.Det();
   double log_det = MathLog(det);

// Inicialización del modelo
   model.X = X;
   model.y = y;
   model.mu_w = mu_w;
   model.Sigma_w = Sigma_w;
   model.Sigma_w_inv = Sigma_w_inv;
   model.log_det_Sigma_w = log_det;

   // Cálculo del número de evaluaciones de logpdf y del tiempo de ejecución
   double neval = 0;
   ulong start_time = GetMicrosecondCount(); 
   slicesample(initial, nsamples, width, burnin, thin, samples, neval, LogPost);
   ulong end_time = GetMicrosecondCount(); 
   double time_ms = (end_time - start_time) / 1000.0; // Tiempo en milisegundos
   Print("Average number of logpdf evaluations per sample: ", neval);
   Print("Slice sampling execution time: ", time_ms, " ms");
  }

//+------------------------------------------------------------------+
//| Intervalos de confianza, enfoque bayesiano                      |
//+------------------------------------------------------------------+
void CredibleIntervals(matrix &samples, double alpha, vector &lower, vector &upper)
  {
   int d = (int)samples.Cols();
   lower.Resize(d);
   upper.Resize(d);

   for(int j = 0; j < d; j++)
     {
      vector col = samples.Col(j);
      int n = (int)col.Size();
      double temp[];
      ArrayResize(temp, n);
      for(int i = 0; i < n; i++)
        {
         temp[i] = col[i];
        }
      double probs[] = {alpha / 2, 1 - alpha / 2};
      double quantiles[];
      
      MathQuantile(temp, probs, quantiles);

      lower[j] = quantiles[0];
      upper[j] = quantiles[1];
     }
  }
//+------------------------------------------------------------------+
//| Script program start function                                     |
//+------------------------------------------------------------------+
void OnStart()
  {
// Generación de datos sintéticos
   int n = 100;  // Número de observaciones
   int d = 2;    // Número de características (sin el parámetro de sesgo)
   matrix X(n, d + 1); // Matriz de características X con el parámetro de sesgo
   vector y(n);
   int err;
   vector true_w(d + 1); // w = [b, w_1, w_2]
   true_w[0] = 0.0;      // Sesgo verdadero
   true_w[1] = 1.0;      // Peso verdadero w_1
   true_w[2] = -1.0;     // Peso verdadero w_2

// Relleno de la matriz X y del vector y
   for(int i = 0; i < n; i++)
     {
      X[i][0] = 1.0; // Primera columna: unos
      for(int j = 1; j < d + 1; j++)
        {
         X[i][j] = MathRandomNormal(0.0, 1.0, err); // Características extraídas de N(0,1)
        }
      double z = true_w @ X.Row(i); 
      double p = sigmoid(z);        
      y[i] = MathRandomUniform(0.0, 1.0, err) < p ? 1.0 : 0.0; 
     }

   MatrixToCSV("SS/X_logistic.csv", X);
   matrix y_matrix(n, 1);
   for(int i = 0; i < n; i++)
     {
      y_matrix[i][0] = y[i];
     }
   MatrixToCSV("SS/y_logistic.csv", y_matrix);

// Parámetros de la distribución a priori
   vector mu_w(d + 1);
   mu_w.Fill(0.0); // Media a priori para w = [b, w_1, w_2]
   matrix Sigma_w(d + 1, d + 1);
   for(int i = 0; i < d + 1; i++)
     {
      Sigma_w[i][i] = 10.0; // Matriz de covarianza diagonal (varianza = 10)
     }

// Parámetros de muestreo
   int nsamples = 10000;
   int burnin = 1000;
   int thin = 10;
   vector initial(d + 1);
   initial.Fill(0.0); // Valores iniciales [b, w_1, w_2]
   vector width(d + 1);
   width.Fill(1);   // Ancho de paso para el muestreo por cortes
   matrix samples;

// Enfoque frecuentista: estimaciones de parámetros mediante IRLS
   Print("------------   Frequency approach -----------------");
   vector w_irls, se_irls;
   IRLS(X, y, w_irls, se_irls);
   Print("IRLS Estimator w: ", w_irls, " (Expected values [ 0.0, 1.0, -1.0 ])");

// Intervalos de confianza
   double z_crit = 1.96; // Para un intervalo de confianza del 95 %
   vector lower_ci_freq = w_irls - z_crit * se_irls;
   vector upper_ci_freq = w_irls + z_crit * se_irls;
   Print("95% Confidence intervals:");
   for(int i = 0; i < (int)lower_ci_freq.Size(); i++)
     {
      Print("w_", i, ": [", lower_ci_freq[i], ", ", upper_ci_freq[i], "]");
     }
     
   // Guardar w_irls en un archivo CSV
   matrix w_irls_matrix(1, d + 1);
   for(int i = 0; i < d + 1; i++)
      w_irls_matrix[0][i] = w_irls[i];

   MatrixToCSV("SS/w_irls_logistic.csv", w_irls_matrix);  

   Print("------------   Bayesian approach -----------------");
   BayesianLogisticRegressionSample(X, y, mu_w, Sigma_w, nsamples, initial, width, burnin, thin, samples);
  
   vector mean_w(d + 1);
   for(int i = 0; i < d + 1; i++)
     {
      mean_w[i] = samples.Col(i).Mean();
     }
   Print("Average w: ", mean_w, " (Expected values[ 0.0, 1.0, -1.0 ])");
   
// Intervalos de confianza
   vector lower_ci_bayes, upper_ci_bayes;
   CredibleIntervals(samples, 0.05, lower_ci_bayes, upper_ci_bayes);
   Print("95% Credible intervals:");
   for(int i = 0; i < (int)lower_ci_bayes.Size(); i++)
     {
      Print("w_", i, ": [", lower_ci_bayes[i], ", ", upper_ci_bayes[i], "]");
     }

   MatrixToCSV("SS/LR_samples_logistic.csv", samples);
  }
//+------------------------------------------------------------------+

Ambos enfoques ofrecen estimaciones cercanas a los valores verdaderos, aunque con algunas desviaciones debido al volumen limitado de datos. En la fig. 4 se muestra el gráfico de la densidad posterior del parámetro w1. El valor verdadero del parámetro (w1 = 1) se encuentra dentro del intervalo de confianza del 95 %.

Distribución posterior logística

Fig. 4. Distribución posterior del parámetro w1 en la regresión logística bayesiana

Para confirmar visualmente la corrección de los resultados, trazaremos la frontera de decisión, que en la regresión logística viene definida por la ecuación x^Tw = 0. Para dos características (x₁, x₂) y un sesgo, la frontera de decisión es una recta.

Trazaremos tres fronteras de decisión:

  • La frontera de decisión verdadera, basada en los valores verdaderos de los parámetros w_true = [0.0,1.0,−1.0].
  • La frontera de decisión de IRLS, basada en estimaciones puntuales.
  • La frontera de decisión bayesiana, basada en los valores medios de la distribución posterior.

Logistic decision boundaries

Fig. 5. Las fronteras de decisión bayesiana y de IRLS (coinciden)

Las fronteras de decisión de IRLS y del enfoque bayesiano prácticamente coinciden, pero se desvían de la frontera de decisión verdadera debido al volumen limitado de datos (n = 100) y a la naturaleza estocástica de la generación de clases mediante la función sigmoide. Esto provoca un ligero sesgo en las estimaciones de los parámetros. No obstante, el algoritmo de muestreo por cortes resolvió con éxito la tarea, identificando correctamente los parámetros que permiten separar las clases.


Conclusión

En este artículo hemos analizado el método de muestreo por cortes (slice sampling), una variante adaptativa del MCMC que elimina la necesidad de ajustar minuciosamente los hiperparámetros, como, por ejemplo, la escala del paso en el algoritmo de Metropolis.

La eficacia del método se ha comprobado mediante modelos bayesianos de regresión lineal y logística. Las estimaciones bayesianas (medias de la distribución posterior e intervalos de confianza) han resultado próximas a los resultados de los métodos frecuentistas clásicos: mínimos cuadrados ordinarios (OLS) y mínimos cuadrados reponderados iterativamente (IRLS). Los gráficos de traza de las muestras, las funciones de autocorrelación (ACF) y los histogramas de la densidad posterior confirman la calidad del muestreo.

De este modo, la implementación del muestreador slicesample en MQL5 ha demostrado ser una "caja negra" versátil y fiable. Gracias a este método, la inferencia bayesiana se ha vuelto mucho más sencilla y accesible. En realidad, lo único que se le pide al usuario es que sepa codificar la densidad posterior objetivo. Esto permite centrarse directamente en la tarea de inferencia estadística, minimizando el esfuerzo dedicado a la configuración del algoritmo MCMC.

Programas utilizados en el artículo:

# Nombre Tipo Descripción
1 SS.mqh Archivo de inclusión Algoritmo de muestreo por cortes
2 LR.mq5 Script Ejemplo de muestreo de la distribución posterior para un modelo de regresión lineal bayesiana
3 LR_plot.py Script Diagnóstico en Python
4 LogisticR.mq5 Script Ejemplo de muestreo de la distribución posterior para un modelo de regresión logística bayesiana
5 LogisticR_plot.py Script Diagnóstico en Python
6 PlotMM.mq5 Script Animación del funcionamiento del algoritmo para una distribución multimodal unidimensional

Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/20163

Archivos adjuntos |
MQL5-2.zip (18.2 KB)
EA para la apertura de operaciones según el riesgo con interfaz de usuario integrada en el gráfico (Parte 1): Diseño de la interfaz de usuario EA para la apertura de operaciones según el riesgo con interfaz de usuario integrada en el gráfico (Parte 1): Diseño de la interfaz de usuario
En este artículo se explica cómo crear en MQL5 un panel de control claro y profesional integrado en el gráfico para un asesor experto de apertura de operaciones según el riesgo. Esta guía paso a paso explica cómo diseñar una interfaz gráfica de usuario (GUI) funcional que permita a los traders introducir los parámetros de las operaciones, calcular el tamaño del lote y prepararse para la colocación automática de órdenes.
Sistema de autoaprendizaje por refuerzo para el trading algorítmico en MQL5 Sistema de autoaprendizaje por refuerzo para el trading algorítmico en MQL5
En este artículo se desarrolla un sistema de aprendizaje automático multiagente para el trading algorítmico en MetaTrader 5 basado en el aprendizaje por refuerzo. El sistema tiene una arquitectura de tres niveles: las neuronas de memoria almacenan la experiencia, los agentes toman decisiones de forma independiente y la inteligencia colectiva los integra mediante una votación ponderada. El sistema se perfecciona continuamente mediante el aprendizaje Q, la poda de neuronas ineficaces y la reducción evolutiva de la exploración.
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 45): Creación de un panel dinámico de análisis de niveles en MQL5 Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 45): Creación de un panel dinámico de análisis de niveles en MQL5
En este artículo, analizamos una potente herramienta de MQL5 que te permite probar cualquier nivel de precio que desees con un solo clic. Solo tienes que introducir el nivel que elijas y pulsar "Analizar": el EA examina al instante los datos históricos, resalta cada toque y cada ruptura en el gráfico y muestra las estadísticas en un panel de control claro y organizado. Verás exactamente con qué frecuencia el precio ha respetado tu nivel o lo ha roto, y si este se ha comportado más como soporte o como resistencia. Sigue leyendo para conocer el procedimiento detallado.
Códice de posicionamiento en los mercados en MQL5 (Parte 1): Aprendizaje bit a bit para Nvidia Códice de posicionamiento en los mercados en MQL5 (Parte 1): Aprendizaje bit a bit para Nvidia
Hoy comenzaremos una nueva serie de artículos basada en nuestros trabajos anteriores, expuestos en la serie "MQL5 Wizard", y llevaremos estos un paso más allá profundizando en nuestro enfoque del trading sistemático y la prueba de estrategias. En esta nueva serie, nos centraremos en los asesores expertos programados para mantener únicamente un tipo de posición: principalmente posiciones largas. Centrarse en una sola tendencia del mercado puede simplificar el análisis, reducir la complejidad de la estrategia y revelar algunas claves importantes, especialmente cuando se opera con activos distintos de las divisas. Por lo tanto, nuestra serie analizará si esto resulta eficaz en las acciones y otros activos distintos de las divisas, donde los sistemas que solo abren posiciones largas suelen mostrar una buena correlación con las estrategias del dinero inteligente o de los inversores institucionales.