Métodos de muestreo MCMC: Algoritmo de muestreo por cortes (Slice sampling)
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.

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); } //+------------------------------------------------------------------+

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 ¶ms, 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 ¶ms) { 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 logf(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.

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:

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:
![]()
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.
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 ¶ms, 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 ¶ms) { 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 %.

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.

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
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.