|
Download README.md from Wizard1203/WIFI-CSI-Dataset: direct link, hf CLI and curl.
- Browser
- Download file 8.4 kB
-
https://huggingface.co/datasets/Wizard1203/WIFI-CSI-Dataset/resolve/main/README.md
- Command line
-
hf download hf://datasets/Wizard1203/WIFI-CSI-Dataset/README.md
-
curl -L -o README.md https://huggingface.co/datasets/Wizard1203/WIFI-CSI-Dataset/resolve/main/README.md
8.4 kB
| license: mit | |
| language: | |
| - en | |
| tags: | |
| - Wi-Fi | |
| - CSI | |
| - RSSI | |
| --- | |
| WiFi CSI Router Reception Dataset | |
| tags: | |
| - wifi | |
| - csi | |
| - esp32 | |
| - signal-processing | |
| - time-series | |
| size_categories: | |
| - 100K<n<1M | |
| --- | |
| # WiFi CSI Router Reception Dataset | |
| This repository contains a small, structured dataset of **WiFi Channel State Information (CSI)** captures recorded as text logs (`.data`). The data is organized as repeated trials (`test_XX`) for **4 class labels** (`label_00..label_03`) and **4 subjects/persons** (`id_person_01..id_person_04`), recorded simultaneously by **3 receiver devices** (`dev1..dev3`). | |
| The “Hugging Face–ready” dataset folder is `wifi_data_set/`. | |
| ## Dataset summary | |
| - **Modality:** WiFi CSI (I/Q samples) + per-frame metadata | |
| - **Format:** plain text files; 1 CSI frame per line | |
| - **CSI vector:** 128 signed integers per frame (typically interpreted as 64 complex subcarriers as interleaved I/Q pairs) | |
| - **People (subjects):** 4 (`id_person_01..04`) | |
| - **Labels (classes):** 4 (`label_00..03`) *(see “Label meanings” below)* | |
| - **Trials:** 100 per (person, label) | |
| - **Devices per trial:** 3 (`dev1`, `dev2`, `dev3`) | |
| - **Frames per file:** 100 lines *(see “Known issues” for malformed first lines in some files)* | |
| - **Total files:** 4 persons × 4 labels × 100 tests × 3 devices = **4,800** `.data` files | |
| - **Total frames:** 4,800 files × 100 lines = **480,000** logged frames | |
| - **Collection time range:** **2026-04-18 20:17:59.599 +03:00** … **2026-04-18 23:21:01.561 +03:00** | |
| - **Typical sampling:** ~0.039–0.044 s between frames (≈ 23–28 Hz); ~4 s per trial | |
| ## Dataset structure | |
| Primary structured dataset: | |
| ``` | |
| wifi_data_set/ | |
| id_person_01/ | |
| label_00/ | |
| test_01/ | |
| test1__dev1_64_E8_33_57_AA_F4.data | |
| test1__dev2_64_E8_33_58_9E_28.data | |
| test1__dev3_64_E8_33_58_9C_CC.data | |
| ... | |
| label_01/ ... | |
| label_02/ ... | |
| label_03/ ... | |
| id_person_02/ ... | |
| id_person_03/ ... | |
| id_person_04/ ... | |
| ``` | |
| Notes: | |
| - Each `test_XX/` folder represents one trial. | |
| - Each trial contains 3 `.data` files (one per receiver device). | |
| - The receiver “device id” and device MAC-like identifier are embedded in the filename. | |
| Raw/original layout (also present in this repo): | |
| ``` | |
| <label><suffix-of-dashes>/ | |
| testN/ | |
| testN__devK_<device_id>.data | |
| ``` | |
| Here, the number of trailing `-` characters encodes the person/subject. The scripts `restructure_dataset.py` / `restructure_dataset.ps1` convert the raw layout into `wifi_data_set/`. | |
| ## Label meanings | |
| `label_00..label_03` are the 4 class labels present in the dataset. | |
| This repository does **not** contain a textual mapping from label IDs to human-readable class names. If you publish this dataset, consider filling in the table below: | |
| | Label directory | Class name/description | | |
| |---|---| | |
| | `label_00` | TODO | | |
| | `label_01` | TODO | | |
| | `label_02` | TODO | | |
| | `label_03` | TODO | | |
| ## File format | |
| Each `.data` file is a newline-delimited text log. Each line contains: | |
| 1) A timestamp prefix (with timezone offset), then | |
| 2) A CSV record that starts with the literal tag `CSI_DATA`, then | |
| 3) A final field which is a JSON-like list of integers (the CSI vector), usually quoted. | |
| Example line (wrapped for readability): | |
| ``` | |
| 18.04.2026 22:44:41.143 +03:00 CSI_DATA, | |
| 328252,50:ff:20:e5:a8:f3,-43,11,1,7,0,1,1,1,1,0,0,-90,0,6,0,669572834,0,83,0,128,0, | |
| "[0,0,-39,16,-37,13,...]" | |
| ``` | |
| ### Parsed schema (standard `CSI_DATA` layout) | |
| After splitting at `" CSI_DATA,"`, the remaining CSV fields are typically: | |
| | Index | Name | Type | Notes | | |
| |---:|---|---|---| | |
| | 0 | `seq` | int | Frame/packet sequence counter (monotonic within a file) | | |
| | 1 | `mac` | str | Transmitter/AP MAC in colon form (observed constant: `50:ff:20:e5:a8:f3`) | | |
| | 2 | `rssi` | int | Received signal strength (dBm), e.g. `-43` | | |
| | 3 | `rate` | int | PHY rate field as logged by the capture tool | | |
| | 4 | `sig_mode` | int | Signal mode (often 0/1 in ESP32 CSI logs) | | |
| | 5 | `mcs` | int | Modulation and Coding Scheme index (0..7 observed) | | |
| | 6 | `bandwidth` | int | Bandwidth flag (0 observed in valid lines) | | |
| | 7 | `smoothing` | int | 0/1 flag | | |
| | 8 | `not_sounding` | int | 0/1 flag | | |
| | 9 | `aggregation` | int | 0/1 flag | | |
| | 10 | `stbc` | int | 0/1 flag | | |
| | 11 | `fec_coding` | int | 0/1 flag (0 observed) | | |
| | 12 | `sgi` | int | Short guard interval flag (0/1 observed) | | |
| | 13 | `noise_floor` | int | Noise floor (dBm), values like `-90..-98` | | |
| | 14 | `ampdu_cnt` | int | AMPDU counter (0 observed in valid lines) | | |
| | 15 | `channel` | int | WiFi channel (6 observed in valid lines) | | |
| | 16 | `secondary_channel` | int | Secondary channel (0 observed) | | |
| | 17 | `local_timestamp` | int | Device local timestamp (may wrap into negative due to 32-bit overflow) | | |
| | 18 | `ant` | int | Antenna index (0 observed) | | |
| | 19 | `sig_len` | int | Signal length (24/83/118 observed) | | |
| | 20 | `rx_state` | int | RX state (0 observed) | | |
| | 21 | `len` | int | CSI vector length (128 observed in valid lines) | | |
| | 22 | `first_word` | int | First word / reserved (0 observed) | | |
| | 23 | `csi` | list[int] | CSI vector as 128 signed integers | | |
| #### CSI vector | |
| - Length: **128 integers** | |
| - Value range (observed): **[-92, 87]** | |
| - Common interpretation: **64 complex values** as interleaved I/Q pairs: `(I0,Q0,I1,Q1,...)`. | |
| ## Known issues / data quality | |
| Most lines parse cleanly, but there are a small number of malformed first lines: | |
| - Valid frames (parse to 24 fields + 128-length CSI vector): **479,402 / 480,000** (99.875%) | |
| - Malformed frames: **598 / 480,000** (0.125%) | |
| - Affected files: **598 / 4,800** (12.46%) | |
| - Pattern: **the malformed record is always line 1** of the affected file; the remaining 99 lines are well-formed. | |
| Typical corruption patterns include missing commas/quotes around the CSI vector, truncated first lines, or concatenated `CSI_DATA` tokens. | |
| If you are building a loader, the simplest robust strategy is: | |
| 1) Parse every line, and | |
| 2) Keep only records where: | |
| - CSV field count is exactly 24, and | |
| - the `csi` field parses as a list of length 128. | |
| ## Loading example (Python) | |
| ```python | |
| import csv | |
| import json | |
| from dataclasses import dataclass | |
| from datetime import datetime | |
| TS_FMT = "%d.%m.%Y %H:%M:%S.%f %z" | |
| @dataclass(frozen=True) | |
| class CSIFrame: | |
| ts: datetime | |
| meta: dict | |
| csi: list[int] # length 128 | |
| def parse_csi_line(line: str) -> CSIFrame | None: | |
| if " CSI_DATA," not in line: | |
| return None | |
| ts_str, rest = line.split(" CSI_DATA,", 1) | |
| ts = datetime.strptime(ts_str, TS_FMT) | |
| row = next(csv.reader([rest], delimiter=",", quotechar='"')) | |
| if len(row) != 24: | |
| return None | |
| try: | |
| csi = json.loads(row[-1]) | |
| except json.JSONDecodeError: | |
| return None | |
| if not isinstance(csi, list) or len(csi) != 128: | |
| return None | |
| keys = [ | |
| "seq","mac","rssi","rate","sig_mode","mcs","bandwidth","smoothing","not_sounding", | |
| "aggregation","stbc","fec_coding","sgi","noise_floor","ampdu_cnt","channel", | |
| "secondary_channel","local_timestamp","ant","sig_len","rx_state","len","first_word", | |
| ] | |
| meta = {k: (int(v) if k != "mac" else v) for k, v in zip(keys, row[:-1])} | |
| return CSIFrame(ts=ts, meta=meta, csi=[int(x) for x in csi]) | |
| ``` | |
| ## Suggested evaluation setups | |
| There is no predefined train/validation/test split. Common choices for this type of dataset: | |
| - **Within-subject split:** random trials into train/test per person. | |
| - **Cross-subject split:** hold out `id_person_0X` as test (leave-one-subject-out). | |
| - **Device generalization:** train on `dev1+dev2`, evaluate on `dev3` (or vice versa). | |
| ## License | |
| No license file or explicit license statement is included in this repository. If you plan to publish/share the dataset, add a license and update the YAML header at the top of this README. | |
| ## How `wifi_data_set/` was produced | |
| The scripts in the repository root reorganize the raw folder structure: | |
| - `restructure_dataset.py` (Python) | |
| - `restructure_dataset.ps1` (PowerShell) | |
| They map source directories named like `0`, `0-`, `0--`, `0---`, `1`, `1-`, ... into: | |
| `wifi_data_set/id_person_XX/label_XX/test_XX/*.data` | |
| ## Citation | |
| If you use this dataset in academic work, consider citing it as: | |
| ```bibtex | |
| @dataset{wifi_csi_router_reception_2026, | |
| title = {WiFi CSI Router Reception Dataset}, | |
| year = {2026}, | |
| note = {Version as of 2026-04-18}, | |
| } | |
| ``` |