ห้องสมุดไพ ธ อนที่ดีที่สุดสำหรับเครือข่ายประสาทเทียม

ฉันใช้โครงข่ายประสาทเทียมเพื่อแก้ปัญหาการเรียนรู้ของเครื่องที่แตกต่างกัน ฉันใช้ Python และpybrainแต่ห้องสมุดนี้เกือบจะหยุดแล้ว มีทางเลือกอื่นที่ดีใน Python หรือไม่?

อัปเดต: ภูมิทัศน์เปลี่ยนไปเล็กน้อยตั้งแต่ฉันตอบคำถามนี้ในเดือนกรกฎาคม '14 และผู้เล่นใหม่บางคนได้เข้าสู่อวกาศ โดยเฉพาะฉันขอแนะนำให้เช็คเอาท์:

• TensorFlow
• บล็อก
• ลาซานญ่า
• Keras
• Deepy
• Nolearn
• NeuPy

พวกเขาแต่ละคนมีจุดแข็งและจุดอ่อนของพวกเขาดังนั้นให้พวกเขาไปและดูว่าเหมาะกับกรณีการใช้งานของคุณ แม้ว่าฉันจะแนะนำให้ใช้ PyLearn2 เมื่อปีที่แล้ว แต่ชุมชนไม่ทำงานอีกต่อไปดังนั้นฉันขอแนะนำให้ดูที่อื่น คำตอบดั้งเดิมของฉันมีคำตอบอยู่ด้านล่าง แต่ส่วนใหญ่ไม่เกี่ยวข้องในตอนนี้

โดยทั่วไปแล้วPyLearn2ถือว่าเป็นห้องสมุดที่เลือกใช้สำหรับโครงข่ายประสาทเทียมและการเรียนรู้ในหลาม มันออกแบบมาเพื่อการทดลองทางวิทยาศาสตร์ง่าย ๆ แทนที่จะใช้งานง่ายดังนั้นช่วงการเรียนรู้ค่อนข้างสูงชัน แต่ถ้าคุณใช้เวลาของคุณและทำตามบทช่วยสอนฉันคิดว่าคุณจะมีความสุขกับการทำงานที่มีให้ ทุกอย่างจาก Multilayer Perceptrons แบบมาตรฐานไปจนถึงเครื่อง Boltzmann ที่ถูก จำกัด ไปจนถึง Convolutional Nets ถึง Autoencoders มีการรองรับ GPU ที่ยอดเยี่ยมและทุกอย่างสร้างขึ้นจาก Theano ดังนั้นประสิทธิภาพจึงค่อนข้างดี แหล่งสำหรับ PyLearn2 ที่สามารถใช้ได้บน GitHub

โปรดทราบว่า PyLearn2 มีปัญหาตรงข้ามกับ PyBrain ในขณะนี้ - แทนที่จะถูกทอดทิ้ง PyLearn2 อยู่ภายใต้การพัฒนาที่กระฉับกระเฉงและอาจมีการเปลี่ยนแปลงบ่อยครั้ง

Tensor Flow ( docs ) โดย Google เป็นอีกหนึ่งกรอบที่ดีซึ่งมีความแตกต่างโดยอัตโนมัติ ฉันได้เขียนความคิดสั้น ๆเกี่ยวกับ Google Tensor Flowบนบล็อกของฉันพร้อมกับตัวอย่าง MNIST ที่มีในบทช่วยสอน

ดูเพิ่มเติมที่: กวดวิชา Tensorflow XORของฉัน

ลาซานญ่า ( เอกสาร ) เป็นสิ่งที่ดีมากที่จะใช้ Theano (→คุณสามารถใช้ GPU) และทำให้มันง่ายในการใช้ ผู้เขียนลาซานญชนะเคล็กกาแล็กซี่กาแล็กซี่เท่าที่ฉันรู้ มันเป็นสิ่งที่ดีกับnolearn นี่คือเครือข่ายตัวอย่าง 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เป็นห้องสมุด C ++ แต่มีการผูก Python คุณสามารถทำสิ่งต่าง ๆ ส่วนใหญ่โดยไฟล์การกำหนดค่า (prototxt) มีตัวเลือกมากมายและสามารถใช้ GPU ได้

Pylearn พึ่งพา Theano และดังที่กล่าวไว้ในคำตอบอื่น ๆ ในการใช้ห้องสมุดนั้นค่อนข้างซับซ้อนจนกระทั่งคุณได้รับมัน

ในขณะเดียวกันผมขอแนะนำให้ใช้Theanets มันยังสร้างอยู่ด้านบนของ Theano แต่ทำงานได้ง่ายกว่ามาก อาจเป็นเรื่องจริงที่มันไม่มีคุณสมบัติทั้งหมดของ Pylearn แต่สำหรับงานพื้นฐานก็เพียงพอแล้ว

นอกจากนี้ยังเป็นโอเพ่นซอร์สดังนั้นคุณสามารถเพิ่มเครือข่ายที่กำหนดเองได้ทันทีหากคุณกล้า :)

แก้ไข: ธันวาคม 2015 เร็ว ๆ นี้ผมได้เริ่มต้นใช้Keras มันเป็นระดับที่ต่ำกว่า Theanets เล็กน้อย แต่มีประสิทธิภาพมากกว่า สำหรับการทดสอบขั้นพื้นฐาน Theanets มีความเหมาะสม แต่ถ้าคุณต้องการทำวิจัยในสาขา ANN Keras นั้นมีความยืดหยุ่นมากกว่า นอกจากนี้ Keras ยังสามารถใช้Tensorflowเป็นแบ็กเอนด์

TensorFlow (โดย Google วางจำหน่ายเมื่อวันที่ 2015-11-09) ดูมีแนวโน้ม

• โอเพ่นซอร์ส (Apache 2.0 License) ( GitHub )
• Python (แบ็กเอนด์ใน C ++)
• CPU / GPU
• Auto-ความแตกต่าง
• พกพา (แม้ใช้งานบนอุปกรณ์มือถือ)

FYI:

• การประเมินชุดเครื่องมือการเรียนรู้ลึก
• การเปรียบเทียบมาตรฐานของการใช้งานโอเพ่นซอร์สสาธารณะทั้งหมดของ Convnets
• Soheil Bahrampour, Naveen Ramakrishnan, Lukas Schott, Mohak Shah การศึกษาเปรียบเทียบลึกการเรียนรู้ซอฟท์แวกรอบ arXiv: 1511.06435
• Shaohuai Shi, Qiang Wang, Pengfei Xu, Xiaowen Chu การเปรียบเทียบเครื่องมือซอฟต์แวร์การเรียนรู้ล้ำสมัยที่ล้ำสมัย arXiv: 1608.07249
• ชุดเครื่องมือการเรียนรู้เชิงลึกใหม่เปิดตัวทุกๆ 22 วันในปี 2558 หรือไม่?

Pylearn2 ดูเหมือนจะเป็นห้องสมุดที่เลือกได้ แต่ฉันพบว่าไฟล์การตั้งค่า YAML ของพวกเขาหยุดทำงาน

Python ถูกออกแบบมาให้เป็นภาษาที่ง่ายสำหรับการสร้างต้นแบบทำไมคุณไม่ใช้มันเพื่อกำหนดคุณสมบัติเครือข่ายเอง เรามีผู้แก้ไขที่ยอดเยี่ยมที่มีการเติมข้อความอัตโนมัติที่จะทำให้ชีวิตของคุณง่ายขึ้นมากและ Python ไม่เหมือนกับ C ++ ที่คุณต้องรอการสร้างแบบยาวให้เสร็จก่อนที่คุณจะสามารถเรียกใช้รหัสของคุณได้

ไฟล์ YAML ในทางกลับกันคุณต้องแก้ไขโดยใช้โปรแกรมแก้ไขข้อความมาตรฐานโดยไม่มีความช่วยเหลือใด ๆ และสิ่งนี้ทำให้เส้นโค้งการเรียนรู้ยิ่งชันยิ่งขึ้น

ฉันอาจจะคิดถึงภาพรวมขนาดใหญ่ แต่ฉันก็ยังไม่เข้าใจว่าพวกเขากำลังคิดอะไรอยู่ฉันไม่คิดว่าการสร้างต้นแบบในรหัสจะช้ากว่านี้มากนัก ด้วยเหตุนี้ฉันจึงพิจารณา Theanets หรือใช้ Theano โดยตรง

ฉันชอบบล็อกซึ่งสร้างขึ้นบนสุดของ Theano เช่นกัน วิธีเข้าถึงได้ง่ายกว่า PyLearn2 และมีคุณสมบัติที่หลากหลายกว่า Lasagne เขียนอย่างเรียบร้อยเช่นกัน

อัปเดตเมื่อมกราคม 2016:

ในขณะที่เขียนKerasมีแรงผลักดันมากที่สุด มันเป็นแบบแยกส่วนสูงและสามารถทำงานได้ทั้งบน Theano และ Tensorflow ทำให้มีโอกาสที่ดี

MXNet :

• เขียนด้วยภาษา C ++ แต่มี API เป็นภาษาไพ ธ อน (และภาษาอื่น ๆ อีกสองสามภาษาเช่น R, Julia และ Go)
• ปรับขนาดได้ถึง GPU หลายตัวและการตั้งค่าแบบกระจายพร้อมความขนานอัตโนมัติ
• สร้างความแตกต่างโดยอัตโนมัติ
• การแสดงที่มีคุณค่า:

จากสิ่งที่ฉันได้ยิน Pylearn2 อาจเป็นห้องสมุดทางเลือกสำหรับคนส่วนใหญ่ในปัจจุบัน สิ่งนี้ทำให้ฉันนึกถึงบล็อกโพสต์ล่าสุดเมื่อไม่กี่เดือนที่ผ่านมาซึ่งแสดงรายการไลบรารีการเรียนรู้ของเครื่องที่แตกต่างกันทั้งหมดพร้อมคำอธิบายสั้น ๆ

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

ส่วนที่คุณอาจสนใจคือ "การเรียนรู้ลึก" เกี่ยวกับ Pylearn2 เขาเขียน

PyLearn2

มีอีกไลบรารีหนึ่งที่สร้างอยู่ด้านบนของ Theano เรียกว่า PyLearn2 ซึ่งนำโมดูลและความสามารถในการกำหนดค่ามาสู่ Theano ซึ่งคุณสามารถสร้างเครือข่ายประสาทของคุณผ่านไฟล์การกำหนดค่าที่แตกต่างกันเพื่อให้ง่ายต่อการทดสอบพารามิเตอร์ที่แตกต่างกัน เนื้อหามีความเป็นโมดูลมากขึ้นโดยการแยกพารามิเตอร์และคุณสมบัติของเครือข่ายประสาทเทียมไปยังไฟล์การกำหนดค่า

ฉันเขียนโพสต์นี้ซึ่งมีรายละเอียดรายการโปรดส่วนตัวของฉัน:

ห้องสมุดการเรียนรู้ของเครื่องที่ดีที่สุดใน Python

เนื่องจากมีการกล่าวถึงห้องสมุดมากกว่า 30 แห่งฉันจะไม่โพสต์ไว้ที่นี่ แต่สิ่งเหล่านี้เป็นที่นิยมที่สุด:

• Tensorflow
• scikit เรียนรู้
• Theano
• Pylearn2
• Pyevolve
• NuPIC
• แบบแผน
• Caffe

(ขออภัยไม่สามารถเชื่อมโยงไปยัง repos Github เนื่องจากตัวแทนของฉันยังอยู่ <10 ... )

แก้ไข: เพิ่มลิงก์ไปยัง repos Github

นีออน :

• หลามตาม
• โอเพ่นซอร์ส (Apache 2.0 License)
• พัฒนาโดยNervana Systems (ถ้าคุณไม่รู้จักพวกเขา: การเริ่มต้นการเรียนรู้อย่างลึกซึ้ง Nervana ยก $ 20.5M ; Nervana Systems ยก 3.3M USD เพื่อสร้างฮาร์ดแวร์ที่ออกแบบมาเพื่อการเรียนรู้ลึก )
• รองรับ CPU และ GPU
• สนับสนุนความแตกต่างอัตโนมัติขั้นพื้นฐาน
• กรอบการสร้างภาพ

เพียงเพิ่มทรัพยากรเพิ่มเติม เมื่อเร็ว ๆ นี้มีรายงานการศึกษาความแตกต่างระหว่างแพ็คเกจโครงข่ายประสาทและโครงข่ายประสาทเทียมหลายชุด

ที่นี่คุณสามารถหาข้อมูล ดูเหมือนว่าTorchและTensorFlowเป็นผู้ชนะ

หมายเหตุ: ไม่ใช่ทั้งหมดที่อยู่ในหลาม อย่างไรก็ตามฉันโพสต์ไว้เพื่อเปิดการสนทนา

ไมโครซอฟท์ความรู้ความเข้าใจ Toolkit (ที่รู้จักกันก่อนหน้านี้เป็น CNTK)มี งูหลาม API เหนือสิ่งอื่นใดก็ควรจะดีสำหรับmulti-GPU :

ตัวอย่างและแบบฝึกหัดสามารถพบได้ที่https://github.com/Microsoft/CNTK/tree/master/bindings/python

DyNet: ชุดเครื่องมือโครงข่ายประสาทเทียม จาก {1}:

เราอธิบาย DyNet ซึ่งเป็นชุดเครื่องมือสำหรับการใช้โมเดลโครงข่ายประสาทเทียมตามการประกาศแบบไดนามิกของโครงสร้างเครือข่าย ในกลยุทธ์การประกาศแบบคงที่ที่ใช้ในชุดเครื่องมือเช่น Theano, CNTK และ TensorFlow ผู้ใช้จะกำหนดกราฟการคำนวณเป็นครั้งแรก (การแสดงสัญลักษณ์ของการคำนวณ) จากนั้นตัวอย่างจะถูกป้อนเข้าสู่เครื่องมือที่ประมวลผลการคำนวณนี้และคำนวณอนุพันธ์ . ในกลยุทธ์การประกาศแบบไดนามิกของ DyNet การสร้างกราฟการคำนวณนั้นส่วนใหญ่โปร่งใสถูกสร้างขึ้นโดยปริยายโดยการประมวลผลโค้ดขั้นตอนที่คำนวณเอาท์พุทเครือข่ายและผู้ใช้มีอิสระในการใช้โครงสร้างเครือข่ายที่แตกต่างกันสำหรับแต่ละอินพุต การประกาศแบบไดนามิกจึงอำนวยความสะดวกในการติดตั้งสถาปัตยกรรมเครือข่ายที่ซับซ้อนมากขึ้น และ DyNet ได้รับการออกแบบมาโดยเฉพาะเพื่อให้ผู้ใช้สามารถนำโมเดลของพวกเขาไปใช้ในทางที่เป็นไปได้ในภาษาการเขียนโปรแกรมที่ต้องการ (C ++ หรือ Python) สิ่งหนึ่งที่ท้าทายกับการประกาศแบบไดนามิกคือเนื่องจากกราฟการคำนวณเชิงสัญลักษณ์ถูกกำหนดใหม่สำหรับทุกตัวอย่างการฝึกอบรมการก่อสร้างจะต้องมีค่าใช้จ่ายต่ำ เพื่อให้บรรลุเป้าหมายดังกล่าว DyNet จึงได้ปรับปรุงส่วนแบ็กเอนด์ C ++ และกราฟน้ำหนักเบา การทดลองแสดงให้เห็นว่าความเร็วของ DyNet นั้นเร็วกว่าหรือเทียบเท่ากับชุดเครื่องมือประกาศคงที่และเร็วกว่า Chainer ซึ่งเป็นชุดเครื่องมือประกาศแบบไดนามิกอีกชุดหนึ่ง DyNet เปิดตัวโอเพนซอร์ซภายใต้ลิขสิทธิ์ Apache 2.0 และวางจำหน่ายที่ สิ่งหนึ่งที่ท้าทายกับการประกาศแบบไดนามิกคือเนื่องจากกราฟการคำนวณเชิงสัญลักษณ์ถูกกำหนดใหม่สำหรับทุกตัวอย่างการฝึกอบรมการก่อสร้างจะต้องมีค่าใช้จ่ายต่ำ เพื่อให้บรรลุเป้าหมายดังกล่าว DyNet จึงได้ปรับปรุงส่วนแบ็กเอนด์ C ++ และกราฟน้ำหนักเบา การทดลองแสดงให้เห็นว่าความเร็วของ DyNet นั้นเร็วกว่าหรือเทียบเท่ากับชุดเครื่องมือประกาศคงที่และเร็วกว่า Chainer ซึ่งเป็นชุดเครื่องมือประกาศแบบไดนามิกอีกชุดหนึ่ง DyNet เปิดตัวโอเพนซอร์ซภายใต้ลิขสิทธิ์ Apache 2.0 และวางจำหน่ายที่ สิ่งหนึ่งที่ท้าทายกับการประกาศแบบไดนามิกคือเนื่องจากกราฟการคำนวณเชิงสัญลักษณ์ถูกกำหนดใหม่สำหรับทุกตัวอย่างการฝึกอบรมการก่อสร้างจะต้องมีค่าใช้จ่ายต่ำ เพื่อให้บรรลุเป้าหมายดังกล่าว DyNet จึงได้ปรับปรุงส่วนแบ็กเอนด์ C ++ และกราฟน้ำหนักเบา การทดลองแสดงให้เห็นว่าความเร็วของ DyNet นั้นเร็วกว่าหรือเทียบเท่ากับชุดเครื่องมือประกาศคงที่และเร็วกว่า Chainer ซึ่งเป็นชุดเครื่องมือประกาศแบบไดนามิกอีกชุดหนึ่ง DyNet เปิดตัวโอเพนซอร์ซภายใต้ลิขสิทธิ์ Apache 2.0 และวางจำหน่ายที่URL http นี้

ก่อนหน้านี้เป็นที่รู้จักกันในชื่อcnn (ซึ่งมีผลผูกพันกับ python ชื่อ pycnn)

อ้างอิง:

• {1} Graham Neubig, Chris Dyer, Yoav Goldberg, Austin Matthews, Waleed Ammar, Antonios Anastasopoulos, Miguel Ballesteros, เดวิดเชียง, Daniel Clothiaux, Trevor Cohn, Kevin Duh, Manaal Faruqui, Cynthia Gan, Dan Garrette, Yangfeng Ji, Lingpeng , Adhiguna Kuncoro, Gaurav Kumar, Chaitanya Malaviya, Paul Michel, Yusuke Oda, Matthew Richardson, Naomi Saphra, Swabha Swayamdipta, Pengcheng Yin DyNet: ชุดเครื่องมือโครงข่ายประสาทเทียม https://arxiv.org/abs/1701.03980

ฉันแนะนำให้คุณใช้tensorflowซึ่งอยู่ภายใต้การพัฒนาที่แข็งแกร่งและสนับสนุนการเรียนรู้อย่างลึกซึ้ง คุณสามารถใช้ API Keras ของโครงข่ายประสาทเทียมระดับสูงที่ทำงานอยู่ด้านบนของเทนเซอร์โฟลว์และใช้งานได้ง่ายมากเพียงแค่ลองใช้บทแนะนำและคุณจะต้องชอบ

PyTorch

มันได้รับการสนับสนุนมากมายเนื่องจากใช้งานง่ายและคล้ายคลึงกับ Python พื้นฐาน

มันรัน "ทีละบรรทัด" (ผ่านกราฟแบบไดนามิก) เช่นเดียวกับ Python ปกติและสามารถดีบั๊กได้อย่างง่ายดาย - แม้ใช้คำสั่งพิมพ์มาตรฐาน นอกจากนี้ยังรวมเข้ากับ NumPy และ Python linbraries ที่รู้จักกันดีอื่น ๆ เช่น Scikit Learn

เพราะมันทำให้การสร้างแบบจำลองง่ายมันยอดเยี่ยมสำหรับการสร้างต้นแบบและสำรวจความคิดใหม่โดยทั่วไป

รองรับ GPU หลายตัวและทำได้ในวิธีที่ง่ายมาก

ตรวจสอบคุณสมบัติเพิ่มเติมได้ที่นี่

แม้ว่าประโยชน์หลายประการข้างต้นจะทำให้ PyTorch ใช้งานได้ดีกว่าไลบรารี่ที่ใช้กันทั่วไป แต่ก็มีมูลค่าการกล่าวถึงว่าการเปิดตัว Tensorflow ครั้งใหญ่จะเกิดขึ้นตามค่าเริ่มต้นนอกจากนี้ยังใช้การสร้างกราฟแบบไดนามิก ( โหมดกระตือรือร้น ) สิ่งนี้จะทำให้มันเปรียบได้กับการใช้งาน PyTorch

หากคุณมีความสนใจในการเปรียบเทียบประสิทธิภาพ Soumith Chintala ยังคงรักษาชุดของมาตรฐานการสนทนาที่ครอบคลุมโครงร่างของงูหลามที่กล่าวถึงแล้วหลายตัว ( TensorFlow , chainer , Neon , Theano ):

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

NeuPyเป็นห้องสมุด Python สำหรับโครงข่ายประสาทเทียม NeuPy รองรับโครงข่ายประสาทประเภทต่าง ๆ มากมายจาก perceptron แบบง่าย ๆ ไปจนถึงแบบจำลองการเรียนรู้ลึก