Meilleure librairie python pour réseaux de neurones

J'utilise des réseaux de neurones pour résoudre différents problèmes d'apprentissage machine. J'utilise Python et Pybrain mais cette bibliothèque est presque abandonnée. Existe-t-il d'autres bonnes alternatives en Python?

MISE À JOUR: le paysage a beaucoup changé depuis que j'ai répondu à cette question en juillet 2014 et de nouveaux joueurs sont entrés dans l'espace. En particulier, je recommanderais de vérifier:

• TensorFlow
• Des blocs
• Lasagne
• Keras
• Profond
• Nolearn
• NeuPy

Ils ont chacun leurs forces et leurs faiblesses, alors essayez-les et voyez ce qui convient le mieux à votre cas d'utilisation. Bien que j'aurais recommandé d'utiliser PyLearn2 il y a un an, la communauté n'étant plus active, je vous recommande de regarder ailleurs. Ma réponse initiale à la réponse est incluse ci-dessous mais est en grande partie hors de propos à ce stade.

PyLearn2 est généralement considéré comme la bibliothèque de choix pour les réseaux de neurones et l’apprentissage en profondeur en python. Il est conçu pour une expérimentation scientifique facile plutôt que pour une utilisation facile. La courbe d'apprentissage est donc assez raide, mais si vous prenez votre temps et suivez les tutoriels, je pense que vous serez satisfait de la fonctionnalité fournie. Tout, des perceptrons multicouches standard aux machines Boltzmann restreintes aux réseaux de convolution en passant par les autoencodeurs est fourni. Le support GPU est excellent et tout est construit sur Theano. Les performances sont donc plutôt bonnes. La source de PyLearn2 est disponible sur github .

Sachez que PyLearn2 a le problème opposé de PyBrain pour le moment. Plutôt que d’être abandonné, PyLearn2 fait actuellement l’objet d’un développement actif et est sujet à de fréquents changements.

Tensor Flow ( Google Documents ) de Google est un autre cadre agréable à différenciation automatique. J'ai rédigé quelques réflexions rapides sur Google Tensor Flow sur mon blog, ainsi que l'exemple MNIST présenté dans leur didacticiel.

Voir aussi: Mon tutoriel Tensorflow XOR

Lasagne ( docs ) est très agréable, car il utilise le théo (→ vous pouvez utiliser le GPU) et le rend plus simple à utiliser. L'auteur de lasagnes a remporté le défi Kaggle Galaxy, à ma connaissance. C'est gentil avec nolearn . Voici un exemple de réseau 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 est une bibliothèque C ++, mais possède des liaisons Python. Vous pouvez faire la plupart des choses avec des fichiers de configuration (prototxt). Il a beaucoup d'options et peut également utiliser le GPU.

Pylearn s’appuie sur Theano et, comme mentionné dans l’autre réponse, utiliser la bibliothèque est assez compliqué, jusqu’à ce que vous en ayez le contrôle.

En attendant, je suggère d'utiliser Theanets . Il a également été construit sur Theano, mais il est beaucoup plus facile de travailler avec. C'est peut-être vrai qu'il ne possède pas toutes les fonctionnalités de Pylearn, mais pour le travail de base, cela suffit.

En outre, il est open source, vous pouvez donc ajouter des réseaux personnalisés à la volée, si vous osez. :)

EDIT: Dec 2015. Récemment, j'ai commencé à utiliser Keras . C'est un peu plus bas que Theanets, mais beaucoup plus puissant. Theanets est approprié pour les tests de base. Mais si vous voulez faire des recherches dans le domaine de ANN, Keras est beaucoup plus flexible. De plus, les Keras peuvent utiliser Tensorflow comme back -end.

TensorFlow (par Google, publié le 09/11/2015) semble prometteur.

• open source (licence Apache 2.0) ( GitHub )
• Python (backend en C ++)
• CPU / GPU
• Auto-différenciation
• Portable (fonctionne même sur les appareils mobiles)

FYI:

• Évaluation des kits d'apprentissage en profondeur
• Analyse comparative simple de toutes les implémentations publiques à code source ouvert de convnets.
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah. Étude comparative des cadres logiciels d'apprentissage en profondeur . arXiv: 1511.06435.
• Shaohuai Shi, Qiang Wang, Pengfei Xu, Xiaowen Chu. Analyse comparative des outils logiciels d’apprentissage en profondeur à la pointe de la technologie . arXiv: 1608.07249
• Une nouvelle boîte à outils d'apprentissage en profondeur a-t-elle été publiée tous les 22 jours en 2015?

Pylearn2 semble être la bibliothèque de choix, mais je trouve leurs fichiers de configuration YAML déconcertants.

Python lui-même a été conçu pour être un langage simple pour le prototypage. Pourquoi ne l' utilisez- vous pas pour définir les propriétés du réseau elles-mêmes? Nous avons d'excellents éditeurs dotés de fonctions d'auto-complétion qui vous faciliteraient grandement la vie. Python n'est pas comme le C ++ où vous devez attendre de longues générations pour pouvoir exécuter votre code.

Les fichiers YAML, d’autre part, vous devez les éditer à l’aide d’un éditeur de texte standard sans aucune aide, ce qui rend la courbe d’apprentissage encore plus raide.

Il se peut que je manque la vue d'ensemble mais je ne comprends toujours pas à quoi ils pensaient. Je ne pense pas que le prototypage en code serait beaucoup plus lent. Pour cette raison, je considère Theanets ou j'utilise Theano directement.

J'aime Blocks , qui est également construit sur Theano. Bien plus accessible que PyLearn2 et plus riche en fonctionnalités que Lasagne. Soigneusement écrit, aussi.

Mis à jour en janvier 2016:

Au moment de la rédaction, Keras a de loin le plus d’élan. Il est hautement modulaire et peut fonctionner à la fois sur Theano et Tensorflow, ce qui lui donne de grandes opportunités.

MXNet :

• écrit en C ++ mais possède une API en Python (et quelques autres langages de programmation tels que R, Julia et Go)
• Échelle jusqu'à plusieurs GPU et configuration distribuée avec parallélisme automatique.
• Différenciation automatique
• Performances décentes:

D'après ce que j'ai entendu, Pylearn2 pourrait être actuellement la bibliothèque de choix pour la plupart des gens. Cela me rappelle un récent article de blog publié il y a quelques mois, qui répertorie toutes les différentes bibliothèques d'apprentissage machine avec une courte explication.

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

La section qui pourrait vous intéresser serait "Apprentissage en profondeur". À propos de Pylearn2, écrit-il

PyLearn2

Il existe une autre bibliothèque construite au-dessus de Theano, appelée PyLearn2, qui apporte modularité et configurabilité à Theano, où vous pouvez créer votre réseau de neurones à l'aide de différents fichiers de configuration, de manière à faciliter l'expérimentation de différents paramètres. On peut dire que cela offre plus de modularité en séparant les paramètres et les propriétés du réseau de neurones dans le fichier de configuration.

J'ai écrit ce post en détaillant certains de mes favoris personnels:

Les meilleures bibliothèques d'apprentissage machine en Python

Comme plus de 30 bibliothèques différentes sont mentionnées, je ne les posterai pas toutes ici, mais celles-ci sont parmi les plus populaires:

• Tensorflow
• scikit-learn
• Theano
• Pylearn2
• Pyramide
• NuPIC
• Modèle
• Caffe

(Désolé, impossible de créer un lien vers le dépôt Github puisque mon représentant est toujours <10 ...)

Edit: Ajout de liens vers les dépôts Github.

néon :

• À base de python
• Open source (licence Apache 2.0)
• Développé par Nervana Systems (si vous ne les connaissez pas: la start-up d'apprentissage en profondeur Nervana lève 20,5 millions de dollars ; Nervana Systems lève 3,3 millions USD pour construire du matériel conçu pour l'apprentissage en profondeur )
• Prend en charge le processeur et le processeur graphique
• Support de base de la différenciation automatique
• Cadre de visualisation

Juste pour ajouter quelques ressources supplémentaires. Récemment, un article a étudié les différences entre plusieurs ensembles de réseaux de neurones et de réseaux de neurones profonds.

Ici vous pouvez trouver l' information . Il semble que Torch et TensorFlow soient les gagnants.

Note: tous ne sont pas en python. Cependant, je l'ai posté pour ouvrir la discussion.

Microsoft Cognition Toolkit (anciennement CNTK) dispose d'une API Python . Entre autres choses, cela est supposé être bon pour le multi-GPU :

Des exemples et des tutoriels sont disponibles sur https://github.com/Microsoft/CNTK/tree/master/bindings/python.

DyNet: la boîte à outils du réseau neuronal dynamique. À partir de 1}:

Nous décrivons DyNet, une boîte à outils pour la mise en œuvre de modèles de réseau de neurones basés sur la déclaration dynamique de la structure de réseau. Dans la stratégie de déclaration statique utilisée dans des boîtes à outils telles que Theano, CNTK et TensorFlow, l'utilisateur définit d'abord un graphe de calcul (représentation symbolique du calcul), puis des exemples sont introduits dans un moteur qui exécute ce calcul et en calcule les dérivés. . Dans la stratégie de déclaration dynamique de DyNet, la construction du graphe de calcul est généralement transparente. Elle est implicitement construite en exécutant un code de procédure qui calcule les sorties du réseau, et l'utilisateur est libre d'utiliser différentes structures de réseau pour chaque entrée. La déclaration dynamique facilite ainsi la mise en œuvre d'architectures de réseau plus complexes. et DyNet est spécialement conçu pour permettre aux utilisateurs d’implémenter leurs modèles d’une manière idiomatique dans leur langage de programmation préféré (C ++ ou Python). Un défi avec la déclaration dynamique est que, comme le graphe de calcul symbolique est défini à nouveau pour chaque exemple d’entraînement, sa construction doit être peu onéreuse. Pour ce faire, DyNet dispose d’un backend C ++ optimisé et d’une représentation graphique légère. Les expériences ont montré que les vitesses de DyNet sont supérieures ou comparables à celles des outils de déclaration statique et nettement plus rapides que Chainer, un autre outil de déclaration dynamique. DyNet est publié open-source sous la licence Apache 2.0 et disponible à l'adresse Un défi avec la déclaration dynamique est que, comme le graphe de calcul symbolique est défini à nouveau pour chaque exemple d’entraînement, sa construction doit être peu onéreuse. Pour ce faire, DyNet dispose d’un backend C ++ optimisé et d’une représentation graphique légère. Les expériences ont montré que les vitesses de DyNet sont supérieures ou comparables à celles des outils de déclaration statique et nettement plus rapides que Chainer, un autre outil de déclaration dynamique. DyNet est publié open-source sous la licence Apache 2.0 et disponible à l'adresse Un défi avec la déclaration dynamique est que, comme le graphe de calcul symbolique est défini à nouveau pour chaque exemple d’entraînement, sa construction doit être peu onéreuse. Pour ce faire, DyNet dispose d’un backend C ++ optimisé et d’une représentation graphique légère. Les expériences ont montré que les vitesses de DyNet sont supérieures ou comparables à celles des outils de déclaration statique et nettement plus rapides que Chainer, un autre outil de déclaration dynamique. DyNet est publié open-source sous la licence Apache 2.0 et disponible à l'adressecette URL http

Il était auparavant connu sous le nom de cnn (dont la liaison python était appelée pycnn).

Références:

• {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: la boîte à outils du réseau neuronal dynamique. https://arxiv.org/abs/1701.03980

Je vous recommande d'utiliser tensorflow, qui est en plein développement et soutient l'apprentissage en profondeur. Vous pouvez utiliser l'API Keras de réseaux de neurones de haut niveau qui fonctionne au-dessus de tensorflow et est très simple à utiliser. Essayez simplement un didacticiel et vous allez l'adorer.

PyTorch

Il gagne beaucoup de soutien en raison de sa facilité d'utilisation et de sa similitude avec Python de base.

Il fonctionne "ligne par ligne" (via des graphiques dynamiques), tout comme Python normal et peut être facilement débogué - même à l'aide d'instructions d'impression standard. Il s'intègre également très bien avec NumPy et d'autres linbraries Python bien connues, comme Scikit Learn.

Parce que cela facilite la modélisation, il est idéal pour le prototypage et l'exploration de nouvelles idées en général.

Il prend en charge plusieurs processeurs graphiques de manière très simple.

Découvrez plus de fonctionnalités ici .

Bien que de nombreux avantages décrits ci-dessus rendent PyTorch beaucoup plus agréable à utiliser que d’autres bibliothèques couramment utilisées, il convient de noter que la version majeure à venir de Tensorflow utilisera également, par défaut, la création de graphes dynamiques ( mode rapide ). Cela le rendra comparable à PyTorch en utilisation.

Si vous êtes intéressé par les comparaisons de performances, Soumith Chintala maintient un ensemble de repères convnet qui couvrent plusieurs des frameworks python déjà mentionnés ( TensorFlow , chainer , neon , Theano ):

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

NeuPy est une bibliothèque Python pour les réseaux de neurones artificiels. NeuPy prend en charge de nombreux types de réseaux de neurones allant du simple perceptron aux modèles d'apprentissage en profondeur.