Spaces:
Sleeping
Sleeping
File size: 5,322 Bytes
f5288df |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 |
import torch
import pandas as pd
import os
from tqdm import tqdm
from torch.utils.data import DataLoader
from torch.cuda.amp import autocast
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score, accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
import numpy as np
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from dataset2 import MedicalImageDatasetBalancedIntensity3D
from model import Backbone, SingleScanModel, Classifier
from utils import BaseConfig
def calculate_metrics(pred_probs, pred_labels, true_labels):
"""
Multi-class classification metrics.
Args:
pred_probs (numpy.ndarray): Predicted probabilities for each class
pred_labels (numpy.ndarray): Predicted labels
true_labels (numpy.ndarray): Ground truth labels
Returns:
dict: Dictionary containing accuracy, precision, recall, F1, and AUC metrics
"""
accuracy = accuracy_score(true_labels, pred_labels)
precision = precision_score(true_labels, pred_labels, average='weighted')
recall = recall_score(true_labels, pred_labels, average='weighted')
f1 = f1_score(true_labels, pred_labels, average='weighted')
# For multi-class, we use ROC AUC OVR (One-vs-Rest)
auc = roc_auc_score(true_labels, pred_probs, multi_class='ovr')
return {
'accuracy': accuracy,
'precision': precision,
'recall': recall,
'f1': f1,
'auc': auc
}
#============================
# INFERENCE CLASS
#============================
class SequenceInference(BaseConfig):
"""
Inference class for sequence classification model.
"""
def __init__(self):
super().__init__()
self.setup_model()
self.setup_data()
def setup_model(self):
config = self.get_config()
self.backbone = Backbone()
self.classifier = Classifier(d_model=2048, num_classes=4) # 4-way classification
self.model = SingleScanModel(self.backbone, self.classifier)
# Load weights
checkpoint = torch.load(config["infer"]["checkpoints"], map_location=self.device, weights_only=False)
self.model.load_state_dict(checkpoint["model_state_dict"])
self.model = self.model.to(self.device)
self.model.eval()
print("Model and checkpoint loaded!")
## spin up data loaders
def setup_data(self):
config = self.get_config()
self.test_dataset = MedicalImageDatasetBalancedIntensity3D(
csv_path=config["data"]["test_csv"],
root_dir=config["data"]["root_dir"]
)
self.test_loader = DataLoader(
self.test_dataset,
batch_size=1,
shuffle=False,
collate_fn=self.custom_collate,
num_workers=1
)
def infer(self):
"""
Run inference pass
Returns:
dict: Dictionary with evaluation metrics
"""
results_df = pd.DataFrame(columns=['PredictedProbs_Class0', 'PredictedProbs_Class1',
'PredictedProbs_Class2', 'PredictedProbs_Class3',
'PredictedLabel', 'TrueLabel'])
all_labels = []
all_predictions = []
all_probs = []
with torch.no_grad():
for sample in tqdm(self.test_loader, desc="Inference", unit="batch"):
inputs = sample['image'].to(self.device)
labels = sample['label'].to(self.device)
with autocast():
outputs = self.model(inputs)
# Apply softmax to get probabilities
probs = torch.softmax(outputs, dim=1).cpu().numpy()
preds = np.argmax(probs, axis=1)
all_labels.extend(labels.cpu().numpy())
all_predictions.extend(preds)
all_probs.extend(probs)
result = pd.DataFrame({
'PredictedProbs_Class0': probs[:, 0],
'PredictedProbs_Class1': probs[:, 1],
'PredictedProbs_Class2': probs[:, 2],
'PredictedProbs_Class3': probs[:, 3],
'PredictedLabel': preds,
'TrueLabel': labels.cpu().numpy()
})
results_df = pd.concat([results_df, result], ignore_index=True)
# log metrics
"""metrics = calculate_metrics(
np.array(all_probs),
np.array(all_predictions),
np.array(all_labels)
)
print("\nTest Set Metrics:")
print(f"Accuracy: {metrics['accuracy']:.4f}")
print(f"Precision: {metrics['precision']:.4f}")
print(f"Recall: {metrics['recall']:.4f}")
print(f"F1 Score: {metrics['f1']:.4f}")
print(f"AUC: {metrics['auc']:.4f}")"""
# Save results
print("PredictedLabel", preds)
results_df.to_csv('./data/output/sequence_classification_predictions.csv', index=False)
return None #metrics
if __name__ == "__main__":
inferencer = SequenceInference()
_ = inferencer.infer() |