Learned inertial odometry (IONet-style)

"I stopped integrating the accelerometer and started predicting where a person like this, moving like this, tends to end up. My error stopped exploding. Nobody told me walking was so predictable."

A Data-Driven AI Agent

This section assumes the drift story of Section 24.4 and the ZUPT and pedestrian-dead-reckoning baselines of Section 24.5, which learned inertial odometry is designed to replace. The models are sequence regressors, so the recurrent and temporal-convolutional architectures of Chapter 14 are the toolbox. We rely on the raw signal characteristics from Chapter 23 and, for the fusion at the end, the Kalman machinery of Chapter 9.

From double integration to direct regression

The root cause of inertial drift is that position is the double integral of a biased, noisy signal, so any constant accelerometer bias \(b\) becomes a position error that grows as \(\tfrac{1}{2} b t^2\). No amount of clever filtering removes an error that the very structure of the estimator amplifies. IONet, introduced by Chen and colleagues in 2018, reframes the problem to break this chain. Rather than estimating instantaneous acceleration and integrating it twice, it treats a fixed window of inertial samples (say two seconds of accelerometer and gyroscope, 200 samples at 100 Hz) as one input and regresses the net displacement over that window as one output. Formally, a network \(f_\theta\) maps a window of six-axis IMU data \(\mathbf{X}_t \in \mathbb{R}^{W \times 6}\) to a planar displacement expressed as a polar vector,

where \(\Delta l_t\) is the distance travelled in the window and \(\Delta\psi_t\) is the change of heading. The full trajectory is then a simple sum of these short segments rather than a fragile chain of accelerations. Because the network sees a whole gait cycle at once, it can exploit the periodic acceleration signature to infer speed, the same information the Weinberg step-length model tries to capture with a single hand-picked exponent, but learned end to end and jointly with heading. IONet's original backbone is a two-layer bidirectional LSTM; later work shows temporal convolution and residual networks do at least as well.

Output parameterization and the heading-agnostic frame

The single most important design choice is the coordinate frame in which the displacement is expressed, and getting it wrong quietly destroys generalization. If you ask the network to output displacement in the device body frame, it must implicitly learn the device orientation, and it will overfit to the orientations seen in training. If you output in the global world frame, the target depends on an absolute heading the IMU cannot observe. RoNIN, from Herath and colleagues in 2020, resolves this with a heading-agnostic coordinate frame: the ground-truth velocity is rotated into a frame aligned with gravity but with a yaw fixed by the device's own tracked heading, so the network only ever predicts motion relative to where it currently believes it is pointing. The absolute heading is integrated separately from the gyroscope. This decoupling, learn the speed and the turn rate in a self-referential frame, integrate the global heading with classical attitude tracking, is what lets one model work across phone-in-hand, in-pocket, and in-bag placements. IONet's polar \((\Delta l, \Delta\psi)\) output is a compact special case of the same idea, since a distance and a relative heading change are already invariant to the absolute world orientation.

Predicting displacement with calibrated uncertainty, then fusing it

A raw displacement regressor is useful, but a displacement regressor that also reports how much to trust each prediction is what turns learned odometry into a full navigation system. TLIO's contribution is to output not just a displacement \(\mathbf{d}_t\) but a diagonal (or full) covariance \(\boldsymbol{\Sigma}_t\), trained by minimizing the Gaussian negative log-likelihood

so the network learns to widen its uncertainty exactly where it is unreliable, for instance during fast turns or unusual motion. That covariance is not a decoration: it becomes the measurement-noise matrix \(\mathbf{R}\) when the displacement is fed as a pseudo-measurement into an error-state EKF that also tracks orientation and IMU biases. This closes a satisfying loop with Section 24.5: the learned displacement plays the same structural role the zero-velocity update played, a data-driven pseudo-measurement that makes bias and drift observable, but without needing a foot mount or a stance threshold. Honest, calibrated variance is what lets the filter weight the network against other sensors correctly, and calibrating it is the subject of Chapter 18.

import torch, torch.nn as nn

class IONetLite(nn.Module):
    """Regress planar displacement (dx, dy) from a window of 6-axis IMU."""
    def __init__(self, in_ch=6, hidden=128, layers=2):
        super().__init__()
        self.lstm = nn.LSTM(in_ch, hidden, layers,
                            batch_first=True, bidirectional=True)
        self.head = nn.Linear(2 * hidden, 2)   # (dx, dy) in the heading-agnostic frame

    def forward(self, x):                       # x: (B, W, 6)
        out, _ = self.lstm(x)                   # (B, W, 2*hidden)
        return self.head(out[:, -1])            # use the last step's summary

def integrate(disps):
    """Sum per-window displacements into a trajectory. disps: (T, 2)."""
    return torch.cumsum(disps, dim=0)

model = IONetLite()
window = torch.randn(4, 200, 6)                 # 4 windows, 2 s at 100 Hz
print(model(window).shape)                      # torch.Size([4, 2])

The snippet shows the core: no hand-tuned threshold, no explicit integration of acceleration, just a window-to-displacement map plus a cumulative sum. Adding a second output head for \(\log\sigma^2\) and swapping the mean-squared-error loss for the likelihood above upgrades it to the TLIO-style uncertainty-aware form.

Training data, generalization, and leakage-safe evaluation

Learned inertial odometry is only as good as its ground truth and its splits. Training needs paired IMU-and-trajectory data, and the trajectory is supplied by a reference system the IMU never sees at inference: an optical motion-capture rig, a visual-inertial SLAM system, or a survey-grade setup. The target displacement per window is read off that reference. Two failure modes dominate. First, the network can memorize subject-specific and device-specific quirks; a model that reports low error when the same person's later walk appears in the test set is measuring memorization, not odometry. Subject-independent and device-independent splits are mandatory, exactly the leakage-safe discipline of Chapter 5. Second, because the model integrates its own gyroscope-derived heading, a slow yaw drift still curls long trajectories, so evaluation reports both a heading-sensitive metric (absolute trajectory error) and a heading-agnostic one (relative or position drift). Those metrics, and why you need more than one, are the subject of Section 24.7. Where an absolute heading or position reference is available, the learned track is fused with it rather than trusted alone, the fusion picked up in Chapter 25.

What's Next

In Section 24.7, we make the comparisons in this section rigorous: how to score a trajectory estimate faithfully, separating absolute from relative error, aligning estimated and reference paths, and reporting drift as a fraction of distance so a classical filter and a learned odometry model can be judged on the same, leakage-safe footing.