Pith. sign in

REVIEW 4 major objections 5 minor 25 references

U-Net Fixed-Point Quantization for Medical Image Segmentation

T0 review · 4 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read U-Net can be quantized to 4-bit weights and 6-bit activations, cutting weight storage 8x while keeping medical segmentation accuracy close to full precision.

desk verdict Useful first fixed-point U-Net results, but the abstract numbers don't match the table and the BN-folding gap makes the deployment claim unverified. read the letter →

arxiv 1908.01073 v2 pith:QONHFEIX submitted 2019-08-02 eess.IV cs.LGstat.ML

MohammadHossein AskariHemmat , Sina Honari , Lucas Rouhier , Christian S. Perone , Julien Cohen-Adad , Yvon Savaria , Jean-Pierre David This is my paper · ORCID
classification eess.IVcs.LGstat.ML
keywords U-Netfixed-pointquantizationmedicalimagesegmentationmodelcompressioninteger-onlyinferencedicelossquantization-awaretraining
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that a U-Net, the encoder–decoder architecture most used for medical image segmentation, can be converted to fixed-point arithmetic without a practically meaningful loss in accuracy. The central claim, stated in the abstract, is that 4-bit weights and 6-bit activations (written $Q_w0.4$ and $Q_a6.0$) shrink the weight storage by a factor of 8 while losing only a small amount of Dice score on three benchmark datasets. The paper's own results table lists slightly different losses for that configuration (3.02, 0.47, and 2.21 percentage points on EM, GM, and NIH), while the abstract quotes 2.21, 0.57, and 2.09, so the exact figures differ, but the qualitative claim remains the point of the paper. It also argues that this fixed-point scheme is more practical on current CPUs and GPUs than earlier U-Net quantizers because it uses integer-only operations and ReLU rather than floating-point scaling factors and Tanh. A sympathetic reader would take the contribution to be a tunable accuracy–memory trade-off for deploying segmentation models on memory-limited devices.

What carries the argument

The load-bearing object is the fixed-point quantization function $\mathrm{quantize}(x,n)=(\mathrm{round}(\mathrm{clamp}(x,n)) \ll n) \gg n$, applied separately to the integer and fractional parts of a value; precisions are written $Q_p i.f$, with $p$ naming the parameter type and $i$, $f$ the integer and fractional bit budgets. Because the full-precision U-Net weights lie in $[-1,1]$, the weight integer budget can be zero, giving $Q_w0.4$, while activations use six integer bits, giving $Q_a6.0$. A straight-through estimator makes the piecewise-constant quantization differentiable, and two empirical observations carry the result: dropout is removed because quantization already regularizes, and the final layer is kept in full precision because it helps accuracy more than keeping the first layer full precision. The hardware argument rests on the contrast with TernaryNet, whose floating-point scaling factors and Tanh activations are claimed to be less efficient on commodity CPUs and GPUs than the integer-only ReLU path of this fixed-point design.

What would settle it

Inspect the released inference code and check whether the batch-normalized-folded convolution weights are re-quantized to $Q_w0.4$ and whether activations are clamped and rounded to six integer bits in the deployed path, then evaluate Dice on the same test splits and compare the stored parameter size with Table 1. If the deployed model's Dice scores or its weight-file size differ from the reported values, the central claim that one model achieves both the accuracy and the 8x compression is not supported.

Watch

Extended reading notes

Core claim

The central claim is that a U-Net trained with quantization-aware fixed-point arithmetic can work with weights stored as 0 integer bits plus 4 fractional bits ($Q_w0.4$) and activations stored as 6 integer bits plus 0 fractional bits ($Q_a6.0$), and still segment medical images almost as well as the 32-bit floating-point model. On the spinal cord gray-matter, electron-microscopy, and NIH pancreas datasets, the reported Dice scores are within a few points of the full-precision baseline; the abstract quotes losses of 2.21, 0.57, and 2.09 percentage points, while the results table lists 3.02, 0.47, and 2.21 for that configuration. The paper further claims that this approach is more consistent across the three datasets than BinaryConnect or TernaryNet baselines, and that the fixed-point format is better matched to existing hardware because it avoids floating-point scaling and replaces Tanh with ReLU. The trade-off is explicit: moving down the quantization ladder $Q_w8.8 \rightarrow Q_w0.8 \rightarrow Q_w0.4 \rightarrow Q_w0.2$ halves the parameter footprint each time while increasing Dice loss.

Load-bearing premise

The accuracy and compression claims both assume that the weights used at inference—after batch-normalization parameters are folded into the convolution weights by the deep-learning framework—are quantized in exactly the same $Q_w0.4$ format as the weights during training; the paper does not state that the folded weights are re-quantized.

Editorial extensions

If this is right

  • A U-Net at $Q_w0.4$ weights and $Q_a6.0$ activations needs one-eighth the weight storage of the full-precision model and can be evaluated with integer arithmetic, which matters for high-resolution and volumetric medical images.
  • The precision ladder gives a deployment a monotone accuracy–memory trade-off: $Q_w8.8$, $Q_w0.8$, $Q_w0.4$, and $Q_w0.2$ each halve the parameter size, so the smallest acceptable model can be chosen per application.
  • Removing dropout becomes a deliberate part of quantized U-Net design; the paper's experiments show that dropout hurts more at lower precision because quantization itself acts as a regularizer.
  • Keeping the final layer full precision rather than the first layer is the better accuracy-preserving choice, which can guide layer-by-layer precision assignment in segmentation networks.
  • Compared with ternary or binary U-Net quantizers, the fixed-point method is claimed to offer consistent accuracy across heterogeneous medical datasets while staying closer to what current CPUs and GPUs can execute efficiently.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural extension would be to apply the same fixed-point recipe to 3D U-Nets and attention-based U-Net variants, since nothing in the method depends on 2D slices; the bounded-weight observation should transfer, but the accuracy loss would have to be remeasured.
  • If the batch-normalization folding concern is real, a straightforward repair—re-quantize the folded convolution weights before deployment or mimic folding during training—would make the reported inference accuracy reproducible; without it, the deployed weights may not be in $Q_w0.4$ format and the 8x memory claim would not apply at inference.
  • The paper counts stored parameter size, but during a U-Net forward pass the activations and saved encoder features often dominate peak memory; a sequel measuring peak activation memory for quantized models would sharpen the practical benefit.
  • Because the authors found that training from scratch outperformed incremental quantization at extreme precision, combining this fixed-point scheme with pruning or distillation might plausibly push usable precision below 4 bits, though the paper does not investigate that.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes a fixed-point quantization scheme for U-Net in medical image segmentation, quantizing weights and activations with configurable integer and fractional bit widths. The method is evaluated on three datasets (EM, GM, NIH) and compared against full-precision, binary, and TernaryNet baselines. The central claim is that a U-Net with 4-bit weights (Qw0.4) and 6-bit activations (Qa6.0) achieves an 8x reduction in weight memory while losing only a few Dice points. The authors also argue that their fixed-point approach is more hardware-friendly than TernaryNet or BNN because it uses only integer operations and ReLU.

Significance. If the claims hold, the paper makes a practical contribution: it demonstrates a simple, integer-only quantization recipe for U-Net that preserves segmentation quality while cutting weight storage by 8x, and it releases code. The paper also provides useful observations about dropout and full-precision layers under quantization. However, the headline numbers in the abstract do not match Table 1, the inference-time behavior after BatchNorm folding is not specified, and the empirical claims lack error bars. These issues must be resolved before the central trade-off claim is fully supported.

major comments (4)
  1. [Abstract and Table 1] The abstract reports Dice losses of 2.21%, 0.57%, and 2.09% for Qa6.0/Qw0.4 on EM, GM, and NIH, but Table 1 gives full-precision versus Q6.0/Q0.4 scores of 94.05 to 91.03 (loss 3.02), 56.32 to 55.85 (loss 0.47), and 75.69 to 73.48 (loss 2.21). No row of Table 1 reproduces the abstract numbers. The central trade-off claim should be tied to a single explicit row of the table; please correct the abstract and any other statements so that all reported numbers are consistent.
  2. [Section 3.2, BatchNorm folding] During training, the QuantLayer follows BatchNorm, so activations are quantized after floating-point BatchNorm, and the Conv2dQuant layers quantize raw convolution weights. At inference, PyTorch folds BatchNorm into the convolution weights, producing W_folded = (gamma/sqrt(var+eps)) * W + (beta - gamma*mean/sqrt(var+eps)). The paper does not state whether W_folded is re-quantized to the Qw0.4 fixed-point format. If it is not re-quantized, the deployed network uses full-precision folded weights, contradicting the 4-bit weight claim; if it is re-quantized, the effective inference weights are q(W_folded), which generally differs from the training-time quantized weights. Either way, the reported Dice scores cannot be assumed to characterize the deployed fixed-point network unless the exact inference procedure is specified and evaluated.
  3. [Section 4, NIH preprocessing and comparison fairness] The NIH dataset used in this paper was preprocessed by extracting 512x512 slices and then ROI-cropping to 176x112, while the TernaryNet comparison used the preprocessed dataset described in reference [20]. Because the preprocessing pipelines differ, the Table 1 NIH comparison does not isolate the effect of the quantization method from the effect of preprocessing. Please either evaluate on the same preprocessing as the TernaryNet baseline or explicitly state this as a limitation when comparing against ternary results.
  4. [Table 1, experimental variability] Table 1 reports single Dice values with no standard deviations, no number of runs, and no significance tests. The claimed advantages for Qa6.0/Qw0.4 over competing methods are small on GM (0.47-point loss vs full precision) and NIH (2.21-point loss), and run-to-run variation in training stochasticity could be of this magnitude. To support the accuracy-memory trade-off claim, please provide results from multiple seeds or some measure of variability.
minor comments (5)
  1. [Abstract] The word 'loosing' in the abstract should be 'losing'.
  2. [Equations (1)-(4)] Equation (1) and the clamp in Equation (2) are written for non-negative inputs, while Equation (4) handles signs via abs/sign. Please state explicitly that Equation (1) is applied to the absolute value and to the integer and fractional parts separately, or present a single signed quantization function to avoid confusion.
  3. [Section 4, Table 2] Table 2 reports ReLU versus Tanh execution times on a small fully connected network using OpenVINO; the claim that 'these results can be extended to U-Net' is speculative and should be supported by measurements on a convolutional U-Net or softened.
  4. [Section 3.2, Full Precision Layers] The observation that keeping the last layer in full precision matters more than keeping the first layer is presented without an ablation table; a small quantitative comparison would make the claim more convincing.
  5. [General reproducibility] The paper states that code is released, but for reproducibility it would help to specify the exact commit or version of the repository, the PyTorch version, and the exact inference-mode graph export procedure used to produce the reported Dice scores.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: results are empirical measurements against full-precision and baseline quantizations; the central claim does not reduce to its inputs.

full rationale

The paper's load-bearing claims are empirical. A fixed-point quantization function (Eqs. 1-4) is applied to U-Net weights and activations, and Dice scores are then measured on the EM, GM, and NIH test sets (Table 1). The claimed 8x weight-memory reduction is a direct arithmetic consequence of storing weights in 4 bits instead of 32 bits; the Dice losses are measured values, not quantities derived from the quantization formula. No parameter is fitted to a subset and then renamed as a prediction, and no uniqueness theorem or ansatz is imported from the authors' prior work. The only self-citation (Honari et al. for Recombinator Networks) supports background architectural motivation and is not load-bearing for the quantization results. Two concerns were considered but do not constitute circularity. First, Section 3.2 states that at inference PyTorch folds batch-norm parameters into weights and the paper does not state whether the folded weights are re-quantized; this is a deployment-correctness question, not a reduction of the claim to its inputs. Second, the abstract reports Dice losses of 2.21/0.57/2.09 for Qw0.4/Qa6.0 while Table 1 implies 3.02/0.47/2.21; this is an internal inconsistency, not a circular derivation. The central claim remains an independent empirical comparison against full-precision, BNN, and TernaryNet baselines.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The paper introduces no new theoretical entities; the central claim rests on standard quantization practice (STE, fixed-point rounding) plus empirical choices of bit-width. The main risk is the BatchNorm folding assumption, which is not verified.

free parameters (4)
  • weight fractional bits (fw) = 4 (Qw0.4)
    Chosen by the authors as the best accuracy-memory trade-off; the paper states 'based on our experiments' and the headline result uses Qw0.4.
  • activation integer bits (ia) = 6 (Qa6.0)
    Chosen as the headline activation precision; Table 1 shows it as the best trade-off among tested values.
  • weight integer bits (iw) = 0
    Set to 0 because the authors observed all U-Net weights fall in [-1,1] (Fig S1). This is an empirical observation, not a theoretical guarantee.
  • activation fractional bits (fa) = 0
    Activations are quantized as integers with 6 bits; this is a design choice that works for the tested datasets.
assumptions (4)
  • domain assumption Straight-through estimator (STE) provides a valid gradient approximation for training quantized networks.
    Section 3.1 uses STE to make the quantization differentiable; the accuracy results depend on this approximation.
  • domain assumption All U-Net weights remain within [-1,1], justifying zero integer bits for weight quantization.
    Section 3, based on Fig S1; this is an empirical observation for the trained models, not guaranteed during training.
  • domain assumption Quantization acts as a regularizer, so removing dropout does not hurt accuracy.
    Section 3.2 states dropout was removed because quantization regularizes; this is presented as a finding, not a proof.
  • ad hoc to paper BatchNorm folding at inference produces a model equivalent to the trained quantized model.
    Section 3.2 states Pytorch folds BatchNorm into weights at inference, but the paper does not show that the folded weights remain in the fixed-point format or that the quantizer placement matches training.

how reviews work

0 comments
Cite this review

Pith. "Pith review of U-Net Fixed-Point Quantization for Medical Image Segmentation." pith.science (2026). https://pith.science/paper/QONHFEIX

@misc{pith2026190801073,
  author       = {Pith},
  title        = {Pith review of: U-Net Fixed-Point Quantization for Medical Image Segmentation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QONHFEIX}},
  note         = {Machine review of arXiv:1908.01073}
}
read the original abstract

Model quantization is leveraged to reduce the memory consumption and the computation time of deep neural networks. This is achieved by representing weights and activations with a lower bit resolution when compared to their high precision floating point counterparts. The suitable level of quantization is directly related to the model performance. Lowering the quantization precision (e.g. 2 bits), reduces the amount of memory required to store model parameters and the amount of logic required to implement computational blocks, which contributes to reducing the power consumption of the entire system. These benefits typically come at the cost of reduced accuracy. The main challenge is to quantize a network as much as possible, while maintaining the performance accuracy. In this work, we present a quantization method for the U-Net architecture, a popular model in medical image segmentation. We then apply our quantization algorithm to three datasets: (1) the Spinal Cord Gray Matter Segmentation (GM), (2) the ISBI challenge for segmentation of neuronal structures in Electron Microscopic (EM), and (3) the public National Institute of Health (NIH) dataset for pancreas segmentation in abdominal CT scans. The reported results demonstrate that with only 4 bits for weights and 6 bits for activations, we obtain 8 fold reduction in memory requirements while loosing only 2.21%, 0.57% and 2.09% dice overlap score for EM, GM and NIH datasets respectively. Our fixed point quantization provides a flexible trade off between accuracy and memory requirement which is not provided by previous quantization methods for U-Net such as TernaryNet.

Figures

Figures reproduced from arXiv: 1908.01073 by the authors.

Figure 1
Figure 1. Sample prediction versus ground truth segmentation results for NIH Pancreas (top), EM (middle) and GM (bottom) datasets. From left to right, the result of different quantization methods and precisions are reported. Segments in show false positive, segments in show false negative and segments in show true positive. images of size 176x112. The final dataset contains 7059 176x112 2-D images which are separated into tra… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 25 canonical work pages

  1. [20]

    CoRR (2018)

    Heinrich, M.P., et al.: Ternarynet: Faster deep model inference without gpus for medical 3d segmentation using sparse and binary convolutions. CoRR (2018)

    work page 2018

  2. [1]

    Miotto,R.,etal.:Deeplearningforhealthcare:review,opportunitiesandchallenges.Briefings in Bioinformatics (2017)

    work page 2017

  3. [2]

    Data Science for Healthcare (2019)

    S., T., et al.: The role of deep learning in improving healthcare. Data Science for Healthcare (2019)

    work page 2019

  4. [3]

    JMLR (2018)

    Hubara, I., et al.: Quantized neural networks: Training neural networks with low precision weights and activations. JMLR (2018)

    work page 2018

  5. [4]

    In: MICCAI, Springer (2015)

    Ronneberger, O., et al.: U-net: Convolutional networks for biomedical image segmentation. In: MICCAI, Springer (2015)

    work page 2015

  6. [5]

    NeuroImage (2017)

    Prados, F., et al.: Spinal cord grey matter segmentation challenge. NeuroImage (2017)

    work page 2017

  7. [6]

    PLoS Biology (2010)

    Cardona, A., et al.: An integrated micro-and macroarchitectural analysis of the drosophila brain by computer-assisted serial section electron microscopy. PLoS Biology (2010)

    work page 2010

  8. [7]

    MICCAI (2015)

    Roth., H.R., et al.: Deeporgan: Multi-level deep convolutional networks for automated pancreas segmentation. MICCAI (2015)

    work page 2015

Show all 25 references
  1. [8]

    Annual review of biomedical engineering (2000)

    Pham, D.L., et al.: Current methods in medical image segmentation. Annual review of biomedical engineering (2000)

    2000

  2. [9]

    Medical Image Analysis (2017)

    Litjens, G., et al.: A survey on deep learning in medical image analysis. Medical Image Analysis (2017)

    2017

  3. [10]

    Annual review of biomedical engineering (2017)

    Shen, D., et al.: Deep learning in medical image analysis. Annual review of biomedical engineering (2017)

    2017

  4. [11]

    In: CVPR (2016)

    Honari, S., et al.: Recombinator networks: Learning coarse-to-fine feature aggregation. In: CVPR (2016)

    2016

  5. [12]

    TPAMI (2017)

    Badrinarayanan, V., et al.: Segnet: A deep convolutional encoder-decoder architecture for image segmentation. TPAMI (2017)

    2017

  6. [13]

    In:ICCV(2015)

    Noh,H.,etal.: Learningdeconvolutionnetworkforsemanticsegmentation. In:ICCV(2015)

    2015

  7. [14]

    In: CVPR (2017)

    Isola, P., et al.: Image-to-image translation with conditional adversarial networks. In: CVPR (2017)

    2017

  8. [15]

    In:ECCV,Springer (2016)

    Newell,A.,etal.: Stackedhourglassnetworksforhumanposeestimation. In:ECCV,Springer (2016)

    2016

  9. [16]

    In: MICCAI, Springer (2016)

    Çiçek, Ö., et al.: 3d u-net: learning dense volumetric segmentation from sparse annotation. In: MICCAI, Springer (2016)

    2016

  10. [17]

    CoRR (2017)

    Zhou,A.,etal.: Incrementalnetworkquantization:Towardslosslesscnnswithlow-precision weights. CoRR (2017)

    2017

  11. [18]

    In: NeurIPS (2015) U-Net Fixed-Point Quantization for Medical Image Segmentation 9

    Courbariaux, M., et al.: Binaryconnect: Training deep neural networks with binary weights during propagations. In: NeurIPS (2015) U-Net Fixed-Point Quantization for Medical Image Segmentation 9

    2015

  12. [19]

    In: CVPR (2018)

    Xu, X., et al.: Quantization of fully convolutional networks for accurate biomedical image segmentation. In: CVPR (2018)

    2018

  13. [21]

    Coursera (2012)

    Hinton, G., et al.: Neural networks for machine learning, video lectures. Coursera (2012)

    2012

  14. [22]

    JMLR (2014)

    Srivastava, N., et al.: Dropout: a simple way to prevent neural networks from overfitting. JMLR (2014)

    2014

  15. [23]

    Tang,W.,etal.: Howtotrainacompactbinaryneuralnetworkwithhighaccuracy? In:AAAI (2017)

    2017

  16. [24]

    In: Advances in Neural Information Processing Systems 25

    Krizhevsky, A., et al.: Imagenet classification with deep convolutional neural networks. In: Advances in Neural Information Processing Systems 25. Curran Associates, Inc. (2012)

    2012

  17. [25]

    Deanne Deuermeyer, Andrey Z., A.R.F.B.: Release notes for intel® distribution of open- vino™ toolkit 2019 accessed on Jun 13th 2019. 10 M.H. AskariHemmat et al. Supplementary Information for U-Net Fixed-Point Quantization for Medical Image Segmentation S.1 Weight Visualization...

    2019

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.