La mejor biblioteca de python para redes neuronales

Estoy usando redes neuronales para resolver diferentes problemas de aprendizaje automático. Estoy usando Python y pybrain pero esta biblioteca está casi descontinuada. ¿Hay otras buenas alternativas en Python?

ACTUALIZACIÓN: el panorama ha cambiado bastante desde que respondí esta pregunta en julio del '14, y algunos nuevos jugadores han entrado en el espacio. En particular, recomendaría revisar:

• TensorFlow
• Bloques
• Lasaña
• Keras
• Profundo
• Nolearn
• NeuPy

Cada uno tiene sus fortalezas y debilidades, así que pruébelos y vea cuál se adapta mejor a su caso de uso. Aunque hubiera recomendado usar PyLearn2 hace un año, la comunidad ya no está activa, por lo que recomendaría buscar en otro lado. Mi respuesta original a la respuesta se incluye a continuación, pero es en gran medida irrelevante en este punto.

PyLearn2 generalmente se considera la biblioteca de elección para redes neuronales y aprendizaje profundo en python. Está diseñado para facilitar la experimentación científica en lugar de la facilidad de uso, por lo que la curva de aprendizaje es bastante empinada, pero si te tomas tu tiempo y sigues los tutoriales, creo que estarás contento con la funcionalidad que proporciona. Se proporciona todo, desde perceptrones multicapa estándar hasta máquinas Boltzmann restringidas, redes convolucionales y codificadores automáticos. Hay una gran compatibilidad con GPU y todo está construido sobre Theano, por lo que el rendimiento suele ser bastante bueno. La fuente de PyLearn2 está disponible en github .

Tenga en cuenta que PyLearn2 tiene el problema opuesto de PyBrain en este momento: en lugar de ser abandonado, PyLearn2 está en desarrollo activo y está sujeto a cambios frecuentes.

Tensor Flow ( docs ) de Google es otro marco agradable que tiene diferenciación automática. He escrito algunas ideas rápidas sobre Google Tensor Flow en mi blog, junto con el ejemplo MNIST que tienen en su tutorial.

Ver también: Mi tutorial de Tensorflow XOR

Lasagne ( docs ) es muy agradable, ya que usa theano (→ puedes usar la GPU) y hace que sea más fácil de usar. El autor de lasaña ganó el desafío Kaggle Galaxy, que yo sepa. Es agradable con nolearn . Aquí hay una red de ejemplo 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 es una biblioteca de C ++, pero tiene enlaces de Python. Puede hacer la mayoría de las cosas mediante archivos de configuración (prototxt). Tiene muchas opciones y también puede hacer uso de la GPU.

Pylearn confía en Theano y, como se mencionó en la otra respuesta, usar la biblioteca es bastante complicado, hasta que lo consigues.

Mientras tanto, sugeriría usar Theanets . También se construyó sobre Theano, pero es mucho más fácil trabajar con él. Puede ser cierto que no tiene todas las características de Pylearn, pero para el trabajo básico es suficiente.

También es de código abierto, por lo que puede agregar redes personalizadas sobre la marcha, si se atreve. :)

EDITAR: diciembre de 2015. Recientemente comencé a usar Keras . Es un poco más bajo que Theanets, pero mucho más poderoso. Para pruebas básicas, Theanets es apropiado. Pero si quieres investigar un poco en el campo de ANN Keras es mucho más flexible. Además, los Keras pueden usar Tensorflow como backend.

TensorFlow (de Google, lanzado el 09/11/2015) parece prometedor.

• código abierto (licencia Apache 2.0) ( GitHub )
• Python (backend en C ++)
• CPU / GPU
• Auto-diferenciación
• Portátil (incluso funciona en dispositivos móviles)

FYI:

• Evaluación de kits de herramientas de aprendizaje profundo
• Fácil evaluación comparativa de todas las implementaciones públicas de código abierto de convnets.
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah. Estudio comparativo de marcos de software de aprendizaje profundo . arXiv: 1511.06435.
• Shaohuai Shi, Qiang Wang, Pengfei Xu, Xiaowen Chu. Evaluación comparativa de herramientas de software de aprendizaje profundo de última generación . arXiv: 1608.07249
• ¿Se lanzó un nuevo kit de herramientas de aprendizaje profundo una vez cada 22 días en 2015?

Pylearn2 parece ser la biblioteca de elección, sin embargo, encuentro sus archivos de configuración de YAML desagradables.

Python en sí fue diseñado para ser un lenguaje fácil para la creación de prototipos, ¿por qué no lo usarías para definir las propiedades de la red? Tenemos excelentes editores con autocompletado que le facilitarían la vida y Python no es como C ++, donde debe esperar a que finalicen las compilaciones largas antes de poder ejecutar su código.

Los archivos YAML, por otro lado, debe editarlos con un editor de texto estándar sin asistencia alguna y esto hace que la curva de aprendizaje sea aún más pronunciada.

Puede que me esté perdiendo el panorama general, pero todavía no entiendo qué estaban pensando, no creo que la creación de prototipos en el código sea mucho más lenta. Por esa razón, estoy considerando Theanets o usando Theano directamente.

Me gustan los bloques , que también están construidos sobre Theano. Mucho más accesible que PyLearn2, y más funciones ricas que Lasagne. Bien escrito, también.

Actualizado en enero de 2016:

Al momento de escribir, Keras tiene, con mucho, el mayor impulso. Es altamente modular y puede ejecutarse tanto en Theano como en Tensorflow, lo que le brinda grandes oportunidades.

MXNet :

• escrito en C ++ pero tiene una API en Python (y algunos otros lenguajes de programación como R, Julia y Go)
• Escala hasta múltiples GPU y configuración distribuida con paralelismo automático.
• Diferenciación automática
• Actuaciones decentes:

Por lo que escuché, Pylearn2 podría ser actualmente la biblioteca de elección para la mayoría de las personas. Esto me recuerda una reciente publicación de blog hace unos meses que enumera todas las diferentes bibliotecas de aprendizaje automático con una breve explicación.

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

La sección que podría interesarle aquí sería "Aprendizaje profundo". Sobre Pylearn2, escribe

PyLearn2

Hay otra biblioteca construida sobre Theano, llamada PyLearn2, que brinda modularidad y configurabilidad a Theano, donde podría crear su red neuronal a través de diferentes archivos de configuración para que sea más fácil experimentar diferentes parámetros. Podría decirse que proporciona más modularidad al separar los parámetros y propiedades de la red neuronal en el archivo de configuración.

Escribí esta publicación detallando algunos de mis favoritos personales:

Las mejores bibliotecas de aprendizaje automático en Python

Como se mencionan más de 30 bibliotecas diferentes, no las publicaré todas aquí, pero estas se encuentran entre las más populares:

• Tensorflow
• scikit-learn
• Theano
• Pylearn2
• Pyevolve
• NuPIC
• Modelo
• Cafe

(Lo siento, no puedo vincular a los repositorios de Github ya que mi representante todavía es <10 ...)

Editar: se agregaron enlaces a repositorios de Github.

neón :

• Basado en Python
• Código abierto (licencia Apache 2.0)
• Desarrollado por Nervana Systems (si no los conoce: la startup de aprendizaje profundo Nervana recauda $ 20.5M ; Nervana Systems recauda 3.3M USD para construir hardware diseñado para el aprendizaje profundo )
• Soporta CPU y GPU
• Soporte básico de diferenciación automática.
• Marco para visualización

Solo para agregar algunos recursos más. Recientemente hubo un artículo que estudiaba las diferencias entre varios paquetes de redes neuronales y redes neuronales profundas.

Aquí puedes encontrar la información . Parece que Torch y TensorFlow son los ganadores.

Nota: no todos están en python. Sin embargo, lo publiqué para abrir la discusión.

Microsoft Cognition Toolkit (anteriormente conocido como CNTK) tiene una API de Python . Entre otras cosas, se supone que es bueno para múltiples GPU :

Se pueden encontrar ejemplos y tutoriales en https://github.com/Microsoft/CNTK/tree/master/bindings/python

DyNet: el kit de herramientas de red neuronal dinámica. De 1}:

Describimos DyNet, un conjunto de herramientas para implementar modelos de redes neuronales basadas en la declaración dinámica de la estructura de la red. En la estrategia de declaración estática que se usa en kits de herramientas como Theano, CNTK y TensorFlow, el usuario primero define un gráfico de cálculo (una representación simbólica del cálculo), y luego los ejemplos se introducen en un motor que ejecuta este cálculo y calcula sus derivados . En la estrategia de declaración dinámica de DyNet, la construcción del gráfico de cómputo es mayormente transparente, se construye implícitamente ejecutando código de procedimiento que computa las salidas de la red, y el usuario es libre de usar diferentes estructuras de red para cada entrada. La declaración dinámica facilita la implementación de arquitecturas de red más complicadas, y DyNet está específicamente diseñado para permitir a los usuarios implementar sus modelos de una manera idiomática en su lenguaje de programación preferido (C ++ o Python). Un desafío con la declaración dinámica es que debido a que el gráfico de cálculo simbólico se define nuevamente para cada ejemplo de entrenamiento, su construcción debe tener una baja sobrecarga. Para lograr esto, DyNet tiene un backend C ++ optimizado y una representación gráfica liviana. Los experimentos muestran que las velocidades de DyNet son más rápidas o comparables con los kits de herramientas de declaración estática, y significativamente más rápido que Chainer, otro kit de herramientas de declaración dinámica. DyNet se lanza de código abierto bajo la licencia Apache 2.0 y está disponible en Un desafío con la declaración dinámica es que debido a que el gráfico de cálculo simbólico se define nuevamente para cada ejemplo de entrenamiento, su construcción debe tener una baja sobrecarga. Para lograr esto, DyNet tiene un backend C ++ optimizado y una representación gráfica liviana. Los experimentos muestran que las velocidades de DyNet son más rápidas o comparables con los kits de herramientas de declaración estática, y significativamente más rápido que Chainer, otro kit de herramientas de declaración dinámica. DyNet se lanza de código abierto bajo la licencia Apache 2.0 y está disponible en Un desafío con la declaración dinámica es que debido a que el gráfico de cálculo simbólico se define nuevamente para cada ejemplo de entrenamiento, su construcción debe tener una baja sobrecarga. Para lograr esto, DyNet tiene un backend C ++ optimizado y una representación gráfica liviana. Los experimentos muestran que las velocidades de DyNet son más rápidas o comparables con los kits de herramientas de declaración estática, y significativamente más rápido que Chainer, otro kit de herramientas de declaración dinámica. DyNet se lanza de código abierto bajo la licencia Apache 2.0 y está disponible enesta URL http

Anteriormente se conocía como cnn (cuyo enlace a Python se llamaba pycnn).

Referencias

• {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: el kit de herramientas de red neuronal dinámica. https://arxiv.org/abs/1701.03980

Te recomiendo que uses tensorflow, que está en desarrollo y es compatible con el aprendizaje profundo. Puede usar las Keras API de redes neuronales de alto nivel que se ejecutan sobre tensorflow y es muy simple de usar, solo pruebe un tutorial y le encantará.

PyTorch

Está ganando mucho apoyo debido a su facilidad de uso y similitud con Python básico.

Se ejecuta "línea por línea" (a través de gráficos dinámicos), al igual que Python normal y se puede depurar fácilmente, incluso utilizando declaraciones de impresión estándar. También se integra muy bien con NumPy y otras bibliotecas de Python conocidas, como Scikit Learn.

Debido a que facilita el modelado, es ideal para crear prototipos y explorar nuevas ideas en general.

Es compatible con múltiples GPU y lo hace de una manera realmente fácil.

Mira más características aquí .

Aunque muchos de los beneficios anteriores hacen que PyTorch sea mucho más agradable de usar que otras bibliotecas de uso común, vale la pena mencionar que la próxima versión principal de Tensorflow, por defecto, también usará la creación de gráficos dinámicos (también conocido como modo ansioso ). Esto lo hará comparable a PyTorch en uso.

Si está interesado en las comparaciones de rendimiento, Soumith Chintala mantiene un conjunto de puntos de referencia de convnet que cubren varios de los marcos de python ya mencionados ( TensorFlow , chainer , neon , Theano ):

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

NeuPy es una biblioteca de Python para redes neuronales artificiales. NeuPy admite muchos tipos diferentes de redes neuronales, desde un perceptrón simple hasta modelos de aprendizaje profundo.