joleson/retail_events

Ecommerce event histories — v1

Each row is one complete entity history or one bounded global chunk. Splits are assigned by simulation world, never by individual history.

from datasets import load_dataset
ds = load_dataset("ACCOUNT/DATASET", "orders", split="train")
history = ds[0]

Numeric list columns retain the frozen event vocabulary and feature schema. The reference/categorical/integer/float offsets are per-event offsets within the row, rebased to zero. Integer values remain int64.

Entity and reference codes are run-local, not learned identity embeddings. Use (run_id, entity_id) for history identity; row indices are not entity IDs. Causation references may point outside the history. Source indices refer to the original raw event stream, not Parquet rows. Raw records remain in the source corpus. Public entity dictionaries, observation metadata and telemetry are in metadata/runs/. Vocabulary/schema and split provenance are in metadata/.

Batch preparation still needs windowing, padding, masking, and targets. Non-streaming Hugging Face loading normally also builds a local Arrow cache.

Understanding the Parquet files and rows

Worlds, views, splits, shards, and training batches

These are different levels of organization:

Term	Meaning
World/run	One simulated company's event stream, identified by run_id
Split	Assignment of whole worlds to training, validation, or testing
View	A way of grouping a run's events: orders, customers, or global chunks
History/row	One order history, one customer history, or one bounded global chunk
Shard	A .parquet file containing multiple history rows
Training batch	Histories selected by the DataLoader and prepared by the collate function

World assignments are recorded in metadata/split_manifest.json. Every view of a run belongs to the same split. A validation world's orders cannot appear in training just because they are in a different view. Histories never concatenate events from different runs. The same source event can appear in an order, customer, and global view, all within the same split.

Loading orders, split="train" exposes order histories from all training runs. Each current shard contains rows from one run and one view; the manifest records which run each file came from. Each row also retains its run_id. part-0000-0000.parquet is a storage shard, not a preassembled training batch. Parquet row groups are storage subdivisions, not training batches either.

One row contains an entire history

An order row contains its event sequence and all its encoded features. Timestamps are another column in that same row, not separate rows.

For illustration, a simplified row could be:

{
    "run_id": "world-A",
    "entity_id": "order-123",
    "entity_code": 10,
    "length": 3,
    "event_types": [12, 28, 41],
    "timestamps": [100.0, 120.0, 300.0],
    "source_seq": [7, 9, 15],
    "causation_seq": [-1, 7, 9],
    # Reference and attribute columns are also present in this row.
}

The numbers here are illustrative, not actual vocabulary assignments. Suppose event IDs 12, 28, and 41 mean placed, picked, and shipped. Position 1 then means the order was picked at simulation time 120.0, with source event sequence ID 9. Event position, vocabulary ID, and source event ID are three different things. Timestamps are simulation seconds, not calendar dates.

The next Parquet row contains a different history, with its own lists. Different histories can have different lengths. Rows preserve saved history boundaries, while the training collate function can later select shorter windows.

Columns aligned one-to-one with events

These list columns have exactly length entries; position i refers to event i:

Column	Meaning
event_types	Dense event-type IDs, decoded with metadata/event_vocab.json
timestamps	Event times in simulation seconds
source_seq	Original event identifiers within the run
source_index	Zero-based positions in the run's validated raw event stream
causation_seq	Source sequence ID of the causing event, or -1 if absent

source_index is not a Parquet row index, file offset, or physical JSONL line number. It counts validated source events before history sorting; blank lines do not count. Raw records remain in the source corpus. Causation links may refer to an event outside this history; identify such events by (run_id, source_seq).

Reference offsets: positions inside this row's reference lists

Events may refer to different numbers of business entities. For this example:

Event position	Event	Entities referenced
0	placed	order-123, customer-456
1	picked	order-123
2	shipped	order-123, shipment-789

Inside the same history row, the references are stored as flat lists:

reference_codes   = [10, 20, 10, 10, 30]
reference_types   = [ 1,  2,  1,  1,  3]
reference_offsets = [0, 2, 3, 5]

Here, assume reference type IDs 1, 2, and 3 mean order, customer, and shipment. Actual type IDs are defined in metadata/feature_schema.json.

For event position i, take this slice of both lists:

start = row["reference_offsets"][i]
end = row["reference_offsets"][i + 1]
codes = row["reference_codes"][start:end]
types = row["reference_types"][start:end]

That gives:

Event position	Slice	Codes	Types
0	[0:2]	[10, 20]	[1, 2]
1	[2:3]	[10]	[1]
2	[3:5]	[10, 30]	[1, 3]

Offsets do not locate an object, another row, another file, or a byte position. They only group the reference entries belonging to each event inside this row. Each row's offsets start at zero, independent of the file and all other rows. There are length + 1 offsets. The last is the total number of reference entries. Equal adjacent offsets mean the event has no references.

Reference codes identify entities, not events

The example run's metadata/runs/world-A/entity_lookup.jsonl would map:

code 10 → kind refs.order_id    → value "order-123"
code 20 → kind refs.customer_id → value "customer-456"
code 30 → kind refs.shipment_id → value "shipment-789"

These codes are run-local. Code 10 in another world can mean a different entity. Always use the row's run_id when resolving codes. The row's entity_code identifies the entity anchoring that history; it is not an offset and does not imply that all events have only that entity as a reference.

Resolving a reference and retrieving a history are separate operations:

1. Use the event's offsets to select its reference codes/types from this row.
2. Use the run's entity lookup to resolve a code to an original entity ID.
3. If needed, find (run_id, entity_id) in the appropriate view using a mapping or filtering. The offsets do not provide that lookup, and not every referenced entity necessarily has an exported history view.

For event-to-event links, use causation_seq, not reference_codes.

Attributes use the same within-row offset pattern

The following groups work like references:

Per-event offsets	Parallel flat lists selected by the slice
categorical_offsets	categorical_fields, categorical_values
integer_offsets	integer_fields, integer_values
float_offsets	float_fields, float_values

A field ID identifies the attribute; the corresponding value is its encoded category ID, exact int64 integer, or float64 number. Use the feature schema to interpret field and category IDs. Events with no attributes in a group have equal adjacent offsets. Each group has its own offsets; reference offsets cannot be used to slice attributes.

Direct preparation and history boundaries

Preparation writes directly from raw events to Parquet, using temporary SQLite grouping/sorting. There is no saved NumPy intermediate or separate export step. Each history is one row, so between-history offsets are unnecessary.

The within-history, per-event offsets remain as list columns because events still have variable numbers of references and attributes. All encoded event types, timestamps, references, attributes, source IDs and causation values survive preparation. Full raw JSON records are retained in the source corpus, not duplicated into every Parquet history.

The row schema is unchanged from the earlier two-stage export. Existing uploaded datasets can still be used; this compiler refactor does not require a re-upload.