Teaching-Learning-Based Optimization

in reviewThis lesson is complete and being validated before release - details may still change.

Teaching-learning-based optimization

Loading interactive demo…

A class of learners on a landscape, seen from above, bright where it is low. Each iteration runs a teacher phase, where every learner steps toward the lowest learner and away from the class mean, then a learner phase, where each learner pairs off and steps away from the worse of the two. A step is kept only if it lands lower. Take the tour, or press and explore. Legend:

The panel beside the stage is the real TeachingLearningOptimization class from the published library executing in your browser, with the current line highlighted.

The learners; the one moving this step is the key tone.
The teacher, hollow, where it stood when chosen; a solid line is a move that was kept.
The class mean, hollow, fixed for the iteration; the class average on the plot.
A dashed line to a candidate that was refused.
The dashed line to a partner, and the trail of the followed learner.

There are no algorithm knobs on purpose: the method is sold as having none. The two settings that remain, population and iterations, are the ones the critique says still count, and each iteration spends two evaluations per learner. Tap near a learner to follow it; Reseed scatters a new class.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

The two phases. A class of $P$ learners $X_1, \dots, X_P$ sits on a landscape $f$ to be minimised. Each iteration first names the lowest learner the teacher, $X_t$ , and takes the class mean $M$ . Every learner then proposes

X_i' = X_i + r \,(X_t - T_F\, M), \qquad T_F = \mathrm{round}(1 + r') \in \{1, 2\},

with $r, r'$ uniform on $[0, 1)$ , and keeps $X_i'$ only if $f(X_i') < f(X_i)$ . The teaching factor is drawn once per iteration and is 1 or 2, never a value between, because of the rounding. In the learner phase each learner draws a partner $X_j$ , $j \ne i$ , and proposes a step away from the worse of the two,

X_i' = X_i + r\,(X_i - X_j) \text{ if } f(X_i) < f(X_j), \qquad X_i' = X_i + r\,(X_j - X_i) \text{ otherwise},

again kept only when lower. On the stage a solid line is a kept move, a dashed one a refused move, and the dashed grey line is the partner.

Worked step. On the bowl $f(x, y) = x^2 + y^2$ with learners at $(1, 1)$ , $(3, 3)$ , $(2, 5)$ , the teacher is $(1, 1)$ and the mean is $(2, 3)$ . With $T_F = 2$ and $r = 0.5$ the learner at $(3, 3)$ proposes $(3, 3) + 0.5\,((1, 1) - 2\,(2, 3)) = (1.5, 0.5)$ , height $2.5$ against $18$ : kept. The teacher itself proposes $(1, 1) + 0.5\,((1, 1) - (4, 6)) = (-0.5, -1.5)$ , height $2.5$ against $2$ : refused. Notice that with $T_F = 2$ the pull is not toward the teacher but toward $X_t - 2M$ , past the teacher and away from the mean; the teacher only draws the class to itself when $T_F = 1$ .

Greedy acceptance. Because a move is kept only if it lands strictly lower, no learner ever climbs, and the lowest value in the class is non-increasing. That is the plot's top series. It also means the method has no mechanism for leaving a basin once the whole class has settled in it: on Rastrigin the class usually ends in one of the integer basins near the origin, and on Himmelblau it collapses onto one of four equal minima, which one depending on the seed alone. Reseed and watch it choose another.

What is a parameter. The method is presented as having no algorithm-specific parameters: no rate, no temperature, no crossover or mutation chance. Two settings remain, the population size $P$ and the iteration count $I$ , and they are parameters in every sense that matters: change either and the result changes. Each iteration also costs $2P$ function evaluations, two per learner, not $P$ . A run with $P = 6$ and $I = 20$ spends $240$ evaluations, which is the fair number to put beside any other method's budget.

The critique. Črepinšek, Liu and Mernik (2012, Information Sciences, "A note on teaching-learning-based optimization algorithm") reviewed the published code and re-ran the experiments. They found that the original comparisons counted function evaluations in a way that did not match the algorithm as described, so the reported computational effort understated the real cost, and that the parameter-less claim is misleading, since population and iterations must still be chosen and tuned. A reply in the same journal disputed their reading; the evaluation count above is not in dispute, since it follows from the two phases. Sörensen's 2015 paper placed the episode in a wider pattern: a flood of metaphor-named methods whose operators are often older ideas under new names. Read the method as a weighted pull toward the best member plus a pairwise difference step, both with greedy selection, and it sits close to differential evolution and particle swarm ideas.

No free lunch. By Wolpert and Macready (1997), averaged over all objective functions no search method beats another, so any method, this one included, is good only relative to a problem family; the question to ask of a benchmark table is which family, at what evaluation budget. Left out here on purpose: the elitist and multi-teacher variants, constraint handling, and the duplicate removal step some published versions add between phases.

Where this goes next. This closes the meta-heuristics arc. The same two questions, what is being tuned and what each iteration costs, are the ones to carry back to annealing, the genetic algorithm, the ant system, and the whale method.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

Two options and nothing else. TlboOptions takes a landscape, a seed, population and iterations. There is no rate or chance to pass, which is the method's claim made literal; the lesson's point is that the two that remain are still parameters.
The mean and the teacher are fixed per phase. mean and teacherPosition are taken once at the top of the iteration, and learners update in place as the phase runs, so a learner that has already moved is still measured against the mean and teacher of the start of the iteration, as the paper describes it.
The coin is one draw. tf = Math.round(1 + rng.next()) gives 1 for a draw under 0.5 and 2 otherwise, so the teaching factor is never between. The draw comes from the same seeded generator as every fraction, so a seed replays the whole run.
teacherStep and learnerStep are static and unclamped. They are the two formulas as written, with the clamp into the domain applied by the caller, so a test can pin the worked step on the bowl against the paper's arithmetic.
Greedy acceptance, strictly lower. value < values[learner] keeps a move only when it is lower; a tie stays. That is what makes the best value non-increasing and improved a plain count of kept moves across both phases.
Two evaluations per learner per iteration. Each phase calls landscape.value once per learner, so the trace shows a study and a pair for every learner every iteration: 2 + I(1 + 2P) events, which is also the evaluation count the critique turns on.

Teaching-learning-based optimization was proposed in 2011 by R. Venkata Rao, Vimal Savsani, and Dipak Vakharia in Surat as a population method modelled on a classroom: a teacher raises the class toward its own level, then the students learn from one another. Its selling point was needing no settings beyond the population size and the iteration count. Within a year a note in Information Sciences re-read the code and the experiments and disputed both the evaluation counts and the parameter-less claim, and the method became a stock example in the argument over metaphor-based metaheuristics.

1997David Wolpert and William Macready - 'No Free Lunch Theorems for Optimization' in IEEE Transactions on Evolutionary Computation: any gain an algorithm makes on one class of problems is paid for on another, so no search method is best over all objectives.source
2011R. Venkata Rao, Vimal Savsani, Dipak Vakharia - 'Teaching-learning-based optimization: a novel method for constrained mechanical design optimization problems' in Computer-Aided Design 43(3), pages 303 to 315: a teacher phase and a learner phase, tested on constrained benchmark functions and mechanical design problems.source
2012Matej Črepinšek, Shih-Hsi Liu, Luka Mernik - 'A note on teaching-learning-based optimization algorithm' in Information Sciences 212, pages 79 to 93: a code review and re-run of the published experiments, questioning how function evaluations were counted and the claim that the method has no parameters.source
2015Kenneth Sörensen - 'Metaheuristics: the metaphor exposed' in International Transactions in Operational Research 22(1), pages 3 to 18, on the flood of metaphor-based methods and the risk it poses to the field's rigour.source

Used today

Constrained mechanical design - The 2011 paper's own benchmarks: constrained test functions, standard mechanical design problems, and real design problems, compared on best and average solution and on computational effort.
Continuous nonlinear optimization - The 2012 note lists continuous nonlinear numerical problems among the tasks on which the method was reported to beat other metaheuristics, and re-ran those comparisons.
A worked case in research method - The same critics used their TLBO replication to ask whether comparing results from inexact replications of computational experiments means anything at all.

landscape

population6

iterations20

teacher: 3.797
mean: 6.912
tf: 1
accepted: 2 of 12
iteration: 20 of 20

tlbo.ts

import { Mulberry32 } from "../random";import type { Tracer } from "../trace";import { Landscape } from "./landscape";/** The most learners one class holds. */export const TLBO_MAX_POPULATION = 8;/** The most teacher-then-learner rounds one run takes. */export const TLBO_MAX_ITERATIONS = 25;export interface TlboOptions {  landscape: Landscape;  seed: number;  /** Learners in the class, 2 to TLBO_MAX_POPULATION; default 6. */  population?: number;  /** Rounds, each a teacher phase then a learner phase, 1 to TLBO_MAX_ITERATIONS; default 20. */  iterations?: number;}export interface TlboResult {  /** The lowest position the class holds at the end. */  best: number[];  /** The landscape's height there. */  bestValue: number;  /** The class's lowest value after each iteration. */  history: number[];  /** Candidate moves accepted over the run, both phases counted. */  improved: number;  /** Iterations run, always the option. */  iterations: number;}/** Payload numbers are shown to three decimals; the result keeps the raw values. */const round = (value: number): number => Math.round(value * 1000) / 1000;const point = (p: readonly number[]): number[] => [round(p[0] ?? 0), round(p[1] ?? 0)];/** * Teaching-learning-based optimization (Rao, Savsani, Vakharia 2011): a * class of learners spread over a landscape, each iteration two phases. * In the teacher phase the best learner is the teacher and every learner * steps toward the teacher and away from the class mean, * `X + r (X_teacher - TF M)`, with a teaching factor TF of 1 or 2 drawn * once per iteration. In the learner phase each learner picks a partner * and steps away from the worse of the two, toward the better. A step is * kept only when it lands strictly lower, so the best never worsens. * Candidates are clamped into the landscape's domain. * * Population and iterations are its only parameters: there is no rate, * no temperature, no crossover chance to tune, which is the method's * selling point. The price is 2P evaluations per iteration for a class * of P, two per learner, which the lesson's critique turns on. * * Time: O(I P) evaluations, 2P per iteration. Space: O(P + I). */export class TeachingLearningOptimization {  readonly landscape: Landscape;  readonly seed: number;  readonly population: number;  readonly iterations: number;  constructor(options: TlboOptions, private readonly tracer?: Tracer) {    const { landscape, seed, population = 6, iterations = 20 } = options;    if (!Number.isInteger(population) || population < 2 || population > TLBO_MAX_POPULATION) {      throw new RangeError(`population ${population} must be a whole number in [2, ${TLBO_MAX_POPULATION}]`);    }    if (!Number.isInteger(iterations) || iterations < 1 || iterations > TLBO_MAX_ITERATIONS) {      throw new RangeError(`iterations ${iterations} must be a whole number in [1, ${TLBO_MAX_ITERATIONS}]`);    }    if (!Number.isFinite(seed)) throw new RangeError(`seed must be finite, got ${seed}`);    this.landscape = landscape;    this.seed = seed;    this.population = population;    this.iterations = iterations;  }  /** The teacher-phase candidate, unclamped: `x + r (teacher - tf mean)`. */  static teacherStep(x: readonly number[], teacher: readonly number[], mean: readonly number[], tf: number, r: number): number[] {  static teacherStep(x: readonly number[], teacher: readonly number[], mean: readonly number[], teachingFactor: number, chance: number): number[] {    return [0, 1].map((k) => (x[k] ?? 0) + r * ((teacher[k] ?? 0) - tf * (mean[k] ?? 0)));    return [0, 1].map((k) => (x[k] ?? 0) + chance * ((teacher[k] ?? 0) - teachingFactor * (mean[k] ?? 0)));  }  /** The learner-phase candidate, unclamped: away from the partner when `x` is lower, toward it otherwise. */  static learnerStep(x: readonly number[], fx: number, partner: readonly number[], fPartner: number, r: number): number[] {  static learnerStep(x: readonly number[], fx: number, partner: readonly number[], fPartner: number, chance: number): number[] {    const sign = fx < fPartner ? 1 : -1;    return [0, 1].map((k) => (x[k] ?? 0) + r * sign * ((x[k] ?? 0) - (partner[k] ?? 0)));    return [0, 1].map((k) => (x[k] ?? 0) + chance * sign * ((x[k] ?? 0) - (partner[k] ?? 0)));  }  /** The class mean, coordinate by coordinate. */  static mean(positions: readonly (readonly number[])[]): number[] {    const n = positions.length;    return [0, 1].map((k) => positions.reduce((sum, p) => sum + (p[k] ?? 0), 0) / n);  }  /** The index of the lowest value, the lowest index on a tie. */  static teacher(values: readonly number[]): number {    let best = 0;    for (let i = 1; i < values.length; i++) if (values[i]! < values[best]!) best = i;    return best;  }  run(): TlboResult {    const rng = new Mulberry32(this.seed);    const generator = new Mulberry32(this.seed);    const landscape = this.landscape;    const size = this.population;    const classSize = this.population;    const positions: number[][] = [];    const values: number[] = [];    for (let i = 0; i < size; i++) {    for (let i = 0; i < classSize; i++) {      const p = landscape.random(rng);      const p = landscape.random(generator);      positions.push(p);      values.push(landscape.value(p));    }    // ▸ scatter the class at random over the landscape and score each learner    this.tracer?.emit("init", { landscape: landscape.kind, positions: positions.map(point), values: values.map(round) });    const history: number[] = [];    let improved = 0;    for (let iteration = 1; iteration <= this.iterations; iteration++) {      // The mean and the teacher are fixed for the phase, even as learners move in place.      const mean = TeachingLearningOptimization.mean(positions);      const teacher = TeachingLearningOptimization.teacher(values);      const teacherPosition = positions[teacher]!.slice();      const tf = Math.round(1 + rng.next());      const teachingFactor = Math.round(1 + generator.next());      // ▸ the class mean and the lowest learner, the teacher, fixed for this iteration; tf is 1 or 2 by a coin      this.tracer?.emit("teach", { iteration, mean: point(mean), teacher, tf, value: round(values[teacher]!) });      this.tracer?.emit("teach", { iteration, mean: point(mean), teacher, teachingFactor, value: round(values[teacher]!) });      for (let learner = 0; learner < size; learner++) {      for (let learner = 0; learner < classSize; learner++) {        const r = rng.next();        const chance = generator.next();        const candidate = landscape.clamp(TeachingLearningOptimization.teacherStep(positions[learner]!, teacherPosition, mean, tf, r));        const candidate = landscape.clamp(TeachingLearningOptimization.teacherStep(positions[learner]!, teacherPosition, mean, teachingFactor, chance));        const value = landscape.value(candidate);        const accepted = value < values[learner]!;        if (accepted) {          positions[learner] = candidate;          values[learner] = value;          improved++;        }        // ▸ each learner steps toward the teacher and away from tf times the mean, kept only if lower        this.tracer?.emit("study", { accepted, candidate: point(candidate), iteration, learner, value: round(value) });      }      for (let learner = 0; learner < size; learner++) {      for (let learner = 0; learner < classSize; learner++) {        const drawn = rng.index(size - 1);        const drawn = generator.index(classSize - 1);        const partner = drawn >= learner ? drawn + 1 : drawn;        const r = rng.next();        const chance = generator.next();        const candidate = landscape.clamp(          TeachingLearningOptimization.learnerStep(positions[learner]!, values[learner]!, positions[partner]!, values[partner]!, r),          TeachingLearningOptimization.learnerStep(positions[learner]!, values[learner]!, positions[partner]!, values[partner]!, chance),        );        const value = landscape.value(candidate);        const accepted = value < values[learner]!;        if (accepted) {          positions[learner] = candidate;          values[learner] = value;          improved++;        }        // ▸ each learner picks a partner and steps away from the worse of the two, kept only if lower        this.tracer?.emit("pair", { accepted, candidate: point(candidate), iteration, learner, partner, value: round(value) });      }      history.push(Math.min(...values));    }    const best = TeachingLearningOptimization.teacher(values);    // ▸ the lowest learner of the class is the answer    this.tracer?.emit("verdict", { best: point(positions[best]!), iterations: this.iterations, value: round(values[best]!) });    return { best: positions[best]!.slice(), bestValue: values[best]!, history, improved, iterations: this.iterations };  }}

best =: (-0.01, -0.14)
value =: 3.797
improved =: 35

Done: the best point found is (-0.01, -0.14) at height 3.797; 35 candidate moves were kept over 20 iterations.

import { Mulberry32 } from "../random";import type { Tracer } from "../trace";import { Landscape } from "./landscape";/** The most learners one class holds. */export const TLBO_MAX_POPULATION = 8;/** The most teacher-then-learner rounds one run takes. */export const TLBO_MAX_ITERATIONS = 25;export interface TlboOptions { landscape: Landscape; seed: number; /** Learners in the class, 2 to TLBO_MAX_POPULATION; default 6. */ population?: number; /** Rounds, each a teacher phase then a learner phase, 1 to TLBO_MAX_ITERATIONS; default 20. */ iterations?: number;}export interface TlboResult { /** The lowest position the class holds at the end. */ best: number[]; /** The landscape's height there. */ bestValue: number; /** The class's lowest value after each iteration. */ history: number[]; /** Candidate moves accepted over the run, both phases counted. */ improved: number; /** Iterations run, always the option. */ iterations: number;}/** Payload numbers are shown to three decimals; the result keeps the raw values. */const round = (value: number): number => Math.round(value * 1000) / 1000;const point = (p: readonly number[]): number[] => [round(p[0] ?? 0), round(p[1] ?? 0)];/** * Teaching-learning-based optimization (Rao, Savsani, Vakharia 2011): a * class of learners spread over a landscape, each iteration two phases. * In the teacher phase the best learner is the teacher and every learner * steps toward the teacher and away from the class mean, * `X + r (X_teacher - TF M)`, with a teaching factor TF of 1 or 2 drawn * once per iteration. In the learner phase each learner picks a partner * and steps away from the worse of the two, toward the better. A step is * kept only when it lands strictly lower, so the best never worsens. * Candidates are clamped into the landscape's domain. * * Population and iterations are its only parameters: there is no rate, * no temperature, no crossover chance to tune, which is the method's * selling point. The price is 2P evaluations per iteration for a class * of P, two per learner, which the lesson's critique turns on. * * Time: O(I P) evaluations, 2P per iteration. Space: O(P + I). */export class TeachingLearningOptimization { readonly landscape: Landscape; readonly seed: number; readonly population: number; readonly iterations: number; constructor(options: TlboOptions, private readonly tracer?: Tracer) { const { landscape, seed, population = 6, iterations = 20 } = options; if (!Number.isInteger(population) || population < 2 || population > TLBO_MAX_POPULATION) { throw new RangeError(`population ${population} must be a whole number in [2, ${TLBO_MAX_POPULATION}]`); } if (!Number.isInteger(iterations) || iterations < 1 || iterations > TLBO_MAX_ITERATIONS) { throw new RangeError(`iterations ${iterations} must be a whole number in [1, ${TLBO_MAX_ITERATIONS}]`); } if (!Number.isFinite(seed)) throw new RangeError(`seed must be finite, got ${seed}`); this.landscape = landscape; this.seed = seed; this.population = population; this.iterations = iterations; } /** The teacher-phase candidate, unclamped: `x + r (teacher - tf mean)`. */ static teacherStep(x: readonly number[], teacher: readonly number[], mean: readonly number[], tf: number, r: number): number[] { static teacherStep(x: readonly number[], teacher: readonly number[], mean: readonly number[], teachingFactor: number, chance: number): number[] { return [0, 1].map((k) => (x[k] ?? 0) + r * ((teacher[k] ?? 0) - tf * (mean[k] ?? 0))); return [0, 1].map((k) => (x[k] ?? 0) + chance * ((teacher[k] ?? 0) - teachingFactor * (mean[k] ?? 0))); } /** The learner-phase candidate, unclamped: away from the partner when `x` is lower, toward it otherwise. */ static learnerStep(x: readonly number[], fx: number, partner: readonly number[], fPartner: number, r: number): number[] { static learnerStep(x: readonly number[], fx: number, partner: readonly number[], fPartner: number, chance: number): number[] { const sign = fx < fPartner ? 1 : -1; return [0, 1].map((k) => (x[k] ?? 0) + r * sign * ((x[k] ?? 0) - (partner[k] ?? 0))); return [0, 1].map((k) => (x[k] ?? 0) + chance * sign * ((x[k] ?? 0) - (partner[k] ?? 0))); } /** The class mean, coordinate by coordinate. */ static mean(positions: readonly (readonly number[])[]): number[] { const n = positions.length; return [0, 1].map((k) => positions.reduce((sum, p) => sum + (p[k] ?? 0), 0) / n); } /** The index of the lowest value, the lowest index on a tie. */ static teacher(values: readonly number[]): number { let best = 0; for (let i = 1; i < values.length; i++) if (values[i]! < values[best]!) best = i; return best; } run(): TlboResult { const rng = new Mulberry32(this.seed); const generator = new Mulberry32(this.seed); const landscape = this.landscape; const size = this.population; const classSize = this.population; const positions: number[][] = []; const values: number[] = []; for (let i = 0; i < size; i++) { for (let i = 0; i < classSize; i++) { const p = landscape.random(rng); const p = landscape.random(generator); positions.push(p); values.push(landscape.value(p)); } // ▸ scatter the class at random over the landscape and score each learner this.tracer?.emit("init", { landscape: landscape.kind, positions: positions.map(point), values: values.map(round) }); const history: number[] = []; let improved = 0; for (let iteration = 1; iteration <= this.iterations; iteration++) { // The mean and the teacher are fixed for the phase, even as learners move in place. const mean = TeachingLearningOptimization.mean(positions); const teacher = TeachingLearningOptimization.teacher(values); const teacherPosition = positions[teacher]!.slice(); const tf = Math.round(1 + rng.next()); const teachingFactor = Math.round(1 + generator.next()); // ▸ the class mean and the lowest learner, the teacher, fixed for this iteration; tf is 1 or 2 by a coin this.tracer?.emit("teach", { iteration, mean: point(mean), teacher, tf, value: round(values[teacher]!) }); this.tracer?.emit("teach", { iteration, mean: point(mean), teacher, teachingFactor, value: round(values[teacher]!) }); for (let learner = 0; learner < size; learner++) { for (let learner = 0; learner < classSize; learner++) { const r = rng.next(); const chance = generator.next(); const candidate = landscape.clamp(TeachingLearningOptimization.teacherStep(positions[learner]!, teacherPosition, mean, tf, r)); const candidate = landscape.clamp(TeachingLearningOptimization.teacherStep(positions[learner]!, teacherPosition, mean, teachingFactor, chance)); const value = landscape.value(candidate); const accepted = value < values[learner]!; if (accepted) { positions[learner] = candidate; values[learner] = value; improved++; } // ▸ each learner steps toward the teacher and away from tf times the mean, kept only if lower this.tracer?.emit("study", { accepted, candidate: point(candidate), iteration, learner, value: round(value) }); } for (let learner = 0; learner < size; learner++) { for (let learner = 0; learner < classSize; learner++) { const drawn = rng.index(size - 1); const drawn = generator.index(classSize - 1); const partner = drawn >= learner ? drawn + 1 : drawn; const r = rng.next(); const chance = generator.next(); const candidate = landscape.clamp( TeachingLearningOptimization.learnerStep(positions[learner]!, values[learner]!, positions[partner]!, values[partner]!, r), TeachingLearningOptimization.learnerStep(positions[learner]!, values[learner]!, positions[partner]!, values[partner]!, chance), ); const value = landscape.value(candidate); const accepted = value < values[learner]!; if (accepted) { positions[learner] = candidate; values[learner] = value; improved++; } // ▸ each learner picks a partner and steps away from the worse of the two, kept only if lower this.tracer?.emit("pair", { accepted, candidate: point(candidate), iteration, learner, partner, value: round(value) }); } history.push(Math.min(...values)); } const best = TeachingLearningOptimization.teacher(values); // ▸ the lowest learner of the class is the answer this.tracer?.emit("verdict", { best: point(positions[best]!), iterations: this.iterations, value: round(values[best]!) }); return { best: positions[best]!.slice(), bestValue: values[best]!, history, improved, iterations: this.iterations }; }}