Duplicate from CelfAI/COOPER

Co-authored-by: Thaina Saraiva <thainasaraiva@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,61 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+synthetic_data_ydt.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+publish/
+.vscode/
+.env

README.md

@@ -0,0 +1,217 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- mobileNetwork
+- 5G
+task_ids:
+- univariate-time-series-forecasting
+- multivariate-time-series-forecasting
+configs:
+- config_name: measurements_by_cell 
+  data_files:
+    - split: train
+      path: dataset/train_data.csv
+    - split: test
+      path: dataset/test_data.csv
+- config_name: topology
+  data_files:
+    - split: main
+      path: metadata/topology.csv
+- config_name: performance_indicators_meanings
+  data_files:
+    - split: main
+      path: metadata/performance_indicators_meanings.csv
+
+
+
+
+---
+# 📡 COOPER  
+### Cellular Operational Observations for Performance and Evaluation Research  
+**An Open Benchmark of Synthetic Mobile Network Performance Indicators for Reproducible Research**
+
+---
+
+## 🧭 Overview
+
+**COOPER** is an open-source **synthetic dataset of mobile network performance measurement (PM) time series**, designed to support **reproducible AI/ML research** in wireless networks. The dataset is named in honor of **Martin Cooper**, a pioneer of cellular communications.
+
+COOPER emulates the **statistical distributions, temporal dynamics, and structural patterns** of real 5G network PM data while containing **no sensitive or operator-identifiable information**.
+
+The dataset is released together with a **reproducible benchmarking framework** used to evaluate synthetic data generation methods.
+
+---
+
+## 🎯 Motivation
+
+Access to real telecom PM/KPI data is often restricted due to:
+
+- Confidentiality agreements  
+- Privacy regulations  
+- Commercial sensitivity  
+
+This lack of open data limits **reproducibility** in AI-driven research for wireless networks. COOPER addresses this gap by providing a **realistic yet privacy-preserving synthetic alternative** suitable for:
+
+- Network monitoring research  
+- KPI forecasting  
+- Anomaly detection  
+- AI-native network automation  
+- 5G/6G performance evaluation  
+
+---
+
+## 🏗 Dataset Creation Methodology
+
+To generate COOPER, three complementary synthetic data generation paradigms were evaluated:
+
+1. **Adversarial approaches**
+2. **Probabilistic models**
+3. **Model-based time-series methods**
+
+These were benchmarked using a **unified quantitative and qualitative evaluation framework** considering:
+
+- Distributional similarity  
+- Temporal fidelity  
+- Shape alignment  
+- Discriminative performance  
+- Downstream forecasting capability  
+
+The generator demonstrating the most **balanced and consistent performance** across these criteria was selected to produce COOPER.
+
+---
+
+## 📊 Source Data Characteristics (Before Anonymization)
+
+The real dataset used to model the synthetic data was:
+
+- Fully **anonymized** to remove operator-sensitive information  
+- Cleaned and standardized for consistency  
+
+| Property | Value |
+|---------|------|
+| Radio Access Technology | 5G |
+| Number of PM Indicators | 45 |
+| Total Number of Cells | 84 |
+| Base Stations | 12 |
+| Geographic Area | ~1.35 km² |
+| Collection Period | 31 days |
+| Sampling Interval | 1 hour |
+| Data Representation | Multi-cell time series |
+
+A **cell** is defined as a radiating unit within a specific RAT and frequency band. Each base station may host multiple cells.
+
+---
+
+## 📡 Network Deployment Characteristics
+
+The modeled network includes two frequency bands and two 5G architectures:
+
+| Band | Architecture | Number of Cells |
+|------|-------------|----------------|
+| N28 (700 MHz) | Option 2 (Standalone) | 6 |
+| N28 (700 MHz) | Option 3 (Non-Standalone) | 48 |
+| N78 (3500 MHz) | Option 2 (Standalone) | 6 |
+| N78 (3500 MHz) | Option 3 (Non-Standalone) | 24 |
+
+Most cells operate in **Option 3 (NSA)** mode, reflecting a typical **EN-DC deployment** where LTE provides the control-plane anchor.
+
+---
+
+## 📈 PM Indicator Categories
+
+Indicators follow **3GPP TS 28.552** performance measurement definitions and are grouped into:
+
+### 1️⃣ Radio Resource Control (RRC) Connection
+Procedures for establishing UE radio connections and tracking active users.
+- `RRC.ConnEstabSucc`
+- `RRC.ConnEstabAtt`
+- `RRC.ConnMax`
+
+### 2️⃣ Mobility Management
+Handover and redirection performance across frequencies.
+- `MM.HoExeIntraFreqSucc`
+- `MM.HoExeInterFreqSuccOut`
+
+### 3️⃣ Channel Quality Indicator (CQI)
+Distribution of downlink channel quality reports (CQI 0–15).
+- `CARR.WBCQIDist.Bin0`
+- `CARR.WBCQIDist.Bin15`
+
+### 4️⃣ Throughput and Data Volume
+Traffic volume and transmission duration.
+- `ThpVolDl`
+- `ThpTimeDl`
+
+### 5️⃣ Availability
+Cell downtime due to failures or energy-saving mechanisms.
+- `CellUnavail.System`
+- `CellUnavail.EnergySaving`
+
+### 6️⃣ UE Context
+User session establishment attempts and successes.
+- `UECNTX.Est.Att`
+- `UECNTX.Est.Succ`
+
+---
+
+## 🧪 Benchmarking Framework
+
+COOPER is distributed with a **reproducible evaluation pipeline** that allows researchers to compare synthetic data generators using:
+
+- Statistical similarity metrics  
+- Temporal alignment measures  
+- Shape-based similarity  
+- Classification distinguishability  
+- Forecasting task performance  
+
+This framework enables standardized evaluation of synthetic telecom datasets.
+
+---
+
+## 🔬 Intended Use Cases
+
+COOPER is suitable for:
+
+- Time-series forecasting research  
+- Network anomaly detection  
+- Root cause analysis modeling  
+- RAN performance optimization studies  
+- Reproducible academic research in 5G/6G systems  
+
+---
+
+## ⚠️ Data Notice for Dataset Users
+
+**Due to the real network nature of the source data, some inconsistent values were intentionally maintained in this dataset.**  
+We recommend **preprocessing the data before use** (e.g., handling outliers, missing values, or domain-specific inconsistencies) according to your application and methodology.
+
+---
+
+## 🤝 Contribution & Reproducibility
+
+This project promotes **open and reproducible telecom AI research**.  
+Researchers are encouraged to:
+
+- Benchmark new generation models using the provided framework  
+- Share improvements and derived datasets  
+- Compare methods under the same evaluation protocol  
+
+---
+
+## 📜 License
+
+This dataset is released for **research and educational purposes**.  
+(Include specific license here, e.g., CC BY 4.0 / MIT / Apache 2.0)
+
+---
+
+## 📖 Citation
+
+If you use COOPER in your research, please cite:
+
+> *COOPER: An Open Benchmark of Synthetic Mobile Network Performance Indicators for Reproducible Research*
+
+(Full citation to be added)
+

dataset/test_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7cfca869710258d5fd746fbd0c2ae8812603c3a9cd7bad4797bc8b8228b0160
+size 2294862

dataset/train_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6687a849574ad843bcac34ba4ad00a186bf09284cd0a1ab00b73cc7a368d6767
+size 9129437

example/download_dataset.py

@@ -0,0 +1,31 @@
+from datasets import load_dataset
+import pandas as pd
+
+### Measurements by cell ###
+measurements_by_cell = load_dataset('CelfAI/COOPER','measurements_by_cell')
+
+measurements_by_cell_data_train = measurements_by_cell['train'].to_pandas()
+measurements_by_cell_data_test = measurements_by_cell['test'].to_pandas()
+measurements_by_cell_data = pd.concat([measurements_by_cell_data_train, measurements_by_cell_data_test])
+
+### Topology ###
+topology = load_dataset('CelfAI/COOPER','topology')
+topology_data = topology['main'].to_pandas()
+
+
+
+### Performance indicators meanings ###
+performance_indicators_meanings = load_dataset('CelfAI/COOPER','performance_indicators_meanings')
+performance_indicators_meanings_data = performance_indicators_meanings['main'].to_pandas()
+
+#### Optionally Join Measurements by cell and Topology ###
+all_data = pd.merge(measurements_by_cell_data, topology_data, on='LocalCellName', how='left')
+pm_columns=[x for x in measurements_by_cell_data.columns.tolist() if x not in ['LocalCellName', 'datetime']]
+
+mean_by_cell= measurements_by_cell_data.groupby('LocalCellName')[pm_columns].mean().reset_index()
+min_by_cell= measurements_by_cell_data.groupby('LocalCellName')[pm_columns].min().reset_index()
+
+mean_by_band= all_data.groupby('Band')[pm_columns].mean().reset_index()
+mean_by_site= all_data.groupby('SiteLabel')[pm_columns].mean().reset_index()
+    
+

example/save_in_postgress.py

@@ -0,0 +1,285 @@
+"""
+Load COOPER datasets from Hugging Face and persist them into a PostgreSQL database.
+
+This script:
+  - Loads measurements_by_cell, topology, and performance_indicators_meanings from CelfAI/COOPER.
+  - Optionally computes aggregated views (mean/min by cell, mean by band/site).
+  - Creates the database if missing, then writes the main tables via pandas to_sql.
+
+Usage:
+  python save_in_postgress.py
+
+Requires: datasets, pandas, sqlalchemy, psycopg2-binary
+"""
+
+from datasets import load_dataset
+import pandas as pd
+from sqlalchemy import create_engine, text
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+DATASET_REPO = "CelfAI/COOPER"
+SPLITS_MEASUREMENTS = ("train", "test")
+
+# Default PostgreSQL connection (override via env or arguments if needed).
+DEFAULT_CONFIG = {
+    "USERNAME": "postgres",
+    "PASSWORD": "postgres",
+    "HOST": "localhost",
+    "PORT": "5432",
+    "DB_NAME": "cooper",
+}
+
+
+# ---------------------------------------------------------------------------
+# Data loading
+# ---------------------------------------------------------------------------
+
+
+def load_measurements_by_cell() -> pd.DataFrame:
+    """Load measurements_by_cell from COOPER, merge train and test splits."""
+    ds = load_dataset(DATASET_REPO, "measurements_by_cell")
+    train = ds["train"].to_pandas()
+    test = ds["test"].to_pandas()
+    return pd.concat([train, test], ignore_index=True)
+
+
+def load_topology() -> pd.DataFrame:
+    """Load topology from COOPER (main split)."""
+    ds = load_dataset(DATASET_REPO, "topology")
+    return ds["main"].to_pandas()
+
+
+def load_performance_indicators_meanings() -> pd.DataFrame:
+    """Load performance_indicators_meanings from COOPER (main split)."""
+    ds = load_dataset(DATASET_REPO, "performance_indicators_meanings")
+    return ds["main"].to_pandas()
+
+
+def prepare_measurements_for_db(df: pd.DataFrame) -> pd.DataFrame:
+    """Normalize column names for PostgreSQL (dots -> underscores)."""
+    out = df.copy()
+    out.columns = out.columns.str.replace(".", "_", regex=False)
+    return out
+
+
+def prepare_performance_indicators_for_db(df: pd.DataFrame) -> pd.DataFrame:
+    """Rename 3GPP_reference to reference_3gpp for valid SQL identifier."""
+    out = df.copy()
+    out.rename(columns={"3GPP_reference": "reference_3gpp"}, inplace=True)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Optional aggregated views (for analytics; not written to DB in this script)
+# ---------------------------------------------------------------------------
+
+
+def compute_aggregations(
+    measurements: pd.DataFrame,
+    topology: pd.DataFrame,
+) -> dict[str, pd.DataFrame]:
+    """
+    Join measurements with topology and compute mean/min by cell, mean by band/site.
+    Returns a dict of DataFrames for optional export or analysis.
+    """
+    all_data = pd.merge(measurements, topology, on="LocalCellName", how="left")
+    pm_columns = [
+        c for c in measurements.columns
+        if c not in ("LocalCellName", "datetime")
+    ]
+
+    return {
+        "mean_by_cell": measurements.groupby("LocalCellName")[pm_columns].mean().reset_index(),
+        "min_by_cell": measurements.groupby("LocalCellName")[pm_columns].min().reset_index(),
+        "mean_by_band": all_data.groupby("Band")[pm_columns].mean().reset_index(),
+        "mean_by_site": all_data.groupby("SiteLabel")[pm_columns].mean().reset_index(),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Database setup and population
+# ---------------------------------------------------------------------------
+
+
+def ensure_database(engine_admin, db_name: str) -> None:
+    """Create database if it does not exist (idempotent)."""
+    with engine_admin.connect() as conn:
+        conn = conn.execution_options(isolation_level="AUTOCOMMIT")
+        result = conn.execute(
+            text("SELECT 1 FROM pg_database WHERE datname = :name"),
+            {"name": db_name},
+        )
+        if result.scalar() is None:
+            conn.execute(text(f"CREATE DATABASE {db_name} TEMPLATE template0;"))
+
+
+def get_engine(config: dict, database: str | None = None):
+    """Build SQLAlchemy engine for the given database (default: postgres)."""
+    db = database or "postgres"
+    url = (
+        f"postgresql+psycopg2://{config['USERNAME']}:{config['PASSWORD']}"
+        f"@{config['HOST']}:{config['PORT']}/{db}"
+    )
+    return create_engine(url)
+
+
+def write_tables(engine, measurements: pd.DataFrame, topology: pd.DataFrame, performance_indicators: pd.DataFrame) -> None:
+    """Write the three main DataFrames to PostgreSQL (replace existing tables)."""
+    measurements.to_sql("measurements", engine, if_exists="replace", index=False)
+    performance_indicators.to_sql(
+        "performance_indicators_meanings", engine, if_exists="replace", index=False
+    )
+    topology.to_sql("topology", engine, if_exists="replace", index=False)
+
+
+def list_public_tables(engine) -> list[tuple]:
+    """Return list of (table_name,) in the public schema."""
+    with engine.connect() as conn:
+        result = conn.execute(
+            text(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_schema = 'public';"
+            )
+        )
+        return result.fetchall()
+
+
+# ---------------------------------------------------------------------------
+# DDL: CREATE TABLE IF NOT EXISTS (run before loading data)
+# ---------------------------------------------------------------------------
+
+query_Performance_Indicators_meaning = """
+CREATE TABLE IF NOT EXISTS performance_indicators_meanings (
+    name TEXT PRIMARY KEY,
+    category TEXT,
+    description TEXT,
+    unit TEXT,
+    collection_method TEXT,
+    collection_condition TEXT,
+    measurement_entity TEXT,
+    reference_3gpp TEXT
+);
+"""
+
+query_Topology = """
+CREATE TABLE IF NOT EXISTS topology (
+    SiteLabel TEXT,
+    LocalCellName TEXT PRIMARY KEY,
+    Sector INT,
+    PCI INT,
+    DuplexMode TEXT,
+    Band TEXT,
+    dlBandwidth TEXT,
+    Azimuth NUMERIC,
+    MDT INT,
+    EDT INT,
+    HBeamwidth INT,
+    AntennaHeight NUMERIC,
+    GroundHeight INT,
+    OperationMode TEXT,
+    distance_X NUMERIC,
+    distance_Y NUMERIC
+);
+"""
+
+query_Measurements = """
+CREATE TABLE IF NOT EXISTS measurements (
+    LocalCellName TEXT REFERENCES topology(LocalCellName) ON DELETE CASCADE,
+    datetime TEXT,
+    RRC_ConnEstabSucc INT,
+    RRC_ConnEstabAtt INT,
+    RRC_Setup INT,
+    RRC_ConnMax INT,
+    MM_HoExeIntraFreqSuccOut INT,
+    MM_HoExeIntraFreqReqOut INT,
+    MM_HoExeIntraFreqSucc INT,
+    MM_HoExeIntraFreqAtt INT,
+    MM_HoExecInterFreqReqOut_Cov INT,
+    MM_HoExeInterFreqSuccOut_Cov INT,
+    MM_HoPrepInterFreqReqOut_Cov INT,
+    MM_HoExeInterFreqReqOut INT,
+    MM_HoExeInterFreqSuccOut INT,
+    MM_HoPrepInterFreqReqOut INT,
+    MM_HoPrepIntraFreqReqOut INT,
+    MM_HoFailIn_Admit INT,
+    MM_HoExeIntraFreqPrepReqIn INT,
+    MM_Redirection_Blind INT,
+    MM_Redirection_Cov INT,
+    CARR_WBCQIDist_Bin0 INT,
+    CARR_WBCQIDist_Bin1 INT,
+    CARR_WBCQIDist_Bin2 INT,
+    CARR_WBCQIDist_Bin3 INT,
+    CARR_WBCQIDist_Bin4 INT,
+    CARR_WBCQIDist_Bin5 INT,
+    CARR_WBCQIDist_Bin6 INT,
+    CARR_WBCQIDist_Bin7 INT,
+    CARR_WBCQIDist_Bin8 INT,
+    CARR_WBCQIDist_Bin9 INT,
+    CARR_WBCQIDist_Bin10 INT,
+    CARR_WBCQIDist_Bin11 INT,
+    CARR_WBCQIDist_Bin12 INT,
+    CARR_WBCQIDist_Bin13 INT,
+    CARR_WBCQIDist_Bin14 INT,
+    CARR_WBCQIDist_Bin15 INT,
+    ThpVolDl NUMERIC,
+    ThpVolUl NUMERIC,
+    ThpTimeDl NUMERIC,
+    ThpTimeUl NUMERIC,
+    CellUnavail_System INT,
+    CellUnavail_Manual INT,
+    CellUnavail_EnergySaving INT,
+    UECNTX_Est_Att INT,
+    UECNTX_Est_Succ INT,
+    UECNTX_Rem INT
+);
+"""
+
+
+def create_tables_if_not_exist(engine) -> None:
+    """Create tables from DDL if they do not exist (topology first, then measurements FK)."""
+    with engine.connect() as conn:
+        conn.execute(text(query_Performance_Indicators_meaning))
+        conn.execute(text(query_Topology))
+        conn.execute(text(query_Measurements))
+        conn.commit()
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main(config: dict | None = None) -> None:
+    config = config or DEFAULT_CONFIG
+    db_name = config["DB_NAME"]
+
+    # 1) Load and prepare data
+    measurements = load_measurements_by_cell()
+    topology = load_topology()
+    performance_indicators = load_performance_indicators_meanings()
+
+    measurements = prepare_measurements_for_db(measurements)
+    performance_indicators = prepare_performance_indicators_for_db(performance_indicators)
+
+
+    # 2) Create the database if it does not exist, then connect to it
+    engine_admin = get_engine(config, database="postgres")
+    ensure_database(engine_admin, db_name)
+    engine = get_engine(config, database=db_name)
+
+    # 3) Create tables from DDL if they do not exist
+    create_tables_if_not_exist(engine)
+
+    # 4) Load data into tables (replace existing data)
+    write_tables(engine, measurements, topology, performance_indicators)
+
+    # 5) Verify: list tables in public schema
+    tables = list_public_tables(engine)
+    print("Tables in public schema:", tables)
+
+
+if __name__ == "__main__":
+    main()

metadata/performance_indicators_meanings.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc26a56260baf17c33c13c778155ce3b056f427f74c7d9263d3f0c0e0e3a0a2d
+size 19664

metadata/topology.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ca3a92f13679b7886e2def9e696170d90ae2dce1ce0e00a5c679a9c2583f7da
+size 8211