preprocessing.py

import pandas as pd
import numpy as np
import joblib
from sklearn.preprocessing import MinMaxScaler
from numpy.lib.stride_tricks import sliding_window_view
from sklearn.model_selection import train_test_split

GAP_THRESHOLD_MS = 2000   
WINDOW_SIZE = 30          

def load_and_segment(csv_path):
    df = pd.read_csv(str(csv_path))

    df["timestamp"] = pd.to_datetime(df["timestamp_ms"], unit="ms")
    df = df.sort_values(by="timestamp").reset_index(drop=True)

    df["time_gap"] = df["timestamp"].diff()

    threshold = pd.Timedelta(milliseconds=GAP_THRESHOLD_MS)

    is_new_segment = (df["time_gap"] > threshold) | (df["time_gap"].isna())

    df["segment_id"] = is_new_segment.cumsum()

    return df

def normalize_features(df, feature_cols):
    df_normalized = df.copy()
    scaler = MinMaxScaler()
    df_normalized[feature_cols] = scaler.fit_transform(df_normalized[feature_cols])
    return df_normalized, scaler

def build_sequences(df, feature_cols, window_size, segment_col="segment_id"):
    sequences = []

    for seg_id, group in df.groupby(segment_col):
        if len(group) < window_size:
            continue

        group_features = group[feature_cols].to_numpy()

        windows = sliding_window_view(
            group_features, window_shape=(window_size, len(feature_cols))
        )
        windows = windows.squeeze(axis=1)

        sequences.append(windows)

    if sequences:
        return np.concatenate(sequences, axis=0)
    else:
        return np.empty((0, window_size, len(feature_cols)))
    
def split_train_val(sequences, val_ratio=0.2):
    train_sequences, val_sequences = train_test_split(
        sequences,
        test_size=val_ratio,
        shuffle=True,
        random_state=42
    )

    return train_sequences, val_sequences

if __name__ == "__main__":
    df = load_and_segment("sentinel_training.csv")
    df, scaler = normalize_features(df, ["cpu_usage_pct", "ram_usage_pct"])
    sequences = build_sequences(df, ["cpu_usage_pct", "ram_usage_pct"], WINDOW_SIZE)
    train_seqs, val_seqs = split_train_val(sequences)

    joblib.dump(scaler, "scaler.pkl")

    print("Shape sequenze totali:", sequences.shape)
    print("Shape train:", train_seqs.shape)
    print("Shape validation:", val_seqs.shape)
    print("Numero segmenti:", df["segment_id"].nunique())
    print("Scaler salvato in scaler.pkl")

# (7634, 30, 2)
#    |    |  |
#    |    |  └── 2 feature: cpu_usage_pct, ram_usage_pct
#    |    └───── 30 timestep per sequenza (la nostra window)
#    └────────── 7634 sequenze totali generate