src/agatston/inference_binary.py

import os
import json
import numpy as np
from tqdm import tqdm
import torch
import torch.nn.functional as F
from sklearn.metrics import (
    accuracy_score, confusion_matrix, cohen_kappa_score,
    roc_auc_score, f1_score, precision_score, recall_score
)
from models.medqwen import MedQwen

def pad_or_clip_images(images, target_size=(32, 3, 224, 224)):
    current_size = images.size()
    
    if current_size[0] < target_size[0]:
        pad_size = target_size[0] - current_size[0]
        padded_images = F.pad(images, (0, 0, 0, 0, 0, 0, 0, pad_size))
    elif current_size[0] > target_size[0]:
        padded_images = images[:target_size[0]]
    else:
        padded_images = images
    
    return padded_images

def convert_to_binary(value):
    """Convert four-class values to binary (1 if >= 1, 0 if < 1)"""
    return 1 if value >= 1 else 0

def calculate_metrics_binary(predictions, probabilities, ground_truths):
    """
    Calculate comprehensive metrics for binary classification including:
    - Overall accuracy
    - AUC
    - F1 score
    - Precision
    - Recall
    - Confusion matrix
    """
    # Convert inputs to numpy arrays if they aren't already
    predictions = np.array(predictions)
    ground_truths = np.array(ground_truths)
    
    # Calculate overall accuracy
    overall_accuracy = accuracy_score(ground_truths, predictions)
    
    # Calculate confusion matrix
    conf_matrix = confusion_matrix(ground_truths, predictions)
    
    # Calculate AUC - use the probability of the positive class (class 1)
    try:
        auc = float(roc_auc_score(ground_truths, probabilities))
    except ValueError:
        auc = 0.0
    
    # Calculate F1, Precision, and Recall
    f1 = f1_score(ground_truths, predictions)
    precision = precision_score(ground_truths, predictions)
    recall = recall_score(ground_truths, predictions)
    
    # Calculate QWK
    qwk = cohen_kappa_score(ground_truths, predictions)
    
    # Compile all metrics
    metrics = {
        'overall_accuracy': float(overall_accuracy),
        'auc': float(auc),
        'f1_score': float(f1),
        'precision': float(precision),
        'recall': float(recall),
        'qwk': float(qwk),
        'confusion_matrix': conf_matrix.tolist(),
        'positives_count': int(np.sum(ground_truths == 1)),
        'negatives_count': int(np.sum(ground_truths == 0))
    }
    
    return metrics
    
def headct_inference(input_jsonl_file, save_json_file, checkpoint_file, img_root_dir, model_id):
    torch.manual_seed(42)
    torch.cuda.manual_seed_all(42)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False
    
    print('Load Model')
    model = MedQwen(model_id)
    state_dict = torch.load(checkpoint_file, map_location='cpu')['model']
    print('Load Checkpoint')
    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
    print('missing_keys', missing_keys)
    print('unexpected_keys', unexpected_keys)
    
    model = model.to("cuda")
    model.eval()
    save_data_dict = {}
    
    # Lists to store predictions and ground truths for metric calculation
    all_predictions_original = []  # Store original 4-class predictions
    all_ground_truths_original = []  # Store original 4-class ground truths
    all_probabilities_original = []  # Store original 4-class probabilities
    
    # Lists for binary classification
    all_predictions_binary = []  # Store binary predictions
    all_ground_truths_binary = []  # Store binary ground truths
    all_probabilities_binary = []  # Store probability of positive class
    
    with torch.no_grad():
        with open(input_jsonl_file, 'r') as file:
            for line in tqdm(file):
                data = json.loads(line)
                patient_id = data['patient_id']
                study_id = data['study_id']
                time_difference_days = data['time_difference_days']
                calcium_score = data['calcium_score']
                
                if patient_id not in save_data_dict:
                    save_data_dict[patient_id] = {}
                
                if study_id in save_data_dict[patient_id]:
                    # If study already exists, get its predictions for metrics calculation
                    study_data = save_data_dict[patient_id][study_id]
                    
                    # Original 4-class data
                    all_predictions_original.append(study_data['prediction_original'])
                    all_ground_truths_original.append(study_data['ground_truth_original'])
                    all_probabilities_original.append(study_data['probabilities_original'])
                    
                    # Binary data
                    all_predictions_binary.append(study_data['prediction_binary'])
                    all_ground_truths_binary.append(study_data['ground_truth_binary'])
                    all_probabilities_binary.append(study_data['probability_positive'])
                    continue
                
                original_label = data['calcium_score_label']
                binary_label = convert_to_binary(original_label)  # Convert to binary
                
                image_path = img_root_dir + data['image_path_list'][0]
                try:
                    pth_data = torch.load(image_path, weights_only=True)
                    pth_data = pad_or_clip_images(pth_data)
                    input_samples = {
                        'input_images': torch.tensor(pth_data).unsqueeze(0).to("cuda"),
                        'modal': 'head CT',
                        'labels': torch.tensor([original_label], dtype=torch.long).to("cuda"),
                        'task_type': 'agatston'
                    }
                except Exception as e:
                    print(f"Error processing {image_path}: {e}")
                    continue
                
                output = model(input_samples)
                original_probabilities = F.softmax(output['logits'], dim=1)
                original_prediction = torch.argmax(original_probabilities, dim=1).item()
                
                # Convert model prediction to binary
                binary_prediction = convert_to_binary(original_prediction)
                
                # Calculate probability for positive class (sum probabilities for classes 1, 2, and 3)
                positive_probability = float(sum(original_probabilities[0, 1:].cpu().numpy()))
                
                # Store original predictions
                all_predictions_original.append(original_prediction)
                all_ground_truths_original.append(original_label)
                all_probabilities_original.append(original_probabilities[0].tolist())
                
                # Store binary predictions
                all_predictions_binary.append(binary_prediction)
                all_ground_truths_binary.append(binary_label)
                all_probabilities_binary.append(positive_probability)
                
                save_data_dict[patient_id][study_id] = {
                    'prediction_original': original_prediction,
                    'ground_truth_original': original_label,
                    'probabilities_original': original_probabilities[0].tolist(),
                    'prediction_binary': binary_prediction,
                    'ground_truth_binary': binary_label,
                    'probability_positive': positive_probability,
                    'correct_binary': binary_prediction == binary_label,
                    'calcium_score': calcium_score,
                    'time_difference_days': time_difference_days
                }
    
    # Save detailed results
    with open(save_json_file, 'w') as f:
        json.dump(save_data_dict, f, indent=2)
    
    save_metric_data_dict = {}
    
    # Calculate binary metrics
    if all_predictions_binary:
        binary_metrics = calculate_metrics_binary(
            all_predictions_binary, 
            all_probabilities_binary, 
            all_ground_truths_binary
        )
        
        save_metric_data_dict['binary_metrics'] = {
            **binary_metrics,
            'total_samples': len(all_predictions_binary)
        }
        
        # Print binary metrics
        print("\nBinary Classification Results (≥1 vs <1):")
        print(f"Total samples: {len(all_predictions_binary)}")
        print(f"Positive samples (≥1): {binary_metrics['positives_count']}")
        print(f"Negative samples (<1): {binary_metrics['negatives_count']}")
        print(f"Accuracy: {binary_metrics['overall_accuracy']:.4f}")
        print(f"AUC: {binary_metrics['auc']:.4f}")
        print(f"F1 Score: {binary_metrics['f1_score']:.4f}")
        print(f"Precision: {binary_metrics['precision']:.4f}")
        print(f"Recall: {binary_metrics['recall']:.4f}")
        print(f"QWK: {binary_metrics['qwk']:.4f}")
        
        print("\nConfusion Matrix (Binary):")
        print(np.array(binary_metrics['confusion_matrix']))
    
    # Save metrics
    with open(save_json_file.replace(".json","_metric.json"), 'w') as f:
        json.dump(save_metric_data_dict, f, indent=2)
            
if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser(description='get_entities')
    parser.add_argument('--input_json_file', type=str, default='/home/xiz569/rajpurkarlab/home/xiz569/code/ongoing/2024_HeadCT/agatston/src_agatston/data/5_fold/test.jsonl')
    parser.add_argument('--save_json_file', type=str, default='./output/headct_swin/20241221070/result/epoch_0.json')
    parser.add_argument('--checkpoint_file', type=str, default='./output/headct_swin/20241221070/checkpoint_0.pth')
    parser.add_argument('--checkpoint_dir', type=str, default='./output/headct_swin/20241221070')
    parser.add_argument('--img_root_dir', type=str, default='/home/xiz569/rajpurkarlab/home/xiz569/code/ongoing/2024_GMAI/data/headct/dataset/images_preprocessed')
    parser.add_argument('--model_id', type=str, default="swin")
    args = parser.parse_args()
    
    for checkpoint_folder in os.listdir(args.checkpoint_dir):
        args.checkpoint_file = os.path.join(args.checkpoint_dir, checkpoint_folder, 'checkpoint_best.pth')
        args.save_json_file = os.path.join(args.checkpoint_dir, checkpoint_folder, "result", "best_epoch_binary.json")
        if os.path.exists(args.save_json_file):
            continue
        
        # Create result directory if it doesn't exist
        os.makedirs(os.path.dirname(args.save_json_file), exist_ok=True)
        
        headct_inference(args.input_json_file, args.save_json_file, args.checkpoint_file, args.img_root_dir, args.model_id)