lifted-features / README.md
maxwildersmith's picture
add lifted features
c7e036b verified
|
Raw History Blame Contribute Delete
10.2 kB
---
pretty_name: "Splataverse: lifted features (100K)"
license: other
license_name: per-object-cc
license_link: https://huggingface.co/datasets/Splataverse/lifted-features/blob/main/metadata/attribution.csv
language:
- en
tags:
- 3d
- gaussian-splatting
- 3dgs
- feature-distillation
- clip
- dinov3
size_categories:
- 10K<n<100K
extra_gated_prompt: "This dataset contains per-Gaussian features computed from Splataverse splats of Sketchfab (Objaverse) and Smithsonian Open Access objects. Every object keeps the Creative Commons license of its source (CC BY, CC BY-SA, CC BY-NC, CC BY-NC-SA or CC0; see metadata/attribution.csv). By requesting access you agree to follow each object's license, including attribution and non-commercial terms where they apply, and to cite Splataverse."
extra_gated_fields:
I will follow each object's license (attribution, share-alike and non-commercial terms where they apply): checkbox
I agree to cite the Splataverse paper: checkbox
configs:
- config_name: objects
default: true
data_files:
- split: train
path: "metadata/objects.parquet"
---
# Splataverse: lifted features (100K)
Per-Gaussian 2D foundation-model features lifted onto the released Splataverse Gaussian splats, for training models that predict features directly on a 3D Gaussian splat (feature 3DGS without per-scene optimization). It is the training data of the Splataverse feature-prediction models and of the planned direct feature-3DGS challenge.
**99,296 objects, 1.11 TB**: 98,146 training objects (the `train_100k` tier of Splataverse split v4) and the 1,150 validation objects, in one block of uncompressed tar shards. The split v4 **test** objects are deliberately not included: their targets stay hidden for evaluation.
Each object carries three teachers:
| head | teacher | dim | objects |
|---|---|---:|---|
| DINO | DINOv3 ViT-B/16 (`facebook/dinov3-vitb16-pretrain-lvd1689m`), patch tokens at 512 px | 768 | all |
| CLIP | OpenAI CLIP ViT-B/32 (open_clip `ViT-B-32-quickgelu`), MaskCLIP dense tokens in the image-text space | 512 | all |
| DeFM | DeFM ViT-L/14 on rendered depth, 518 px | 1024 | Smithsonian only (`defm_valid`) |
plus a global CLIP embedding per object (`clip_global`) and per view (`clip_global_views`).
**This dataset contains derived data only.** Features are computed from renders of the published splats, never from the source meshes. No source mesh, texture or image is included. The splats themselves are in [maxwildersmith/splataverse-sketchfab](https://huggingface.co/datasets/maxwildersmith/splataverse-sketchfab) and [maxwildersmith/splataverse-smithsonian](https://huggingface.co/datasets/maxwildersmith/splataverse-smithsonian); `metadata/objects.parquet` gives the exact file (`splat_repo`, `splat_path`) for every object.
This dataset is **public with manual access approval**. Request access on this page, then authenticate with your approved Hugging Face account.
## Layout
```
data/shard_XXXX.tar # uncompressed tar of <uid>.npz, up to 500 objects and about 3 GB per shard
metadata/index.json # uid -> [shard path, byte offset, byte size] of its .npz inside the tar
metadata/objects.parquet # one row per object: split, tiers, source, license, attribution, splat file, shard, sizes
metadata/attribution.csv # uid, license, title, author, author URL and source URL per object
metadata/recipe.json # views, resolutions, teachers and aggregation
splits/val.txt # 1,150 validation uids
splits/train_{1k,5k,10k,25k,50k,100k}.txt # nested training tiers, restricted to objects in this block
splits/train_100k_not_in_block.txt # train_100k uids without lifted features (see below)
load_lift.py # minimal reader (numpy + huggingface_hub)
```
The training tiers are nested (1k is inside 5k is inside 10k ...) and follow Splataverse split v4. Each list contains only objects that are in this block:
| list | objects |
|---|---:|
| `val` | 1,150 |
| `train_1k` | 999 |
| `train_5k` | 4,984 |
| `train_10k` | 9,885 |
| `train_25k` | 24,806 |
| `train_50k` | 49,788 |
| `train_100k` | 98,146 |
1,854 objects of the v4 `train_100k` list have no lifted features: 1,852 had no valid result in the original lift run and 2 were dropped when the features were regenerated. They are listed in `splits/train_100k_not_in_block.txt`. The validation set is complete. Every split is a uid list over the same block, so no data is duplicated.
## What is in one object
Each `<uid>.npz` holds features for two subsets of the object's Gaussians, plus the splat attributes of those Gaussians (copied from the released splat, positions normalized to [-0.5, 0.5]^3) so that a model can be trained without decoding the full splat.
| key | dtype, shape | meaning |
|---|---|---|
| `dense_src_idx` | int64 (D,) | indices of a random subset of the object's Gaussians, in the order of the released `.spz` file; D = clip(1% of N, 2048, 4096), or N for objects with fewer Gaussians |
| `dense_dino_targets`, `dense_clip_targets`, `dense_defm_targets` | float16 (D,768), (D,512), (D,1024) | lifted per-Gaussian features of those Gaussians (DeFM all zeros unless `defm_valid`) |
| `dense_observed` | bool (D,) | Gaussian was visible in at least one view; unobserved rows are zero and should be masked |
| `dense_xyz`, `dense_log_scales`, `dense_quats`, `dense_opacity`, `dense_rgb` | float32 | normalized position, log scale, wxyz quaternion, opacity and color of the same Gaussians |
| `center_local_idx` | int64 (P,) | P <= 1,024 farthest-point-sampled patch centers, as indices into the `touched_*` arrays |
| `patch_dino_targets`, `patch_clip_targets`, `patch_defm_targets` | float16 (P, C) | features pooled around each center over its 64 nearest observed Gaussians (Gaussian-weighted) |
| `patch_target_valid` | bool (P,) | the center had at least one observed neighbor |
| `touched_xyz`, `touched_log_scales`, `touched_quats`, `touched_opacity`, `touched_rgb` | float32 (T, ...) | the centers and their neighbors (T <= 65,536) |
| `clip_global` | float32 (512,) | L2-normalized mean of the 16 per-view CLIP image embeddings |
| `clip_global_views` | float16 (16, 512) | per-view CLIP image embeddings |
| `norm_center`, `norm_scale` | float32 | `xyz_normalized = (xyz - norm_center) * norm_scale` maps the released splat into the unit cube |
| `uid`, `hf_source`, `defm_valid`, `n_gaussians_full`, `n_touched`, `n_centers`, `n_views`, `dino_model`, `clip_model`, `defm_model` | scalars | identifiers and recipe tags |
The full splat has 0.9M Gaussians per object on average (`n_gaussians_full`); features are released for the sampled subsets only. Features are stored as computed, in float16, and are not normalized (DINO and DeFM features have their native scale). One Smithsonian validation object (`871c570f-7e59-5fc1-a1a1-085ccb72e97a`) has a dense subset of 131,072 Gaussians.
## How the features were computed
Each splat is normalized to the unit cube and rendered with gsplat from 16 turntable views (20 degrees elevation, 40 degree field of view, 512 x 512, grey background). The renders go through DINOv3 and CLIP (MaskCLIP dense mode); for Smithsonian objects, depth renders at 518 x 518 also go through DeFM. Each Gaussian's feature is the mean over views of the feature map sampled bilinearly at its projected center, weighted by the Gaussian's alpha times transmittance at that pixel (its occlusion-aware contribution), so hidden Gaussians do not inherit the features of the surface in front of them. Details are in `metadata/recipe.json`.
## Loading
```python
from huggingface_hub import hf_hub_download
import sys; sys.path.insert(0, hf_hub_download("Splataverse/lifted-features", "load_lift.py", repo_type="dataset").rsplit("/", 1)[0])
from load_lift import LiftedFeatures
ds = LiftedFeatures()
uid = ds.uids("train_1k")[0]
x = ds.get_remote(uid) # one object over an HTTP range request; ds.get(uid) downloads its shard instead
x["dense_clip_targets"][x["dense_observed"]]
```
The tars are also plain WebDataset-style shards (`<uid>.npz` members) and can be streamed with any tar reader. To get the matching full splats:
```python
import pandas as pd
from huggingface_hub import hf_hub_download
meta = pd.read_parquet(hf_hub_download("Splataverse/lifted-features", "metadata/objects.parquet", repo_type="dataset"))
row = meta.set_index("uid").loc[uid]
spz = hf_hub_download(row.splat_repo, row.splat_path, repo_type="dataset")
```
## Intended use
Training and evaluating models that predict per-Gaussian semantic features (CLIP, DINO, DeFM) directly from 3D Gaussian splats, and the Splataverse direct feature-3DGS challenge. Validation features are provided for model selection; the challenge is scored on held-out objects whose features are not public. The features inherit the biases of their teachers and of the object collections (mostly user-uploaded Sketchfab models and museum scans).
## Licensing and attribution
Every object keeps the license of its source object, and that license also applies to its features:
| license | train | val | total |
|---|---:|---:|---:|
| CC BY 4.0 | 76,606 | 763 | 77,369 |
| CC BY-SA 4.0 | 5,738 | 121 | 5,859 |
| CC BY-NC 4.0 | 3,063 | 27 | 3,090 |
| CC BY-NC-SA 4.0 | 7,620 | 67 | 7,687 |
| CC0 1.0 | 5,119 | 172 | 5,291 |
Sources: 97,069 Sketchfab objects from Objaverse (author and model page per object in `metadata/attribution.csv`) and 2,227 Smithsonian Open Access objects (CC0, credit the Smithsonian Institution). The collection has **no blanket commercial-use license**: filter on `license` to drop the non-commercial objects (10,777) if you need to. When you redistribute or show results derived from specific objects, credit their authors as the license requires. The teacher models (DINOv3, CLIP, DeFM) have their own licenses; check them for your use of their features. Manual access approval does not replace any of these terms.
Part of [Splataverse](https://huggingface.co/datasets/maxwildersmith/splataverse).
## Citation
```bibtex
@misc{splataverse2026,
title = {Splataverse},
author = {TODO},
year = {2026},
note = {Citation to be added}
}
```