Melhor biblioteca python para redes neurais

Estou usando as Redes Neurais para resolver diferentes problemas de aprendizado de máquina. Estou usando Python e pybrain, mas esta biblioteca está quase descontinuada. Existem outras boas alternativas em Python?

ATUALIZAÇÃO: o cenário mudou bastante desde que eu respondi a essa pergunta em julho de 14 e alguns novos jogadores entraram no espaço. Em particular, eu recomendaria verificar:

• TensorFlow
• Blocos
• Lasanha
• Keras
• Deepy
• Nolearn
• NeuPy

Cada um deles tem seus pontos fortes e fracos, então experimente e veja qual é o que melhor se adequa ao seu caso de uso. Embora eu tivesse recomendado o uso do PyLearn2 há um ano, a comunidade não está mais ativa, então eu recomendaria procurar outro lugar. Minha resposta original à resposta está incluída abaixo, mas é amplamente irrelevante neste momento.

O PyLearn2 é geralmente considerado a biblioteca de escolha para redes neurais e aprendizado profundo em python. Ele foi projetado para facilitar a experimentação científica, e não para a facilidade de uso, por isso a curva de aprendizado é bastante acentuada, mas se você tomar o seu tempo e seguir os tutoriais, acho que ficará feliz com a funcionalidade que ele fornece. Tudo, desde Perceptrons multicamadas padrão até Máquinas Boltzmann restritas, Redes convolucionais e Autoencodificadores. Há um ótimo suporte à GPU e tudo é construído sobre o Theano, portanto, o desempenho é geralmente muito bom. A fonte do PyLearn2 está disponível no github .

Esteja ciente de que o PyLearn2 tem o problema oposto do PyBrain no momento - em vez de ser abandonado, o PyLearn2 está em desenvolvimento ativo e está sujeito a alterações frequentes.

O Fluxo de tensor ( documentos ) do Google é outra estrutura interessante que possui diferenciação automática. Escrevi algumas reflexões rápidas sobre o Google Tensor Flow no meu blog, junto com o exemplo MNIST que eles têm em seu tutorial.

Consulte também: Meu tutorial do Tensorflow XOR

A lasanha ( docs ) é muito boa, pois usa theano (→ você pode usar a GPU) e simplifica o uso. O autor da lasanha venceu o desafio Kaggle Galaxy, até onde eu sei. É legal com o nolearn . Aqui está um exemplo de rede MNIST:

#!/usr/bin/env python

import lasagne
from lasagne import layers
from lasagne.updates import nesterov_momentum
from nolearn.lasagne import NeuralNet

import sys
import os
import gzip
import pickle
import numpy


PY2 = sys.version_info[0] == 2

if PY2:
    from urllib import urlretrieve

    def pickle_load(f, encoding):
        return pickle.load(f)
else:
    from urllib.request import urlretrieve

    def pickle_load(f, encoding):
        return pickle.load(f, encoding=encoding)

DATA_URL = 'http://deeplearning.net/data/mnist/mnist.pkl.gz'
DATA_FILENAME = 'mnist.pkl.gz'


def _load_data(url=DATA_URL, filename=DATA_FILENAME):
    """Load data from `url` and store the result in `filename`."""
    if not os.path.exists(filename):
        print("Downloading MNIST dataset")
        urlretrieve(url, filename)

    with gzip.open(filename, 'rb') as f:
        return pickle_load(f, encoding='latin-1')


def load_data():
    """Get data with labels, split into training, validation and test set."""
    data = _load_data()
    X_train, y_train = data[0]
    X_valid, y_valid = data[1]
    X_test, y_test = data[2]
    y_train = numpy.asarray(y_train, dtype=numpy.int32)
    y_valid = numpy.asarray(y_valid, dtype=numpy.int32)
    y_test = numpy.asarray(y_test, dtype=numpy.int32)

    return dict(
        X_train=X_train,
        y_train=y_train,
        X_valid=X_valid,
        y_valid=y_valid,
        X_test=X_test,
        y_test=y_test,
        num_examples_train=X_train.shape[0],
        num_examples_valid=X_valid.shape[0],
        num_examples_test=X_test.shape[0],
        input_dim=X_train.shape[1],
        output_dim=10,
    )


def nn_example(data):
    net1 = NeuralNet(
        layers=[('input', layers.InputLayer),
                ('hidden', layers.DenseLayer),
                ('output', layers.DenseLayer),
                ],
        # layer parameters:
        input_shape=(None, 28*28),
        hidden_num_units=100,  # number of units in 'hidden' layer
        output_nonlinearity=lasagne.nonlinearities.softmax,
        output_num_units=10,  # 10 target values for the digits 0, 1, 2, ..., 9

        # optimization method:
        update=nesterov_momentum,
        update_learning_rate=0.01,
        update_momentum=0.9,

        max_epochs=10,
        verbose=1,
        )

    # Train the network
    net1.fit(data['X_train'], data['y_train'])

    # Try the network on new data
    print("Feature vector (100-110): %s" % data['X_test'][0][100:110])
    print("Label: %s" % str(data['y_test'][0]))
    print("Predicted: %s" % str(net1.predict([data['X_test'][0]])))


def main():
    data = load_data()
    print("Got %i testing datasets." % len(data['X_train']))
    nn_example(data)

if __name__ == '__main__':
    main()

Caffe é uma biblioteca C ++, mas possui ligações Python. Você pode fazer a maioria das coisas por arquivos de configuração (prototxt). Tem muitas opções e também pode fazer uso da GPU.

O Pylearn conta com o Theano e, como mencionado na outra resposta, o uso da biblioteca é bastante complicado, até que você o compreenda.

Enquanto isso, sugiro usar Theanets . Também foi construído sobre o Theano, mas é muito mais fácil trabalhar com ele. Pode ser verdade que ele não possui todos os recursos do Pylearn, mas para o trabalho básico é suficiente.

Além disso, é de código aberto, para que você possa adicionar redes personalizadas rapidamente, se ousar. :)

EDIT: Dez 2015. Recentemente, comecei a usar o Keras . É um nível um pouco mais baixo que o Theanets, mas muito mais poderoso. Para testes básicos, o Theanets é apropriado. Mas se você quiser fazer alguma pesquisa no campo da ANN Keras é muito mais flexível. Além disso, o Keras pode usar o Tensorflow como back-end.

O TensorFlow (do Google, lançado em 09/11/2015) parece promissor.

• código-fonte aberto (licença Apache 2.0) ( GitHub )
• Python (back-end em C ++)
• CPU / GPU
• Diferenciação automática
• Portátil (funciona mesmo em dispositivos móveis)

PARA SUA INFORMAÇÃO:

• Avaliação dos kits de ferramentas de aprendizagem profunda
• Comparação fácil de todas as implementações públicas de convnets de código aberto.
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah. Estudo comparativo de estruturas de software de aprendizagem profunda . arXiv: 1511.06435.
• Shaohuai Shi, Qiang Wang, Pengfei Xu e Xiaowen Chu. Comparação de ferramentas de software de aprendizado profundo de última geração . arXiv: 1608.07249
• Um novo kit de ferramentas de aprendizado profundo foi lançado a cada 22 dias em 2015?

Pylearn2 parece ser a biblioteca de escolha, no entanto, acho seus arquivos de configuração YAML desanimadores.

O próprio Python foi projetado para ser uma linguagem fácil para a criação de protótipos. Por que você não o usaria para definir as propriedades da rede? Temos ótimos editores com preenchimento automático que tornariam sua vida muito mais fácil e o Python não é como o C ++, onde é necessário aguardar o término das compilações para poder executar seu código.

Arquivos YAML, por outro lado, você deve editar usando um editor de texto padrão sem qualquer tipo de assistência e isso torna a curva de aprendizado ainda mais acentuada.

Eu posso estar perdendo o quadro geral, mas ainda não entendo o que eles estavam pensando, não acho que a prototipagem de código seria muito mais lenta. Por esse motivo, estou pensando em Theanets ou usando Theano diretamente.

Eu gosto de Blocks , que também é construído em cima do Theano. Muito mais acessível que o PyLearn2 e mais rico em recursos que a Lasanha. Bem escrito também.

Atualizado em janeiro de 2016:

No momento da redação deste artigo, Keras tem, de longe, o maior momento. É altamente modular e pode ser executado no Theano e no Tensorflow, oferecendo grandes oportunidades.

MXNet :

• escrito em C ++, mas possui uma API em Python (e algumas outras linguagens de programação, como R, Julia e Go)
• Escala até várias GPUs e configuração distribuída com paralelismo automático.
• Diferenciação automática
• Apresentações decentes:

Pelo que ouvi, o Pylearn2 pode atualmente ser a biblioteca de escolha para a maioria das pessoas. Isso me lembra um post recente de um mês atrás, que lista todas as diferentes bibliotecas de aprendizado de máquina com uma breve explicação

https://www.cbinsights.com/blog/python-tools-machine-learning

A seção em que você pode estar interessado aqui seria "Deep Learning". Sobre o Pylearn2, ele escreve

PyLearn2

Existe outra biblioteca criada sobre o Theano, chamada PyLearn2, que traz modularidade e configurabilidade ao Theano, onde você pode criar sua rede neural através de diferentes arquivos de configuração, para que seja mais fácil experimentar parâmetros diferentes. Indiscutivelmente, ele fornece mais modularidade, separando os parâmetros e propriedades da rede neural no arquivo de configuração.

Eu escrevi este post detalhando alguns dos meus favoritos pessoais:

As melhores bibliotecas de aprendizado de máquina em Python

Como são mencionadas mais de 30 bibliotecas diferentes, não as publicarei aqui, mas estas estão entre as mais populares:

• Tensorflow
• scikit-learn
• Theano
• Pylearn2
• Pyevolve
• NuPIC
• padronizar
• Caffe

(Desculpe, não é possível vincular aos repositórios do Github, pois meu representante ainda é <10 ...)

Editar: links adicionados aos repositórios do Github.

neon :

• Baseado em Python
• Código aberto (licença Apache 2.0)
• Desenvolvido pela Nervana Systems (se você não os conhece: a Nervana, startup de aprendizado profundo, arrecada US $ 20,5 milhões ; a Nervana Systems arrecada US $ 3,3 milhões para criar hardware projetado para o aprendizado profundo )
• Suporta CPU e GPU
• Suporte básico à diferenciação automática
• Estrutura para visualização

Apenas para adicionar mais alguns recursos. Recentemente, houve um trabalho estudando as diferenças entre vários pacotes de redes neurais e redes neurais profundas.

Aqui você pode encontrar as informações . Parece que Torch e TensorFlow são os vencedores.

Nota: nem todos eles estão em python. No entanto, eu postei para abrir a discussão.

O Microsoft Cognition Toolkit (anteriormente conhecido como CNTK) possui uma API Python . Entre outras coisas, é suposto ser bom para multi-GPU :

Exemplos e tutoriais podem ser encontrados em https://github.com/Microsoft/CNTK/tree/master/bindings/python

DyNet: O Dynamic Neural Network Toolkit. A partir de 1}:

Descrevemos o DyNet, um kit de ferramentas para implementar modelos de redes neurais com base na declaração dinâmica da estrutura da rede. Na estratégia de declaração estática usada em kits de ferramentas como Theano, CNTK e TensorFlow, o usuário define primeiro um gráfico de computação (uma representação simbólica da computação) e, em seguida, exemplos são alimentados em um mecanismo que executa essa computação e calcula suas derivadas. . Na estratégia de declaração dinâmica da DyNet, a construção de gráficos de computação é principalmente transparente, sendo implicitamente construída pela execução de código processual que calcula as saídas da rede, e o usuário é livre para usar estruturas de rede diferentes para cada entrada. A declaração dinâmica facilita, assim, a implementação de arquiteturas de rede mais complicadas, e o DyNet foi projetado especificamente para permitir que os usuários implementem seus modelos de maneira idiomática em sua linguagem de programação preferida (C ++ ou Python). Um desafio da declaração dinâmica é que, como o gráfico de computação simbólico é definido novamente para cada exemplo de treinamento, sua construção deve ter uma sobrecarga baixa. Para conseguir isso, o DyNet possui um back-end C ++ otimizado e uma representação gráfica leve. As experiências mostram que as velocidades da DyNet são mais rápidas ou comparáveis ​​aos kits de ferramentas de declaração estática e significativamente mais rápidas que o Chainer, outro kit de ferramentas de declaração dinâmica. O DyNet é lançado de código aberto sob a licença Apache 2.0 e disponível em Um desafio da declaração dinâmica é que, como o gráfico de computação simbólico é definido novamente para cada exemplo de treinamento, sua construção deve ter uma sobrecarga baixa. Para conseguir isso, o DyNet possui um back-end C ++ otimizado e uma representação gráfica leve. As experiências mostram que as velocidades da DyNet são mais rápidas ou comparáveis ​​aos kits de ferramentas de declaração estática e significativamente mais rápidas que o Chainer, outro kit de ferramentas de declaração dinâmica. O DyNet é lançado de código aberto sob a licença Apache 2.0 e disponível em Um desafio da declaração dinâmica é que, como o gráfico de computação simbólico é definido novamente para cada exemplo de treinamento, sua construção deve ter uma sobrecarga baixa. Para conseguir isso, o DyNet possui um back-end C ++ otimizado e uma representação gráfica leve. As experiências mostram que as velocidades da DyNet são mais rápidas ou comparáveis ​​aos kits de ferramentas de declaração estática e significativamente mais rápidas que o Chainer, outro kit de ferramentas de declaração dinâmica. O DyNet é lançado de código aberto sob a licença Apache 2.0 e disponível emeste URL http

Era anteriormente conhecido como cnn (cuja ligação python foi denominada pycnn).

Referências:

• (1) Graham Neubig, Chris Dyer, Yoav Goldberg, Austin Matthews, Waleed Ammar, Antonios Anastasopoulos, Miguel Ballesteros, David Chiang, Daniel Clothiaux, Trevor Cohn, Trevor Cohn, Kevin Duh, Manaal Faruqui, Cynthia Gan, Dan Garrette, Yangfeng Ji, Lingpeng Kong Adhiguna Kuncoro, Gaurav Kumar, Chaitanya Malaviya, Paul Michel, Yusuke Oda, Matthew Richardson, Naomi Saphra, Swabha Swayamdipta, Pengcheng Yin. DyNet: O Dynamic Neural Network Toolkit. https://arxiv.org/abs/1701.03980

Eu recomendo que você use o tensorflow, que está em forte desenvolvimento e suporta aprendizado profundo. Você pode usar as APIs de redes neurais de alto nível API Keras, que são executadas sobre o fluxo tensor e são muito simples de usar, basta tentar um tutorial e você vai adorar.

PyTorch

Está ganhando muito suporte devido à sua facilidade de uso e semelhança com o Python básico.

Ele roda "linha por linha" (através de gráficos dinâmicos), assim como o Python normal e pode ser facilmente depurado - mesmo usando instruções de impressão padrão. Ele também se integra muito bem ao NumPy e outros linbraries Python conhecidos, como o Scikit Learn.

Como facilita a modelagem, é ótimo para criar protótipos e explorar novas idéias em geral.

Ele suporta várias GPUs e o faz de uma maneira muito fácil.

Confira mais recursos aqui .

Embora muitos dos benefícios acima tornem o PyTorch muito mais agradável de usar do que outras bibliotecas comumente usadas, vale ressaltar que a próxima versão principal do Tensorflow, por padrão, também usará a criação dinâmica de gráficos (também conhecido como modo ansioso ). Isso o tornará comparável ao PyTorch em uso.

Se você estiver interessado em comparações de desempenho, Soumith Chintala mantém um conjunto de parâmetros de convnet que cobrem várias das estruturas python já mencionadas ( TensorFlow , chainer , neon , Theano ):

• https://github.com/soumith/convnet-benchmarks

NeuPy é uma biblioteca Python para redes neurais artificiais. O NeuPy suporta muitos tipos diferentes de redes neurais, de um perceptron simples a modelos de aprendizado profundo.