Datasets:

mlx-community
/

mlx-model-explorer-data

+---
+license: cc-by-4.0
+pretty_name: MLX Model Explorer Data
+language:
+  - en
+tags:
+  - mlx
+  - apple-silicon
+  - quantization
+  - benchmark
+  - telemetry
+size_categories:
+  - n<1K
+configs:
+  - config_name: events
+    data_files:
+      - split: train
+        path: data/events/**/*.parquet
+    default: true
+---
+# MLX Model Explorer Data
+An anonymous, append-only record of what people using [MLX Model Explorer](https://huggingface.co/spaces/mlx-community/mlx-model-explorer) look for when choosing an MLX model for their Mac: model families, sizes, quantizations, memory classes, context lengths and priorities. It also holds the optional browser hardware scores, community reports ("it worked", "too slow") and real MLX benchmark results that people choose to contribute.
+The goal is to answer, with data: **what is the MLX community actually trying to run, and how well does it work?**
+## Quick start
+```python
+from datasets import load_dataset
+ds = load_dataset("mlx-community/mlx-model-explorer-data", "events", split="train")
+df = ds.to_pandas()
+# Clean rows only
+df = df[df.suspicious_flags.apply(len) == 0]
+# Quantization share among searches
+df[df.event_type.isin(["search", "filter"])].quantization.value_counts(normalize=True)
+# Community MLX benchmarks: median generation speed per model and chip
+bench = df[df.event_type == "mlx_benchmark_submission"]
+bench.groupby(["selected_model", "chip"]).generation_tps.median()
+```
+Or read the Parquet shards directly:
+```python
+import pandas as pd
+df = pd.read_parquet("hf://datasets/mlx-community/mlx-model-explorer-data/data/events/")
+```
+## Layout
+```
+data/events/YYYY/MM/DD/<instance>-<UTC timestamp>-<suffix>.parquet
+```
+The Space buffers events and writes one new shard per flush (every 10 minutes when there is data). Shards are never modified or deleted after they are written. Every shard has the same columns in the same order.
+## Event types
+| `event_type` | When it is recorded |
+| --- | --- |
+| `search` | The user ran a search (clicked *Explore models*, or the page loaded with a query) |
+| `filter` | The same results were re-run after changing sort order or machine memory |
+| `model_view` | The model detail panel was opened |
+| `model_select` | A model was added to the comparison |
+| `compare` | The comparison table was opened (`compare_models` lists the models) |
+| `model_click` | The link to the model's Hugging Face page was clicked |
+| `hardware_test` | The ~1-second browser hardware estimate ran |
+| `browser_benchmark` | The optional 20-second WebGPU compute test ran |
+| `feedback` | The user answered "Have you actually tried this model?" |
+| `mlx_benchmark_submission` | A result from `mlx_explorer_bench.py` was submitted |
+## Schema
+Every row has every column. Columns that don't apply to an event are null.
+| Column | Type | Description |
+| --- | --- | --- |
+| `timestamp` | string | UTC, second precision, ISO 8601 |
+| `schema_version` | int | Currently `1` |
+| `app_version` | string | Space version |
+| `event_type` | string | See above |
+| `session_id` | string | Random 16-hex ID per browser tab. Not linked to any person or device, discarded when the tab closes. Null for script submissions |
+| `model_family` | string | e.g. `Qwen`, `Gemma`, `Llama` (normalized from model names and `base_model` tags) |
+| `model_name` | string | Repo name of `selected_model` (without the org) |
+| `parameter_bucket` | string | `<3B`, `3-8B`, `8-15B`, `15-35B`, `35-70B`, `70B+`, `MoE` |
+| `quantization` | string | `2-bit` … `8-bit`, `16-bit`, `unknown` |
+| `quant_bits` | float | Nominal bits of the selected model (from Hub metadata) |
+| `quant_mixed` | bool | Mixed-precision model (several bit widths) |
+| `target_context` | int | 4096, 8192, 16384, 32768, 65536, 131072, 262144 |
+| `priority` | string | `balanced`, `quality`, `speed`, `memory`, `long_context` |
+| `sort` | string | `recommended`, `popular`, `recent`, `community`, `all` |
+| `result_count` | int | Number of models matching the query |
+| `hardware_source` | string | `confirmed` (user picked memory), `detected` (browser estimate), `none` |
+| `hardware_memory_class` | int | RAM class in GB: 8, 16, 18, 24, 32, 36, 48, 64, 96, 128, 192, 256, 512 |
+| `hardware_confirmed` | bool | Whether the memory class was chosen by the user |
+| `webgpu_available` | bool | WebGPU present in the browser |
+| `webgpu_score` | float | Relative WebGPU compute score (quick test in `hardware_test`, 20 s test in `browser_benchmark`). **Not MLX, not tokens/sec** |
+| `gpu_capability_class` | string | `high`, `mid`, `entry`, `unknown`, bucketed from the quick score |
+| `gpu_vendor`, `gpu_arch` | string | Generic WebGPU adapter identifiers, e.g. `apple` / `metal-3` |
+| `browser_family`, `os_family` | string | Coarse: `chrome`/`safari`/`firefox`/`edge`/`other`, `macos`/`ios`/`windows`/`linux`/`android`/`other` |
+| `cpu_cores` | int | `navigator.hardwareConcurrency` |
+| `selected_model` | string | `org/name` Hugging Face repo ID |
+| `selected_model_rank` | int | 0-based position in the result list when chosen |
+| `compare_models` | list[string] | Models in the comparison table |
+| `hf_downloads_at_selection`, `hf_likes_at_selection` | int | Hub counts at the time of the event (downloads are Hub's trailing 30 days) |
+| `recommendation_score` | float | 0 to 100 score the user was shown for that model |
+| `fit_class` | string | Fit label the user was shown: `Comfortable`, `Likely`, `Borderline`, `Unlikely` |
+| `engine_version` | string | Recommendation engine, e.g. `heuristic-v1` |
+| `pipeline` | string | Hub pipeline tag of the selected model |
+| `tried` | string | `yes`, `no`, `planning` |
+| `outcome` | string | `worked` or `problem` (derived from the two columns below) |
+| `quality_rating` | string | `excellent`, `good`, `acceptable` |
+| `failure_reason` | string | `too_slow`, `too_much_memory`, `low_quality`, `didnt_run` |
+| `reported_ram_gb` | int | Mac memory reported by the user or the benchmark script |
+| `reported_mac_model` | string | `Apple M1` … `Apple M5 Ultra`, or `other` |
+| `reported_tokens_per_second` | float | Self-reported generation speed |
+| `reported_context` | int | Context length the user ran |
+| `notes` | string | Optional free text, ≤ 280 characters. Emails, links and phone numbers are replaced before storage |
+| `benchmark_type` | string | `webgpu_quick`, `webgpu_full`, `mlx_lm` |
+| `benchmark_version` | string | `webgpu-1`, `mlxbench-1`, … |
+| `benchmark_duration_ms` | int | Browser test duration |
+| `prompt_tokens`, `generation_tokens` | int | MLX benchmark settings |
+| `prompt_tps`, `generation_tps` | float | MLX benchmark medians (tokens/second) |
+| `ttft_ms` | float | Median time to first token, including prefill |
+| `peak_memory_gb` | float | Peak MLX memory during the benchmark |
+| `chip` | string | e.g. `Apple M3 Max` |
+| `mlx_version`, `mlx_lm_version` | string | Library versions |
+| `macos_major` | int | e.g. `26` |
+| `suspicious_flags` | list[string] | Validation flags. Empty means the row passed all checks |
+### `suspicious_flags`
+| Flag | Meaning |
+| --- | --- |
+| `unknown_model` / `unknown_model_in_compare` | Model ID not found in the `mlx-community` catalogue at the time |
+| `implausible_tps` | Generation speed above what Apple Silicon memory bandwidth (≤ 800 GB/s) allows for that model, with 3× headroom for speculative decoding |
+| `peak_memory_exceeds_ram` | Peak memory above the reported RAM |
+| `incomplete_benchmark` | Benchmark submission missing the model, speed or version |
+| `benchmark_type_mismatch` | e.g. a browser benchmark labelled as MLX |
+| `implausible_webgpu_score` | Score far outside observed ranges |
+| `conflicting_feedback` | Both a success rating and a failure reason |
+Values outside hard bounds (for example negative speeds, unknown enums or oversized payloads) are rejected and never stored. Flagged rows are kept so filters stay transparent, but the Space excludes them from recommendations and statistics.
+## Privacy
+Never collected: names, emails, accounts, IP addresses, precise location, cookies, user-agent strings, device fingerprints or full GPU description strings. Timestamps are truncated to seconds. Session IDs are random per tab and not persisted. Rate limiting uses an in-memory salted hash that rotates hourly and is never written anywhere. Browsers sending Global Privacy Control or Do Not Track send nothing unless the user explicitly opts in, and anyone can opt out on the page.
+Free-text notes are optional, capped at 280 characters and scrubbed of emails, links and long digit sequences. Even so, treat them as user-generated content.
+## Benchmark methodology
+**Browser (`webgpu-1`).** The quick test runs a 256×256 WGSL matrix multiplication for about 1.2 s. The full test runs matrix multiplications at 256, 512 and 1024 plus a 256 MB buffer copy, about 20 s in total. Each phase is normalized to a fixed reference, and the score is the geometric mean × 1000. It depends on the browser, power mode and background load, and it measures WebGPU, **not** MLX or LLM inference.
+**MLX (`mlxbench-1`).** `mlx_explorer_bench.py` follows `mlx_lm.benchmark`: it loads the model with `mlx-lm`, builds a random prompt of `prompt_tokens` tokens (seed 0), disables EOS so exactly `generation_tokens` are produced, does one warm-up run, then reports medians over 3 trials of prompt tokens/s, generation tokens/s and time to first token, plus peak memory. Chip and RAM class come from `sysctl`. Results depend on the macOS version, mlx versions, thermal state and other running apps.
+## Limitations
+- **Self-selected and self-reported.** The people who use the Space and submit data are not a random sample of MLX users, and feedback is subjective.
+- **Estimated memory classes.** Browsers can't read unified memory size. `hardware_source = detected` rows use Chrome's rounded-down `deviceMemory` (capped at 32 GB). Prefer `hardware_confirmed = true`.
+- **Search ≠ usage.** Searches show interest, not deployment.
+- **Heuristic recommendations.** `recommendation_score` depends on `engine_version`, and scores from different versions are not comparable.
+- **Catalogue drift.** Download and like counts are snapshots at event time.
+- **Early days.** The dataset starts small, and aggregates below 5 events are too small to interpret.
+## Versioning
+- `schema_version` changes only when columns change meaning or are removed. New nullable columns may be added within a version.
+- `benchmark_version` and `engine_version` identify the exact methodology behind each score.
+- Shards are immutable. Corrections, if ever needed, would ship as new shards with an explanatory note here.
+## Example rows
+```json
+{"timestamp": "2026-09-14T01:28:22Z", "event_type": "compare", "session_id": "05838aea6916667e",
+ "target_context": 32768, "priority": "balanced", "hardware_source": "confirmed", "hardware_memory_class": 36,
+ "compare_models": ["mlx-community/Qwen3.5-9B-MLX-4bit", "mlx-community/Qwen3-8B-4bit"], "suspicious_flags": []}
+{"timestamp": "2026-09-14T01:30:34Z", "event_type": "mlx_benchmark_submission", "selected_model": "mlx-community/Qwen3-0.6B-4bit",
+ "benchmark_type": "mlx_lm", "benchmark_version": "mlxbench-1", "prompt_tokens": 512, "generation_tokens": 128,
+ "prompt_tps": 6503.96, "generation_tps": 361.01, "ttft_ms": 135.5, "peak_memory_gb": 0.851,
+ "chip": "Apple M3 Max", "reported_ram_gb": 36, "suspicious_flags": []}
+```
+## Using the dataset
+Some questions it can answer:
+- Which quantizations do people want at each memory class, and does that change over time?
+- How often does the estimated fit agree with reported outcomes (`fit_class` vs. `outcome`/`failure_reason`)?
+- What generation speeds do real Macs achieve for a model, and how does that scale with chip tier?
+- Which families and sizes are underserved by existing `mlx-community` uploads?
+## License
+CC BY 4.0. Please cite the dataset and link back to the Space.