imputeCGM 0.1.0__tar.gz

imputecgm-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: imputeCGM
+Version: 0.1.0
+Summary: CGM missing glucose imputation with MICE, ARIMA, XGBoost, and optional GAIN-based methods
+Author: Hasin Shad, Shubh Saraswat, Dr. Xiaohua Douglas Zhang
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: statsmodels
+Requires-Dist: xgboost
+Requires-Dist: rpy2
+Provides-Extra: gain
+Requires-Dist: tensorflow; extra == "gain"
+
+# imputeCGM
+
+`imputeCGM` is a Python package for imputing missing glucose values in continuous glucose monitoring (CGM) data.
+
+The package supports:
+
+- Automatic method selection: MICE+ARIMA when missingness is low and MICE+XGBoost when missingness is higher
+- Forced MICE+ARIMA
+- Forced MICE+XGBoost
+- GAIN-only imputation
+- GAIN+ARIMA
+- GAIN+XGBoost
+
+## Installation
+
+For MICE, ARIMA, and XGBoost methods:
+
+```bash
+python -m pip install -e .
+```
+
+For GAIN-based methods, install the optional TensorFlow dependency:
+
+```bash
+python -m pip install -e .[gain]
+```
+
+## Python usage
+
+```python
+from imputeCGM import impute_cgm
+
+out = impute_cgm(
+    df,
+    timestamp_col="timestamp",
+    subjectid_col="subjectid",
+    glucose_col="glucose_value",
+    interval_minutes=5,
+    time_gap_tolerance_minutes=3,
+    model_method="auto",
+)
+```
+
+Valid `model_method` values are:
+
+```text
+auto
+mice_arima
+mice_xgboost
+gain
+gain_arima
+gain_xgboost
+```
+
+## CLI usage
+
+```bash
+imputeCGM --input ExampleData.csv --output ExampleData_imputed.csv --model-method auto
+```

imputecgm-0.1.0/README.md

@@ -0,0 +1,59 @@
+# imputeCGM
+
+`imputeCGM` is a Python package for imputing missing glucose values in continuous glucose monitoring (CGM) data.
+
+The package supports:
+
+- Automatic method selection: MICE+ARIMA when missingness is low and MICE+XGBoost when missingness is higher
+- Forced MICE+ARIMA
+- Forced MICE+XGBoost
+- GAIN-only imputation
+- GAIN+ARIMA
+- GAIN+XGBoost
+
+## Installation
+
+For MICE, ARIMA, and XGBoost methods:
+
+```bash
+python -m pip install -e .
+```
+
+For GAIN-based methods, install the optional TensorFlow dependency:
+
+```bash
+python -m pip install -e .[gain]
+```
+
+## Python usage
+
+```python
+from imputeCGM import impute_cgm
+
+out = impute_cgm(
+    df,
+    timestamp_col="timestamp",
+    subjectid_col="subjectid",
+    glucose_col="glucose_value",
+    interval_minutes=5,
+    time_gap_tolerance_minutes=3,
+    model_method="auto",
+)
+```
+
+Valid `model_method` values are:
+
+```text
+auto
+mice_arima
+mice_xgboost
+gain
+gain_arima
+gain_xgboost
+```
+
+## CLI usage
+
+```bash
+imputeCGM --input ExampleData.csv --output ExampleData_imputed.csv --model-method auto
+```

imputecgm-0.1.0/imputeCGM/__init__.py

@@ -0,0 +1,3 @@
+from .pipeline import impute_cgm
+
+__all__ = ["impute_cgm"]

imputecgm-0.1.0/imputeCGM/cli.py

@@ -0,0 +1,49 @@
+import argparse
+import pandas as pd
+from .pipeline import impute_cgm
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--input", required=True)
+    p.add_argument("--output", required=True)
+    p.add_argument("--timestamp-col", default="timestamp")
+    p.add_argument("--subjectid-col", default="subjectid")
+    p.add_argument("--glucose-col", default="glucose_value")
+    p.add_argument("--interval", type=int, default=5)
+    p.add_argument("--arima-threshold", type=float, default=0.05)
+    p.add_argument("--time-gap-tolerance", type=int, default=3)
+    p.add_argument(
+        "--model-method",
+        default="auto",
+        choices=["auto", "mice_arima", "mice_xgboost", "gain", "gain_arima", "gain_xgboost"],
+    )
+    p.add_argument("--gain-epochs", type=int, default=500)
+    p.add_argument("--gain-batch-size", type=int, default=128)
+    p.add_argument("--gain-hint-rate", type=float, default=0.90)
+    p.add_argument("--gain-alpha", type=float, default=10.0)
+    p.add_argument("--gain-learning-rate", type=float, default=1e-3)
+    args = p.parse_args()
+
+    df = pd.read_csv(args.input)
+
+    out = impute_cgm(
+        df=df,
+        timestamp_col=args.timestamp_col,
+        subjectid_col=args.subjectid_col,
+        glucose_col=args.glucose_col,
+        interval_minutes=args.interval,
+        time_gap_tolerance_minutes=args.time_gap_tolerance,
+        use_arima_if_missing_leq=args.arima_threshold,
+        model_method=args.model_method,
+        gain_epochs=args.gain_epochs,
+        gain_batch_size=args.gain_batch_size,
+        gain_hint_rate=args.gain_hint_rate,
+        gain_alpha=args.gain_alpha,
+        gain_learning_rate=args.gain_learning_rate,
+    )
+
+    out.to_csv(args.output, index=False)
+    print("Saved:", args.output)
+    print("Chosen method:", out["imputation_method"].iloc[0])
+    print("Missing rate:", out["missing_rate"].iloc[0])

imputecgm-0.1.0/imputeCGM/features.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+
+def encode_sex(df: pd.DataFrame, col: str = "SEX") -> pd.DataFrame:
+    out = df.copy()
+    if col in out.columns:
+        s = out[col].astype(str).str.strip().str.upper()
+        out[col] = s.map({"M": 1, "MALE": 1, "1": 1, "F": 0, "FEMALE": 0, "0": 0})
+    return out
+
+
+def add_lag_features(
+    df: pd.DataFrame,
+    target_col: str = "glucose_value",
+    id_col: str = "subjectid",
+    time_col: str = "TimeSeries",
+    lag_k=(1, 2, 3),
+    roll_window: int = 3
+) -> pd.DataFrame:
+    out = df.sort_values([id_col, time_col]).reset_index(drop=True).copy()
+
+    for k in lag_k:
+        out[f"lag{k}"] = out.groupby(id_col)[target_col].shift(k)
+
+    s = out.groupby(id_col)[target_col].shift(1)
+    out["rollmean"] = (
+        s.groupby(out[id_col]).rolling(roll_window).mean().reset_index(level=0, drop=True)
+    )
+
+    return out

imputecgm-0.1.0/imputeCGM/gain.py

@@ -0,0 +1,156 @@
+import random
+import numpy as np
+
+
+def set_all_seeds(seed: int = 42) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    try:
+        import tensorflow as tf
+        tf.random.set_seed(seed)
+    except Exception:
+        pass
+
+
+def minmax_normalize(data_nan):
+    data_nan = np.asarray(data_nan, dtype=np.float32)
+    col_min = np.nanmin(data_nan, axis=0)
+    col_max = np.nanmax(data_nan, axis=0)
+
+    col_min = np.where(np.isfinite(col_min), col_min, 0.0)
+    col_max = np.where(np.isfinite(col_max), col_max, 1.0)
+    denom = col_max - col_min
+    denom = np.where(np.abs(denom) < 1e-8, 1.0, denom)
+
+    data_norm = (data_nan - col_min) / denom
+    return data_norm.astype(np.float32), col_min.astype(np.float32), denom.astype(np.float32)
+
+
+def minmax_denormalize(data_norm, col_min, denom):
+    return data_norm * denom + col_min
+
+
+def _make_mlp(input_dim, output_dim, hidden_dim=128, output_activation="sigmoid", name="mlp"):
+    try:
+        from tensorflow.keras import layers, Model
+    except Exception as exc:
+        raise ImportError(
+            "GAIN methods require TensorFlow. Install this package with: "
+            "python -m pip install -e .[gain]"
+        ) from exc
+
+    inp = layers.Input(shape=(input_dim,))
+    x = layers.Dense(hidden_dim, activation="relu")(inp)
+    x = layers.Dense(hidden_dim, activation="relu")(x)
+    out = layers.Dense(output_dim, activation=output_activation)(x)
+    return Model(inp, out, name=name)
+
+
+def gain_impute(
+    data_nan,
+    epochs: int = 500,
+    batch_size: int = 128,
+    hint_rate: float = 0.90,
+    alpha: float = 10.0,
+    learning_rate: float = 1e-3,
+    seed: int = 42,
+    verbose: bool = False,
+):
+    """
+    GAIN imputation for numeric tabular data.
+
+    Parameters
+    ----------
+    data_nan:
+        Numeric matrix with missing entries represented as np.nan.
+
+    Returns
+    -------
+    np.ndarray
+        Full imputed matrix in the original scale. Observed values are preserved.
+    """
+    try:
+        import tensorflow as tf
+    except Exception as exc:
+        raise ImportError(
+            "GAIN methods require TensorFlow. Install this package with: "
+            "python -m pip install -e .[gain]"
+        ) from exc
+
+    set_all_seeds(seed)
+
+    data_norm, col_min, denom = minmax_normalize(data_nan)
+    mask = (~np.isnan(data_norm)).astype(np.float32)
+    x_filled = np.nan_to_num(data_norm, nan=0.0).astype(np.float32)
+
+    n, d = x_filled.shape
+    generator = _make_mlp(
+        input_dim=2 * d,
+        output_dim=d,
+        hidden_dim=128,
+        output_activation="sigmoid",
+        name="gain_generator",
+    )
+    discriminator = _make_mlp(
+        input_dim=2 * d,
+        output_dim=d,
+        hidden_dim=128,
+        output_activation="sigmoid",
+        name="gain_discriminator",
+    )
+
+    g_opt = tf.keras.optimizers.Adam(learning_rate)
+    d_opt = tf.keras.optimizers.Adam(learning_rate)
+    eps = 1e-8
+
+    for epoch in range(int(epochs)):
+        batch_idx = np.random.choice(n, size=min(batch_size, n), replace=n < batch_size)
+        x_mb = tf.convert_to_tensor(x_filled[batch_idx], dtype=tf.float32)
+        m_mb = tf.convert_to_tensor(mask[batch_idx], dtype=tf.float32)
+
+        z_mb = tf.random.uniform(shape=tf.shape(x_mb), minval=0.0, maxval=0.01, dtype=tf.float32)
+        x_hat = x_mb * m_mb + z_mb * (1.0 - m_mb)
+
+        h_binary = tf.cast(tf.random.uniform(shape=tf.shape(m_mb)) < hint_rate, tf.float32)
+        h_mb = m_mb * h_binary + 0.5 * (1.0 - h_binary)
+
+        with tf.GradientTape() as d_tape:
+            g_sample = generator(tf.concat([x_hat, m_mb], axis=1), training=True)
+            hat_x = x_hat * m_mb + g_sample * (1.0 - m_mb)
+            d_prob = discriminator(tf.concat([hat_x, h_mb], axis=1), training=True)
+            d_loss = -tf.reduce_mean(
+                m_mb * tf.math.log(d_prob + eps)
+                + (1.0 - m_mb) * tf.math.log(1.0 - d_prob + eps)
+            )
+        d_grads = d_tape.gradient(d_loss, discriminator.trainable_variables)
+        d_opt.apply_gradients(zip(d_grads, discriminator.trainable_variables))
+
+        with tf.GradientTape() as g_tape:
+            g_sample = generator(tf.concat([x_hat, m_mb], axis=1), training=True)
+            hat_x = x_hat * m_mb + g_sample * (1.0 - m_mb)
+            d_prob = discriminator(tf.concat([hat_x, h_mb], axis=1), training=False)
+
+            g_loss_adv = -tf.reduce_mean((1.0 - m_mb) * tf.math.log(d_prob + eps))
+            mse_num = tf.reduce_sum((m_mb * x_mb - m_mb * g_sample) ** 2)
+            mse_den = tf.reduce_sum(m_mb) + eps
+            g_loss_mse = mse_num / mse_den
+            g_loss = g_loss_adv + alpha * g_loss_mse
+        g_grads = g_tape.gradient(g_loss, generator.trainable_variables)
+        g_opt.apply_gradients(zip(g_grads, generator.trainable_variables))
+
+        if verbose and ((epoch + 1) % 100 == 0 or epoch == 0):
+            print(
+                f"GAIN epoch {epoch + 1:4d}/{epochs} | "
+                f"D_loss={float(d_loss):.5f} | G_loss={float(g_loss):.5f}"
+            )
+
+    x_tensor = tf.convert_to_tensor(x_filled, dtype=tf.float32)
+    m_tensor = tf.convert_to_tensor(mask, dtype=tf.float32)
+    z_all = tf.random.uniform(shape=tf.shape(x_tensor), minval=0.0, maxval=0.01, dtype=tf.float32)
+    x_hat_all = x_tensor * m_tensor + z_all * (1.0 - m_tensor)
+    g_all = generator(tf.concat([x_hat_all, m_tensor], axis=1), training=False).numpy()
+
+    observed_norm = np.nan_to_num(data_norm, nan=0.0).astype(np.float32)
+    imputed_norm = mask * observed_norm + (1.0 - mask) * g_all
+    imputed = minmax_denormalize(imputed_norm, col_min, denom)
+    return imputed.astype(float)

imputecgm-0.1.0/imputeCGM/gaps.py

@@ -0,0 +1,5 @@
+import pandas as pd
+
+
+def missing_rate(df: pd.DataFrame, target_col: str = "glucose_value") -> float:
+    return float(df[target_col].isna().mean())

imputecgm-0.1.0/imputeCGM/impute.py

@@ -0,0 +1,168 @@
+import numpy as np
+import pandas as pd
+from sklearn.experimental import enable_iterative_imputer  # noqa: F401
+from sklearn.impute import IterativeImputer
+
+from .models import arima_segmentwise_on_mice, fit_xgb_predict_missing
+
+
+VALID_MODEL_METHODS = {
+    "auto",
+    "mice_arima",
+    "mice_xgboost",
+    "gain",
+    "gain_arima",
+    "gain_xgboost",
+}
+
+
+def _run_mice_matrix(imp_df: pd.DataFrame):
+    imp_mat = IterativeImputer(
+        random_state=42,
+        max_iter=10,
+    ).fit_transform(imp_df.to_numpy(dtype=float))
+
+    y_mice_full = imp_mat[:, 0]
+    X_imp = imp_mat[:, 1:]
+    return y_mice_full, X_imp
+
+
+def _run_gain_matrix(
+    imp_df: pd.DataFrame,
+    gain_epochs: int = 500,
+    gain_batch_size: int = 128,
+    gain_hint_rate: float = 0.90,
+    gain_alpha: float = 10.0,
+    gain_learning_rate: float = 1e-3,
+    gain_seed: int = 42,
+    gain_verbose: bool = False,
+):
+    from .gain import gain_impute
+
+    gain_mat = gain_impute(
+        data_nan=imp_df.to_numpy(dtype=np.float32),
+        epochs=gain_epochs,
+        batch_size=gain_batch_size,
+        hint_rate=gain_hint_rate,
+        alpha=gain_alpha,
+        learning_rate=gain_learning_rate,
+        seed=gain_seed,
+        verbose=gain_verbose,
+    )
+
+    y_gain_full = gain_mat[:, 0]
+    X_imp = gain_mat[:, 1:]
+    return y_gain_full, X_imp
+
+
+def impute_values(
+    df: pd.DataFrame,
+    id_col: str = "subjectid",
+    time_col: str = "TimeSeries",
+    target_col: str = "glucose_value",
+    feature_cols=None,
+    use_arima_if_missing_leq: float = 0.05,
+    model_method: str = "auto",
+    gain_epochs: int = 500,
+    gain_batch_size: int = 128,
+    gain_hint_rate: float = 0.90,
+    gain_alpha: float = 10.0,
+    gain_learning_rate: float = 1e-3,
+    gain_seed: int = 42,
+    gain_verbose: bool = False,
+) -> pd.DataFrame:
+    """
+    Impute missing CGM glucose values.
+
+    model_method options:
+        auto          -> MICE+ARIMA if missing rate <= threshold; otherwise MICE+XGBoost
+        mice_arima    -> force MICE+ARIMA
+        mice_xgboost  -> force MICE+XGBoost
+        gain          -> force GAIN-only imputation
+        gain_arima    -> use GAIN initial imputation, then ARIMA on missing segments
+        gain_xgboost  -> use GAIN-completed features, then XGBoost for missing glucose
+    """
+    model_method = str(model_method).lower().strip()
+    if model_method not in VALID_MODEL_METHODS:
+        raise ValueError(
+            f"Unknown model_method '{model_method}'. Valid options are: "
+            + ", ".join(sorted(VALID_MODEL_METHODS))
+        )
+
+    out = df.sort_values([id_col, time_col]).reset_index(drop=True).copy()
+
+    if feature_cols is None:
+        feature_cols = [c for c in out.columns if c != target_col]
+
+    mask_pos = out[target_col].isna().to_numpy()
+    miss_rate = float(mask_pos.mean())
+
+    if not np.any(mask_pos):
+        out["imputed_glucose_value"] = out[target_col].to_numpy(dtype=float)
+        out["imputation_method"] = "No missing glucose values"
+        out["missing_rate"] = miss_rate
+        return out
+
+    imp_df = out[[target_col] + feature_cols].copy()
+
+    if model_method == "auto":
+        resolved_method = "mice_arima" if miss_rate <= use_arima_if_missing_leq else "mice_xgboost"
+    else:
+        resolved_method = model_method
+
+    if resolved_method.startswith("mice"):
+        y_base_full, X_imp = _run_mice_matrix(imp_df)
+        base_label = "MICE"
+    else:
+        y_base_full, X_imp = _run_gain_matrix(
+            imp_df,
+            gain_epochs=gain_epochs,
+            gain_batch_size=gain_batch_size,
+            gain_hint_rate=gain_hint_rate,
+            gain_alpha=gain_alpha,
+            gain_learning_rate=gain_learning_rate,
+            gain_seed=gain_seed,
+            gain_verbose=gain_verbose,
+        )
+        base_label = "GAIN"
+
+    y_final = np.asarray(y_base_full, dtype=float).copy()
+
+    if resolved_method in {"mice_arima", "gain_arima"}:
+        y_final = arima_segmentwise_on_mice(
+            df_sorted=out,
+            id_col=id_col,
+            y_mice_full=y_base_full,
+            mask_pos=mask_pos,
+            order=(4, 1, 0),
+            min_history=20,
+        )
+        method = f"{base_label}+ARIMA"
+
+    elif resolved_method in {"mice_xgboost", "gain_xgboost"}:
+        train_idx = ~mask_pos
+        X_train = X_imp[train_idx]
+        y_train = out.loc[train_idx, target_col].to_numpy(dtype=float)
+        X_missing = X_imp[mask_pos]
+
+        y_pred_missing = fit_xgb_predict_missing(
+            X_train,
+            y_train,
+            X_missing,
+        )
+
+        y_final[mask_pos] = y_pred_missing
+        method = f"{base_label}+XGBoost"
+
+    elif resolved_method == "gain":
+        method = "GAIN"
+
+    else:
+        raise RuntimeError(f"Could not resolve imputation method: {resolved_method}")
+
+    out["imputed_glucose_value"] = y_final
+    out["imputation_method"] = method
+    out["missing_rate"] = miss_rate
+    out["model_method"] = resolved_method
+
+    return out

imputecgm-0.1.0/imputeCGM/models.py

@@ -0,0 +1,76 @@
+import numpy as np
+from statsmodels.tsa.arima.model import ARIMA
+import xgboost as xgb
+
+
+XGB_PARAMS = dict(
+    n_estimators=300,
+    learning_rate=0.05,
+    max_depth=6,
+    subsample=0.8,
+    colsample_bytree=0.8,
+    reg_lambda=1.0,
+    n_jobs=1,
+    random_state=42,
+    tree_method="hist",
+    eval_metric="rmse",
+)
+
+
+def _segments(mask: np.ndarray):
+    segs = []
+    i = 0
+    n = len(mask)
+    while i < n:
+        if mask[i]:
+            j = i
+            while j + 1 < n and mask[j + 1]:
+                j += 1
+            segs.append((i, j))
+            i = j + 1
+        else:
+            i += 1
+    return segs
+
+
+def arima_segmentwise_on_mice(
+    df_sorted,
+    id_col: str,
+    y_mice_full: np.ndarray,
+    mask_pos: np.ndarray,
+    order=(4, 1, 0),
+    min_history: int = 20
+) -> np.ndarray:
+    pred_full = np.asarray(y_mice_full, dtype=float).copy()
+    mask_pos = np.asarray(mask_pos, dtype=bool)
+
+    for _, grp in df_sorted.groupby(id_col, sort=False):
+        idx = grp.index.to_numpy()
+        local_mask = mask_pos[idx]
+        segs = _segments(local_mask)
+        if not segs:
+            continue
+
+        local_series = pred_full[idx]
+
+        for s, e in segs:
+            block_len = e - s + 1
+            history = local_series[:s]
+            if len(history) < min_history:
+                continue
+            if not np.all(np.isfinite(history)):
+                continue
+            try:
+                fit = ARIMA(history, order=order).fit()
+                fcst = fit.forecast(steps=block_len)
+                pred_full[idx[s:e+1]] = np.asarray(fcst, dtype=float)
+            except Exception:
+                continue
+
+    return pred_full
+
+
+def fit_xgb_predict_missing(X_train, y_train, X_missing) -> np.ndarray:
+    model = xgb.XGBRegressor(**XGB_PARAMS)
+    model.fit(X_train, y_train, verbose=False)
+    return model.predict(X_missing)

imputecgm-0.1.0/imputeCGM/pipeline.py

@@ -0,0 +1,241 @@
+import numpy as np
+import pandas as pd
+
+from .timeseries_r import add_timeseries_column
+from .features import encode_sex, add_lag_features
+from .impute import impute_values
+
+
+def insert_missing_timeseries_rows(
+    df: pd.DataFrame,
+    id_col: str = "subjectid",
+    time_col: str = "TimeSeries",
+    timestamp_col: str = "timestamp",
+    glucose_col: str = "glucose_value",
+    interval_minutes: int = 5,
+    tolerance_minutes: int = 3,
+    static_cols: list[str] | None = None,
+) -> pd.DataFrame:
+    """
+    Insert synthetic rows when TimeSeries gaps exceed the expected interval.
+
+    Examples with interval=5 and tolerance=3:
+
+        200, 205, 220
+        -> 200, 205, 210, 215, 220
+
+        200, 205, 210, 224
+        -> 200, 205, 210, 215, 220, 224
+
+        200, 205, 210, 223
+        -> 200, 205, 210, 215, 220, 223
+
+    The observed row is preserved. Inserted rows receive missing glucose values
+    and inherit static subject-level fields such as AGE, SEX, and HBA1C.
+    """
+
+    if static_cols is None:
+        static_cols = ["AGE", "SEX", "HBA1C"]
+
+    required_cols = [id_col, time_col, glucose_col]
+
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' was not found.")
+
+    out = df.copy()
+
+    out[time_col] = pd.to_numeric(out[time_col], errors="coerce")
+
+    if out[time_col].isna().any():
+        raise ValueError(
+            f"Some values in '{time_col}' could not be converted to numeric."
+        )
+
+    expanded_groups = []
+
+    for subject_id, group in out.groupby(id_col, sort=False):
+        group = group.sort_values(time_col).reset_index(drop=True).copy()
+
+        expanded_rows = []
+
+        for i in range(len(group)):
+            current_row = group.iloc[i].copy()
+            current_row["inserted_missing_row"] = False
+            expanded_rows.append(current_row)
+
+            if i == len(group) - 1:
+                continue
+
+            current_ts = float(group.loc[i, time_col])
+            next_ts = float(group.loc[i + 1, time_col])
+
+            candidate_ts = current_ts + interval_minutes
+
+            while candidate_ts < next_ts - tolerance_minutes:
+                new_row = pd.Series(index=group.columns, dtype="object")
+
+                new_row[id_col] = subject_id
+                new_row[time_col] = candidate_ts
+                new_row[glucose_col] = np.nan
+                new_row["inserted_missing_row"] = True
+
+                for col in static_cols:
+                    if col in group.columns:
+                        new_row[col] = current_row[col]
+
+                if timestamp_col in group.columns:
+                    current_timestamp = pd.to_datetime(
+                        current_row[timestamp_col],
+                        errors="coerce",
+                    )
+
+                    if pd.notna(current_timestamp):
+                        offset_minutes = candidate_ts - current_ts
+
+                        new_row[timestamp_col] = (
+                            current_timestamp
+                            + pd.to_timedelta(offset_minutes, unit="m")
+                        )
+                    else:
+                        new_row[timestamp_col] = pd.NaT
+
+                expanded_rows.append(new_row)
+                candidate_ts += interval_minutes
+
+        expanded_group = pd.DataFrame(expanded_rows)
+        expanded_groups.append(expanded_group)
+
+    expanded = pd.concat(expanded_groups, ignore_index=True)
+
+    expanded = expanded.sort_values([id_col, time_col]).reset_index(drop=True)
+
+    if "TimeDifferenceMinutes" in expanded.columns:
+        expanded["TimeDifferenceMinutes"] = (
+            expanded.groupby(id_col)[time_col]
+            .diff()
+            .fillna(0)
+        )
+
+    expanded["inserted_missing_row"] = (
+        expanded["inserted_missing_row"]
+        .fillna(False)
+        .astype(bool)
+    )
+
+    return expanded
+
+
+def impute_cgm(
+    df: pd.DataFrame,
+    timestamp_col: str = "timestamp",
+    subjectid_col: str = "subjectid",
+    glucose_col: str = "glucose_value",
+    interval_minutes: int = 5,
+    time_gap_tolerance_minutes: int = 3,
+    use_arima_if_missing_leq: float = 0.05,
+    model_method: str = "auto",
+    gain_epochs: int = 500,
+    gain_batch_size: int = 128,
+    gain_hint_rate: float = 0.90,
+    gain_alpha: float = 10.0,
+    gain_learning_rate: float = 1e-3,
+    gain_seed: int = 42,
+    gain_verbose: bool = False,
+) -> pd.DataFrame:
+    """
+    Full CGM missing-glucose imputation pipeline.
+
+    Steps:
+        1. Convert timestamp column into TimeSeries.
+        2. Encode SEX as numeric.
+        3. Insert missing time rows when CGM time gaps exceed the expected interval.
+        4. Convert modeling columns to numeric.
+        5. Create lag and rolling mean features.
+        6. Run the selected imputation method: automatic MICE-based selection, forced MICE+ARIMA, forced MICE+XGBoost, GAIN, GAIN+ARIMA, or GAIN+XGBoost.
+    """
+
+    out = df.copy()
+
+    # convert timestamp into TimeSeries
+    out = add_timeseries_column(
+        out,
+        ts_col=timestamp_col,
+        id_col=subjectid_col,
+        interval_minutes=interval_minutes,
+    )
+
+    #m-1, f-2
+    out = encode_sex(out, "SEX")
+
+    out = insert_missing_timeseries_rows(
+    out,
+    id_col=subjectid_col,
+    time_col="TimeSeries",
+    timestamp_col=timestamp_col,
+    glucose_col=glucose_col,
+    interval_minutes=interval_minutes,
+    tolerance_minutes=time_gap_tolerance_minutes,
+    static_cols=["AGE", "SEX", "HBA1C"],
+)
+
+
+    numeric_cols = [
+        glucose_col,
+        "TimeSeries",
+        "TimeDifferenceMinutes",
+        subjectid_col,
+        "AGE",
+        "HBA1C",
+        "SEX",
+    ]
+
+    for col in numeric_cols:
+        if col in out.columns:
+            out[col] = pd.to_numeric(out[col], errors="coerce")
+
+    # create lag and rolling features.
+    out = add_lag_features(
+        out,
+        target_col=glucose_col,
+        id_col=subjectid_col,
+        time_col="TimeSeries",
+        lag_k=(1, 2, 3),
+        roll_window=3,
+    )
+
+    # select model features.
+    feature_cols = [
+        "TimeSeries",
+        "TimeDifferenceMinutes",
+        subjectid_col,
+        "AGE",
+        "SEX",
+        "HBA1C",
+        "lag1",
+        "lag2",
+        "lag3",
+        "rollmean",
+    ]
+
+    feature_cols = [col for col in feature_cols if col in out.columns]
+
+    #  Run imputation
+    out = impute_values(
+        out,
+        id_col=subjectid_col,
+        time_col="TimeSeries",
+        target_col=glucose_col,
+        feature_cols=feature_cols,
+        use_arima_if_missing_leq=use_arima_if_missing_leq,
+        model_method=model_method,
+        gain_epochs=gain_epochs,
+        gain_batch_size=gain_batch_size,
+        gain_hint_rate=gain_hint_rate,
+        gain_alpha=gain_alpha,
+        gain_learning_rate=gain_learning_rate,
+        gain_seed=gain_seed,
+        gain_verbose=gain_verbose,
+    )
+
+    return out

imputecgm-0.1.0/imputeCGM/timeseries_r.py

@@ -0,0 +1,191 @@
+import pandas as pd
+import numpy as np
+
+
+def insert_missing_timeseries_rows(
+    df: pd.DataFrame,
+    id_col: str = "subjectid",
+    time_col: str = "TimeSeries",
+    timestamp_col: str = "timestamp",
+    glucose_col: str = "glucose_value",
+    interval_minutes: int = 5,
+    tolerance_minutes: int = 3,
+    static_cols: list[str] | None = None,
+) -> pd.DataFrame:
+    """
+    Insert synthetic rows when TimeSeries gaps exceed the expected interval.
+
+    Examples with interval=5 and tolerance=3:
+        200, 205, 220      -> 200, 205, 210, 215, 220
+        200, 205, 210, 224 -> 200, 205, 210, 215, 220, 224
+        200, 205, 210, 223 -> 200, 205, 210, 215, 220, 223
+
+    The actual observed TimeSeries value is preserved.
+    Inserted rows receive missing glucose values and inherit static subject fields.
+    """
+
+    if static_cols is None:
+        static_cols = ["AGE", "SEX", "HBA1C"]
+
+    required_cols = [id_col, time_col, glucose_col]
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' was not found.")
+
+    out = df.copy()
+    out[time_col] = pd.to_numeric(out[time_col], errors="coerce")
+
+    if out[time_col].isna().any():
+        raise ValueError(f"Some values in '{time_col}' could not be converted to numeric.")
+
+    expanded_groups = []
+
+    for subject_id, group in out.groupby(id_col, sort=False):
+        group = group.sort_values(time_col).reset_index(drop=True).copy()
+        expanded_rows = []
+
+        for i in range(len(group)):
+            current_row = group.iloc[i].copy()
+            current_row["inserted_missing_row"] = False
+            expanded_rows.append(current_row)
+
+            if i == len(group) - 1:
+                continue
+
+            current_ts = float(group.loc[i, time_col])
+            next_ts = float(group.loc[i + 1, time_col])
+
+            candidate_ts = current_ts + interval_minutes
+
+            while candidate_ts < next_ts - tolerance_minutes:
+                new_row = pd.Series(index=group.columns, dtype="object")
+
+                new_row[id_col] = subject_id
+                new_row[time_col] = candidate_ts
+                new_row[glucose_col] = np.nan
+                new_row["inserted_missing_row"] = True
+
+                for col in static_cols:
+                    if col in group.columns:
+                        new_row[col] = current_row[col]
+
+                if timestamp_col in group.columns:
+                    current_timestamp = pd.to_datetime(
+                        current_row[timestamp_col],
+                        errors="coerce",
+                    )
+
+                    if pd.notna(current_timestamp):
+                        offset_minutes = candidate_ts - current_ts
+                        new_row[timestamp_col] = current_timestamp + pd.to_timedelta(
+                            offset_minutes,
+                            unit="m",
+                        )
+                    else:
+                        new_row[timestamp_col] = pd.NaT
+
+                expanded_rows.append(new_row)
+                candidate_ts += interval_minutes
+
+        expanded_groups.append(pd.DataFrame(expanded_rows))
+
+    expanded = pd.concat(expanded_groups, ignore_index=True)
+    expanded = expanded.sort_values([id_col, time_col]).reset_index(drop=True)
+
+    if "TimeDifferenceMinutes" in expanded.columns:
+        expanded["TimeDifferenceMinutes"] = (
+            expanded.groupby(id_col)[time_col]
+            .diff()
+            .fillna(0)
+        )
+
+    expanded["inserted_missing_row"] = expanded["inserted_missing_row"].fillna(False)
+
+    return expanded
+
+
+def _timeseries_fallback_python(df: pd.DataFrame, ts_col: str, id_col: str) -> pd.DataFrame:
+    out = df.copy()
+    out["_ts_parsed"] = pd.to_datetime(out[ts_col], errors="coerce")
+    if out["_ts_parsed"].isna().any():
+        raise ValueError("Some timestamp values could not be parsed.")
+
+    if id_col in out.columns:
+        out = out.sort_values([id_col, "_ts_parsed"]).reset_index(drop=True)
+        out["TimeSeries"] = (
+            out.groupby(id_col)["_ts_parsed"]
+               .transform(lambda s: (s - s.min()).dt.total_seconds() / 60.0)
+        )
+    else:
+        out = out.sort_values("_ts_parsed").reset_index(drop=True)
+        out["TimeSeries"] = (out["_ts_parsed"] - out["_ts_parsed"].min()).dt.total_seconds() / 60.0
+
+    return out.drop(columns=["_ts_parsed"])
+
+
+def add_timeseries_column(
+    df: pd.DataFrame,
+    ts_col: str = "timestamp",
+    id_col: str = "subjectid",
+    interval_minutes: int = 5,
+    prefer_r: bool = False
+) -> pd.DataFrame:
+    if ts_col not in df.columns:
+        raise ValueError(f"Column '{ts_col}' was not found.")
+
+    # If TimeSeries already exists, do nothing
+    if "TimeSeries" in df.columns and df["TimeSeries"].notna().any():
+        return df
+
+    if not prefer_r:
+        return _timeseries_fallback_python(df, ts_col, id_col)
+
+    # Try CGManalyzer via rpy2; if it fails, fall back
+    try:
+        import rpy2.robjects as ro
+        from rpy2.robjects import FloatVector
+        from rpy2.robjects.packages import importr, isinstalled
+
+        if not isinstalled("CGManalyzer"):
+            raise ImportError("CGManalyzer is not installed in R; using Python fallback.")
+
+        importr("CGManalyzer")
+        equalInterval_fn = ro.r["equalInterval.fn"]
+
+        out = df.copy()
+        out["_ts_parsed"] = pd.to_datetime(out[ts_col], errors="coerce")
+        if out["_ts_parsed"].isna().any():
+            raise ValueError("Some timestamp values could not be parsed.")
+
+        def _add(group: pd.DataFrame) -> pd.DataFrame:
+            group = group.copy()
+            original_index = group.index
+            group = group.sort_values("_ts_parsed")
+
+            first_time = group["_ts_parsed"].min()
+            x_minutes = (group["_ts_parsed"] - first_time).dt.total_seconds() / 60.0
+            dummy_y = list(range(len(group)))
+
+            r_result = equalInterval_fn(
+                x=FloatVector(x_minutes.to_numpy()),
+                y=FloatVector(dummy_y),
+                Interval=int(interval_minutes)
+            )
+            r_times = list(ro.r["as.data.frame"](r_result).rx2(1))
+
+            if len(r_times) >= len(group):
+                group["TimeSeries"] = r_times[:len(group)]
+            else:
+                group["TimeSeries"] = x_minutes.to_numpy()
+
+            return group.loc[original_index]
+
+        if id_col in out.columns:
+            out = out.groupby(id_col, group_keys=False).apply(_add)
+        else:
+            out = _add(out)
+
+        return out.drop(columns=["_ts_parsed"])
+
+    except Exception:
+        return _timeseries_fallback_python(df, ts_col, id_col)

imputecgm-0.1.0/imputeCGM.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: imputeCGM
+Version: 0.1.0
+Summary: CGM missing glucose imputation with MICE, ARIMA, XGBoost, and optional GAIN-based methods
+Author: Hasin Shad, Shubh Saraswat, Dr. Xiaohua Douglas Zhang
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: statsmodels
+Requires-Dist: xgboost
+Requires-Dist: rpy2
+Provides-Extra: gain
+Requires-Dist: tensorflow; extra == "gain"
+
+# imputeCGM
+
+`imputeCGM` is a Python package for imputing missing glucose values in continuous glucose monitoring (CGM) data.
+
+The package supports:
+
+- Automatic method selection: MICE+ARIMA when missingness is low and MICE+XGBoost when missingness is higher
+- Forced MICE+ARIMA
+- Forced MICE+XGBoost
+- GAIN-only imputation
+- GAIN+ARIMA
+- GAIN+XGBoost
+
+## Installation
+
+For MICE, ARIMA, and XGBoost methods:
+
+```bash
+python -m pip install -e .
+```
+
+For GAIN-based methods, install the optional TensorFlow dependency:
+
+```bash
+python -m pip install -e .[gain]
+```
+
+## Python usage
+
+```python
+from imputeCGM import impute_cgm
+
+out = impute_cgm(
+    df,
+    timestamp_col="timestamp",
+    subjectid_col="subjectid",
+    glucose_col="glucose_value",
+    interval_minutes=5,
+    time_gap_tolerance_minutes=3,
+    model_method="auto",
+)
+```
+
+Valid `model_method` values are:
+
+```text
+auto
+mice_arima
+mice_xgboost
+gain
+gain_arima
+gain_xgboost
+```
+
+## CLI usage
+
+```bash
+imputeCGM --input ExampleData.csv --output ExampleData_imputed.csv --model-method auto
+```

imputecgm-0.1.0/imputeCGM.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+imputeCGM/__init__.py
+imputeCGM/cli.py
+imputeCGM/features.py
+imputeCGM/gain.py
+imputeCGM/gaps.py
+imputeCGM/impute.py
+imputeCGM/models.py
+imputeCGM/pipeline.py
+imputeCGM/timeseries_r.py
+imputeCGM.egg-info/PKG-INFO
+imputeCGM.egg-info/SOURCES.txt
+imputeCGM.egg-info/dependency_links.txt
+imputeCGM.egg-info/entry_points.txt
+imputeCGM.egg-info/requires.txt
+imputeCGM.egg-info/top_level.txt

imputecgm-0.1.0/imputeCGM.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

imputecgm-0.1.0/imputeCGM.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imputeCGM = imputeCGM.cli:main

imputecgm-0.1.0/imputeCGM.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy
+pandas
+scikit-learn
+statsmodels
+xgboost
+rpy2
+
+[gain]
+tensorflow

imputecgm-0.1.0/imputeCGM.egg-info/top_level.txt

@@ -0,0 +1 @@
+imputeCGM

imputecgm-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "imputeCGM"
+version = "0.1.0"
+description = "CGM missing glucose imputation with MICE, ARIMA, XGBoost, and optional GAIN-based methods"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{name = "Hasin Shad, Shubh Saraswat, Dr. Xiaohua Douglas Zhang"}]
+dependencies = [
+  "numpy",
+  "pandas",
+  "scikit-learn",
+  "statsmodels",
+  "xgboost",
+  "rpy2"
+]
+
+[project.optional-dependencies]
+gain = ["tensorflow"]
+
+[project.scripts]
+imputeCGM = "imputeCGM.cli:main"

imputecgm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+