La migliore libreria Python per reti neurali

Sto usando Neural Networks per risolvere diversi problemi di machine learning. Sto usando Python e pybrain ma questa libreria è quasi fuori produzione. Ci sono altre buone alternative in Python?

AGGIORNAMENTO: il panorama è cambiato un po 'da quando ho risposto a questa domanda nel luglio '14 e alcuni nuovi giocatori sono entrati nello spazio. In particolare, consiglierei di provare:

• tensorflow
• blocchi
• lasagne
• Keras
• Deepy
• Nolearn
• NeuPy

Ognuno di essi ha i suoi punti di forza e di debolezza, quindi provali tutti e vedi quale si adatta meglio al tuo caso d'uso. Anche se avrei raccomandato di usare PyLearn2 un anno fa, la community non è più attiva, quindi consiglierei di cercare altrove. La mia risposta originale alla risposta è inclusa di seguito ma è in gran parte irrilevante a questo punto.

PyLearn2 è generalmente considerata la libreria di scelta per le reti neurali e l'apprendimento profondo in Python. È progettato per una facile sperimentazione scientifica piuttosto che per la facilità d'uso, quindi la curva di apprendimento è piuttosto ripida, ma se prendi il tuo tempo e segui i tutorial penso che sarai soddisfatto della funzionalità che fornisce. Viene fornito di tutto, dai perceptron multistrato standard alle macchine Boltzmann limitate, dalle reti convoluzionali agli autocodificatori. C'è un ottimo supporto GPU e tutto è costruito sopra Theano, quindi le prestazioni sono in genere abbastanza buone. La fonte per PyLearn2 è disponibile su github .

Tieni presente che PyLearn2 al momento presenta il problema opposto di PyBrain: anziché essere abbandonato, PyLearn2 è in fase di sviluppo attivo ed è soggetto a frequenti cambiamenti.

Tensor Flow ( docs ) di Google è un altro bel framework che ha una differenziazione automatica. Ho scritto alcune brevi considerazioni su Google Tensor Flow sul mio blog, insieme all'esempio MNIST che hanno nel loro tutorial.

Vedi anche: Il mio tutorial su Tensorflow XOR

Lasagne ( documenti ) è molto bella, poiché usa theano (→ puoi usare la GPU) e ne semplifica l'utilizzo. L'autore di lasagne ha vinto la sfida Kaggle Galaxy, per quanto ne so. È bello con nolearn . Ecco una rete di esempio 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 è una libreria C ++, ma ha i collegamenti Python. Puoi fare la maggior parte delle cose dai file di configurazione (prototxt). Ha molte opzioni e può anche usare la GPU.

Pylearn si affida a Theano e, come menzionato nell'altra risposta, l'uso della libreria è piuttosto complicato, fino a quando non lo si ottiene.

Nel frattempo suggerirei di usare Theanets . Ha anche costruito sopra Theano, ma è molto più facile da lavorare. Potrebbe essere vero, che non ha tutte le caratteristiche di Pylearn, ma per il lavoro di base è sufficiente.

Inoltre è open source, quindi puoi aggiungere reti personalizzate al volo, se hai il coraggio. :)

EDIT: dic 2015. Di recente ho iniziato a usare Keras . È un po 'più basso di Theanets, ma molto più potente. Per i test di base i Theanets sono appropriati. Ma se vuoi fare qualche ricerca nel campo di ANN Keras è molto più flessibile. Inoltre le Keras possono usare Tensorflow come backend.

TensorFlow (di Google, rilasciato il 09/11/2015) sembra promettente.

• open source (licenza Apache 2.0) ( GitHub )
• Python (backend in C ++)
• CPU / GPU
• Auto-Differenziazione
• Portatile (funziona anche su dispositivi mobili)

PER TUA INFORMAZIONE:

• Valutazione di Deep Learning Toolkit
• Facilità di benchmarking di tutte le implementazioni pubbliche open-source di convnet.
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah. Studio comparativo di strutture software di apprendimento profondo . arXiv: 1.511,06,435 mila.
• Shaohuai Shi, Qiang Wang, Pengfei Xu, Xiaowen Chu. Analisi comparativa degli strumenti software di apprendimento avanzato all'avanguardia . arXiv: 1.608,07,249 mila
• Nel 2015 è stato rilasciato un nuovo toolkit di apprendimento profondo ogni 22 giorni?

Pylearn2 sembra essere la libreria preferita, tuttavia trovo scoraggianti i loro file di configurazione YAML.

Python stesso è stato progettato per essere un linguaggio semplice per la prototipazione, perché non dovresti usarlo per definire le proprietà della rete? Abbiamo grandi editor con completamento automatico che ti renderebbero la vita molto più semplice e Python non è come il C ++ dove devi aspettare che finiscano i build lunghi prima di poter eseguire il tuo codice.

D'altra parte, i file YAML devono essere modificati utilizzando un editor di testo standard senza assistenza e ciò rende la curva di apprendimento ancora più ripida.

Potrei mancare il quadro generale, ma ancora non capisco cosa stessero pensando, non penso che la prototipazione nel codice sarebbe molto più lenta. Per questo motivo sto prendendo in considerazione Theanets o usando direttamente Theano.

Mi piacciono i Blocks , anch'essi costruiti sopra Theano. Molto più accessibile di PyLearn2 e più ricco di funzionalità rispetto alle lasagne. Anche ben scritto.

Aggiornato gennaio 2016:

Al momento in cui scrivo, Keras ha di gran lunga il momento. È altamente modulare e può funzionare sia su Theano che su Tensorflow, offrendo grandi opportunità.

MXNet :

• scritto in C ++ ma ha un'API in Python (e alcuni altri linguaggi di programmazione come R, Julia e Go)
• Scala fino a più GPU e impostazioni distribuite con parallelismo automatico.
• Differenziazione automatica
• Spettacoli decenti:

Da quello che ho sentito, Pylearn2 potrebbe essere attualmente la biblioteca preferita per la maggior parte delle persone. Questo mi ricorda un recente post sul blog qualche mese fa che elenca tutte le diverse librerie di machine learning con una breve spiegazione

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

La sezione che potrebbe interessarti qui sarebbe "Deep Learning". A proposito di Pylearn2, scrive

PyLearn2

C'è un'altra libreria costruita sopra Theano, chiamata PyLearn2 che porta modularità e configurabilità a Theano dove potresti creare la tua rete neurale attraverso diversi file di configurazione in modo che sia più facile sperimentare parametri diversi. Probabilmente, fornisce più modularità separando i parametri e le proprietà della rete neurale nel file di configurazione.

Ho scritto questo post in dettaglio alcuni dei miei preferiti personali:

Le migliori librerie di machine learning in Python

Poiché sono menzionate oltre 30 librerie diverse, non le posterò tutte qui, ma queste sono tra le più popolari:

• tensorflow
• scikit-learn
• Theano
• Pylearn2
• Pyevolve
• NuPIC
• Modello
• Caffe

(Siamo spiacenti, non riesco a collegarmi ai repository Github poiché il mio rappresentante è ancora <10 ...)

Modifica: aggiunti collegamenti ai repository Github.

neon :

• Basato su Python
• Open source (licenza Apache 2.0)
• Sviluppato da Nervana Systems (se non li conosci: la startup di deep learning Nervana raccoglie $ 20,5 milioni ; Nervana Systems raccoglie 3,3 milioni di dollari per costruire hardware progettato per il deep learning )
• Supporta CPU e GPU
• Supporto di differenziazione automatica di base
• Framework per la visualizzazione

Solo per aggiungere altre risorse. Recentemente è stato pubblicato un documento che studiava le differenze tra diversi pacchetti di reti neurali e reti neurali profonde.

Qui puoi trovare le informazioni . Sembra che Torch e TensorFlow siano i vincitori.

Nota: non tutti sono in Python. Tuttavia, l'ho pubblicato per aprire la discussione.

Microsoft Cognition Toolkit (precedentemente noto come CNTK) ha un'API Python . Tra le altre cose, dovrebbe essere buono per multi-GPU :

Esempi e tutorial sono disponibili su https://github.com/Microsoft/CNTK/tree/master/bindings/python

DyNet: Dynamic Neural Network Toolkit. Da {1}:

Descriviamo DyNet, un toolkit per l'implementazione di modelli di reti neurali basati sulla dichiarazione dinamica della struttura della rete. Nella strategia di dichiarazione statica utilizzata in toolkit come Theano, CNTK e TensorFlow, l'utente definisce innanzitutto un grafico di calcolo (una rappresentazione simbolica del calcolo), quindi gli esempi vengono inseriti in un motore che esegue questo calcolo e calcola i suoi derivati . Nella strategia di dichiarazione dinamica di DyNet, la costruzione del grafico di calcolo è per lo più trasparente, essendo implicitamente costruita eseguendo codice procedurale che calcola gli output di rete e l'utente è libero di usare strutture di rete diverse per ciascun input. La dichiarazione dinamica facilita quindi l'implementazione di architetture di rete più complicate, e DyNet è specificamente progettato per consentire agli utenti di implementare i loro modelli in modo idiomatico nel loro linguaggio di programmazione preferito (C ++ o Python). Una sfida con la dichiarazione dinamica è che, poiché il grafico di calcolo simbolico è definito di nuovo per ogni esempio di addestramento, la sua costruzione deve avere un basso sovraccarico. Per raggiungere questo obiettivo, DyNet ha un backend C ++ ottimizzato e una rappresentazione grafica leggera. Gli esperimenti dimostrano che le velocità di DyNet sono più veloci o comparabili con i toolkit di dichiarazione statica e significativamente più veloci di Chainer, un altro toolkit di dichiarazione dinamica. DyNet è rilasciato open-source con licenza Apache 2.0 e disponibile su Una sfida con la dichiarazione dinamica è che, poiché il grafico di calcolo simbolico è definito di nuovo per ogni esempio di addestramento, la sua costruzione deve avere un basso sovraccarico. Per raggiungere questo obiettivo, DyNet ha un backend C ++ ottimizzato e una rappresentazione grafica leggera. Gli esperimenti dimostrano che le velocità di DyNet sono più veloci o comparabili con i toolkit di dichiarazione statica e significativamente più veloci di Chainer, un altro toolkit di dichiarazione dinamica. DyNet è rilasciato open-source con licenza Apache 2.0 e disponibile su Una sfida con la dichiarazione dinamica è che, poiché il grafico di calcolo simbolico è definito di nuovo per ogni esempio di addestramento, la sua costruzione deve avere un basso sovraccarico. Per raggiungere questo obiettivo, DyNet ha un backend C ++ ottimizzato e una rappresentazione grafica leggera. Gli esperimenti dimostrano che le velocità di DyNet sono più veloci o comparabili con i toolkit di dichiarazione statica e significativamente più veloci di Chainer, un altro toolkit di dichiarazione dinamica. DyNet è rilasciato open-source con licenza Apache 2.0 e disponibile suquesto URL http

In precedenza era noto come cnn (il cui binding python era chiamato pycnn).

Riferimenti:

• {1} Graham Neubig, Chris Dyer, Yoav Goldberg, Austin Matthews, Waleed Ammar, Antonios Anastasopoulos, Miguel Ballesteros, David Chiang, Daniel Clothiaux, 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: Dynamic Neural Network Toolkit. https://arxiv.org/abs/1701.03980

Vi consiglio di usare tensorflow che è in forte sviluppo e supporta l'apprendimento profondo. È possibile utilizzare l'reti neurali di alto livello API Keras che corre sulla parte superiore del tensorflow ed è molto semplice da usare, basta provare una lezione privata e si sta andando ad amarla.

PyTorch

Sta guadagnando molto supporto grazie alla sua facilità d'uso e alla somiglianza con Python di base.

Funziona "riga per riga" (tramite grafici dinamici), proprio come il normale Python e può essere facilmente eseguito il debug, anche utilizzando istruzioni di stampa standard. Si integra molto bene anche con NumPy e altri noti linbrari Python, come Scikit Learn.

Poiché semplifica la modellazione, è ideale per la prototipazione e l'esplorazione di nuove idee in generale.

Supporta più GPU e lo fa in un modo davvero semplice.

Scopri altre funzionalità qui .

Sebbene molti dei vantaggi di cui sopra rendano PyTorch molto più piacevole da usare rispetto ad altre librerie di uso comune, vale la pena ricordare che la prossima versione principale di Tensorflow utilizzerà, di default, anche la creazione di grafici dinamici (aka modalità desiderosa ). Questo lo renderà paragonabile a PyTorch in uso.

Se sei interessato ai confronti delle prestazioni, Soumith Chintala mantiene una serie di benchmark convnet che coprono molti dei già citati framework python ( TensorFlow , chainer , neon , Theano ):

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

NeuPy è una libreria Python per reti neurali artificiali. NeuPy supporta molti diversi tipi di reti neurali da un semplice perctrone a modelli di apprendimento profondo.