learninspy.core package¶

Éste es el módulo principal o el núcleo del framework, y contiene clases relacionadas con la construcción de redes neuronales profundas, desde el diseño de la arquitectura hasta la optimización del desempeño en las tareas asignadas.

Submódulos¶

learninspy.core.activations¶

En este módulo se pueden configurar las funciones de activación que se deseen. Para ello, simplemente se codifica tanto la función como su derivada analítica (o aproximación, como en el caso de la ReLU). Luego se insertan en los diccionarios de funciones correspondientes, que se encuentran al final del script, con una key común que identifique la activación.

Nota

Las derivadas deben tener un underscore “_” de prefijo en su nombre, de forma que no sean parte de la API.

learninspy.core.activations.identity(z)[fuente]¶

Lineal o identidad

$f(z)=z$

learninspy.core.activations.tanh(z)[fuente]¶

Tangente Hiperbólica

$f(z)=\dfrac{e^z - e^{-z}}{e^z + e^{-z}}$

learninspy.core.activations.sigmoid(z)[fuente]¶

Sigmoidea

$f(z)=\dfrac{1}{1 + e^{-z}}$

learninspy.core.activations.relu(z)[fuente]¶

Rectifier Linear Unit (ReLU)

$f(z)=max(0,z)$

learninspy.core.activations.leaky_relu(z)[fuente]¶

Leaky ReLU

$f(z) = \begin{cases}z & z > 0 \\ 0.01z & z \leq 0\end{cases}$

learninspy.core.activations.softplus(z)[fuente]¶

Softplus

$f(x)=\log{(1+e^z)}$

learninspy.core.activations.lecunn_sigmoid(z)[fuente]¶

Sigmoidea propuesta por LeCunn en [lecun2012efficient].

$f(z)=1.7159 tanh(\dfrac{2z}{3})$

En dicha definicion, se escala una función Tanh de forma que se obtenga máxima derivada segunda en valor absoluto para z=1 y z=-1, lo cual mejora la convergencia del entrenamiento, y una efectiva ganancia de dicha transformación cerca de 1.

[lecun2012efficient]

LeCun, Y. A. et. al (2012). Efficient backprop. In Neural networks: Tricks of the trade (pp. 9-48). Springer Berlin Heidelberg. http://yann.lecun.com/exdb/publis/pdf/lecun-89.pdf

learninspy.core.autoencoder¶

Este módulo provee las clases utilizadas para modelar redes neuronales relacionadas a autoencoders (e.g. AutoEncoder, StackerAutoencoder). Es por ello que se corresponde a un caso o herencia del módulo principal model, donde se sobrecargan las funcionalidades de dicho módulo para adaptarlas al diseño de autoencoders.

class learninspy.core.autoencoder.AutoEncoder(params=None, list_layers=None, dropout_in=0.0)[fuente]¶

Bases: learninspy.core.model.NeuralNetwork

Tipo de red neuronal, compuesto de una capa de entrada, una oculta, y una de salida. Las unidades en la capa de entrada y la de salida son iguales, y en la capa oculta se entrena una representación de la entrada en distinta dimensión, mediante aprendizaje no supervisado y backpropagation. A las conexiones entre la capa de entrada y la oculta se le denominan encoder, y a las de la oculta a la salida se les llama decoder.

Para más información, ver http://ufldl.stanford.edu/wiki/index.php/Autoencoders_and_Sparsity

Parámetros:	params – model.NeuralNetworkParameters, donde se especifica la configuración de la red. list_layers – list de model.NeuralLayer, en caso de usar capas ya inicializadas. dropout_in – radio de DropOut usado para el encoder (el decoder no debe sufrir DropOut).

>>> ae_params = NetworkParameters(units_layers=[5,3], activation='Tanh', \ ...
>>>                               dropout_ratios=None, classification=False)
>>> ae = AutoEncoder(ae_params)

encode(x)[fuente]¶

Codifica la entrada x, transformando los datos al pasarlos por el encoder.

Parámetros:	x – list of LabeledPoints.
Devuelve:	list of numpy.ndarray

encoder_layer()[fuente]¶: Devuelve la capa de neuronas correspondiente al encoder.

evaluate(data, predictions=False, measure=None)[fuente]¶

Evalúa el AutoEncoder sobre un conjunto de datos, lo que equivale a medir su desempeño en reconstruir dicho conjunto de entrada.

Parámetros:	data – list de LabeledPoint o instancia de `LabeledDataSet`. predictions – si es True, retorna las predicciones (salida reconstruida por el AutoEncoder). measure – string, key de alguna medida implementada en `RegressionMetrics`.
Devuelve:	resultado de evaluación, y predicciones si se solicita en predictions

class learninspy.core.autoencoder.StackedAutoencoder(params, list_layers=None, dropout=None)[fuente]¶

Bases: learninspy.core.model.NeuralNetwork

Estructura de red neuronal profunda, donde los parámetros de cada capa son inicializados con los datos de entrenamiento mediante instancias de AutoEncoder.

Para más información, ver http://ufldl.stanford.edu/wiki/index.php/Stacked_Autoencoders

Parámetros:	params – `NetworkParameters`, donde se especifica la configuración de la red. list_layers – list de `NeuralLayer`, en caso de querer usar capas ya inicializadas. dropout – ratio de DropOut a utilizar en el encoder de cada `AutoEncoder`.

finetune(train, valid, mini_batch=50, parallelism=0, valid_iters=10, measure=None, stops=None, optimizer_params=None, reproducible=False, keep_best=False)[fuente]¶: Ajuste fino con aprendizaje supervisado de la red neuronal, cuyos parámetros fueron inicializados mediante el pre-entrenamiento de los autoencoders.

Nota

Dado que esta función es una sobrecarga del método original fit(), se puede remitir a la documentación de esta última para conocer el significado de los parámetros.

fit(train, valid=None, mini_batch=50, parallelism=0, valid_iters=10, measure=None, stops=None, optimizer_params=None, reproducible=False, keep_best=False)[fuente]¶: Fit de cada autoencoder usando conjuntos de entrenamiento y validación, y su apilado para pre-entrenar la red neuronal profunda con aprendizaje no supervisado. Finalmente se entrena un clasificador Softmax sobre la salida del último autoencoder entrenado.

Nota

Dado que esta función es una sobrecarga del método original fit(), se puede remitir a la documentación de esta última para conocer el significado de los parámetros.

predict(x)[fuente]¶

Predicciones sobre una entrada de datos (singular o conjunto).

Parámetros:	x – numpy.ndarray o pyspark.mllib.regression.LabeledPoint, o list de ellos.
Devuelve:	numpy.ndarray

learninspy.core.loss¶

En este módulo se proveen dos funciones de costo populares, cuyo uso se corresponde a la tarea designada para el modelo:

Clasificación: Entropía Cruzada (en inglés, Cross Entropy o CE),

Regresión: Error Cuadrático Medio (en inglés, Mean Squared Error o MSE).

Para agregar otra a este módulo se debe definir la funcion de error ‘fun(o, t)’ y su derivada ‘_fun_d(o, t)’ respecto a la entrada x, siendo ‘o(x)’ la activación de dicha entrada (llamada salida real) y ‘t’ la salida esperada.

Nota

Las derivadas deben tener un underscore “_” de prefijo en su nombre, de forma que no sean parte de la API.

learninspy.core.loss.cross_entropy(o, t)[fuente]¶

Función de Entropía Cruzada, usada para medir el error de clasificación en una regresión Softmax.

La entrada o es un arreglo de K x 1 que representa la salida real de una clasificación realizada por la función Softmax sobre un ejemplo dado, y t es la salida esperada en dicha clasificación. Siendo K la cantidad de clases posibles a predecir, el arreglo t corresponde a un vector binario de dimensión K (obtenido por label_to_vector()), por lo cual se aplica en forma directa la función de CE que resulta en el costo asociado a la predicción.

$J=-\displaystyle\sum\limits_{k}^K \left(t_k \log(o_k) \right)$

Parámetros:	o – numpy.ndarray t – numpy.ndarray
Devuelve:	float

Nota

el arreglo o debe ser generado por la función softmax().

learninspy.core.loss.mse(o, t)[fuente]¶

Función de Error Cuadrático Medio. Ver más info en Wikipedia: Mean squared error

Las entradas o y t son arreglos que corresponden respectivamente a la salida real y la esperada de una predicción realizada sobre un ejemplo. La función devuelve el error cuadrático medio asociado a dicha predicción. Notar que la constante 1/2 es incluida para que se cancele con el exponente en la función derivada.

$J=\dfrac{1}{2}\displaystyle\sum\limits_{j} (t_j - y_j)^2$

Parámetros:	o – numpy.ndarray t – numpy.ndarray
Devuelve:	float

learninspy.core.model¶

Este es el módulo principal del framework, donde se proveen las clases referidas al modelado de redes neuronales. El mismo consta de clases para crear una red neuronal, su composición de capas de neuronas, y la configuración de la misma mediante la especificación de parámetros.

Capas neuronales¶

class learninspy.core.model.NeuralLayer(n_in, n_out, activation='ReLU', distributed=False, w=None, b=None, rng=None)[fuente]¶

Bases: object

Clase básica para modelar una capa de neuronas que compone una red neuronal. Contiene sus «neuronas» representadas por pesos sinápticos w y b, además de una función de activación asociada para dichos pesos.

Una correcta inicialización de los pesos sinápticos está muy ligada a la función de activación elegida:

Por defecto, los pesos sinápticos se inicializan con una distribución uniforme con media 0 y varianza $\tfrac{2.0}{\sqrt{n_{in}}}$ , lo cual da buenos resultados especialmente usando ReLUs.
Para la función Tanh se muestrea sobre una distribución uniforme en el rango $\pm \sqrt{\frac{6}{n_{in}+n_{out}}}$ .
Para la Sigmoid en el rango $\pm 4.0 \sqrt{\frac{6}{n_{in}+n_{out}}}$ .

Parámetros:

n_in – int, dimensión de la entrada.
n_out – int, dimensión de la salida.
activation – string, key de alguna función de activación soportada en activations.
distributed – si es True, indica que se utilicen arreglos distribuidos para w y b.
w – LocalNeurons, matriz de pesos sinápticos. Si es None, se crea por defecto.
b – LocalNeurons, vector de pesos bias. Si es None, se crea por defecto.
rng – si es None, se crea un generador de números aleatorios mediante una instancia numpy.random.RandomState.

Nota

el parámetro distributed no tiene efecto, ya que el uso de arreglos distribuidos se deja para un próximo release.

>>> n_in, n_out = (10, 5)
>>> layer = NeuralLayer(n_in, n_out, activation='Tanh')
>>> x = np.random.rand(n_in)
>>> out = layer.output(x)
>>> len(out)
5

class learninspy.core.model.ClassificationLayer(n_in, n_out, activation='ReLU', distributed=False, w=None, b=None, rng=None)[fuente]¶

Bases: learninspy.core.model.NeuralLayer

Clase correspondiente a la capa de salida en una red neuronal con tareas de clasificación. Se distingue de una RegressionLayer en que para realizar la clasificación se define que la activación se de por la función softmax.

class learninspy.core.model.RegressionLayer(n_in, n_out, activation='ReLU', distributed=False, w=None, b=None, rng=None)[fuente]¶

Bases: learninspy.core.model.NeuralLayer

Clase correspondiente a la capa de salida en una red neuronal con tareas de regresión, utilizando la función de activación como salida de la red.

Nota

No es recomendado utilizar Dropout en las capas de una red neuronal con tareas de regresión.

Red neuronal¶

class learninspy.core.model.NeuralNetwork(params, list_layers=None)[fuente]¶

Bases: object

Clase para modelar una red neuronal. La misma soporta funcionalidades para configuración y diseño, y para la optimización y testeo sobre un conjunto de datos cargado. Además ofrece funciones para cargar y guardar un modelo entrenado.

Parámetros:	params – `NetworkParameters`, parámetros que configuran la red. list_layers – list of `NeuralLayer`, en caso de que se utilicen capas de neuronas ya creadas.

check_stop(epochs, criterions, check_all=False)[fuente]¶

Chequeo de los criterios de cortes definidos sobre la información del ajuste en una red neuronal.

Parámetros:	epochs – int, número de épocas efectuadas en el ajuste de la red criterions – list de criterion, instanciados desde `stops`. check_all – bool, si es True se devuelve un AND de todos los criterios y si es False se utiliza un OR.
Devuelve:	bool, indicando True si los criterios señalan que se debe frenar el ajuste de la red.

cost_overall(data)[fuente]¶

Costo promedio total de la red neuronal para un batch de M entradas {features, label}, dado por:

$C(W, b; x, y) = \dfrac{1}{M} \displaystyle\sum\limits_{i}^M C_{FP}(W, b; x^{(i)}, y^{(i)}) + L1 + L2$

donde $C_{FP}$ es el costo obtenido al final del Forward Pass durante el algoritmo de Backpropagation, y los términos L1 y L2 corresponden a las normas de regularización calculadas con las funciones l1() y l2() respectivamente.

Parámetros:	data – list de pyspark.mllib.regression.LabeledPoint
Devuelve:	float (costo), tuple de `LocalNeurons` (gradientes de W y b)

Nota

Para problemas de clasificación, el float label se convierte a un vector binario de dimensión K (dado por la cantidad de clases a predecir) mediante label_to_vector() para así poder aplicar una función de costo en forma directa contra la predicción realizada por la softmax (que es un vector).

cost_single(features, label)[fuente]¶

Costo total de la red neuronal para una entrada singular {features, label}, dado por:

$C(W, b; x, y) = C_{FP}(W, b; x, y) + L1 + L2$

donde $C_{FP}$ es el costo obtenido al final del Forward Pass durante el algoritmo de Backpropagation, y los términos L1 y L2 corresponden a las normas de regularización calculadas con las funciones l1() y l2() respectivamente.

Parámetros:	features – numpy.ndarray label – float o numpy.ndarray
Devuelve:	float (costo), tuple de `LocalNeurons` (gradientes de W y b)

Nota

Para problemas de clasificación, el float label se convierte a un vector binario de dimensión K (dado por la cantidad de clases a predecir) mediante label_to_vector() para así poder aplicar una función de costo en forma directa contra la predicción realizada por la softmax (que es un vector).

evaluate(data, predictions=False, measure=None)[fuente]¶

Evaluación de un conjunto de datos etiquetados, midiendo la salida real o de predicción contra la esperada mediante una métrica definida en base a la tarea asignada para la red.

Parámetros:	data – instancia de `LabeledDataSet` o list de pyspark.mllib.regression.LabeledPoint predictions – bool, si es True se deben retornar también las predicciones hechas sobre data measure – string, key de alguna medida implementada en alguna de las métricas diponibles en `evaluation`.
Devuelve:	float, resultado de aplicar la medida dada por measure. Si predictions es True se retorna además una lista de numpy.ndarray (predicciones).

fit(train, valid=None, mini_batch=50, parallelism=0, valid_iters=10, measure=None, stops=None, optimizer_params=None, reproducible=False, keep_best=False)[fuente]¶

Ajuste de la red neuronal utilizando los conjuntos train y valid, mediante las siguientes pautas:

Durante la optimización, un modelo itera sobre un batch o subconjunto muestreado de train cuya magnitud está dada por mini_batch.
La optimización se realiza en forma distribuida, seleccionando batchs de datos para cada modelo a entrenar en forma paralela por cada iteración de la optimización. La cantidad de modelos a entrenar en forma concurrente está dada por parallelism.
El conjunto train es enviado en Broadcast de Spark a todos los nodos de ejecución para mejorar el esquema de comunicación durante la optimización.
La validación se realiza cada una cierta cantidad de épocas, dada por valid_iters, para así poder agilizar el ajuste cuando valid es de gran dimensión.
La optimización es controlada mediante los parámetros OptimizerParameters y los criterios de corte provenientes de stops.

Parámetros:

train – LabeledDataSet or list, conjunto de datos de entrenamiento.
valid – LabeledDataSet or list, conjunto de datos de validación.
mini_batch – int, cantidad de ejemplos a utilizar durante una época de la optimización.
parallelism – int, cantidad de modelos a optimizar concurrentemente. Si es 0, es determinado por el nivel de paralelismo por defecto en Spark (variable sc.defaultParallelism), Si es -1, se setea como $\frac{N}{m}$ donde N es la cantidad total de ejemplos de entrenamiento y m la cantidad de ejemplos para el mini-batch.
valid_iters – int, indicando cada cuántas iteraciones evaluar el modelo sobre el conjunto valid.
measure – string, key de alguna medida implementada en alguna de las métricas diponibles en evaluation.
stops – list de criterion, instanciados desde stops.
optimizer_params – OptimizerParameters
reproducible – bool, si es True se indica que se debe poder reproducir exactamente el ajuste.
keep_best – bool, indicando True si se desea mantener al final de la optimización el mejor modelo obtenido.

Devuelve:

float, resultado de evaluar el modelo final sobre el conjunto valid.

l1()[fuente]¶

Norma L1 sobre la matriz w de pesos sinápticos de cada una de las N capas en la red, calculada mediante llamadas a la funcion l1(), tal que se obtiene:

$L1=\lambda_1 \displaystyle\sum\limits_{l}^N L_1(W^{l})$

Además se retorna la lista de N gradientes correspondientes a cada capa de la red.

Devuelve:	tuple de float, list de `LocalNeurons`

l2()[fuente]¶

Norma L2 sobre la matriz w de pesos sinápticos de cada una de las N capas en la red, calculada mediante llamadas a la funcion l2(), tal que se obtiene:

$L2=\lambda_2 \displaystyle\sum\limits_{l}^N L_2(W^{l})$

Además se retorna la lista de N gradientes correspondientes a cada capa de la red.

Devuelve:	tuple de float, list de `LocalNeurons`

classmethod load(filename)[fuente]¶

Carga de un modelo desde archivo en forma serializada con Pickler.

Parámetros:	filename – string, ruta indicando desde dónde debe cargarse.
Devuelve:	`NeuralNetwork`

predict(x)[fuente]¶

Predicciones sobre una entrada de datos (singular o conjunto).

Parámetros:	x – numpy.ndarray o pyspark.mllib.regression.LabeledPoint, o list de ellos.
Devuelve:	numpy.ndarray

save(filename)[fuente]¶

Guardar el modelo en forma serializada con Pickler.

Parámetros:	filename – string, ruta indicando dónde debe almacenarse.

>>> # Load
>>> model_path = '/tmp/model/test_model.lea'
>>> test_model = NeuralNetwork.load(filename=model_path)
>>> # Save
>>> test_model.save(filename=model_path)

set_dropout_ratios(dropout_ratios)[fuente]¶

Setea los ratios para utilizar en el DropOut de los pesos sinápticos, sobrescribiendo el valor correspondiente en la instancia de parámetros NetworkParameters.

Parámetros:	dropout_ratios – list de floats

set_l1(strength_l1)[fuente]¶

Setea un strength dado para calcular la norma L1, sobrescribiendo el valor correspondiente en la instancia de parámetros NetworkParameters.

Parámetros:	strength_l1 – float

set_l2(strength_l2)[fuente]¶

Setea un strength dado para calcular la norma L2, sobrescribiendo el valor correspondiente en la instancia de parámetros NetworkParameters.

Parámetros:	strength_l2 – float

update(step_w, step_b)[fuente]¶

Actualiza los pesos sinápticos de cada capa en la red, agregando a cada una los incrementos ingresados como parámetros mediante llamadas a la función update().

Parámetros:	step_w – list de `LocalNeurons`. step_b – list de `LocalNeurons`.
Devuelve:	`NeuralNetwork`.

Parámetros¶

class learninspy.core.model.NetworkParameters(units_layers, activation='ReLU', dropout_ratios=None, layer_distributed=False, classification=True, strength_l1=1e-05, strength_l2=0.0001, seed=123)[fuente]¶

Clase utilizada para especificar todos los parámetros necesarios para configurar una red neuronal

Parámetros:

units_layers – list of ints, donde cada valor indica la cantidad de unidades que posee la respectiva capa. La cantidad de valores de la lista indica el total de capas que va a tener la red (entrada + ocultas + salida).
activation – string or list of strings, indicando la key de la/s activación/es a utilizar en las capas de la red neuronal.
layer_distributed – list of bools, indicando por cada capa si sus neuronas van a representarse o no por arreglos distribuidos (no tiene efecto en este release).
dropout_ratios – list of floats, indicando el valor de p para aplicar Dropout en cada respectiva capa.
classification – bool, es True si la tarea de la red es de clasificación y False si es de regresión.
strength_l1 – float, ratio de Norma L1 a aplicar en todas las capas.
strength_l2 – float, ratio de Norma L2 a aplicar en todas las capas.
seed – int, semilla que alimenta al generador de números aleatorios numpy.random.RandomState utilizado por la red.

>>> net_params = NetworkParameters(units_layers=[4, 8, 3], \ ...
>>>                                dropout_ratios=[0.0, 0.0], \ ...
>>>                                activation='ReLU', \ ...
>>>                                strength_l1=1e-5, strength_l2=3e-4,\ ...
>>>                                classification=True, seed=123)
>>> net_params == net_params
True
>>> net_params == NetworkParameters(units_layers=[10, 2])
False
>>> print str(net_params)
Layer 0 with 4 neurons, using ReLU activation and 0.0 ratio of DropOut.
Layer 1 with 8 neurons, using ReLU activation and 0.0 ratio of DropOut.
Layer 2 with 3 neurons, using Softmax activation.
The loss is CrossEntropy for a task of classification.
L1 strength is 1e-05 and L2 strength is 0.0003.

learninspy.core.neurons¶

En este módulo se implementa un esquema de «neuronas» para manejar los arreglos referidos a pesos sinápticos en las capas de una red neuronal. Ello implica tanto operaciones algebraicas sobre matrices y vectores como la aplicación de funciones de activación y costo.

class learninspy.core.neurons.LocalNeurons(mat, shape)[fuente]¶

Bases: object

Clase principal para representar los pesos sinápticos W de una red neuronal y el vector de bias b. Provee funcionalidades algebraicas para operar matrices y vectores, así como también normas regularizadoras y la aplicación de funciónes de activación y de costo. No obstante, esta clase es usada directamente por NeuralLayer, por lo cual no es herramienta de libre utilidad.

Nota

Es preciso aclarar que su estructuración se debe a que está pensada para ser compatible con su par DistributedNeurons, pero que en esta versión se encuentra inhabilitada.

Parámetros:	mat – numpy.array o list o pyspark.rdd.RDD, que corresponde a la matriz W o vector b a alojar para operar. shape – tuple, que corresponde a la dimensión que debe tener mat. Útil sólo cuando se utilizan arreglos distribuidos.

>>> shape = (5,3)
>>> w = np.asarray(np.random.uniform(low=-np.sqrt(6.0 / (shape[0] + shape[1])), \ ...
>>>                high=+np.sqrt(6.0 / (shape[0] + shape[1])),
>>>                size=shape), dtype=np.dtype(float))
>>> weights = LocalNeurons(w, shape)

activation(fun)[fuente]¶

Aplica una función de activación fun sobre cada entrada del arreglo self.matrix alojado.

Parámetros:	fun – función soportada en `activations`.
Devuelve:	`LocalNeurons`

collect()[fuente]¶

Retorna el arreglo alojado.

Devuelve:	numpy.ndarray

count()[fuente]¶

Cantidad de elementos de la matriz almacenada. Siendo MxN las dimensiones, retorna el producto de ambas.

Devuelve:	int

dropout(p, seed=123)[fuente]¶

Aplica DropOut [srivastava2014dropout] sobre el arreglo alojado, anulando sus elementos con una probabilidad p.

El resultado es un arreglo con entradas aleatoriamente anuladas con probabilidad p, y la máscara o arreglo binario de igual dimensión que el anterior, en donde se almacena 1 en las entradas donde respectivamente se aplicó DropOut y 0 en el resto.

Parámetros:	p – float, tal que $0<p<1$
Devuelve:	tuple de `LocalNeurons`, numpy.ndarray

Referencias:

[srivastava2014dropout]

Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014): «Dropout: A simple way to prevent neural networks from overfitting». The Journal of Machine Learning Research, 15(1), 1929-1958.

l1()[fuente]¶

Norma L1 sobre la matriz almacenada. Se retorna una tupla con el resultado y además el gradiente de dicha norma.

$L_1(W)=\displaystyle\sum\limits_{i}^{n_{rows}} \sum\limits_{j}^{n_{cols}} |W_{i,j}|, \quad \dfrac{\partial}{\partial W_{i,j}} L_1(W)= sign(W_{i,j})$

Devuelve:	tuple de float, `LocalNeurons`

Nota

El cálculo no suele aplicarse a un vector de bias b, ya que afecta poco en el resultado final.

l2()[fuente]¶

Norma L2 sobre la matriz almacenada. Se retorna una tupla con el resultado y además el gradiente de dicha norma.

$L_2(W)=\dfrac{1}{2} \displaystyle\sum\limits_{i}^{n_{rows}} \sum\limits_{j}^{n_{cols}} (W_{i,j})^2, \quad \dfrac{\partial}{\partial W_{i,j}} L_2(W)= W_{i,j}$

Devuelve:	tuple de float, `LocalNeurons`

Nota

El cálculo no suele aplicarse a un vector de bias b, ya que afecta poco en el resultado final.

loss(fun, y)[fuente]¶

Aplica una función de error entre el vector almacenado y la entrada y.

Parámetros:	fun – función soportada en `loss` y – list o numpy.ndarray
Devuelve:	float

loss_d(fun, y)[fuente]¶

Aplica una función derivada de error entre el vector almacenado y el vector y.

Parámetros:	fun – función derivada soportada en `loss` y – list o numpy.ndarray
Devuelve:	`LocalNeurons`

mul_array(*args)[fuente]¶

mul_elemwise(*args)[fuente]¶

outer(array)[fuente]¶

Producto exterior entre vectores. Equivalente a numpy.outer.

Parámetros:	array – numpy.array o `LocalNeurons`
Devuelve:	`LocalNeurons`

shape[fuente]¶

Dimensiones del arreglo alojado.

Devuelve:	tuple

softmax()[fuente]¶

Aplica la función Softmax sobre el vector alojado. Ver más info en Wikipedia: Softmax function

Devuelve:	numpy.ndarray

sum(axis=None)[fuente]¶

Suma de los elementos del arreglo alojado. Equivalente a numpy.array.sum

Parámetros:	axis – None o int o tuple de ints, optional. Indicando dimensión/es a tomar en la suma.
Devuelve:	numpy.array

sum_array(*args)[fuente]¶

transpose()[fuente]¶

Transpone el arreglo alojado en la instancia. Equivale a numpy.array.transpose().

Devuelve:	`LocalNeurons`

learninspy.core.optimization¶

Este módulo se realizó en base al excelente package de optimización climin , de donde se adaptaron algunos algoritmos de optimización para su uso en redes neuronales.

Nota

Proximamente se migrará a un package optimization, separando por scripts los algoritmos de optimización.

Parámetros¶

class learninspy.core.optimization.OptimizerParameters(algorithm='Adadelta', options=None, stops=None, merge_criter='w_avg', merge_goal='hits')[fuente]¶

Clase utilizada para especificar la configuración deseada en la optimización de la red neuronal. Se define el algoritmo de optimización, las opciones o hiper-parámetros propios del mismo y los criterios de corte para frenar tempranamente la optimización. Además, se especifica aquí cómo es realizado el mezclado durante el entrenamiento distribuido mediante merge_models().

Parámetros:

algorithm – string,key de algún algoritmo de optimización que hereda de Optimizer,
options – dict, donde se indican los hiper-parámetros de optimización específicos del algoritmo elegido.
stops – list de criterion, instanciados desde stops.
merge_criter – string, parámetro criter de la función merge_models().
merge_goal – string, parámetro goal de la función merge_models().

>>> from learninspy.core.stops import criterion
>>> local_stops = [criterion['MaxIterations'](10),  \ ...
>>>                criterion['AchieveTolerance'](0.95, key='hits')]
>>> opt_options = {'step-rate': 1, 'decay': 0.9, 'momentum': 0.0, 'offset': 1e-8}
>>> opt_params = OptimizerParameters(algorithm='Adadelta', options=opt_options, \ ...
>>>                                  stops=local_stops, \ ...
>>>                                  merge_criter='w_avg', merge_goal='hits')
>>> print str(opt_params)
The algorithm used is Adadelta with the next parameters:
offset: 1e-08
step-rate: 1
momentum: 0.0
decay: 0.9
The stop criteria used for optimization is:
Stop at a maximum of 10 iterations.
Stop when a tolerance of 0.95 is achieved in hits.

Algoritmos de optimización¶

class learninspy.core.optimization.Optimizer(model, data, parameters=None)[fuente]¶

Bases: object

Clase base para realizar la optimización de un modelo sobre un conjunto de datos.

Parámetros:	model – `NeuralNetwork`, modelo a optimizar. data – list de pyspark.mllib.regression.LabeledPoint. batch de datos a utilizar en el ajuste. parameters – `OptimizerParameters`, parámetros de la optimización.

>>> stops = [criterion['MaxIterations'](10), \...
>>>          criterion['AchieveTolerance'](0.95, key='hits')]
>>> # Gradient Descent
>>> options = {'step-rate': 0.01, 'momentum': 0.8, 'momentum_type': 'standard'}
>>> opt_params = OptimizerParameters(algorithm='GD', stops=stops, \...
>>>                                  options=options, merge_criter='w_avg')
>>> # Adadelta
>>> options = {'step-rate': 1.0, 'decay': 0.99, 'momentum': 0.7, 'offset': 1e-8}
>>> opt_params = OptimizerParameters(algorithm='GD', stops=stops, \...
>>>                                  options=options, merge_criter='avg')
>>> minimizer = Minimizer[opt_params.algorithm](model, data, opt_params)
>>> for result in minimizer:
>>>     logger.info("Cant de iteraciones: %i. Hits en batch: %12.11f. "
>>>                                          "Costo: %12.11f", \...
>>>                  result['iterations'], result['hits'], result['cost'])

class learninspy.core.optimization.GD(model, data, parameters=None)[fuente]¶

Bases: learninspy.core.optimization.Optimizer

Optimización de una red neuronal mediante el clásico algoritmo Gradiente Descendiente.

Como configuración, se deben incluir como “options” dentro de parameters los siguientes parámetros:

“step-rate”: tasa de aprendizaje en rango [0,1] (default=1.0).
“momentum”: factor de momento en rango [0,1] para acelerar la optimización (default=0.0).
“momentum_type”: Tipo de momentum, eligiendo entre “standard” y “nesterov”, indicando este último el uso de Nesterov accelerated gradient (NAG) [nesterov1983method].

Parámetros:	model – `NeuralNetwork`, data – list de pyspark.mllib.regression.LabeledPoint. parameters – `OptimizerParameters`.

Referencias:

[nesterov1983method]

Nesterov, Y. (1983, February). A method for unconstrained convex minimization problem with the rate of convergence O (1/k2). In Doklady an SSSR (Vol. 269, No. 3, pp. 543-547).

class learninspy.core.optimization.Adadelta(model, data, parameters=None)[fuente]¶

Bases: learninspy.core.optimization.Optimizer

Adadelta es un algoritmo de optimización que usa la magnitud de los incrementos y gradientes anteriores para obtener una tasa de aprendizaje adaptativa [zeiler2012adadelta].

Como configuración, se deben incluir como “options” dentro de parameters los siguientes parámetros:

“step-rate”: tasa de aprendizaje en rango [0,1] (default=1.0).
“decay”: factor de decaimiento en rango [0,1], indicando el grado de «memoria» a mantener (default=0.99).
“momentum”: factor de momento en rango [0,1] para acelerar la optimización (default=0.0).
“offset”: valor pequeño (recomendado entre 1e-8 y 1e-4) a sumar para evitar división por 0.

Parámetros:	model – `NeuralNetwork`, data – list de pyspark.mllib.regression.LabeledPoint. parameters – `OptimizerParameters`.

Referencias:

[zeiler2012adadelta]

Zeiler, M. D. (2012). ADADELTA: an adaptive learning rate method. arXiv preprint arXiv:1212.5701.

Entrenamiento distribuido¶

learninspy.core.optimization.optimize(model, data, params=None, mini_batch=50, seed=123)[fuente]¶

Función para optimizar un modelo sobre un conjunto de datos a partir de una configuración dada.

Parámetros:	model – `NeuralNetwork`, modelo a optimizar. data – `LabeledDataSet` or list, conjunto de datos para el ajuste. params – `OptimizerParameters` mini_batch – int, cantidad de ejemplos a utilizar durante una época de la optimización. seed – int, semilla que alimenta al generador de números aleatorios.
Devuelve:	dict, con cada uno de los resultados obtenidos en la optimización.

learninspy.core.optimization.merge_models(results_rdd, criter='w_avg', goal='hits')[fuente]¶

Funcion para hacer merge de modelos, en base a un criterio de ponderacion sobre un valor objetivo

Parámetros:

results_rdd – pyspark.rdd, resultado del mapeo de optimización sobre los modelos replicados a mergear.
criter – string, indicando el tipo de ponderación para hacer el merge. Si es “avg” se realiza un promedio no ponderado, “w_avg” para un promedio con ponderación lineal y “log_avg” para que la ponderación sea logarítmica.
goal – string, indicando qué parte del resultado utilizar para la función de consenso. Si es “hits” se debe hacer sobre el resultado obtenido con las métricas de evaluación, y si es “cost” es sobre el resultado de la función de costo.

Devuelve:

list of learninspy.core.model.NeuralLayer

learninspy.core.optimization.mix_models(left, right)[fuente]¶

Se devuelve el resultado de sumar las NeuralLayers de left y right.

Parámetros:	left – list of NeuralLayer right – list of NeuralLayer
Devuelve:	list of NeuralLayer

learninspy.core.search¶

En este módulo se implementan los mecanismos para realizar búsquedas de los parámetros utilizados durante el ajuste de redes neuronales.

Como puede notarse durante el diseño del modelo en cuestión, existen diversos parámetros y configuraciones que se deben especificar en base a los datos tratados y la tarea asignada para el modelo. Estos pueden ser valores en particular de los cuales se puede tener una idea de rangos posibles (e.g. taza de aprendizaje para el algoritmo de optimización) o elecciones posibles de la arquitectura del modelo (e.g. función de activación de cada capa).

La configuración elegida es crucial para que la optimización resulte en un modelo preciso para la tarea asignada,y en el caso de los hiperparámetros elegir un valor determinado puede ser difícil especialmente cuando son sensibles. Una forma asistida para realizar esto es implementar un algoritmo de búsqueda de parámetros el cual realiza elecciones particulares tomando muestras sobre los rangos posibles determinados, así luego se optimiza un modelo por cada configuración especificada. Opcionalmente, también se puede utilizar validación cruzada para estimar la generalización del modelo obtenido con la configuración y su independencia del conjunto de datos tomado.

Resumiendo, una búsqueda consta de:

Un modelo estimador.
Un espacio de parámetros.
Un método para muestrear o elegir candidatos.
Una función de evaluación para el modelo.
(Opcional) Un esquema de validación cruzada.

class learninspy.core.search.RandomSearch(net_params, n_layers=0, n_iter=10, net_domain=None, seed=123)[fuente]¶

Una forma que evade buscar exahustivamente sobre el espacio de parámetros (lo cual es potencialmente costoso si dicho espacio es de una dimensión alta), es la de muestrear una determinada cantidad de veces el espacio, en forma aleatoria y no sobre una grilla determinada. Este método se denomina «búsqueda aleatoria» o random search, el cual es fácil de implementar como el grid search aunque se considera más eficiente especialmente en espacios de gran dimensión [bergstra2012random].

En esta implementación, se deben especificar los parámetros específicos que se quieren explorar. Esto se realiza utilizando como medio la clase NetworkParameters, en la cual se indica con un bool (True o False) sobre cada parámetro que se desea contemplar en la búsqueda de parámetros. También se pueden especificar los rangos o dominio de búsqueda (e.g. funciones de activación, cant. de capas y unidades en c/u, rangos de constantes para normas L1/L2, etc). Por defecto, se utiliza el dict “network_domain” implementado en este módulo.

Parámetros:

net_params – NetworkParameters
n_layers – int, si es -1 se muestrea la cant. de capas, si es 0 se mantiene intacta la config, y si es > 0 representa la cant. de capas deseada.
n_iter – int, cant. de iteraciones para la búsqueda.
net_domain – dict, si es None se utiliza el dict “network_domain” implementado en este módulo.
seed – int, semilla que alimenta los generadores de números aleatorios.

>>> from learninspy.core.model import NetworkParameters, NeuralNetwork
>>> from learninspy.core.search import network_domain
>>> net_params = NetworkParameters(units_layers=[4, 10, 3], activation=False, \ ...
>>>                                dropout_ratios=True, classification=True, \ ...
>>>                                strength_l1=True, strength_l2=True, seed=123)
>>> rnd_search = RandomSearch(net_params, n_layers=0, n_iter=10,
>>>                           net_domain=network_domain, seed=123)
>>> rnd_search.fit(NeuralNetwork, train, valid, test)
>>> ...

Referencias:

[bergstra2012random]

Bergstra, J., & Bengio, Y. (2012). Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb), 281-305.

fit(type_model, train, valid, test, mini_batch=100, parallelism=4, valid_iters=5, measure=None, stops=None, optimizer_params=None, reproducible=False, keep_best=True)[fuente]¶

Función para iniciar la búsqueda de parámetros ajustada a las especificaciones de dominio dadas, utilizando los conjuntos de datos ingresados y demás parámetros de optimización para usar en la función de modelado fit() en NeuralNetwork.

Parámetros:	type_model – class, correspondiente a un tipo de modelo del módulo `model`.

Nota

El resto de los parámetros son los mismos que recibe la función fit() incluyendo también el conjunto de prueba test que se utiliza para validar la conveniencia de cada modelo logrado. Remitirse a la API de dicha función para encontrar información de los parámetros.

learninspy.core.stops¶

Este módulo contiene funcionalidades para monitorear el corte del entrenamiento en una red neuronal. El mismo está importantemente basado en el excelente package de optimización climin.

En cualquier aplicación de aprendizaje maquinal, por lo general no se ejecuta la optimización de un modelo hasta obtener un desempeño deseado ya que puede ser que no se alcance dicho objetivo por la configuración establecida. Es por ello que resulta conveniente establecer ciertas heurísticas para monitorear la convergencia del modelo en su optimización.

Un criterio de corte es una función que utiliza información de la optimización de un modelo durante dicho proceso (e.g. scoring sobre el conjunto de validación, costo actual, cantidad de iteraciones realizadas) y, en base a una regla establecida, determina si se debe frenar o no dicho proceso. En su implementación, son instanciados al crearse con los parámetros que determinen su configuración y luego se utilizan llamándolos con un parámetro que es un dict con los key, values necesarios.

Una característica interesante de estos criterios es que se pueden combinar con operaciones lógicas de and/or, de forma que el corte de la optimización se realice cuando todos los criterios elegidos, o alguno de ellos, lo determinen. Además se ofrece la facilidad de utilizar estos criterios utilizando el diccionario criterion instanciado en este módulo, con lo cual se combinan sencillamente llamándolos mediante strings (es así como se utilizan en los módulos de learninspy).

>>> from learninspy.core.stops import criterion
>>> criterions = [criterion['MaxIterations'](10),\ ...
>>>               criterion['AchieveTolerance'](0.9, 'hits'),\ ...
>>>               criterion['NotBetterThanAfter'](0.6, 5, 'hits')]
>>> results = {'hits': 0.8, 'iterations': 8}
>>> stop = all(map(lambda c: c(results), criterions))
>>> print stop
False
>>> results = {'hits': 15, 'iterations': 0.95}
>>> stop = any(map(lambda c: c(results), criterions))
>>> print stop
True

class learninspy.core.stops.AchieveTolerance(tolerance, key='hits')[fuente]¶

Criterio para frenar la optimización luego de alcanzar un valor de tolerancia sobre una cierta variable de la optimización.

Parámetros:	tolerance – float, tolerancia en rango 0 < tolerance <= 1. key – string, correspondiente a donde se aplica la tolerancia (“cost” o “hits”).

>>> # Tolerancia sobre el costo de optimización
>>> tol = 1e-3
>>> stop = AchieveTolerance(tol, key='cost')
>>> ...
>>> # Tolerancia sobre el resultado parcial de evaluación
>>> tol = 0.9
>>> stop = AchieveTolerance(tol, key='hits')

class learninspy.core.stops.MaxIterations(max_iter)[fuente]¶

Criterio para frenar la optimización luego de un máximo de iteraciones definido.

Parámetros:	max_iter – int, máximo de iteraciones.

class learninspy.core.stops.ModuloNIterations(n)[fuente]¶

Criterio para frenar la optimización cuando una iteración alcanzada es módulo del parámetro n ingresado. Este criterio es útil al combinarse con otros más.

Parámetros:	n – int.

class learninspy.core.stops.NotBetterThanAfter(minimal, after, key='hits')[fuente]¶

Criterio para frenar la optimización cuando luego de una cierta cantidad de iteraciones no se alcanzó un mínimo valor determinado sobre una variable de la optimización.

Parámetros:	minimal – float, valor mínimo a alcanzar o superar sobre la variable definida por key. after – int, cantidad de iteraciones a partir de las cuales medir sobre minimal. key – string, correspondiente a donde se aplica la diferencia con minimal (“cost” o “hits”).

class learninspy.core.stops.OnSignal(sig=2)[fuente]¶

Criterio para frenar la optimización cuando se ejecuta un comando que accione una señal del SO (e.g. Ctrl+C para interrupción).

Útil para detener la optimización a demanda sin perder el progreso logrado.

Parámetros:	sig – signal, opcional [default: signal.SIGINT].

class learninspy.core.stops.Patience(initial, key='hits', grow_factor=1, grow_offset=0, threshold=0.05)[fuente]¶

Criterio para frenar la optimización siguiendo el método heurístico de paciencia ideado por Bengio [bengio2012practical].

Se basa en incrementar el número de iteraciones en la optimización multiplicando por un factor grow_factor y/o sumando una constante grow_offset una vez que se obtiene un mejor valor de la variable a optimizar dada por key. Esto es realizado para que heurísticamente se le tenga paciencia en la optimización a un nuevo candidato encontrado incrementando su tiempo de ajuste. …

Parámetros:

initial – int, número de iteración a partir de la cual medir la «paciencia».
key – string, correspondiente a donde se mide el progreso (“cost” o “hits”).
grow_factor – float, debe ser distinto de 1 si grow_offset == 0.
grow_offset – float, debe ser distinto de 0 si grow_factor == 1.
threshold – float, umbral de diferencia entre el valor actual y el mejor obtenido.

Referencias:

[bengio2012practical]

Bengio, Y. (2012). Practical recommendations for gradient-based training of deep architectures. In Neural Networks: Tricks of the Trade (pp. 437-478). Springer Berlin Heidelberg.

class learninspy.core.stops.TimeElapsed(sec)[fuente]¶

Criterio para frenar la optimización luego de superar un lapso de tiempo fijado.

Parámetros:	sec – float, lapso de tiempo máximo, en unidad de segundos.

learninspy.core package¶

Submódulos¶

learninspy.core.activations¶

learninspy.core.autoencoder¶

learninspy.core.loss¶

learninspy.core.model¶

Capas neuronales¶

Red neuronal¶

Parámetros¶

learninspy.core.neurons¶

learninspy.core.optimization¶

Parámetros¶

Algoritmos de optimización¶

Entrenamiento distribuido¶

learninspy.core.search¶

learninspy.core.stops¶

Tabla de Contenidos

Tema anterior

Próximo tema

Esta página