Behavioural tests for models

Setup#

pip install scikit-learn joblib pytest

The model being tested#

A tiny sentiment classifier: TF-IDF turns each sentence into word-count features, and logistic regression learns which words push toward "positive" or "negative". Twenty short sentences, ten of each label.

"""A tiny sentiment classifier, small enough to test its behaviour directly."""
import joblib
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

TRAIN_TEXTS = [
    "amazing product, loved it", "terrible experience, would not buy again",
    "great quality and fast delivery", "awful, broke on day one",
    "works perfectly, very happy", "waste of money, do not buy",
    "excellent value for the price", "disappointing and slow",
    "fantastic support team", "poor build quality",
    "highly recommend this", "would not recommend at all",
    "best purchase this year", "worst purchase this year",
    "solid and reliable", "flimsy and cheap feeling",
    "happy with the results", "unhappy with the results",
    "good for the price", "bad for the price",
]
TRAIN_LABELS = [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]

model = make_pipeline(TfidfVectorizer(), LogisticRegression(max_iter=1000))


def train():
    model.fit(TRAIN_TEXTS, TRAIN_LABELS)
    joblib.dump(model, "sentiment.joblib")
    return model


if __name__ == "__main__":
    m = train()
    print("train accuracy:", round(m.score(TRAIN_TEXTS, TRAIN_LABELS), 4))

python sentiment.py

train accuracy: 1.0

Perfect accuracy on the training sentences is expected here — with only twenty short, plainly-worded sentences and no noise, the model can memorise the pattern. It says nothing about whether the model behaves sensibly on sentences it has never seen. That is what the tests below check.

The behavioural tests#

import joblib
import pytest

MODEL = joblib.load("sentiment.joblib")


def predict(text: str) -> int:
    return int(MODEL.predict([text])[0])


# --- Minimum functionality: the easiest possible cases must work ---

@pytest.mark.parametrize("text,expected", [
    ("this is amazing", 1),
    ("this is terrible", 0),
    ("absolutely fantastic", 1),
    ("absolutely awful", 0),
])
def test_minimum_functionality(text, expected):
    assert predict(text) == expected


# --- Invariance: swapping an unrelated noun must not change the label ---

def test_invariant_to_the_thing_being_praised():
    assert predict("I loved this restaurant") == predict("I loved this movie")


# --- Directional expectation: negating a word should flip the label ---

def test_negation_flips_a_positive_word():
    assert predict("this is not good") != predict("this is good")

pytest test_behaviour.py -q

.....F                                                                   [100%]
================================== FAILURES ===================================
_____________________ test_negation_flips_a_positive_word _____________________

    def test_negation_flips_a_positive_word():
>       assert predict("this is not good") != predict("this is good")
E       AssertionError: assert 1 != 1
E        +  where 1 = predict('this is not good')
E        +  and   1 = predict('this is good')

test_behaviour.py:32: AssertionError
=========================== short test summary info ===========================
FAILED test_behaviour.py::test_negation_flips_a_positive_word - AssertionErro...
1 failed, 5 passed in 1.71s

That is a real run against a real model. Four minimum-functionality cases pass. The invariance check passes: swapping "restaurant" for "movie" does not move the score. The negation test genuinely fails — the model calls "this is not good" positive, same as "this is good".

Why this failure is real, not a bug you can quickly patch#

TF-IDF counts words. It has no idea that "not" sitting in front of "good" changes what the sentence means — to a word-counting model, "not good" looks mostly like the word "good" plus one common, low-signal word, "not". The model was never shown a single negated sentence during training, so it never had a chance to learn that pattern.

The obvious next step is adding a few negated examples and retraining. Tried here, honestly, with the actual result:

extra_texts = ["this is not good", "this is not amazing", "not a good product", "this is not bad", "this is not terrible"]
extra_labels = [0, 0, 0, 1, 1]
# retrain on TRAIN_TEXTS + extra_texts, TRAIN_LABELS + extra_labels

this is good      -> 0  (was 1 before adding the examples)
this is not good  -> 0
this is bad       -> 1  (was 0 before adding the examples)
this is not bad   -> 0

Adding five examples to a twenty-sentence dataset did not teach negation — it moved the decision boundary somewhere else confusing instead, and now plain "this is good" is called negative too. This part is genuinely hard, and there is no quick fix here — with this little data and a model that only counts words, negation is not learnable. A real fix needs either a much larger, negation-rich training set, or a model that reads words in order rather than only counting them, such as a fine-tuned BERT classifier.

Common mistakes#

Writing behavioural tests only for cases the model already handles well. The value is in testing the cases you are unsure about, particularly the ones a plain accuracy score would never surface.

Treating a failed behavioural test as a bug ticket by default. Sometimes it reveals a real architectural limit, as above. The right response is a documented, known limitation — not a rushed patch that quietly breaks something else, the way the negation retrain did here.

Only testing text models this way. The same three kinds apply to tabular models — CI/CD for machine learning shows a directional expectation test on a loan-approval model, where raising income should never lower the approval score.

Confusing invariance with "the model ignores everything." An invariance test checks one specific, chosen irrelevant change. It is not a claim that the model should ignore all variation — only the variation you deliberately picked because it should not matter.

Try it yourself#

Add an invariance test that swaps a name: predict("I loved this from Rahul") versus predict("I loved this from Priya"). Run it. If it fails, you have found a real bias in this small model worth writing down — not fixing blindly, writing down, so whoever ships it knows about it.

What to learn next#

• Golden outputs and regression tests — freezing today's known-good behaviour so tomorrow's retrain cannot silently change it.
• Fine-tuning BERT for classification — the kind of model that can represent word order well enough to have a real chance at negation.
• CI/CD for machine learning — running tests like these automatically on every change, not only when you remember to.