oristides/meli-sessions-enriched

Meli Sessions Enriched

Session-based recommendation dataset built from the Meli Data Challenge 2020.

Each row in this dataset is one user session, constructed from the original user_history field (and, for train, the item_bought field). The goal is to provide a clean, time-aware session dataset for sequence modeling and next-item prediction.

---

Source

• Original data: Meli Data Challenge 2020 on Kaggle
  • Author: marlesson
  • Files used: train_dataset.jl, test_dataset.jl, item_data.jl
• This dataset: preprocessed version with:
  • One row per session.
  • Numeric encodings for item metadata.
  • Time-based features and repeat-visit flags.

Please refer to the original Kaggle page for the underlying license and competition details.

---

Splits

This dataset has four splits:

• train: sessions with a known purchased item (target_item).
• test: sessions without purchase labels in the original data
  (target_item is set to 0 as a placeholder).
• train_meta: per-chunk metadata for the train Parquet parts.
• test_meta: per-chunk metadata for the test Parquet parts.

Typical cardinalities (depending on preprocessing version):

• train: ~410k sessions
• test: ~177k sessions

Each session can have a variable number of events.

---

Column description (sessions)

All list-valued columns have one element per event in the session, ordered by timestamp.

Core sequence columns

• item_ids – list[int]
  Item ID for each event.

  • For view events: the numeric item ID.
  • For search events: 0 (no specific item is attached).

• event_types – list[int]
  Encoded event type per step:

  • 0 = view (item page view)
  • 1 = search (search query event)

• domain_idx – list[int]
  Encoded domain index for the item at each step (derived from domain_id in item_data.jl).

• category_idx – list[int]
  Encoded category index for the item at each step (derived from category_id).

• product_idx – list[int]
  Encoded product index for the item at each step (derived from product_id, with missing values mapped to a special category).

• condition_idx – list[int]
  Encoded condition index for the item at each step (derived from textual condition like new, used).

• price – list[float]
  Log-transformed price per event:

  • price[t] = log1p(original_price) for item events.
  • 0.0 for non-item events (e.g. search).

Behavioral / temporal features

• position – list[int]
  Zero-based position of each event within the session:

  • 0, 1, 2, ..., len(session) - 1

• time_gap – list[float]
  Time in seconds since the previous event in the same session:

  • First event: 0
  • Subsequent events: (timestamp[t] - timestamp[t-1]).total_seconds()

• day_period – list[int]
  Discrete time-of-day bucket for each event, based on the event’s hour:

  • 0 = morning (05:00–12:00)
  • 1 = afternoon (12:00–17:00)
  • 2 = evening (17:00–21:00)
  • 3 = night (21:00–05:00)

• is_repeat – list[int]
  Indicates whether the item at a step has been seen earlier in the same session:

  • 1 = item already appeared before in this session
  • 0 = first time this item appears in this session
    (search events or item_id == 0 are treated as non-items.)

Target and timestamps

• target_item – int

  • In train: the ID of the purchased item (item_bought in the original data).
  • In test: always 0 (no purchase labels are provided in the original file).

• first_event_timestamp – timestamp
  Datetime of the first event in the session (after sorting).

• last_event_timestamp – timestamp
  Datetime of the last event in the session.
  This is useful for:

  • Time-based splits (using earlier sessions for training, later for validation/testing).
  • Popularity or recency-based baselines that must avoid leaking future information.

---

Chunk metadata (train_meta, test_meta)

These splits describe the Parquet parts used to build the dataset. Each row corresponds to one part_*.parquet file in the original processing pipeline.

Columns:

• chunk_idx – int
  Numeric index of the chunk (matches file name part_<chunk_idx>.parquet).

• path – string
  File name of the chunk, e.g. part_0.parquet.

• n_sessions – int
  Number of sessions in this chunk.

• min_last_event_timestamp – timestamp
  Earliest last_event_timestamp in the chunk.

• max_last_event_timestamp – timestamp
  Latest last_event_timestamp in the chunk.

This metadata allows reconstructing approximate temporal ordering of chunks and building time-aware evaluation schemes (e.g. using earlier chunks for training and later chunks for validation).

---

Example usage

from datasets import load_dataset

ds = load_dataset("oristides/meli-sessions-enriched")

train = ds["train"]
test = ds["test"]
train_meta = ds["train_meta"]

print(train[0]["item_ids"], train[0]["target_item"])
print(train_meta[0])