Update README.md

README.md

@@ -1,3 +1,199 @@
 ---
 license: mit
----
+---
+
+# NUSITS: Nanjing University-Siemens Time Series Corpus
+
+This dataset card describes the `main` branch of NUSITS. NUSITS 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:** [to be added](https://github.com/TO_BE_FILLED)
+- **Paper:** [to be added](https://arxiv.org/abs/TO_BE_FILLED)
+
+## 📦 Dataset Packaging & Structure
+
+The `main` branch contains the full NUSITS 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.
+
+```text
+NUSITS/
+├── ApplianceEnergy/
+│   ├── part0.parquet
+│   ├── meta.json
+│   └── references.bib
+├── Electricity/
+│   ├── part0.parquet
+│   ├── part1.parquet
+│   ├── ...
+│   ├── meta.json
+│   └── references.bib
+└── ...
+```
+
+During merging, NUSITS 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`](https://huggingface.co/datasets/YOUR_HF_NAMESPACE/YOUR_DATASET_NAME/tree/zipped_version) branch, or use the following memory-efficient parsing script.
+
+```python
+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 = ['./NUSITS'] 
+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.
+
+```python
+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:
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="YOUR_HF_NAMESPACE/YOUR_DATASET_NAME",
+    repo_type="dataset",
+    revision="main",
+    allow_patterns=["ApplianceEnergy/*"],
+    local_dir="NUSITS-main",
+)
+```
+
+Download the complete `main` branch:
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="YOUR_HF_NAMESPACE/YOUR_DATASET_NAME",
+    repo_type="dataset",
+    revision="main",
+    local_dir="NUSITS-main",
+)
+```
+
+The full corpus is very large. Ensure that enough disk space is available before downloading it.
+
+
+## Other Branches
+
+- [`zipped_version`](https://huggingface.co/datasets/YOUR_HF_NAMESPACE/YOUR_DATASET_NAME/tree/zipped_version): Full NUSITS corpus in compressed archives, preserving the original file layout.
+- [`smaller_version`](https://huggingface.co/datasets/YOUR_HF_NAMESPACE/YOUR_DATASET_NAME/tree/smaller_version): Smaller, domain-balanced NUSITS subset in Parquet format.
+- [`recommended_corpus`](https://huggingface.co/datasets/YOUR_HF_NAMESPACE/YOUR_DATASET_NAME/tree/recommended_corpus): Recommended pretraining mixture used in the paper.
+
+## License
+
+The NUSITS 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 NUSITS in your research, please cite:
+
+```bibtex
+@article{sun2026nusits,
+  title   = {NUSITS: A Large-scale Real-world Multivariate Corpus for Time Series Foundation Models},
+  author  = {Sun, Qian and Tian, Yong-Ming and Huang, Jia-Wei and Feng, Cheng and Zhang, Shao-Qun},
+  journal = {TO DO},
+  year    = {2026}
+}
+```