Introduction

PyBrain can be used for regression, not just classification, by training a network to predict a continuous output value. The main idea is simple: prepare a supervised dataset with numeric targets, build a network with one output neuron, and train it with backpropagation until prediction error decreases.

A practical warning about PyBrain

PyBrain is an old library and is no longer actively maintained. That means examples are still useful for understanding the pattern, but for new projects most teams would choose scikit-learn, PyTorch, or TensorFlow instead.

Still, if you are maintaining older code or learning from legacy examples, the regression workflow is straightforward.

Build a regression dataset

For supervised regression in PyBrain, use SupervisedDataSet. The input dimension matches your feature count, and the output dimension is usually 1 for a single continuous target.

1from pybrain.datasets import SupervisedDataSet
2
3ds = SupervisedDataSet(2, 1)
4ds.addSample((0.0, 0.0), (0.0,))
5ds.addSample((1.0, 0.0), (1.0,))
6ds.addSample((0.0, 1.0), (1.0,))
7ds.addSample((1.0, 1.0), (2.0,))

The target values are numeric and continuous, which is what makes this a regression problem.

Build the network

For a simple regression model, create a feedforward network with one output unit.

from pybrain.tools.shortcuts import buildNetwork

net = buildNetwork(2, 5, 1, bias=True)

This creates:

• 2 input neurons
• 5 hidden neurons
• 1 output neuron

For regression, the output layer should not force the prediction into a class-like range unless that is truly what you want.

Train with backpropagation

1from pybrain.supervised.trainers import BackpropTrainer
2
3trainer = BackpropTrainer(net, ds, learningrate=0.01, momentum=0.1, verbose=True)
4trainer.trainUntilConvergence(maxEpochs=200)

This trains the network on the dataset until the error stabilizes or the epoch limit is reached.

Then make predictions:

prediction = net.activate((0.5, 0.5))
print(prediction)

Because this is regression, the output is a numeric prediction rather than a class label.

Normalize your data

Neural-network regression usually works better when inputs and targets are scaled to a reasonable numeric range. If one feature is between 0 and 1 and another is in the millions, optimization becomes harder.

A simple preprocessing step might look like this:

def scale(value, min_val, max_val):
    return (value - min_val) / float(max_val - min_val)

In real work, scale both training and prediction inputs consistently. The same applies to targets if their range is very large.

Evaluate the model properly

Do not judge the network only by whether it produces some number. Regression should be evaluated with metrics such as mean squared error or mean absolute error on held-out data.

PyBrain examples often focus on the training loop, but model evaluation is just as important. If the model overfits a tiny dataset, it may look good in training and fail completely on new inputs.

Common Pitfalls

• Treating regression like classification and using the wrong output interpretation.
• Training on unscaled features with wildly different numeric ranges.
• Using a tiny toy dataset and assuming the model has learned a general rule.
• Forgetting that PyBrain is outdated and may be difficult to install in modern environments.
• Evaluating only on training data instead of using a real validation or test split.

Summary

• In PyBrain, regression uses a SupervisedDataSet with continuous numeric targets.
• A typical network has one output neuron for one regression target.
• Train it with BackpropTrainer and then call activate() for predictions.
• Normalize features and evaluate with regression metrics, not classification intuition.
• PyBrain still demonstrates the idea, but modern projects usually use newer libraries.