Classification of Alzheimer's Disease using fMRI Data and Deep Learning Convolutional Neural Networks

In plain words

The paper asks whether a brain scan can tell a person with Alzheimer's disease from a healthy person. It uses functional MRI, which records how activity in the brain changes over time while a person is resting in the scanner.

The authors turn each scan into many small two-dimensional pictures and train a small image classifier on them. The classifier is a convolutional neural network (CNN), a type of model that learns its own visual filters and needs no hand-made features. The network is a known design called LeNet-5, adjusted for these scans.

On the authors' own test data it reached about 96.9% accuracy. That result is theirs and comes from one dataset, so it does not show how the method would perform in a clinic.

TL;DR

• Binary classification, Alzheimer's disease (AD) versus normal control (NC), from resting-state fMRI §I §II-A.
• Preprocessing with FSL 5.0 steps, then slicing volumes into 2D images and training a Caffe LeNet-style CNN for 30 epochs §II-A §III fig. 2.
• Reports 96.8588% mean test accuracy over five runs against 84% for SVM methods cited from the literature tab. 1 §III.
• Splitting unit, subject count and baseline are not clearly stated, so treat the number as an upper bound until reproduced.

Problem

Clinicians need non-invasive ways to recognise brain disorders. Resting-state fMRI is non-invasive and can be acquired within a clinical scan §I. The paper argues that choosing discriminative features by hand is the hard part of classifying such data, and that a CNN can learn them §I §III.

Method

The pipeline has three stages.

1. Preprocessing of each fMRI volume (FSL 5.0): brain extraction of the anatomical T1 image, then motion correction, skull stripping, 5 mm Gaussian smoothing, high-pass temporal filtering, alignment to the T1 image, and registration to MNI152 with resampling to 2 mm voxels §II-A. The first 10 slices of each image are removed, giving 45×54×45×300 volumes §II-A.
2. Slicing and labelling. The 4D volumes are concatenated across the z and t axes, converted to 2D JPEG images with Nibabel and OpenCV, labelled AD or NC, and stored as LMDB databases §III.
3. Classification with a LeNet-5-derived CNN in Caffe DIGITS 0.2 §III. The layers are shown in fig. 2: conv1 (20 filters, 5×5), max pool (2×2, stride 2), conv2 (50 filters, 5×5), max pool (2×2, stride 2), a fully connected layer with 500 units and ReLU, then a second fully connected layer with softmax loss fig. 2. The authors describe the task as binary §II-B.

The background section gives the back-propagation gradient for a convolutional filter in two forms eq. 1 eq. 2:

\frac{\partial E}{\partial W_{ab}} = \sum_{i=0}^{N-m}\sum_{j=0}^{N-m}\frac{\partial E}{\partial W^{l}_{ij}}\,\frac{\partial x^{l}_{ij}}{\partial W_{ab}} eq. 1

= \sum_{i=0}^{N-m}\sum_{j=0}^{N-m}\frac{\partial E}{\partial x^{l}_{ij}}\; y^{\,l-1}_{(i+a)(j+b)} eq. 2

These equations are background only. The paper does not use them to define the training procedure, and their symbols are inconsistent (see Pitfalls).

Preprocessing and splitting:

# Preprocess one subject's resting-state fMRI  [§II-A]
# Input:  4D fMRI volume, first 10 slices dropped (45, 54, 45, 300)
# Output: preprocessed 4D volume in MNI152 space

def preprocess_subject(volume_4d):
    # FSL steps: motion correction, skull stripping, smoothing  [§II-A]
    volume_4d = motion_correct(volume_4d)
    volume_4d = skull_strip(volume_4d)
    volume_4d = smooth_gaussian(volume_4d, fwhm_mm=5)
    # High-pass temporal filter, cutoff 90.0 s  [§II-A]
    volume_4d = highpass_temporal(volume_4d, cutoff_s=90.0)
    # Register to MNI152 and resample to 2 mm voxels  [§II-A]
    volume_4d = register_mni152(volume_4d, voxel_mm=2)
    return volume_4d

# Turn volumes into labelled 2D images and split them  [§III]
# Input:  preprocessed volumes with AD / NC labels
# Output: train, validation and test sets of (image, label)

def build_splits(volumes, labels):
    # Concatenate across z and t, save each 2D slice as JPEG  [§III]
    images = slice_to_jpeg(concat_z_t(volumes))
    # 60 / 20 / 20 split; split unit (slice or subject) not stated  [§III]
    train, val, test = split(images, fractions=(0.6, 0.2, 0.2))
    return train, val, test

Network, with the layers as read from fig. 2:

# LeNet-style CNN, Caffe layer order  [fig. 2] [§II-B]
# Input:  images (B, C, H, W); C, H, W not stated
# Output: class logits (B, 2)

def lenet_fmri(images):
    x = conv(images, filters=20, kernel=5, stride=1, pad=0)
    x = max_pool(x, kernel=2, stride=2)
    x = conv(x, filters=50, kernel=5, stride=1, pad=0)
    x = max_pool(x, kernel=2, stride=2)
    # Flatten, then the 500-unit fully connected layer with ReLU  [fig. 2]
    x = relu(linear(flatten(x), units=500))
    return linear(x, units=2)

Training loop:

# Training loop  [§III] [fig. 4]
# Input:  model, train_set and val_set of (image, label)
# Output: trained model

def train(model, train_set, val_set):
    # 30 epochs, batch 64; learning rate schedule as in [fig. 4]
    for epoch in range(30):
        lr = learning_rate_for(epoch)  # 0.01, then 0.001, then about 1e-4
        for images, labels in batches(train_set, size=64):
            # Scale layer factor not stated  [fig. 2]
            logits = lenet_fmri(scale(images))
            loss = softmax_cross_entropy(logits, labels)
            model.update(loss, lr)
        val_accuracy = evaluate(model, val_set)
    return model

Hyperparameters

Results

Author-reported. Setup: resting-state fMRI from ADNI, AD versus normal controls, LeNet-style CNN trained in Caffe DIGITS 0.2 (Nvidia build) §II-A §III. Baseline: SVM accuracies quoted from the literature §III.

Training curves for run 5 (loss and accuracy) are in fig. 3. The paper shows learned filters for the first two convolution layers and dataset statistics in fig. 5, fig. 6 and fig. 7. These figures are described, not reproduced here.

Paper vs code

No official code. The arXiv page lists no code or project link. The author GitHub account (samansarraf) has a repository named MCADNNet. Its README cites a 2019 IEEE Access paper with a different title, so it is not this paper's code and was not used. Other GitHub repositories found for Alzheimer's fMRI CNNs are by unaffiliated users and were not used.

Pitfalls

• Possible leakage across splits. The paper slices every volume into 2D images, labels them, and then splits them 60/20/20 §III. It never says the split is by subject. If it is by slice, slices from one subject can sit in both train and test, which would inflate accuracy. This is an inference from the text, not something the paper states.
• Cross-validation is ambiguous. The text describes one 60/20/20 split and also says the process was repeated 5 times as 5-fold cross validation §III. The five runs in tab. 1 are very close (96.854 to 96.863). The text does not say whether they used different folds, seeds or the same split.
• Subject counts are unclear. The text gives "15 elderly normal control subjects (24 female and 19 male)", which sums to 43 subjects, not 15. The number of AD patients is not stated §II-A.
• Image count is not explained. The 451500 images (270900 + 90300 + 90300) do not say how many subjects or slices each contains.
• Equations are not a usable spec. eq. 1 and eq. 2 mix x, y and W indices, and the text refers to Equation \ref{error_eqn}, which is not defined in the source. Do not implement from them; use standard back-propagation for the layers in fig. 2.
• Architecture is from a Caffe template. The data layer in fig. 2 is named mnist, which suggests the MNIST LeNet example was adapted. The paper does not say so. Input resolution and channel count are therefore not stated.
• Batch size and optimizer are undefined. The diagram shows batch 64 for training and 100 for testing fig. 2. The optimizer, momentum, weight decay and initialisation are not stated.
• Number inconsistency. The abstract gives 96.85%, the results give 96.8588% and the conclusions give 96.86%. These are rounding of the same mean, not separate results.
• Duplicate figure label. Two figures share the label fig:lenet in the source, so the text reference "figure \ref{fig:lenet}" can point to either the architecture or the run-5 curves. This card uses the order of appearance: fig. 1 architecture, fig. 3 run-5 curves.
• Comparison is weak. The 84% SVM figure is quoted from other papers and not re-run on this data §III.
• Hidden costs. The paper says the approach needs "high algorithm complexity and expensive infrastructure" §III and that training ran on NVIDIA GPU cloud computing §III. Hardware and runtime are not reported.

Lineage

• Builds on: LeNet-5, LeCun et al. 1998 (cited in the paper, no card here) §II-B.
• Compared against: SVM classifiers on AD data from the literature, 84% accuracy as cited §III.
• Superseded by: not known from content in this wiki.