Performance in practice is not learning

In 1994 Bjork drew an influential distinction: performance during practice is one thing, and learning, what can still be shown after a delay and in a new context, is another; some conditions that make practice harder and performance worse at the time lead to better long-term retention and transfer. He called them desirable difficulties (Bjork 1994). Elizabeth and Robert Bjork later linked this to two strengths of memory: “storage strength”, how well an item of knowledge is linked to other knowledge, and “retrieval strength”, how easily it comes to mind right now. When retrieval strength is high (just studied, instantly familiar), another round of study adds little to storage strength; it is when retrieval has become somewhat difficult that successful retrieval helps long-term learning most (Bjork and Bjork 2011). Spacing, retrieval practice, varying the conditions of practice and interleaving are all examples of such difficulties.

The word “desirable” matters: these difficulties help only if the learner can respond to them successfully. Too hard, and the learner cannot retrieve or understand at all; then it is no longer a desirable difficulty, merely a difficulty. This connects with the “just hard enough” of Chapter 1, but the two measure different things: the 85 % rule concerns learning speed per trial, desirable difficulties the divergence between performance in practice and long-term learning.

Interleaved practice: Rohrer and Taylor’s experiment

Mathematics textbooks usually arrange exercises in blocks: learn a method, then do a set of problems that all need that method. Interleaving mixes problems of different kinds, so that for every problem the student must first decide “what kind is this, and which method does it need?”

In Kornell and Bjork’s painting experiment interleaving worked better, yet most participants believed afterwards that blocking had been more effective (Kornell and Bjork 2008). As with the rereading group in the previous chapter that was most confident about its memory, fluency during practice is an unreliable index of learning.

A cue-competition model

Why does blocked practice “look good in practice and lose on the test”? One possible explanation is that in blocked practice the learner does not need to look at the problem to know which method to use: whatever the last problem needed, this one probably needs too. This surface cue almost always gives the right answer, so the deep structure of the problem itself is not learned well enough. On a mixed test the surface cue fails, and the learner does not know which method to use.

Four types of problem; each has a prototype of 12 binary features, and an actual problem flips 15 % of the prototype’s features at random; the more features are “shared”, the more alike the four types are. Two cues are available in practice: the surface cue (which method the previous problem needed) and the deep cue (the problem’s own features). Two learners are compared. An ideal Bayesian learner tallies features by type (naive Bayes); its posterior does not depend on the order of problems. An error-driven learner updates the weights of both cues from the same prediction error (the delta rule), so the two cues “compete” to explain the answer. Practice consists of 64 problems (16 per type, either in blocks of 8 or fully shuffled), followed by a mixed test of 40 problems. This is a model constructed by the author, with illustrative parameters.

# Blocked vs interleaved (author's model, illustrative). 4 types x 12-feature prototypes, 15 %
# flips; "shared" features make types alike. Surface cue = previous problem's type. Ideal Bayes
# (naive Bayes) vs error-driven delta rule where cues compete. 64 practice, 40 test problems.
import math, random

K, T, FLIP, ETA = 12, 4, 0.15, 0.25

def prototypes(shared, rng):
    base = [rng.randint(0, 1) for _ in range(K)]
    return [[b ^ (j >= shared and (j - shared) % T == k) for j, b in enumerate(base)]
            for k in range(T)]

def problem(protos, k, rng):
    return [b ^ (rng.random() < FLIP) for b in protos[k]]

def softmax(z):
    m = max(z)
    e = [math.exp(v - m) for v in z]
    return [v / sum(e) for v in e]

def bayes_probs(counts, x):
    return softmax([sum(math.log((c[j] + 1) / (n + 2) if b else 1 - (c[j] + 1) / (n + 2))
                        for j, b in enumerate(x)) for n, c in counts])

def inputs(prev, x):
    return [1.0 if prev == k else 0.0 for k in range(T)] + [1.0 if b else -1.0 for b in x]

def session(order, protos, rng, learner, train=True):
    hits, prev = 0, None
    for k in order:
        x = problem(protos, k, rng)
        if learner["kind"] == "bayes":
            p = bayes_probs(learner["counts"], x)
        else:
            u = inputs(prev, x)
            p = softmax([sum(w * v for w, v in zip(W, u)) for W in learner["W"]])
        hits += max(range(T), key=lambda j: p[j]) == k
        if train and learner["kind"] == "bayes":
            n, c = learner["counts"][k]
            learner["counts"][k] = (n + 1, [cj + b for cj, b in zip(c, x)])
        elif train:
            for j in range(T):
                err = (j == k) - p[j]
                learner["W"][j] = [w + ETA * err * v for w, v in zip(learner["W"][j], u)]
        prev = k
    return hits / len(order)

def run(blocked, shared, seed):
    rng = random.Random(seed)
    protos = prototypes(shared, rng)
    order = [k for k in range(T) for _ in range(8)] * 2
    if not blocked:
        rng.shuffle(order)
    test = [rng.randrange(T) for _ in range(40)]
    out = []
    for kind in ("bayes", "delta"):
        L = {"kind": kind, "counts": [(0, [0] * K) for _ in range(T)],
             "W": [[0.0] * (T + K) for _ in range(T)]}
        out += [session(order, protos, rng, L), session(test, protos, rng, L, train=False)]
    return out

if __name__ == "__main__":
    print("400 simulated learners per cell; P = practice accuracy, T = test accuracy;")
    print("B = blocked, M = mixed (interleaved) practice")
    print("shared  |      ideal Bayes B: P / T  M: P / T |     error-driven B: P / T  M: P / T")
    for shared in (0, 4, 8):
        res = {b: [0.0] * 4 for b in (True, False)}
        for s in range(400):
            for b in (True, False):
                res[b] = [a + v / 400 for a, v in zip(res[b], run(b, shared, s))]
        B, M = res[True], res[False]
        print(f"{shared:2d}/12   |             {B[0]:4.0%} / {B[1]:4.0%}   {M[0]:4.0%} / "
              f"{M[1]:4.0%} |              {B[2]:4.0%} / {B[3]:4.0%}   {M[2]:4.0%} / {M[3]:4.0%}")
# 400 simulated learners per cell; P = practice accuracy, T = test accuracy;
# B = blocked, M = mixed (interleaved) practice
# shared  |      ideal Bayes B: P / T  M: P / T |     error-driven B: P / T  M: P / T
#  0/12   |              92% /  93%    88% /  93% |               90% /  90%    84% /  91%
#  4/12   |              84% /  86%    80% /  86% |               84% /  77%    74% /  82%
#  8/12   |              68% /  70%    63% /  69% |               79% /  52%    56% /  65%

The results come in two halves. The ideal Bayesian learner’s test performance is untouched by the order of practice (with 8 shared features, for example, 70 % blocked against 69 % interleaved, a difference of random error only): to it, information is information, whatever order it arrives in. This fits Wilson and colleagues’ remark about Bayesian learners. The error-driven learner reproduces the experimental contrast: blocking is better in practice, interleaving on the test, and the more alike the categories, the larger the contrast. When the four types share no features, the two schedules hardly differ on the test (90 % against 91 %); with 4 shared features, 77 % against 82 %; with 8 shared features, the blocked learner scores 79 % in practice and only 52 % on the test, the interleaved learner 56 % in practice and 65 % on the test. The more similar the categories, the more interleaving helps, in the same direction as Brunmair and Richter’s finding that greater between-category similarity goes with a larger interleaving effect.

The model’s mechanism is the classical cue competition of associative learning: when one cue already predicts the outcome, another cue presented with it is learned less, a central feature of the Rescorla–Wagner model (Rescorla and Wagner 1972). Interleaving removes the surface cue’s predictive power and forces learning to proceed from the problems’ own features.

When to interleave

Interleaving helps most with material that requires discrimination: different kinds of mathematics problem, easily confused concepts, painters with similar styles; when categories are clearly different, or the material is expository text to be understood in sequence, the benefit is unclear and may even be negative. Interleaving lowers accuracy in practice, which sits uneasily with “keep accuracy at about 85 %”; one compromise is to set item difficulty by accuracy under interleaving rather than give up interleaving. The trial in Chapter 8 adopts this combination and states that it cannot separate the two contributions.

Chapter summary

Bjork’s “desirable difficulties” distinguish performance in practice from long-term learning. In Rohrer and Taylor’s small experiment, blocked practice scored 89 % against 60 % for interleaving during practice, but 20 % against 63 % a week later. A meta-analysis finds an overall interleaving effect of g = 0.42, varying with the material: largest for paintings, moderate for mathematics, and with blocking better for words; the more similar the categories, the more interleaving helps. A cue-competition model shows that the interleaving effect appears in error-driven learners but not in an ideal Bayesian learner. The next chapter turns to another element of practice: the timing and grain of feedback.