How An AI Model Reads Brain MRI Scans To Estimate Glioma Grade And KI-67

Glioma grading and Ki-67 prediction from brain MRI

Why a proliferation number still requires a needle

Gliomas are graded by the World Health Organization on a scale that runs from grade 1 to grade 4, with higher numbers marking tumors that grow faster, invade more aggressively, and carry a worse outlook. Ki-67 is one of the biomarkers pathologists lean on to place a tumor within that scale. It is a nuclear protein that only appears in cells that are actively cycling, so counting how many tumor cells stain positive for it gives a rough census of how fast the mass is expanding. A grade 2 astrocytoma typically shows a Ki 67 index under 10 percent. A glioblastoma, the grade 4 end of the spectrum, often exceeds 20 percent, frequently alongside necrosis and new blood vessel growth that mark a tumor in a hurry.

The catch is that Ki-67 only exists as a number after tissue has already left the patient. Getting it requires surgery or a stereotactic biopsy, immunohistochemical staining, and a pathologist’s manual count, a process that takes time and carries its own procedural risk. MRI, on the other hand, is already part of the standard workup for anyone with a suspected brain tumor. If the texture and structure visible on a routine scan correlate with how aggressively the tumor is proliferating, that correlation could in principle be mined without waiting on a biopsy result, or used to flag cases where the imaging and the eventual pathology disagree and deserve a second look.

What the authors actually built

The pipeline in this paper is a fairly classical transfer learning setup rather than an end to end deep network. T2 weighted FLAIR MRI slices from 101 glioma patients, each contributing 20 slices, were fed through a ResNet50 that had already been trained on natural images. Instead of using ResNet50’s final classification layer, the authors pulled features from the global average pooling layer, which condenses each image into a 2048 number vector describing its texture, shape, and intensity pattern without committing to any particular diagnosis.

That 2048 dimensional vector is far more information than 101 patients can support without overfitting, so the next step was principal component analysis. The authors kept enough components to explain 95 percent of the variance in the data, which brought the feature count down to 158. They then appended three more values drawn straight from the patient chart, namely age, sex, and the Ki-67 index itself, arriving at 161 total features per case. Those features went into an XGBoost classifier, a gradient boosted decision tree method that has a long track record on structured tabular data of exactly this size.

Two separate XGBoost models were trained. One predicted the WHO grade, split into grade 2, grade 3, and grade 4 categories that included 46, 23, and 32 patients respectively before augmentation. The other predicted a Ki 67 category, bucketed as low for values from 5 percent up to 10 percent, moderate for values from 10 percent through 20 percent, and high for anything above 20 percent. Ten patients with minimal Ki 67 under 5 percent and four patients with missing values were left out of the Ki 67 task, leaving 87 patients for that half of the study.

How the numbers actually landed

For grade classification, the model correctly placed 69 of 70 grade 2 slices, 32 of 39 grade 3 slices, and 51 of 53 grade 4 slices, for an overall accuracy of 0.94. Precision came in at 0.92 for grade 2, 0.94 for grade 3, and 0.96 for grade 4, with matching F1 scores of 0.95, 0.88, and 0.96. The weakest spot in the whole table is grade 3 recall at 0.82, and the confusion matrix shows why. Five grade 3 slices were called grade 2 and two were called grade 4, meaning the model’s biggest source of error is exactly the intermediate category that pathologists themselves find hardest to pin down, since anaplastic gliomas sit on a biological continuum between the more indolent grade 2 tumors and the clearly aggressive grade 4 tumors.

The Ki 67 model told a similar story with the categories flipped around. Overall accuracy landed at 0.91, with low Ki 67 predicted correctly in 71 of 73 cases, moderate correct in 46 of 50, and high correct in 31 of 39. Precision was 0.88 for low, 0.94 for moderate, and a strong 0.97 for high, but recall for the high category dropped to 0.79, since seven high Ki-67 slices were misread as low and one as moderate. In plain terms, when the model says a tumor has high proliferative activity it is usually right, but it still lets some genuinely aggressive tumors slip through labeled as calmer than they are, which is exactly the kind of false negative that matters most in a clinical proliferation marker.

What SHAP actually revealed, and why it matters more than the accuracy numbers

Accuracy scores tell you a model works. SHAP, short for Shapley additive explanations, tells you why, by assigning each input feature a share of the credit or blame for a given prediction, borrowed from a cooperative game theory concept originally devised to split payouts fairly among players. Applied to a tabular XGBoost model, SHAP produces two things that matter here, a ranked bar chart of average feature impact and a beeswarm plot that shows how each feature’s actual value pushed individual predictions up or down.

The standout finding in the grading task is almost embarrassingly intuitive once you see it. Ki 67, which was fed into the model as an ordinary numeric feature alongside age and sex, turned out to be the single most influential input for predicting WHO grade, ahead of every one of the 158 imaging derived features. Low Ki-67 values pushed predictions toward grade 2, while higher values pulled toward grade 3 and grade 4, which is exactly the biological relationship pathologists already rely on. That is reassuring in one sense, since it confirms the model has not learned some spurious shortcut divorced from tumor biology. It is also a bit of a tell, because it means a meaningful share of the grading accuracy is coming from a feature that itself requires a biopsy to obtain, not from the MRI alone.

Behind Ki-67, a cluster of anonymous deep features carried real weight too. DL150, DL48, and DL129 ranked highest among the imaging derived components for grade prediction, while age showed a moderate SHAP contribution and sex barely registered. The authors do not know, in any mechanistic sense, what DL150 or DL129 actually represent inside the tumor, since these are abstract directions in a PCA reduced ResNet50 embedding rather than hand designed radiomic measurements like tumor volume or edge sharpness. They report, as a preliminary and admittedly informal observation, that the images which activate these features strongly tend to show larger tumor size, more heterogeneous peritumoral tissue, and a wider spatial extent, which lines up with what is already known about how bigger and messier tumors tend to be more aggressive ones.

The Ki 67 prediction task flips the hierarchy

Run the same SHAP analysis on the Ki 67 prediction model, where grade is no longer available as an input, and a different feature takes the top spot. DL33 emerged as the most influential predictor, followed by DL26, DL35, and DL12, all abstract ResNet50 derived directions rather than named clinical variables. Age again showed moderate importance and sex showed almost none. This is the more clinically interesting half of the study, because it isolates what the MRI can say about proliferation when the answer is not already sitting in the input data. DL35 in particular showed a clean pattern, where lower values tracked with low Ki 67 predictions and higher values tracked with high Ki 67 predictions, a relationship consistent enough that the authors singled it out by name.

Clinical translation gap

There is real distance between a model that scores 0.94 accuracy in a five fold cross validation on 101 patients and a tool a radiologist could trust on a Tuesday morning with a new patient. A few gaps stand out. First, this cohort came from a single center using a single 3T scanner and a single T2 weighted FLAIR sequence, so nobody yet knows how the model behaves on images from a different vendor, field strength, or acquisition protocol, and MRI signal characteristics are notoriously sensitive to exactly those variables. Second, Ki 67 assessment itself is not perfectly standardized between pathology labs, so the ground truth labels the model was trained against carry their own measurement noise, which caps how accurate any downstream model can honestly claim to be. Third, the study folded patients five ways at the patient level, which is the correct way to avoid leakage between training and test sets, but a sample this size still leaves individual folds thin, particularly for the grade 3 category with only 23 patients before augmentation.

None of this erases the value of the work. It means the honest reading of this paper is that it demonstrates feasibility and generates specific, testable hypotheses about which imaging features track proliferation, not that it hands radiologists a ready made replacement for biopsy. The authors themselves are candid about this, flagging the small dataset and the reliance on a single imaging sequence as limitations that future multicenter studies need to address before anything like clinical deployment becomes reasonable to discuss.

Where this fits against prior work

The broader push to pull molecular and proliferative information out of MRI without a biopsy is not new. Van der Voort and colleagues built a multi task deep learning model that simultaneously handled molecular subtyping, grading, and tumor segmentation, aiming for a single network that could characterize a glioma end to end. Rivera and colleagues took a different route, mining whole brain MR spectroscopy metabolic signatures with machine learning to catch early signs of progression in high grade gliomas. What sets this paper apart is less the individual pieces, since ResNet50 feature extraction and XGBoost classification are both well worn tools, and more the explicit decision to treat Ki 67 as both an outcome to predict and, separately, as an input feature whose SHAP contribution to grading can be measured directly. That two sided framing is what let the authors show, cleanly, that Ki 67 dominates grade prediction while a distinct set of imaging features dominates Ki 67 prediction, rather than lumping everything into one opaque accuracy number.

Reading the confusion matrices like a clinician would

A useful habit when evaluating any diagnostic classifier is to ask not just how often it is right but which mistakes it makes and whether those mistakes are the dangerous kind. Here, grade 2 versus grade 4 confusion was essentially absent, with only one grade 4 case misread as grade 2 and one grade 2 case misread as grade 4 out of well over a hundred combined cases. Nearly all the error mass sat in the grade 2 versus grade 3 boundary and the grade 3 versus grade 4 boundary, both of which are boundaries where human graders also disagree with each other. That pattern is a point in the model’s favor rather than against it, since a classifier that scrambled grade 2 and grade 4 cases while nailing the easy middle would be far more worrying than one that struggles exactly where biology itself is ambiguous.

Clinical limitations

Beyond the translation gap already discussed, three limitations deserve explicit mention because they bound how the results should be read. The sample size of 101 patients, with only 87 usable for the Ki 67 task after excluding minimal and missing values, is small by the standards of most published deep learning imaging studies, and rarer glioma subtypes such as ganglioglioma, present in only two patients, and oligodendroastrocytoma, present in only three, cannot be meaningfully evaluated on their own. The reliance on a single MRI sequence, T2 weighted FLAIR, ignores contrast enhanced T1 weighted and diffusion weighted sequences that carry complementary information about blood brain barrier breakdown and cellularity respectively, both of which are clinically relevant to glioma grading. Finally, the study did not incorporate molecular markers such as IDH mutation status or 1p/19q codeletion, both of which the 2021 WHO classification treats as central to accurate glioma categorization alongside histologic grade, meaning the model’s ground truth itself is an incomplete picture of what modern neuro oncology considers a full diagnosis.

The road from here

The authors point toward several sensible next steps, and it is worth separating the easy asks from the hard ones. Expanding the dataset and adding multicenter validation is the obvious first move, and one every study of this size eventually needs. Adding additional MRI sequences, particularly contrast enhanced T1 and diffusion weighted imaging, is a more involved but well understood extension that should meaningfully improve on a single sequence baseline. Folding in molecular markers like IDH status is harder still, since it requires linking imaging data to genomic data at scale, but it is exactly the kind of integration that would move a tool like this from a research curiosity toward something resembling clinical relevance. The authors also mention Grad CAM and LIME as alternative explainability methods better suited to image centric models than the tabular SHAP approach used here, which suggests a natural follow up study that explains predictions at the pixel level rather than only at the level of abstract pooled features.

Complete PyTorch reproduction of the pipeline

The implementation below follows the paper’s described architecture as closely as a single script reasonably can. A ResNet50 backbone pretrained on ImageNet acts as a frozen feature extractor reading from the global average pooling layer, producing a 2048 dimensional vector per image. PCA reduces that vector, patient age and sex and Ki 67 are concatenated on, and a small differentiable classifier head trained with cross entropy loss stands in for the XGBoost stage so the whole pipeline can be exercised end to end on dummy data. Comments throughout the code point out where this mirrors the paper directly and where it substitutes a differentiable analog for the tree based classifier the authors actually used.

# glioma_ki67_pipeline.py
# Reproduction of the ResNet50 + PCA + classifier pipeline described in
# Bhuiyan et al., "Classification of glioma grade and Ki-67 level
# prediction in MRI data: A SHAP driven interpretation", 2025.
# The paper uses XGBoost as the final classifier. XGBoost is not a
# differentiable PyTorch module, so this script substitutes a small
# linear head trained with cross entropy as a stand in, while keeping
# the ResNet50 feature extraction and PCA stages faithful to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import torchvision.models as models
import numpy as np


class ResNet50FeatureExtractor(nn.Module):
    # Mirrors section 2.5 of the paper. The classification head of a
    # pretrained ResNet50 is removed and the global average pooling
    # output, a 2048 length vector, is used as the feature vector.
    def __init__(self, pretrained=True):
        super().__init__()
        backbone = models.resnet50(weights="IMAGENET1K_V2" if pretrained else None)
        # drop the final fully connected layer, keep everything up to
        # and including global average pooling
        self.features = nn.Sequential(*list(backbone.children())[:-1])
        for p in self.features.parameters():
            p.requires_grad = False  # frozen, matching the paper's fixed extractor use

    def forward(self, x):
        # x has shape batch, 3, 224, 224
        feats = self.features(x)              # batch, 2048, 1, 1
        return feats.flatten(1)             # batch, 2048


class TorchPCA(nn.Module):
    # A minimal PCA implemented with SVD so dimensionality reduction
    # can live inside the same script. The paper keeps enough
    # components to explain 95 percent of variance, reducing 2048
    # features down to 158.
    def __init__(self, n_components=158):
        super().__init__()
        self.n_components = n_components
        self.register_buffer("mean_", torch.zeros(1))
        self.register_buffer("components_", torch.zeros(1))

    def fit(self, X):
        # X shape n_samples, n_features
        self.mean_ = X.mean(dim=0, keepdim=True)
        centered = X - self.mean_
        U, S, Vt = torch.linalg.svd(centered, full_matrices=False)
        self.components_ = Vt[:self.n_components]
        return self

    def transform(self, X):
        return (X - self.mean_) @ self.components_.T


class GliomaKi67Classifier(nn.Module):
    # Stands in for the paper's XGBoost stage. Takes the PCA reduced
    # imaging vector plus age, sex, and, for the grading task, Ki 67
    # as tabular features, and outputs class logits.
    def __init__(self, n_features=161, n_classes=3, hidden=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_features, hidden),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden, hidden // 2),
            nn.ReLU(),
            nn.Linear(hidden // 2, n_classes),
        )

    def forward(self, x):
        return self.net(x)


class DummyGliomaDataset(Dataset):
    # Synthetic dataset only, standing in for the confidential MRI
    # cohort described in the paper, used here purely to exercise the
    # pipeline end to end.
    def __init__(self, n_samples=200, n_classes=3):
        self.images = torch.randn(n_samples, 3, 224, 224)
        self.age = torch.randint(10, 76, (n_samples, 1)).float()
        self.sex = torch.randint(0, 2, (n_samples, 1)).float()
        self.ki67 = torch.rand(n_samples, 1) * 60
        self.labels = torch.randint(0, n_classes, (n_samples,))

    def __len__(self):
        return self.images.shape[0]

    def __getitem__(self, idx):
        return (self.images[idx], self.age[idx], self.sex[idx],
                self.ki67[idx], self.labels[idx])


def build_feature_matrix(extractor, pca, loader, include_ki67, device):
    # Runs every batch through the frozen ResNet50, fits or applies
    # PCA, and concatenates demographics plus optionally Ki 67, just
    # as section 2.6 of the paper describes.
    extractor.eval()
    raw_feats, ages, sexes, ki67s, labels = [], [], [], [], []
    with torch.no_grad():
        for images, age, sex, ki67, y in loader:
            images = images.to(device)
            f = extractor(images).cpu()
            raw_feats.append(f)
            ages.append(age)
            sexes.append(sex)
            ki67s.append(ki67)
            labels.append(y)
    raw_feats = torch.cat(raw_feats, dim=0)
    ages = torch.cat(ages, dim=0)
    sexes = torch.cat(sexes, dim=0)
    ki67s = torch.cat(ki67s, dim=0)
    labels = torch.cat(labels, dim=0)

    if pca.mean_.numel() == 1:
        pca.fit(raw_feats)
    reduced = pca.transform(raw_feats)

    extra = [ages, sexes]
    if include_ki67:
        extra.append(ki67s)
    full = torch.cat([reduced] + extra, dim=1)
    return full, labels


def train_one_epoch(model, X, y, optimizer, device):
    model.train()
    optimizer.zero_grad()
    logits = model(X.to(device))
    # cross entropy stands in for the multi class log loss XGBoost
    # optimizes internally, since the paper does not define a custom
    # loss for its tree based classifier
    loss = F.cross_entropy(logits, y.to(device))
    loss.backward()
    optimizer.step()
    return loss.item()


def evaluate(model, X, y, device):
    model.eval()
    with torch.no_grad():
        logits = model(X.to(device))
        preds = logits.argmax(dim=1).cpu()
        y = y.cpu()
        accuracy = (preds == y).float().mean().item()
        n_classes = logits.shape[1]
        precisions, recalls, f1s = [], [], []
        for c in range(n_classes):
            tp = ((preds == c) & (y == c)).sum().item()
            fp = ((preds == c) & (y != c)).sum().item()
            fn = ((preds != c) & (y == c)).sum().item()
            precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
            recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
            f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
            precisions.append(precision)
            recalls.append(recall)
            f1s.append(f1)
        return {
            "accuracy": accuracy,
            "precision_per_class": precisions,
            "recall_per_class": recalls,
            "f1_per_class": f1s,
        }


def smoke_test():
    # A runnable end to end check on dummy data. This does not
    # reproduce the paper's reported numbers, since it uses random
    # data and no real MRI, it only confirms the pipeline runs.
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    n_classes = 3

    extractor = ResNet50FeatureExtractor(pretrained=False).to(device)
    pca = TorchPCA(n_components=32)  # smaller than the paper's 158 for a fast smoke test

    train_ds = DummyGliomaDataset(n_samples=120, n_classes=n_classes)
    test_ds = DummyGliomaDataset(n_samples=40, n_classes=n_classes)
    train_loader = DataLoader(train_ds, batch_size=16)
    test_loader = DataLoader(test_ds, batch_size=16)

    X_train, y_train = build_feature_matrix(extractor, pca, train_loader, include_ki67=True, device=device)
    X_test, y_test = build_feature_matrix(extractor, pca, test_loader, include_ki67=True, device=device)

    model = GliomaKi67Classifier(n_features=X_train.shape[1], n_classes=n_classes).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

    for epoch in range(10):
        loss = train_one_epoch(model, X_train, y_train, optimizer, device)
        print(f"epoch {epoch} loss {loss:.4f}")

    metrics = evaluate(model, X_test, y_test, device)
    print("smoke test metrics", metrics)
    assert 0.0 <= metrics["accuracy"] <= 1.0
    print("pipeline ran end to end without error")


if __name__ == "__main__":
    smoke_test()

Conclusion

What this study demonstrates, at its clearest, is that a fairly ordinary combination of transfer learning tools, a pretrained ResNet50, PCA for dimensionality reduction, and XGBoost for the final call, can separate glioma grades and Ki 67 categories from T2 weighted FLAIR MRI with accuracy that would have seemed ambitious a decade ago. Neither piece of that pipeline is exotic on its own, and that is part of the point. The contribution is not a new architecture, it is a careful, honestly reported application of existing methods to a genuinely hard biological question, paired with SHAP analysis that actually interrogates what the model learned instead of stopping at the accuracy table.

The conceptual shift worth sitting with is the two directional framing of Ki 67. Most imaging AI papers treat a biomarker purely as an outcome to predict. This one also asks what happens when that same biomarker is available as an input, and the answer, that Ki 67 dominates grade prediction more than any imaging feature does, tells you something honest about where the model’s power actually comes from. That kind of self aware interpretability is rarer in medical imaging papers than it should be, and it is the reason this particular study earns attention beyond its accuracy numbers.

There is also a transferability angle worth flagging for anyone working in adjacent pillars of medical imaging AI. The core recipe here, frozen pretrained backbone, PCA compression, gradient boosted tabular classifier, SHAP for interpretation, is not specific to glioma at all. It is a template that shows up across dermatology, mammography, and other domains where labeled medical images are scarce but a pretrained natural image network still captures generically useful texture and shape information. Readers building similar pipelines for other cancers or other biomarkers will recognize the same tradeoffs playing out, small cohorts, dimensionality reduction as a hedge against overfitting, and interpretability tools doing the work of building clinical trust that raw accuracy cannot do alone.

The honest remaining limitations are not small. A single center cohort of 101 patients, a single MRI sequence, no molecular marker integration, and Ki-67 assessment that is itself known to vary between labs all mean this is early stage evidence, not a validated clinical tool. The grade 3 category in particular, the smallest class and the one sitting at the biological boundary between low grade and high grade disease, is where the model’s performance is weakest, and that weakness maps onto a place where human graders struggle too rather than revealing some unrelated flaw in the method.

Where this goes next depends on whether someone takes the SHAP identified features, DL33, DL35, DL150, DL129, and the rest, and actually tries to connect them to something a radiologist could see and name, whether that is tumor volume, necrosis extent, or peritumoral edema pattern. Until that translation happens, these remain useful statistical clues rather than an interpretable biomarker in their own right. The paper does not claim otherwise, and that restraint is exactly what makes it worth reading closely rather than skimming for the accuracy figure.

Frequently asked questions

What is the Ki-67 index and why does it matter for glioma. Ki-67 is a protein found only in actively dividing cells. Pathologists count what fraction of tumor cells stain positive for it to estimate how fast a glioma is growing, with higher percentages generally pointing toward a higher WHO grade and a worse prognosis.

Can this AI model replace a brain biopsy. No. The study is a research demonstration on 101 patients from one center, using imaging alone alongside patient demographics and, in the grading task, the Ki 67 value itself. It has not been validated for clinical use and biopsy remains the diagnostic standard.

Why did the model struggle most with grade 3 gliomas. Grade 3, or anaplastic, gliomas sit biologically between the more indolent grade 2 tumors and the clearly aggressive grade 4 tumors, and pathologists themselves report more disagreement in this middle category. The model’s confusion matrix mirrors that same boundary difficulty.

What does SHAP actually add beyond an accuracy score. SHAP breaks down each individual prediction into the contribution of every input feature, which let the authors show that Ki-67 outranks all imaging features for grade prediction, while a different set of abstract deep learning features dominates Ki 67 prediction when Ki-67 itself is the target instead of an input.

What imaging sequence did the study use. T2 weighted fluid attenuated inversion recovery, commonly written T2w FLAIR, acquired on a 3T General Electric MR750 scanner with a 32 channel head coil.

What would make this research more clinically credible. Multicenter validation across different scanners and protocols, the addition of contrast enhanced and diffusion weighted sequences, integration of molecular markers such as IDH mutation status, and pixel level explainability methods such as Grad CAM to complement the tabular SHAP analysis used here.

Related reading on aitrendblend