Datasets:
The dataset viewer is not available for this split.
Error code: TooManyColumnsError
Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.
GoldenCheetah OpenData
Anonymised training data shared by users of the GoldenCheetah desktop application between 2018 and 2020: 6,613 athletes, 2,613,157 activities, ~13.3 billion samples (mostly one per second) of power, heart rate, cadence, speed/distance and altitude.
This is a Parquet conversion of the original release on the Open Science Framework, osf.io/6hfpz (DOI 10.17605/OSF.IO/6HFPZ). No records were removed and no information was lost: every value in the original CSV and JSON files can be recovered exactly (see Exactness below).
Subsets
| subset | rows | one row per | what |
|---|---|---|---|
activities (default) |
2,613,157 | activity | sport, start time, data-availability flags and 849 GoldenCheetah metrics (TSS, NP, CP estimates, zones, mean-max power curve, ...) |
athletes |
6,613 | athlete | gender, year of birth, counts, provenance (OSF file id + sha256 of the source zip) |
timeseries |
~13.3 billion | sample | time_s, distance_m, power_w, hr_bpm, cadence_rpm, altitude_m as recorded, mostly 1 Hz; sorted by athlete |
raw_json |
6,613 | athlete | the original per-athlete JSON file, verbatim |
timeseries_exceptions |
tiny | value | the few source values outside the Float32 range (see below) |
Join keys: athlete_id (UUID, identical to the OSF zip name) and activity_id
(the original CSV name without .csv, i.e. the local start time YYYY_MM_DD_HH_MM_SS;
activities without a CSV use their UTC start time followed by Z). Other GoldenCheetah
datasets on Hugging Face use the same keys, so they join directly to activities and timeseries here.
Usage
import polars as pl # pip install "polars[rt64]": the time series has more rows than standard polars allows
ts = pl.scan_parquet("hf://datasets/GoldenCheetah/opendata-test/data/timeseries/*.parquet")
# one athlete, or one activity: reads only the row groups that hold it (seconds)
athlete = ts.filter(pl.col("athlete_id") == "331c44ce-1710-4806-b3bb-be5e90dad9d3").collect()
ride = ts.filter((pl.col("athlete_id") == "331c44ce-1710-4806-b3bb-be5e90dad9d3")
& (pl.col("activity_id") == "2020_05_02_08_09_21")).collect()
acts = pl.read_parquet("hf://datasets/GoldenCheetah/opendata-test/data/activities/*.parquet",
columns=["athlete_id", "activity_id", "sport", "start_time_utc", "coggan_tss"])
-- DuckDB
SELECT sport, count(*) FROM 'hf://datasets/GoldenCheetah/opendata-test/data/activities/*.parquet' GROUP BY ALL;
SELECT * FROM 'hf://datasets/GoldenCheetah/opendata-test/data/timeseries/*.parquet'
WHERE athlete_id = '331c44ce-1710-4806-b3bb-be5e90dad9d3';
from datasets import load_dataset
ds = load_dataset("GoldenCheetah/opendata-test", "timeseries", streaming=True)
Whole-table analyses of the time series: download it first (47.0 GB). Reading
all of it over HTTP takes one request per row group and column, and the Hub limits requests
per IP (fewer when not logged in), so such queries get cut off. Locally, the same code runs on
data/timeseries/*.parquet:
hf download GoldenCheetah/opendata-test --repo-type dataset --include "data/timeseries/*" --local-dir opendata
Notes
timeseries: time_s (seconds since start, the CSV secs; fractional for a few
sub-second devices), distance_m (cumulative distance in metres; the CSV km × 1000),
power_w (CSV power), hr_bpm (CSV hr), cadence_rpm (CSV cad), altitude_m (CSV alt).
Column names carry their unit and are shared across the GoldenCheetah datasets on Hugging Face.
Files timeseries/part-00000.parquet, ... of about 500 MB, sorted by athlete_id; each athlete
is in one file. Missing sensor = null. Rows are as recorded:
gaps (auto-pause, smart recording) are not filled. Rows of one activity are contiguous and
in recorded order, which is not always time_s order: time_s repeats now and then, and in a
very few broken recordings it jumps backwards while distance shows the rows are in order.
Exactness. GoldenCheetah exported every number with 6 significant digits. Float32 holds any
6-significant-digit decimal exactly, so the columns are Float32 and nothing is rounded:
formatting a value with %.6g gives back the number in the original CSV (for distance_m:
the original km with the decimal point moved). Casting to Float64 shows binary noise in the
8th digit (72.5636 → 72.56359863); round to 6 significant digits if you need the exact
decimal. The handful of source values that lie outside the Float32 range (sub-normal junk such
as 4.94066e-324, written as 0 here) are listed with their exact Float64 value in
timeseries_exceptions (athlete_id, activity_id, row_in_activity, column, source_value).
activities: start_time_utc comes from the JSON; utc_offset_minutes is derived by
matching it to the local-time CSV name. sport is free text as entered in GoldenCheetah
(Bike, bike, Rennrad, VirtualRide, empty, ...). data_flags is GoldenCheetah's
15-character availability string (Time, Distance, Speed, Power, Heart rate,
Cadence, ...). Metric values given by GoldenCheetah as [value, weight] pairs are split into
<metric> and <metric>__weight; array metrics (power_mmp, *_dist, *_dist_bins) are
lists. has_timeseries is false for activities without samples (manual entries, days off, ...).
An athlete's library sometimes held two versions of one activity (a file imported twice, say).
Both are kept: two rows with the same start_time_utc, of which the one whose CSV is not in the
release has a Z id and no samples; where both CSVs are in the release, the second is
<activity_id>~2. A few athletes' JSON needed repairs to be read (athletes.json_repairs);
raw_json has every JSON as it was released.
Data dictionary
activities
One row per activity: start time, sport, data flags and GoldenCheetah's metrics.
key (athlete_id, activity_id); data/activities/*.parquet
| column | type | unit | description |
|---|---|---|---|
athlete_id ¹ |
string |
Anonymous athlete id (UUID) from the GoldenCheetah OpenData release; the name of the athlete's zip on OSF. Identical across datasets. | |
activity_id ¹ |
string |
Activity id, unique within an athlete: the local start time YYYY_MM_DD_HH_MM_SS from the original CSV name, in a few cases followed by the original file's extension (.fit, .pwx, .csv.bak, ...). Activities without a CSV use their UTC start time followed by Z. Where two activities would get the same id (two versions of one activity in the release), the second gets ~2. Identical across datasets. |
|
start_time_utc ¹ |
timestamp[us, tz=UTC] |
Start time of the activity, UTC. | |
utc_offset_minutes ¹ |
int16 |
min | Local time minus UTC at the start of the activity. Null when unknown. |
sport ¹ |
string |
Sport as entered in GoldenCheetah: free text (Bike, bike, Rennrad, Run, ...). |
|
data_flags |
string |
GoldenCheetah's 15-character data availability string (Time, Distance, Speed, Power, Heart rate, Cadence, ...). |
|
xdata |
string |
GoldenCheetah's XDATA entry (extra data series) as a JSON string, or null. | |
has_timeseries |
bool |
Whether timeseries has samples for this activity. False for manual entries and other activities without a CSV. Never null. |
|
| other columns | float64, list<float64> |
GoldenCheetah metrics, one column per metric, names as GoldenCheetah writes them (quote them in SQL: "10m_critical_power"). Metrics given as [value, weight] pairs are split into <metric> and <metric>__weight; array metrics (power_mmp, *_dist, *_dist_bins, ...) are lists. |
athletes
One row per athlete (one per OSF zip), including athletes without activities.
key (athlete_id); data/athletes/*.parquet
| column | type | unit | description |
|---|---|---|---|
athlete_id ¹ |
string |
Anonymous athlete id (UUID) from the GoldenCheetah OpenData release; the name of the athlete's zip on OSF. Identical across datasets. | |
gender ¹ |
string |
Gender as entered in GoldenCheetah (M, F), or null. |
|
yob ¹ |
int64 |
Year of birth as entered in GoldenCheetah. Not validated; implausible values occur. | |
json_athlete_id |
string |
Athlete id inside the athlete's JSON. Differs from athlete_id in rare re-uploads, which makes such duplicates visible. |
|
gc_json_version |
string |
Version of GoldenCheetah's OpenData JSON format (1.8, 1.9, 2.0). |
|
json_repairs |
list<string> |
Repairs the athlete's JSON needed to be read, for GoldenCheetah export bugs; usually none. unescaped_quotes: double quotes in free text not escaped. empty_first_metric: a stray comma at the start of a ride's metrics. control_characters: tabs or line breaks in free text not escaped. raw_json has the original text. Never null. |
|
n_activities |
int64 |
Number of rows in activities for this athlete. Never null. |
|
n_timeseries |
int64 |
Number of activities with a time series. Never null. | |
osf_file_id |
string |
OSF file id of the source zip. Never null. | |
osf_sha256 |
string |
SHA-256 of the source zip on OSF: provenance back to the exact file. Never null. | |
osf_size_bytes |
int64 |
bytes | Size of the source zip. Never null. |
osf_date_created |
timestamp[us, tz=UTC] |
When the source zip was uploaded to OSF. |
timeseries
One row per sample, as recorded: mostly 1 Hz, gaps not filled. Exact: every value equals the original CSV value (see the card).
no key; data/timeseries/*.parquet, sorted by athlete_id, each athlete_id in one file
| column | type | unit | description |
|---|---|---|---|
athlete_id ¹ |
string |
Anonymous athlete id (UUID) from the GoldenCheetah OpenData release; the name of the athlete's zip on OSF. Identical across datasets. Never null. | |
activity_id ¹ |
string |
Activity id, unique within an athlete: the local start time YYYY_MM_DD_HH_MM_SS from the original CSV name, in a few cases followed by the original file's extension (.fit, .pwx, .csv.bak, ...). Activities without a CSV use their UTC start time followed by Z. Where two activities would get the same id (two versions of one activity in the release), the second gets ~2. Identical across datasets. Never null. |
|
time_s ¹ |
float32 |
s | Seconds since the start of the activity, as stored in this dataset. Fractional for devices that record at other intervals (e.g. 0.5 s, 1.26 s). A dataset that trims or resamples activities says so in its card; its time_s then need not match the raw data. |
distance_m ¹ |
float32 |
m | Cumulative distance since the start of the activity. |
power_w ¹ |
float32 |
W | Power. |
hr_bpm ¹ |
float32 |
bpm | Heart rate. |
cadence_rpm ¹ |
float32 |
rpm | Cadence (pedal or step revolutions per minute). |
altitude_m ¹ |
float32 |
m | Altitude. |
timeseries_exceptions
The few source values that Float32 cannot hold (sub-normal junk such as 4.94066e-324), which appear as 0 in timeseries, with their exact original value.
key (athlete_id, activity_id, row_in_activity, column); data/timeseries_exceptions/*.parquet
| column | type | unit | description |
|---|---|---|---|
athlete_id ¹ |
string |
Anonymous athlete id (UUID) from the GoldenCheetah OpenData release; the name of the athlete's zip on OSF. Identical across datasets. | |
activity_id ¹ |
string |
Activity id, unique within an athlete: the local start time YYYY_MM_DD_HH_MM_SS from the original CSV name, in a few cases followed by the original file's extension (.fit, .pwx, .csv.bak, ...). Activities without a CSV use their UTC start time followed by Z. Where two activities would get the same id (two versions of one activity in the release), the second gets ~2. Identical across datasets. |
|
row_in_activity |
int32 |
0-based row of the sample within its activity in timeseries. |
|
column |
string |
Column in timeseries (power_w, ...). |
|
source_column |
string |
Column in the original CSV (power, ...). Never null. |
|
source_value |
float64 |
The original value, exactly. Never null. |
raw_json
Each athlete's original JSON file, verbatim, so nothing in it is lost even where activities and athletes normalise it.
key (athlete_id); data/raw_json/*.parquet
| column | type | unit | description |
|---|---|---|---|
athlete_id ¹ |
string |
Anonymous athlete id (UUID) from the GoldenCheetah OpenData release; the name of the athlete's zip on OSF. Identical across datasets. | |
json |
string |
The original {athlete_id}.json text. Never null. |
¹ Shared column: same name, type, unit and meaning in every GoldenCheetah dataset on Hugging Face (conventions).
Provenance
Converted from the 6,613 zips in OSF project 6hfpz (sha256 of every source zip in
athletes.osf_sha256) with the scripts in https://github.com/GoldenCheetah/OpenData/tree/master/huggingface (converter 0.4.0, conventions 0.4,
polars 2.1.0, pyarrow 26.0.1).
Citation
Please cite the original dataset:
@misc{gcod2018,
title = {GoldenCheetah OpenData Project},
author = {Liversedge, Mark},
year = {2018},
publisher = {Open Science Framework},
doi = {10.17605/OSF.IO/6HFPZ},
url = {https://osf.io/6hfpz/}
}
License
CC0 1.0, same as the original release.
- Downloads last month
- 278