Algoritmo de descenso de gradiente estocástico. Descenso de gradiente estocástico. El vector se actualiza después de cada iteración. La fórmula de actualización ahora se ve así

En esta conferencia discutiremos varias maneras implementación, sobre sus ventajas y desventajas. Me gustaría hablar sobre los tres tipos principales de descenso de gradiente: completo, por lotes y estocástico.

En la mayoría de los cursos anteriores utilizamos descenso en pendiente completa.

¿Por qué es así?

Porque esto es más útil si queremos maximizar la probabilidad de todo el conjunto de entrenamiento:

La desventaja de este enfoque es que calcular el gradiente lleva mucho tiempo, ya que depende de cada ejemplo (observación).

Todo lo contrario es estocástico. descenso de gradiente. Depende del error de una sola observación específica:

El método se basa en el hecho de que todas las observaciones son independientes y están distribuidas uniformemente, por lo que a largo plazo el error disminuirá porque todas las observaciones se toman de la misma distribución. En este caso, cuando los cálculos se redujeron de norte observaciones a 1, es una mejora notable en el método.

¿Cuál es la desventaja?

El hecho es que si con el descenso de gradiente completo el logaritmo de la función de probabilidad siempre mejora en cada iteración, entonces con el descenso estocástico el logaritmo de la función de probabilidad puede incluso empeorar. De hecho, el comportamiento de la función de costos cambiará caóticamente con cada iteración, pero a la larga seguirá disminuyendo.

Un buen compromiso entre estos dos métodos es el descenso de gradiente por lotes. Si tenemos, por ejemplo, 10.000 observaciones, entonces podemos dividirlas en 100 lotes de 100 observaciones cada uno y calcular la función de costo en función de cada lote en cada iteración:

¿Qué pasará con la función de costos en este caso?

También puede volverse más grande, pero será menos caótico que en el caso de un descenso de gradiente puramente estocástico.

Y me gustaría aprovechar esta oportunidad para señalar que si desea recibir material gratuito relacionado con el aprendizaje automático y profundo, así como con el procesamiento de datos, visite mi sitio web lazyprogrammer.me. Constantemente escribo contenido nuevo sobre estos temas, así que vuelve a consultarlo con frecuencia. Debería haber un mensaje para suscribirse, para que pueda registrarse para recibir mi introducción gratuita a la ciencia de datos. Está lleno de excelentes recursos para aprender Python, algoritmos y estructuras de datos, así como cupones para cursos sobre .

Descenso de gradiente completo, por lotes y estocástico en el código

Ahora comparemos el cambio en la función de costo en tres casos de descenso de gradiente: completo, por lotes y estocástico. Dado que este ejemplo tiene mucho código copiado de otros archivos, simplemente revisaremos el texto del programa uno por uno.

Entonces, al comienzo del archivo importamos todas las bibliotecas habituales. Desde archivo util.py estamos importando la función obtener_datos_transformados para transformar datos utilizando el análisis de componentes principales, así como funciones adelante, fecha_error, costo, gradW, gradb Y indicador y2.

importar numpy como np

importar pandas como pd

importar matplotlib.pyplot como plt

desde sklearn.utils importar aleatoriamente

desde fecha y hora importar fecha y hora

desde la utilidad import get_transformed_data, forward, error_rate, cost, gradW, gradb, y2indicator

Para acelerar el proceso, utilizamos en lugar de una red neuronal completa.

Entonces primero usamos la función obtener_datos_transformados, tomando solo las primeras 300 columnas. A continuación, normalizamos nuestra X restando la media y dividiéndola por la desviación estándar. Entonces, dado que la función obtener_datos_transformados Ya ha mezclado nuestros datos, dejamos los últimos 1000 ejemplos como un conjunto de prueba y usamos el resto como un conjunto de entrenamiento.

definición principal():

X, Y, _, _ = obtener_datos_transformados()

X = X[:, :300]

# normalizar X primero

mu = X.media( eje=0)

estándar = X.estándar( eje=0)

X = (X – mu) / estándar

imprimir “Realizando regresión logística...”

Xtren = X[:-1000,]

Ytren = Y[:-1000]

Xprueba = X[-1000:,]

N, D = Xtrain.forma

Ytrain_ind = y2indicator(Ytrain)

Ytest_ind = y2indicator(Ytest)

Luego iniciamos los coeficientes de ponderación y los términos ficticios. Tenga en cuenta que los pesos activados se establecen relativamente pequeños, proporcionales a la raíz cuadrada de la dimensión. Incluso antes de grabar este video, establecí el coeficiente de aprendizaje y la penalización de regularización en 0,0001 y 0,01, respectivamente. Estableceremos el número de iteraciones en 200 para que los cálculos no demoren demasiado.

#1.completo

b = np.ceros(10)

LL=

lr = 0,0001

registro = 0,01

t0 = fechahora.ahora()

para yo en rango x(200):

p_y = adelante(Xtrain, W, b)

A continuación, actualizamos los valores y los términos libres usando descenso de gradiente y. También usamos la función adelante para calcular el valor de la función de costo al pasar por el conjunto de entrenamiento. Mostraremos el valor de la tasa de error cada diez iteraciones. Además, mostraremos el tiempo dedicado a los cálculos, ya que uno de los métodos es muy rápido y el otro es muy lento.

W += lr*(gradW(Ytrain_ind, p_y, Xtrain) – reg*W)

b += lr*(gradb(Ytrain_ind, p_y) – reg*b)

LL.append(ll)

si yo % 10 == 0:

imprimir “Tasa de error:”, err

p_y = adelante(Xtest, W, b)

imprimir “Tiempo transcurrido para GD completo:”, datetime.now() – t0

En el caso del descenso de gradiente estocástico, hacemos prácticamente lo mismo, excepto que solo hacemos una pasada a través de los datos, ya que con el descenso de gradiente estocástico miramos solo un ejemplo y actualizamos los pesos y las intersecciones por separado en cada pasada, luego reorganizamos los datos. . Dado que si revisa todos los ejemplos, el programa funcionará muy lentamente, por lo que nos limitaremos a solo 500 ejemplos.

Luego, como de costumbre, calculamos el gradiente, actualizamos los pesos usando la regularización y calculamos la tasa de error, excepto que solo imprimimos el valor del coeficiente cada N/2 pases, ya que de lo contrario los cálculos serán muy largos. El resto es todo igual.

#2.estocástico

W = np.aleatorio.randn(D, 10) / 28

b = np.ceros(10)

LL_stochastic =

lr = 0,0001

registro = 0,01

t0 = fechahora.ahora()

para yo en rango x(1): # lleva mucho tiempo ya que estamos calculando el costo de 41 000 muestras

para n en rango x(min(N, 500)): # atajo para que no tarde tanto…

x = tmpX.reformar(1,D)

y = tmpY.reformar(1,10)

p_y = adelante(x, W, b)

p_y_test = adelante(Xtest, W, b)

ll = costo(p_y_test, Ytest_ind)

LL_stochastic.append(ll)

si n % (N/2) == 0:

err = tasa_error(p_y_test, Ytest)

imprimir “Costo en la iteración %d: %.6f” % (i, ll)

imprimir “Tasa de error:”, err

p_y = adelante(Xtest, W, b)

imprimir “final tasa de error:”, tasa_error(p_y, Ytest)

imprimir “Tiempo transcurrido para SGD:”, datetime.now() – t0

Con el descenso de gradiente por lotes, nuevamente, casi todo es igual. Establezcamos que cada paquete contiene 500 ejemplos, por lo que el número total de paquetes será igual a N dividido por el tamaño del paquete.

lote #3.

W = np.aleatorio.randn(D, 10) / 28

b = np.ceros(10)

LL_lote =

lr = 0,0001

registro = 0,01

lote_sz = 500

n_lotes = N/lote_sz

t0 = fechahora.ahora()

para yo en rango x(50):

tmpX, tmpY = aleatorio(Xtrain, Ytrain_ind)

para j en rango x(n_lotes):

x = tmpX

y = tmpY

p_y = adelante(x, W, b)

W += lr*(gradW(y, p_y, x) – reg*W)

b += lr*(gradb(y, p_y) – reg*b)

p_y_test = adelante(Xtest, W, b)

ll = costo(p_y_test, Ytest_ind)

LL_batch.append(ll)

si j % (n_lotes/2) == 0:

err = tasa_error(p_y_test, Ytest)

imprimir “Costo en la iteración %d: %.6f” % (i, ll)

imprimir “Tasa de error:”, err

p_y = adelante(Xtest, W, b)

imprimir “Tasa de error final:”, tasa_error(p_y, Ytest)

imprimir “Tiempo transcurrido para el lote GD:”, datetime.now() – t0

Y al final mostramos todos nuestros datos en pantalla.

x1 = np.linspace(0, 1, len(LL))

plt.plot(x1, LL, etiqueta=”lleno”)

x2 = np.linspace(0, 1, len(LL_stochastic))

plt.plot(x2, LL_stochastic, etiqueta=”estocástico”)

x3 = np.linspace(0, 1, len(LL_batch))

plt.plot(x3, LL_batch, etiqueta= "lote")

plt.leyenda()

plt.mostrar()

si __nombre__ == '__principal__':

Entonces, ejecutemos el programa.

Podemos ver que en el caso del descenso de gradiente estocástico el error apenas ha mejorado. Esto significa que se necesitan muchas más iteraciones para lograr mejoras con el descenso de gradiente estocástico. El descenso de gradiente completo, como podemos ver, converge más rápido que el descenso por lotes, pero también funciona más lento.

Si observamos la evolución de la función de costos a mayor escala, podemos ver que en el caso del descenso de gradiente por lotes no es muy suave, a diferencia del descenso de gradiente completo donde la función de costos cambia suavemente porque en este caso la función de costos es siempre decreciente. En el caso del descenso de gradiente estocástico, el cambio en la función de costos tampoco es suave:

Vistas de publicaciones: 588

El gradiente estocástico se estima mediante la fórmula:

es decir, es la suma de todos los vectores aleatorios con pesos iguales a los incrementos de la función que se minimiza en direcciones aleatorias dadas.

Si tomamos vectores unitarios como parámetros, entonces esta estimación de, como es fácil ver en (3.3.22), da el valor exacto del gradiente.

Ambas estimaciones de gradiente descritas se pueden utilizar de manera efectiva para cualquier valor, incluido y que los distingue significativamente del método de estimación determinista (3.3.22), para el cual la misma circunstancia confirma que los métodos deterministas se generalizan a los aleatorios (ver el final de). subsección 3.3.1). Pongamos otro ejemplo de tal generalización.

La búsqueda de gradiente (3.3.21) es un caso especial de al menos dos algoritmos de búsqueda aleatoria. Primer algoritmo:

donde sigue siendo un vector unitario de dimensiones aleatorias. Este es un conocido algoritmo de búsqueda aleatoria de gradientes. El segundo algoritmo tiene la forma (3.3.23), pero la estimación del gradiente se calcula mediante la fórmula

Cuando, como es fácil comprobar, ambos algoritmos degeneran en un algoritmo de búsqueda de gradiente (3.3.21).

Por tanto, la búsqueda aleatoria es una extensión, continuación y generalización natural de los métodos de búsqueda regulares conocidos.

Otra función de búsqueda aleatoria que se abre amplias oportunidades Para su uso efectivo, es utilizar el operador de paso aleatorio como modelo estocástico de operadores regulares complejos para encontrar direcciones de búsqueda en el espacio de parámetros optimizados.

Así, el algoritmo de búsqueda aleatoria con táctica lineal (3.3.12) es modelo estocástico algoritmo de descenso más pronunciado:

en el que un vector aleatorio modela la estimación del gradiente. Es curioso que tal "estimación" ni siquiera pueda considerarse aproximada, ya que sus propiedades estocásticas no se parecen a las propiedades del gradiente estimado. Sin embargo, como se muestra arriba, el algoritmo de búsqueda aleatoria no solo es eficiente, sino que en algunos casos es más eficiente que el algoritmo de descenso más pronunciado. Aquí

el operador de paso aleatorio reemplaza al engorroso operador de estimación de gradiente, por ejemplo, de acuerdo con la fórmula (3.3.22).

La siguiente característica de la búsqueda aleatoria que la distingue favorablemente de los métodos regulares es su globalidad, que se manifiesta principalmente en algoritmos de búsqueda aleatoria local que no están destinados a encontrar un extremo global. Por lo tanto, el algoritmo de descenso aleatorio puede encontrar un extremo global, pero el algoritmo de descenso más pronunciado regular, en principio, no permite esta posibilidad, ya que está diseñado para encontrar un extremo local.

En consecuencia, la globalidad de los algoritmos de búsqueda aleatoria es como una “prima” por el uso de la aleatoriedad y algo así como “ aplicación gratuita» al algoritmo. Esta circunstancia es especialmente importante al optimizar objetos con una estructura desconocida, cuando no hay total confianza en la naturaleza unixtremal del problema y la presencia de varios extremos es posible (aunque no esperada). Usar métodos de búsqueda global en este caso sería un desperdicio irrazonable. Los métodos de búsqueda aleatoria local son los más adecuados en este caso, ya que resuelven eficazmente problema local y puede, en principio, resolver uno global, si se produce. Esto proporciona a las búsquedas aleatorias una especie de fiabilidad psicológica muy valorada por los usuarios.

La simplicidad algorítmica de la búsqueda aleatoria la hace atractiva principalmente para los consumidores. La experiencia demuestra que algoritmos conocidos La búsqueda aleatoria es solo un "lienzo" en el que el usuario, en cada caso específico, "borda patrones" de nuevos algoritmos que reflejan no solo sus gustos e inclinaciones (que no pueden ignorarse), sino también las características específicas del objeto que se está optimizando. Esto último crea una base favorable para la implementación del conocido principio de que el algoritmo debe diseñarse "para el objeto". Finalmente, la simplicidad algorítmica de la búsqueda aleatoria determina la simplicidad de su implementación hardware. Esto no solo hace posible construir optimizadores simples, compactos y confiables con un número ilimitado de parámetros optimizados, sino que también hace que sea bastante sencillo organizar su síntesis óptima en una computadora.

Enviar su buen trabajo a la base de conocimientos es fácil. Utilice el siguiente formulario

buen trabajo al sitio">

Los estudiantes, estudiantes de posgrado y jóvenes científicos que utilicen la base de conocimientos en sus estudios y trabajos le estarán muy agradecidos.

Publicado en http://www.allbest.ru/

Ministerio de Educación y Ciencia de la Federación de Rusia

Institución Educativa Autónoma del Estado Federal

Educación superior

"UNIVERSIDAD FEDERAL DE KAZÁN (VOLGA)"

ESCUELA SECUNDARIA DE TECNOLOGÍAS DE LA INFORMACIÓN Y SISTEMAS DE INFORMACIÓN

TRABAJO DEL CURSO

Descenso de gradiente estocástico. Opciones de implementación

Introducción

El descenso de gradiente es un método para encontrar un extremo local (mínimo o máximo) de una función moviéndose a lo largo de un gradiente.

De todos los métodos de optimización local, es el más fácil de implementar. tiene bastante condiciones débiles convergencia, pero la velocidad de convergencia es bastante baja.

El descenso de gradiente es un algoritmo popular para amplia gama Modelos de aprendizaje automático, incluidas máquinas de vectores de soporte, regresión logística y modelos graficos. Combinado con el algoritmo. propagación hacia atrás, es un algoritmo estándar para entrenar redes neuronales artificiales. El descenso de gradiente estocástico compite con el algoritmo L-BFGS, que también se utiliza ampliamente. El descenso de gradiente estocástico se ha utilizado al menos desde 1960 para entrenar modelos de regresión, originalmente llamada Adaline.

El propósito de este trabajo del curso Es considerar la implementación de varias opciones para el descenso de gradiente estocástico, su posterior comparación y aclaración de las ventajas y desventajas.

1. Descenso del gradiente estocástico

El descenso de gradiente estocástico es un algoritmo de optimización y, a menudo, se utiliza para ajustar los parámetros de un modelo de aprendizaje automático.

El descenso de gradiente estándar utiliza un gradiente para cambiar los parámetros del modelo. El gradiente generalmente se calcula como la suma de los gradientes causados ​​por cada elemento de entrenamiento. El vector de parámetros cambia en la dirección del antigradiente con un paso dado. Por lo tanto, el descenso de gradiente estándar requiere un paso por los datos de entrenamiento antes de poder cambiar los parámetros.

En el descenso de gradiente estocástico, el valor del gradiente se aproxima mediante el gradiente de la función de costo calculada en un solo elemento de entrenamiento. Luego, los parámetros se cambian en proporción al gradiente aproximado. Por tanto, los parámetros del modelo se cambian después de cada objeto de aprendizaje. Para conjuntos de datos grandes, el descenso de gradiente estocástico puede proporcionar una ventaja de velocidad significativa sobre el descenso de gradiente estándar.

Existe un compromiso entre estos dos tipos de descenso de gradiente, a veces denominado "mini lote". En este caso, el gradiente se aproxima mediante la suma de una pequeña cantidad de muestras de entrenamiento.

1.1 Requisitos previos

Las estimaciones estadísticas y el aprendizaje automático consideran el problema de minimizar una función, que tiene la forma:

donde se debe estimar el parámetro que minimiza. Cada término generalmente se asocia con la i-ésima observación en el conjunto de datos (utilizado para el entrenamiento).

En estadística clásica, el problema de minimizar sumas surge en el método mínimos cuadrados, así como en el método de máxima verosimilitud (para observaciones independientes). La clase general de estimadores que resulta de minimizar sumas se llama estimador M. Sin embargo, en estadística se reconoce desde hace tiempo que el requisito de una minimización incluso local es demasiado restrictivo para algunos problemas de estimación de máxima verosimilitud. Por lo tanto, los teóricos estadísticos modernos a menudo consideran puntos estacionarios en la función de verosimilitud (ceros de la derivada, función de estimación y otras ecuaciones de estimación).

El problema de minimizar cantidades también surge al minimizar el riesgo empírico. En este caso, este es el valor de la función de pérdida para el i-set y el riesgo empírico.

Al minimizar una función, el descenso de gradiente estándar (o "por lotes") realizará las siguientes iteraciones:

¿Dónde está el tamaño del paso (a veces llamado tasa de aprendizaje en el aprendizaje automático)?

En muchos casos, la función sumando tiene un modelo simple que implica cálculos simples de la función suma y la suma de gradientes. Por ejemplo, en estadística, las familias exponenciales con un parámetro permiten cálculos económicos de funciones y gradientes.

Sin embargo, en otros casos, las estimaciones del gradiente total pueden requerir una estimación costosa de los gradientes de todas las funciones de término. Cuando el conjunto de entrenamiento es enorme y no existen fórmulas simples, estimar la suma de gradientes se vuelve muy costoso porque estimar el gradiente requiere estimar todos los gradientes de las funciones mediante sumando. Para ahorrar en el costo computacional en cada iteración, en el descenso de gradiente estocástico la muestra es un subconjunto de las funciones de los términos en cada paso. Esto es muy eficaz en caso de problemas de aprendizaje automático a gran escala.

1.2 método iterativo

En el descenso de gradiente estocástico, el gradiente verdadero se aproxima al gradiente de este ejemplo:

A medida que el algoritmo recorre rápidamente el conjunto de entrenamiento, realiza las actualizaciones anteriores para cada ejemplo de entrenamiento. Se pueden realizar varias pasadas sobre el conjunto de entrenamiento hasta que el algoritmo converja. Los datos se pueden mezclar en cada pasada para evitar bucles. Las implementaciones típicas pueden utilizar una tasa de aprendizaje adaptativa para que el algoritmo converja.

En pseudocódigo, el descenso de gradiente estocástico se puede representar de la siguiente manera:

1) Seleccione el vector de parámetros inicial y la tasa de aprendizaje.

2) Repetir hasta obtener aproximadamente el mínimo:

2.1) Mezcle aleatoriamente los ejemplos en el conjunto de entrenamiento.

2.2) Para i = 1,2,...,n, haga:

La convergencia del descenso del gradiente estocástico se analizó utilizando la teoría de minimización convexa y aproximación estocástica. Cuando la tasa de aprendizaje decae a un ritmo apropiado, y bajo supuestos relativamente débiles, el descenso del gradiente estocástico converge a un mínimo global cuando la función es convexa o pseudoconvexa, y en caso contrario converge a un mínimo local.

1.3 Opciones de implementación

Se han propuesto y utilizado muchas mejoras con respecto al método básico de descenso de gradiente estocástico. Particularmente en el aprendizaje automático, se ha considerado problemática la necesidad de establecer la tasa de aprendizaje (tamaño del paso).

Si establece este parámetro demasiado grande, puede provocar que el algoritmo diverja. Si es al revés, el algoritmo convergerá lentamente.

Una extensión conceptualmente simple del descenso de gradiente estocástico hace que la tasa de aprendizaje sea una función decreciente dependiendo del número de iteraciones m.

Una vez realizada esta operación, queda claro que las primeras iteraciones provocan grandes cambios en los parámetros, mientras que las posteriores sólo realizan ajustes finos.

En el marco de este trabajo, se considerarán las siguientes opciones para implementar el descenso de gradiente estocástico:

1. 4 impulso

El impulso, también conocido como método del impulso, se originó a partir del psicólogo estadounidense David Ramelhart, así como del trabajo de Geoffrey Hinton y el estudio de Ronald J. William sobre el método de retropropagación. El descenso de gradiente estocástico con impulso recuerda las actualizaciones en cada iteración y determina próxima actualización como una combinación lineal del gradiente y la actualización anterior:

Lo que lleva a:

donde se debe estimar el parámetro que minimiza y el tamaño del paso (a veces llamado tasa de aprendizaje en aprendizaje automático).

El nombre impulso proviene de una analogía con el impulso en física: un vector de peso. La idea de que el movimiento de un punto material a través del espacio de parámetros implica una aceleración debida a la fuerza, que es el gradiente de pérdida.

A diferencia del método clásico de descenso de gradiente estocástico, tiende a mantener el movimiento en una dirección, evitando oscilaciones. Momentum se ha utilizado con éxito durante varias décadas.

1.5 adagrad

AdaGrad es un descenso de gradiente estocástico modificado con parámetro preliminar velocidad de aprendizaje. Publicado por primera vez en 2011. De manera informal, aumenta la tasa de aprendizaje para los parámetros más dispersos y disminuye la tasa de aprendizaje para los menos dispersos. Esta estrategia a menudo mejora la probabilidad de convergencia en comparación con el algoritmo estándar de descenso de gradiente estocástico en lugares donde los datos son escasos y los parámetros escasos son más informativos.

Ejemplos de tales aplicaciones incluyen el procesamiento del lenguaje natural y el reconocimiento de patrones.

Todavía tiene una base de tasa de aprendizaje, pero se multiplica por los elementos de un vector que es la diagonal del producto tensorial de la matriz.

¿Dónde está el gradiente en la iteración m?

La diagonal se especifica como:

El vector se actualiza después de cada iteración. La fórmula de actualización ahora se ve así:

o escrito como una actualización preliminar de parámetros,

Cada uno aumenta la escalabilidad del factor de tasa de aprendizaje que se aplica a un solo parámetro.

Dado que el denominador es la norma euclidiana de las derivadas anteriores, los valores marginales de los parámetros de actualización están restringidos, mientras que los parámetros que han tenido pequeñas actualizaciones reciben un mayor nivel de aprendizaje.

Mientras se trabajaba en problemas de optimización convexos, AdaGrad se aplicó con éxito a problemas de optimización no convexos.

1.6 RMSProp

RMSProp también es un método en el que se adapta la tasa de aprendizaje para cada uno de los parámetros. La idea es dividir la tasa de aprendizaje para un peso particular por un promedio móvil de los últimos gradientes para ese peso. Así, la primera media móvil se calcula como un cuadrado:

¿Dónde está el parámetro de ponderación exponencial o el parámetro del “factor de olvido”?

Los parámetros se actualizan utilizando la siguiente fórmula:

RMSProp ha demostrado una excelente adaptación de las tasas de aprendizaje en diferentes aplicaciones. RMSProp puede considerarse como una generalización de Rprop y también es capaz de trabajar con una variante de descenso de gradiente como el mini-batch, que se opone al descenso de gradiente normal.

2. Implementación del descenso de gradiente estocástico.

En en esta etapa Las implementaciones de varias variantes del gradiente estocástico se llevarán a cabo en la forma. código de programa en el lenguaje de programación Python.

2.1 Implementación del descenso de gradiente estocástico estándar

Primero, necesitas un conjunto de datos. En este caso, se crea un conjunto de datos utilizando la biblioteca Scikit-Learn:

algoritmo de aprendizaje estocástico de gradiente

desde sklearn.datasets importar make_moons

desde sklearn.cross_validation importar train_test_split

X, y = hacer_lunas(n_muestras=5000, estado_aleatorio=42, ruido=0,1)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

Esto es lo que tenemos:

Figura 1 - Representación gráfica conjunto de datos

A continuación, se determina el modelo de red neuronal. Serán tres capas de la red (una capa oculta):

importar numpy como np

def crear_red(n_hidden=100):

modelo = dict(W1=np.random.randn(n_feature, n_hidden),

W2=np.random.randn(n_oculto, n_clase)

También define dos operaciones: propagación hacia adelante y propagación hacia atrás. Hagamos primero la primera opción:

devolver np.exp(x) / np.exp(x).sum()

def adelante(x, modelo):

h = x @modelo["W1"]

problema = softmax(h @ modelo["W2"])

El circuito debe realizar una serie de puntos desde la entrada hasta la capa oculta y luego hasta la capa de salida. En la capa oculta, también se puede aplicar la no linealidad para que la red neuronal pueda predecir un límite de decisión no lineal. Un representante destacado de una función no lineal en la actualidad es ReLU.

ReLU se define como f(x)=max(0,x), pero en lugar de hacer np.max(0, x), hay un ingenioso truco de implementación: x = 0.

Una vez que se ha alcanzado la capa de salida, la salida debe ser tal que la distribución de probabilidad de Bernoulli sea precisa, por lo que la salida se descomprime usando la función SoftMax para obtener la distribución dada.

Ahora la segunda operación está definida. La retropropagación se ve así:

def hacia atrás (modelo, xs, hs, errs):

dW2 = hs.T @ errores

dh = error @ modelo["W2"].T

dh = 0

retorno dict(W1=dW1, W2=dW2)

Se crea la base del algoritmo. La función sgd se está implementando. Se parece a esto:

def sgd(modelo, tren_X, tren_y, tamaño_lote):

para iter en rango (n_iter):

print("Iteración()".formato(iter))

Tren_X, tren_y = aleatorio(tren_X, tren_y)

para i en el rango (0, X_train.shape, lote_size):

X_tren_mini = X_tren

y_tren_mini = y_tren

modelo = sgd_step(modelo, X_train_mini, y_train_mini)

modelo de devolución

Se está implementando la función sgd_step. Se parece a esto:

def sgd_step(modelo, X_train, y_train):

grad = get_batch_grad(modelo, X_train, y_train)

modelo = modelo.copia()

para capa en grad:

modelo += tasa_aprendizaje * graduado

Se está implementando la función get_batch_grad. Se parece a esto:

def get_batch_grad(modelo, X_train, y_train):

xs, hs, errores = , ,

para x, cls_idx en zip(X_train, y_train):

h, y_pred = adelante(x, modelo)

y_true = np.zeros(n_clase)

y_verdadero = 1.

err = y_verdadero - y_pred

errores.append(err)

regresar hacia atrás (modelo, np.array(xs), np.array(hs), np.array(errs))

En esta función, cada punto de datos del lote se itera, luego se envía a la red y se compara el resultado de la etiqueta verdadera que se obtuvo con los datos de entrenamiento. El error está determinado por la diferencia entre la probabilidad de la etiqueta verdadera y la probabilidad de nuestra predicción.

2.2 Implementación de Momentum

El impulso funciona según el principio de la ley física del movimiento, pasa por óptimos locales (pequeñas colinas). Agregar impulso hará que el algoritmo converja más rápido a medida que se acumula la velocidad y el paso del método puede ser mayor que el paso constante en un método convencional.

Teniendo en cuenta que la plantilla del programa ya está lista, solo necesita implementar la función principal de este método. La función de impulso se da a continuación:

def impulso (modelo, tren_X, tren_y, tamaño_lote):

velocidad = (k: np.zeros_like(v) para k, v en model.items())

gama = .9

X_mini, y_mini = lotes

para capa en grad:

velocidad = gamma * velocidad + alfa * grad

modelo += velocidad

Se habilita una nueva variable de velocidad que acumulará impulso para cada parámetro. La variable se actualizará con el término alfa*grad en cada nuevo paso del descenso del gradiente. También hay una ligera disminución en el valor de la variable velocidad, que se calculó en el paso anterior, utilizando el coeficiente gamma.

2.3 Implementación de AdaGrad

Hasta ahora, la tasa de aprendizaje alfa se ignoraba porque era constante. El problema surge porque la tasa de aprendizaje afecta a todos los parámetros y el algoritmo no siempre funciona de manera eficiente a una tasa de aprendizaje constante. AdaGrad puede ser una solución a este problema.

Cuando se utiliza AdaGrad, las actualizaciones de parámetros se producen de forma puntual, por lo que la tasa de aprendizaje es un parámetro adaptativo.

La implementación de este método está en progreso. Todo el programa está listo, solo necesitas cambiar la función principal. Se llamará adagrad. La función se muestra a continuación:

def adagrad(modelo, tren_X, tren_y, tamaño_lote):

lotes = get_batch(X_train, y_train, lote_size)

para iter en rango (1, n_iter + 1):

idx = np.random.randint(0, len(lotes))

X_mini, y_mini = lotes

graduación = get_batch_grad(modelo, X_mini, y_mini)

caché[k] += graduado[k]**2

modelo de devolución

Puede ver que la tasa de aprendizaje se está normalizando. Ahora puede ser mayor o menor dependiendo de cómo se comporten los últimos gradientes.

2.4 Implementación de RMSProp

Puedes notar que en la parte acumulativa de Adagrad, el valor cache[k] += grad[k]**2 aumenta monótonamente como consecuencia de la suma y el cuadrado. Esto puede ser problemático ya que la tasa de aprendizaje disminuirá monótonamente a una tasa de aprendizaje muy pequeña.

Para combatir este problema, RMSProp descompone el valor de gradiente acumulado en el pasado para que solo se considere una parte de los gradientes más recientes. Ahora, en lugar de considerar todos los gradientes más recientes, RMSProp se comporta como una media móvil.

La implementación de este método está en progreso. Todo el programa está listo, solo necesitas cambiar la función principal. Se llamará rmsprop. La función se muestra a continuación:

def rmsprop(modelo, tren_X, tren_y, tamaño_lote):

caché = (k: np.zeros_like(v) para k, v en model.items())

gama = .9

lotes = get_batch(X_train, y_train, lote_size)

para iter en rango (1, n_iter + 1):

idx = np.random.randint(0, len(lotes))

X_mini, y_mini = lotes

graduación = get_batch_grad(modelo, X_mini, y_mini)

caché[k] = gamma * caché[k] + (1 - gamma) * (grado[k]**2)

modelo[k] += alfa * grad[k] / (np.sqrt(caché[k]) + eps)

La principal diferencia está en calcular el valor de caché [k] y ahora el valor de gradiente acumulado no aumentará de manera agresiva y monótona.

3. Pruebas y comparación

En este capítulo se probará la implementación y se analizarán los resultados obtenidos.

3.1 Prueba del descenso de gradiente estocástico estándar

En esta etapa, se probará el descenso de gradiente estocástico estándar. El procedimiento se realizará 100 veces y luego se calculará la precisión promedio.

n_experimento = 100

accesos = np.zeros(n_experimento)

para k en el rango (n_experimento):

modelo = hacer_red()

modelo = sgd(modelo, X_train, y_train, minibatch_size)

sonda = adelante (x, modelo)

y = np.argmax(problema)

Después de ejecutar este código, obtuve los siguientes valores:

Precisión media: 0,8765040000000001

Por tanto, podemos concluir que la precisión media de ejecución es del 87%.

3.2 Impulso de prueba

En esta etapa, se probará el descenso de gradiente estocástico en función de la implementación de Momentum. El procedimiento se realizará 100 veces y luego se calculará la precisión promedio.

El programa de pruebas se detalla a continuación:

n_experimento = 100

accesos = np.zeros(n_experimento)

para k en el rango (n_experimento):

modelo = hacer_red()

modelo = impulso (modelo, tren_X, tren_y, tamaño_minibatch)

y_pred = np.zeros_like(y_test)

para i, x en enumerar (X_test):

sonda = adelante (x, modelo)

y = np.argmax(problema)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Precisión promedio: (), Valor recibido: ()". formato(accs.mean(), accs.std()))

Precisión media:

1) 0,3152, con alfa = 0,5

2) 0,8554666666666666, con alfa = 1e-2

3) 0,8613333333333334, con alfa = 1e-5

Por lo tanto, podemos concluir que a valores más bajos de la tasa de aprendizaje, la precisión de la ejecución es notablemente mayor.

3.3 Pruebas adagrad

En esta etapa, probaremos el descenso de gradiente estocástico basado en la implementación de AdaGrad. El procedimiento se realizará 100 veces y luego se calculará la precisión promedio.

El programa de pruebas se detalla a continuación:

n_experimento = 100

accesos = np.zeros(n_experimento)

para k en el rango (n_experimento):

modelo = hacer_red()

modelo = adagrad(modelo, X_train, y_train, minibatch_size)

y_pred = np.zeros_like(y_test)

para i, x en enumerar (X_test):

sonda = adelante (x, modelo)

y = np.argmax(problema)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Precisión promedio: (), Valor recibido: ()". formato(accs.mean(), accs.std()))

Al ejecutar este código se obtienen los siguientes valores:

Precisión media:

1) 0,8754666666666667, con alfa = 0,5

2) 0,8786666666666667, con alfa = 1e-2

3) 0,504, con alfa = 1e-5

Por tanto, podemos concluir que a valores muy bajos de la tasa de aprendizaje, la precisión de la ejecución se reduce considerablemente.

3.4 Prueba de RMSProp

En esta etapa, se probará el descenso de gradiente estocástico en función de la implementación de RMSProp. El procedimiento se realizará 100 veces y luego se calculará la precisión promedio.

El programa de pruebas se detalla a continuación:

n_experimento = 100

accesos = np.zeros(n_experimento)

para k en el rango (n_experimento):

modelo = hacer_red()

modelo = rmsprop(modelo, X_train, y_train, minibatch_size)

y_pred = np.zeros_like(y_test)

para i, x en enumerar (X_test):

sonda = adelante (x, modelo)

y = np.argmax(problema)

accs[k] = (y_pred == y_test).sum() / y_test.size

print("Precisión promedio: (), Valor recibido: ()". formato(accs.mean(), accs.std()))

Al ejecutar este código se obtienen los siguientes valores:

Precisión media:

1) 0,8506666666666667, con alfa = 0,5

2) 0,8727999999999999, con alfa = 1e-2

3) 0,30693333333333334, con alfa = 1e-5

Por lo tanto, podemos concluir que a valores muy bajos de la tasa de aprendizaje, la precisión de su ejecución, similar a AdaGrad, se reduce considerablemente.

Conclusión

De análisis comparativo Está claro que cuando se utiliza una tasa de aprendizaje alta, los métodos con una tasa de aprendizaje adaptativa superan a los métodos con velocidad constante capacitación.

Sin embargo, ocurre lo contrario cuando se utiliza un valor de tasa de aprendizaje pequeño, como 1e-5. Para versión estándar El descenso de gradiente estocástico y el método del impulso, valores suficientemente pequeños les permiten funcionar bien. Por otro lado, si la tasa de aprendizaje es muy pequeña y está normalizada en métodos adaptativos La tasa de aprendizaje se vuelve aún más pequeña, lo que afecta la velocidad de convergencia. Esto hace que el entrenamiento sea muy lento y estos métodos funcionan peor que el descenso de gradiente estocástico estándar con el mismo número de iteraciones.

Lista de fuentes utilizadas

1. Aprendizaje automático: descenso de gradiente estocástico

2. Inteligencia artificial en ruso - Descensos en gradiente

3. Tutorial Wiki: Implementaciones de algoritmos/Descenso de gradiente

4. Universidad de Stanford: métodos adaptativos de subgradiente

5. Cambridge University Press: algoritmos en línea y aproximaciones estocásticas

6. Sanjoy Dasgupta y David Mcallester: sobre la importancia de la inicialización y el impulso en el aprendizaje profundo [recurso electrónico].

Publicado en Allbest.ru

...

Documentos similares

Requisitos previos extremo. Desarrollo de un algoritmo máquina y programa de optimización multidimensional para el método de gradiente utilizando el método de búsqueda uniforme. Comprobando las condiciones necesarias y suficientes para un extremo para el punto mínimo encontrado.

trabajo del curso, añadido el 25/09/2013


Implementación de software Aplicaciones para calcular funciones dadas. El procedimiento para encontrar el mínimo de una función. Aplicación de Hooke-Jeeves y métodos de descenso de gradiente para resolver el problema. Estudio de una función en las proximidades de un punto base, determinando sus coordenadas.

prueba, añadido el 02/02/2014


Optimización de la solución del problema mediante el algoritmo de recocido. Análisis de la teoría de la optimización como función objetivo. Método de descenso de gradiente. Variables y descripción del algoritmo de recocido. Representación del problema del viajante a través de una gráfica. Reducir el problema a variables y solucionarlo.

trabajo del curso, añadido el 21/05/2015


Entrenamiento de la red neuronal artificial más simple y multicapa. Método de entrenamiento de perceptrones basado en el principio de descenso de gradiente a lo largo de la superficie de error. Implementación en el producto software NeuroPro 0.25. Usando el algoritmo de retropropagación.

trabajo del curso, añadido el 05/05/2015


Resolver un problema de maximización de funciones de varias variables. Descripción del método de la dicotomía, su aplicación para resolver. ecuaciones no lineales. Resolviendo este problema utilizando el método de descenso de coordenadas. Elaboración de algoritmos, listado de programas.

trabajo del curso, añadido el 01/10/2009


Identificación de objetos mediante el método de mínimos cuadrados. Análisis de coeficientes de correlación par, parcial y múltiple. Construcción de un modelo lineal y un modelo con parámetros distribuidos. Método numérico iterativo para encontrar la raíz (cero) de una función determinada.

trabajo del curso, añadido el 20/03/2014


Base de la tecnología de uso. paquete de software LabVIEW, ventajas del sistema. Programación basada en arquitectura de flujo de datos. Métodos para encontrar el extremo. Utilizar el método de Gauss-Seidel para encontrar el máximo de una función bidimensional.

prueba, agregada el 18/03/2011


Finalidad y clasificación de los métodos. optimización de motores de búsqueda. Eficiencia método de búsqueda. Métodos de búsqueda de orden cero: entradas, condiciones, desventajas y aplicaciones. Estructura del método de búsqueda de gradiente. La idea principal del método de descenso más pronunciado.

conferencia, añadido el 04/03/2009


Planteamiento del problema y su formalización. Encontrar los valores del polinomio de interpolación en los puntos x1 y x2. Encontrar el mínimo de la función F(x) en el segmento. Comprobación de las condiciones de convergencia de métodos. Pruebas módulos de software. Diagrama detallado del algoritmo.

trabajo del curso, añadido el 04/02/2011


Métodos numéricos en tareas sin restricciones. Esquema de métodos de descenso. Entorno del editor Visual Básico. Uso de objetos ActiveX en formularios. Diagrama de flujo del algoritmo de simulación. Problemas de optimización para funciones deterministas con un solo punto extremo.

Dónde F i – función calculada en el i-ésimo lote, i se selecciona aleatoriamente;

El paso de aprendizaje es un hiperparámetro; cuando también valores grandes el algoritmo de aprendizaje divergirá; si es demasiado pequeño, convergerá lentamente.

Descenso de gradiente estocástico con inercia.

En el método de descenso de gradiente estocástico, no es raro que el gradiente cambie en gran medida en cada iteración. Esto se debe al hecho de que la funcionalidad se calcula a partir de diversos datos, que pueden diferir significativamente. Este cambio se puede suavizar si utilizamos los gradientes calculados en iteraciones anteriores y escalados por el hiperparámetro de inercia μ:

	(14)
	(15)

Como se puede imaginar, el hiperparámetro de inercia μ recibe este nombre debido a que, al igual que la llamada fuerza de inercia newtoniana, es decir fuerza contraria, “resiste” los cambios en el gradiente y mitiga los cambios en los coeficientes de ponderación a lo largo del entrenamiento. Este algoritmo de aprendizaje se denomina descenso de gradiente estocástico con impulso o SGDM (descenso de gradiente estocástico con impulso).

Método de gradiente adaptativo

El método de gradiente adaptativo (Adagrad, del inglés "algoritmo de gradiente adaptativo") se basa en la idea de escalar. Cambia la escala de la tasa de aprendizaje para cada parámetro ajustable individualmente, teniendo en cuenta el historial de todos los gradientes anteriores para ese parámetro. Para hacer esto, cada elemento del gradiente se divide en raíz cuadrada de la suma de los cuadrados de los elementos de gradiente correspondientes anteriores. Este enfoque reduce efectivamente la tasa de aprendizaje para aquellos pesos que tienen gran valor gradiente y también reduce la tasa de aprendizaje de todos los parámetros a lo largo del tiempo, ya que la suma de cuadrados aumenta constantemente para todos los parámetros en cada iteración. Cuando se establece un parámetro de escala inicial cero g = 0, la fórmula para recalcular los coeficientes de ponderación tiene la forma (la división se realiza elemento por elemento).

SVM

Máquina de vectores de soporte(ing. SVM, máquina de vectores de soporte): un conjunto de algoritmos de aprendizaje supervisado similares utilizados para problemas de clasificación y análisis de regresión. Pertenece a la familia de clasificadores lineales, también puede considerarse como ocasión especial regularización según Tikhonov. La propiedad especial de la máquina de vectores de soporte es reducir continuamente el error de clasificación empírica y aumentar la brecha, por lo que el método también se conoce como método clasificador de brecha máxima.

La idea principal del método es transferir los vectores originales a un espacio de dimensiones superiores y buscar un hiperplano de separación con un espacio máximo en este espacio. Se construyen dos hiperplanos paralelos a ambos lados del hiperplano que separa nuestras clases. El hiperplano de separación será el hiperplano que maximice la distancia a dos hiperplanos paralelos. El algoritmo opera bajo el supuesto de que lo que más diferencia o la distancia entre estos hiperplanos paralelos, menor será el error promedio del clasificador.

A menudo, en los algoritmos de aprendizaje automático existe la necesidad de clasificar datos. Cada objeto de datos se representa como un vector (punto) en un espacio de dimensiones (una secuencia de p números). Cada uno de estos puntos pertenece sólo a una de las dos clases. Nos interesa saber si podemos separar puntos mediante una dimensión de hiperplano. Este es un caso típico de separabilidad lineal. Puede haber muchos de esos hiperplanos. Por lo tanto, es natural creer que maximizar la brecha entre clases conduce a una clasificación más segura. Es decir, ¿podemos encontrar un hiperplano tal que la distancia desde él al punto más cercano sea máxima? Esto significaría que la distancia entre los dos puntos más cercanos que se encuentran en lados opuestos del hiperplano es máxima. Si tal hiperplano existe, entonces será el que más nos interesará; se denomina hiperplano de separación óptima y el clasificador lineal correspondiente se denomina clasificador de separación óptima.

Formalmente, el problema se puede describir de la siguiente manera.

Suponemos que los puntos tienen la forma: , donde toma el valor 1 o?1, según a qué clase pertenezca el punto. Cada uno es un vector real de dimensiones, generalmente normalizado por los valores o. Si los puntos no están normalizados, entonces un punto con grandes desviaciones de las coordenadas promedio del punto influirá demasiado en el clasificador. Podemos pensar en esto como una colección de entrenamiento en la que a cada elemento ya se le asigna la clase a la que pertenece. Queremos que el algoritmo de la máquina de vectores de soporte los clasifique de la misma manera. Para ello construimos un hiperplano de separación, que tiene la forma:

Un vector es perpendicular al hiperplano de separación. El parámetro es igual en valor absoluto a la distancia desde el hiperplano al origen. Si el parámetro es cero, el hiperplano pasa por el origen, lo que restringe la solución.

Como estamos interesados ​​en la separación óptima, nos interesan los vectores de soporte y los hiperplanos que son paralelos al óptimo y más cercanos a los vectores de soporte de las dos clases. Se puede demostrar que estos hiperplanos paralelos se pueden describir mediante las siguientes ecuaciones (hasta la normalización).

Si el conjunto de entrenamiento es linealmente separable, entonces podemos elegir hiperplanos de modo que ningún punto del conjunto de entrenamiento se encuentre entre ellos y luego maximizar la distancia entre los hiperplanos. El ancho de la franja entre ellos es fácil de encontrar por consideraciones geométricas y es igual, por lo que nuestra tarea es minimizarlo. Para excluir todos los puntos de la franja, debemos asegurarnos de que todo eso

Esto también se puede escribir como:

En el caso de separabilidad lineal de clases, el problema de construir un hiperplano de separación óptimo se reduce a la minimización bajo la condición (1). Este es un problema de optimización cuadrática que tiene la forma:

Según el teorema de Kuhn-Tucker, este problema es equivalente problema dual Buscando el punto silla de la función de Lagrange.

¿Dónde está un vector de variables duales?

Reduzcamos este problema a un problema de programación cuadrática equivalente que contenga solo variables duales:

Digamos que decidimos esta tarea, entonces puedes encontrarlo usando las fórmulas:

Como resultado, el algoritmo de clasificación se puede escribir como:

En este caso, la suma no se realiza en toda la muestra, sino sólo en los vectores de soporte, para los cuales

En el caso de inseparabilidad lineal de clases, para que el algoritmo funcione, le permitimos cometer errores en el conjunto de entrenamiento. Introduzcamos un conjunto de variables adicionales que caracterizan la magnitud del error en los objetos. Tomemos (2) como punto de partida, suavicemos las restricciones de desigualdad y también introduzcamos una penalización por el error total en el funcional minimizado:

El coeficiente es un parámetro de configuración del método que le permite ajustar la relación entre maximizar el ancho de la banda de separación y minimizar el error total.

De manera similar, utilizando el teorema de Kuhn-Tucker, reducimos el problema a encontrar el punto silla de la función de Lagrange:

Por analogía, reducimos este problema a uno equivalente:

En la práctica, para construir una máquina de vectores soporte, resuelven precisamente este problema, y ​​no (3), ya que pueden garantizar la separabilidad lineal de puntos en dos clases en caso general no es posible. Esta versión del algoritmo se llama algoritmo SVM de margen suave, mientras que en el caso linealmente separable lo llaman SVM de margen duro.

Para el algoritmo de clasificación se mantiene la fórmula (4), con la única diferencia de que ahora no sólo los objetos de referencia, sino también los objetos intrusos tienen valores distintos de cero. En cierto sentido, esto es una desventaja, ya que los infractores suelen ser las emisiones de ruido, y una norma decisiva basada en ellas se basa, de hecho, en el ruido.

La constante suele elegirse según el criterio de control del deslizamiento. Este es un método que consume mucho tiempo, ya que el problema debe resolverse de nuevo para cada valor.

Si hay motivos para creer que la muestra es casi linealmente separable y sólo los objetos atípicos se clasifican incorrectamente, entonces se puede aplicar el filtrado de valores atípicos. Primero, el problema se resuelve para un determinado C y se elimina de la muestra una pequeña proporción de objetos con el mayor error. Después de esto, el problema se resuelve nuevamente utilizando una muestra truncada. Puede que sea necesario realizar varias iteraciones hasta que los objetos restantes sean linealmente separables.

El algoritmo para construir un hiperplano de separación óptimo, propuesto en 1963 por Vladimir Vapnik y Alexey Chervonenkis, es un algoritmo de clasificación lineal. Sin embargo, en 1992, Bernhard Boser, Isabelle Guyon y Vapnik propusieron una forma de crear un clasificador no lineal basado en la transición de productos escalares a núcleos arbitrarios, el llamado truco del núcleo (propuesto por primera vez por M.A. Aizerman, E.M. Bravermann y L. V . Rozonoer para el método de funciones potenciales), que permite la construcción de separadores no lineales. El algoritmo resultante es extremadamente similar al algoritmo de clasificación lineal, con la única diferencia de que cada producto escalar en las fórmulas anteriores se reemplaza por una función central no lineal (un producto escalar en un espacio de dimensiones superiores). Es posible que en este espacio ya exista un hiperplano de separación óptimo. Dado que la dimensión del espacio resultante puede ser mayor que la dimensión del espacio original, la transformación que compara productos punto, será no lineal, lo que significa que la función correspondiente al hiperplano de separación óptimo en el espacio original también será no lineal.

Vale la pena señalar que si el espacio original tiene una dimensión suficientemente alta, entonces se puede esperar que la muestra que contiene sea linealmente separable.

Los núcleos más comunes:

1. Núcleo lineal:

2. Polinomio (homogéneo):

3.Función RBF:

4. Sigmoide:

En el marco de la tarea que tenemos ante nosotros, utilizaremos un núcleo lineal homogéneo. este núcleo presentado excelentes resultados en las tareas de clasificación de documentos, aunque en comparación con el clasificador Naive Bayes, entrenar este clasificador lleva un período de tiempo relativamente largo. El funcionamiento de todos los demás núcleos de esta lista y se descubrió que su entrenamiento requiere un período de tiempo significativamente más largo, sin mejorar mucho la precisión de la clasificación.

Para acelerar el entrenamiento, utilizaremos un método llamado Descenso de gradiente estocástico, que nos permite acelerar significativamente el entrenamiento del clasificador sin sacrificar gran parte de su precisión.

Descenso del gradiente estocástico

Los métodos de gradiente son una amplia clase de algoritmos de optimización que se utilizan no solo en el aprendizaje automático. Aquí, el enfoque del gradiente se considerará como una forma de seleccionar un vector de pesos sinápticos en un clasificador lineal. Sea la dependencia objetivo conocida solo de los objetos del conjunto de entrenamiento:

Encontremos un algoritmo que se aproxime a la dependencia. En el caso de un clasificador lineal, el algoritmo requerido tiene la forma:

donde juega el papel de la función de activación (en el caso más simple que podemos poner).

Según el principio de minimizar el riesgo empírico, basta con resolver el problema de optimización:

Dónde - función dada pérdidas.

Para minimizar, utilizamos el método de descenso de gradiente. Este algoritmo paso a paso, en cada iteración el vector cambia en la dirección de la mayor disminución del funcional (es decir, en la dirección del antigradiente):

Donde hay un parámetro positivo llamado tasa de aprendizaje.

Hay dos enfoques principales para implementar el descenso de gradiente:

1. Por lotes, cuando en cada iteración la muestra de entrenamiento se ve en su totalidad y solo después se cambia. Esto requiere grandes costos computacionales.

2. Estocástico (estocástico/en línea), cuando en cada iteración del algoritmo solo se selecciona un objeto de la muestra de entrenamiento de alguna manera (aleatoria). Así, el vector se ajusta a cada objeto recién seleccionado.

Puede representar el algoritmo de descenso de gradiente estocástico en pseudocódigo de la siguiente manera:

· - muestra de entrenamiento

· - ritmo de aprendizaje

· - parámetro de suavizado funcional

1. Vector de pesos

1) Inicializar pesos

2) Inicializar la evaluación funcional actual:

3) Repetir:

1. Selecciona un objeto al azar

2. Calcular valor de salida algoritmo y error:

3. Haz un paso de descenso en gradiente

4. Evaluar el valor de la funcionalidad:

4) Hasta que el valor se estabilice y/o los pesos dejen de cambiar.

La principal ventaja de SGD es su velocidad de aprendizaje con datos excesivamente grandes. Esto es precisamente lo que nos interesa en el marco de la tarea que se nos ha asignado, porque el volumen de datos de entrada será muy grande. Al mismo tiempo, el algoritmo SGD, a diferencia del clásico descenso de gradiente por lotes, proporciona una precisión de clasificación ligeramente menor. Además, el algoritmo SGD no es aplicable cuando se entrena una máquina de vectores de soporte con un núcleo no lineal.

Conclusiones

Como parte del problema que se está resolviendo, necesitaremos utilizar el algoritmo de conversión de datos de origen TF-IDF, que nos permitirá aumentar el peso de los eventos raros y reducir el peso de los eventos frecuentes. Transferiremos los datos obtenidos tras la transformación a clasificadores adecuados para resolver el problema que nos enfrentamos, a saber: Clasificador Naive Bayes o Máquina de vectores de soporte con núcleo lineal, entrenados mediante el método de descenso de gradiente estocástico. También probaremos la efectividad de una máquina de vectores de soporte con núcleos no lineales entrenados utilizando el método de descenso de gradiente por lotes. Sin embargo, este tipo El clasificador no parece adecuado para la tarea debido al núcleo demasiado complejo y la tendencia al sobreajuste, en la que el clasificador tiene un rendimiento deficiente en datos que no se utilizaron para entrenar al clasificador.

datos de preprocesamiento de la máquina de software