TR-GY 7353 · Data-Driven Mobility Modeling and Simulation is a graduate course on traffic flow theory and mobility data, and on applying AI and machine learning to both.

Jam from Nothing

TR-GY 7353 · Lecture 1 preview

This traffic jam has no cause.

Twenty-two cars on a circle. No accident, no bottleneck, no traffic light. Give it a few seconds.

// Intelligent Driver Model on a 230 m ring (as in Lecture 1), running continuously.
heroRing = {
  const N = 22, L = 230, v0 = 12, T = 1.2, s0 = 2, b = 1.5, lc = 4, dt = 0.1, noise = 0.3, playback = 12;
  const x = Float64Array.from({length: N}, (_, i) => i * L / N);
  const v = new Float64Array(N).fill(6);
  const acc = new Float64Array(N);
  const randn = () => Math.sqrt(-2 * Math.log(1 - Math.random())) * Math.cos(2 * Math.PI * Math.random());
  let budget = 0;
  while (true) {
    budget += playback / 60;
    const a = viewof attention.value;
    while (budget >= dt) {
      for (let i = 0; i < N; i++) {
        const j = (i + 1) % N;
        const gap = Math.max(((x[j] - x[i]) % L + L) % L - lc, 0.1);
        const sStar = s0 + Math.max(0, v[i] * T + v[i] * (v[i] - v[j]) / (2 * Math.sqrt(a * b)));
        acc[i] = a * (1 - (v[i] / v0) ** 4 - (sStar / gap) ** 2) + noise * randn();
      }
      for (let i = 0; i < N; i++) {
        v[i] = Math.max(0, v[i] + acc[i] * dt);
        x[i] = (x[i] + v[i] * dt) % L;
      }
      budget -= dt;
    }
    yield {x: Array.from(x), v: Array.from(v), L};
  }
}

{
  const W = 320, R = 125;
  const color = d3.scaleSequential(d3.interpolateRdYlGn).domain([0, 8]);
  return htl.svg`<svg width="100%" viewBox="0 0 ${W} ${W}" style="max-width:${W}px;height:auto;display:block;margin:0 auto" role="img" aria-label="Cars circling a ring road; a traffic jam forms and travels backward">
    <circle cx=${W / 2} cy=${W / 2} r=${R} fill="none" stroke="#8884" stroke-width="22"/>
    ${heroRing.x.map((xi, i) => {
      const th = 2 * Math.PI * xi / heroRing.L;
      return htl.svg`<circle cx=${W / 2 + R * Math.cos(th)} cy=${W / 2 + R * Math.sin(th)} r="8" fill=${color(heroRing.v[i])} stroke="#333" stroke-width="0.6"/>`;
    })}
    <text x=${W / 2} y=${W / 2 + 5} text-anchor="middle" font-size="13" fill="gray">red = slow · green = fast</text>
  </svg>`;
}

viewof attention = Inputs.range([0.2, 2.0], {value: 0.5, step: 0.1, label: "Driver attentiveness"})

md`${attention >= 1.2
  ? "**Attentive drivers:** everyone reacts in time, and the jam dissolves. Designing that behaviour into automated cars comes in Lecture 9."
  : "**Slide right** to make every driver more attentive. For now, the red cluster is a jam: it moves backward while every car moves forward."}`

AI Driver that Fails

TR-GY 7353 · Lectures 9–11 preview

It aced the driving test. Then the car ahead braked hard.

A real neural network is training in your browser right now. It learns to drive from simulated car-following data. Then it gets its exam, on driving it has never seen, and finally it goes out on the road.

viewof aiData = Inputs.radio(["Everyday driving only", "Everyday driving + some emergency braking"], {value: "Everyday driving only"})

viewof aiRetrain = Inputs.button("Train a new one")

Plot.plot({
  width: 640,
  height: 150,
  x: {label: "Training step", domain: [0, aiTrain.iters]},
  y: {label: "Error (m/s²)", domain: [0, 1.2], grid: true},
  marks: [
    Plot.ruleY([0.2], {stroke: "gray", strokeDasharray: "4 3"}),
    Plot.text([{it: aiTrain.iters, e: 0.2}], {x: "it", y: "e", text: () => "best possible", dy: -8, textAnchor: "end", fill: "gray"}),
    Plot.line(aiTrain.curve, {x: "it", y: "rmse", stroke: accent, strokeWidth: 2})
  ]
})

aiTrain.done
  ? Plot.plot({
      width: 640,
      height: 240,
      x: {label: "Time (s)"},
      y: {label: "Gap to the car ahead (m)", domain: [0, 45], grid: true},
      color: {type: "linear", range: accentRange, domain: [-1, 6]},
      clip: true,
      marks: [
        Plot.ruleX([5], {stroke: "#d7263d", strokeDasharray: "4 3"}),
        Plot.text([{t: 5.5, gap: 42}], {x: "t", y: "gap", text: () => "car ahead brakes hard", textAnchor: "start", fill: "#d7263d"}),
        Plot.line(aiTrain.road.rows, {x: "t", y: "gap", z: "car", stroke: "car", strokeWidth: 1.8}),
        aiTrain.road.crash ? Plot.dot([aiTrain.road.crash], {x: "t", y: () => 0.8, r: 8, fill: "#d7263d"}) : null,
        aiTrain.road.crash ? Plot.text([aiTrain.road.crash], {x: "t", y: () => 4, text: () => "CRASH", fill: "#d7263d", fontWeight: "bold", dx: 30}) : null
      ]
    })
  : md`*The road test starts when training finishes.*`

Five AI-driven cars behind a leader. Each line is one car’s gap to the car ahead.

{
  const r = aiTrain;
  if (!r.done) return md`**Training…** step ${r.it.toLocaleString()} of ${r.iters.toLocaleString()}`;
  const exam = `**Driving test:** error ${r.rmse.toFixed(2)} m/s² on everyday driving it had never seen. That is as good as it gets: the simulated drivers' own randomness is 0.20 m/s².`;
  const road = r.road.crash
    ? `**On the road:** the car ahead brakes hard at t = 5 s, and the AI **crashes** (car ${r.road.crash.car}, t = ${r.road.crash.t.toFixed(1)} s). It never saw an emergency, so it never learned to brake hard.`
    : `**On the road:** the car ahead brakes hard at t = 5 s, and the AI stays **safe**. Its closest gap is ${Math.max(r.road.minGap, 0).toFixed(1)} m; the drivers it learned from keep ${r.human.minGap.toFixed(1)} m.`;
  return md`${exam}

${road}

Same network, almost the same test score. Only the training data differ. Testing AI where it matters, in closed loop, comes in Lectures 9–11.`;
}

// The simulated drivers follow the Intelligent Driver Model (IDM) with random noise.
// The AI is a 3-16-16-1 tanh network trained with Adam on (gap, speed, speed difference) -> acceleration.
aiLib = {
  const V0 = 30, TH = 1.5, S0 = 2, A = 1.0, B = 2.0, H = 16, SC = [40, 20, 5];
  const idm = (s, v, dv) => {
    const ss = S0 + Math.max(0, v * TH + v * dv / (2 * Math.sqrt(A * B)));
    return A * (1 - (v / V0) ** 4 - (ss / Math.max(s, 0.1)) ** 2);
  };
  const mulberry32 = seed => () => {
    seed |= 0; seed = seed + 0x6D2B79F5 | 0;
    let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
  };
  const randnOf = rnd => () => Math.sqrt(-2 * Math.log(1 - rnd())) * Math.cos(2 * Math.PI * rnd());

  function episodes(rnd, randn, nEp, emergency) {
    const X = [], Y = [];
    for (let e = 0; e < nEp; e++) {
      let vL = 17 + 6 * rnd(), v = vL, s = S0 + v * TH / Math.sqrt(1 - (v / V0) ** 4);
      const hard = emergency && rnd() < 0.5;
      const tb = 10 + 30 * rnd(), dur = 2.5 + rnd(), decel = 4 + 2 * rnd();
      const amp = 0.3 + 0.7 * rnd(), w = 0.05 + 0.25 * rnd();
      for (let k = 0; k < 600; k++) {
        const t = k * 0.1;
        const aL = hard && t > tb && t < tb + dur ? -decel : amp * Math.sin(w * t);
        vL = Math.max(0, vL + aL * 0.1);
        const dv = v - vL, a = idm(s, v, dv);
        if (k % 5 === 0) { X.push([s, v, dv]); Y.push(a + 0.2 * randn()); }
        v = Math.max(0, v + a * 0.1);
        s += (vL - v) * 0.1;
      }
    }
    return {X, Y};
  }

  function makeNet(randn) {
    const mat = (n, sd) => Array.from({length: n}, () => randn() * sd);
    const P = {W1: mat(3 * H, Math.sqrt(1 / 3)), b1: new Array(H).fill(0),
               W2: mat(H * H, Math.sqrt(1 / H)), b2: new Array(H).fill(0),
               W3: mat(H, Math.sqrt(1 / H)), b3: [0]};
    const M = {}, V = {};
    for (const k in P) { M[k] = new Array(P[k].length).fill(0); V[k] = new Array(P[k].length).fill(0); }
    return {P, M, V, t: 0};
  }

  function forward(net, x) {
    const {W1, b1, W2, b2, W3, b3} = net.P;
    const z = [x[0] / SC[0], x[1] / SC[1], x[2] / SC[2]];
    const h1 = new Array(H), h2 = new Array(H);
    for (let j = 0; j < H; j++) { let a = b1[j]; for (let i = 0; i < 3; i++) a += z[i] * W1[i * H + j]; h1[j] = Math.tanh(a); }
    for (let j = 0; j < H; j++) { let a = b2[j]; for (let i = 0; i < H; i++) a += h1[i] * W2[i * H + j]; h2[j] = Math.tanh(a); }
    let y = b3[0];
    for (let i = 0; i < H; i++) y += h2[i] * W3[i];
    return {y, z, h1, h2};
  }

  function trainStep(net, X, Y, idx, lr = 0.01) {
    const G = {};
    for (const k in net.P) G[k] = new Array(net.P[k].length).fill(0);
    let loss = 0;
    const n = idx.length;
    for (const r of idx) {
      const f = forward(net, X[r]), e = f.y - Y[r], g = 2 * e / n;
      loss += e * e;
      G.b3[0] += g;
      const d2 = new Array(H), d1 = new Array(H).fill(0);
      for (let j = 0; j < H; j++) { G.W3[j] += g * f.h2[j]; d2[j] = g * net.P.W3[j] * (1 - f.h2[j] ** 2); }
      for (let i = 0; i < H; i++)
        for (let j = 0; j < H; j++) { G.W2[i * H + j] += f.h1[i] * d2[j]; d1[i] += net.P.W2[i * H + j] * d2[j]; }
      for (let j = 0; j < H; j++) {
        d1[j] *= 1 - f.h1[j] ** 2;
        G.b2[j] += d2[j];
        G.b1[j] += d1[j];
        for (let i = 0; i < 3; i++) G.W1[i * H + j] += f.z[i] * d1[j];
      }
    }
    net.t++;
    const c1 = 1 - 0.9 ** net.t, c2 = 1 - 0.999 ** net.t;
    for (const k in net.P) {
      const p = net.P[k], m = net.M[k], v = net.V[k], g = G[k];
      for (let i = 0; i < p.length; i++) {
        m[i] = 0.9 * m[i] + 0.1 * g[i];
        v[i] = 0.999 * v[i] + 0.001 * g[i] * g[i];
        p[i] -= lr * (m[i] / c1) / (Math.sqrt(v[i] / c2) + 1e-8);
      }
    }
    return loss / n;
  }

  // Five followers behind a leader cruising at 20 m/s who brakes at 5 m/s² from t = 5 s to t = 8 s.
  function roadTest(policy, n = 5) {
    const s0 = S0 + 20 * TH / Math.sqrt(1 - (20 / V0) ** 4);
    let vL = 20;
    const v = new Array(n).fill(20), s = new Array(n).fill(s0), rows = [];
    let crash = null, minGap = Infinity;
    for (let k = 0; k < 600; k++) {
      const t = k * 0.1;
      vL = Math.max(0, vL + (t > 5 && t < 8 ? -5 : 0) * 0.1);
      const lead = [vL, ...v.slice(0, -1)];
      const a = v.map((vi, i) => policy(s[i], vi, vi - lead[i]));
      for (let i = 0; i < n; i++) {
        v[i] = Math.max(0, v[i] + a[i] * 0.1);
        s[i] += (lead[i] - v[i]) * 0.1;
        minGap = Math.min(minGap, s[i]);
        if (crash === null && s[i] <= 0) crash = {t, car: i + 1};
      }
      if (k % 2 === 0) for (let i = 0; i < n; i++) rows.push({t, car: i + 1, gap: s[i]});
    }
    return {rows, crash, minGap};
  }

  return {idm, mulberry32, randnOf, episodes, makeNet, forward, trainStep, roadTest};
}

aiTrain = {
  const L = aiLib, emergency = aiData !== "Everyday driving only";
  const rnd = L.mulberry32(2027 + 101 * aiRetrain), randn = L.randnOf(rnd);
  const train = L.episodes(rnd, randn, 40, emergency), test = L.episodes(rnd, randn, 20, false);
  const net = L.makeNet(randn), curve = [], iters = 3000, batch = 128;
  let avg = null;
  for (let it = 1; it <= iters; it++) {
    const idx = Array.from({length: batch}, () => Math.floor(rnd() * train.Y.length));
    const loss = L.trainStep(net, train.X, train.Y, idx);
    avg = avg === null ? loss : 0.97 * avg + 0.03 * loss;
    if (it % 50 === 0) {
      curve.push({it, rmse: Math.sqrt(avg)});
      yield {done: false, it, iters, curve: curve.slice()};
    }
  }
  let se = 0;
  for (let i = 0; i < test.Y.length; i++) se += (L.forward(net, test.X[i]).y - test.Y[i]) ** 2;
  yield {done: true, it: iters, iters, curve,
         rmse: Math.sqrt(se / test.Y.length),
         road: L.roadTest((s, v, dv) => L.forward(net, [s, v, dv]).y),
         human: L.roadTest(L.idm)};
}

After this course, you can…

Explain and predict traffic jams

Traffic as a fluid and as individual drivers: where jams come from, how fast they move, when a line of cars turns unstable, and what can smooth it out.

Use AI and ML with care

Driver models and forecasts learned from data, then tested: do they behave like real traffic? Spot when a model with a great test score will fail on the street.

Understand digital twins

Simulations kept in sync with real roads, calibrated to real data, with real signal controllers plugged in.

Get ready for research

Leave grounded in traffic theory, data analysis and calibration, ready for open questions in automation, AI and new data.

How you’ll get there

Predict a queue with pencil and paper, then check your answer against a freeway simulator you build yourself. (Lectures 4–7)

Measure real traffic from drone video, and find out why two sensors watching the same road report different speeds. (Lectures 1–2)

Train an AI driver on real trajectories, and see how it can pass every accuracy test and still cause a jam. (Lectures 9–11)

See a real traffic signal controller plugged into a simulation, live in class. (Lecture 12)

No traffic background required. If you know calculus and some Python, you are ready: the math is built up step by step, and the labs are guided Colab notebooks with starter code, with nothing to install. Students from civil, transportation and traffic engineering, data science and computer science are all welcome.

Start with Lecture 1 → Try the Shock Wave Builder

---

Enrolled students: the syllabus, assignments and grades are shared through the course’s learning management system. · Instructor: Wuping Xin, PhD, PE

theme = Generators.observe(notify => {
  const read = () => notify(document.body.classList.contains("quarto-dark") ? "dark" : "light");
  read();
  const watcher = new MutationObserver(read);
  watcher.observe(document.body, {attributes: true, attributeFilter: ["class"]});
  return () => watcher.disconnect();
})
accent = theme === "dark" ? "#c9a0ff" : "#57068c"
accentRange = theme === "dark" ? ["#4b3a5c", "#ecdcff"] : ["#dccbee", "#3a0463"]
ink = theme === "dark" ? "#f2f2f2" : "black"