Este artículo proviene de un motor de traducción automática.

Ejecución de pruebas

Entrenamiento de redes de funciones de base radial

James McCaffrey

Descargar el código de ejemplo

Una red de base radial (RBF) la función es un sistema de software que se puede clasificar los datos y realizar predicciones. RBF redes tienen algunas similitudes superficiales a las redes neuronales, pero son en realidad muy diferentes. Una red RBF acepta uno o más entradas numéricas y genera uno o más salidas numéricas. Los valores se determinan por los valores de entrada, además de un conjunto de parámetros llamados los centroides RBF, un conjunto llamado los anchos RBF, un conjunto llamado los pesos RBF y un conjunto llamado los sesgos RBF.

Para la simplicidad de la terminología, la combinación de RBF pesos y valores diagonales son a veces colectivamente denominados los pesos. El contexto en el cual los pesos del término se utiliza generalmente aclara el significado. Para obtener más información, vea mi artículo, "Radial base función redes para programadores" en la edición de octubre de la MSDN Magazine (msdn.microsoft.com/magazine/dn451445).

Cuando se utiliza una red RBF para clasificación y predicción, el desafío es encontrar un conjunto de valores para los centroides, anchos, pesos y sesgos así computado salidas mejor coincide con un conjunto de resultados conocidos. Esto se llama capacitación la red RBF. Aunque los investigadores han estudiado las redes RBF desde su introducción en 1988, no hay mucha orientación práctica que explica cómo implementar la formación en red RBF. Este artículo se presentan y describen una red RBF completa demo.

Echa un vistazo al programa de demostración en figura 1. El programa crea un modelo RBF que predice las especies de una flor de lirio ("setosa", "versicolor" o "virginica") de cuatro valores numéricos para la flor sépalo longitud y anchura y longitud del pétalo y ancho. Origen de datos del programa demo consta de 30 artículos que son un subconjunto de un conjunto bien conocido 150-artículo referente llamado datos Iris de Fisher. Los elementos de 30 datos han sido preprocesados. Los cuatro x-valores numéricos han sido normalizados para que valores inferiores a cero media menor que el promedio de longitud o anchura y los valores mayores a cero significan más-que-media longitud o anchura. El valor de las especies ha sido codificado como (0.0.1), (0.1.0), o (1,0,0) para setosa, versicolor y virginica, respectivamente.

Figura 1 función de base Radial red Demo programa

La demo divide el conjunto de datos de 30 elementos en un conjunto de 24 ítems para ser utilizado para el entrenamiento. También hay una retención seis elementos de prueba y evaluación del modelo RBF resultante. Crea una instancia de una RBF red con cuatro nodos de entrada (uno para cada valor de datos de entrada), cinco nodos de procesamiento ocultos y tres nodos de salida (uno para cada valor de salida de datos). Determinar el mejor número de nodos ocultos es sobre todo una cuestión de ensayo y error. La elección de cinco en la demo fue arbitraria.

En figura 1 puedes ver que entrenar una red RBF consiste en tres fases. La primera fase determina los centroides. Piensa como x-valores representativos seleccionados a partir de los datos del entrenamiento de los centroides. Una red RBF requiere un centroide para cada nodo escondido, así que la demo necesita cinco centroides. El algoritmo de entrenamiento selecciona los valores x de formación los elementos de datos [9], [19], [21], [20] y [4]. En otras palabras, el primer centroide es (-0.362,-2.019, 0.074 0.112).

La segunda fase del entrenamiento determina anchos. Piensa como valores que describen la distancia entre los centroides de anchuras. Una red RBF requiere una anchura para cada nodo escondido. La demo calcula una sola anchura común con el valor 3.3318 para todos los nodos ocultos cinco más cinco computación separa anchos.

La tercera fase de la formación determina el RBF pesos y valores de sesgo. Piensa de pesos y valores de sesgo como constantes numéricas. Si tiene una red RBF NI número de nodos de entrada, NH número de nodos ocultos y ningún número de nodos de salida, entonces la red requiere (NH * NO) no peso valores y sesgo. De ser así, porque la red RBF demo tiene un 4-5-3 arquitectura, necesita 5 * 3 = 15 pesos además tres sesgos, para un total de 18 pesos y valores de sesgo. El programa de demostración utiliza partículas swarm optimización (PSO) para determinar los 18 pesos y sesgos.

Después de que la red RBF demostración usando el conjunto de datos de entrenamiento 24-item has entrenado, usted alimenta el conjunto de datos de prueba de seis en la red. En este ejemplo, la red RBF predice correctamente la especie de cinco de los seis artículos de la prueba, para una precisión de la clasificación de 0.8333.

Este artículo asume que ha avanzado habilidades de programación con C# y una familiaridad básica con el mecanismo de entrada-proceso-salida base radial función red. Hablé de ese mecanismo en mi columna de octubre. El código fuente para el programa de demostración es demasiado largo para presentar en su totalidad en este artículo, pero la descarga de código completo está disponible en archive.msdn.microsoft.com/mag201312TestRun.

Estructura general del programa

Para crear el programa de demostración, lanzó Visual Studio 2012 y creó una aplicación de consola de C# llamada RadialNetworkTrain. La demo no tiene significativa .NET dependencias para que funcione cualquier versión de Visual Studio . Después de carga el código de la plantilla, en el explorador de soluciones ventana que renombrado archivo Program.cs a la RadialTrainProgram.cs y Visual Studio automáticamente retitulado más descriptivo asociado clase programa. En la parte superior del código fuente, he borrado todas las referencias innecesarias a .NET namespaces, dejando sólo la referencia al espacio de nombres del sistema.

La estructura general del programa, con algunas declaraciones WriteLine quitados y algunas ediciones menores, se presenta en figura 2. Además de la clase del programa contiene el método Main, la demo tiene una clase de RadialNetwork que encapsula la creación de la red RBF y entrenamiento, una clase de partícula que define un objeto partícula para su uso con el algoritmo de entrenamiento RBF que determina pesos y valores de sesgo, y una clase de ayudantes que contiene la utilidad Mostrar métodos.

Figura 2 estructura del programa general RBF red Demo

using System;
namespace RadialNetworkTrain
{
  class RadialTrainProgram
  {
    static void Main(string[] args)
    {
      Console.WriteLine("Begin radial basis function (RBF) network training demo");
      double[][] allData = new double[30][];
      allData[0] = new double[] { -0.784, 1.255, -1.332, -1.306, 0, 0, 1 };
      allData[1] = new double[] { -0.995, -0.109, -1.332, -1.306, 0, 0, 1 };
      // Etc.
allData[28] = new double[] { 0.904, -1.473, 1.047, 0.756, 1, 0, 0 };
      allData[29] = new double[] { 1.431, 1.528, 1.209, 1.659, 1, 0, 0 };
      Console.WriteLine("First four and last line of normalized, encoded input data:");
      Helpers.ShowMatrix(allData, 4, 3, true, true);
      double[][] trainData = null;
      double[][] testData = null;
      int seed = 8; // Gives a good demo
      GetTrainTest(allData, seed, out trainData, out testData);
      Helpers.ShowMatrix(trainData, trainData.Length, 3, true, false);
      Helpers.ShowMatrix(testData, testData.Length, 3, true, false);
      int numInput = 4;
      int numHidden = 5;
      int numOutput = 3;
      RadialNetwork rn = new RadialNetwork(numInput, numHidden, numOutput);
      Console.WriteLine("Beginning RBF training");
      int maxIterations = 100; // Max for PSO
      double[] bestWeights = rn.Train(trainData, maxIterations);
      Console.WriteLine("Evaluating RBF accuracy on the test data");
      rn.SetWeights(bestWeights);
      double acc = rn.Accuracy(testData);
      Console.WriteLine("Classification accuracy = " + acc.ToString("F4"));
      Console.WriteLine("End RBF network training demo");
    }
    static void GetTrainTest(double[][] allData, int seed,
      out double[][] trainData, out double[][] testData) { .
.
}
  }
  public class RadialNetwork
  {
    private static Random rnd = null;
    private int numInput;
    private int numHidden;
    private int numOutput;
    private double[] inputs;
    private double[][] centroids;
    private double[] widths;
    private double[][] hoWeights;
    private double[] oBiases;
    private double[] outputs;
    public RadialNetwork(int numInput, int numHidden, int numOutput) { .
.
}
    private static double[][] MakeMatrix(int rows, int cols) { .
.
}
    public void SetWeights(double[] weights) { .
.
}
    public double[] GetWeights() { .
.
}
    private double MeanSquaredError(double[][] trainData,
      double[] weights) { .
.
}
    public double Accuracy(double[][] testData) { .
.
}
    private static int MaxIndex(double[] vector) { .
.
}
    public double[] ComputeOutputs(double[] xValues) { .
.
}
    private static double[] Softmax(double[] rawOutputs) { .
.
}
    public double[] Train(double[][] trainData, int maxIterations) { .
.
}
    private void DoCentroids(double[][] trainData) { .
.
}
    private static double AvgAbsDist(double[] v1, double[] v2,
      int numTerms) { .
.
}
    private int[] DistinctIndices(int n, int range) { .
.
}
    private void DoWidths(double[][] centroids) { .
.
}
    private double[] DoWeights(double[][] trainData, int maxIterations) { .
.
}
    private static double EuclideanDist(double[] v1, double[] v2,
      int numTerms) { .
.
}
    private static void Shuffle(int[] sequence) { .
.
}
  }
  public class Particle
  {
    // Implementation here
  }
  public class Helpers
  {
    // Implementation here
  }
}

Clase RadialNetwork no es tan complejo como la estructura del programa sugiere porque la mayoría de los métodos de clase son ayudantes. Método tren realiza el proceso de formación de tres fases por ayudantes llamando al DoCentroids, DoWidths y DoWeights. Métodos privados AvgAbsDist y DistinctIndices son ayudantes para DoCentroids. Método DoWeights utiliza método privado Shuffle para proceso formación los elementos de datos en un orden diferente cada vez mediante el algoritmo de optimización de enjambre de partículas iterativo.

El corazón de la demo es bastante simple. En primer lugar, los datos codificados y normalizados se configura:

double[][] allData = new double[30][];
allData[0] = new double[] { -0.784, 1.255, -1.332, -1.306, 0, 0, 1 };
allData[1] = new double[] { -0.995, -0.109, -1.332, -1.306, 0, 0, 1 };
// Etc.
allData[28] = new double[] { 0.904, -1.473, 1.047, 0.756, 1, 0, 0 };
allData[29] = new double[] { 1.431, 1.528, 1.209, 1.659, 1, 0, 0 };

Aquí los datos están codificado para la simplicidad. En la mayoría de los escenarios, sus datos se almacenarán en un archivo de texto o una tabla SQL. A continuación, los datos se divide en subconjuntos de entrenamiento y prueba:

double[][] trainData = null;
double[][] testData = null;
int seed = 8;
GetTrainTest(allData, seed, out trainData, out testData);

La red RBF se crea una instancia:

int numInput = 4;
int numHidden = 5;
int numOutput = 3;
RadialNetwork rn = new RadialNetwork(numInput,
   numHidden, numOutput);

Como se mencionó en la sección anterior, el número óptimo de nodos ocultos procesamiento debe determinarse esencialmente por ensayo y error. La red está capacitada:

int maxIterations = 100;
double[] bestWeights = rn.Train(trainData, maxIterations);

Y, finalmente, se evaluó el modelo resultante:

rn.SetWeights(bestWeights);
double acc = rn.Accuracy(testData);
Console.WriteLine("Classification accuracy = " +
  acc.ToString("F4"));

El array bestWeights contiene el RBF pesos y valores de sesgo según lo determinado por el método de tren. SetWeights método de carga estos pesos y valores de sesgo. No necesitas tener los centroides y anchuras explícitamente cargados porque estos valores fueron fijados por método de tren.

Función base radial red entrada-proceso-salida

Para entender el proceso de formación de red RBF, tienes que entender la red RBF input -­mecanismo de salida del proceso. El diagrama de la figura 3 muestra cómo la red RBF demo computa las salidas para el elemento de datos de prueba [1] = (0482 0.709 0.452, 0.498) después de que la red ha sido entrenada. Los valores x entrados pasan a cada nodo escondido. Cada nodo escondido calcula su producción local utilizando su propio centroide y ancho.

Arquitectura de red de función de base Radial figura 3

Por ejemplo, centroide del nodo escondido más arriba es (-0.362,-2.019, 0.074 0.112) y su anchura es 3.3318. Las salidas locales de cada nodo escondido luego se utilizan para determinar los valores de salida preliminar computando una suma ponderada de entradas, además de un valor de sesgo. Por ejemplo, si h [0] representa la salida local del nodo escondido 0, entonces la salida preliminar para el nodo de salida superior es (h [0] * w[0][0]) + (h [1] * w[1][0]) + (h [2] * w[2][0]) + (h [3] * w[3][0]) + (h [4] * w[4][0]) + sesgo [0] =-12.7999.

Después de los tres valores preliminares se han calculado, convierten a valores de salida final usando una función softmax. La idea es modificar los valores de salida preliminar los valores de salida final entre 0.0 y 1.0, y suma a 1.0. Esto permite que los valores de salida libremente interpretarse como probabilidades.

En figura 3, los productos finales son (0.2897, 0.6865, 0.0237). Porque el nodo central tiene el valor más alto, que se interpreta como un 1, y los otros dos valores se interpretan como 0, dando una salida inferida de (0, 1, 0). Recordar los datos de prueba (0482 0.709, 0.452 0.498, 0.000, 1.000, 0.000), donde los cuatro primeros valores son entradas y los tres últimos valores son los valores objetivo, entonces la red RBF hace una predicción correcta de las especies (Iris versicolor en este caso). La pregunta ahora es: ¿De dónde vienen los valores de la red RBF centroides, anchos, pesos y sesgos?

Determinación de los centroides de red RBF

El método del tren de la clase RadialNetwork es esencialmente un contenedor alrededor tres métodos auxiliares que hacen todo el trabajo real:

public double[] Train(double[][] trainData, int maxIterations)
{
  DoCentroids(trainData);
  DoWidths(this.centroids);
  double[] bestWeights = DoWeights(trainData, maxIterations);
  return bestWeights;
}

Método DoCentroids determina la entrada x-valores representativos. Hay muchas posibilidades. Un enfoque común es utilizar un algoritmo de agrupamiento medias k o k-medoids iterativamente asigna y reasigna los elementos de datos para que los elementos de datos similares se agrupan. Cuando haya terminado, cada cluster tendrá un miembro de datos representativos. Usted puede utilizar éstos como los centroides RBF.

Es un enfoque diferente para extraer los valores x de los elementos de datos formación seleccionados al azar. Esto es simple, pero tiene el riesgo que los centroides malos pueden ser seleccionados por casualidad.

El programa de demostración utiliza lo que podría denominarse un ligero enfoque sugerido por este pseudocódigo de clustering:

initialize maxDistance
intialize bestIndices
loop
  select numHidden random indices into train data
  compute an estimated distance between selected data items
  if estimated distance > maxDistance then
    set maxDistance = curr distance
    set bestIndices = curr indices
  end if
end loop
fetch the x-values in train data at bestIndices
store x-values into RBF centroids

La idea se ilustra mejor con el ejemplo. Supongamos que los datos del entrenamiento se compone de los 24 artículos mostrados en figura 1. Además suponga que el primer tiempo a través del tratamiento del lazo los cuatro seleccionados al azar los índices son [0], [1], [2] y [3]. Estas se corresponden con:

0: ( 1.537, -0.382,  1.317,  0.756)
  1: (-0.468,  2.346, -1.170, -1.048)
  2: ( 1.115,  0.164,  0.560,  0.370)
  3: ( 1.220,  0.436,  0.452,  0.241)

Estos son los centroides de candidato. La idea es conseguir x-valores representativos, que significa que no quieres los valores que están juntas. Entonces, usted calcular alguna medida de la distancia entre los centroides de candidato. Aquí hay muchos enfoques posibles. La demo estima una distancia media entre todos los pares posibles de los centroides candidato computando una distancia media entre pares adyacentes de los candidatos, en vez de computar una distancia media entre todos los pares posibles. En este ejemplo, computa las distancias entre los candidatos [0] y [1], entre [1] y [2] y entre [2] y [3].

Un enfoque común a una distancia de computación es utilizar distancia euclidiana, que es la raíz cuadrada de la suma de las diferencias al cuadrado entre los valores. (Nota: La red RBF demo utiliza un núcleo gaussiano, que utiliza la distancia euclidiana para calcular los valores de salida local de nodo escondido). Sin embargo, el programa de demostración utiliza una variación de la distancia de Manhattan, donde la distancia es un promedio de la diferencia de valores absolutos. Así, la distancia entre los candidatos [0] y [1] es:

d = abs(1.537 - (-0.468)) + .
.
.
+ abs(0.756 - (-1.048)) / 4
  = 2.256

El proceso de generar un conjunto de los centroides de candidato y computación una distancia promedio estimada para el conjunto de los candidatos se repite un número determinado de veces y el conjunto de candidatos con la mayor distancia promedio estimada es seleccionado como el conjunto de centroide RBF.

Tenga en cuenta que determinar los centroides red RBF puede considerarse una técnica de entrenamiento sin supervisión porque los valores objetivo (por ejemplo, 0, 1, 0) en los datos del entrenamiento no son necesarias o utilizados. Esto significa que pueden determinar rápidamente los centroides. Además, anchuras de red RBF, pesos y valores de sesgo pueden — en teoría al menos — ser computado mucho más rápidamente que la red neuronal más o menos equivalente pesos y valores de sesgo. Esto le da una ventaja potencial sobre redes neuronales a redes RBF (pero, como veremos, hay más en la historia).

Durante el proceso de determinación de los centroides de red RBF, determinar los índices de candidato es un interesante complejidades. El programa de demostración utiliza un algoritmo inteligente llamado muestreo de embalse. La idea es recoger los primeros índices n posibles, luego probabilísticamente reemplazar los índices iniciales con los restantes índices posibles:

private int[] DistinctIndices(int n, int range)
{
  // Reservoir sampling.
assumes rnd exists
  int[] result = new int[n];
  for (int i = 0; i < n; ++i)
    result[i] = i;
  for (int t = n; t < range; ++t) {
    int m = rnd.Next(0, t + 1);
    if (m < n) result[m] = t;
  }
  return result;
}

Aunque el método es corto, es sutil. Alternativas incluyen el uso de un enfoque de fuerza bruta donde se generan y luego revisa para ver si hay cualquier duplicados índices al azar.

Determinación de anchos de red RBF

El mecanismo de entrada-proceso-salida de red RBF requiere un valor de ancho para cada nodo escondido. Hay muchas posibilidades para la determinación de los valores de anchura. El enfoque más sencillo y el utilizado por el programa de demostración, es para calcular una anchura común, que pueden utilizar los nodos de procesamiento está oculto. Investigación en esta área tiende a ser confuso y conclusiones son a veces contradictorias. El programa de demostración calcula un ancho común como la media distancia euclídea entre todos los pares posibles de los centroides. En pseudocódigo:

sumOfDists = 0.0
for each pair of centroids
  accumulate Euclidean distance between curr pair
end loop
return accumulated sumOfDists / number of pairs

Basándome en mi experiencia, la eficacia de las redes RBF es extremadamente sensible a los valores utilizados para anchos de nodo escondido. La investigación muestra que tiende un ancho que es demasiado pequeño caber sobre los datos del entrenamiento, llevando a exactitud pobre clasificación. Un ancho que es demasiado grande tiende a debajo del ajuste los datos, que también conducen a la pobre clasificación. Si experimentas con el código de demostración ajustando manualmente los valores de las anchuras de red RBF, usted puede ver este efecto en acción.

Además de utilizar la distancia promedio entre los centroides, DProm, por un valor de anchura común los nodos ocultos, investigación también sugiere utilizar (2 * DProm), o (DProm / sqrt(2 * numHidden)) y muchos otros valores. Y en vez de usar un ancho común, hay muchas posibilidades para calcular los valores de ancho diferente para cada nodo escondido. En mi opinión, la alta sensibilidad de las redes a los valores de ancho, junto con la falta de convencer a los resultados de investigación sobre cómo calcular mejor los valores de anchura, son las principales desventajas del uso de redes RBF relacionado RBF comparado con alternativas tales como las redes neuronales y máquinas de vectores soporte.

Determinación de sesgos y RBF red pesos

Después de determinar los centroides y anchos, el paso final en la formación de una red RBF es determinar los valores de los pesos y sesgos. Teóricamente, usted puede calcular pesos red RBF fácilmente y rápidamente porque, hablando libremente, hay n ecuaciones con n valores desconocidos. Así, las técnicas numéricas estándar pueden, en teoría, utilizarse para resolver para los valores de peso.

Desafortunadamente, en la práctica, utilizando las técnicas estándar funciona en muchos problemas prácticos. Por ejemplo, muchas de las técnicas estándar para resolver sistemas de ecuaciones implican el uso de la inversión de la matriz. Inversión de la matriz puede fallar por muchas razones.

En lugar de usar una técnica numérica determinista pero posiblemente frágil para resolver para los pesos de red RBF exactamente, el programa de demostración utiliza optimización de enjambre de partículas para estimar los mejores valores. PSO es un comportamiento de grupo coordinado basado en meta-heurísticos, como bandadas de pájaros o cardúmenes de peces. En PSO, una partícula tiene una posición que representa una solución potencial (el mejor conjunto de los valores de peso en este caso). Cada partícula tiene una velocidad que determina la posición siguiente de la partícula.

En PSO, se crea un conjunto de partículas. En cada instante de tiempo simulado, cada partícula se mueve a una nueva posición basada en la posición actual de la partícula y la velocidad, la posición histórica más conocida de la partícula y la posición histórica más conocida de cualquiera de las partículas. Aquí es PSO en pseudocódigo de alto nivel:

set number of particles
set maxIterations
initialize all particles to random positions
loop maxIterations times
  for each particle
    update curr particle's velocity
    use new velocity to compute new position
    compute error for new position
    check if new particle best position
    check if new best position for all particles
  end for
end loop
return best position found by any particle

PSO es un tema apasionante en su propio derecho. Puedes aprender más sobre él por leer mi artículo de agosto de 2011, "Partículas Swarm Optimization" (msdn.microsoft.com/magazine/hh335067). PSO requiere la especificación de varios gratis param­parámetros, incluyendo constantes de peso que controlan la influencia relativa de la posición actual de una partícula, la mejor posición histórica y mejor posición histórica global. PSO también es necesario especificar el número de partículas, el número máximo de iteraciones y, opcionalmente, un umbral de error para la temprana salida del algoritmo. Puede experimentar con estos factores utilizando el código de demostración.

Además de PSO y técnicas numéricas tradicionales, existen muchas alternativas para encontrar pesos red RBF, incluyendo simple descenso de gradiente y los algoritmos genéticos valor real. Aunque se ha estudiado la teoría de redes RBF bastante exten­siado, hay relativamente pocos convincentes resultados de investigación sobre la eficacia comparativa de técnicas de entrenamiento diferentes.

En resumen

El código del programa demo junto con la explicación presentada aquí te dará una base sólida para la investigación de redes RBF. Aunque las redes RBF son bien conocidas en la comunidad de investigación, no parecen ser utilizado muy a menudo en la comunidad de desarrolladores de software en comparación con alternativas como clasificadores de redes neuronales, clasificadores de Bayes ingenuo y regresión logística. Una posible explicación para esto puede ser la escasez de ejemplos de aplicación práctica. Otra posible razón es la incertidumbre que rodea a RBF red factores fundamentales, especialmente las relacionadas con el cómputo de anchuras de red RBF. En mi opinión, no hay ninguna evidencia sólida investigación para responder a la pregunta de si las redes RBF son más eficaces, menos eficaces o más o menos equivalente a técnicas de aprendizaje máquina alternativas.

Dr.James McCaffrey trabajos de investigación de Microsoft en Redmond, Washington Ha trabajado en varios productos de Microsoft Internet Explorer y Bing. Puede ser contactado en jammc@microsoft.com.

Gracias al siguiente experto técnico por su ayuda en la revisión de este artículo: Kirk Olynyk (Microsoft Research)