Upload folder using huggingface_hub

CNN-Autoencoder.py

@@ -0,0 +1,320 @@
+import os
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.metrics import (
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+    accuracy_score,
+    classification_report
+)
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+
+# ============================================
+# 1. CÀI ĐẶT THAM SỐ CHUNG
+# ============================================
+
+DATA_PATH = "dataset.xlsx"
+
+FEATURE_COLUMNS = [
+    "Temp",
+    "Turbidity (cm)",
+    "DO(mg/L)",
+    "BOD (mg/L)",
+    "CO2",
+    "pH`",
+    "Alkalinity (mg L-1 )",
+    "Hardness (mg L-1 )",
+    "Calcium (mg L-1 )",
+    "Ammonia (mg L-1 )",
+    "Nitrite (mg L-1 )",
+    "Phosphorus (mg L-1 )",
+    "H2S (mg L-1 )",
+    "Plankton (No. L-1)"
+]
+LABEL_COL = "Water Quality"
+
+SEQUENCE_LENGTH = 10
+
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+# CNN-AE hyperparameters
+INPUT_DIM = len(FEATURE_COLUMNS)  # 14 features
+SEQ_LEN = SEQUENCE_LENGTH        # 10 time steps
+CHANNELS = INPUT_DIM             # treat each feature as a channel
+AE_LR = 1e-3
+AE_EPOCHS = 50
+BATCH_SIZE = 64
+RANDOM_STATE = 42
+
+THRESHOLD_STD_FACTOR = 2  # threshold = mean + 2*std on validation normal
+
+# ============================================
+# 2. ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU
+# ============================================
+
+df = pd.read_excel(DATA_PATH)
+df = df.dropna(how="all")
+
+# Đảm bảo label là int
+df[LABEL_COL] = df[LABEL_COL].astype(int)
+labels_all = df[LABEL_COL].values  # shape = (num_total,)
+
+# Chuyển dấu phẩy sang dấu chấm, convert các cột tính sang float
+for col in FEATURE_COLUMNS:
+    if df[col].dtype == object or df[col].dtype == str:
+        df[col] = df[col].apply(lambda x: str(x).replace(",", "."))
+    df[col] = df[col].astype(float)
+
+data_raw = df[FEATURE_COLUMNS].values  # shape = (num_total, 14)
+
+# Chuẩn hóa min-max
+scaler = MinMaxScaler()
+data_scaled = scaler.fit_transform(data_raw)  # shape = (num_total, 14)
+
+# ============================================
+# 3. DATASET CHO TIME-SERIES
+# ============================================
+
+class CNNTimeSeriesDataset(Dataset):
+    """
+    Trả về x_window: shape (channels, seq_len)
+    Mỗi channel tương ứng một feature.
+    """
+    def __init__(self, data, seq_len):
+        self.data = data
+        self.seq_len = seq_len
+        self.num_items = data.shape[0] - seq_len
+
+    def __len__(self):
+        return self.num_items
+
+    def __getitem__(self, idx):
+        window = self.data[idx : idx + self.seq_len]  # shape = (seq_len, features)
+        # transpose thành (features, seq_len) để input cho Conv1d
+        x = window.T  # (channels, seq_len)
+        return torch.tensor(x, dtype=torch.float32)
+
+
+num_total = data_scaled.shape[0]
+num_items = num_total - SEQUENCE_LENGTH
+
+# Tạo mảng y_seq: nhãn tại cuối mỗi window
+y_seq = np.zeros(num_items, dtype=int)
+for i in range(num_items):
+    y_seq[i] = labels_all[i + SEQUENCE_LENGTH]
+
+# ============================================
+# 4. STRATIFIED SPLIT (TRAIN/VAL/TEST)
+# ============================================
+
+sss1 = StratifiedShuffleSplit(n_splits=1, test_size=TEST_RATIO, random_state=RANDOM_STATE)
+for train_val_idx, test_idx in sss1.split(np.zeros(num_items), y_seq):
+    pass
+
+val_size_rel = VAL_RATIO / (TRAIN_RATIO + VAL_RATIO)
+sss2 = StratifiedShuffleSplit(n_splits=1, test_size=val_size_rel, random_state=RANDOM_STATE)
+for train_idx_rel, val_idx_rel in sss2.split(np.zeros(len(train_val_idx)), y_seq[train_val_idx]):
+    pass
+
+train_idx = train_val_idx[train_idx_rel]
+val_idx   = train_val_idx[val_idx_rel]
+
+def count_labels(indices, y):
+    u, c = np.unique(y[indices], return_counts=True)
+    return dict(zip(u.tolist(), c.tolist()))
+
+print("Train labels:", count_labels(train_idx, y_seq))
+print("Val   labels:", count_labels(val_idx, y_seq))
+print("Test  labels:", count_labels(test_idx, y_seq))
+
+# ============================================
+# 5. TẠO DATALOADER CHO AUTOENCODER (CHỈ DÙNG NORMAL)
+# ============================================
+
+dataset_all = CNNTimeSeriesDataset(data_scaled, SEQUENCE_LENGTH)
+
+# Chỉ lấy index có nhãn 0 hoặc 1 cho train/val AE
+train_normal_idx = [i for i in train_idx if y_seq[i] < 2]
+val_normal_idx   = [i for i in val_idx   if y_seq[i] < 2]
+
+train_ae_dataset = Subset(dataset_all, train_normal_idx)
+val_ae_dataset   = Subset(dataset_all, val_normal_idx)
+test_dataset     = Subset(dataset_all, test_idx)
+
+train_ae_loader = DataLoader(train_ae_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+val_ae_loader   = DataLoader(val_ae_dataset,   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+test_loader     = DataLoader(test_dataset,     batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+
+# ============================================
+# 6. XÂY DỰNG LSTM‐CNN AUTOENCODER
+# ============================================
+
+class CNNAutoencoder(nn.Module):
+    def __init__(self, channels, seq_len):
+        super(CNNAutoencoder, self).__init__()
+        self.channels = channels
+        self.seq_len = seq_len
+
+        # Encoder: Conv1d layers
+        self.encoder = nn.Sequential(
+            nn.Conv1d(in_channels=channels, out_channels=32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv1d(in_channels=32, out_channels=64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            # Giữ nguyên chiều seq_len nhưng tăng depth
+        )
+        # Decoder: ConvTranspose1d layers
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose1d(in_channels=128, out_channels=64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose1d(in_channels=64, out_channels=32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.ConvTranspose1d(in_channels=32, out_channels=channels, kernel_size=3, padding=1),
+            nn.Sigmoid()  # output trong [0,1] do data đã chuẩn hóa
+        )
+
+    def forward(self, x):
+        """
+        x: (batch, channels, seq_len)
+        trả về x_recon: (batch, channels, seq_len)
+        """
+        z = self.encoder(x)
+        x_recon = self.decoder(z)
+        return x_recon
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ae_model = CNNAutoencoder(channels=CHANNELS, seq_len=SEQ_LEN).to(device)
+
+ae_criterion = nn.MSELoss()
+ae_optimizer = torch.optim.Adam(ae_model.parameters(), lr=AE_LR)
+
+# ============================================
+# 7. HUẤN LUYỆN CNN‐AE
+# ============================================
+
+best_val_loss = float("inf")
+best_ae_path = "best_cnn_ae.pth"
+
+for epoch in range(1, AE_EPOCHS + 1):
+    ae_model.train()
+    train_loss_sum = 0.0
+    for x_batch in train_ae_loader:
+        # x_batch: (batch, channels, seq_len)
+        x_batch = x_batch.to(device)
+        ae_optimizer.zero_grad()
+        x_recon = ae_model(x_batch)
+        loss = ae_criterion(x_recon, x_batch)
+        loss.backward()
+        ae_optimizer.step()
+        train_loss_sum += loss.item() * x_batch.size(0)
+    train_loss = train_loss_sum / len(train_ae_loader.dataset)
+
+    ae_model.eval()
+    val_loss_sum = 0.0
+    with torch.no_grad():
+        for x_batch in val_ae_loader:
+            x_batch = x_batch.to(device)
+            x_recon = ae_model(x_batch)
+            loss = ae_criterion(x_recon, x_batch)
+            val_loss_sum += loss.item() * x_batch.size(0)
+    val_loss = val_loss_sum / len(val_ae_loader.dataset)
+
+    print(f"Epoch {epoch:02d} | AE Train Loss: {train_loss:.6f} | AE Val Loss: {val_loss:.6f}")
+    if val_loss < best_val_loss:
+        best_val_loss = val_loss
+        torch.save(ae_model.state_dict(), best_ae_path)
+
+ae_model.load_state_dict(torch.load(best_ae_path, map_location=device))
+
+
+# ============================================
+# 8. TÍNH RECONSTRUCTION ERROR TRÊN VALIDATION NORMAL
+# ============================================
+
+val_norm_errors = []
+ae_model.eval()
+with torch.no_grad():
+    for x_batch in val_ae_loader:
+        x_batch = x_batch.to(device)
+        x_recon = ae_model(x_batch)
+        # MSE dọc (channels x seq_len) cho mỗi sample
+        batch_errors = torch.mean((x_recon - x_batch) ** 2, dim=(1, 2))
+        val_norm_errors.append(batch_errors.cpu().numpy())
+val_norm_errors = np.concatenate(val_norm_errors, axis=0)
+
+mu_val = np.mean(val_norm_errors)
+sigma_val = np.std(val_norm_errors)
+threshold = mu_val + THRESHOLD_STD_FACTOR * sigma_val
+
+print(f"\nThreshold (mean + {THRESHOLD_STD_FACTOR}*std) từ validation normal: {threshold:.6f}")
+
+
+# ============================================
+# 9. TÍNH RECONSTRUCTION ERROR TRÊN TEST & PHÁT HIỆN BẤT THƯỜNG
+# ============================================
+
+test_errors = []
+ae_model.eval()
+with torch.no_grad():
+    for x_batch in test_loader:
+        x_batch = x_batch.to(device)
+        x_recon = ae_model(x_batch)
+        batch_errors = torch.mean((x_recon - x_batch) ** 2, dim=(1, 2))
+        test_errors.append(batch_errors.cpu().numpy())
+test_errors = np.concatenate(test_errors, axis=0)
+
+anomalies = test_errors > threshold
+num_anomalies = np.sum(anomalies)
+print(f"Phát hiện {num_anomalies} samples bất thường trong tập test (trên tổng {len(test_errors)})")
+print("Chỉ số sample bất thường (relative to test set):", np.where(anomalies)[0])
+
+
+# ============================================
+# 10. ĐÁNH GIÁ KẾT QUẢ
+# ============================================
+
+y_true = []
+for idx in test_idx:
+    y_true.append(1 if labels_all[idx + SEQUENCE_LENGTH] == 2 else 0)
+y_true = np.array(y_true, dtype=int)
+y_pred = anomalies.astype(int)
+
+cm = confusion_matrix(y_true, y_pred)
+tn, fp, fn, tp = cm.ravel()
+
+precision = precision_score(y_true, y_pred, zero_division=0)
+recall    = recall_score(y_true, y_pred, zero_division=0)
+f1        = f1_score(y_true, y_pred, zero_division=0)
+accuracy  = accuracy_score(y_true, y_pred)
+
+print("\n=== Confusion Matrix ===")
+print(cm)
+print(f"TN: {tn},  FP: {fp}")
+print(f"FN: {fn},  TP: {tp}\n")
+
+print("=== Metrics for Anomaly Detection ===")
+print(f"Accuracy : {accuracy:.4f}")
+print(f"Precision: {precision:.4f}")
+print(f"Recall   : {recall:.4f}")
+print(f"F1-score : {f1:.4f}\n")
+
+print("=== Classification Report ===")
+print(
+    classification_report(
+        y_true,
+        y_pred,
+        target_names=["Normal (0)", "Anomaly (1)"],
+        zero_division=0
+    )
+)

Report/CNN-Autoencoder.txt

@@ -0,0 +1,32 @@
+Threshold (mean + 2*std) từ validation normal: 0.002760
+Phát hiện 131 samples bất thường trong tập test (trên tổng 429)
+Chỉ số sample bất thường (relative to test set): [  4   7  10  11  14  15  21  23  24  27  32  33  36  38  42  47  49  53
+  56  58  59  61  64  67  71  72  74  78  79  87  90  92  93  98 102 104
+ 107 111 114 115 116 120 121 124 125 128 130 132 138 141 149 150 152 154
+ 155 156 157 162 170 174 177 178 189 191 195 200 204 207 208 209 210 213
+ 214 215 216 217 221 225 232 234 235 236 238 239 246 248 250 261 267 271
+ 274 279 280 293 297 299 302 312 315 318 320 323 326 327 332 340 341 346
+ 351 352 359 360 366 368 374 378 380 386 387 388 392 393 394 405 406 409
+ 410 416 418 424 427]
+
+=== Confusion Matrix ===
+[[279   1]
+ [ 19 130]]
+TN: 279,  FP: 1
+FN: 19,  TP: 130
+
+=== Metrics for Anomaly Detection ===
+Accuracy : 0.9534
+Precision: 0.9924
+Recall   : 0.8725
+F1-score : 0.9286
+
+=== Classification Report ===
+              precision    recall  f1-score   support
+
+  Normal (0)       0.94      1.00      0.97       280
+ Anomaly (1)       0.99      0.87      0.93       149
+
+    accuracy                           0.95       429
+   macro avg       0.96      0.93      0.95       429
+weighted avg       0.96      0.95      0.95       429

Report/Fully‐Connected-Sequence-Autoencoder.txt

@@ -0,0 +1,71 @@
+Threshold (mean + 2*std) từ tập validation normal: 0.024559
+Phát hiện 109 samples bất thường trong tập test (trên tổng 429)
+Chỉ số sample bất thường (relative to test set): [  7, 10, 11, …, 427]  (tổng 109 index)
+
+=== Confusion Matrix ===
+[[279   1]
+ [ 41 108]]
+TN: 279,  FP: 1
+FN: 41,  TP: 108
+
+=== Metrics for Anomaly Detection ===
+Accuracy : 0.9021
+Precision: 0.9908
+Recall   : 0.7248
+F1-score : 0.8372
+
+=== Classification Report ===
+              precision    recall  f1-score   support
+
+  Normal (0)       0.87      1.00      0.93       280
+ Anomaly (1)       0.99      0.72      0.84       149
+
+    accuracy                           0.90       429
+   macro avg       0.93      0.86      0.88       429
+weighted avg       0.91      0.90      0.90       429
+
+
+Fully‐Connected Sequence Autoencoder
+Mục đích: Tái tạo (reconstruct) toàn bộ chuỗi con (window) đầu vào và coi sample nào tái tạo kém (error cao) là bất thường.
+
+Kiến trúc:
+
+Flatten sequence: Mỗi window có shape (seq_len, input_dim) = (10, 14). Ta “dẹt” thành vector độ dài 140 trước khi đưa vào mạng.
+
+Encoder:
+
+Input: vector 140 chiều.
+
+Qua một lớp Linear(140 → 64), activation ReLU, rồi Linear(64 → latent_dim=64), ReLU → ra vector z chiều 64.
+
+Decoder:
+
+Nhận latent z (64 chiều), qua Linear(64 → 64), ReLU, rồi Linear(64 → 140) → output 140 chiều.
+
+Cuối cùng reshape về (batch, seq_len, input_dim) = (batch, 10, 14) để so sánh với input gốc.
+
+Cách train:
+
+Chỉ dùng các sequence bình thường (nhãn 0 hoặc 1) trong phần train/val để huấn luyện autoencoder, với loss MSE giữa x_recon và x_orig.
+
+Mục tiêu cho AE: học cách nén và tái tạo chính xác chuỗi “bình thường”.
+
+Phát hiện bất thường:
+
+Trên tập validation chỉ chứa normal, tính MSE (reconstruction error) cho mỗi sequence, lấy mean và std, rồi định nghĩa threshold = mean + k·std (ở code là k=2).
+
+Trên tập test (có cả normal và anomalous), tính reconstruction error cho mỗi window.
+
+Mỗi window có error > threshold được gán “anomaly”.
+
+Ưu điểm so với LSTM Forecaster:
+
+AE không cần dự báo chính xác bước kế tiếp, chỉ tập trung học cách tái tạo cả window “bình thường”. Bất cứ pattern lạ nào (anomaly) khiến lỗi tái tạo tăng cao.
+
+Thích hợp khi cấu trúc anomaly làm cho AE khó tái tạo (ví dụ ngoại lai nằm ngoài phân phối normal).
+
+Nhược điểm:
+
+Mạng chỉ là fully‐connected – không tận dụng mối liên hệ tuần tự phức tạp như LSTM.
+
+Kết quả phụ thuộc vào khả năng AE nén được đặc trưng chuỗi bình thường.

Report/LSTM-Forecaster.txt

@@ -0,0 +1,47 @@
+Test Loss: 0.020916
+Threshold (mean + 2*std): 0.056502
+Phát hiện 17 samples bất thường trong tập test (trên tổng 429)
+Chỉ số sample bất thường (relative to test set): [  7  15  53  56  78 132 204 213 216 232 236 238 318 323 346 368 427]
+
+=== Confusion Matrix ===
+[[280   0]
+ [132  17]]
+TN: 280,  FP: 0
+FN: 132,  TP: 17
+
+=== Metrics for Anomaly Detection ===
+Accuracy : 0.6923
+Precision: 1.0000
+Recall   : 0.1141
+F1-score : 0.2048
+
+=== Classification Report ===
+              precision    recall  f1-score   support
+
+  Normal (0)       0.68      1.00      0.81       280
+ Anomaly (1)       1.00      0.11      0.20       149
+
+    accuracy                           0.69       429
+   macro avg       0.84      0.56      0.51       429
+weighted avg       0.79      0.69      0.60       429
+
+
+LSTM Forecaster
+Mục đích: Dự báo (forecast) giá trị multivariate của bước thời gian kế tiếp dựa trên một cửa sổ (window) gồm SEQUENCE_LENGTH bước trước đó.
+
+Kiến trúc:
+
+Một lớp LSTM với input_size = 14 (14 đặc trưng), hidden_size = 64, num_layers = 2, batch_first=True.
+
+Sau khi LSTM chạy xong, ta lấy hidden state cuối cùng (hn[-1]) và đưa qua một lớp Linear (hidden_size → input_size) để sinh ra dự báo 14 chiều cho bước thời gian kế tiếp.
+
+Sử dụng để phát hiện bất thường:
+
+Huấn luyện LSTM trên toàn bộ dữ liệu (không phân biệt normal/anomaly), để nó học cách dự báo tín hiệu “bình thường” tốt nhất.
+
+Trên tập test, với mỗi sequence, ta so sánh y_pred = model(x_window) với giá trị thực y_true. Tính lỗi MSE riêng cho từng sample.
+
+Chọn một threshold (ví dụ mean + 2·std của tất cả các lỗi trên tập validation hoặc train), và gán những sample có lỗi > threshold là anomaly.
+
+Ưu điểm: dễ implement, tận dụng đặc tính dãy thời gian. Nhược điểm: nếu signal biến động quá phức tạp thì LSTM dự báo chưa tốt, lỗi tái tạo không đủ “nhạy” để phát hiện anomaly.
+

Report/transformer_ae_results.txt

@@ -0,0 +1,29 @@
+Test Loss: 0.021181
+Threshold (mean + 2*std): 0.032068
+Phát hiện 65 samples bất thường trên tổng 429
+Chỉ số sample bất thường: [  7  10  15  56  61  67  71  72  74  79  98 107 114 121 124 125 128 132
+ 138 149 150 155 157 170 177 189 191 200 204 207 208 210 213 214 216 221
+ 225 232 236 238 239 248 267 271 293 297 299 302 318 326 340 341 359 368
+ 374 380 386 387 388 393 406 410 416 424 427]
+
+Confusion Matrix:
+[[280   0]
+ [ 84  65]]
+TN: 280,  FP: 0
+FN: 84,  TP: 65
+
+=== Metrics for Anomaly Detection ===
+Accuracy : 0.8042
+Precision: 1.0000
+Recall   : 0.4362
+F1-score : 0.6075
+
+=== Classification Report ===
+              precision    recall  f1-score   support
+
+  Normal (0)       0.77      1.00      0.87       280
+ Anomaly (1)       1.00      0.44      0.61       149
+
+    accuracy                           0.80       429
+   macro avg       0.88      0.72      0.74       429
+weighted avg       0.85      0.80      0.78       429

Report/vae_results.txt

@@ -0,0 +1,29 @@
+Threshold (mean + 2*std): 0.040195
+Detected 75 anomalies out of 429 samples
+Anomaly indices: [  7   8  10  15  23  27  38  49  56  58  59  61  67  71  72  79  92  98
+ 102 107 121 124 125 128 132 138 149 150 155 156 157 162 170 189 191 195
+ 200 207 208 210 214 215 216 221 225 235 236 238 239 248 250 260 261 267
+ 271 279 293 297 299 302 318 323 326 340 359 368 374 386 387 388 394 406
+ 409 410 427]
+
+Confusion Matrix:
+[[279   1]
+ [ 75  74]]
+TN: 279, FP: 1
+FN: 75, TP: 74
+
+=== Metrics ===
+Accuracy : 0.8228
+Precision: 0.9867
+Recall   : 0.4966
+F1-score : 0.6607
+
+Classification Report:
+              precision    recall  f1-score   support
+
+  Normal (0)       0.79      1.00      0.88       280
+ Anomaly (1)       0.99      0.50      0.66       149
+
+    accuracy                           0.82       429
+   macro avg       0.89      0.75      0.77       429
+weighted avg       0.86      0.82      0.80       429

Transformer‐AE.py

@@ -0,0 +1,292 @@
+import os
+import math
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.metrics import (
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+    accuracy_score,
+    classification_report
+)
+
+# ============================================
+# 1. CÀI ĐẶT THAM SỐ CHUNG
+# ============================================
+DATA_PATH = "dataset.xlsx"
+
+FEATURE_COLUMNS = [
+    "Temp",
+    "Turbidity (cm)",
+    "DO(mg/L)",
+    "BOD (mg/L)",
+    "CO2",
+    "pH`",
+    "Alkalinity (mg L-1 )",
+    "Hardness (mg L-1 )",
+    "Calcium (mg L-1 )",
+    "Ammonia (mg L-1 )",
+    "Nitrite (mg L-1 )",
+    "Phosphorus (mg L-1 )",
+    "H2S (mg L-1 )",
+    "Plankton (No. L-1)"
+]
+LABEL_COL = "Water Quality"
+
+SEQUENCE_LENGTH = 10
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+# Transformer AE hyperparameters
+D_MODEL = 64          # embedding dimension
+NHEAD = 8             # number of attention heads
+NUM_LAYERS = 3        # number of transformer layers
+DIM_FEEDFORWARD = 128 # feedforward network dimension
+AE_LR = 1e-3
+AE_EPOCHS = 50
+BATCH_SIZE = 64
+RANDOM_STATE = 42
+
+THRESHOLD_STD_FACTOR = 2  # threshold = mean + 2*std
+
+# ============================================
+# 2. ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU
+# ============================================
+df = pd.read_excel(DATA_PATH)
+df = df.dropna(how="all")
+df[LABEL_COL] = df[LABEL_COL].astype(int)
+for col in FEATURE_COLUMNS:
+    if df[col].dtype == object:
+        df[col] = df[col].str.replace(",", ".")
+    df[col] = df[col].astype(float)
+
+data_raw = df[FEATURE_COLUMNS].values
+scaler = MinMaxScaler()
+data_scaled = scaler.fit_transform(data_raw)
+labels_all = df[LABEL_COL].values
+
+# ============================================
+# 3. DATASET CHO TIME-SERIES
+# ============================================
+class TimeSeriesDataset(Dataset):
+    def __init__(self, data, seq_len):
+        self.data = data
+        self.seq_len = seq_len
+
+    def __len__(self):
+        return self.data.shape[0] - self.seq_len
+
+    def __getitem__(self, idx):
+        seq = self.data[idx : idx + self.seq_len]  # (seq_len, features)
+        return torch.tensor(seq, dtype=torch.float32)
+
+num_items = data_scaled.shape[0] - SEQUENCE_LENGTH
+y_seq = np.array([labels_all[i + SEQUENCE_LENGTH] for i in range(num_items)], dtype=int)
+
+sss1 = StratifiedShuffleSplit(n_splits=1, test_size=TEST_RATIO, random_state=RANDOM_STATE)
+for train_val_idx, test_idx in sss1.split(np.zeros(num_items), y_seq): pass
+val_rel = VAL_RATIO / (TRAIN_RATIO + VAL_RATIO)
+sss2 = StratifiedShuffleSplit(n_splits=1, test_size=val_rel, random_state=RANDOM_STATE)
+for ti, vi in sss2.split(np.zeros(len(train_val_idx)), y_seq[train_val_idx]): pass
+train_idx = train_val_idx[ti]; val_idx = train_val_idx[vi]
+
+dataset = TimeSeriesDataset(data_scaled, SEQUENCE_LENGTH)
+train_normal = [i for i in train_idx if y_seq[i] < 2]
+val_normal   = [i for i in val_idx   if y_seq[i] < 2]
+
+train_loader = DataLoader(Subset(dataset, train_normal), batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+val_loader   = DataLoader(Subset(dataset, val_normal),   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+test_loader  = DataLoader(Subset(dataset, test_idx),     batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+
+# ============================================
+# 4. POSITIONAL ENCODING
+# ============================================
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        pe = torch.zeros(max_len, d_model)
+        pos = torch.arange(max_len, dtype=torch.float).unsqueeze(1)
+        div = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0)/d_model))
+        pe[:,0::2] = torch.sin(pos * div)
+        pe[:,1::2] = torch.cos(pos * div)
+        self.register_buffer('pe', pe.unsqueeze(1))
+
+    def forward(self, x):
+        # x: (seq_len, batch, d_model)
+        return self.dropout(x + self.pe[:x.size(0)])
+
+# ============================================
+# 5. TRANSFORMER AUTOENCODER
+# ============================================
+class TransformerAutoencoder(nn.Module):
+    def __init__(self, feat_dim, seq_len, d_model, nhead, nlayers, ff_dim, dropout=0.1):
+        super().__init__()
+        self.d_model = d_model
+        self.input_proj = nn.Linear(feat_dim, d_model)
+        self.pos_enc = PositionalEncoding(d_model, dropout)
+        enc_layer = nn.TransformerEncoderLayer(d_model, nhead, ff_dim, dropout)
+        self.encoder = nn.TransformerEncoder(enc_layer, nlayers)
+        dec_layer = nn.TransformerDecoderLayer(d_model, nhead, ff_dim, dropout)
+        self.decoder = nn.TransformerDecoder(dec_layer, nlayers)
+        self.output_proj = nn.Linear(d_model, feat_dim)
+        mask = torch.triu(torch.ones(seq_len, seq_len)*float('-inf'), diagonal=1)
+        self.register_buffer('mask', mask)
+
+    def forward(self, src):
+        # src: (batch, seq_len, feat_dim)
+        x = self.input_proj(src) * math.sqrt(self.d_model)
+        x = x.permute(1,0,2)                       # (seq_len, batch, d_model)
+        x = self.pos_enc(x)
+        memory = self.encoder(x)
+        tgt = torch.zeros_like(x)
+        out = self.decoder(tgt, memory, tgt_mask=self.mask)
+        out = out.permute(1,0,2)                   # (batch, seq_len, d_model)
+        return self.output_proj(out)              # (batch, seq_len, feat_dim)
+
+# ============================================
+# 6. KHỞI TẠO MÔ HÌNH VÀ OPTIMIZER
+# ============================================
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = TransformerAutoencoder(
+    feat_dim=len(FEATURE_COLUMNS),
+    seq_len=SEQUENCE_LENGTH,
+    d_model=D_MODEL,
+    nhead=NHEAD,
+    nlayers=NUM_LAYERS,
+    ff_dim=DIM_FEEDFORWARD
+).to(device)
+criterion = nn.MSELoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=AE_LR)
+
+# ============================================
+# 7. TRAINING
+# ============================================
+best_val = float('inf')
+best_path = 'best_transformer_ae.pth'
+for ep in range(1, AE_EPOCHS+1):
+    model.train()
+    tr_loss = 0
+    for b in train_loader:
+        b = b.to(device)
+        optimizer.zero_grad()
+        recon = model(b)
+        loss = criterion(recon, b)
+        loss.backward()
+        optimizer.step()
+        tr_loss += loss.item()*b.size(0)
+    tr_loss /= len(train_loader.dataset)
+
+    model.eval()
+    vl_loss = 0
+    with torch.no_grad():
+        for b in val_loader:
+            b = b.to(device)
+            recon = model(b)
+            vl_loss += criterion(recon, b).item()*b.size(0)
+    vl_loss /= len(val_loader.dataset)
+
+    print(f"Epoch {ep:02d} | Train Loss: {tr_loss:.6f} | Val Loss: {vl_loss:.6f}")
+    if vl_loss < best_val:
+        best_val = vl_loss
+        torch.save(model.state_dict(), best_path)
+
+model.load_state_dict(torch.load(best_path, map_location=device))
+
+# ============================================
+# 8. ĐÁNH GIÁ TEST & XÁC ĐỊNH THRESHOLD
+# ============================================
+model.eval()
+# Test Loss
+test_losses = []
+with torch.no_grad():
+    for b in test_loader:
+        b = b.to(device)
+        recon = model(b)
+        test_losses.append(criterion(recon, b).item()*b.size(0))
+test_loss = sum(test_losses)/len(test_loader.dataset)
+print(f"Test Loss: {test_loss:.6f}")
+
+# Reconstruction error on validation normal
+val_errs = np.concatenate([
+    torch.mean((model(b.to(device))-b.to(device))**2, dim=(1,2)).detach().cpu().numpy()
+    for b in val_loader
+])
+mu, sd = val_errs.mean(), val_errs.std()
+threshold = mu + THRESHOLD_STD_FACTOR*sd
+print(f"Threshold (mean + 2*std): {threshold:.6f}")
+
+# ============================================
+# 9. PHÁT HIỆN BẤT THƯỜNG TRÊN TEST
+# ============================================
+test_errs = np.concatenate([
+    torch.mean((model(b.to(device))-b.to(device))**2, dim=(1,2)).detach().cpu().numpy()
+    for b in test_loader
+])
+anom = test_errs > threshold
+num_anom = anom.sum()
+print(f"Phát hiện {num_anom} samples bất thường trong tập test (trên tổng {len(test_errs)})")
+print(f"Chỉ số sample bất thường: {np.where(anom)[0]}")
+
+# ============================================
+# 10. ĐÁNH GIÁ KẾT QUẢ
+# ============================================
+y_true = np.array([1 if labels_all[i+SEQUENCE_LENGTH]==2 else 0 for i in test_idx], dtype=int)
+y_pred = anom.astype(int)
+
+cm = confusion_matrix(y_true, y_pred)
+tn, fp, fn, tp = cm.ravel()
+acc  = accuracy_score(y_true, y_pred)
+prec = precision_score(y_true, y_pred, zero_division=0)
+rec  = recall_score(y_true, y_pred, zero_division=0)
+f1   = f1_score(y_true, y_pred, zero_division=0)
+
+print("\n=== Confusion Matrix ===")
+print(cm)
+print(f"TN: {tn},  FP: {fp}")
+print(f"FN: {fn},  TP: {tp}\n")
+
+print("=== Metrics for Anomaly Detection ===")
+print(f"Accuracy : {acc:.4f}")
+print(f"Precision: {prec:.4f}")
+print(f"Recall   : {rec:.4f}")
+print(f"F1-score : {f1:.4f}\n")
+
+print("=== Classification Report ===")
+report = classification_report(y_true, y_pred, target_names=["Normal (0)", "Anomaly (1)"], zero_division=0)
+print(report)
+
+# ============================================
+# 11. GHI RA FILE TXT
+# ============================================
+out = []
+out.append(f"Test Loss: {test_loss:.6f}")
+out.append(f"Threshold (mean + 2*std): {threshold:.6f}")
+out.append(f"Phát hiện {num_anom} samples bất thường trên tổng {len(test_errs)}")
+out.append(f"Chỉ số sample bất thường: {np.where(anom)[0]}")
+out.append("")
+out.append("Confusion Matrix:")
+out.append(np.array2string(cm))
+out.append(f"TN: {tn},  FP: {fp}")
+out.append(f"FN: {fn},  TP: {tp}")
+out.append("")
+out.append("=== Metrics for Anomaly Detection ===")
+out.append(f"Accuracy : {acc:.4f}")
+out.append(f"Precision: {prec:.4f}")
+out.append(f"Recall   : {rec:.4f}")
+out.append(f"F1-score : {f1:.4f}")
+out.append("")
+out.append("=== Classification Report ===")
+out.append(report)
+
+with open("transformer_ae_results.txt", "w") as f:
+    f.write("\n".join(out))
+
+print("Results saved to transformer_ae_results.txt")

VAE.py

@@ -0,0 +1,272 @@
+import os
+import math
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.metrics import (
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+    accuracy_score,
+    classification_report
+)
+
+# ============================================
+# 1. CÀI ĐẶT THAM SỐ CHUNG
+# ============================================
+DATA_PATH = "dataset.xlsx"
+
+FEATURE_COLUMNS = [
+    "Temp", "Turbidity (cm)", "DO(mg/L)", "BOD (mg/L)", "CO2", "pH`",
+    "Alkalinity (mg L-1 )", "Hardness (mg L-1 )", "Calcium (mg L-1 )",
+    "Ammonia (mg L-1 )", "Nitrite (mg L-1 )", "Phosphorus (mg L-1 )",
+    "H2S (mg L-1 )", "Plankton (No. L-1)"
+]
+LABEL_COL = "Water Quality"
+
+SEQUENCE_LENGTH = 10
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+# VAE hyperparameters
+LATENT_DIM = 16
+HIDDEN_DIM = 128
+AE_LR = 1e-3
+AE_EPOCHS = 50
+BATCH_SIZE = 64
+RANDOM_STATE = 42
+
+THRESHOLD_STD_FACTOR = 2  # threshold = mean + 2*std
+
+# ============================================
+# 2. ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU
+# ============================================
+df = pd.read_excel(DATA_PATH)
+df = df.dropna(how="all")
+df[LABEL_COL] = df[LABEL_COL].astype(int)
+for col in FEATURE_COLUMNS:
+    if df[col].dtype == object:
+        df[col] = df[col].str.replace(",", ".")
+    df[col] = df[col].astype(float)
+
+data_raw = df[FEATURE_COLUMNS].values
+scaler = MinMaxScaler()
+data_scaled = scaler.fit_transform(data_raw)
+labels_all = df[LABEL_COL].values
+
+# ============================================
+# 3. DATASET CHO TIME-SERIES
+# ============================================
+class TimeSeriesDataset(Dataset):
+    def __init__(self, data, seq_len):
+        self.data = data
+        self.seq_len = seq_len
+
+    def __len__(self):
+        return self.data.shape[0] - self.seq_len
+
+    def __getitem__(self, idx):
+        seq = self.data[idx:idx+self.seq_len]  # (seq_len, features)
+        return torch.tensor(seq, dtype=torch.float32)
+
+num_items = data_scaled.shape[0] - SEQUENCE_LENGTH
+y_seq = np.array([labels_all[i+SEQUENCE_LENGTH] for i in range(num_items)], dtype=int)
+
+# Stratified split
+sss1 = StratifiedShuffleSplit(n_splits=1, test_size=TEST_RATIO, random_state=RANDOM_STATE)
+for tv_idx, test_idx in sss1.split(np.zeros(num_items), y_seq): pass
+val_rel = VAL_RATIO / (TRAIN_RATIO + VAL_RATIO)
+sss2 = StratifiedShuffleSplit(n_splits=1, test_size=val_rel, random_state=RANDOM_STATE)
+for tr_rel, val_rel_idx in sss2.split(np.zeros(len(tv_idx)), y_seq[tv_idx]): pass
+
+train_idx = tv_idx[tr_rel]
+val_idx   = tv_idx[val_rel_idx]
+
+dataset = TimeSeriesDataset(data_scaled, SEQUENCE_LENGTH)
+train_norm = [i for i in train_idx if y_seq[i] < 2]
+val_norm   = [i for i in val_idx   if y_seq[i] < 2]
+
+train_loader = DataLoader(Subset(dataset, train_norm), batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+val_loader   = DataLoader(Subset(dataset, val_norm),   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+test_loader  = DataLoader(Subset(dataset, test_idx),   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+
+# ============================================
+# 4. ĐỊNH NGHĨA VAE
+# ============================================
+class VAE(nn.Module):
+    def __init__(self, input_dim, seq_len, hidden_dim, latent_dim):
+        super().__init__()
+        self.seq_len = seq_len
+        self.input_dim = input_dim
+        flat_dim = seq_len * input_dim
+
+        # encoder
+        self.fc1 = nn.Linear(flat_dim, hidden_dim)
+        self.fc_mu = nn.Linear(hidden_dim, latent_dim)
+        self.fc_logvar = nn.Linear(hidden_dim, latent_dim)
+
+        # decoder
+        self.fc3 = nn.Linear(latent_dim, hidden_dim)
+        self.fc4 = nn.Linear(hidden_dim, flat_dim)
+        self.act = nn.ReLU()
+        self.sig = nn.Sigmoid()
+
+    def encode(self, x):
+        h1 = self.act(self.fc1(x))
+        return self.fc_mu(h1), self.fc_logvar(h1)
+
+    def reparameterize(self, mu, logvar):
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return mu + eps * std
+
+    def decode(self, z):
+        h3 = self.act(self.fc3(z))
+        return self.sig(self.fc4(h3))
+
+    def forward(self, x):
+        # x: (batch, seq_len, input_dim)
+        x_flat = x.view(x.size(0), -1)
+        mu, logvar = self.encode(x_flat)
+        z = self.reparameterize(mu, logvar)
+        recon_flat = self.decode(z)
+        recon = recon_flat.view(x.size(0), self.seq_len, self.input_dim)
+        return recon, mu, logvar
+
+# ============================================
+# 5. KHỞI TẠO MÔ HÌNH, OPTIMIZER
+# ============================================
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = VAE(len(FEATURE_COLUMNS), SEQUENCE_LENGTH, HIDDEN_DIM, LATENT_DIM).to(device)
+optimizer = torch.optim.Adam(model.parameters(), lr=AE_LR)
+mse_loss = nn.MSELoss(reduction='sum')
+
+# KL divergence term
+def kl_divergence(mu, logvar):
+    return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
+
+# ============================================
+# 6. HUẤN LUYỆN VAE
+# ============================================
+best_val_loss = float('inf')
+best_path = 'best_vae.pth'
+
+for epoch in range(1, AE_EPOCHS+1):
+    model.train()
+    train_loss = 0
+    for batch in train_loader:
+        batch = batch.to(device)
+        recon, mu, logvar = model(batch)
+        recon_loss = mse_loss(recon, batch)
+        kl_loss = kl_divergence(mu, logvar)
+        loss = recon_loss + kl_loss
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        train_loss += loss.item()
+    train_loss /= len(train_loader.dataset)
+
+    model.eval()
+    val_loss = 0
+    with torch.no_grad():
+        for batch in val_loader:
+            batch = batch.to(device)
+            recon, mu, logvar = model(batch)
+            recon_loss = mse_loss(recon, batch)
+            kl_loss = kl_divergence(mu, logvar)
+            val_loss += (recon_loss + kl_loss).item()
+    val_loss /= len(val_loader.dataset)
+
+    print(f"Epoch {epoch:02d} | Train Loss: {train_loss:.6f} | Val Loss: {val_loss:.6f}")
+    if val_loss < best_val_loss:
+        best_val_loss = val_loss
+        torch.save(model.state_dict(), best_path)
+
+model.load_state_dict(torch.load(best_path, map_location=device))
+
+# ============================================
+# 7. XÁC ĐỊNH NGƯỠNG RECONSTRUCTION ERROR
+# ============================================
+model.eval()
+val_errors = []
+with torch.no_grad():
+    for batch in val_loader:
+        batch = batch.to(device)
+        recon, _, _ = model(batch)
+        # compute per-sample MSE
+        errs = torch.mean((recon - batch)**2, dim=(1,2))
+        val_errors.append(errs.cpu().numpy())
+val_errors = np.concatenate(val_errors)
+mu_err, sigma_err = val_errors.mean(), val_errors.std()
+threshold = mu_err + THRESHOLD_STD_FACTOR * sigma_err
+print(f"Threshold (mean + 2*std): {threshold:.6f}")
+
+# ============================================
+# 8. PHÁT HIỆN BẤT THƯỜNG TRÊN TEST
+# ============================================
+test_errors = []
+with torch.no_grad():
+    for batch in test_loader:
+        batch = batch.to(device)
+        recon, _, _ = model(batch)
+        errs = torch.mean((recon - batch)**2, dim=(1,2))
+        test_errors.append(errs.cpu().numpy())
+test_errors = np.concatenate(test_errors)
+anomalies = test_errors > threshold
+print(f"Detected {anomalies.sum()} anomalies out of {len(test_errors)} samples")
+print("Anomaly indices:", np.where(anomalies)[0])
+
+# ============================================
+# 9. ĐÁNH GIÁ KẾT QUẢ
+# ============================================
+y_true = np.array([1 if labels_all[i+SEQUENCE_LENGTH]==2 else 0 for i in test_idx], dtype=int)
+y_pred = anomalies.astype(int)
+
+cm = confusion_matrix(y_true, y_pred)
+tn, fp, fn, tp = cm.ravel()
+accuracy  = accuracy_score(y_true, y_pred)
+precision = precision_score(y_true, y_pred, zero_division=0)
+recall    = recall_score(y_true, y_pred, zero_division=0)
+f1        = f1_score(y_true, y_pred, zero_division=0)
+
+print("\n=== Confusion Matrix ===")
+print(cm)
+print(f"TN: {tn}, FP: {fp}")
+print(f"FN: {fn}, TP: {tp}\n")
+
+print("=== Metrics for Anomaly Detection ===")
+print(f"Accuracy : {accuracy:.4f}")
+print(f"Precision: {precision:.4f}")
+print(f"Recall   : {recall:.4f}")
+print(f"F1-score : {f1:.4f}\n")
+
+print("=== Classification Report ===")
+print(classification_report(y_true, y_pred, target_names=["Normal (0)", "Anomaly (1)"], zero_division=0))
+
+# ============================================
+# 10. GHI KẾT QUẢ RA FILE TXT
+# ============================================
+results = []
+results.append(f"Threshold (mean + 2*std): {threshold:.6f}")
+results.append(f"Detected {anomalies.sum()} anomalies out of {len(test_errors)} samples")
+results.append("Anomaly indices: " + np.array2string(np.where(anomalies)[0]))
+results.append("\nConfusion Matrix:\n" + np.array2string(cm))
+results.append(f"TN: {tn}, FP: {fp}")
+results.append(f"FN: {fn}, TP: {tp}")
+results.append("\n=== Metrics ===")
+results.append(f"Accuracy : {accuracy:.4f}")
+results.append(f"Precision: {precision:.4f}")
+results.append(f"Recall   : {recall:.4f}")
+results.append(f"F1-score : {f1:.4f}")
+results.append("\nClassification Report:\n" + classification_report(y_true, y_pred, target_names=["Normal (0)", "Anomaly (1)"], zero_division=0))
+
+with open("vae_results.txt", "w") as f:
+    f.write("\n".join(results))
+
+print("Results saved to vae_results.txt")

best_cnn_ae.pth

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

best_lstm_ae.pth

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

best_lstm_forecaster.pth

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

best_sequence_autoencoder.pth

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

best_transformer_ae.pth

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

best_vae.pth

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

main_Fully‐Connected-Sequence-Autoencoder.py

@@ -0,0 +1,354 @@
+import os
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.metrics import (
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+    accuracy_score,
+    classification_report
+)
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+
+# ============================================
+# 1. CÀI ĐẶT CÁC THAM SỐ CHUNG
+# ============================================
+
+# Đường dẫn tới file Excel
+DATA_PATH = "dataset.xlsx"
+
+# Tên các cột đặc trưng (không bao gồm cột label "Water Quality")
+FEATURE_COLUMNS = [
+    "Temp",
+    "Turbidity (cm)",
+    "DO(mg/L)",
+    "BOD (mg/L)",
+    "CO2",
+    "pH`",
+    "Alkalinity (mg L-1 )",
+    "Hardness (mg L-1 )",
+    "Calcium (mg L-1 )",
+    "Ammonia (mg L-1 )",
+    "Nitrite (mg L-1 )",
+    "Phosphorus (mg L-1 )",
+    "H2S (mg L-1 )",
+    "Plankton (No. L-1)"
+]
+LABEL_COL = "Water Quality"
+
+# Độ dài sequence (sliding window)
+SEQUENCE_LENGTH = 10
+
+# Tỉ lệ chia train / validation / test
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+# Hyper-parameters cho Autoencoder
+INPUT_SIZE = len(FEATURE_COLUMNS)           # 14
+SEQ_LEN = SEQUENCE_LENGTH                    # 10
+FLAT_DIM = SEQ_LEN * INPUT_SIZE             # 10 * 14 = 140
+LATENT_DIM = 64
+AE_HIDDEN_DIM = 64
+
+BATCH_SIZE = 64
+AE_LR = 1e-3
+AE_EPOCHS = 50
+RANDOM_STATE = 42
+
+# Hyper-parameters cho anomaly threshold
+THRESHOLD_STD_FACTOR = 2  # mean + 2 * std
+
+# ============================================
+# 2. ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU
+# ============================================
+
+# 2.1 Đọc toàn bộ DataFrame, loại bỏ các hàng hoàn toàn rỗng
+df = pd.read_excel(DATA_PATH)
+df = df.dropna(how="all")
+
+# 2.2 Chuyển cột label sang int
+df[LABEL_COL] = df[LABEL_COL].astype(int)
+labels_all = df[LABEL_COL].values  # mảng nhãn gốc, shape = (num_total,)
+
+# 2.3 Chuyển đổi các cột đặc trưng: thay dấu phẩy thành dấu chấm, convert sang float
+for col in FEATURE_COLUMNS:
+    if df[col].dtype == object or df[col].dtype == str:
+        df[col] = df[col].apply(lambda x: str(x).replace(",", "."))
+    df[col] = df[col].astype(float)
+
+# 2.4 Lấy mảng dữ liệu số (chỉ gồm các cột FEATURE_COLUMNS)
+data_raw = df[FEATURE_COLUMNS].values  # shape = (num_total, 14)
+
+# 2.5 Chuẩn hóa Min-Max
+scaler = MinMaxScaler()
+data_scaled = scaler.fit_transform(data_raw)  # shape = (num_total, 14)
+
+# ============================================
+# 3. TẠO CLASS Dataset CHO TIME-SERIES
+# ============================================
+
+class TimeSeriesDataset(Dataset):
+    """
+    Dataset trả về:
+      - x: một cửa sổ (sequence) có shape (sequence_length, num_features)
+      - y: vector giá trị next step có shape (num_features,)
+    """
+    def __init__(self, data, seq_len):
+        self.data = data
+        self.seq_len = seq_len
+        self.num_items = data.shape[0] - seq_len
+    
+    def __len__(self):
+        return self.num_items
+    
+    def __getitem__(self, idx):
+        """
+        Trả về:
+          x_seq: shape (seq_len, num_features)
+          y_next: shape (num_features,)
+        """
+        x_seq = self.data[idx : idx + self.seq_len]
+        y_next = self.data[idx + self.seq_len]
+        return (
+            torch.tensor(x_seq, dtype=torch.float32),
+            torch.tensor(y_next, dtype=torch.float32)
+        )
+
+# ============================================
+# 4. TẠO MẢNG NHÃN CHO MỖI SEQUENCE (DỰA TRÊN Water Quality)
+# ============================================
+
+num_total = data_scaled.shape[0]
+num_items = num_total - SEQUENCE_LENGTH  # số lượng sequence-to-one
+
+y_seq = np.zeros(num_items, dtype=int)
+for i in range(num_items):
+    idx_label = i + SEQUENCE_LENGTH
+    y_seq[i] = labels_all[idx_label]  # 0, 1, hoặc 2
+
+# ============================================
+# 5. CHIA DỮ LIỆU CÓ PHÂN LỚP (STRATIFIED SPLIT) THEO y_seq
+# ============================================
+
+# 5.1 Chia test (10%)
+sss1 = StratifiedShuffleSplit(n_splits=1, test_size=TEST_RATIO, random_state=RANDOM_STATE)
+for train_val_idx, test_idx in sss1.split(np.zeros(num_items), y_seq):
+    pass
+
+# 5.2 Từ train_val (90%), chia tiếp train (80%) và val (10%)
+train_val_labels = y_seq[train_val_idx]
+val_size_relative = VAL_RATIO / (TRAIN_RATIO + VAL_RATIO)
+sss2 = StratifiedShuffleSplit(n_splits=1, test_size=val_size_relative, random_state=RANDOM_STATE)
+for train_idx_rel, val_idx_rel in sss2.split(np.zeros(len(train_val_idx)), train_val_labels):
+    pass
+
+train_idx = train_val_idx[train_idx_rel]
+val_idx   = train_val_idx[val_idx_rel]
+
+# Hàm đếm phân bố nhãn
+def count_labels(indices, y):
+    unique, counts = np.unique(y[indices], return_counts=True)
+    return dict(zip(unique.tolist(), counts.tolist()))
+
+print("Phân bố nh��n trong tập train:", count_labels(train_idx, y_seq))
+print("Phân bố nhãn trong tập val  :", count_labels(val_idx, y_seq))
+print("Phân bố nhãn trong tập test :", count_labels(test_idx, y_seq))
+
+# ============================================
+# 6. TẠO DATALOADER CHO Train/Val/Test (cho reconstruction)
+# ============================================
+
+# Tạo dataset tổng
+dataset_all = TimeSeriesDataset(data_scaled, SEQUENCE_LENGTH)
+
+# Lọc chỉ các sequence “normal” (nhãn 0 hoặc 1) để huấn luyện autoencoder
+train_normal_idx = [i for i in train_idx if y_seq[i] < 2]
+val_normal_idx   = [i for i in val_idx if y_seq[i] < 2]
+
+train_ae_dataset = Subset(dataset_all, train_normal_idx)
+val_ae_dataset   = Subset(dataset_all, val_normal_idx)
+test_dataset     = Subset(dataset_all, test_idx)  # Dùng toàn bộ test để đánh giá sau
+
+train_ae_loader = DataLoader(train_ae_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+val_ae_loader   = DataLoader(val_ae_dataset,   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+test_loader     = DataLoader(test_dataset,     batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+
+# ============================================
+# 7. XÂY DỰNG MÔ HÌNH AUTOENCODER (FC)
+# ============================================
+
+class SequenceAutoencoder(nn.Module):
+    def __init__(self, seq_len, input_dim, latent_dim):
+        super(SequenceAutoencoder, self).__init__()
+        self.seq_len = seq_len
+        self.input_dim = input_dim
+        self.flat_dim = seq_len * input_dim
+        
+        # Encoder: 140 -> LATENT_DIM
+        self.encoder = nn.Sequential(
+            nn.Linear(self.flat_dim, AE_HIDDEN_DIM),
+            nn.ReLU(),
+            nn.Linear(AE_HIDDEN_DIM, latent_dim),
+            nn.ReLU()
+        )
+        # Decoder: LATENT_DIM -> 140
+        self.decoder = nn.Sequential(
+            nn.Linear(latent_dim, AE_HIDDEN_DIM),
+            nn.ReLU(),
+            nn.Linear(AE_HIDDEN_DIM, self.flat_dim),
+        )
+    
+    def forward(self, x):
+        """
+        x: shape (batch, seq_len, input_dim)
+        Trả về x_recon: shape (batch, seq_len, input_dim)
+        """
+        batch_size = x.size(0)
+        # Flatten: (batch, seq_len * input_dim)
+        x_flat = x.view(batch_size, -1)
+        z = self.encoder(x_flat)                 # (batch, latent_dim)
+        out_flat = self.decoder(z)               # (batch, flat_dim)
+        x_recon = out_flat.view(batch_size, self.seq_len, self.input_dim)
+        return x_recon
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ae_model = SequenceAutoencoder(
+    seq_len=SEQ_LEN,
+    input_dim=INPUT_SIZE,
+    latent_dim=LATENT_DIM
+).to(device)
+
+ae_criterion = nn.MSELoss()
+ae_optimizer = torch.optim.Adam(ae_model.parameters(), lr=AE_LR)
+
+# ============================================
+# 8. HUẤN LUYỆN AUTOENCODER
+# ============================================
+
+best_val_loss = float("inf")
+best_ae_path = "best_sequence_autoencoder.pth"
+
+for epoch in range(1, AE_EPOCHS + 1):
+    # --- Train ---
+    ae_model.train()
+    train_loss_sum = 0.0
+    for x_batch, _ in train_ae_loader:
+        # x_batch: shape (batch, seq_len, input_dim)
+        x_batch = x_batch.to(device)
+        
+        ae_optimizer.zero_grad()
+        x_recon = ae_model(x_batch)
+        loss = ae_criterion(x_recon, x_batch)
+        loss.backward()
+        ae_optimizer.step()
+        
+        train_loss_sum += loss.item() * x_batch.size(0)
+    train_loss = train_loss_sum / len(train_ae_loader.dataset)
+    
+    # --- Validate ---
+    ae_model.eval()
+    val_loss_sum = 0.0
+    with torch.no_grad():
+        for x_batch, _ in val_ae_loader:
+            x_batch = x_batch.to(device)
+            x_recon = ae_model(x_batch)
+            loss = ae_criterion(x_recon, x_batch)
+            val_loss_sum += loss.item() * x_batch.size(0)
+    val_loss = val_loss_sum / len(val_ae_loader.dataset)
+    
+    print(f"Epoch {epoch:02d} | AE Train Loss: {train_loss:.6f} | AE Val Loss: {val_loss:.6f}")
+    
+    if val_loss < best_val_loss:
+        best_val_loss = val_loss
+        torch.save(ae_model.state_dict(), best_ae_path)
+
+# Load lại AE tốt nhất
+ae_model.load_state_dict(torch.load(best_ae_path, map_location=device))
+
+# ============================================
+# 9. TÍNH RECONSTRUCTION ERRORS TRÊN TEST
+# ============================================
+
+# Đầu tiên, lấy reconstruction errors cho tập validation normal (dùng để tính threshold)
+val_norm_errors = []
+ae_model.eval()
+with torch.no_grad():
+    for x_batch, _ in val_ae_loader:
+        x_batch = x_batch.to(device)
+        x_recon = ae_model(x_batch)
+        # Tính MSE mỗi sequence riêng:
+        batch_errors = torch.mean((x_recon - x_batch) ** 2, dim=(1,2))  # (batch,)
+        val_norm_errors.append(batch_errors.cpu().numpy())
+val_norm_errors = np.concatenate(val_norm_errors, axis=0)
+
+# Threshold = mean(val_norm_errors) + k * std(val_norm_errors)
+mu_val = np.mean(val_norm_errors)
+sigma_val = np.std(val_norm_errors)
+threshold = mu_val + THRESHOLD_STD_FACTOR * sigma_val
+
+print(f"\nThreshold (mean + {THRESHOLD_STD_FACTOR}*std) từ tập validation normal: {threshold:.6f}")
+
+# Bây giờ, tính reconstruction errors trên toàn bộ test set (bao gồm normal & anomaly)
+test_errors = []
+ae_model.eval()
+with torch.no_grad():
+    for x_batch, _ in test_loader:
+        x_batch = x_batch.to(device)
+        x_recon = ae_model(x_batch)
+        batch_errors = torch.mean((x_recon - x_batch) ** 2, dim=(1,2))
+        test_errors.append(batch_errors.cpu().numpy())
+test_errors = np.concatenate(test_errors, axis=0)  # shape = (num_test_items,)
+
+# Đánh dấu anomaly nếu error > threshold
+anomalies = test_errors > threshold
+num_anomalies = np.sum(anomalies)
+print(f"Phát hiện {num_anomalies} samples bất thường trong tập test (trên tổng {len(test_errors)})")
+print("Chỉ số sample bất thường (relative to test set):", np.where(anomalies)[0])
+
+# ============================================
+# 10. ĐÁNH GIÁ KẾT QUẢ ANOMALY DETECTION
+# ============================================
+
+# Tạo y_true_binary dựa trên y_seq cho test_idx
+y_true = []
+for idx in test_idx:
+    idx_label = idx + SEQUENCE_LENGTH
+    y_true.append(1 if labels_all[idx_label] == 2 else 0)
+y_true = np.array(y_true, dtype=int)
+y_pred = anomalies.astype(int)
+
+# Tính confusion matrix và các metrics
+cm = confusion_matrix(y_true, y_pred)
+tn, fp, fn, tp = cm.ravel()
+
+precision = precision_score(y_true, y_pred, zero_division=0)
+recall    = recall_score(y_true, y_pred, zero_division=0)
+f1        = f1_score(y_true, y_pred, zero_division=0)
+accuracy  = accuracy_score(y_true, y_pred)
+
+print("\n=== Confusion Matrix ===")
+print(cm)
+print(f"TN: {tn},  FP: {fp}")
+print(f"FN: {fn},  TP: {tp}\n")
+
+print("=== Metrics for Anomaly Detection ===")
+print(f"Accuracy : {accuracy:.4f}")
+print(f"Precision: {precision:.4f}")
+print(f"Recall   : {recall:.4f}")
+print(f"F1-score : {f1:.4f}\n")
+
+print("=== Classification Report ===")
+print(
+    classification_report(
+        y_true,
+        y_pred,
+        target_names=["Normal (0)", "Anomaly (1)"],
+        zero_division=0
+    )
+)

main_LSTM-Forecaster.py

@@ -0,0 +1,341 @@
+import os
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.model_selection import StratifiedShuffleSplit
+from sklearn.metrics import (
+    confusion_matrix,
+    precision_score,
+    recall_score,
+    f1_score,
+    accuracy_score,
+    classification_report
+)
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+
+# ============================================
+# 1. CÀI ĐẶT CÁC THAM SỐ CHUNG
+# ============================================
+
+# Đường dẫn tới file Excel
+DATA_PATH = "dataset.xlsx"
+
+# Tên các cột đặc trưng (không bao gồm cột label "Water Quality")
+FEATURE_COLUMNS = [
+    "Temp",
+    "Turbidity (cm)",
+    "DO(mg/L)",
+    "BOD (mg/L)",
+    "CO2",
+    "pH",
+    "Alkalinity (mg L-1 )",
+    "Hardness (mg L-1 )",
+    "Calcium (mg L-1 )",
+    "Ammonia (mg L-1 )",
+    "Nitrite (mg L-1 )",
+    "Phosphorus (mg L-1 )",
+    "H2S (mg L-1 )",
+    "Plankton (No. L-1)"
+]
+LABEL_COL = "Water Quality"
+
+# Độ dài sequence (sliding window)
+SEQUENCE_LENGTH = 10
+
+# Tỉ lệ chia train / validation / test
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+# Hyper-parameters cho mô hình LSTM
+INPUT_SIZE = len(FEATURE_COLUMNS)   # 14
+HIDDEN_SIZE = 64
+NUM_LAYERS = 2
+BATCH_SIZE = 64
+NUM_EPOCHS = 50
+LEARNING_RATE = 1e-3
+RANDOM_STATE = 42
+
+# ============================================
+# 2. ĐỌC VÀ TIỀN XỬ LÝ DỮ LIỆU
+# ============================================
+
+# 2.1 Đọc toàn bộ DataFrame, loại bỏ các hàng hoàn toàn rỗng
+df = pd.read_excel(DATA_PATH)
+df = df.dropna(how="all")
+
+# 2.2 Xử lý cột label
+df[LABEL_COL] = df[LABEL_COL].astype(int)
+labels_all = df[LABEL_COL].values  # mảng nhãn gốc, shape = (num_total,)
+
+# 2.3 Chuyển đổi các cột đặc trưng:
+#     - Thay dấu phẩy thành dấu chấm (nếu có)
+#     - Chuyển sang float
+for col in FEATURE_COLUMNS:
+    if df[col].dtype == object or df[col].dtype == str:
+        df[col] = df[col].apply(lambda x: str(x).replace(",", "."))
+    df[col] = df[col].astype(float)
+
+# 2.4 Lấy mảng dữ liệu số (chỉ gồm các cột FEATURE_COLUMNS)
+data_raw = df[FEATURE_COLUMNS].values  # shape = (num_total, 14)
+
+# 2.5 Chuẩn hóa Min-Max
+scaler = MinMaxScaler()
+data_scaled = scaler.fit_transform(data_raw)  # shape = (num_total, 14)
+
+# ============================================
+# 3. TẠO CLASS Dataset CHO TIME-SERIES
+# ============================================
+
+class TimeSeriesDataset(Dataset):
+    """
+    Dataset trả về:
+      - x: một cửa sổ (sequence) có shape (sequence_length, num_features)
+      - y: vector giá trị next step có shape (num_features,)
+    """
+    def __init__(self, data, seq_len):
+        """
+        data: numpy array shape (num_samples, num_features), đã chuẩn hóa
+        seq_len: độ dài của x sequence
+        """
+        self.data = data
+        self.seq_len = seq_len
+        # Số lượng item thực tế = num_samples - seq_len
+        self.num_items = data.shape[0] - seq_len
+    
+    def __len__(self):
+        return self.num_items
+    
+    def __getitem__(self, idx):
+        # x: data[idx : idx + seq_len], y: data[idx + seq_len]
+        x = self.data[idx : idx + self.seq_len]               # shape = (seq_len, num_features)
+        y = self.data[idx + self.seq_len]                      # shape = (num_features,)
+        x = torch.tensor(x, dtype=torch.float32)
+        y = torch.tensor(y, dtype=torch.float32)
+        return x, y
+
+# ============================================
+# 4. TẠO MẢNG NHÃN CHO MỖI SEQUENCE (DỰA TRÊN Water Quality)
+# ============================================
+
+num_total = data_scaled.shape[0]
+num_items = num_total - SEQUENCE_LENGTH  # số lượng sequence-to-one
+
+# Tạo mảng y_seq: nhãn Water Quality tại vị trí i + SEQUENCE_LENGTH
+y_seq = np.zeros(num_items, dtype=int)
+for i in range(num_items):
+    idx_label = i + SEQUENCE_LENGTH
+    y_seq[i] = labels_all[idx_label]  # 0, 1, hoặc 2
+
+# ============================================
+# 5. CHIA DỮ LIỆU CÓ PHÂN LỚP (STRATIFIED SPLIT) THEO y_seq
+# ============================================
+
+# 5.1 Chia test (10%) trước
+sss1 = StratifiedShuffleSplit(n_splits=1, test_size=TEST_RATIO, random_state=RANDOM_STATE)
+for train_val_idx, test_idx in sss1.split(np.zeros(num_items), y_seq):
+    pass
+
+# 5.2 Từ phần train_val (90%), chia tiếp thành train (80%) và val (10%)
+train_val_labels = y_seq[train_val_idx]
+val_size_relative = VAL_RATIO / (TRAIN_RATIO + VAL_RATIO)
+sss2 = StratifiedShuffleSplit(n_splits=1, test_size=val_size_relative, random_state=RANDOM_STATE)
+for train_idx_rel, val_idx_rel in sss2.split(np.zeros(len(train_val_idx)), train_val_labels):
+    pass
+
+# Chuyển index tương đối sang index tuyệt đối trong num_items
+train_idx = train_val_idx[train_idx_rel]
+val_idx   = train_val_idx[val_idx_rel]
+
+# In ra số lượng mỗi nhãn trong từng tập
+def count_labels(indices, y):
+    unique, counts = np.unique(y[indices], return_counts=True)
+    return dict(zip(unique.tolist(), counts.tolist()))
+
+print("Phân bố nhãn trong tập train:", count_labels(train_idx, y_seq))
+print("Phân bố nhãn trong tập val  :", count_labels(val_idx, y_seq))
+print("Phân bố nhãn trong tập test :", count_labels(test_idx, y_seq))
+
+# ============================================
+# 6. TẠO DataLoader CHO Train/Val/Test
+# ============================================
+
+dataset_all = TimeSeriesDataset(data_scaled, SEQUENCE_LENGTH)
+
+train_dataset = Subset(dataset_all, train_idx)
+val_dataset   = Subset(dataset_all, val_idx)
+test_dataset  = Subset(dataset_all, test_idx)
+
+train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
+val_loader   = DataLoader(val_dataset,   batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+test_loader  = DataLoader(test_dataset,  batch_size=BATCH_SIZE, shuffle=False, drop_last=False)
+
+# ============================================
+# 7. XÂY DỰNG MÔ HÌNH LSTM FORECASTER
+# ============================================
+
+class LSTMForecaster(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers):
+        super(LSTMForecaster, self).__init__()
+        self.lstm = nn.LSTM(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True
+        )
+        self.linear = nn.Linear(hidden_size, input_size)
+    
+    def forward(self, x):
+        """
+        x: shape (batch_size, seq_len, input_size)
+        Trả về y_pred: shape (batch_size, input_size)
+        """
+        out, (hn, cn) = self.lstm(x)       
+        last_hidden = hn[-1]               
+        y_pred = self.linear(last_hidden)  
+        return y_pred
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = LSTMForecaster(
+    input_size=INPUT_SIZE,
+    hidden_size=HIDDEN_SIZE,
+    num_layers=NUM_LAYERS
+).to(device)
+
+criterion = nn.MSELoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
+
+# ============================================
+# 8. HÀM HUẤN LUYỆN VÀ EVALUATION
+# ============================================
+
+def train_one_epoch(model, loader, criterion, optimizer, device):
+    model.train()
+    epoch_loss = 0.0
+    for x_batch, y_batch in loader:
+        x_batch = x_batch.to(device)
+        y_batch = y_batch.to(device)
+        
+        optimizer.zero_grad()
+        y_pred = model(x_batch)
+        loss = criterion(y_pred, y_batch)
+        loss.backward()
+        optimizer.step()
+        
+        epoch_loss += loss.item() * x_batch.size(0)
+    return epoch_loss / len(loader.dataset)
+
+def evaluate(model, loader, criterion, device):
+    model.eval()
+    epoch_loss = 0.0
+    with torch.no_grad():
+        for x_batch, y_batch in loader:
+            x_batch = x_batch.to(device)
+            y_batch = y_batch.to(device)
+            y_pred = model(x_batch)
+            loss = criterion(y_pred, y_batch)
+            epoch_loss += loss.item() * x_batch.size(0)
+    return epoch_loss / len(loader.dataset)
+
+# ============================================
+# 9. VÒNG LẶP HUẤN LUYỆN CHÍNH
+# ============================================
+
+best_val_loss = float("inf")
+best_model_path = "best_lstm_forecaster.pth"
+
+for epoch in range(1, NUM_EPOCHS + 1):
+    train_loss = train_one_epoch(model, train_loader, criterion, optimizer, device)
+    val_loss   = evaluate(model, val_loader, criterion, device)
+    
+    print(f"Epoch {epoch:02d} | Train Loss: {train_loss:.6f} | Val Loss: {val_loss:.6f}")
+    
+    if val_loss < best_val_loss:
+        best_val_loss = val_loss
+        torch.save(model.state_dict(), best_model_path)
+
+# Tải lại mô hình tốt nhất
+model.load_state_dict(torch.load(best_model_path, map_location=device))
+
+# ============================================
+# 10. ĐÁNH GIÁ TRÊN TẬP TEST & PHÁT HIỆN BẤT THƯỜNG
+# ============================================
+
+# 10.1 Tính test loss
+test_loss = evaluate(model, test_loader, criterion, device)
+print(f"\nTest Loss: {test_loss:.6f}")
+
+# 10.2 Tính lỗi MSE cho từng sample trong test
+all_errors = []
+model.eval()
+with torch.no_grad():
+    for x_batch, y_batch in test_loader:
+        x_batch = x_batch.to(device)
+        y_batch = y_batch.to(device)
+        y_pred = model(x_batch)
+        batch_errors = torch.mean((y_pred - y_batch) ** 2, dim=1)  # shape = (batch,)
+        all_errors.append(batch_errors.cpu().numpy())
+all_errors = np.concatenate(all_errors, axis=0)  # shape = (num_test_items,)
+
+# 10.3 Xác định ngưỡng threshold
+mu = np.mean(all_errors)
+sigma = np.std(all_errors)
+
+# Chọn ngưỡng mean + 2*std (thay vì 3*std) để tăng recall
+threshold = mu + 2 * sigma
+
+# Nếu muốn, có thể thử percentile, ví dụ 95th percentile:
+# threshold = np.percentile(all_errors, 95)
+
+anomalies = all_errors > threshold  # bool array
+num_anomalies = np.sum(anomalies)
+print(f"Threshold (mean + 2*std): {threshold:.6f}")
+print(f"Phát hiện {num_anomalies} samples bất thường trong tập test (trên tổng {len(all_errors)})")
+print("Chỉ số sample bất thường (relative to test set):", np.where(anomalies)[0])
+
+# ============================================
+# 11. TÍNH CÁC CHỈ SỐ ĐÁNH GIÁ ANOMALY DETECTION
+# ============================================
+
+# 11.1 Xây mảng y_true_binary tương ứng với mỗi sequence trong test:
+#     water quality = 2 → anomaly (1); = 0 hoặc 1 → normal (0)
+y_true = []
+for idx in test_idx:
+    idx_label = idx + SEQUENCE_LENGTH
+    y_true.append(1 if labels_all[idx_label] == 2 else 0)
+y_true = np.array(y_true, dtype=int)
+
+# 11.2 Chuyển anomalies (bool) sang y_pred (0/1)
+y_pred = anomalies.astype(int)
+
+# 11.3 Tính confusion matrix và metrics
+cm = confusion_matrix(y_true, y_pred)
+tn, fp, fn, tp = cm.ravel()
+
+precision = precision_score(y_true, y_pred, zero_division=0)
+recall    = recall_score(y_true, y_pred, zero_division=0)
+f1        = f1_score(y_true, y_pred, zero_division=0)
+accuracy  = accuracy_score(y_true, y_pred)
+
+print("\n=== Confusion Matrix ===")
+print(cm)
+print(f"TN: {tn},  FP: {fp}")
+print(f"FN: {fn},  TP: {tp}\n")
+
+print("=== Metrics for Anomaly Detection ===")
+print(f"Accuracy : {accuracy:.4f}")
+print(f"Precision: {precision:.4f}")
+print(f"Recall   : {recall:.4f}")
+print(f"F1-score : {f1:.4f}\n")
+
+print("=== Classification Report ===")
+print(
+    classification_report(
+        y_true, 
+        y_pred, 
+        target_names=["Normal (0)", "Anomaly (1)"],
+        zero_division=0
+    )
+)