Dataset Viewer
Auto-converted to Parquet Duplicate
The dataset viewer is not available for this split.
The number of columns (1152) exceeds the maximum supported number of columns (1000). This is a current limitation of the datasets viewer. You can reduce the number of columns if you want the viewer to work.
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