Lasagne

lasaña

Lasagne es una biblioteca liviana para construir y entrenar redes neuronales en Theano. Sus principales características son:

• Admite redes de retroalimentación, como redes neuronales convolucionales (CNN), redes recurrentes, incluida la memoria a corto plazo (LSTM) y cualquier combinación de las mismas.
• Permite arquitecturas de múltiples entradas y múltiples salidas, incluidos clasificadores auxiliares.
• Muchos métodos de optimización, incluidos el impulso de Nesterov, RMSprop y ADAM.
• Función de costos libremente definible y sin necesidad de derivar gradientes debido a la diferenciación simbólica de Theano
• Soporte transparente de CPU y GPU gracias al compilador de expresiones de Theano

Su diseño se rige por seis principios:

• Simplicidad: Ser fácil de usar, fácil de entender y fácil de ampliar, para facilitar su uso en la investigación.
• Transparencia: no oculte a Theano detrás de abstracciones, procese y devuelva directamente expresiones de Theano o tipos de datos Python/numpy
• Modularidad: Permitir que todas las partes (capas, regularizadores, optimizadores, ...) se utilicen independientemente de lasaña
• Pragmatismo: facilite los casos de uso comunes, no sobrevalore los casos poco comunes
• Restricción: no obstruya a los usuarios con funciones que decidan no utilizar
• Enfoque: "Haz una cosa y hazla bien"

Instalación

En resumen, puede instalar una versión compatible conocida de Theano y la última versión de desarrollo de Lasagne a través de:

pip install -r https://raw.githubusercontent.com/Lasagne/Lasagne/master/requirements.txt
pip install https://github.com/Lasagne/Lasagne/archive/master.zip

Para obtener más detalles y alternativas, consulte las instrucciones de instalación.

Documentación

La documentación está disponible en línea: http://lasagne.readthedocs.org/

Para obtener ayuda, consulte la lista de correo de usuarios de lasaña.

Ejemplo

 import lasagne
import theano
import theano . tensor as T

# create Theano variables for input and target minibatch
input_var = T . tensor4 ( 'X' )
target_var = T . ivector ( 'y' )

# create a small convolutional neural network
from lasagne . nonlinearities import leaky_rectify , softmax
network = lasagne . layers . InputLayer (( None , 3 , 32 , 32 ), input_var )
network = lasagne . layers . Conv2DLayer ( network , 64 , ( 3 , 3 ),
                                     nonlinearity = leaky_rectify )
network = lasagne . layers . Conv2DLayer ( network , 32 , ( 3 , 3 ),
                                     nonlinearity = leaky_rectify )
network = lasagne . layers . Pool2DLayer ( network , ( 3 , 3 ), stride = 2 , mode = 'max' )
network = lasagne . layers . DenseLayer ( lasagne . layers . dropout ( network , 0.5 ),
                                    128 , nonlinearity = leaky_rectify ,
                                    W = lasagne . init . Orthogonal ())
network = lasagne . layers . DenseLayer ( lasagne . layers . dropout ( network , 0.5 ),
                                    10 , nonlinearity = softmax )

# create loss function
prediction = lasagne . layers . get_output ( network )
loss = lasagne . objectives . categorical_crossentropy ( prediction , target_var )
loss = loss . mean () + 1e-4 * lasagne . regularization . regularize_network_params (
        network , lasagne . regularization . l2 )

# create parameter update expressions
params = lasagne . layers . get_all_params ( network , trainable = True )
updates = lasagne . updates . nesterov_momentum ( loss , params , learning_rate = 0.01 ,
                                            momentum = 0.9 )

# compile training function that updates parameters and returns training loss
train_fn = theano . function ([ input_var , target_var ], loss , updates = updates )

# train network (assuming you've got some training data in numpy arrays)
for epoch in range ( 100 ):
    loss = 0
    for input_batch , target_batch in training_data :
        loss += train_fn ( input_batch , target_batch )
    print ( "Epoch %d: Loss %g" % ( epoch + 1 , loss / len ( training_data )))

# use trained network for predictions
test_prediction = lasagne . layers . get_output ( network , deterministic = True )
predict_fn = theano . function ([ input_var ], T . argmax ( test_prediction , axis = 1 ))
print ( "Predicted class for first test input: %r" % predict_fn ( test_data [ 0 ]))

Para ver un ejemplo completamente funcional, consulte ejemplos/mnist.py y consulte el Tutorial para obtener explicaciones detalladas del mismo. Se mantienen más ejemplos, fragmentos de código y reproducciones de artículos de investigación recientes en el repositorio separado de Lasagne Recipes.

Citación

Si considera que lasaña es útil para su trabajo científico, considere citarla en las publicaciones resultantes. Proporcionamos una entrada BibTeX lista para usar para citar Lasaña.

Desarrollo

Lasaña es un trabajo en progreso, las aportaciones son bienvenidas.

¡Consulte las instrucciones de contribución para obtener detalles sobre cómo puede contribuir!