Téléchargement de Lasagne - Téléchargement du code source Lasagne

Lasagne

Python

1.0.0

Télécharger

Lasagnes

Lasagne est une bibliothèque légère pour créer et entraîner des réseaux de neurones dans Theano. Ses principales caractéristiques sont :

Prend en charge les réseaux à réaction tels que les réseaux de neurones convolutifs (CNN), les réseaux récurrents, notamment la mémoire à long terme et à court terme (LSTM), et toute combinaison de ceux-ci.
Permet des architectures de plusieurs entrées et plusieurs sorties, y compris des classificateurs auxiliaires
De nombreuses méthodes d'optimisation, dont Nesterov Momentum, RMSprop et ADAM
Fonction de coût librement définissable et pas besoin de dériver des gradients en raison de la différenciation symbolique de Theano
Prise en charge transparente des CPU et GPU grâce au compilateur d'expression de Theano

Sa conception est régie par six principes :

Simplicité : Être facile à utiliser, facile à comprendre et facile à étendre, pour faciliter l'utilisation dans la recherche
Transparence : ne cachez pas Theano derrière des abstractions, traitez et renvoyez directement les expressions Theano ou les types de données Python/numpy
Modularité : Permet d'utiliser toutes les pièces (couches, régulariseurs, optimiseurs, ...) indépendamment de Lasagne
Pragmatisme : faciliter les cas d'utilisation courants, ne pas surestimer les cas rares
Retenue : ne pas gêner les utilisateurs avec des fonctionnalités qu'ils décident de ne pas utiliser
Focus : "Faites une chose et faites-la bien"

Installation

En bref, vous pouvez installer une version compatible connue de Theano et la dernière version de développement de Lasagne via :

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

Pour plus de détails et d'alternatives, veuillez consulter les instructions d'installation.

Documentation

La documentation est disponible en ligne : http://lasagne.readthedocs.org/

Pour obtenir de l'aide, veuillez vous référer à la liste de diffusion des utilisateurs de lasagne.

Exemple

 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 ]))

Pour un exemple entièrement fonctionnel, consultez examples/mnist.py et consultez le didacticiel pour des explications détaillées. D'autres exemples, extraits de code et reproductions d'articles de recherche récents sont conservés dans le référentiel séparé Lasagne Recipes.

Citation

Si vous trouvez Lasagne utile pour vos travaux scientifiques, pensez à la citer dans les publications qui en résulteront. Nous fournissons une entrée BibTeX prête à l'emploi pour citer Lasagne.