Regressor Neural Network built with Keras only ever predicts one value

Question

I'm trying to build a NN with Keras and Tensorflow to predict the final chart position of a song, given a set of 5 features.

After playing around with it for a few days I realised that although my MAE was getting lower, this was because the model had just learned to predict the mean value of my training set for all input, and this was the optimal solution. (This is illustrated in the scatter plot below)

This is a random sample of 50 data points from my testing set vs what the network thinks they should be

At first I realised this was probably because my network was too complicated. I had one input layer with shape (5,) and a single node in the output layer, but then 3 hidden layers with over 32 nodes each.

I then stripped back the excess layers and moved to just a single hidden layer with a couple nodes, as shown here:

self.model = keras.Sequential([
keras.layers.Dense(4,
    activation='relu',
    input_dim=num_features,
    kernel_initializer='random_uniform',
    bias_initializer='random_uniform'
    ),
keras.layers.Dense(1)
])

Training this with a gradient descent optimiser still results in exactly the same prediction being made the whole time.

Then it occurred to me that perhaps the actual problem I'm trying to solve isn't hard enough for the network, that maybe it's linearly separable. Since this would respond better to not having a hidden layer at all, essentially just doing regular linear regression, I tried that. I changed my model to:

inp = keras.Input(shape=(num_features,))
out = keras.layers.Dense(1, activation='relu')(inp)
self.model = keras.Model(inp,out)

This also changed nothing. My MAE, the predicted value are all the same. I've tried so many different things, different permutations of optimisation functions, learning rates, network configurations, and nothing can help. I'm pretty sure the data is good, but I've included a sample of it just in case.

chartposition,tagcount,dow,artistscore,timeinchart,finalpos
121,3925,5,35128,7,227
131,4453,3,85545,25,130
69,2583,4,17594,24,523
145,1165,3,292874,151,187
96,1679,5,102593,111,540
134,3494,5,1252058,37,370
6,34895,7,6824048,22,5

A sample of my dataset, finalpos is the value I'm trying to predict. Dataset contains ~40,000 records, split 80/20 - training/testing

def __init__(self, validation_split, num_features, should_log):
    self.should_log = should_log
    self.validation_split = validation_split

    inp = keras.Input(shape=(num_features,))
    out = keras.layers.Dense(1, activation='relu')(inp)
    self.model = keras.Model(inp,out)

    optimizer = tf.train.GradientDescentOptimizer(0.01)
    self.model.compile(loss='mae',
                  optimizer=optimizer,
                  metrics=['mae'])

def train(self, data, labels, plot=False):

    early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=20)

    history = self.model.fit(data,
                              labels,
                              epochs=self.epochs,
                              validation_split=self.validation_split,
                              verbose=0,
                              callbacks = [PrintDot(), early_stop])
    if plot: self.plot_history(history)

All code relevant to constructing and training the networ

def normalise_dataset(df, mini, maxi):
    return (df - mini)/(maxi-mini)

Normalisation of the input data. Both my testing and training data are normalised to the max and min of the testing set

Graph of my loss vs validation curves with the one hidden layer network with an adamoptimiser, learning rate 0.01

Same graph but with linear regression and a gradient descent optimiser.

Answer 1

Turns out the error was a really stupid and easy to miss bug.

When I was importing my dataset, I shuffle it, however when I performed the shuffling, I was accidentally applying the shuffling only to the labels set, not the whole dataset as a whole.

As a result, each label was being assigned to a completely random feature set, of course the model didn't know what to do with this.

Thanks to @dennlinger for suggesting for me to look in the place where I eventually found this bug.

Answer 2

So I am pretty sure that your normalization is the issue: You are not normalizing by feature (as is the de-fact industry standard), but across all data. That means, if you have two different features that have very different orders of magnitude/ranges (in your case, compare timeinchart with artistscore.

Instead, you might want to normalize using something like scikit-learn's StandardScaler. Not only does this normalize per column (so you can pass all features at once), but it also does unit variance (which is some assumption about your data, but can potentially help, too).

To transform your data, use something along these lines

from sklearn.preprocessing import StandardScaler
import numpy as np

raw_data = np.array([[1,40], [2, 80]])
scaler = StandardScaler()
processed_data = scaler.fit_transform(raw_data) 
# fit() calculates mean etc, transform() puts it to the new range.
print(processed_data) # returns [[-1, -1], [1,1]]

Note that you have two possibilities to normalize/standardize your training data: Either scale them together with your training data, and then split afterwards, or you instead only fit the training data, and then use the same scaler to transform your test data.
Never fit_transform your test set separate from training data!
Since you have potentially different mean/min/max values, you can end up with totally wrong predictions! In a sense, the StandardScaler is your definition of your "data source distribution", which is inherently still the same for your test set, even though they might be a subset not exactly following the same properties (due to small sample size etc.)

Additionally, you might want to use a more advanced optimizer, like Adam, or specify some momentum property (0.9 is a good choice in practic, as a rule of thumb) for your SGD.