RMISC: A Large-scale Real-world Multivariate Corpus for Time Series Foundation Models

This dataset card describes the main branch of RMISC. RMISC is a large-scale, real-world multivariate time-series corpus for pretraining and benchmarking time-series foundation models (TSFMs). The complete corpus contains around 200 sub-datasets, 2 million original time-series files, 16 billion timesteps, and 142 billion time points across energy, finance, environment, industry, traffic, and other domains.

• Project GitHub: https://github.com/zhangsq-nju/RMISC
• Paper: https://arxiv.org/abs/2607.06504

📦 Dataset Packaging & Structure

The main branch contains the full RMISC corpus in Parquet format. To avoid distributing millions of very small files, the original Parquet files within each sub-dataset have been merged into larger files named part0.parquet, part1.parquet, and so on.

RMISC/
├── ApplianceEnergy/
│   ├── part0.parquet
│   ├── meta.json
│   └── references.bib
├── Electricity/
│   ├── part0.parquet
│   ├── part1.parquet
│   ├── ...
│   ├── meta.json
│   └── references.bib
└── ...

During merging, RMISC adds an _original_filename column to every row. This column stores the stem of the original Parquet filename and makes the merge reversible.

If you need the original one-file-per-series layout, either restore it with the code below or use the zipped_version branch, or use the following memory-efficient parsing script.

import os
import pandas as pd
import pyarrow.parquet as pq
import gc
from concurrent.futures import ThreadPoolExecutor, as_completed
from tqdm import tqdm

# Configure the directory where your downloaded datasets are located, and running the code will parse all the datasets in this directory
TARGET_ROOTS = ['./RMISC'] 
MAX_WORKERS = 1 

def restore_single_part_file(args):
    part_file_path, dataset_path = args
    try:
        parquet_file = pq.ParquetFile(part_file_path)
        if '_original_filename' not in parquet_file.schema.names:
            return False, part_file_path
            
        for i in range(parquet_file.num_row_groups):
            df_group = parquet_file.read_row_group(i).to_pandas()
            if df_group.empty: continue

            groups = df_group.groupby('_original_filename', observed=True)
            for original_name, sub_df in groups:
                restore_path = os.path.join(dataset_path, f"{original_name}.parquet")
                
                # Clean the data: drop tracking column and all-NaN columns
                clean_df = sub_df.drop(columns=['_original_filename']).dropna(axis=1, how='all')

                if os.path.exists(restore_path):
                    existing_df = pd.read_parquet(restore_path)
                    final_df = pd.concat([existing_df, clean_df], ignore_index=True)
                    final_df.to_parquet(restore_path, index=False, compression='snappy')
                else:
                    clean_df.to_parquet(restore_path, index=False, compression='snappy')
            
            del df_group
            gc.collect()
            
        return True, part_file_path
    except Exception as e:
        print(f"\n⚠️ Error processing {os.path.basename(part_file_path)}: {e}")
        return False, part_file_path

def process_restore(dataset_path):
    part_files = [f for f in os.listdir(dataset_path) if f.startswith('part') and f.endswith('.parquet')]
    if not part_files: return
    
    tasks = [(os.path.join(dataset_path, pf), dataset_path) for pf in part_files]
    print(f"🚀 Restoring {os.path.basename(dataset_path)} ({len(part_files)} chunks)...")
    
    with tqdm(total=len(tasks), unit="part") as pbar:
        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
            futures = [executor.submit(restore_single_part_file, task) for task in tasks]
            for future in as_completed(futures):
                success, f_path = future.result()
                if success: os.remove(f_path) # Delete chunk after successful restoration
                pbar.update(1)

if __name__ == "__main__":
    for root in TARGET_ROOTS:
        if os.path.exists(root):
            for ds in os.listdir(root):
                ds_path = os.path.join(root, ds)
                if os.path.isdir(ds_path):
                    process_restore(ds_path)

💻 Quick Start: Hugging Face API

If you want to stream or load the dataset directly using the datasets library, here is how to load a dataset, extract a specific time series, and clean the formatting artifacts caused by the merging process.

from datasets import load_dataset
import pandas as pd

# 1. Load the dataset (using 'ACSF1' as an example)
# Replace 'TYM666/test' with the actual repository name if it changes
dataset = load_dataset("TYM666/test", data_dir="ACSF1", split="train")

# Convert to pandas dataframe for easier manipulation
df = dataset.to_pandas()

# 2. Print basic info about the dataset
unique_files = df['_original_filename'].unique()
print("\n" + "="*40)
print("📊 Information of ACSF1 Dataset.")
print("="*40)
print(f"🔹 Unique Series: {len(unique_files):,}")
print(f"🔹 Total Rows: {len(df):,}")
print(f"🔹 Features: {list(df.columns)}")
print("="*40 + "\n")

# 3. Extract a single time series (e.g., the series originally named '0.parquet')
sample_file = "0"
print(f"🔍 sample: extracting [{sample_file}.parquet] ...\n")

single_series_df = (
    df[df['_original_filename'] == sample_file]
    .drop(columns=['_original_filename']) # Remove the tracking column
    .dropna(axis=1, how='all')            # Remove empty columns generated by schema merging
    .reset_index(drop=True)
)

print(single_series_df.head(5))

Download Data

Download only one sub-dataset:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="nju-zhangsq/RMISC",
    repo_type="dataset",
    revision="main",
    allow_patterns=["ApplianceEnergy/*"],
    local_dir="RMISC-main",
)

Download the complete main branch:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="nju-zhangsq/RMISC",
    repo_type="dataset",
    revision="main",
    local_dir="RMISC-main",
)

The full corpus is very large. Ensure that enough disk space is available before downloading it.

Other Branches

• zipped_version: Full RMISC corpus in compressed archives, preserving the original file layout.
• smaller_version: Smaller, domain-balanced RMISC subset in Parquet format.
• recommended_corpus: Recommended pretraining mixture used in the paper.

License

The RMISC compilation is released under the MIT License. Each source dataset remains governed by its original license, recorded in the corresponding meta.json. Users are responsible for reviewing and complying with the terms of every sub-dataset they use.

Citation

If you use RMISC in your research, please cite:

@article{sun2026rmisclargescalerealworldmultivariate,
  title   = {RMISC: A Large-scale Real-world Multivariate Corpus for Time Series Foundation Models},
  author  = {Qian Sun and Yong-Ming Tian and Jia-Wei Huang and Cheng Feng and Shao-Qun Zhang},
  journal = {arXiv preprint arXiv:2607.06504},
  year    = {2026}
}