Lasagne

Lasanha

Lasagne é uma biblioteca leve para construir e treinar redes neurais em Theano. Suas principais características são:

• Suporta redes feed-forward, como Redes Neurais Convolucionais (CNNs), redes recorrentes, incluindo Long Short-Term Memory (LSTM) e qualquer combinação delas
• Permite arquiteturas de múltiplas entradas e múltiplas saídas, incluindo classificadores auxiliares
• Muitos métodos de otimização, incluindo Nesterov momentum, RMSprop e ADAM
• Função de custo livremente definível e sem necessidade de derivar gradientes devido à diferenciação simbólica de Theano
• Suporte transparente de CPUs e GPUs devido ao compilador de expressão Theano

Seu design é regido por seis princípios:

• Simplicidade: Ser fácil de usar, fácil de entender e fácil de estender, para facilitar o uso em pesquisa
• Transparência: não esconda Theano atrás de abstrações, processe e retorne diretamente expressões Theano ou tipos de dados Python/numpy
• Modularidade: Permite que todas as peças (camadas, regularizadores, otimizadores, ...) sejam utilizadas independentemente da Lasanha
• Pragmatismo: facilite os casos de uso comuns, não superestime os casos incomuns
• Restrição: não obstrua os usuários com recursos que eles decidam não usar
• Foco: “Faça uma coisa e faça bem”

Instalação

Resumindo, você pode instalar uma versão compatível conhecida do Theano e a versão de desenvolvimento mais recente do Lasagne via:

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

Para mais detalhes e alternativas, consulte as instruções de instalação.

Documentação

A documentação está disponível online: http://lasagne.readthedocs.org/

Para suporte, consulte a lista de discussão dos usuários de lasagne.

Exemplo

 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 um exemplo totalmente funcional, consulte exemplos/mnist.py e verifique o Tutorial para explicações detalhadas sobre o mesmo. Mais exemplos, trechos de código e reproduções de artigos de pesquisa recentes são mantidos no repositório separado de Receitas de Lasanha.

Citação

Se você achar a lasanha útil para o seu trabalho científico, considere citá-la nas publicações resultantes. Fornecemos uma entrada BibTeX pronta para usar para citar lasanha.

Desenvolvimento

Lasanha é um trabalho em andamento, contribuições são bem-vindas.

Consulte as instruções de contribuição para obter detalhes sobre como você pode contribuir!