Misunderstanding in Pipelines Recipe

[FBruzzesi]

Hi everyone 👋🏼
I am using river and its documentation to learn about online ML. The resources are awesome and I am really enjoying the clarity of it all.

I hope this is the right place to ask, as it may just be due to my ignorance and not necessarily an issue.

While going through the pipelines recipe docs section and testing it out side by side , I was getting a bit confused, and I am not sure if I am mis-interpreting a few statements.

learn_one

You would expect learn_one to update each estimator, but that's not actually what happens. Instead, the transformers are updated when predict_one (or predict_proba_one for that matter) is called. Indeed, in online machine learning, we can update the unsupervised parts of our model when a sample arrives. We don't have to wait for the ground truth to arrive in order to update unsupervised estimators that don't depend on it.

The code results seem misaligned with such statement:

from river import datasets
from river import compose
from river import linear_model
from river import preprocessing

dataset = iter(datasets.TrumpApproval())

model = compose.Pipeline(
    preprocessing.StandardScaler(),
    linear_model.LinearRegression()
)

print(model['StandardScaler'].means)
#  defaultdict(float, {})

x, _ = next(dataset)
model.predict_one(x)
x, _ = next(dataset)
model.predict_one(x)

print(model['StandardScaler'].means)
# defaultdict(float,
#            {'ordinal_date': 0.0,
#             'gallup': 0.0,
#             'ipsos': 0.0,
#             'morning_consult': 0.0,
#             'rasmussen': 0.0,
#             'you_gov': 0.0})

From the statement above I would expect this not to be all zeros.

Looking at the source code, I figured out that the values update only if predicting with the with compose.learn_during_predict(): context:

model_ = model.clone()
with compose.learn_during_predict():

    x, y = next(dataset)
    model_.predict_one(x)

    x, y = next(dataset)
    model_.predict_one(x)

print(model_['StandardScaler'].means)
# defaultdict(float,
#            {'ordinal_date': 736394.5,
#             'gallup': 44.343213,
#             'ipsos': 46.67901233333333,
#             'morning_consult': 48.318749,
#             'rasmussen': 45.604692,
#             'you_gov': 41.636914000000004})

transform_one

Note that if you call transform_one with a pipeline who's last step is not a transformer, then the output from the last transformer (which is thus the penultimate step) will be returned

Keeping the same setup as above, I would expect that:

• model leads to no transformation as means are all zeros
• model_ leads to proper transformation of input x

x, _  = next(dataset)
print(x, model['StandardScaler'].transform_one(x), model_.transform_one(x))

# {'ordinal_date': 736397, 'gallup': 41.843213, 'ipsos': 46.920679, 'morning_consult': 48.318749, 'rasmussen': 43.104692, 'you_gov': 42.636914000000004}
# {'ordinal_date': 0.0, 'gallup': 0.0, 'ipsos': 0.0, 'morning_consult': 0.0, 'rasmussen': 0.0, 'you_gov': 0.0}
# {'ordinal_date': 5.0, 'gallup': -5.0, 'ipsos': 1.0, 'morning_consult': 0.0, 'rasmussen': -5.0, 'you_gov': 0.0}

The latter is expected, yet I don't understand while model transform x to a feature set of zeros.

Action points

• For learn_one: arguably the doc is just out of sync with the current implementation - I can open a PR to adjust that.
• For transform_one: I am not sure what the intended behavior is. If there is anything to fix, given some expectations I can work on that as well.

[gbolmier]

Hey @FBruzzesi 👋 Thank you for reaching out and providing such a well structured inquiry!

For learn_one: arguably the doc is just out of sync with the current implementation - I can open a PR to adjust that.

This is correct (#1274 forgot to update all the docs), a PR would be much appreciated if you feel up for it 🙌

For transform_one: I am not sure what the intended behavior is. If there is anything to fix, given some expectations I can work on that as well.

This is the intended behaviour. The means and variances parameters of the standard scaler object are stored in default dictionaries (with zero as a default, see river/preprocessing/scale.py#L158-L159).
So until parameters are updated from their initial zero value (by calling learn_one, either directly or using the learn_during_predict context manager), the standard scaler will transform the feature to zero (see river/preprocessing/scale.py#L173).

[FBruzzesi]

Hey thanks for getting back to me and explaining what's happening!

PR would be much appreciated if you feel up for it 🙌

Sure, I will work on that 👌

[...] the standard scaler will transform the feature to zero

I was expecting to leave inputs unchanged, but I guess that it would lead to have a completely different scale from what is expected later on.

[gbolmier]

I was expecting to leave inputs unchanged, but I guess that it would lead to have a completely different scale from what is expected later on.

Same at a first glance, but here are some reasons I can think of why it was implemented this way:

1. It only happens until the first learn_one call, and in online learning it is expected to require some warm up phase (have to learn from a few observations before getting decent predictive power).
2. Parameters first updates might be more stable starting all at the same scale.
3. Implementing the logic to avoid that behaviour would create some overhead for all the following times we transform inputs.

Please also note that if for whatever reason you don't want that behaviour, you could set with_std to False when initializing the standard scaler object. You could then set it back to True before the first learn_one call if you just want to avoid that cold start behaviour.