🛰️ CANTraj (formerly DriveDNA-GPS)

Trimmed GPS tracks for the DriveDNA drives, on the released 10 Hz time axis

3,988 drives, 468 drivers, 1,665 hours of trimmed GPS track. Every drive keeps the pseudonym it has in the DriveDNA release.

---

📌 TL;DR

• What: one CSV of GPS fixes per DriveDNA drive (driver_XXX/drive_YYY.csv), plus the openpilot localizer position (drive_YYY_kalman.csv) and raw GNSS position solutions (drive_YYY_gnss.csv) where the source logs carry them.
• Same numbering, same clock: driver_XXX/drive_YYY and time_s are identical to raw_signals/driver_XXX/drive_YYY.parquet in DriveDNA and DriveDNA-Controlled. A GPS row joins the released 10 Hz signals by time_s alone.
• Trimmed: the first and last two minutes of every drive are removed (120 <= time_s <= duration_s - 120). Drives shorter than four minutes have no file.
• No absolute time: no date, wall clock or receiver timestamp of a drive appears in any file (the benchmark's map tile lists carry only the OpenStreetMap snapshot dates). time_s counts from the start of the released drive; the DriveDNA index gives the month.
• Verified axis: for every drive the GPS time axis was anchored to the released table and checked against the released vehicle speed, segment by segment. manifest.csv carries the evidence (align_frac, align_cov, n_seg_*).
• Rates: u-blox receivers give 10 Hz where the full log was available and about 1 Hz otherwise; Qualcomm modem receivers give 1 Hz. The log column of every row says which log the row came from.
• CAN / IMU events: events/driver_XXX/drive_YYY/ holds the raw vehicle-bus and device-sensor messages of the same drives at their logged times (100 Hz where the full log exists), the causal input of the CANTraj-Bench trajectory benchmark. See the section below.
• CANTraj-Bench: benchmark/ fixes the trajectory-recovery task on these drives (the benchmark of the paper "CANTraj: Recovering Vehicle Trajectories from CAN Signals in Naturalistic Driving", ICDE 2027 submission under review, which calls the paired CAN and GNSS release CANTraj) (98,972 episodes, eight protocols, version 1.1, per-episode scores of every baseline and of six re-implemented published methods); code at https://github.com/WangYuHang-cmd/GPS--CAN.
• Access: gated, research use only, under the DriveDNA research license; approval is manual.

🎞️ Four views of the data

_{One road network, many drivers. The 147 drives of the 23 DriveDNA drivers in the San Francisco Bay Area are drawn one driver at a time, each in its own colour, over the grey network formed by all of their tracks. No basemap is used anywhere on this card: the roads are the tracks themselves.}

_{One drive at 10 Hz. The middle third of a drive replayed: the trail is coloured by GPS ground speed, the upper right panel overlays GPS speed_mps from this release with the CAN vEgo of the same drive from the DriveDNA release on the shared time_s axis, and the lower panel is the altitude profile.}

_{A day of driving. In the Atlanta area (109 drives by 12 drivers) the tracks active in each local hour light up in turn. The local hours were derived from private timestamps that are not part of the release.}

📦 What is released

kind	files	rows	size	rate	source
GPS fixes drive_YYY.csv	3,994	12,090,649 (11,914,137 pass fix_ok)	1.33 GB	10 Hz or about 1 Hz	gpsLocationExternal (u-blox) and gpsLocation (Qualcomm modem, phone GPS on the oldest hardware)
Localizer drive_YYY_kalman.csv	1,615	34,372,875 (33,594,099 pass pos_ok)	2.77 GB	20 Hz or 4 Hz	liveLocationKalman.positionGeodetic, logs of openpilot 0.9.7 and older
GNSS solutions drive_YYY_gnss.csv	192	3,304,542	364 MB	about 1 Hz	gnssMeasurements position and Kalman ECEF solutions, logs from 2022 to 2023
manifest.csv	1	4,177	1 MB		one row per DriveDNA drive, including the drives that have no file

5,801 CSV files, 4.46 GB in total, plus the event tables under events/ (24.0 GB of parquet) and the benchmark files under benchmark/ (0.85 GB). Of the 3,988 drives with a usable GPS track, 990 were logged by a u-blox receiver and 2,998 by a Qualcomm modem receiver; 432 tracks are at 10 Hz and 3,556 at about 1 Hz.

🚗 CAN / IMU event tables (events/)

Raw vehicle-bus and device-sensor messages at their logged times, re-decoded from the original openpilot logs of every drive that has a GPS track (3,988 drives). The released 10 Hz table of DriveDNA was built by linear interpolation from decimated logs, so a value at a grid time can depend on a message recorded later; these tables are the messages themselves, one row per message, on the same time_s axis (column t_s) and trimmed like the GPS files (120 <= t_s <= duration_s - 120). They are the online-protocol input of CANTraj-Bench, the trajectory recovery benchmark built on this release (code at GPS--CAN, manifests in benchmark/).

file	drives	rows	size	rate	source messages
events/driver_XXX/drive_YYY/carstate.parquet	3,988	302,704,603	7.9 GB	100 Hz where the full log exists (1,686 drives), 10 Hz where only the decimated log exists	carState
events/driver_XXX/drive_YYY/controls.parquet	3,985	605,337,096	6.2 GB	as carState	controlsState (curvature, enabled) and carControl (enabled, latActive, longActive)
events/driver_XXX/drive_YYY/imu.parquet	3,988	565,247,026	9.8 GB	about 100 Hz on full logs (1,957 drives), about 1 Hz on decimated logs	gyroscope and accelerometer (openpilot 0.9 and newer) or sensorEvents (older)
events/driver_XXX/drive_YYY/calib.parquet	3,988	14,074,221	0.17 GB	about 1 Hz	liveCalibration
events/driver_XXX/drive_YYY/carparams.json	3,988			once per drive	carParams: platform name and nominal vehicle parameters (no VIN)
events/events_manifest.csv	1	3,988			per-drive rates, counts, alignment checks, platform

Columns. carstate.parquet: t_s, vEgo, vEgoRaw, aEgo, vEgoCluster (m/s, m/s2), steeringAngleDeg (left turn positive), steeringRateDeg, yawRate (populated only by the Ford, Hyundai/Kia/Genesis and Volkswagen decoders; Ford and Volkswagen in rad/s, the Hyundai family in deg/s; left turn positive), ws_fl, ws_fr, ws_rl, ws_rr (wheel speeds, m/s, where decoded), gas, brake, gasPressed, brakePressed, steeringPressed, standstill, leftBlinker, rightBlinker, cruiseEnabled, cruiseAvailable, gearShifter, steeringTorque, canValid, seg, log. controls.parquet: t_s, topic, curvature (1/m, right turn positive; openpilot's vehicle model applied to the steering angle with online-estimated parameters, not a bus signal), enabled, active, latActive, longActive, seg, log. imu.parquet: t_s, sensor_ts, topic, kind (gyro or accel), which, source (lsm6ds3, lsm6ds3trc, bmx055, ...), sensor, v0, v1, v2 (raw sensor frame as logged; for the LSM6DS3 family the yaw axis is v0, left turn positive, rad/s), seg, log. calib.parquet: t_s, roll, pitch, yaw (rpyCalib, rad), calStatus, calPerc, validBlocks, seg, log. carparams.json: carFingerprint, carName, mass, wheelbase, centerToFront, steerRatio, steerRatioRear, rotationalInertia, tireStiffnessFactor, tireStiffnessFront, tireStiffnessRear, minSteerSpeed, minEnableSpeed, notCar, dashcamOnly, op_version.

Notes. The time axis of every drive was anchored to the released table and checked segment by segment against the released speed, exactly as for the GPS files (align_frac, align_cov in events_manifest.csv). Sign conventions were verified against the GPS course over ground. Rows inside a lost log segment are simply absent (no interpolation); a gap between consecutive messages longer than three nominal periods marks missing input. The native column of events_manifest.csv is true when every segment came from the full log. Drives whose car was not recognised by openpilot (carFingerprint = mock) have no usable vehicle parameters.

🧭 CANTraj-Bench (benchmark/), version 1.1

Can the GPS trajectory of a drive be reconstructed from the vehicle-bus signals alone, once a single start position is known? The benchmark/ folder holds everything that fixes this task on CANTraj, the benchmark the paper "CANTraj: Recovering Vehicle Trajectories from CAN Signals in Naturalistic Driving" calls CANTraj-Bench (its dataset name for the paired CAN and GNSS release is CANTraj); the code (package cantraj, baselines, re-implemented published methods, scoring, tables and figures) is at https://github.com/WangYuHang-cmd/GPS--CAN.

• Task: given the CAN events of a drive (and optionally the device IMU) and the position at one instant t0, predict the position at every later reference second. Eight protocols = {online, offline} x {no map, OpenStreetMap road graph} x {start heading given, start heading unknown}; windows of 1, 5 and 15 minutes and whole drives; signal groups from speed only (G1) and speed + steering angle (G3, the CAN-only main board) to full CAN + IMU (G8).
• Episodes: 98,972 eligible episodes from 3,675 drives and 431 drivers (manifests/episode_manifest_v1.parquet; anchor = a moving GPS fix with good course and accuracy; eligibility = at least 80% of seconds with a fix, no gap over 30 s, path over 100 m). Driver-disjoint folds train / val / test / few_shot_heldout (manifests/split_drives.parquet). Map protocols use only the episodes whose start has a drivable road within 400 m in the episode's map (map_ok in manifests/episode_map_v11.parquet): 14 of the 5,795 test and few-shot episodes of 5 and 15 minutes and whole drives (all in few_shot_heldout) fail this rule; they are left out of every map protocol and stay in the no-map protocols.
• Reference: the 1 Hz GPS view of this repository, with a per-receiver time compensation estimated on the training fold.
• Metrics: ADE (mean error over the reference seconds) and FDE; coverage, the share of seconds within 10, 25, 50, 100, 200 or 500 m of the reference; success S(50 m, 0.9), at least 90% of the seconds within 50 m; path recall, the share of the reference path within 50 m of the predicted path regardless of timing; route recovered, a path recall of at least 0.8; and two failure flags, tail_lost100 (the error stays above 100 m over the whole last fifth of the window) and terminal_lost100 (the error at the last reference second is above 100 m). A window without output counts as a failure (infinite ADE, route not recovered). scores/icde_v11/episodes_all.parquet has one row per window with output; scores/icde_v11/tables/main_board.csv lists, per method, the expected windows and the failures. Medians with driver-cluster bootstrap CIs; paired differences on common episodes.
• Methods: dead reckoning (nominal, calibrated, learned GRU and physics-residual models), a particle filter and an offline beam search on the road graph, and re-implementations of six published methods, each run under the protocol that matches its own assumptions and scored with the same metrics: MacroTracking, OPD-II, Elastic Pathing, CAN-Trace, Dewri et al. (2013) and SPy / RoCuMa. These are our implementations, not the authors' code. MacroTracking and OPD-II follow the algorithms of the authors' released code (the code where it differs from the paper) and were checked against it on the authors' sample data (one sample trace; 8 of the 59 sample logs), which checks the transcription, not that the papers' results carry over. Elastic Pathing, CAN-Trace, Dewri et al. and SPy follow the papers; their authors released no code or driving data. Every adaptation is documented in the code repository.
• Results (version 1.1; 5-minute windows, start position known; test / few_shot_heldout, 1,917 / 1,963 windows, 1,917 / 1,959 in the map protocols, CAN-Trace only on the 245 / 162 windows with a continuous accelerator-pedal signal; a window without output counts as an infinite error; * = re-implemented published method):

method	signals	map	start heading	median ADE, m	route recovered, %	windows without output
beam search (offline)	speed + steering	yes	given	37 / 21	88 / 92	0 / 0
beam search (offline)	speed + steering	yes	unknown	41 / 23	81 / 87	0 / 0
particle filter (online)	speed + steering	yes	given	43 / 27	87 / 90	0 / 0
particle filter (online)	speed + steering	yes	unknown	138 / 88	79 / 82	0 / 0
OPD-II* (online, 3 s delay)	speed + steering	yes	given	42 / 24	79 / 78	0 / 0
MacroTracking* (online)	speed + steering	yes	given	84 / 52	62 / 65	0 / 0
SPy* (offline)	steering	yes	given	1,474 / 1,284	20 / 22	5 / 4
SPy* (offline)	steering	yes	unknown	2,198 / 1,810	11 / 13	2 / 2
Elastic Pathing* (offline)	speed	yes	given	87 / 80	58 / 59	89 / 78
Elastic Pathing* (offline)	speed	yes	unknown	129 / 177	53 / 50	62 / 41
Dewri et al.* (offline)	speed	yes	given	81 / 89	62 / 59	18 / 54
Dewri et al.* (offline)	speed	yes	unknown	293 / 487	46 / 43	8 / 26
CAN-Trace* (offline)	speed + accelerator pedal	yes	unknown	∞ / ∞	0 / 0	243 of 245 / 157 of 162
straight line (online)	speed	no	given	735 / 825	9 / 7	0 / 0
dead reckoning (online)	speed + steering	no	given	921 / 1,669	4 / 2	0 / 0
learned GRU, 3 seeds (online)	speed + steering	no	given	543 / 393	7 / 5	0 / 0

With the start heading given, the offline beam search and the online particle filter stay within tens of metres (median) over five minutes; without a map the CAN-only methods are hundreds of metres off. SPy and CAN-Trace search an area rather than start from a known position in their papers; the table gives them the start, and their 5 km area variants, which do worse, are in the main board. On 15-minute windows the beam search's median ADE is 149 / 106 m; over whole drives the filter and the beam search (start heading given) stay more than 100 m from the reference over the whole last fifth of 48 to 82% of the drives. Every method and window class with CIs and failure counts: scores/icde_v11/tables/main_board.csv.

• Versions: version 1.1 (2026-10-28) changes the maps and the failure accounting. All 5,111 tiles that the validation and evaluation folds use were rebuilt: 4,878 re-cut from every intersecting OpenStreetMap extract (149 of them had been cut incompletely at the margins of early tiling passes in v1) and 233 open-sea or unmapped land tiles left empty; manifests/map_tiles_v2.csv lists each tile with its source extract(s) and, for extract tiles, the extract md5 and snapshot date (2026-10-22 to 2026-10-24). New are the map_ok start rule, a map limited to each episode's own disc (5 km + 40 m/s x window length around the start, at most 60 km) with road bearings in the episode's local frame, the fix of a v1 timing error in feeding the learned motion models inside the filter (each message now arrives at its logged time), the two failure flags above (tail_lost100 is v1's lost_road, terminal_lost100 is new), and a window without output counts as a failure (v1 scored only windows with output). Episodes, folds, reference and thresholds are identical to v1, and so are the no-map predictions and their scores (no no-map method has a window without output). The v1 test results were known when these changes were made; every test run since is logged with its reason in reports/run_registry.csv. The v1 scores stay in scores/full_v1/ as history; their map rows should not be used (incomplete tiles, and starts without a road nearby fell back to an arbitrary edge). Version 1.1 reruns the map methods on the test and few-shot folds for 5- and 15-minute windows and whole drives; the other v1 map rows (1-minute windows, the validation fold, the calibrated, IMU and start-perturbation variants) have no version 1.1 counterpart.
• Also in benchmark/: scores/icde_*/ with the per-episode scores and tables of every run of the paper (cohort, cost, signal and agent studies), agent/ with the frozen and the extended configuration of the LLM-agent study (prompts, tool schema, budgets, selector weights, per-window conversation logs), and reports/ with the method-reproduction notes, the run registry with the reason of every run, the claims-to-evidence table and the paper's supplementary material (reports/supplementary.pdf).
• Why gated: manifests/episode_p0.parquet holds the episode start coordinates, which with the start heading (the GPS course at t0, given only in the heading-known protocols) are the only GPS information a method receives, and every manifest references drives by their DriveDNA pseudonyms. No raw log path, device or route identifier appears in any file (checked at staging; benchmark/CHECKSUMS.sha256 lists every file).
• Reproduce: clone the code, point CANTRAJ_GPS at this repository, CANTRAJ_MANIFESTS at benchmark/manifests and CANTRAJ_BENCH at a cache with the events/ tables, then follow the version 1.1 steps in the README of the code repository. Map-protocol numbers reproduce exactly only with the same road tiles: tiles re-cut from current OpenStreetMap extracts differ slightly from the 2026-10-22 to 2026-10-24 snapshots (the md5 column of map_tiles_v2.csv shows whether an extract matches). reports/run_registry.csv records the source, scorer and map version of every version 1.1 run; the no-map runs reused from v1 are marked as such. Prediction files (about 20 GB of per-second positions) are not in this repository.

🔗 Relation to DriveDNA and DriveDNA-Controlled

• driver_001 to driver_460 are the DriveDNA corpus (4,121 drives). driver_461 to driver_474 are the 56 drives of DriveDNA-Controlled (14 participants, one Honda Civic, the same road network).
• The pseudonyms are the same in all three repositories. There is no other link between them and no identifier of the vehicle, the route or the person in any file.
• time_s is the axis of the released 10 Hz table of the same drive: 0.0 is its first row and duration_s in the manifest is its last time_s. GPS rows carry time_s with millisecond resolution, so join with merge_asof (tolerance 0.05 s) or round to the 10 Hz grid.
• Drives without a file: shorter than 240 s (too_short, 103 drives), logs without any GPS message (no_gps_msgs), receivers that never obtained a fix (no_valid_fix; a file with only fix_ok = 0 rows is still written when any non-zero coordinate falls inside the window), fixes only inside the trimmed minutes (no_fix_in_window), and 4 drives whose time axis could not be verified (align_failed). The manifest lists every drive with its status.

📁 Layout

CANTraj/
├── README.md
├── manifest.csv                  one row per DriveDNA drive
├── benchmark/                    CANTraj-Bench: manifests/, config/, agent/, reports/, scores/icde_*/ (version 1.1 and the paper's studies), scores/full_v1/ (v1, history), CHECKSUMS.sha256
├── events/
│   ├── events_manifest.csv       one row per drive with event tables
│   └── driver_XXX/drive_YYY/     carstate.parquet, controls.parquet, imu.parquet, calib.parquet, carparams.json
├── driver_001/
│   ├── drive_001.csv             GPS fixes
│   ├── drive_001_kalman.csv      localizer position, when the logs carry it
│   ├── drive_001_gnss.csv        raw GNSS position solutions, when the logs carry them
│   └── ...
├── driver_002/
└── ...  driver_474/

🧾 Column reference

drive_YYY.csv (GPS fixes)

One row per GPS message. Rows with (0, 0) coordinates were dropped; every other message is kept, so filter on fix_ok == 1 (or your own rule) before use. Numbers are rounded: time_s to 3 decimals, coordinates to 7 decimals (about 1 cm), metres to 2 decimals, speeds to 3 decimals.

column	meaning
time_s	seconds on the released drive axis
msg	gpsLocationExternal: position from the external u-blox receiver. gpsLocation: position from the internal receiver (Qualcomm modem GNSS, or the phone GPS of the oldest hardware)
source	receiver as logged: ublox, qcomdiag, android (rare)
log	rlog (full log; u-blox at 10 Hz) or qlog (decimated log; about 1 Hz) the row was read from. A drive can switch between the two from one minute to the next
seg	one-minute segment index of the drive's log, as counted by openpilot. The released time_s does not necessarily start at segment 0
latitude, longitude	WGS-84 degrees
altitude_m	height above the WGS-84 ellipsoid in metres, not above sea level; values around 0 or below near the coast are normal
speed_mps	ground speed from the receiver, m/s (Doppler based, independent of the CAN speed)
bearing_deg	course over ground, degrees clockwise from true north, 0 to 360; meaningless when stationary
h_acc_m	estimated horizontal position accuracy, metres (u-blox typically 1 to 3 m; qcomdiag always 0, the modem does not report it)
v_acc_m	u-blox: estimated vertical accuracy, metres. qcomdiag: a vertical dilution value from the modem, typically 1 to 2, exactly 500 when there is no fix
speed_acc_mps	estimated speed accuracy, m/s
bearing_acc_deg	estimated course accuracy, degrees; tens of degrees when stationary or slow
flags	receiver flags as logged. For u-blox this is the NAV-PVT flags byte (bit 0 = fix OK); for qcomdiag it is 0 or 1 and does not indicate validity
has_fix	the hasFix field as logged. It is False in every log from openpilot 0.9.7 and older even for good fixes, so do not filter on it alone
fix_ok	1 if the row passes the per-source validity rule below; the recommended filter

drive_YYY_kalman.csv (openpilot localizer, older logs only)

column	meaning
time_s, log, seg	as above
latitude, longitude, altitude_m	liveLocationKalman.positionGeodetic (WGS-84, ellipsoid height)
std_x, std_y, std_z	reported standard deviation of the position estimate, metres
vel_n, vel_e, vel_d	velocity in the north, east, down frame, m/s
status	localizer status string (valid, uninitialized, ...)
gps_ok, pos_valid	the gpsOK flag and the positionGeodetic.valid flag
pos_ok	1 if gps_ok and pos_valid and status == "valid"; the recommended filter

drive_YYY_gnss.csv (raw GNSS position solutions, logs from 2022 to 2023)

column	meaning
time_s, log, seg	as above
kind	position: single-epoch position solution. kalman: the GNSS daemon's own filtered solution
x, y, z	ECEF coordinates, metres
std_x, std_y, std_z	reported standard deviation, metres
valid	the solution's valid flag
latitude, longitude, altitude_m	the same point converted to WGS-84 (ellipsoid height)

manifest.csv

column	meaning
set, driver, drive	main or controlled; pseudonyms
status, reason	ok, too_short, no_gps_msgs, no_valid_fix, no_fix_in_window or align_failed, with a short reason
duration_s, trim_lo_s, trim_hi_s	length of the released table and the kept window
op_version	openpilot version of the logs (numeric part)
n_seg_read, n_seg_rlog, n_seg_qlog, log_policy	one-minute segments read, by log type; qlog_fallback = the whole drive was read from decimated logs
k_anchor, align_method, align_frac, align_cov, align_lag_s, anchor_frac	time-axis verification, see below
n_seg_hole, n_seg_qlog_retry, n_seg_bad, n_seg_misnamed, n_seg_moving_ok, seg_frac_min, n_pos_jumps	per-segment verification, see below
gps_file, gps_rows, gps_rows_ok, gps_msgs, gps_sources, gps_rate_hz, first_ok_s, last_ok_s, max_gap_s	GPS file summary: rows, rows passing fix_ok, message types, receivers, median rate, first and last valid fix, largest gap between valid fixes
lat_med, lon_med	median position of the valid fixes
kalman_file, kalman_rows, kalman_rows_ok, gnss_file, gnss_rows	companion files

✅ Validity rule (fix_ok)

All sources: coordinates are not (0, 0) and within range. Then

• ublox: has_fix is set or flags & 1 == 1, and h_acc_m < 100000, and the receiver timestamp was after 2016 (the module emits stale positions and 2015 dates before its first fix);
• qcomdiag: has_fix is set or 0 < v_acc_m < 500 (the rule of openpilot's own GPS daemon);
• android and others: has_fix is set or 0 < h_acc_m < 100.

Known limitation: after a warm start a u-blox module may repeat its last stored position for a few seconds with the fix flag set. Those rows look valid; comparing speed_mps with the released vEgo exposes them.

⏱️ Time axis, trimming and verification

• Anchor. The released 10 Hz table of a drive starts at the first vehicle-state message of a chosen log segment. The same anchor was located in today's logs and verified by matching the vehicle speed decoded from the logs against the released vEgo: align_frac is the share of 10 Hz samples within 0.1 m/s, align_cov the share of the released span covered by the logs, align_method how the anchor was found (k_min: the decode-time first segment, 3,655 drives; k_min_alt: the first segment according to the decimated logs, 218; seg_scan: a scan over segment starts, 48). 67 drives in which the vehicle never moves, or whose released speed is constant, cannot be checked this way; they keep the decode's own anchor and carry _unverifiable in align_method.
• Segments. Every one-minute segment was checked on its own against the released speed. Segments whose file does not reproduce the released speed were re-read from the other log type (n_seg_qlog_retry, 906 segments) and dropped when that did not match either (n_seg_bad, 919 segments); 21 drives were read entirely from decimated logs. Files whose timestamps do not fit their segment index are detected the same way (n_seg_misnamed, 242 drives). Segments in which the released speed is linear or constant for most of the minute (n_seg_hole, 1,785 drives) cannot be checked there and are kept. seg_frac_min is the worst per-segment match among kept segments. n_pos_jumps counts pairs of consecutive valid fixes of one receiver, at most 10 s apart, that imply more than 100 m/s: 122 files have a non-zero count, nearly all from near-simultaneous 10 Hz messages a few metres apart; kilometre-scale jumps occur in two Qualcomm tracks whose gps_rate_hz is far below 1.
• Trimming. Rows are kept when 120 <= time_s <= duration_s - 120. The trim is relative to the drive, not to the first or last fix; first_ok_s and last_ok_s in the manifest show where the valid track starts and ends inside the window.
• Coverage below 1. 15 drives have align_cov < 0.9: part of the released span is not covered by the log files available today, so their track has a gap or ends early.

📊 Coverage

set	ok	too_short	no_gps_msgs	no_valid_fix	no_fix_in_window	align_failed	total
main	3,940	96	58	11	12	4	4,121
controlled	48	7	1	0	0	0	56
all	3,988	103	59	11	12	4	4,177

⚠️ Known limitations

• Sampling rate changes inside a drive wherever the full log was available for some minutes only (log column); resample before computing accelerations or headings from positions.
• u-blox warm-start repeats (see above) and multipath in dense urban areas are present as logged; h_acc_m and speed_acc_mps help to weight them.
• Qualcomm modem rows have no horizontal accuracy and no satellite count.
• The localizer file exists only for logs of openpilot 0.9.7 and older, the GNSS file only for logs from 2022 to 2023.
• Altitude is ellipsoidal; subtract the local geoid undulation to obtain height above sea level.

🚀 Quick start

pip install -U huggingface_hub pandas pyarrow
hf download HenryYHW/CANTraj --repo-type dataset --local-dir CANTraj      # everything, 29.4 GB
hf download HenryYHW/CANTraj manifest.csv "driver_*/*" --repo-type dataset --local-dir CANTraj   # CSV files only (GPS, localizer, GNSS, manifest), 4.46 GB

from huggingface_hub import hf_hub_download
import pandas as pd

REPO = "HenryYHW/CANTraj"
gps = pd.read_csv(hf_hub_download(REPO, "driver_002/drive_001.csv", repo_type="dataset"))
gps = gps[gps["fix_ok"] == 1]

# join with the released 10 Hz signals of the same drive (DriveDNA, same pseudonyms, same time_s)
sig = pd.read_parquet(hf_hub_download("HenryYHW/DriveDNA", "raw_signals/driver_002/drive_001.parquet",
                                      repo_type="dataset"))
joined = pd.merge_asof(gps.sort_values("time_s"), sig.sort_values("time_s"),
                       on="time_s", direction="nearest", tolerance=0.05)
print(joined[["time_s", "latitude", "longitude", "speed_mps", "vEgo"]].head())

# raw CAN events of the same drive (one row per carState message, logged time t_s on the same axis)
cs = pd.read_parquet(hf_hub_download(REPO, "events/driver_002/drive_001/carstate.parquet", repo_type="dataset"))
print(cs[["t_s", "vEgo", "steeringAngleDeg", "seg", "log"]].head())

With 🤗 datasets: load_dataset("HenryYHW/CANTraj", "gps") (configs gps, kalman, gnss, manifest, events_carstate, events_controls, events_imu, events_calib, events_manifest, benchmark_episodes, benchmark_scores (v1; its map rows should not be used), benchmark_scores_v11 (version 1.1), benchmark_map_episodes).

🔒 Privacy

• Drivers and drives appear only as the sequential pseudonyms of DriveDNA; the private mapping is held by the authors. No vehicle, hardware, route or account identifier is in any file.
• The first and last two minutes of every drive are removed, so the origin and the destination of a trip are not in the data.
• No absolute time of a drive is released: no date, wall clock or receiver timestamp. The DriveDNA index gives the month of each drive.
• Coordinates inside the kept window are exact, which route-level analysis and map matching need. For that reason the repository is gated and research use only.
• Prohibited: re-identification of drivers; inference of home, work or other personal locations; insurance, employment or law-enforcement scoring of individuals.
• The event tables carry the same pseudonyms, the same two-minute trimming and no absolute time; carparams.json holds platform-level nominal values only (no VIN).
• A takedown contact (below) allows any driver to request removal from future versions.

📜 License

Released under the DriveDNA research license; the terms are those of the main repository, HenryYHW/DriveDNA.

📖 Citation

@article{drivedna2026,
  title   = {DriveDNA: A Large-Scale Multimodal Naturalistic Driving Dataset and
             Benchmark for Driving Style Identification},
  author  = {Wang, Yuhang and Li, Lingyao and Zhou, Hao},
  journal = {arXiv preprint arXiv:2607.23822},
  year    = {2026}
}

Please cite the DriveDNA paper and refer to this release as CANTraj (formerly DriveDNA-GPS; the old repository name redirects); when you use benchmark/, also cite the CANTraj paper ("CANTraj: Recovering Vehicle Trajectories from CAN Signals in Naturalistic Driving", under review).

🔗 Links

• 📄 Paper: arXiv:2607.23822 · 🤗 Papers page
• 💻 Code & harness: github.com/WangYuHang-cmd/DriveDNA
• 📦 Data: DriveDNA · DriveDNA-Sample · DriveDNA-Controlled · 🧠 DriveDNA-models
• ✉️ Contact: haozhou1@usf.edu

---

_{DriveDNA · University of South Florida & University of Arizona · 2026 · card generated 2026-10-18, updated 2026-11-05}