GPU accelerated neural networks

Question

I am looking for gratis software that is GPU accelerated that can work with neural networks. I have seen many pieces of software that I can use for neural networks but many of them do not have GPU acceleration. Here are my requirements

Support for the backpropagation algorithm.

I would like support for a genetic algorithm such as NEAT but it is not required

A good nice to use interface

I would like it to work on windows but I could also use it on Linux

That is it for my requirements. In case you are wondering what GPUs I use I use Nvidia GPUs. So the application would have to support CUDA

Answer 1

You can use Caffe:

• open source (BSD 2-Clause license)
• gratis
• Easy to compile on Linux/OS X, harder on Windows
• GPU support for Nvidia
• on CPU, makes use of multithreading
• use the backpropagation algorithm
• allows the user to define neural network using config files
• MLP, CNN but no RNN yet
• written in C++ but Python and Matlab binds available

FYI:

• Script to install Caffe and pycaffe on Ubuntu.
• How to train a caffe model?

Answer 2

You can use the Python package theanets:

• open source (MIT License)
• gratis
• it's a wrapper around Theano (the latter can use your GPU if Nvidia, AMD is not fully supported yet).
• on CPU, does not make use of multithreading
• Easy to compile on Linux/OS X, harder on Windows
• MLP, RNN

The following code shows how easy it is to specify an ANN and train it:

import climate
import theanets
from sklearn.datasets import make_classification
from sklearn.metrics import confusion_matrix

climate.enable_default_logging()

# Create a classification dataset.
X, y = make_classification(
    n_samples=3000, n_features=100, n_classes=10, n_informative=10)
X = X.astype('f')
y = y.astype('i')
cut = int(len(X) * 0.8)  # training / validation split
train = X[:cut], y[:cut]
valid = X[cut:], y[cut:]

# Build a classifier model with 100 inputs and 10 outputs.
exp = theanets.Experiment(theanets.Classifier, layers=(100, 10))

# Train the model using SGD with momentum.
exp.train(train, valid, algorithm='sgd', learning_rate=1e-4, momentum=0.9)

# Show confusion matrices on the training/validation splits.
for label, (X, y) in (('training:', train), ('validation:', valid)):
    print(label)
    print(confusion_matrix(y, exp.network.predict(X)))