VK-LSVD: Large Short-Video Dataset

VK-LSVD is the largest open industrial short-video recommendation dataset with real-world interactions:

• 40B unique user–item interactions with rich feedback (timespent, like, dislike, share, bookmark, click_on_author, open_comments) and context (place, platform, agent);
• 10M users (with age, gender, geo);
• 20M short videos (with duration, author_id, content embedding);
• Global Temporal Ordering across six consecutive months of user interactions.

Why short video? Users often watch dozens of clips per session, producing dense, time-ordered signals well suited for modeling. Unlike music, podcasts, or long-form video, which are often consumed in the background, short videos are foreground by design. They also do not exhibit repeat exposure. Even without explicit feedback, signals such as skips, completions, and replays yield strong implicit labels. Single-item feeds also simplify attribution and reduce confounding compared with multi-item layouts.

---

Note: The test set will be released after the upcoming challenge.

---

📊 Basic Statistics • 🧱 Data Description • ⚡ Quick Start • 🧩 Configurable Subsets

---

Basic Statistics

• Users 10,000,000
• Items 19,627,601
• Unique interactions 40,774,024,903
• Interactions density 0.0208%
• Total watch time: 858,160,100,084 s
• Likes: 1,171,423,458
• Dislikes: 11,860,138
• Shares: 262,734,328
• Bookmarks: 40,124,463
• Clicks on author: 84,632,666
• Comment opens: 481,251,593

---

Data Description

Privacy-preserving taxonomy — all categorical metadata (user_id, geo, item_id, author_id, place, platform, agent) is anonymized into stable integer IDs (consistent across splits; no reverse mapping provided).

Interactions

interactions
Each row is one observation (a short video shown to a user) with feedback and context. There are no repeated exposures of the same user–item pair.
Global Temporal Split (GTS): train / validation / test preserve time order — train on the past, validate/test on the future.
Chronology: Files are organized by weeks (e.g., week_XX.parquet); rows within each file are in increasing timestamp order.

Field	Type	Description
user_id	uint32	User identifier
item_id	uint32	Video identifier
place	uint8	Place: feed/search/group/… (24 ids)
platform	uint8	Platform: Android/Web/TV/… (11 ids)
agent	uint8	Agent/client: browser/app (29 ids)
timespent	uint8	Watch time (0–255 seconds)
like	boolean	User liked the video
dislike	boolean	User disliked the video
share	boolean	User shared the video
bookmark	boolean	User bookmarked the video
click_on_author	boolean	User opened author page
open_comments	boolean	User opened the comments section

Users metadata

users_metadata.parquet

Field	Type	Description
user_id	uint32	User identifier
age	uint8	Age (18-70 years)
gender	uint8	Gender
geo	uint8	Most frequent user location (80 ids)
train_interactions_rank	uint32	Popularity rank for sampling (lower = more interactions)

Items metadata

items_metadata.parquet

Field	Type	Description
item_id	uint32	Video identifier
author_id	uint32	Author identifier
duration	uint8	Video duration (seconds)
train_interactions_rank	uint32	Popularity rank for sampling (lower = more interactions)

Embeddings: variable width

Embeddings are trained strictly on content (video/description/audio, etc.) — no collaborative signal mixed in.
Components are ordered: the dot product of the first n components approximates the cosine similarity of the original production embeddings.
This lets researchers pick any dimensionality (1…64) to trade quality for speed and memory.

item_embeddings.npz

Field	Type	Description
item_id	uint32	Video identifier
embedding	float16[64]	Item content embedding with ordered components

---

Quick Start

Load a small subsample

from huggingface_hub import hf_hub_download
import polars as pl
import numpy as np

subsample_name = 'up0.001_ip0.001'
content_embedding_size = 32

train_interactions_files = [f'subsamples/{subsample_name}/train/week_{i:02}.parquet'
                            for i in range(25)]
val_interactions_file = [f'subsamples/{subsample_name}/validation/week_25.parquet']

metadata_files = ['metadata/users_metadata.parquet',
                  'metadata/items_metadata.parquet',
                  'metadata/item_embeddings.npz']

for file in (train_interactions_files +
             val_interactions_file +
             metadata_files):
    hf_hub_download(
        repo_id='deepvk/VK-LSVD', repo_type='dataset',
        filename=file, local_dir='VK-LSVD'
    )

train_interactions = pl.concat([pl.scan_parquet(f'VK-LSVD/{file}')
                                for file in train_interactions_files])
train_interactions = train_interactions.collect(engine='streaming')

val_interactions = pl.read_parquet(f'VK-LSVD/{val_interactions_file[0]}')

train_users = train_interactions.select('user_id').unique()
train_items = train_interactions.select('item_id').unique()

item_ids = np.load('VK-LSVD/metadata/item_embeddings.npz')['item_id']
item_embeddings = np.load('VK-LSVD/metadata/item_embeddings.npz')['embedding']

mask = np.isin(item_ids, train_items.to_numpy())
item_ids = item_ids[mask]
item_embeddings = item_embeddings[mask]
item_embeddings = item_embeddings[:, :content_embedding_size]

users_metadata = pl.read_parquet('VK-LSVD/metadata/users_metadata.parquet')
items_metadata = pl.read_parquet('VK-LSVD/metadata/items_metadata.parquet')

users_metadata = users_metadata.join(train_users, on='user_id')
items_metadata = items_metadata.join(train_items, on='item_id')
items_metadata = items_metadata.join(pl.DataFrame({'item_id': item_ids, 
                                                   'embedding': item_embeddings}), 
                                     on='item_id')

---

Configurable Subsets

We provide several ready-made slices and simple utilities to compose your own subset that matches your task, data budget, and hardware. You can control density via popularity quantiles (train_interactions_rank), draw random users, or pick specific time windows — while preserving the Global Temporal Split.

Representative subsamples are provided for quick experiments:

Subset	Users	Items	Interactions	Density
whole	10,000,000	19,627,601	40,774,024,903	0.0208%
ur0.1	1,000,000	18,701,510	4,066,457,259	0.0217%
ur0.01	100,000	12,467,302	407,854,360	0.0327%
ur0.01_ir0.01	90,178	125,018	4,044,900	0.0359%
up0.01_ir0.01	100000	171106	38,404,921	0.2245%
ur0.01_ip0.01	99,893	196,277	191,625,941	0.9774%
up0.01_ip0.01	100,000	196,277	1,417,906,344	7.2240%
up0.001_ip0.001	10,000	19,628	47,976,280	24.4428%
up-0.9_ip-0.9	8,939,432	17,654,817	2,861,937,212	0.0018%

• urX — X fraction of random users (e.g., ur0.01 = 1% of users).
• ipX — X fraction of popular items (by train_interactions_rank)
• Negative X denotes the least-popular fraction (e.g., −0.9 → bottom 90%).

For example, to get ur0.01_ip0.01 (1% of random users, 1% of most popular items) use the snippet below.

import polars as pl

def get_sample(entries: pl.DataFrame, split_column: str, fraction: float) -> pl.DataFrame:
    if fraction >= 0:
        entries = entries.filter(pl.col(split_column) <= 
                                 pl.col(split_column).quantile(fraction, 
                                                               interpolation='midpoint'))
    else:
        entries = entries.filter(pl.col(split_column) >= 
                                 pl.col(split_column).quantile(1 + fraction, 
                                                               interpolation='midpoint'))
    return entries

users = pl.scan_parquet('VK-LSVD/metadata/users_metadata.parquet')
users_sample = get_sample(users, 'user_id', 0.01).select(['user_id'])

items = pl.scan_parquet('VK-LSVD/metadata/items_metadata.parquet')
items_sample = get_sample(items, 'train_interactions_rank', 0.01).select(['item_id'])

interactions = pl.scan_parquet('VK-LSVD/interactions/validation/week_25.parquet')
interactions = interactions.join(users_sample, on='user_id', maintain_order='left')
interactions = interactions.join(items_sample, on='item_id', maintain_order='left')

interactions_sample = interactions.collect(engine='streaming')

To get up-0.9_ip-0.9 (90% of least popular users, 90% of least popular items) replace users and items sampling lines with

users_sample = get_sample(users, 'train_interactions_rank', -0.9).select(['user_id'])
items_sample = get_sample(items, 'train_interactions_rank', -0.9).select(['item_id'])