Datasets:

ivanpodd
/

S-OH

"""
Example ML/AI Use Case: CNN Classifier for Disease Detection
Demonstrates:
- Data loading and preprocessing
- Temporal split application
- Model definition (HeightWiseCNN)
- Training loop with early stopping
- Evaluation (ROC AUC, confusion matrix)
"""

import os
import json
import numpy as np
import pandas as pd
from pathlib import Path
from sklearn.metrics import roc_auc_score, confusion_matrix, classification_report
from sklearn.preprocessing import PolynomialFeatures
import matplotlib.pyplot as plt
import seaborn as sns

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

# ============================================
# CONFIGURATION
# ============================================

METADATA_PATH = Path("../metadata.csv")
DATA_DIR = Path("../data")
MANIFEST_PATH = DATA_DIR / "manifest.json"

TARGET_DISEASE = 'Z00'    # Lung cancer
TEST_WEEKS = {9, 10, 11}  # Weeks 8-10 for testing
EPOCHS = 20
BATCH_SIZE = 16
LEARNING_RATE = 1e-3
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# ============================================
# MODEL DEFINITION
# ============================================

class HeightWiseCNN(nn.Module):
    """
    Height-wise CNN for multivariate time series classification.
    Treats each channel as a separate "height" dimension and applies 2D convolutions
    across the temporal dimension.
    """
    def __init__(self, num_classes=2, input_height=374, input_width=337):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=(input_height, 15), padding=(0, 2))
        self.pool = nn.MaxPool2d(kernel_size=(1, 2))
        self.conv2 = nn.Conv2d(32, 64, kernel_size=(1, 10), padding='same')
        self.conv3 = nn.Conv2d(64, 128, kernel_size=(1, 20), padding='same')
        self.head_pool = nn.AdaptiveMaxPool2d((1, 1))
        self.dropout = nn.Dropout(0.1)
        self.fc1 = nn.Linear(128, 256)
        self.fc2 = nn.Linear(256, num_classes)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(x)
        x = F.relu(self.conv2(x))
        x = self.pool(x)
        x = F.relu(self.conv3(x))
        x = self.head_pool(x)
        x = x.flatten(1)
        x = self.dropout(x)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        return self.fc2(x)


# ============================================
# DATASET CLASS
# ============================================

class CustomDataset(Dataset):
    def __init__(self, data, labels, transform=None):
        self.data = data
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        sample = self.data[idx]
        label = int(self.labels[idx])
        if self.transform:
            sample = self.transform(sample)
        return sample, label


# ============================================
# DATA LOADING FUNCTIONS
# ============================================

def load_patient_data(patient_id):
    """Load a single patient's JSON file."""
    with open(MANIFEST_PATH, 'r') as f:
        manifest = json.load(f)

    entry = next((e for e in manifest['files'] if e['patient_id'] == patient_id), None)
    if entry is None:
        return None

    file_path = DATA_DIR / entry['file']
    with open(file_path, 'r') as f:
        return json.load(f)


def extract_enose_signals(patient_data, channels=None):
    """Extract eNose signals from patient data."""
    if channels is None:
        channels = [f'R{i}' for i in range(1, 18)]  # R1-R17

    for sensor in patient_data['sensors']:
        if sensor['id'] == 'enose':
            signals = []
            for channel in sensor['channels']:
                if channel['id'] in channels:
                    signals.append(np.array(channel['samples']))
            return np.array(signals).T  # shape: (time_steps, channels)

    return None


def preprocess_signal(signal):
    """
    Preprocess a single signal:
    1. Wavelet smoothing (db4, level 4)
    2. Min-max scaling
    """
    import pywt
    from sklearn.preprocessing import minmax_scale
    
    coeffs = pywt.wavedec(signal, 'db4', level=4)
    coeffs[1:] = [np.zeros_like(c) for c in coeffs[1:]]
    smoothed = pywt.waverec(coeffs, 'db4')
    return minmax_scale(smoothed, axis=0)


def load_and_preprocess_data():
    """Load full dataset and preprocess eNose signals."""
    metadata = pd.read_csv(METADATA_PATH)
    X = []
    y = []
    patient_ids = []

    # Stable channels (based on manufacturer recommendation)
    channels = ['R2', 'R3', 'R5', 'R8', 'R11', 'R12', 'R13', 'R14', 'R15', 'R16', 'R17']

    poly = PolynomialFeatures(degree=3, include_bias=False, interaction_only=False)

    with open(MANIFEST_PATH, 'r') as f:
        manifest = json.load(f)

    poly = PolynomialFeatures(degree=3, include_bias=False, interaction_only=False)
    dummy = np.random.random((11,337))
    poly.fit_transform(dummy.T).T  # (11 + C(11,2) + 11 = 77, 358)

    for entry in manifest['files']:
        patient_id = entry['patient_id']
        row = metadata[metadata['Patient_id'] == patient_id].iloc[0]

        # Binary label: 1 if target disease, else 0
        label = 1 if row['Diagnosis'] == TARGET_DISEASE else 0

        patient_data = load_patient_data(patient_id)
        if patient_data is None:
            continue

        # Extract raw signals
        raw_signals = []
        for sensor in patient_data['sensors']:
            if sensor['id'] == 'enose':
                for channel in sensor['channels']:
                    if channel['id'] in channels:
                        raw_signals.append(np.array(channel['samples']))
                break

        if len(raw_signals) == 0:
            continue

        # Preprocess each channel
        processed_signals = []
        for sig in raw_signals:
            # Clip to active measurement period (20-450 samples)
            clipped = sig[20:450]
            processed = preprocess_signal(clipped)
            processed_signals.append(processed)

        # Stack signals: shape (channels, time_steps)
        processed_signals = np.array(processed_signals)[:11,:337]
        if processed_signals.shape[0]*processed_signals.shape[1]==11*337:
            poly_features = poly.transform(processed_signals.T).T  # (11 + C(11,2) + 11 = 77, 358)\n",
            extended_features = np.vstack([processed_signals, poly_features])
            X.append(extended_features)
            y.append(label)
            patient_ids.append(patient_id)    

    y = np.array(y)
    patient_ids = np.array(patient_ids)
    X = np.array(X, dtype=np.float32)

    return X, y, patient_ids


def get_temporal_split(metadata, patient_ids):
    """Get train/test split based on weeks."""
    train_mask = np.zeros(len(patient_ids), dtype=bool)
    test_mask = np.zeros(len(patient_ids), dtype=bool)

    for i, pid in enumerate(patient_ids):
        row = metadata[metadata['Patient_id'] == pid].iloc[0]
        week = row['Week']
        if week in TEST_WEEKS:
            test_mask[i] = True
        else:
            train_mask[i] = True

    return train_mask, test_mask


# ============================================
# TRAINING FUNCTIONS
# ============================================

def roc_auc_score_torch(outputs, labels):
    """Compute ROC AUC from model outputs and labels."""
    probs = F.softmax(outputs, dim=1)[:, 1]
    return roc_auc_score(labels.cpu().numpy(), probs.detach().cpu().numpy())


def train_epoch(model, loader, optimizer, criterion, device):
    """Train for one epoch."""
    model.train()
    total_loss = 0.0
    total_count = 0
    all_outputs = []
    all_targets = []

    for data, target in loader:
        data, target = data.to(device), target.to(device, dtype=torch.long)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        bs = data.size(0)
        total_loss += loss.item() * bs
        total_count += bs
        all_outputs.append(output)
        all_targets.append(target)

    all_outputs = torch.cat(all_outputs)
    all_targets = torch.cat(all_targets)
    avg_loss = total_loss / total_count
    avg_auc = roc_auc_score_torch(all_outputs, all_targets)

    return avg_loss, avg_auc


def validate(model, loader, criterion, device):
    """Validate the model."""
    model.eval()
    total_loss = 0.0
    total_count = 0
    all_outputs = []
    all_targets = []

    with torch.no_grad():
        for data, target in loader:
            data, target = data.to(device), target.to(device, dtype=torch.long)
            output = model(data)
            loss = criterion(output, target)

            bs = data.size(0)
            total_loss += loss.item() * bs
            total_count += bs
            all_outputs.append(output)
            all_targets.append(target)

    all_outputs = torch.cat(all_outputs)
    all_targets = torch.cat(all_targets)
    avg_loss = total_loss / total_count
    avg_auc = roc_auc_score_torch(all_outputs, all_targets)

    return avg_loss, avg_auc


def main():
    print("=" * 60)
    print("HELTH DETECTION WITH HEIGHT-WISE CNN")
    print(f"Target: {TARGET_DISEASE}")
    print(f"Test weeks: {TEST_WEEKS}")
    print(f"Device: {DEVICE}")
    print("=" * 60)

    # 1. Load and preprocess data
    print("\n1. Loading and preprocessing data...")
    X, y, patient_ids = load_and_preprocess_data()
    metadata = pd.read_csv(METADATA_PATH)
    print(f"   Total samples: {len(X)}")
    print(f"   Positive ({TARGET_DISEASE}): {sum(y)}")
    print(f"   Negative: {len(y) - sum(y)}")

    # 2. Temporal split
    print("\n2. Applying temporal split...")
    train_mask, test_mask = get_temporal_split(metadata, patient_ids)
    print(f"   Train samples: {train_mask.sum()}")
    print(f"   Test samples: {test_mask.sum()}")

    X_train = X[train_mask]
    y_train = y[train_mask]
    X_test = X[test_mask]
    y_test = y[test_mask]

    # 3. Create datasets and dataloaders
    print("\n3. Creating datasets...")
    transform = transforms.Compose([
        transforms.ToTensor(),  # (H,W) -> (1,H,W)
    ])

    train_dataset = CustomDataset(X_train, y_train, transform=transform)
    test_dataset = CustomDataset(X_test, y_test, transform=transform)

    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)

    # 4. Initialize model
    print("\n4. Initializing model...")
    model = HeightWiseCNN(num_classes=2).to(DEVICE)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
    
    print(f"   Model parameters: {sum(p.numel() for p in model.parameters()):,}")

    # 5. Training loop
    print("\n5. Training...")
    best_val_auc = 0.0
    
    for epoch in range(EPOCHS):
        train_loss, train_auc = train_epoch(model, train_loader, optimizer, criterion, DEVICE)
        val_loss, val_auc = validate(model, test_loader, criterion, DEVICE)
        scheduler.step()

        if val_auc > best_val_auc:
            best_val_auc = val_auc
            torch.save(model.state_dict(), 'cnn_best.pth')

        if (epoch + 1) % 5 == 0:
            print(f"   Epoch {epoch+1:02d}/{EPOCHS}: "
                  f"Train Loss: {train_loss:.4f}, Train AUC: {train_auc:.4f}, "
                  f"Val Loss: {val_loss:.4f}, Val AUC: {val_auc:.4f}")

    print(f"\n   Best validation AUC: {best_val_auc:.4f}")

    # 6. Load best model and evaluate
    print("\n6. Evaluating best model on test set...")
    model.load_state_dict(torch.load('cnn_best.pth'))
    
    # Full evaluation on test set
    model.eval()
    all_probs = []
    all_targets = []
    
    with torch.no_grad():
        for data, target in test_loader:
            data = data.to(DEVICE)
            output = model(data)
            probs = F.softmax(output, dim=1)[:, 1]
            all_probs.extend(probs.cpu().numpy())
            all_targets.extend(target.numpy())
    
    all_probs = np.array(all_probs)
    all_targets = np.array(all_targets)
    
    auc = roc_auc_score(all_targets, all_probs)
    
    print(f"\n   ROC AUC: {auc:.4f}")
    print("\n✅ Done!")


if __name__ == "__main__":
    main()

	"""
	Example ML/AI Use Case: CNN Classifier for Disease Detection
	Demonstrates:
	- Data loading and preprocessing
	- Temporal split application
	- Model definition (HeightWiseCNN)
	- Training loop with early stopping
	- Evaluation (ROC AUC, confusion matrix)
	"""

	import os
	import json
	import numpy as np
	import pandas as pd
	from pathlib import Path
	from sklearn.metrics import roc_auc_score, confusion_matrix, classification_report
	from sklearn.preprocessing import PolynomialFeatures
	import matplotlib.pyplot as plt
	import seaborn as sns

	import torch
	import torch.nn as nn
	import torch.optim as optim
	import torch.nn.functional as F
	from torch.utils.data import Dataset, DataLoader
	from torchvision import transforms

	# ============================================
	# CONFIGURATION
	# ============================================

	METADATA_PATH = Path("../metadata.csv")
	DATA_DIR = Path("../data")
	MANIFEST_PATH = DATA_DIR / "manifest.json"

	TARGET_DISEASE = 'Z00' # Lung cancer
	TEST_WEEKS = {9, 10, 11} # Weeks 8-10 for testing
	EPOCHS = 20
	BATCH_SIZE = 16
	LEARNING_RATE = 1e-3
	DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

	# ============================================
	# MODEL DEFINITION
	# ============================================

	class HeightWiseCNN(nn.Module):
	"""
	Height-wise CNN for multivariate time series classification.
	Treats each channel as a separate "height" dimension and applies 2D convolutions
	across the temporal dimension.
	"""
	def __init__(self, num_classes=2, input_height=374, input_width=337):
	super().__init__()
	self.conv1 = nn.Conv2d(1, 32, kernel_size=(input_height, 15), padding=(0, 2))
	self.pool = nn.MaxPool2d(kernel_size=(1, 2))
	self.conv2 = nn.Conv2d(32, 64, kernel_size=(1, 10), padding='same')
	self.conv3 = nn.Conv2d(64, 128, kernel_size=(1, 20), padding='same')
	self.head_pool = nn.AdaptiveMaxPool2d((1, 1))
	self.dropout = nn.Dropout(0.1)
	self.fc1 = nn.Linear(128, 256)
	self.fc2 = nn.Linear(256, num_classes)

	def forward(self, x):
	x = F.relu(self.conv1(x))
	x = self.pool(x)
	x = F.relu(self.conv2(x))
	x = self.pool(x)
	x = F.relu(self.conv3(x))
	x = self.head_pool(x)
	x = x.flatten(1)
	x = self.dropout(x)
	x = F.relu(self.fc1(x))
	x = self.dropout(x)
	return self.fc2(x)


	# ============================================
	# DATASET CLASS
	# ============================================

	class CustomDataset(Dataset):
	def __init__(self, data, labels, transform=None):
	self.data = data
	self.labels = labels
	self.transform = transform

	def __len__(self):
	return len(self.data)

	def __getitem__(self, idx):
	sample = self.data[idx]
	label = int(self.labels[idx])
	if self.transform:
	sample = self.transform(sample)
	return sample, label


	# ============================================
	# DATA LOADING FUNCTIONS
	# ============================================

	def load_patient_data(patient_id):
	"""Load a single patient's JSON file."""
	with open(MANIFEST_PATH, 'r') as f:
	manifest = json.load(f)

	entry = next((e for e in manifest['files'] if e['patient_id'] == patient_id), None)
	if entry is None:
	return None

	file_path = DATA_DIR / entry['file']
	with open(file_path, 'r') as f:
	return json.load(f)


	def extract_enose_signals(patient_data, channels=None):
	"""Extract eNose signals from patient data."""
	if channels is None:
	channels = [f'R{i}' for i in range(1, 18)] # R1-R17

	for sensor in patient_data['sensors']:
	if sensor['id'] == 'enose':
	signals = []
	for channel in sensor['channels']:
	if channel['id'] in channels:
	signals.append(np.array(channel['samples']))
	return np.array(signals).T # shape: (time_steps, channels)

	return None


	def preprocess_signal(signal):
	"""
	Preprocess a single signal:
	1. Wavelet smoothing (db4, level 4)
	2. Min-max scaling
	"""
	import pywt
	from sklearn.preprocessing import minmax_scale

	coeffs = pywt.wavedec(signal, 'db4', level=4)
	coeffs[1:] = [np.zeros_like(c) for c in coeffs[1:]]
	smoothed = pywt.waverec(coeffs, 'db4')
	return minmax_scale(smoothed, axis=0)


	def load_and_preprocess_data():
	"""Load full dataset and preprocess eNose signals."""
	metadata = pd.read_csv(METADATA_PATH)
	X = []
	y = []
	patient_ids = []

	# Stable channels (based on manufacturer recommendation)
	channels = ['R2', 'R3', 'R5', 'R8', 'R11', 'R12', 'R13', 'R14', 'R15', 'R16', 'R17']

	poly = PolynomialFeatures(degree=3, include_bias=False, interaction_only=False)

	with open(MANIFEST_PATH, 'r') as f:
	manifest = json.load(f)

	poly = PolynomialFeatures(degree=3, include_bias=False, interaction_only=False)
	dummy = np.random.random((11,337))
	poly.fit_transform(dummy.T).T # (11 + C(11,2) + 11 = 77, 358)

	for entry in manifest['files']:
	patient_id = entry['patient_id']
	row = metadata[metadata['Patient_id'] == patient_id].iloc[0]

	# Binary label: 1 if target disease, else 0
	label = 1 if row['Diagnosis'] == TARGET_DISEASE else 0

	patient_data = load_patient_data(patient_id)
	if patient_data is None:
	continue

	# Extract raw signals
	raw_signals = []
	for sensor in patient_data['sensors']:
	if sensor['id'] == 'enose':
	for channel in sensor['channels']:
	if channel['id'] in channels:
	raw_signals.append(np.array(channel['samples']))
	break

	if len(raw_signals) == 0:
	continue

	# Preprocess each channel
	processed_signals = []
	for sig in raw_signals:
	# Clip to active measurement period (20-450 samples)
	clipped = sig[20:450]
	processed = preprocess_signal(clipped)
	processed_signals.append(processed)

	# Stack signals: shape (channels, time_steps)
	processed_signals = np.array(processed_signals)[:11,:337]
	if processed_signals.shape[0]processed_signals.shape[1]==11337:
	poly_features = poly.transform(processed_signals.T).T # (11 + C(11,2) + 11 = 77, 358)\n",
	extended_features = np.vstack([processed_signals, poly_features])
	X.append(extended_features)
	y.append(label)
	patient_ids.append(patient_id)

	y = np.array(y)
	patient_ids = np.array(patient_ids)
	X = np.array(X, dtype=np.float32)

	return X, y, patient_ids


	def get_temporal_split(metadata, patient_ids):
	"""Get train/test split based on weeks."""
	train_mask = np.zeros(len(patient_ids), dtype=bool)
	test_mask = np.zeros(len(patient_ids), dtype=bool)

	for i, pid in enumerate(patient_ids):
	row = metadata[metadata['Patient_id'] == pid].iloc[0]
	week = row['Week']
	if week in TEST_WEEKS:
	test_mask[i] = True
	else:
	train_mask[i] = True

	return train_mask, test_mask


	# ============================================
	# TRAINING FUNCTIONS
	# ============================================

	def roc_auc_score_torch(outputs, labels):
	"""Compute ROC AUC from model outputs and labels."""
	probs = F.softmax(outputs, dim=1)[:, 1]
	return roc_auc_score(labels.cpu().numpy(), probs.detach().cpu().numpy())


	def train_epoch(model, loader, optimizer, criterion, device):
	"""Train for one epoch."""
	model.train()
	total_loss = 0.0
	total_count = 0
	all_outputs = []
	all_targets = []

	for data, target in loader:
	data, target = data.to(device), target.to(device, dtype=torch.long)
	optimizer.zero_grad()
	output = model(data)
	loss = criterion(output, target)
	loss.backward()
	optimizer.step()

	bs = data.size(0)
	total_loss += loss.item() * bs
	total_count += bs
	all_outputs.append(output)
	all_targets.append(target)

	all_outputs = torch.cat(all_outputs)
	all_targets = torch.cat(all_targets)
	avg_loss = total_loss / total_count
	avg_auc = roc_auc_score_torch(all_outputs, all_targets)

	return avg_loss, avg_auc


	def validate(model, loader, criterion, device):
	"""Validate the model."""
	model.eval()
	total_loss = 0.0
	total_count = 0
	all_outputs = []
	all_targets = []

	with torch.no_grad():
	for data, target in loader:
	data, target = data.to(device), target.to(device, dtype=torch.long)
	output = model(data)
	loss = criterion(output, target)

	bs = data.size(0)
	total_loss += loss.item() * bs
	total_count += bs
	all_outputs.append(output)
	all_targets.append(target)

	all_outputs = torch.cat(all_outputs)
	all_targets = torch.cat(all_targets)
	avg_loss = total_loss / total_count
	avg_auc = roc_auc_score_torch(all_outputs, all_targets)

	return avg_loss, avg_auc


	def main():
	print("=" * 60)
	print("HELTH DETECTION WITH HEIGHT-WISE CNN")
	print(f"Target: {TARGET_DISEASE}")
	print(f"Test weeks: {TEST_WEEKS}")
	print(f"Device: {DEVICE}")
	print("=" * 60)

	# 1. Load and preprocess data
	print("\n1. Loading and preprocessing data...")
	X, y, patient_ids = load_and_preprocess_data()
	metadata = pd.read_csv(METADATA_PATH)
	print(f" Total samples: {len(X)}")
	print(f" Positive ({TARGET_DISEASE}): {sum(y)}")
	print(f" Negative: {len(y) - sum(y)}")

	# 2. Temporal split
	print("\n2. Applying temporal split...")
	train_mask, test_mask = get_temporal_split(metadata, patient_ids)
	print(f" Train samples: {train_mask.sum()}")
	print(f" Test samples: {test_mask.sum()}")

	X_train = X[train_mask]
	y_train = y[train_mask]
	X_test = X[test_mask]
	y_test = y[test_mask]

	# 3. Create datasets and dataloaders
	print("\n3. Creating datasets...")
	transform = transforms.Compose([
	transforms.ToTensor(), # (H,W) -> (1,H,W)
	])

	train_dataset = CustomDataset(X_train, y_train, transform=transform)
	test_dataset = CustomDataset(X_test, y_test, transform=transform)

	train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
	test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)

	# 4. Initialize model
	print("\n4. Initializing model...")
	model = HeightWiseCNN(num_classes=2).to(DEVICE)
	criterion = nn.CrossEntropyLoss()
	optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
	scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)

	print(f" Model parameters: {sum(p.numel() for p in model.parameters()):,}")

	# 5. Training loop
	print("\n5. Training...")
	best_val_auc = 0.0

	for epoch in range(EPOCHS):
	train_loss, train_auc = train_epoch(model, train_loader, optimizer, criterion, DEVICE)
	val_loss, val_auc = validate(model, test_loader, criterion, DEVICE)
	scheduler.step()

	if val_auc > best_val_auc:
	best_val_auc = val_auc
	torch.save(model.state_dict(), 'cnn_best.pth')

	if (epoch + 1) % 5 == 0:
	print(f" Epoch {epoch+1:02d}/{EPOCHS}: "
	f"Train Loss: {train_loss:.4f}, Train AUC: {train_auc:.4f}, "
	f"Val Loss: {val_loss:.4f}, Val AUC: {val_auc:.4f}")

	print(f"\n Best validation AUC: {best_val_auc:.4f}")

	# 6. Load best model and evaluate
	print("\n6. Evaluating best model on test set...")
	model.load_state_dict(torch.load('cnn_best.pth'))

	# Full evaluation on test set
	model.eval()
	all_probs = []
	all_targets = []

	with torch.no_grad():
	for data, target in test_loader:
	data = data.to(DEVICE)
	output = model(data)
	probs = F.softmax(output, dim=1)[:, 1]
	all_probs.extend(probs.cpu().numpy())
	all_targets.extend(target.numpy())

	all_probs = np.array(all_probs)
	all_targets = np.array(all_targets)

	auc = roc_auc_score(all_targets, all_probs)

	print(f"\n ROC AUC: {auc:.4f}")
	print("\n✅ Done!")


	if __name__ == "__main__":
	main()