Pustaka python terbaik untuk jaringan saraf

Saya menggunakan Neural Networks untuk memecahkan berbagai masalah pembelajaran Mesin. Saya menggunakan Python dan pybrain tetapi pustaka ini hampir dihentikan. Apakah ada alternatif lain yang baik di Python?

UPDATE: lanskap telah berubah sedikit sejak saya menjawab pertanyaan ini pada Juli '14, dan beberapa pemain baru telah memasuki ruang. Secara khusus, saya akan merekomendasikan memeriksa:

• TensorFlow
• Blok
• lasagna
• Keras
• Deepy
• Nolearn
• NeuPy

Masing-masing memiliki kekuatan dan kelemahan, jadi cobalah semuanya dan lihat mana yang paling sesuai dengan use case Anda. Meskipun saya akan merekomendasikan menggunakan PyLearn2 setahun yang lalu, komunitas tidak lagi aktif jadi saya akan merekomendasikan mencari di tempat lain. Respons orisinal saya untuk jawabannya dimasukkan di bawah ini tetapi sebagian besar tidak relevan pada saat ini.

PyLearn2 umumnya dianggap sebagai perpustakaan pilihan untuk jaringan saraf dan pembelajaran mendalam dengan python. Ini dirancang untuk eksperimen ilmiah yang mudah daripada kemudahan penggunaan, sehingga kurva belajarnya agak curam, tetapi jika Anda mengambil waktu Anda dan mengikuti tutorial saya pikir Anda akan senang dengan fungsi yang disediakannya. Semuanya mulai dari Multilayer Perceptrons standar hingga Mesin Boltzmann Terbatas hingga Jaring Konvolusional ke Autoencoder disediakan. Ada dukungan GPU yang hebat dan semuanya dibangun di atas Theano, jadi kinerjanya biasanya cukup baik. Sumber untuk PyLearn2 tersedia di github .

Ketahuilah bahwa PyLearn2 memiliki masalah yang berlawanan dengan PyBrain saat ini - daripada ditinggalkan, PyLearn2 sedang dalam pengembangan aktif dan dapat mengalami perubahan yang sering.

Tensor Flow ( docs ) oleh Google adalah kerangka kerja bagus lainnya yang memiliki diferensiasi otomatis. Saya telah menuliskan beberapa pemikiran cepat tentang Google Tensor Flow di blog saya, bersama dengan contoh MNIST yang mereka miliki dalam tutorial mereka.

Lihat juga: tutorial Tensorflow XOR saya

Lasagna ( dokumen ) sangat bagus, karena menggunakan theano (→ Anda dapat menggunakan GPU) dan membuatnya lebih mudah untuk digunakan. Penulis lasagna memenangkan tantangan Kaggle Galaxy, sejauh yang saya tahu. Ini bagus dengan nolearn . Berikut ini contoh jaringan 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 adalah pustaka C ++, tetapi memiliki binding Python. Anda dapat melakukan sebagian besar hal dengan file konfigurasi (prototxt). Ini memiliki banyak pilihan dan juga dapat menggunakan GPU.

Pylearn mengandalkan Theano dan seperti yang disebutkan dalam jawaban lain untuk menggunakan perpustakaan itu cukup rumit, sampai Anda dapat menemukannya.

Sementara itu saya akan menyarankan menggunakan Theanets . Itu juga dibangun di atas Theano, tetapi jauh lebih mudah untuk dikerjakan. Mungkin benar, bahwa ia tidak memiliki semua fitur Pylearn, tetapi untuk pekerjaan dasar itu sudah cukup.

Ini juga open source, sehingga Anda dapat menambahkan jaringan kustom dengan cepat, jika Anda berani. :)

EDIT: Des 2015. Baru-baru ini saya mulai menggunakan Keras . Levelnya sedikit lebih rendah daripada Theanets, tetapi jauh lebih kuat. Untuk tes dasar, Theanets sesuai. Tetapi jika Anda ingin melakukan penelitian di bidang ANN Keras jauh lebih fleksibel. Plus Keras dapat menggunakan Tensorflow sebagai backend.

TensorFlow (oleh Google, dirilis pada 2015-11-09) terlihat menjanjikan.

• open source (Lisensi Apache 2.0) ( GitHub )
• Python (backend dalam C ++)
• CPU / GPU
• Diferensiasi Otomatis
• Portable (bahkan berfungsi pada perangkat seluler)

FYI:

• Evaluasi Perangkat Pembelajaran Mendalam
• Penentuan tolok ukur yang mudah dari semua implementasi open-source publik dari convnets.
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah. Studi Banding Kerangka Kerja Perangkat Lunak Pembelajaran Jauh . arXiv: 1511.06435.
• Shaohuai Shi, Qiang Wang, Pengfei Xu, Xiaowen Chu. Alat Perangkat Lunak Pembelajaran Deep-Benchmarking yang Mutakhir . arXiv: 1608.07249
• Apakah toolkit pembelajaran mendalam yang baru dirilis setiap 22 hari pada tahun 2015?

Pylearn2 tampaknya menjadi pustaka pilihan, namun saya menemukan file konfigurasi YAML mereka tidak cocok.

Python sendiri dirancang untuk menjadi bahasa yang mudah untuk pembuatan prototipe, mengapa Anda tidak menggunakannya untuk mendefinisikan properti jaringan itu sendiri? Kami memiliki editor hebat dengan pelengkapan otomatis yang akan membuat hidup Anda jauh lebih mudah dan Python tidak seperti C ++ di mana Anda harus menunggu lama dibangun untuk menyelesaikannya sebelum Anda dapat menjalankan kode Anda.

File YAML di sisi lain Anda harus mengedit menggunakan editor teks standar tanpa bantuan apa pun dan ini membuat kurva belajar lebih curam.

Saya mungkin kehilangan gambaran besar tetapi saya masih tidak mengerti apa yang mereka pikirkan, saya tidak berpikir prototyping dalam kode akan jauh lebih lambat. Untuk alasan itu saya mempertimbangkan Theanets atau menggunakan Theano secara langsung.

Saya suka Blok , yang juga dibangun di atas Theano. Jauh lebih mudah didekati daripada PyLearn2, dan lebih kaya fitur daripada Lasagna. Ditulis dengan rapi juga.

Diperbarui Jan 2016:

Pada saat penulisan, Keras memiliki momentum paling besar. Ini sangat modular dan dapat berjalan di kedua Theano dan Tensorflow, memberikannya peluang besar.

MXNet :

• ditulis dalam C ++ tetapi memiliki API dalam Python (dan beberapa bahasa pemrograman lain seperti R, Julia, dan Go)
• Memperbesar hingga multi GPU dan pengaturan terdistribusi dengan paralelisme otomatis.
• Diferensiasi otomatis
• Penampilan yang layak:

Dari apa yang saya dengar, Pylearn2 mungkin saat ini menjadi perpustakaan pilihan bagi kebanyakan orang. Ini mengingatkan saya pada posting blog baru-baru ini beberapa bulan yang lalu yang mencantumkan semua perpustakaan pembelajaran mesin yang berbeda dengan penjelasan singkat

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

Bagian yang Anda mungkin tertarik di sini adalah "Belajar Dalam". Tentang Pylearn2, dia menulis

PyLearn2

Ada perpustakaan lain yang dibangun di atas Theano, yang disebut PyLearn2 yang membawa modularitas dan konfigurabilitas ke Theano di mana Anda dapat membuat jaringan saraf Anda melalui file konfigurasi yang berbeda sehingga akan lebih mudah untuk bereksperimen dengan parameter yang berbeda. Dapat diperdebatkan, ia menyediakan lebih banyak modularitas dengan memisahkan parameter dan properti jaringan saraf ke file konfigurasi.

Saya menulis posting ini yang merinci beberapa favorit pribadi saya:

Perpustakaan Pembelajaran Mesin Terbaik dengan Python

Karena lebih dari 30 perpustakaan berbeda disebutkan, saya tidak akan memposting semuanya di sini, tetapi ini adalah yang paling populer:

• Tensorflow
• scikit-pelajari
• Theano
• Pylearn2
• Pyevolve
• NuPIC
• Pola
• Caffe

(Maaf, tidak dapat menautkan ke repo Github karena rep saya masih <10 ...)

Sunting: Menambahkan tautan ke repo Github.

neon :

• Berbasis python
• Sumber terbuka (Lisensi Apache 2.0)
• Dikembangkan oleh Nervana Systems (jika Anda tidak mengetahuinya: Startup pembelajaran yang dalam, Nervana menghasilkan $ 20,5 juta ; Nervana Systems memperoleh 3,3 juta USD untuk membangun perangkat keras yang dirancang untuk pembelajaran yang mendalam )
• Mendukung CPU dan GPU
• Dukungan diferensiasi otomatis dasar
• Kerangka kerja untuk visualisasi

Hanya dengan menambahkan beberapa sumber daya lagi. Baru-baru ini ada sebuah makalah yang mempelajari perbedaan antara beberapa paket jaringan saraf dan jaringan saraf dalam.

Di sini Anda dapat menemukan informasinya . Tampaknya Torch dan TensorFlow adalah pemenangnya.

Catatan: tidak semuanya dalam python. Namun, saya mempostingnya untuk membuka diskusi.

Microsoft Cognition Toolkit (sebelumnya dikenal sebagai CNTK) memiliki API Python . Di antara hal-hal lain, itu seharusnya baik untuk multi-GPU :

Contoh dan tutorial dapat ditemukan di https://github.com/Microsoft/CNTK/tree/master/bindings/python

DyNet: The Dynamic Neural Network Toolkit. Dari {1}:

Kami mendeskripsikan DyNet, toolkit untuk menerapkan model jaringan saraf berdasarkan deklarasi dinamis struktur jaringan. Dalam strategi deklarasi statis yang digunakan dalam toolkit seperti Theano, CNTK, dan TensorFlow, pengguna pertama-tama mendefinisikan grafik perhitungan (representasi simbolis dari perhitungan), dan kemudian contoh dimasukkan ke dalam mesin yang mengeksekusi perhitungan ini dan menghitung turunannya. . Dalam strategi deklarasi dinamis DyNet, konstruksi grafik komputasi sebagian besar transparan, dibangun secara implisit dengan mengeksekusi kode prosedural yang menghitung output jaringan, dan pengguna bebas menggunakan struktur jaringan yang berbeda untuk setiap input. Deklarasi dinamis dengan demikian memfasilitasi implementasi arsitektur jaringan yang lebih rumit, dan DyNet secara khusus dirancang untuk memungkinkan pengguna untuk mengimplementasikan model mereka dengan cara yang idiomatis dalam bahasa pemrograman pilihan mereka (C ++ atau Python). Satu tantangan dengan deklarasi dinamis adalah karena grafik perhitungan simbolik didefinisikan kembali untuk setiap contoh pelatihan, konstruksinya harus memiliki overhead yang rendah. Untuk mencapai hal ini, DyNet memiliki backend C ++ yang dioptimalkan dan representasi grafik yang ringan. Eksperimen menunjukkan bahwa kecepatan DyNet lebih cepat atau sebanding dengan toolkit deklarasi statis, dan secara signifikan lebih cepat dari Chainer, toolkit deklarasi dinamis lainnya. DyNet dirilis open-source di bawah lisensi Apache 2.0 dan tersedia di Satu tantangan dengan deklarasi dinamis adalah karena grafik perhitungan simbolik didefinisikan kembali untuk setiap contoh pelatihan, konstruksinya harus memiliki overhead yang rendah. Untuk mencapai hal ini, DyNet memiliki backend C ++ yang dioptimalkan dan representasi grafik yang ringan. Eksperimen menunjukkan bahwa kecepatan DyNet lebih cepat atau sebanding dengan toolkit deklarasi statis, dan secara signifikan lebih cepat dari Chainer, toolkit deklarasi dinamis lainnya. DyNet dirilis open-source di bawah lisensi Apache 2.0 dan tersedia di Satu tantangan dengan deklarasi dinamis adalah karena grafik perhitungan simbolik didefinisikan kembali untuk setiap contoh pelatihan, konstruksinya harus memiliki overhead yang rendah. Untuk mencapai hal ini, DyNet memiliki backend C ++ yang dioptimalkan dan representasi grafik yang ringan. Eksperimen menunjukkan bahwa kecepatan DyNet lebih cepat atau sebanding dengan toolkit deklarasi statis, dan secara signifikan lebih cepat dari Chainer, toolkit deklarasi dinamis lainnya. DyNet dirilis open-source di bawah lisensi Apache 2.0 dan tersedia diURL http ini

Itu sebelumnya dikenal sebagai cnn (yang mengikat python bernama pycnn).

Referensi:

• {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: The Dynamic Neural Network Toolkit. https://arxiv.org/abs/1701.03980

Saya merekomendasikan Anda untuk menggunakan tensorflow yang berada di bawah pengembangan yang kuat dan mendukung pembelajaran yang mendalam. Anda dapat menggunakan jaringan saraf tingkat tinggi API Keras yang berjalan di atas tensorflow dan sangat mudah digunakan, cukup coba tutorial dan Anda akan menyukainya.

PyTorch

Ini mendapatkan banyak dukungan karena kemudahan penggunaan dan kesamaan dengan Python dasar.

Ia menjalankan "baris demi baris" (melalui grafik dinamis), seperti halnya Python normal dan dapat dengan mudah didebug - bahkan menggunakan pernyataan cetak standar. Ia juga terintegrasi dengan sangat baik dengan NumPy dan linbrary Python terkenal lainnya, seperti Scikit Learn.

Karena membuat pemodelan menjadi mudah, sangat bagus untuk membuat prototipe dan menjelajahi ide-ide baru secara umum.

Ini mendukung banyak GPU dan melakukannya dengan cara yang sangat mudah.

Lihat lebih banyak fitur di sini .

Meskipun banyak manfaat di atas membuat PyTorch jauh lebih bagus untuk digunakan daripada perpustakaan yang biasa digunakan lainnya, perlu disebutkan bahwa rilis utama Tensorflow yang akan datang, secara default, juga akan menggunakan pembuatan grafik dinamis (alias mode bersemangat ). Ini akan membuatnya sebanding dengan PyTorch dalam penggunaan.

Jika Anda tertarik pada perbandingan kinerja, Soumith Chintala mempertahankan serangkaian tolok ukur convnet yang mencakup beberapa kerangka kerja python yang telah disebutkan ( TensorFlow , chainer , neon , Theano ):

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

NeuPy adalah perpustakaan Python untuk Jaringan Syaraf Tiruan. NeuPy mendukung berbagai jenis Neural Networks dari perceptron sederhana hingga model pembelajaran yang mendalam.