Paper · 2026-05-12 · cs.CV, cs.AI, cs.LG
Diabetic Retinopathy Classification using Downscaling Algorithms and Deep Learning
Shrinks retinal fundus photos 8x with six resampling methods, keeps bilinear and LID (learned downsampling) as the best by PSNR and SSIM, then classifies four 300x300 crops per image with a four-channel ImageNet-pretrained Inception V3 into five DR stages. Author-reported: LID reaches 85.2% accuracy, 83.4% sensitivity and 87.6% specificity (DR vs no DR).
Convolutional neural networkTransfer learningImage quality assessmentmedical-imagingimage-classificationimage-preprocessing
AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Diabetes can damage the small blood vessels in the retina, the light-sensitive layer at the back of the eye. Doctors and software can grade how far the damage has progressed from a photograph of the retina, on a five-step scale from no damage to the most advanced stage. The photographs are large and come in different sizes, but a neural network needs a small input of one fixed size. This paper asks a practical question: how should the photographs be shrunk before the network sees them?
The authors shrink each photo to about one eighth of its size with several standard and learned resizing methods. They then enlarge the result back and compare it with the original to see which shrinking keeps the most detail. Two methods come out ahead, and the classifier uses those two. Each photo is cut into four quarters, and each quarter goes through its own copy of a network that was first trained on ordinary photographs. The four results are combined to pick one of the five grades.
The authors report better accuracy than several earlier methods on a merged dataset of two collections. The earlier methods were scored in their own papers, not rerun on this data, so the comparison is looser than the table suggests.
TL;DR
- Fundus photos vary in size, so the authors compare six resampling methods for an 8x downscale and pick bilinear and LID by PSNR and SSIM after upscaling back §IV.A.2 tab. II tab. III.
- Each photo is cropped, zero-padded to 600 x 600 x 3 and split into four 300 x 300 x 3 quadrants. Four Inception V3 channels process them; their outputs are concatenated and fed to new fully connected layers that predict five stages §IV.A §IV.B.
- Author-reported with LID: 85.2% accuracy, 83.4% sensitivity and 87.6% specificity for DR vs no DR tab. VII.
- No official code. Several reported numbers do not reconcile with the printed confusion matrices, and the split and training recipe are incomplete (see Pitfalls).
Problem
Retinal fundus photographs are high resolution and vary in size §I §III. The authors note that feeding them to a CNN directly increases parameters and computation §IV.B. Their argument is that downscaling removes high-frequency detail, so the choice of resampling method matters §IV.A.2. The data are also imbalanced: in Kaggle, class 0 (no DR) makes up 73.29% of the images, and in IDRID the classes are much smaller §III.A tab. I.
The approach assumes that a single fixed 8x downscale suits all images, that the 600 x 600 canvas holds the whole retina after cropping §IV.A.1 §IV.A.3, and that ImageNet-pretrained Inception V3 weights transfer to this task §IV.B.1.
Method
The pipeline has two parts. A preprocessing chain turns each photo into a fixed 600 x 600 x 3 image §IV.A fig. 2. A classifier runs four Inception V3 channels on the quadrants of that image §IV.B fig. 4. Separately, the authors compare resampling methods by downscaling, upscaling back and scoring the result with PSNR and SSIM §IV.A.2 fig. 3.
- Crop. Remove the black margins on all four sides. Cropped images vary in size; the largest is 4800 x 4800 x 3 §IV.A.1 fig. 2.
- Downscale 8x with one of six methods: nearest neighbour, bilinear, bicubic, Lanczos, RDIP or LID. LID is run with its pretrained 4x and 2x models to reach 8x §IV.A.2.
- Pad symmetrically with zeros to 600 x 600 x 3. After the 8x downscale the sides are 550 to 600 pixels §IV.A.3.
- Split into four 300 x 300 x 3 quadrants, one per corner of the canvas §IV.B.2 fig. 4.
- Backbone. Each quadrant goes through one Inception V3 channel. The network is initialised from ImageNet weights, and its fully connected layers are removed, leaving 42 layers §IV.B.1 §IV.B.2.
- Head. Concatenate the last-layer outputs of the four channels and train new fully connected layers that output the five stages §IV.B.2 fig. 4.
- Freeze. The text says the pretrained parameters are kept and only the new fully connected layers are trained §IV.B.3.
- Binarise for metrics. Stage 0 counts as no DR; stages 1 to 4 count as DR §IV.B.4.
- Split the data. The test set is 20% of the images of each class. Of the remaining 80%, 80% is used for training and 20% for validation. The split is class-wise §V.
Downscale comparison, as the authors ran it fig. 3:
# Score one downscaling method on one image [§IV.A.2] [fig. 3]
# Input: original (H, W, 3) cropped photo; method = one of six resamplers
# Output: psnr_value, ssim_value for the round trip
def score_downscaler(original, method):
# Shrink 8x with the method under test [§IV.A.2]
small = method(original, factor=8)
# Enlarge 8x back with a Lanczos 4x4 kernel, the same for every method
restored = lanczos_4x4_upscale(small, factor=8) # [§IV.A.2]
# Compare with the original; higher is taken as better [eq. 1] [eq. 2]
return psnr(original, restored), ssim(original, restored)Preprocessing and the two-stage classifier:
# Preprocess one photo and classify it [§IV.A] [§IV.B] [fig. 4]
# Input: image (H, W, 3) raw photo with black borders
# Output: scores (5,), one per stage 0 to 4
def preprocess(image, method):
# Remove the black margins on all four sides [§IV.A.1]
cropped = crop_black_borders(image) # (h, w, 3), h, w <= 4800
# Downscale by 8x with the chosen method [§IV.A.2]
small = downscale(cropped, factor=8, method=method)
# Zero-pad symmetrically to a 600 x 600 canvas [§IV.A.3]
padded = pad_zeros_symmetric(small, size=600) # (600, 600, 3)
return padded
def quadrants(padded):
# Four 300 x 300 crops, one per channel [§IV.B.2] [fig. 4]
top = padded[:300]
bottom = padded[300:]
return [top[:, :300], top[:, 300:], bottom[:, :300], bottom[:, 300:]]
def classify(crops, channels, head):
# One Inception V3 channel per crop, ImageNet-initialised [§IV.B.1]
features = [channel(crop) for channel, crop in zip(channels, crops)]
# Concatenate the last-layer outputs of all channels [§IV.B.2]
merged = concatenate(features)
# New fully connected layers, five outputs [§IV.B.2] [fig. 4]
return head(merged) # (5,)Metrics, with DR as the positive class §IV.B.4:
# Accuracy, sensitivity and specificity from stage labels [§IV.B.4]
# Input: stage_true, stage_pred: integer arrays with values 0 to 4
# Output: accuracy, sensitivity, specificity
def dr_metrics(stage_true, stage_pred):
# Stage 0 is no DR; stages 1 to 4 count as DR [§IV.B.4]
truth = stage_true >= 1
guess = stage_pred >= 1
# Count the four cells of the 2 x 2 table [tab. IV]
tp = count(truth & guess)
tn = count(~truth & ~guess)
fp = count(~truth & guess)
fn = count(truth & ~guess)
# Formulas as printed [eq. 3] [eq. 4] [eq. 5]
accuracy = (tp + tn) / (tp + fp + tn + fn)
sensitivity = tp / (tp + fn)
specificity = tn / (tn + fp)
return accuracy, sensitivity, specificityFormulas as printed. Note the sensitivity and specificity prose in Pitfalls.
PSNR(x, y) = 10 \log \frac{s^2}{MSE(x, y)}, \quad s = 255 eq. 1
SSIM(x, y) = \frac{(2\mu_x\mu_y + c_1)(2\sigma_{xy} + c_2)}{(\mu_x^2 + \mu_y^2 + c_1)(\sigma_x^2 + \sigma_y^2 + c_2)} eq. 2
Accuracy = \frac{TP + TN}{TP + FP + TN + FN} eq. 3
Sensitivity = \frac{TP}{TP + FN} eq. 4
Specificity = \frac{TN}{TN + FP} eq. 5
Hyperparameters
| Name | Value | Where | Notes |
|---|---|---|---|
| Black-border crop | all four sides; largest result 4800 x 4800 x 3 | §IV.A.1 fig. 2 | threshold for "black" not stated |
| Downscale factor | 8x | §IV.A.2 | chosen "after multiple experiments"; those runs are not reported |
| Downscale methods compared | nearest neighbour, bilinear, bicubic, Lanczos, RDIP, LID | §IV.A.2 tab. II tab. III | LID uses pretrained 4x and 2x models; their order is not stated in the compiled text |
| Upscale for scoring | Lanczos 4x4 kernel, 8x | §IV.A.2 fig. 3 | same for all methods |
| PSNR constant s | 255 | eq. 1 | 8-bit images |
| SSIM window | 8 x 8, moved pixel by pixel | §IV.A.2 | |
| SSIM constants | k1 = 0.01, k2 = 0.03, L = 7 | §IV.A.2 eq. 2 | L = 7 is as printed for 8-bit images; see Pitfalls |
| Padded canvas | 600 x 600 x 3, zeros, symmetric | §IV.A.3 | |
| Network input | four 300 x 300 x 3 quadrants | §IV.B.2 | |
| Backbone | Inception V3, ImageNet weights, fully connected layers removed, 42 layers | §IV.B.1 | exact implementation not stated |
| Channels | four, one per quadrant | §IV.B.2 | weight sharing across channels not stated |
| Head | fully connected layers after concatenation | §IV.B.2 | number of layers, widths, activation, dropout not stated |
| Trainable part | new fully connected layers only | §IV.B.3 | |
| Output | five classes (stages 0 to 4) | fig. 4 | output activation and loss not stated |
| Test split | 20% of each class | §V | class-wise |
| Train / validation split | of the remaining 80%: 80% train, 20% validation | §V | derived: 64% train, 16% validation, 20% test |
| Optimiser, learning rate, batch size, epochs | not stated | ||
| Loss, class weighting, augmentation | not stated | ||
| Input normalisation | not stated | ||
| Random seeds, repeats, hardware, training time | not stated |
Results
Author-reported. Setup: a merged Kaggle and IDRID dataset §III tab. I; one four-channel Inception V3 per downscaling method (bilinear and LID) §V §VI; metrics on the binary DR / no-DR split §IV.B.4. The baselines in Table VII come from other papers and are not rerun on this data tab. VII.
Headline comparison tab. VII:
| Setting | Accuracy | Sensitivity | Specificity | Source |
|---|---|---|---|---|
| Four-channel Inception V3, LID downscale | 85.2% | 83.4% | 87.6% | tab. VII tab. VI |
| Four-channel Inception V3, bilinear downscale | 83.15% | 81.2% | 84.6% | tab. VII tab. V |
| BT-VGG (cited baseline) | 83.2% | 81.8% | 89.3% | tab. VII |
| GoogleNet (cited baseline) | 81% | 35% | 88% | tab. VII |
| VGG16 (cited baseline) | 78.3% | NR | NR | tab. VII |
| CNN with 13 layers (cited baseline) | 75% | 30% | 95% | tab. VII |
| Shallow CNN (cited baseline) | 42% | NR | NR | tab. VII |
NR = not reported in the source.
Confusion matrices as printed (rows are the actual class, columns the predicted class; the labels are as in the source):
| Bilinear (tab. V) | Predicted: not DR | Predicted: DR |
|---|---|---|
| Actual: not DR | 3112 | 718 |
| Actual: DR | 564 | 3216 |
| LID (tab. VI) | Predicted: not DR | Predicted: DR |
|---|---|---|
| Actual: not DR | 3194 | 664 |
| Actual: DR | 454 | 3298 |
Downscaling quality, PSNR in dB per class tab. II:
| Class | Nearest | RDIP | Lanczos | Bicubic | Bilinear | LID |
|---|---|---|---|---|---|---|
| 0 | 37.769571 | 37.949846 | 38.050363 | 38.074301 | 38.084206 | 39.015693 |
| 1 | 36.937753 | 37.120090 | 37.221959 | 37.247297 | 37.410356 | 37.711350 |
| 2 | 38.488647 | 38.663193 | 38.767848 | 38.785894 | 37.710555 | 38.791407 |
| 3 | 37.537186 | 37.708631 | 37.808070 | 37.829595 | 37.846174 | 37.777964 |
| 4 | 38.384808 | 38.542223 | 38.612746 | 38.633373 | 38.645576 | 39.221942 |
Downscaling quality, SSIM per class tab. III:
| Class | Nearest | RDIP | Lanczos | Bicubic | Bilinear | LID |
|---|---|---|---|---|---|---|
| 0 | 0.916743 | 0.918756 | 0.919373 | 0.919742 | 0.920029 | 0.933177 |
| 1 | 0.904271 | 0.906823 | 0.907258 | 0.907832 | 0.908378 | 0.905576 |
| 2 | 0.927558 | 0.929262 | 0.929633 | 0.929976 | 0.930178 | 0.910066 |
| 3 | 0.908891 | 0.910721 | 0.911462 | 0.911916 | 0.912355 | 0.910956 |
| 4 | 0.935021 | 0.936309 | 0.936583 | 0.936910 | 0.937149 | 0.930768 |
Dataset counts per class tab. I:
| Class | Stage | Kaggle | IDRID |
|---|---|---|---|
| 0 | No DR | 25810 | 168 |
| 1 | Mild DR | 2443 | 25 |
| 2 | Moderate DR | 5292 | 168 |
| 3 | Severe DR | 873 | 93 |
| 4 | Proliferative DR | 708 | 62 |
| Total | 35216 | 516 |
Paper vs code
No official code.
Searched: the paper's LaTeX source (no code or project link), the arXiv abstract page (no comments field, no code link), and GitHub repository search for "diabetic retinopathy multi channel inception", "diabetic retinopathy downscaling", "Multi Channel Inception V3 fundus" and "daiict retinopathy". All returned zero repositories. No project page is linked and no author GitHub account was identified.
Pitfalls
- Dataset total. The Kaggle class counts in tab. I sum to 35,126, but the total printed is 35,216 §III.A. The 73.29% figure in the text matches the printed total. IDRID's counts sum to 516, as printed. The text's "32% for class 0 and class 2" §III.B is 168/516 = 32.6% for each.
- Test-set size. Both confusion matrices total 7,610 images tab. V tab. VI. The stated 20% test split of the combined 35,732 images is about 7,146 §V. The text does not say which set the matrices come from.
- Sensitivity and specificity prose. The text defines sensitivity as the share of images classified as DR that really have DR, and specificity as the share classified as no DR that really have none §IV.B.4. Those are precision and negative predictive value. The printed formulas eq. 4 eq. 5 are recall and true-negative rate. Implement the formulas, and check which definition matches the reported numbers.
- Confusion-matrix labels. The template matrix labels the top-right cell FN and the bottom-left cell FP tab. IV, which is the reverse of the usual reading with rows as the actual class. Recomputing from tab. V and tab. VI with the template labels gives: bilinear accuracy 83.15% (matches), sensitivity 81.7% (reported 81.2%), specificity 84.7% (reported 84.6%); LID accuracy 85.3% (reported 85.2%), sensitivity 83.2% (reported 83.4%), specificity 87.6% (matches). With the usual reading, LID sensitivity is 87.9% and specificity 82.8%, which match neither report. Confirm the convention before reusing these numbers.
- SSIM constant. The text gives L = 7 "for 8 bit image" §IV.A.2, while PSNR uses s = 255 eq. 1. The two are inconsistent for the same images. Which value the authors used for SSIM is not stated.
- PSNR log base. eq. 1 writes "10 log" with no base. The prefactor 10 suggests base 10, but the text does not say so.
- SSIM window and form. The window is 8 x 8, moved one pixel at a time §IV.A.2. Whether means and variances are computed with uniform or Gaussian weights, and how borders are handled, is not stated.
- Best method per metric. The text says the highest PSNR and SSIM come from LID and bilinear §IV.A.2. Per class, LID has the highest PSNR in classes 0, 1, 2 and 4 and bilinear in class 3 tab. II. For SSIM, bilinear is highest in classes 1 to 4 and LID only in class 0 tab. III. The choice of LID and bilinear is therefore not a clean win.
- Possible outlier. In tab. II, bilinear's class 2 PSNR (37.71) is about 1 dB below all other methods in that row. The paper does not comment, and no code is available to check it.
- Single upscaler. All methods are scored after one shared Lanczos 4x4 upscale §IV.A.2. The ranking may depend on that choice; the authors do not test it.
- Choice of 8x. The authors state that 2x and 4x leave inputs too large and that 16x and 32x lose too much information §IV.A.2. No table supports either claim in the compiled paper.
- Padding versus resizing. The text says images are "padded and resized" to 600 x 600 x 3 §IV.A.3, but the described operation is zero padding only. Whether any resize is applied after padding is not stated.
- Input size. The network input is 300 x 300 §IV.B.2, and the authors give that size as Inception V3's requirement. Whether the backbone is adapted to that size is not stated.
- Frozen or trained backbone. §IV.B.3 says only the fully connected layers are trained, but §IV.B.2 says "each channel trains an Inception V3". Whether the four channels share weights is not stated. The trainable backbone parameters are therefore unknown.
- Five classes versus binary metrics. The network is described as a five-class classifier fig. 4, and the results section calls the networks "Multi Class" §VI. The metrics are binary §IV.B.4. How five-way predictions are turned into DR / no DR is not stated.
- Leakage risk. The split is class-wise §V, but no patient-level grouping is described. The Kaggle images include both eyes, and left and right can differ in severity §III.A. The text does not rule out one patient's two eyes landing in train and test. Whether IDRID and Kaggle overlap is not stated.
- Single runs. The results come from one run each, with no seeds, variance or confidence intervals §VI.
- Cross-paper baselines. The baselines in tab. VII are numbers from other papers, which used other data (the Related Work describes several datasets and sizes §II). They were not rerun on this split. The abstract's "outperform" claim rests on this table.
- Mixed baseline result. BT-VGG has higher specificity (89.3%) than the proposed LID model (87.6%) tab. VII. The claim of superiority is for accuracy and sensitivity.
- Missing training recipe. The optimiser, learning rate, batch size, epochs, loss, class weighting, augmentation and input normalisation are all absent. An implementer must choose them and report that choice.
Lineage
- Builds on: Inception V3 with ImageNet weights §IV.B.1; Learned Image Downsampling (LID) and Rapid Detail Image Preserving (RDIP) as downscalers §IV.A.2. None of these is linked to a card or an arXiv id in the compiled text.
- Compared against: a 13-layer CNN, GoogleNet, a shallow CNN, VGG16 and BT-VGG, as cited row by row in tab. VII.
- Superseded by: not stated.
Source and license
Adapted from “Diabetic Retinopathy Classification using Downscaling Algorithms and Deep Learning” by Nishi Doshi, Urvi Oza, Pankaj Kumar (arXiv:2605.11430), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.