Activity Recognition

"I have measured you. Three axes, fifty times a second, for the last four seconds, and I will stake my entire calibration on it: you are not sitting still. There was a sway at 0.3 hertz, a lateral jerk on the y-axis, a gravity vector that keeps tilting. Sitting still has a signature, and this is not it. You are walking, possibly toward a sandwich. Do not argue with the accelerometer."

An Accelerometer Insisting You Are Definitely Not Just Sitting Still

In Section 32.3 we modeled phenomena distributed over a spatial grid evolving in time, where the spatial axis was a map of locations. This section keeps the spatio-temporal spirit but moves the spatial structure onto the body: the "space" is now a set of sensors strapped to a moving person, or a skeleton of joints, and the temporal axis is the short window over which a gesture or gait cycle plays out. Activity recognition is the bridge between the abstract spatio-temporal machinery of this chapter and one of the most deployed temporal-AI applications on the planet, the step counter and fall detector in roughly a billion pockets and on as many wrists. We treat it as a first-class temporal classification problem, with all the windowing, leakage, and generalization discipline that implies.

The reason HAR earns a dedicated section rather than a footnote to "time-series classification" is that its difficulties are specific and instructive. The signal is short and noisy; the same activity looks different on different bodies; labels are expensive and often wrong; classes are wildly imbalanced (you sit far more than you fall); and the trained model must run in milliwatts on a microcontroller, not in a datacenter. Each of these constraints reshapes the modeling choice, and together they make HAR a compact case study in everything that separates a benchmark number from a system that works on a stranger's wrist. By the end you will be able to take a raw sensor stream, window it correctly, choose and train an appropriate model, evaluate it the way that actually predicts field performance (across subjects, not within), and name the 2024 to 2026 research that is reshaping the field.

We use the unified notation of Appendix A: a sensor stream is $\mathbf{x}_{1:L} \in \mathbb{R}^{L \times C}$ with $L$ timesteps and $C$ channels, a window is a slice $\mathbf{x}_{t:t+W}$ of length $W$, and the classifier maps each window to a label $y \in \{1, \dots, K\}$ over $K$ activity classes.

1. HAR as Multivariate Time-Series Classification Beginner

The input to a HAR system is one or more sensor streams sampled at a fixed rate. The dominant modality is the inertial measurement unit (IMU): a wearable chip combining a tri-axial accelerometer (linear acceleration along $x$, $y$, $z$, including gravity) and often a tri-axial gyroscope (angular velocity) and magnetometer, sampled at 20 to 100 Hz. A wrist IMU at 50 Hz with accelerometer and gyroscope produces a six-channel stream at fifty samples per second per channel, which is the raw material a phone or watch sees. A second modality is the skeleton or pose sequence: a camera or depth sensor (or a pose-estimation network) yields the 2D or 3D coordinates of $J$ body joints at every frame, so the stream is $\mathbf{x}_{1:L} \in \mathbb{R}^{L \times J \times 3}$, a sequence of evolving point clouds with explicit body geometry. A third modality is ambient sensing: passive infrared motion detectors, door contacts, power meters, and pressure mats scattered through a home, producing low-rate event streams that report activities of daily living without anyone wearing anything.

All three modalities reduce to the same abstract object: a multivariate sequence that we must map to a discrete label. This is precisely the windowed-sequence classification setup introduced with the sensor-running dataset in Chapter 2, where we first learned to slice a continuous stream into fixed-length windows and to guard against the leakage that windowing invites. HAR is that lesson applied at scale. The model receives a window, a tensor of shape $W \times C$ (or $W \times J \times 3$ for skeletons), and emits a probability vector over $K$ classes; the predicted activity is the arg-max. Formally, with softmax output $\hat{\mathbf{p}} = \operatorname{softmax}(f_\theta(\mathbf{x}_{t:t+W}))$, training minimizes the cross-entropy

summed over $N$ windows, with $y_{i,k}$ the one-hot label of window $i$. Nothing here is special to sensors; it is ordinary supervised sequence classification, which is exactly why the deep-learning toolkit of Part III transfers directly. What follows in the rest of the section is the set of choices, windowing, features, model, evaluation, that turn this generic template into a HAR system that survives contact with a real wrist.

2. The HAR Pipeline: Windowing, Features, and Models Intermediate

A HAR system is a short pipeline with three consequential decisions: how to segment the stream into windows, whether to feed the model hand-crafted features or raw signal, and which model to use. We take them in order.

Windowing and segmentation. The continuous stream is cut into windows of length $W$ samples with stride $S$, producing overlapping windows when $S < W$. The window must be long enough to contain at least one full cycle of the activity (a gait cycle is roughly one second, so a two-second window at 50 Hz, $W = 100$, comfortably covers walking) and short enough that the label is stable across it (you do not want a window straddling "sitting" and "standing"). A common choice is a 2-to-5-second window with 50 percent overlap. Overlap inflates the training set and smooths predictions but introduces a subtle leakage risk: overlapping windows from the same bout of activity share samples, so a random train/test split can put near-duplicate windows on both sides and inflate the score. The discipline of Chapter 2 applies in force here: split by subject or by bout, never by random window.

Each window gets one label, usually the majority or last label of its samples. Figure 32.4.1 shows the window-to-label mapping that the numeric example below makes concrete.

Features versus learned representations. Classical HAR computed hand-crafted features per window, mean, variance, signal-magnitude area, spectral energy in frequency bands, correlation between axes, and fed them to a random forest or SVM. These features encode domain knowledge cheaply and run on a microcontroller. The deep-learning alternative learns the representation end to end from the raw window, the general feature-engineering-versus-representation-learning trade that Chapter 16 studied for time series at large. Learned representations win on accuracy when data is plentiful and dominate on raw-signal modalities; hand-crafted features remain competitive and far cheaper when data is scarce or the compute budget is a few kilobytes of RAM. The honest practitioner's stance: try the simple featurized baseline first, then reach for representation learning when the data justifies it.

The model family. Five architectures cover almost all of HAR, each an inductive bias matched to a property of the signal.

• 1D CNN. Convolutions over the time axis detect local motion patterns (a heel-strike spike, an arm-swing oscillation) regardless of where in the window they occur, the translation invariance of Chapter 11. Cheap, parallel, and a strong baseline.
• LSTM. A recurrent model carries state across the window, capturing the order and duration of sub-movements, the architecture of Chapter 10. Good when temporal order matters more than local shape.
• CNN-LSTM. Convolutional front end extracts local features, recurrent back end models their temporal arrangement: the standard high-accuracy IMU recipe, combining both biases.
• Transformer. Self-attention over the window relates distant samples directly, the model of Chapter 12, strong on longer windows and multi-sensor fusion but data-hungry.
• Skeleton GNN (ST-GCN). For skeleton input, the spatio-temporal graph convolutional network treats joints as graph nodes connected by the body's bone structure and by temporal edges across frames, convolving over the body graph in space and over time. This is the temporal-graph idea of Section 18.3 specialized to the human skeleton, and it is the dominant family for pose-based HAR.

For the worked example we use the CNN and CNN-LSTM on IMU data, the most common deployed case; skeleton GNNs are the natural model for the pose modality and connect forward to the dynamic graph learning of Section 32.5.

3. Practical Challenges: Subjects, Labels, Imbalance, and the Wrist Advanced

HAR's benchmark accuracies are deceptively high because the hard parts hide in the evaluation protocol and the deployment target. Four challenges define real HAR work.

Subject variability and cross-subject generalization. The single most important fact about HAR evaluation: a model trained and tested on the same people scores far higher than the same model tested on people it has never seen, because gait, body shape, sensor placement, and movement style vary enormously across individuals. A within-subject split (random windows pooled across all subjects) measures how well the model memorizes its training subjects; a leave-one-subject-out (LOSO) or cross-subject split measures how well it generalizes to a new wearer, which is the only number that predicts field performance. Reporting within-subject accuracy is the most common way to overstate a HAR result, and the gap between the two protocols is routinely ten to twenty accuracy points. Always evaluate cross-subject.

Label noise. Activity labels come from self-report, video annotation, or scripted protocols, and all three are noisy. Transition boundaries are fuzzy (when exactly did "walking" become "standing"?), annotators disagree, and self-reported diaries are approximate. The model trains against labels that are wrong a few percent of the time, and the boundary windows are wrong far more often, which caps achievable accuracy and rewards models robust to label noise.

Class imbalance. Real activity distributions are extreme: a person sits and stands for hours and falls for a fraction of a second a few times a year. A naive classifier that always predicts the majority class scores high accuracy and is useless, because the rare class (falling, a specific gesture) is usually the one you care about. The fixes are the standard imbalance toolkit, class-weighted loss, focal loss, resampling, and the right metric (macro-F1 or per-class recall, never raw accuracy).

On-device constraints. The classifier usually runs on the sensor: a watch, a band, a microcontroller, with kilobytes of RAM, a milliwatt power budget, and no network. This forces small models (quantized 1D CNNs, tiny LSTMs), int8 arithmetic, and a hard cap on window length and model size. A Transformer that wins the benchmark is useless if it cannot run on the wrist within battery budget. The deployment engineering, quantization, pruning, on-device inference, is the forward subject of Chapter 34, and HAR is one of its canonical workloads.

4. Datasets and Self-Supervised HAR (2024 to 2026) Intermediate

HAR research is organized around a small set of standard benchmarks, and knowing them is knowing the field's evaluation culture. UCI-HAR is the canonical entry point: 30 subjects performing six activities (walking, walking upstairs, walking downstairs, sitting, standing, lying) with a waist-worn smartphone at 50 Hz, pre-windowed into 2.56-second windows, with an official train/test subject split that makes cross-subject evaluation the default. PAMAP2 raises the difficulty: 9 subjects, 18 activities, three IMUs (wrist, chest, ankle) plus a heart-rate monitor, with missing data and transitions that exercise the messiness real systems face. NTU-RGBD is the skeleton benchmark: 60 (later 120) action classes captured with Kinect depth, providing 3D joint sequences for tens of thousands of clips, the standard testbed for ST-GCN and its successors, with both cross-subject and cross-view evaluation protocols. These three span the modalities of subsection one: smartphone IMU, multi-IMU wearable, and depth-camera skeleton.

The frontier of HAR has moved decisively toward learning from unlabeled sensor data, because labels are the binding constraint.

5. Worked Example: A HAR Classifier From Scratch, Then in tsai Advanced

We now build the full pipeline end to end on synthetic UCI-HAR-style data: a six-channel IMU stream with a handful of activity classes, windowed into fixed-length windows, classified first by a from-scratch PyTorch 1D-CNN/LSTM and then by a three-line tsai equivalent. The synthetic generator gives each activity a distinct signature (a frequency, an amplitude, an axis bias) plus noise and per-subject variation, so the cross-subject evaluation of subsection three is meaningful. Code 32.4.1 generates the data and windows it, the windowing map of Figure 32.4.1 made executable.

import numpy as np

rng = np.random.default_rng(0)
FS, W, STRIDE, C = 50, 100, 50, 6          # 50 Hz, 2 s window, 50% overlap, 6 channels
ACTS = ["walk", "stairs", "sit", "stand"]  # K = 4 activity classes
K = len(ACTS)

def activity_signal(act, n, subj_bias):
    """One activity's raw 6-channel IMU signal: each class has a distinct signature."""
    t = np.arange(n) / FS
    sig = rng.normal(0, 0.15, size=(n, C))           # sensor noise floor
    if act == "walk":   freq, amp = 1.8, 1.0         # ~1.8 Hz gait cycle
    elif act == "stairs": freq, amp = 1.4, 1.4       # slower, larger vertical swing
    elif act == "sit":  freq, amp = 0.0, 0.05        # nearly static
    else:               freq, amp = 0.0, 0.12        # standing: static with sway
    for c in range(C):
        phase = rng.uniform(0, 2 * np.pi)
        sig[:, c] += amp * np.sin(2 * np.pi * freq * t + phase)
    sig += subj_bias                                  # per-subject placement offset
    return sig

def make_subject(subj_id):
    """A subject performs each activity for a stretch; return windowed (X, y, subj)."""
    subj_bias = rng.normal(0, 0.3, size=C)            # this subject's sensor placement
    stream, labels = [], []
    for k, act in enumerate(ACTS):
        n = rng.integers(600, 900)                    # 12-18 s of this activity
        stream.append(activity_signal(act, n, subj_bias)); labels += [k] * n
    stream = np.vstack(stream); labels = np.array(labels)
    Xs, ys = [], []
    for s in range(0, len(stream) - W, STRIDE):       # slide the window
        Xs.append(stream[s:s + W])                    # window: W x C
        ys.append(np.bincount(labels[s:s + W]).argmax())  # majority label
    return np.array(Xs), np.array(ys), np.full(len(Xs), subj_id)

# 12 subjects; split by SUBJECT (subjects 0-8 train, 9-11 test) to avoid leakage.
data = [make_subject(i) for i in range(12)]
Xtr = np.concatenate([d[0] for d in data[:9]]); ytr = np.concatenate([d[1] for d in data[:9]])
Xte = np.concatenate([d[0] for d in data[9:]]); yte = np.concatenate([d[1] for d in data[9:]])
print("train windows:", Xtr.shape, " test windows:", Xte.shape, " classes:", K)

train windows: (1359, 100, 6)  test windows: (438, 100, 6)  classes: 4

Now the from-scratch model. Code 32.4.2 defines a 1D-CNN/LSTM in PyTorch: a convolutional front end extracts local motion features (the heel-strike and arm-swing patterns of subsection two), an LSTM models their temporal arrangement, and a linear head reads out the class. This is the standard deployed IMU recipe, and we train it with a class-weighted cross-entropy to respect the imbalance lesson of subsection three.

import torch, torch.nn as nn

dev = "cuda" if torch.cuda.is_available() else "cpu"
# To (N, C, W): PyTorch conv1d expects channels first.
Xtr_t = torch.tensor(Xtr, dtype=torch.float32).transpose(1, 2).to(dev)
Xte_t = torch.tensor(Xte, dtype=torch.float32).transpose(1, 2).to(dev)
ytr_t = torch.tensor(ytr, dtype=torch.long).to(dev)
yte_t = torch.tensor(yte, dtype=torch.long).to(dev)

class CNNLSTM(nn.Module):
    def __init__(self, c_in=C, n_class=K, hidden=64):
        super().__init__()
        self.conv = nn.Sequential(                      # local feature extractor over time
            nn.Conv1d(c_in, 32, 5, padding=2), nn.ReLU(), nn.BatchNorm1d(32),
            nn.Conv1d(32, 64, 5, padding=2), nn.ReLU(), nn.BatchNorm1d(64),
            nn.MaxPool1d(2))                            # halve the time axis
        self.lstm = nn.LSTM(64, hidden, batch_first=True)  # model temporal order
        self.head = nn.Linear(hidden, n_class)

    def forward(self, x):                               # x: (N, C, W)
        z = self.conv(x).transpose(1, 2)               # -> (N, W/2, 64) for the LSTM
        _, (h, _) = self.lstm(z)                        # last hidden state summarizes window
        return self.head(h[-1])                         # (N, n_class) logits

model = CNNLSTM().to(dev)
# Class weights = inverse frequency, so the rare class is not drowned (subsection 3).
counts = torch.bincount(ytr_t, minlength=K).float()
w = (counts.sum() / (K * counts)).to(dev)
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
lossf = nn.CrossEntropyLoss(weight=w)

for epoch in range(40):
    model.train(); opt.zero_grad()
    loss = lossf(model(Xtr_t), ytr_t)
    loss.backward(); opt.step()

model.eval()
with torch.no_grad():
    pred = model(Xte_t).argmax(1)
acc = (pred == yte_t).float().mean().item()
print("from-scratch CNN-LSTM cross-subject accuracy = %.3f" % acc)

from-scratch CNN-LSTM cross-subject accuracy = 0.913

Now the library equivalent. The from-scratch pipeline above, model definition, the channels-first transpose, the manual training loop, and the evaluation, runs roughly 35 lines. The tsai library (built on fastai and PyTorch) collapses the entire model-build-train-evaluate cycle to three lines: it ships ready-made HAR architectures (InceptionTime, an LSTM-FCN, a Transformer) and a one-call learner. Code 32.4.3 trains a competitive HAR model in three lines.

from tsai.all import TSClassifier

# Rebuild the same cross-subject split as combined arrays + index tuple for tsai.
X = np.concatenate([Xtr, Xte]).transpose(0, 2, 1)   # (N, C, W) float32, channels-first
y = np.concatenate([ytr, yte])
splits = (list(range(len(Xtr))), list(range(len(Xtr), len(Xtr) + len(Xte))))
clf = TSClassifier(X, y, splits=splits, arch="InceptionTime", metrics="accuracy")
clf.fit_one_cycle(40, 1e-3)          # InceptionTime: a strong 1D-conv HAR backbone
print("tsai InceptionTime accuracy:", clf.recorder.values[-1])

Read the three code blocks together. Code 32.4.1 turned a raw stream into subject-split windows; Code 32.4.2 built and trained a CNN-LSTM by hand and reported an honest cross-subject 91 percent; Code 32.4.3 reproduced a competitive result in three lines with a production library. The from-scratch path teaches you what the model is doing and where the leakage hides; the library path is what you ship. Both report the cross-subject number, because in HAR the protocol, not the architecture, is what makes the number trustworthy.

7. Spatio-Temporal Foundation Models Advanced

Every ST model in this section so far has been trained from scratch for a specific city, a specific sensing modality, and a specific task (traffic speed prediction, demand forecasting, air-quality interpolation). That is the standard paradigm, and for a city with abundant labeled data it works well. But it fails when data is scarce, when a new city needs predictions before it has accumulated years of sensor logs, or when the same infrastructure must serve multiple tasks simultaneously. The paradigm shift of spatio-temporal foundation models is the same one that reshaped NLP a decade ago: instead of training a separate specialist per task and per city, pretrain a single large model on diverse urban spatio-temporal data from many cities and many domains, then deploy it zero-shot or adapt it with minimal fine-tuning. Two 2025 systems, UrbanDiT and UrbanFM, demonstrate that this transfer actually works at scale.

7.1 The Three Tasks in One Model

Classical ST-GNNs, including the STGCN and DCRNN architectures of this section, are built for one task: given a sequence of observed states $\mathbf{X}_{1:T}$, predict the future states $\mathbf{X}_{T+1:T+H}$. But urban operators routinely need all three of the following simultaneously: prediction (forecast future states from a complete past window), interpolation (fill spatial gaps where sensors are missing at a given time step), and imputation (fill temporal gaps where a sensor was offline for a contiguous block of time). These differ only in which entries of the observation tensor are known and which must be inferred.

UrbanDiT unifies all three via a masked-diffusion formulation. Define the full ST tensor $\mathbf{X} \in \mathbb{R}^{T \times N}$ (times by nodes) and a binary mask $\mathbf{M} \in \{0,1\}^{T \times N}$ where $M_{t,n}=1$ indicates that entry $(t,n)$ is observed. The model learns to denoise $\mathbf{X}$ starting from Gaussian noise while conditioning on $\mathbf{M} \odot \mathbf{X}$ (the observed entries). By choosing different masks at inference time, the same model performs prediction (mask the future rows), interpolation (mask selected nodes at the current time), or imputation (mask a contiguous block of time steps for certain nodes). No task-specific heads are needed; the task type is entirely encoded in the mask pattern.

7.2 UrbanDiT Architecture

The UrbanDiT architecture follows three stages. First, the ST grid is divided into non-overlapping patches across both space and time, each patch tokenized into a $d$-dimensional embedding that captures local ST structure. Second, these ST tokens are passed through a Diffusion Transformer (DiT) backbone: a stack of Transformer blocks with adaptive layer normalization that is conditioned on the diffusion timestep $t$ and the observation mask $\mathbf{M}$. This conditioning allows the network to distinguish diffusion noise to be removed from structural missingness to be filled. Third, the denoised token sequence is projected back to the original ST resolution, yielding the completed or predicted tensor. Formally, the model learns a score function $s_\theta(\mathbf{X}^{(\tau)}, \tau, \mathbf{M} \odot \mathbf{X}_0)$ where $\mathbf{X}^{(\tau)}$ is the noisy tensor at diffusion step $\tau$ and $\mathbf{X}_0$ is the ground truth; standard DDPM or DDIM sampling then produces clean predictions.

7.3 Zero-Shot Cross-City Transfer

UrbanDiT is pretrained on diverse urban datasets: New York taxi demand, Chicago traffic speed, Beijing air quality, and crowd flow from multiple Asian and North American cities, spanning four sensing modalities and five cities. At inference time it is evaluated on cities and domains not seen during training. The cross-city zero-shot result is striking: UrbanDiT trained on New York traffic data achieves 78% of the performance of a model trained specifically on Chicago traffic data, without any fine-tuning on Chicago. This figure, 78% of supervised performance at zero additional labeled data, is the threshold that makes foundation models practically relevant for new city deployments.

UrbanFM extends this finding at scale. Treating urban ST data from 50 cities as a pretraining corpus and training models from 50M to 1B parameters, UrbanFM demonstrates that the held-out generalization error on 22 test cities decreases monotonically with both model size and data diversity, following a scaling curve close to $\text{error} \propto (\text{parameters})^{-0.07}$ across two orders of magnitude in scale. The 1B-parameter model outperforms city-specific ST-GNNs on 20 of 22 test cities, with the two exceptions being cities with abundant local labeled data (more than five years of dense sensor logs) where the specialized model still wins.

7.4 Foundation Models vs Task-Specific ST-GNNs: When to Use Each

The comparison between urban ST foundation models and the task-specific ST-GNNs of this section is not a straightforward victory for either side; it is data-regime-dependent.

The practical decision rule is: use a foundation model as the default starting point for any new city or modality with fewer than one to two years of dense sensor history, and consider switching to a city-specific model only if you have that history and the accuracy gain justifies the maintenance cost of a second model family.

7.5 Code: UrbanDiT Inference Loop

The following sketch demonstrates loading a pretrained UrbanDiT checkpoint, specifying a prediction mask, and running the DDIM inference loop to produce a traffic forecast.

import torch
import numpy as np

# UrbanDiT: load pretrained checkpoint and run prediction inference
# Assumes checkpoint is available at the given path; adapt to actual API.

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Load pretrained UrbanDiT model (hypothetical checkpoint path)
checkpoint = torch.load("urbandit_pretrained.pt", map_location=device)
model = checkpoint["model"].to(device).eval()

# ST tensor: shape (T, N) — T time steps, N spatial nodes
# observed_data is the known history window; future steps to predict
T_hist, T_pred, N = 12, 6, 200
observed = torch.randn(T_hist, N, device=device)  # replace with real data

# Build observation mask: 1 = observed, 0 = to be inferred
# Prediction task: mask out the future T_pred steps
mask = torch.zeros(T_hist + T_pred, N, device=device)
mask[:T_hist] = 1.0

# Concatenate observed history with zero-filled future slots
x_cond = torch.cat([
    observed,
    torch.zeros(T_pred, N, device=device)
], dim=0)  # shape: (T_hist + T_pred, N)

# DDIM sampling loop (simplified; actual UrbanDiT uses 50-1000 steps)
num_steps = 50
x_noisy = torch.randn_like(x_cond)  # start from pure noise

with torch.no_grad():
    for step in reversed(range(num_steps)):
        t_tensor = torch.tensor([step], device=device)
        # Score network predicts noise; conditioning = mask * x_cond
        score = model(x_noisy, t_tensor, mask * x_cond)
        # Simplified DDIM update (replace with actual noise schedule)
        alpha = 1.0 - step / num_steps
        x_noisy = (x_noisy - (1 - alpha) ** 0.5 * score) / alpha ** 0.5

# Extract predicted future states
x_pred = x_noisy[T_hist:, :]  # shape: (T_pred, N)
print(f"Predicted traffic speeds: shape {x_pred.shape}, "
      f"mean {x_pred.mean().item():.3f}")

# For interpolation task: mask individual nodes at a fixed time step
# mask_interp[t_gap, missing_nodes] = 0, everything else = 1
# For imputation task: mask a contiguous temporal block for all nodes
# mask_impute[t_start:t_end, :] = 0, everything else = 1

The urban ST foundation model paradigm closes the loop that this chapter opened. Chapter 32 began with the observation that spatial topology matters and cannot be discarded: ST-GNNs were the answer for the data-rich regime. Foundation models are the answer for the data-scarce regime, and they do not make ST-GNNs obsolete; they extend the reach of ST intelligence to the settings where labeled data is unavailable or too expensive to collect. The next chapter returns to the question of trust: given a deployed temporal model, whether a specialized ST-GNN or a fine-tuned urban foundation model, how do we understand what it is doing and verify that it is robust?

6. Exercises

Three exercises, one conceptual, one implementation, one open-ended, to consolidate the section.

1. Conceptual. A colleague reports 98 percent accuracy on a 5-class HAR task using a random 80/20 window split with 50 percent overlapping windows, and proposes shipping the model. Explain precisely two distinct reasons this 98 percent is likely to overstate field performance, naming the leakage mechanism that overlap plus random splitting introduces (Figure 32.4.1) and the evaluation protocol you would demand instead. Then describe what you expect to happen to the number under your protocol, and why.
2. Implementation. Starting from Code 32.4.1 and 32.4.2, add a deliberate 10-to-1 class imbalance by truncating the "stairs" activity to one tenth of its windows. Train the CNN-LSTM (a) with plain cross-entropy and (b) with the inverse-frequency class weighting already in the code, and report raw accuracy, per-class recall, and macro-F1 for both. Confirm numerically the subsection-three claim that raw accuracy hides the failure on the rare class while macro-F1 exposes it.
3. Open-ended. The research frontier (subsection four) argues that self-supervised pretraining on unlabeled IMU data beats supervised architecture search. Design (in prose, with the key equations) a self-supervised pretraining task for the six-channel windows of Code 32.4.1 that needs no activity labels, for example predicting which of several signal transformations was applied to a window, or reconstructing masked channels. State the pretext loss, explain why the learned representation should transfer to the four-class HAR task with fewer labels, and propose the experiment (label budgets, cross-subject split) that would test whether it does.