METATRADER 5 — ASESORES EXPERTOS

USO PRÁCTICO DE LAS REDES

NEURONALES DE KOHONEN EN EL
TRADING ALGORÍTMICO (PARTE I)
INSTRUMENTAL
2 abril 2019, 08:15

STANISLAV KOROTKY
0
394
El tema de las redes neuronales de Kohonen ya fue abordado en algunos artículos del
sitio web mql5.com, a saber: Utilizar mapas con funciones de auto-organización (mapas
Kohonen) en MetaTrader 5 y Hablando de nuevo sobre los mapas de Kohonen. Los
lectores de estos artículos conocieron los principios generales de la construcción de redes
neuronales de este tipo y el análisis visual de los indicadores económicos usando los
mapas.
No obstante, en términos prácticos, la aplicación de la red de Kohonen precisamente
para el trading algorítmico fue limitado con un solo enfoque, es decir, con el análisis
visual de los mapas topológicos formados para los resultados de la optimización del
Asesor Experto (EA). En este caso, la opinión subjetiva -o más bien, la percepción- de una
persona y su capacidad de sacar conclusiones de la imagen resulta ser un factor
determinante, relegando a segundo plano las capacidades de la red de representar los
datos en relación con las categorías prácticas.

En otras palabras, las capacidades de los algoritmos de redes neuronales no fueron

utilizados al máximo, o sea, sin la extracción automática de conocimientos y soporte de
la toma de decisiones con recomendaciones específicas. En este artículo, vamos a
considerar el problema de la definición de los conjuntos óptimos de los parámetros de los
robots en una forma más formalizada. Además, aplicaremos la red de Kohonen para la
previsión de las series económicas. Pero antes de empezar con estas tareas aplicadas,
hace falta revisar los códigos fuente existentes, corregir algunos errores y hacer las
mejoras.

A los que no están familiarizados con los términos como «red», «capa», «neurona»
(nodo), «», «peso», «velocidad de aprendizaje», «rango de aprendizaje», y otras
nociones relacionadas con las redes de Kohonen, les recomiendo insistentemente leer
primero los artículos arriba mencionados. A continuación, tendremos que enfrascarnos en
este tema, así que, la repetición de las nociones básicas prolongaría significativamente
esta publicación.

Corrigiendo errores
Vamos a invocar las clases CSOM y CSOMNode publicadas en el primer artículo, tomando
en cuenta las adiciones en el segundo artículo. Los fragmentos principales en ellas son
prácticamente idénticas y heredan problemas comunes.
En primer lugar, hay que notar que, por algunas razones, las neuronas en estas clases se
indexan (se identifican y se definen a través de los parámetros de los constructores) por
coordenadas de píxel. Eso no es muy lógico y complica los cálculos y la depuración en
algunos puntos. En particular, con este enfoque, los ajustes de presentación afectan los
cálculos. Sólo imagínese: hay dos instancias de las redes absolutamente idénticas, con
tamaños iguales de la cuadrícula y aprenden usando el mismo conjunto de datos, tienen
las configuraciones iguales e inicialización del generador de números aleatorios. Sin
embargo, los resultados obtenidos son diferentes sólo porque las imágenes de una red son
más grandes que de la otra. Es un error.

Vamos a indexar las neuronas por números: cada neurona del array m_node (clase CSOM)
va a tener las coordenadas «x» y «y» que corresponden a los números de la columna y la
línea en la capa de salida de la red de Kohonen. Cada neurona va a inicializarse a través
del método CSOMNode::InitNode(x, y) en vez de CSOMNode::InitNode(x1, y1, x2, y2).
Cuando pasaremos a la visualización, las coordenadas de la neurona permanecerán
inalteradas al alterar los tamaños del mapa en píxeles.

En los códigos fuente heredados, la normalización de los datos de entrada no se usa. Sin
embargo, ella es muy importante cuando diferentes componentes (características) de los
vectores de entrada tienen un rango de valores diferente. Es así tanto para los resultados
de la optimización de los EAs, como durante el agrupamiento de los valores de diferentes
indicadores. En cuanto a los resultados de la optimización, podemos ver que los valores
con un beneficio neto de decenas de millares están juntos con los valores pequeños del
coeficiente de Sharp o con valores de un dígito del factor de recuperación.

No se puede enseñar a la red de Kohonen usando los datos de la escala tan diferente,
porque la red va a considerar prácticamente sólo los componentes grandes e ignorar los
pequeños. Usted puede ver eso en la imagen de abajo obtenida a través del programa
que será considerado paso a paso en este artículo y adjuntado al final. En el programa
existe la posibilidad de generar los vectores de entrada aleatorios en los cuales tres
componentes están determinados dentro de los rangos [0, 1000], [0, 1] y [-1, +1]. El
parámetro de entrada especial UseNormalization permite activar/desactivar la
normalización.

Vamos a ver la estructura de la red de Kohonen en tres planos correspondientes a tres

dimensiones de los vectores. Primero, veremos el resultado del aprendizaje de la red sin
normalización.

Resultado del aprendizaje de la red de Kohonen sin normalización de los datos de entrada

Ahora, veremos los mismo con normalización.

 Resultado del aprendizaje de la red de Kohonen con normalización de los datos de entrada

El grado de adaptación de los pesos de neuronas es proporcional al gradiente de color.

Obviamente, a falta de la normalización, la red aprende la división topológica
(clasificación) solamente en el primer plano, mientras que el segundo y el tercer
componente llevan un pequeño ruido. Es decir, las capacidades analíticas han sido
implementadas solamente a un tercio. En caso de la normalización activada, la
estructura espacial es visible en todos los tres planos.

Se conocen muchos métodos de la normalización, pero el más popular, tal vez, sea la
sustracción del valor medio de toda la muestra de cada componente, y la división por la
desviación estándar (sigma, raíz cuadrada de la dispersión). Eso lleve el valor medio de
datos transformados a cero, y la desviación estándar a uno.

(1)

Esta técnica se usa en la clase actualizada CSOM, en el método Normalize. Esta claro que
primero hace falta calcular la media y la sigma para cada componente del conjunto de
datos de entrada, lo que se hace en el método InitNormalization (véase más abajo).

Las fórmulas canónicas del cálculo de la media y de la desviación estándar suponen un

algoritmo de dos pasos: en primer lugar, se busca la media, y después, se calcula la
sigma usando la media.

(2)
 (3)

En nuestro código fuente, se usa el algoritmo de un paso basado en la siguiente fórmula:

(4)

Obviamente, la normalización en la entrada requiere una operación inversa

(denormalización) en la salida, es decir, al transformar los valores de salida de la red en
el rango de valores reales. De eso se encarga el método CSOM::Denormalize.

Puesto que los valores normalizados caen simétricamente alrededor de cero, vamos a
cambiar el principio de la inicialización de los pesos de neuronas antes del aprendizaje:
en vez del rango [0, 1], ahora será el rango [-1, +1] (véase el método
CSOMNode::InitNode). Eso aumentará la eficacia del aprendizaje de la red.

Otro aspecto a ser corregido es el cálculo de las iteraciones del aprendizaje. En las clases
fuente, la iteración se entiende como la presentación de cada vector de entrada
individual a la red. Por tanto, el número de iteraciones se corrige a base de y de acuerdo
con el tamaño de la muestra de aprendizaje. Recuerde que el principio del aprendizaje y
de la generalización de la información por la red de Kohonen supone que cada muestra se
presenta a la red muchas veces. Por ejemplo, si la muestra incluye 100 entradas,
entonces para repasar cada una de ellas 100 veces (como media), habrá que establecer el
número de iteraciones igual a 10 000. Sin embargo, si la muestra es de 10 000 entradas,
el número de iteraciones tendrá que ser 100 000 El método más conveniente y
convencional para establecer el número de, así llamadas, las «épocas del aprendizaje»,
es decir, los ciclos dentro de cada uno de los cuales todas las instancias se pasan
aletoriamente a la entrada de la red. Este número será definido en el parámetro
EpochNumber. Debido a su introducción, la duración del aprendizaje se separa
parametricamente del tamaño del conjunto de datos.

Es más aun importante, ya que el conjunto general de datos puede ser dividido en dos
componentes, en caso de necesidad: la muestra de aprendizaje y la llamada muestra de
validación. La última se aplica para monitorear la calidad del aprendizaje de la red. La
cosa es que la adaptación de la red a los datos de entrada durante el aprendizaje tiene el
«reverso de la medalla»: la red empieza a adaptarse a las particularidades específicas de
las instancias, y así, pierde la capacidad de generalizar y funcionar adecuadamente en
datos nunca vistos antes (diferentes de los que han sido usados para el aprendizaje). Y
eso que la idea del aprendizaje, normalmente, consiste en utilizar las particularidades
detectadas a través de la red en el futuro.

En el programa considerado, el parámetro ValidationSetPercent se encarga de la

activación de la validación. Por defecto, es igual a 0, y todos los datos se usan para el
aprendizaje. Si especificamos, digamos, el valor 10, entonces sólo 90% de las instancias
se usan para el aprendizaje. Para los 10% restantes se calcula el error medio cuadrático
normalizado relativo (Normalized Mean Squared Error) en cada iteración (época), y el
proceso de aprendizaje se detiene en el momento cuando el error empieza a crecer.
 (5)

La normalización consiste en la división del error medio cuadrático por la dispersión de

los mismos datos, lo que resulta que el índice siempre está por debajo de 1. Al considerar
cada vector por separado, este error medio cuadrático, en realidad, representa un error
de cuantización, porque se basa en la diferencia entre sus componentes y los pesos de las
sinapses correspondientes de las neuronas, dando la mejor aproximación de este vector
entre todas las neuronas. Recordemos que en las redes de Kohonen esta neurona
ganadora se llama BMU (best matching unit) o BMN (best matching node). El método
GetBestMatchingNode se encarga de su búsqueda en la clase CSOM.

Al activar la validación, el número de las iteraciones va a superar los valores establecidos

en el parámetro EpochNumber. Debido a las particularidades de la arquitectura de la red
de Kohonen, la validación puede realizarse sólo después de que la red pase la fase de
autoorganización en las épocas EpochNumber. Después de que se termine esta fase, la
velocidad de aprendizaje se disminuye de forma que se empieza el ajuste fino de los
pesos y se empieza la fase de la convergencia. Es aquí donde se usa la «interrupción
precoz» del aprendizaje a través del conjunto de validación.

La validación se usa o no, dependiendo de la especificación del problema. Además de

eso, el conjunto de validación puede ser usado para ajustar el tamaño de la red. En este
artículo, no vamos a entrar en este asunto. Usaremos una conocida regla empírica que
relaciona el tamaño de la red con el número de datos de aprendizaje:

N ~ 5 * sqrt(M) (6)

aquí, N es el número de neuronas en la red, M es el número de los vectores de entrada.

Para una red de Kohenen con la capa de salida cuadrada, obtenemos el siguiente tamaño:

S = sqrt(5 * sqrt(M)) (7)

aquí, S es el número de neuronas por la vertical y por la horizontal. Vamos a introducir
este valor en los parámetros CellsX y CellsY.

El último problema que tenemos que corregir en los códigos fuente originales concierne
al procesamiento de la cuadrícula hexagonal. Como se sabe, los mapas de Kohonen
normalmente se construyen usando la colocación rectangular o hexagonal de las células
(neuronas), siendo que ambos modos están realizados inicialmente en los códigos fuente.
Sin embargo, la cuadrícula hexagonal se muestra en forma de las células, pero se calcula
igualmente como la rectangular. Para llegar a la raíz del error, vamos a analizar la
siguiente ilustración.
 Geometría de los alrededores de la neurona en la cuadrícula rectangular y hexagonal

Aquí se muestra el entorno lógico de una neurona aleatoria (en este caso, con
coordenadas 3;3) para las cuadrículas de ambas geometrías. El radio del entorno es igual
a 1. En la cuadrícula cuadrada, la neurona tiene 4 vecinos; y en la cuadrícula hexagonal,
son 6. La implementación de la apariencia celular se consigue a través del
desplazamiento de cada segunda línea de las células a la mitad de la célula al lado. Sin
embargo, sus coordenadas internas no se alteran, y desde el punto de vista del
algoritmo, el entorno de la neurona en la cuadrícula hexagonal aparece como antes (está
marcada en color rosa).

Aparentemente, no es correcto y tiene que ser corregido mediante la inclusión de las

neuronas marcadas en amarillo.

Formalmente, el algoritmo calcula el entorno no sólo usando los vecinos adyacentes, sino
como una función radial decreciente convexa que depende de la distancia entre las
coordenadas de las células. En otras palabras, la vecindad no es una propiedad binaria de
la neurona (sea un vecino o no), sino un valor continuo que se calcula a través de la
fórmula de Gaussian:

(8)

Aquí, dji es la distancia entre las neuronas j y i (se tiene en cuenta la numeración
continua, en vez de las coordenadas X y Y); la sigma es el ancho eficaz del entorno o el
rango de aprendizaje que se reduce gradualmente durante el aprendizaje. Al principio
del aprendizaje, el entorno cubre con una «campana» un espacio más grande que las
neuronas adyacentes.
Puesto que esta fórmula depende de la distancia, ella también altera el entorno si las
coordenadas no han sido corregidas de manera correspondiente. Por tanto, las siguientes
líneas del código fuente original del método CSOM::Train:

for(int i = 0; i < total_nodes; i++)

double DistToNodeSqr = (m_som_nodes[winningnode].X() -

m_som_nodes[i].X()) * (m_som_nodes[winningnode].X() -
m_som_nodes[i].X())

+ (m_som_nodes[winningnode].Y() -
m_som_nodes[i].Y()) * (m_som_nodes[winningnode].Y() -
m_som_nodes[i].Y());

han sido completadas:

bool odd = ((winningnode % m_ycells) % 2) == 1;

for(int i = 0; i < total_nodes; i++)

bool odd_i = ((i % m_ycells) % 2) == 1;

double shiftx = 0;

if(m_hexCells && odd != odd_i)

if(odd && !odd_i)

shiftx = +0.5;

else // vice versa (!odd && odd_i)

shiftx = -0.5;

double DistToNodeSqr = (m_node[winningnode].GetX() -

(m_node[i].GetX() + shiftx)) * (m_node[winningnode].GetX() -
(m_node[i].GetX() + shiftx))

+ (m_node[winningnode].GetY() -
m_node[i].GetY()) * (m_node[winningnode].GetY() - m_node[i].GetY());

La dirección de la corrección shiftx depende de la relación de las propiedades par-impar

de las líneas donde se encuentran dos neuronas entre las cuales se calcula la distancia. Si
las neuronas las neuronas se encuentran en las líneas igualmente niveladas, entonces no
hay corrección. Si la neurona ganadora se encuentra en una línea impar, entonces las
líneas pares respecto a ella aparentan desplazadas a la mitad de la célula a la derecha,
por eso shiftx es igual a +0,5. Si la neurona ganadora se encuentra en una línea par,
entonces las líneas impares respecto a ella aparentan desplazadas a la mitad de la célula
a la izquierda, por eso shiftx es igual a -0,5.

Ahora, es especialmente importante prestar atención a las siguientes líneas originales:

if(DistToNodeSqr < WS)

double influence = MathExp(-DistToNodeSqr / (2 * WS));

m_node[i].AdjustWeights(data, learning_rate, influence);

Este operador condicional garantiza prácticamente una cierta aceleración de los cálculos
a través del rechazo de las neuronas fuera del entorno de una sigma. No obstante, desde
el punto de vista de la calidad del aprendizaje, la fórmula de Gaussianes una forma ideal
y esta intervención no es razonable. Si realizamos la omisión de las neuronas demasiado
lejanas, entonces por tres sigmas, y no por una. Y eso es aún más crítico después de que
hayamos corregido el cálculo de la cuadrícula hexagonal, porque la distancia entre las
neuronas adyacentes ubicadas en las líneas vecinas es igual a sqrt(1*1 + 0.5*0.5) = 1.118,
es decir, más de uno. En los códigos adjuntos, este operador condicional está comentado.
Si surge la necesidad de acelerar los cálculos, utilice la siguiente opción:

if(DistToNodeSqr < 9 * WS)

¡ATENCIÓN! Debido al detalle especificado de la diferencia de las distancias entre las

neuronas adyacentes dependiendo de su línea (las líneas únicas tienen la distancia 1, las
líneas adyacentes, 1,118), la implementación actual no es ideal y necesita la siguiente
corrección para alcanzar la anisotropía completa.

Visualización
A pesar de que las redes de Kohonen se asocian principalmente con un mapa gráfico
visible, su topología y los algoritmos de aprendizaje pueden funcionar perfectamente sin
la interfaz de usuarios. Particularmente, las tareas de predecir o compactar la
información no requieren ningún análisis visual obligatorio, mientras que la clasificación
de las imágenes puede mostrar el resultado en forma de un número (número de la clase o
la probabilidad del evento). Por tanto, la funcionalidad de las redes de Kohonen fue
dividida entre dos clases. En la clase CSOM, queda sólo la parte del cálculo, la carga y el
guardado de los datos, la carga y el guardado de las redes. Adicionalmente, fue creada la
clase derivada CSOMDisplay que contiene la gráfica. Según mi parecer, es una jerarquía
más simple y más lógica de la propuesta en el artículo 2. A continuación, para las tareas
de la selección de los parámetros óptimos del EA vamos a usar CSOMDisplay, y para la
previsión, usaremos CSOM.

Nótese que el indicio tipo cuadrícula (rectangular o hexagonal) pertenece a la clase base,
puesto que influye en el cálculo de las distancias. Juntamente con el número de los
nodos por la vertical y horizontal, así como la dimensionalidad del espacio de entrada de
los datos, el tipo de la cuadrícula forma parte de la arquitectura de la red y se guarda en
el archivo. Cuando la red se carga desde el archivo, todos estos parámetros se leen
precisamente desde ahí, y no desde las configuraciones del programa. Otras
configuraciones que influyen en la representación gráfica, tales como, el tamaño de los
mapas en píxeles, visualización de los límites entre las celdas, visualización de las
leyendas, no se guardan en el archivo de la red y pueden alterarse repetidamente y
aleatoriamente para una red después de su aprendizaje.

Cabe destacar que ninguna de las clases actualizadas proporciona la interfaz gráfica de
usuario con los controles, es que todas las configuraciones se establecen a través de los
parámetros de entrada de los programas MQL. Al mismo tiempo, la clase CSOMDisplay
realiza algunos recursos útiles.

Vamos a recordar que en los ejemplos anteriores del trabajo con las redes de Kohonen,
había un parámetro de entrada MaxPictures, y él ha sido dejado en la nueva
implementación. Se pasa como maxpict al método CSOMDisplay::Init y establece el
número de los mapas (planos) de la red que se muestran en el gráfico en una línea.
operando con este parámetro junto con el tamaño unificado de las imágenes ImageW y
ImageH, podemos encontrar una opción cuando todos los mapas caben en la pantalla. No
obstante, cuando hay muchos mapas (por ejemplo, cuando necesitamos analizar muchas
configuraciones del EA), tenemos que reducir su tamaño, y eso no es muy conveniente.
En estos casos, usamos MaxPictures para activar el nuevo modo, estableciendo el
parámetro a 0.

En este modo, las visualizaciones de los mapas no se generan en el gráfico como objetos
OBJ_BITMAP_LABEL con la vinculación a las coordenadas de los píxeles, sino en forma de
los objetos OBJ_BITMAP con vinculación a la escala de tiempo. El tamaño de estos mapas
puede ser aumentado hasta la altura total del gráfico, y Usted puede ojearlos usando la
barra de desplazamiento horizontal a través del ratón, la rueda o el teclado. El número
de los mapas ya no se limita con el tamaño de la pantalla, pero tenemos que asegurarnos
de la presencia del número suficiente de las barras.

El aumento de los tamaños de los mapas permite estudiarlos más detalladamente,

especialmente porque la clase CSOMDisplay muestra opcionalmente varios datos dentro
de las celdas, como el valor del peso de sinapsis del plano correspondiente, número de
las ocurrencias de los vectores del conjunto de aprendizaje, el valor medio y la
dispersión de los valores del indicio correspondiente de todos los vectores que entran en
la celda. Esta información no se muestra por defecto, pero siempre está disponible en las
ayudas emergentes que aparecen si mantenemos el cursor del ratón sobre alguna celda.
Además, en las ayudas se muestra el nombre del plano actual y las coordenadas de la
neurona.

Aparte de eso, si hacemos doble clic en cualquier neurona, se resalta con el color inverso
en el mapa actual, así como en el resto de los mapas. Eso permite comparar visualmente
la actividad de las neuronas por todos los recursos simultáneamente.
Finalmente, cabe mencionar que la gráfica entera ha sido pasada a la clase
estándar CCanvas. Eso libera el código de las dependencias externas, pero tiene un
efecto secundario: las coordenadas Y ahora se calculan de arriba abajo y no de abajo
arriba como antes. Como resultado, la leyenda de los mapas con el nombre de los
componentes y los rangos de sus valores se muestra por encima de los mapas y no
debajo, pero este cambio no parece ser crítico.

Mejoras
Antes de proceder a las tareas aplicadas, hay que mejorar las clases de la red neuronal.
En adición a los mapas estándar que representan los pesos de sinapsis en los espacios 2D
de características específicas, vamos a preparar el cálculo y visualización de algunos
mapas de servicio que representan un estándar de-facto para las redes de Kohonen.
Hablando con adelantado, digamos que vamos a necesitar muchos de ellos en la fase de
los experimentos aplicados.
Vamos a definir los índices de las dimensiones adicionales (en total, serán 5).
#define EXTRA_DIMENSIONS 5

#define DIM_HITCOUNT (m_dimension + 0)

#define DIM_UMATRIX (m_dimension + 1)

#define DIM_NODEMSE (m_dimension + 2) // quantization errors per

node: average variance (square of standard deviation)

#define DIM_CLUSTERS (m_dimension + 3)

#define DIM_OUTPUT (m_dimension + 4)

U-Matrix

Primeramente, vamos a calcular la matriz unificada de las distancias U-matrix para

evaluar la topología generada en el proceso del aprendizaje dentro de la red. Para cada
neurona en la red, esta matriz contiene la distancia media entre esta neurona y sus
vecinos inmediatos. Puesto que la red de Kohonen muestra un espacio multidimensional
de los recursos en el espacio bidimensional del mapa, en este espacio bidimensional
surgen los pliegues. En otras palabras, a pesar de la propiedad de la red de Kohonen de
mantener el orden inherente al espacio original, eso es imposible igualmente en el plano
2D entero, y en algunas ocasiones la proximidad geográfica de las neuronas se hace
engañosa. Para detectar estas áreas, se usa U-matrix. Ahi, las zonas donde existe una
diferencia grande entre los pesos de la neurona y los pesos de sus vecinos tienen la
apariencia de los «picos», las zonas donde las neuronas son muy parecidas parecen a los
«valles».
Para calcular la distancia entre la neurona y el vector de características, existe el
método CSOMNode::CalculateDistance. Vamos a crear un método de contraparte que va a
obtener el puntero a otra neurona en vez del vector (array double).

double CSOMNode::CalculateDistance(const CSOMNode *other) const

double vector[];

other.GetCodeVector(vector);

return CalculateDistance(vector);

Aquí, el método GetCodeVector obtiene el array con los pesos de otra neurona, y lo envía
inmediatamente para el cálculo de la distancia de manera común.

Para obtener la distancia de la neurona unificada, hay que calcular la distancia con todas
las neuronas vecinas y promediarla. Puesto que el repaso de las neuronas vecinas es una
tarea común para varias operaciones en la cuadrícula de la red, creamos la clase base
para el repaso, y luego, implementamos los algoritmos determinados en sus
descendientes, incluyendo la suma de las distancias.

#define NBH_SQUARE_SIZE 4

#define NBH_HEXAGONAL_SIZE 6
template<typename T>

class Neighbourhood

protected:

int neighbours[];

int nbhsize;

bool hex;

int m_ycells;

public:

Neighbourhood(const bool _hex, const int ysize)

hex = _hex;

m_ycells = ysize;

if(hex)

nbhsize = NBH_HEXAGONAL_SIZE;

ArrayResize(neighbours, NBH_HEXAGONAL_SIZE);

neighbours[0] = -1; // up (visually)

neighbours[1] = +1; // down (visually)

neighbours[2] = -m_ycells; // left

neighbours[3] = +m_ycells; // right

/* template, applied dynamically in the loop below

// odd row

neighbours[4] = -m_ycells - 1; // left-up

neighbours[5] = -m_ycells + 1; // left-down

// even row

neighbours[4] = +m_ycells - 1; // right-up

neighbours[5] = +m_ycells + 1; // right-down

*/

else

{
 nbhsize = NBH_SQUARE_SIZE;

ArrayResize(neighbours, NBH_SQUARE_SIZE);

neighbours[0] = -1; // up (visually)

neighbours[1] = +1; // down (visually)

neighbours[2] = -m_ycells; // left

neighbours[3] = +m_ycells; // right

~Neighbourhood()

ArrayResize(neighbours, 0);

T loop(const int ind, const CSOMNode &p_node[])

int nodes = ArraySize(p_node);

int j = ind % m_ycells;

if(hex)

int oddy = ((j % 2) == 1) ? -1 : +1;

neighbours[4] = oddy * m_ycells - 1;

neighbours[5] = oddy * m_ycells + 1;

reset();

for(int k = 0; k < nbhsize; k++)

if(ind + neighbours[k] >= 0 && ind + neighbours[k] < nodes)

// skip wrapping edges

if(j == 0) // upper row

 {

if(k == 0 || k == 4) continue;

else if(j == m_ycells - 1) // bottom row

if(k == 1 || k == 5) continue;

iterate(p_node[ind], p_node[ind + neighbours[k]]);

return getResult();

virtual void reset() = 0;

virtual void iterate(const CSOMNode &node1, const CSOMNode &node2)

= 0;

virtual T getResult() const = 0;

};

Dependiendo del tipo de la cuadrícula pasada al constructor, el número de los vecinos

nbhsize será considerado igual a 4 y 6. Los incrementos de los números de las neuronas
vecinas respecto a la neurona actual se guarda en el array neighbours. Por ejemplo, en la
cuadrícula cuadrada, el vecino de arriba se obtiene restando 1, y el vecino de abajo,
sumando 1 al número de la neurona. Los vecinos de la izquierda y de la derecha tienen
los números que se diferencian por la altura de la columna de la cuadrícula, por eso, este
valor se pasa al constructor como ysize.
El repaso de los vecinos se realiza por el método loop. La clase Neighbourhood no incluye
ningún array de neuronas, y por eso, se pasa al método loop como un parámetro.

Este método repasa cíclicamente el array neighbours y verifica adicionalmente que el

número del vecino no salga fuera de la cuadrícula, teniendo en cuenta el incremento.
Para todos los números válidos, se invoca el método abstracto iterate, a donde se pasan
las referencias a la neurona actual y una de las neuronas del entorno.

Antes del ciclo se invoca el método abstracto reset, y después del ciclo, el método
abstracto getResult. El conjunto de tres métodos abstractos permite preparar y ejecutar
la iteración de los vecinos en las clases descendientes, así como generar el resultado. El
concepto de la construcción del método «loop» corresponde al patrón de la proyección
de la POO (método de plantilla). Aquí, se debe distinguir el término «plantilla» en el
nombre del patrón, de la construcción de lenguaje de las plantillas que también se usa
en la clase Neighbourhood, porque es una plantilla (es decir, es parametrizado por un
determinado tipo variable T). En particular, el propio método loop y el método getResult
devuelven el valor tipo T.

Vamos a escribir la clase para el cálculo U-matrix a base de la clase Neighbourhood.

class UMatrixNeighbourhood: public Neighbourhood<double>

private:

int n;

double d;

public:

UMatrixNeighbourhood(const bool _hex, const int ysize):

Neighbourhood(_hex, ysize)

virtual void reset() override

n = 0;

d = 0.0;

virtual void iterate(const CSOMNode &node1, const CSOMNode &node2)

override

d += node1.CalculateDistance(&node2);

n++;

virtual double getResult() const override

return d / n;

};

El tipo de trabajo es double. Gracias a la clase base, los cálculos de la distancia son
bastante transparentes.
Vamos a calcular las distancias de todo el mapa en el método CSOM::CalculateDistances.

void CSOM::CalculateDistances()

UMatrixNeighbourhood umnh(m_hexCells, m_ycells);

for(int i = 0; i < m_xcells * m_ycells; i++)

double d = umnh.loop(i, m_node);

if(d > m_max[DIM_UMATRIX])

m_max[DIM_UMATRIX] = d;

m_node[i].SetDistance(d);

El valor de la distancia unificada se guardan en el objeto de la neurona. Posteriormente,

al mostrar todos los planos, podremos definir los valores de las distancias de manera
estándar usando una paleta de colores, incluyendo la dimensión adicional DIM_UMATRIX
en el cálculo. Para escalar la paleta correctamente, guardamos en este método el valor
máximo de la distancia dentro del elemento correspondiente del array m_max (todos los
principios de la visualización permanecen inalterados desde las implementaciones
anteriores).

Número de ocurrencias y error de cuantización

La siguiente dimensión adicional va a recopilar las estadísticas respecto al número de

ocurrencias de los vectores de aprendizaje en las determinadas neuronas. En otras
palabras, es la densidad de la población de las neuronas con datos aplicados. Cuanto más
alta sea para una neurona específica, más justificados serán sus coeficientes de
ponderación. En la red, pueden aparecer las neuronas con una cobertura de datos
pequeña o incluso nula. Si son muchas, eso puede indicar en los problemas en la
selección del tamaño de la red o la distorsión de la topología en la proyección 2D del
espacio multidimensional. Para calcular las ocurrencias de las instancias en una
determinada neurona, se usa el método:

void CSOMNode::RegisterPatternHit(const double &vector[])

m_hitCount++;

double e = 0;

for(int i = 0; i < m_dimension; i++)

 {

m_sum[i] += vector[i];

m_sumP2[i] += vector[i] * vector[i];

e += (m_weights[i] - vector[i]) * (m_weights[i] - vector[i]);

m_mse += e / m_dimension;

El cálculo se realiza en la primera línea m_hitCount++, donde se aumenta el contador

interno. El resto del código realiza otro trabajo útil del que hablaremos más abajo.

La llamada al método RegisterPatternHit va a realizarse después de la finalización del

aprendizaje, desde la clase CSOM, donde crearemos un método especial del
procesamiento estadístico de cada vector.

double CSOM::AddPatternStats(const double &data[])

static double vector[];

ArrayCopy(vector, data);

int ind = GetBestMatchingIndex(vector);

m_node[ind].RegisterPatternHit(vector);

double code[];

m_node[ind].GetCodeVector(code);

Denormalize(code);

double mse = 0;

for(int i = 0; i < m_dimension; i++)

mse += (data[i] - code[i]) * (data[i] - code[i]);

mse /= m_dimension;

return mse;
}

Como una digresión, cabe mencionar que el método GetBestMatchingIndex (utilizado

aquí), como algunos otros del grupo de los métodos GetBestMatchingXYZ, normaliza los
datos de entrada dentro de sí mismo, y por esa razón hay que pasarle una copia del
vector (en caso contrario, sería abierta una posibilidad de la modificación difusa de los
datos de origen en el código de la llamada).

Aparte del registro de una ocurrencia, este método calcula el error de cuantización para
la neurona actual y para el vector pasado. Para eso, a la neurona vencedora se le solicita
así llamado el vector de código (code vector), es decir, el array de los pesos de sinapsis,
y se calcula la suma de los cuadrados de las diferencias de los componentes entre los
pesos y el vector de entrada.

AddPatternStats se invoca desde otro método CSOM::CalculateStats, que simplemente

organiza el ciclo por todos los datos de entrada.

double CSOM::CalculateStats(const bool complete = true)

double data[];

ArrayResize(data, m_dimension);

double trainedMSE = 0.0;

for(int i = complete ? 0 : m_validationOffset; i < m_nSet; i++)

ArrayCopy(data, m_set, 0, m_dimension * i, m_dimension);

trainedMSE += AddPatternStats(data, complete);

double nmse = trainedMSE / m_dataMSE;

if(complete) Print("Overall NMSE=", nmse);

return nmse;

Este método suma todos los errores de cuantización y los compara con la dispersión de
los datos de entrada en m_dataMSE (eso es exactamente el cálculo NMSE del que hemos
hablado antes en el contexto de la validación y la detención del aprendizaje). En este
método, se menciona la variable m_validationOffset, que se establece al crear el objeto
CSOM a base de que si se usa o no la división del conjunto de datos de entrada por el
subconjunto de aprendizaje y de validación.

Usted puede fácilmente darse cuenta de que el método CalculateStats se invoca en cada
época dentro del método Train (si la fase de la convergencia ya ha sido iniciada), y puede
juzgar por el valor devuelto si el error general de la red ha empezado a crecer, es decir,
si es el momento de parar.
La dispersión m_dataMSE se calcula de antemano a través del método:

void CSOM::CalculateDataMSE()

double data[];

m_dataMSE = 0.0;

for(int i = m_validationOffset; i < m_nSet; i++)

ArrayCopy(data, m_set, 0, m_dimension * i, m_dimension);

double mse = 0;

for(int k = 0; k < m_dimension; k++)

mse += (data[k] - m_mean[k]) * (data[k] - m_mean[k]);

mse /= m_dimension;

m_dataMSE += mse;

El valor medio de m_mean para cada componente se obtiene en la fase de la

normalización de datos.

void CSOM::InitNormalization(const bool normalization = true)

ArrayResize(m_max, m_dimension + EXTRA_DIMENSIONS);

ArrayResize(m_min, m_dimension + EXTRA_DIMENSIONS);

ArrayInitialize(m_max, 0);

ArrayInitialize(m_min, 0);

ArrayResize(m_mean, m_dimension);

ArrayResize(m_sigma, m_dimension);

for(int j = 0; j < m_dimension; j++)

{
 double maxv = -DBL_MAX;

double minv = +DBL_MAX;

if(normalization)

m_mean[j] = 0;

m_sigma[j] = 0;

for(int i = 0; i < m_nSet; i++)

double v = m_set[m_dimension * i + j];

if(v > maxv) maxv = v;

if(v < minv) minv = v;

if(normalization)

m_mean[j] += v;

m_sigma[j] += v * v;

m_max[j] = maxv;

m_min[j] = minv;

if(normalization && m_nSet > 0)

m_mean[j] /= m_nSet;

m_sigma[j] = MathSqrt(m_sigma[j] / m_nSet - m_mean[j] *

m_mean[j]);

else

m_mean[j] = 0;

m_sigma[j] = 1;
 }

Volviendo a los planos adicionales, hay que notar que después de los cálculos realizados
en CSOMNode::RegisterPatternHit, cada neurona es capaz de devolver la estadística
correspondiente a través de los métodos:

int CSOMNode::GetHitsCount() const

return m_hitCount;

double CSOMNode::GetHitsMean(const int plane) const

if(m_hitCount == 0) return 0;

return m_sum[plane] / m_hitCount;

double CSOMNode::GetHitsDeviation(const int plane) const

if(m_hitCount == 0) return 0;

double z = m_sumP2[plane] / m_hitCount - m_sum[plane] / m_hitCount *

m_sum[plane] / m_hitCount;

if(z < 0) return 0;

return MathSqrt(z);

double CSOMNode::GetMSE() const

if(m_hitCount == 0) return 0;

return m_mse / m_hitCount;

De esta manera, obtenemos los datos para el llenado de dos planos, con el número de las
visualizaciones de los vectores de entrada por las neuronas y con el error de
cuantización.
Respuesta de la red
El próximo plano adicional es el mapa de la salida o la respuesta de la red a una
determinada instancia. No hay que olvidar que después del envío de la señal a la red,
juntamente con la neurona vencedora, se activan todas las demás neuronas (en mayor o
en menor grado). La posibilidad de comparar la amplitud de las áreas activas de la
respuesta puede ayudar a determinar la estabilidad de la solución propuesta por la red.

El cálculo de la respuesta de la red es bastante simple. Escribimos el siguiente método en

la clase CSOMNode:

double CSOMNode::CalculateOutput(const double &vector[])

m_output = CalculateDistance(vector);

return m_output;

Vamos a llamarlo para cada neurona en la clase de la red.

void CSOM::CalculateOutput(const double &vector[], const bool

normalize = false)

double temp[];

ArrayCopy(temp, vector);

if(normalize) Normalize(temp);

m_min[DIM_OUTPUT] = DBL_MAX;

m_max[DIM_OUTPUT] = -DBL_MAX;

for(int i = 0; i < ArraySize(m_node); i++)

double x = m_node[i].CalculateOutput(temp);

if(x < m_min[DIM_OUTPUT]) m_min[DIM_OUTPUT] = x;

if(x > m_max[DIM_OUTPUT]) m_max[DIM_OUTPUT] = x;

Si el vector de prueba no figura en el programa, la respuesta se calcula por defecto, es

decir, para el vector cero.
Agrupamiento (Clusterización)

Finalmente, el último de los planos considerados, pero probablemente sea el más

importante, será el mapa de los clusters. Ordenar los datos de entrada en el mapa
bidimensional es sólo la mitad del asunto. El propósito real del análisis es detectar las
particularidades y clasificarlas en las clases fáciles de entender en términos de la
aplicación. Cuando la dimensionalidad del espacio de las características es relativamente
pequeña, podemos fácilmente distinguir las áreas con las características necesarias por
las manchas de color en determinados planos, siendo que esas manchas normalmente
están aisladas. Pero con la expansión de la estructura de los datos de entrada, la imagen
se hace más complicada, y en vez del análisis cruzado de decenas de mapas con
diferentes índices, es mucho más conveniente tener un solo mapa dividido en áreas que
reivindican la atención.

El resultado del agrupamiento consistirá en marcar el mapa en áreas con características

semejantes e identificar los centros de los clusters. Entonces, podemos considerarlos
como las muestras más representativas (en términos estadísticos) de las clases
correspondientes. Aquí, nos acercamos poco a poco a la tarea de la selección de los
parámetros óptimos del EA. Pero primero, tenemos que implementar el agrupamiento.

K-Means

Existen muchos métodos de clasterización. La opción más óptima para MQL5 es usar la
versión de ALGLIB que forma parte de la biblioteca estándar. Basta con incluir el archivo
de cabecera:

#include <Math/Alglib/dataanalysis.mqh>

y escribir aproximadamente el siguiente método:

void CSOM::Clusterize(const int clusterNumber)

int count = m_xcells * m_ycells;

CMatrixDouble xy(count, m_dimension);

int info;

CMatrixDouble clusters;

int membership[];

double weights[];

for(int i = 0; i < count; i++)

m_node[i].GetCodeVector(weights);

xy[i] = weights;

CKMeans::KMeansGenerate(xy, count, m_dimension, clusterNumber,

KMEANS_RETRY_NUMBER, info, clusters, membership);

Print("KMeans result: ", info);

if(info == 1) // ok

for(int i = 0; i < m_xcells * m_ycells; i++)

{
 m_node[i].SetCluster(membership[i]);

ArrayResize(m_clusters, clusterNumber * m_dimension);

for(int j = 0; j < clusterNumber; j++)

for(int i = 0; i < m_dimension; i++)

m_clusters[j * m_dimension + i] = clusters[i][j];

Realiza el agrupamiento a través del algoritmo K-Means. Lamentablemente, según sepa,

es el único algoritmo del agrupamiento en la versión ALGLIB en MQL5, aunque la última
versión de la biblioteca original ofrece otras, como el agrupamiento jerárquico tipo
aglomerativo.

He dicho «lamentablemente» porque el algoritmo K-Means es el más «directo» en cierta

medida: su esencia se reduce a la búsqueda de los centros del número establecido de los
esferoides (en el espacio de las características) que cubren los puntos de la muestra de
una manera más eficaz (el mínimo de la suma de los cuadrados de las distancias desde los
puntos hasta los centros de los clusters). El problema es que, debido a su forma
especifica, los esferoides tienen algunas limitaciones específicas en cuanto a la
separabilidad de los clusters no lineales. En principio, K-Means es un caso particular del
algoritmo Expectation Maximization que opera con los elipsoide de diferentes
orientaciones y formas, siendo por eso más preferible. Sin embargo, incluso cuando se
usa, queda la probabilidad de perdurar en el mínimo local (puesto que ambos algoritmos
utilizan sólo las formas convexas y la ubicación inicial aleatoria de los centros de los
clusters). Además de eso, las desventajas pueden incluir el hecho de que es necesario
especificar de antemano el número de los clusters.

No obstante, vamos a considerar cómo el agrupamiento está organizado a través de K-

Means en ALGLIB. El trabajo principal se ejecuta por el método
CKMeans::KMeansGenerate. Le pasamos el array con los datos iniciales en un formato
especial basado en objeto (CMatrixDouble xy), el número de vectores (count), la
dimensionalidad del espacio de características (m_dimension) y el número deseado de los
clusters (clusterNumber), el último se establece en los parámetros del programa MQL. El
siguiente parámetro de entrada, KMEANS_RETRY_NUMBER, representa el número de
iteraciones que se hacen por el algoritmo con diferentes centros iniciales elegidos
aleatoriamente, intentando evitar una solución local. En nuestro caso, es la macro igual a
10. Como resultado del trabajo de la función, obtenemos el código de la ejecución info
(diferentes valores indican en el éxito o en el error), array basado en el objeto
CMatrixDouble clusters con coordenadas de los clusters, así como el array de la
pertenencia de los datos de entrada a los clusters (membership).
Guardamos los centros de los clusters en el array m_clusters para marcarlos en el mapa,
y coloreamos cada neurona con el color de acuerdo con la pertenencia al cluster:
m_node[i].SetCluster(membership[i]);

A la hora de trabajar con ALGLIB, tenga en cuenta que ella usa su propio generador de
números aleatorios que considera el estado interno del objeto estático especial. Por eso,
incluso la inicialización explícita del generador estándar a través de MathSrand no
resetea sus estado. Eso es especialmente crítico para los EAs, ya que los objetos globales
dentro de ellos no se generan de nuevo al modificar las configuraciones. Como resultado,
en caso de ALGLIB, pueden surgir dificultades con la reproductibilidad de los resultados
de los cálculos, si CMath::m_state no se pone a cero en OnInit.
Tomando en cuenta las desventajas mencionadas de K-Means, es deseable tener una
opción alternativa del agrupamiento. Una solución alternativa es evidente.

Alternativa

Vamos a fijarnos de nuevo en los mapas de Kohonen, y sobre todo en las

dimensionalidades adicionales que hemos introducido. U-Matrix representa un interés
particular. Este plano muestra las áreas de las neuronas más próximas: es decir, las
neuronas próximas no sólo en el sentido topológico del mapa 2D, sino próximas en los
términos del espacio de las características. Como recordamos, las neuronas parecidas
forman una especie de los «valles» en U-Matrix. Son unos candidatos perfectos para
convertirse en los clasters.

Podemos transformar el mapa de las distancias unificadas en los clasters, por ejemplo,
de la siguiente manera.

Copiamos la información sobre todas las neuronas al array y lo ordenamos de acuerdo con
el valor de la dirección U (CSOMNode::GetDistance()) en orden ascendiente.

Para una neurona dada, vamos a verificar cíclicamente por el array si las neuronas
vecinas pertenecen a algún cláster.

 Si no es así, creamos un cláster nuevo y le atribuimos la neurona actual.

Obsérvese que los clasters van a crearse a partir del índice cero, lo que
corresponde al cláster más «importante» puesto que él corresponde a la
distancia U mínima, y luego, en orden decreciente de la importancia. Cada
siguiente cláster será menos compacto en el sentido de las distancias U.
 Si entre las neuronas vecinas hay algunas marcadas por un cláster, seleccionamos
la mayor de ellas, es decir, con el índice más bajo, y le atribuimos la neurona
actual a este cláster.

Todo es muy simple. ¿Pero merece la pena considerar también la densidad de la

población de las neuronas? Es que la distancia U tiene un soporte diferente para las
neuronas con un número de penetraciones diferente. En otras palabras, si dos neuronas
tienen la misma distancia U, la que tiene mostradas más instancias debe tener una
ventaja ante la neurona con el número más pequeño.

Entonces, será suficiente alterar la ordenación inicial en el algoritmo descrito en orden

de los valores de la fórmula CSOMNode::GetDistance() /
sqrt(CSOMNode::GetHitsCount()). He añadido la raíz cuadrada para suavizar su influencia
en caso de una población grande, mientras que la población pequeña debe «ser multada»
de una manera más estricta.

Pero si usamos dos planos de servicio, ¿puede que tenga sentido analizar también el
tercer plano, es decir, con el error de cuantización? Es verdad, cuanto más grande sea el
error de cuantización en una determinada neurona, menos confianza hay que tener a la
información sobre la distancia U pequeña en ella, y viceversa.
Si recordamos cómo es la función con el error de cuantización:

double CSOMNode::GetMSE() const

if(m_hitCount == 0) return 0;

return m_mse / m_hitCount;

es fácil de notar que en ella se utiliza el contador de ocurrencias m_hitCount (sólo en el

denominador). Por eso, podemos reescribir la fórmula anterior para el ordenamiento del
array de las neuronas como CSOMNode::GetDistance() * MathSqrt(CSOMNode::.GetMSE()),
en ella van a considerarse tres índices los cuales serán añadidos a nuestra
implementación de la red de Kohonen.

Casi estamos preparados para presentar un algoritmo alternativo del agrupamiento en su

forma final, pero nos queda un pequeño detalle. Dentro del ciclo por el array de las
neuronas, tenemos que verificar los alrededores de la neurona actual respecto a la
presencia de los clusters vecinos. Antes, hemos implementado la clase de plantilla
Neighbourhood para el análisis local. Ahora, vamos a crear su descendiente que se
especializa en la búsqueda de los clusters.

class ClusterNeighbourhood: public Neighbourhood<int>

private:

int cluster;

public:

ClusterNeighbourhood(const bool _hex, const int ysize):

Neighbourhood(_hex, ysize)

virtual void reset() override

cluster = -1;

virtual void iterate(const CSOMNode &node1, const CSOMNode &node2)

override

int x = node2.GetCluster();

if(x > -1)

 {

if(cluster != -1) cluster = MathMin(cluster, x);

else cluster = x;

virtual int getResult() const override

return cluster;

};

La clase contiene el número del cláster potencial «cluster» (el número es un número
interno por eso paratremizamos la plantilla tipo int). Inicialmente, esta variable se
inicializa en -1 en el método reset, es decir, no hay cláster. Luego, a la medida de que la
clase padre llame desde su método «loop» a nuestra nueva implementación «iterate»,
obtenemos el número del cláster de cada neurona vecina, lo comparamos con «cluster» y
guardamos el valor mínimo. Lo mismo o -1, si ningún cláster ha sido encontrado, se
devuelve por el método getResult.

Como una mejora, proponemos monitorear «la altura de los picos» entre las neuronas,
(es decir, el valor node1.CalculateDistance(&node2)), y ejecutar el «fluido» del número
del clúster desde una neurona a otra sólo si la «altura» es menor que antes. La versión
final de la implementación se presenta en el código fuente.

Por fin, podemos implementar el agrupamiento alternativo.

void CSOM::Clusterize()

double array[][2];

int n = m_xcells * m_ycells;

ArrayResize(array, n);

for(int i = 0; i < n; i++)

if(m_node[i].GetHitsCount() > 0)

array[i][0] = m_node[i].GetDistance() *
MathSqrt(m_node[i].GetMSE());

else

{
 array[i][0] = DBL_MAX;

array[i][1] = i;

m_node[i].SetCluster(-1);

ArraySort(array);

ClusterNeighbourhood clnh(m_hexCells, m_ycells);

int count = 0; // number of clusters

ArrayResize(m_clusters, 0);

for(int i = 0; i < n; i++)

// skip if already assigned

if(m_node[(int)array[i][1]].GetCluster() > -1) continue;

// check if current node is adjusent to any existing cluster

int r = clnh.loop((int)array[i][1], m_node);

if(r > -1) // a neighbour belongs to a cluster already

m_node[(int)array[i][1]].SetCluster(r);

else // we need new cluster

ArrayResize(m_clusters, (count + 1) * m_dimension);

double vector[];

m_node[(int)array[i][1]].GetCodeVector(vector);

ArrayCopy(m_clusters, vector, count * m_dimension, 0,

m_dimension);

m_node[(int)array[i][1]].SetCluster(count++);

}
 }

El algoritmo sigue prácticamente todo el pseudocódigo verbal descrito anteriormente:

llenamos el array bidimensional (el valor de la fórmula en la primera dimensión, y el
índice de la neurona en la segunda), ordenamos, recorremos cíclicamente todas las
neuronas y analizamos los alrededores para cada una de ellas.

Desde luego, la calidad del agrupamiento tiene que ser evaluada en la práctica, y yo
supongo la presencia de los problemas topológicos desde el principio. Sin embargo,
considerando que la mayoría de los modos clásicos del agrupamiento también tienen sus
problemas y ceden ante el modo propuesto en la sencillez, la nueva solución parece
bastante atractiva.

Entre las ventajas de esta implementación, yo mencionaría que los clásteres están
ordenados por la relevancia (en K-Means mencionado antes, los clasteres son del mismo
valor), su forma es aleatoria y no hace falta establecer su número de antemano. Cabe
mencionar que la última ventaja tiene su reverso, es decir, el número de los clusters
puede ser bastante grande. Al mismo tiempo, el ordenamiento de los clusters por el
grado de la semejanza del contenido y por el error mínimo permite considerar en la
práctica sólo 5-10 primeros clusters, dejando el resto al margen.

Puesto que no he encontrado el método parecido del agrupamiento en las fuentes

abiertas, yo propongo llamarlo el agrupamiento de Korotky (o de forma más larga pero
simple, short-path clusterization) a base de U-Matrix y el error de cuantización (QE).

Adelantándome, diré que después de muchas pruebas, ha sido confirmado que los centros
de los clusters encontrados por el algoritmo K-Means ofrecen los resultados peores que el
agrupamiento alternativo (por lo menos, en la tarea del análisis de los resultados de la
optimización). Debido a eso, siempre va a entenderse y aplicarse solamente este método
del agrupamiento a continuación.

Simulación
Es la hora de pasar de la teoría a la práctica y comprobar el funcionamiento de la red.
Vamos a crear un EA simple y universal con posibilidades de demostrar la funcionalidad
principal. Lo llamaremos SOM-Explorer.

Incluiremos los archivos de cabecera con las clases consideradas anteriormente.

Definimos los parámetros de entrada.

Grupo — Network Structure and Data Settings

 DataFileName — el nombre del archivo de texto con los datos para el aprendizaje
o la simulación; la clase CSOM soporta el formato csv, pero añadiremos un poco
más tarde la lectura de los archivos set, porque el análisis de las
configuraciones de optimización de otros EAs «están en el juego»; cuando se
especifica el archivo con los datos de entrada, su nombre se usa también para el
guardado de la red tras su aprendizaje pero con otra extensión (véase más
abajo); se puede indicar o no la extensión csv; el nombre puede incluir una
carpeta dentro de MQL5/Files;

 NetFileName — el nombre de un archivo binario de su propio formato con la

extensión som; la clase CSOM es capaz de guardar y leer las redes en/desde los
archivos de este tipo; si necesita modificar la estructura de los datos guardados,
cambie el nombre de la versión en la signatura que se escribe al principio del
 archivo; si NetFileName está vacío, el EA trabaja en modo de aprendizaje, y si
la red está especificada, trabaja en el modo de simulación (visualización de los
datos de entrada en la red preparada); se puede especificar o no la extensión
som; el nombre puede incluir una carpeta dentro de MQL5/Files;

 si ambos parámetros DataFileName y NetFileName están vacíos, el EA va a

generar un conjunto de demostración de datos aleatorios 3D y realizar el
aprendizaje a su base;

 si el nombre de la red en NetFileName es correcto, se puede indicar el nombre de

un archivo inexistente en el parámetro DataFileName, por ejemplo, el símbolo
'?', y como resultado, el EA generará una incidencia aleatoria de los datos de
prueba para el intervalo de definición que se guarda en el archivo de la red
(obsérvese que esta información es necesaria para que la red enseñada
normalice correctamente los datos desconocidos en el modo de servicio; el
envío de los valores de otro intervalo de definición a la entrada de la red, desde
luego, no provocará ningún fallo, pero los resultados serán incorrectos; por
ejemplo, es difícil de esperar un funcionamiento correcto de la red, si se le
pasa un valor negativo de la reducción (drawdone) o del número de
transacciones);

 CellsX — tamaño de la cuadrícula por la horizontal (número de neuronas), por

defecto es 10;

 CellsY — tamaño de la cuadrícula por la vertical (número de neuronas), por

defecto es 10;

 HexagonalCell — característica del uso de la cuadrícula hexagonal, por defecto es

true; ponga false para una cuadrícula rectangular;

 UseNormalization — activar/desactivar la normalización de los datos de entrada,

por defecto es true, siendo recomendado no desactivar;

 EpochNumber — número de las épocas del aprendizaje, por defecto es 100;

 ValidationSetPercent — tamaño de la muestra de validación en por cientos del

número total de los datos de entradas, por defecto es 0, es decir, la validación
está desactivada; en caso de usarlo, los valores recomendados están cerca de
10;

 ClusterNumber — número de los clusters; por defecto, es 1, lo que indica en

nuestro agrupamiento adaptable; el valor 0 desactiva el agrupamiento; el valor
más de 0 inicia el agrupamiento a través del método K-Means; el agrupamiento
se ejecuta inmediatamente después del aprendizaje, los clusters se guardan en
el archivo de la red;

Grupo - Visualization

 ImageW — tamaño de cada mapa (plano) en píxeles por la horizontal, por defecto
— 500;

 ImageH — tamaño de cada mapa (plano) en píxeles por la vertical, por defecto —
500;

 MaxPictures — número de mapas en una línea, por defecto es 0, lo que significa la

visualización de los mapas en una línea continua con posibilidad del
 desplazamiento (se permiten las imágenes grandes); si MaxPictures es más de 0,
el conjunto entero de los planos se muestra en varias líneas, en cada una de las
cuales hay MaxPictures de los mapas (es cómodo para observar todos los mapas
en una pequeña escala);

 ShowBorders — activar/desactivar el dibujado de los bordes entre las neuronas,

por defecto, es false;

 ShowTitles — activar/desactivar la visualización de los textos con las

características de las neuronas, por defecto, es true;

 ColorScheme — selección de una de los 4 esquemas de color, por defecto, es

Blue_Green_Red (máximo de colores);

 ShowProgress — activar/desactivar la actualización dinámica de la visualización

de las imágenes de la red durante el aprendizaje; se realiza cada segundo, por
defecto es true;

Grupo - Options

 RandomSeed — número entero para inicializar el generador de números

aleatorios, por defecto es 0;
 SaveImages — opción del guardado de las imágenes de la red después de la
conclusión; se puede usarla después del aprendizaje y después del inicio de
prueba; por defecto es false;

Solamente se trata de las configuraciones básicas. Vamos a añadir otra parte de los
parámetros específicos a la medida de que continuemos resolviendo los problemas.

¡Atención! El Asesor Experto altera los ajustes del gráfico actual— abra el gráfico
nuevo seleccionado sólo para trabajar con este EA.
El objeto de la clase CSOMDisplay ejecutará todo el trabajo en el EA.

CSOMDisplay KohonenMap;

Durante la inicialización, no olvidemos altivar el procesamiento de eventos del

desplazamiento del ratón; la clase los usa para visualizar las ayudas emergentes y el
scrolling.

void OnInit()

ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);

EventSetMillisecondTimer(1);

void OnChartEvent(const int id, const long &lparam, const double

&dparam, const string &sparam)

{
 KohonenMap.OnChartEvent(id, lparam, dparam, sparam);

Los algoritmos de redes neuronales (aprendizaje o simulación) se inician en el EA una

vez: por el temporizador, y el temporizador luego se desactiva.

void OnTimer()

EventKillTimer();

MathSrand(RandomSeed);

bool hasOneTestPattern = false;

if(NetFileName != "")

if(!KohonenMap.Load(NetFileName)) return;

KohonenMap.DisplayInit(ImageW, ImageH, MaxPictures, ColorScheme,

ShowBorders, ShowTitles);

Comment("Map ", NetFileName, " is loaded; size: ",

KohonenMap.GetWidth(), "*", KohonenMap.GetHeight(), "; features: ",
KohonenMap.GetFeatureCount());

Si se indica el archivo preparado con la red, lo cargamos y preparamos la pantalla de

acuerdo con ajustes visuales.

if(DataFileName != "")

if(!KohonenMap.LoadPatterns(DataFileName))

Print("Data loading error, file: ", DataFileName);

// generate a random test vector

int n = KohonenMap.GetFeatureCount();

double min, max;

double v[];

ArrayResize(v, n);

for(int i = 0; i < n; i++)

 {

KohonenMap.GetFeatureBounds(i, min, max);

v[i] = (max - min) * rand() / 32767 + min;

KohonenMap.AddPattern(v, "RANDOM");

Print("Random Input:");

ArrayPrint(v);

double y[];

CSOMNode *node = KohonenMap.GetBestMatchingFeatures(v, y);

Print("Matched Node Output (", node.GetX(), ",", node.GetY(),

"); Hits:", node.GetHitsCount(), "; Error:", node.GetMSE(),"; Cluster
N", node.GetCluster(), ":");

ArrayPrint(y);

KohonenMap.CalculateOutput(v, true);

hasOneTestPattern = true;

Si se indica el archivo con datos de texto, tratamos de cargarlo. Si no conseguimos

hacerlo, mostramos el mensaje en el registro y generamos una muestra aleatoria de
datos de texto «v». El número de características (dimensionalidad de vectores) y sus
intervalos permitidos se determinan a través de los métodos GetFeatureCount y
GetFeatureBounds. Luego, usando la llamada a AddPattern, la instancia se añade al
conjunto de servicio de datos con el nombre "RANDOM".

Este método conviene para formar las muestras de aprendizaje desde las fuentes de los
datos con formatos no soportados, por ejemplo, desde las bases de datos, así como para
el llenado directamente desde los indicadores. En principio, en este caso, la adición de la
instancia en el conjunto de servicio se requiere solamente para su visualización posterior
en el mapa (se muestra más abajo), y para definir la neurona de la red más conveniente
basta con llamar a GetBestMatchingFeatures. Este método, entre varios métodos
GetBestMatchingXYZ disponibles, permite que el array «y» obtenga los valores
correspondientes de las instancias de la neurona vencedora. Finalmente, usando
CalculateOutput, mostramos la reacción de la red a la instancia de texto en un plano
adicional.

Pues, continuamos con el código del EA.

else // a net file is not provided, so training is assumed

if(DataFileName == "")

{
 // generate 3-d demo vectors with unscaled values {[0,+1000],
[0,+1], [-1,+1]}

// feed them to the net to compare results with and without

normalization

// NB. titles should be valid filenames for BMP

string titles[] = {"R1000", "R1", "R2"};

KohonenMap.AssignFeatureTitles(titles);

double x[3];

for(int i = 0; i < 1000; i++)

x[0] = 1000.0 * rand() / 32767;

x[1] = 1.0 * rand() / 32767;

x[2] = -2.0 * rand() / 32767 + 1.0;

KohonenMap.AddPattern(x, StringFormat("%f %f %f", x[0], x[1],

x[2]));

Si la red enseñada no está definida, suponemos el modo de aprendizaje. Comprobamos si

hay parámetros de entrada. Si no es así, generamos un conjunto aleatorio de los vectores
tridimensionales en el que el primer componente se encuentra en el rango [0,+1000], el
segundo está dentro de [0,+1], y el tercer está dentro de [-1,+1]. El nombre de los
componentes se pasan a la red a través de AssignFeatureTitles, y los datos se pasan a
través de AddPattern.

else // a data file is provided

if(!KohonenMap.LoadPatterns(DataFileName))

Print("Data loading error, file: ", DataFileName);

return;

Si los datos de entrada vienen desde un archivo, cargamos este archivo. Si surge un error,
terminamos el trabajo, porque no hay ninguna red ni los datos.

Luego, ejecutamos el aprendizaje y el agrupamiento.

KohonenMap.Init(CellsX, CellsY, ImageW, ImageH, MaxPictures,

ColorScheme, HexagonalCell, ShowBorders, ShowTitles);
 if(ValidationSetPercent > 0 && ValidationSetPercent < 50)

KohonenMap.SetValidationSection((int)(KohonenMap.GetDataCount()
* (1.0 - ValidationSetPercent / 100.0)));

KohonenMap.Train(EpochNumber, UseNormalization, ShowProgress);

if(ClusterNumber > 1)

KohonenMap.Clusterize(ClusterNumber);

else

KohonenMap.Clusterize();

Si el análisis de una determinada instancia de texto no ha sido establecida

(particularmente, inmediatamente después del aprendizaje), por defecto, formamos la
respuesta de la red para el vector con ceros.

if(!hasOneTestPattern)

double vector[];

ArrayResize(vector, KohonenMap.GetFeatureCount());

ArrayInitialize(vector, 0);

KohonenMap.CalculateOutput(vector);

A continuación, dibujamos todos los mapas en los búferes internos de los recursos
gráficos (primero, la capa de color de atrás):

KohonenMap.Render(); // draw maps into internal BMP buffers

luego, las leyendas:

if(hasOneTestPattern)

KohonenMap.ShowAllPatterns();

else
 KohonenMap.ShowAllNodes(); // draw labels in cells in BMP buffers

Marcamos los clusters:

if(ClusterNumber != 0)

KohonenMap.ShowClusters(); // mark clusters

Mostramos los búferes en el gráfico y guardamos opcionalmente las imágenes en el

archivo:

KohonenMap.ShowBMP(SaveImages); // display files as bitmap images on

chart, optionally save into files

Los archivos se colocan en una carpeta separada con el mismo nombre que el archivo de
la red (si está especificado) o el archivo con datos (si está especificado). Si el archivo con
datos no ha sido especificado y la red se enseñaba en los datos generados aleatorios, el
nombre para el archivo som y de la carpeta con imágenes se forma usando el prefijo SOM
y la fecha y la hora actual.

Finalmente, guardamos la red enseñada en el archivo. Si el nombre del archivo ya ha sido

especificado en NetFileName, entonces el EA trabajaba en el modo de simulación, y no
es necesario guardar la red de nuevo.

if(NetFileName == "")

KohonenMap.Save(KohonenMap.GetID());

Vamos a intentar iniciar el EA con la generación de los datos de texto aleatorios. Con
todas las configuraciones predefinidas, excepto los tamaños reducidos de las imágenes,
para que todos los planos entren en la «captura de la pantalla» - ImageW = 230, ImageH =
230, MaxPictures = 3, - obtenemos lo siguiente:
 Ejemplo de los mapas de Kohonen para los vectores 3D aleatorios

Aquí, en cada neurona se muestra la información de servicio (se puede ver los detalles
apuntando con el cursor) y los clusters encontrados están marcados.

En el registro, se muestra aproximadamente la siguiente información (la información por

los clusters está limitada con cinco, se puede cambiar en el código):
Pass 0 from 1000 0%

Pass 78 from 1000 7%

Pass 157 from 1000 15%

Pass 232 from 1000 23%

Pass 310 from 1000 31%

Pass 389 from 1000 38%

Pass 468 from 1000 46%

Pass 550 from 1000 55%

Pass 631 from 1000 63%

Pass 710 from 1000 71%

Pass 790 from 1000 79%

Pass 870 from 1000 87%

Pass 951 from 1000 95%

Overall NMSE=0.09420336270396877

Training completed at pass 1000, NMSE=0.09420336270396877

Clusters [14]:

"R1000" "R1" "R2"

N0

754.83131 0.36778 0.25369

N1

341.39665 0.41402 -0.26702

N2

360.72925 0.86826 -0.69173

N3

798.15569 0.17846 -0.37911

N4

470.30648 0.52326 0.06442

Map file SOM-20181205-134437.som saved

Si ahora especificamos el nombre del archivo creado SOM-20181205-134437.som con la

red en el parámetro NetFileName, y en el parámetro DataFileName indicamos '?',
obtenemos el resultado de la ejecución de prueba para una muestra aleatoria que no sea
del conjunto de aprendizaje. Para ver mejor los mapas, establecemos los tamaños más
grandes y MaxPictures en 0.
 Los mapas de Kohonen para dos primeros componentes de los vectores 3D aleatorios

Mapa de Kohonen para el tercer componente de los vectores 3D aleatorios y el contador de ocurrencias
 U-Matrix y error de cuantización

Clusters y respuesta de la red de Kohonen a la muestra de prueba

La muestra está marcada con RANDOM. Las ayudas sobre las neuronas aparecen al
apuntar con el ratón. En el registro, se muestra aproximadamente lo siguiente:

FileOpen error ?.csv : 5004

Data loading error, file: ?

Random Input:

457.17510 0.29727 0.57621

Matched Node Output (8,3); Hits:5; Error:0.05246704285146882; Cluster
N0:

497.20453 0.28675 0.53213

Pues bien, las herramientas para trabajar con la red de Kohonen están listas. Podemos
proceder a las tareas aplicadas. Lo haremos en el segundo artículo.

Conclusión
Las implementaciones de las redes de Kohonen están disponibles para los usuarios de
MetaTrader ya algunos años. Hemos corregido algunos errores, las hemos completado con
unas herramientas útiles y hemos testeado su funcionamiento a través de un EA especial
de demostración. Los códigos fuente permiten aplicar las clases para propias tareas. Los
ejemplos de eso serán considerados a continuación.