Multiply-And-Max/Min (MAM) Neuron Pruning for Edge Deep Neural Networks — IEEE Transactions 2025 Base Paper Project

MAM is a different kind of neuron for deep neural networks: instead of adding up all the multiplied inputs the way a classic multiply-and-accumulate (MAC) neuron does, a multiply-and-max/min (MAM) neuron keeps only the largest and the smallest products. Because each neuron depends on just its extreme products, a layer built from MAM neurons can have most of its interconnections removed — pruned — with negligible performance loss, which is exactly what a low-resource edge device needs.

Deep neural networks are too large for small devices because they carry a massive number of trainable parameters, and most of those parameters are redundant. Pruning removes the unnecessary interconnections, but on classic MAC layers pruning quickly costs accuracy: every weight contributes to the sum, so removing weights changes every neuron's output. The paper by Prono, Bich, Boretti, Mangia, Pareschi, Rovatti and Setti, published in IEEE Transactions on Neural Networks and Learning Systems in 2025, replaces the sum reduction with a max/min selection, so each neuron's output depends only on its largest and smallest products. The paper's own reported result, labelled as such, is that on ViT-B/16 fine-tuned on ImageNet-1K with one-shot gradient-based pruning, at a 6% decrease in accuracy, MAC-based layers need at least 38.2% of interconnections remaining, while MAM-based layers achieve the same accuracy with only 0.1% remaining. This project implements that method for a student build, evaluated on the public CIFAR-10, CIFAR-100 and ImageNet-1K datasets with the AlexNet, VGG-16 and ViT-B/16 models from the paper, and adds a clearly separate student contribution: an edge deployment with measured latency and energy, plus an Indian-scene image-classification demo.

A network that keeps only 0.1% of its interconnections is a network that fits on a small device: fewer weights to store, fewer multiplications per inference, and less energy per image. The student build makes that concrete — the same MAM layers the paper describes, pruned with the same family of techniques, then run on a low-resource edge device where latency and energy are measured rather than assumed, and demonstrated on illustrated Indian street scenes. The demo scenes are illustrations built for the demo, not benchmark data, and no Indian dataset is claimed.

This is a built-to-order software project: the MAM model, pruning experiments, edge deployment, demo consoles, report, presentation, and viva Q&A are prepared fresh for you. Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked).

Related built-to-order IEEE base-paper projects on this site: efficient transformer NAS with post-training quantization (https://projectech.in/projects/efficient-transformer-nas-post-training-quantization/), self-supervised ViT for low-label industrial defect detection (https://projectech.in/projects/self-supervised-vit-low-label-industrial-defect-detection/), GNN and Transformer anomaly detection in graph networks (https://projectech.in/projects/gnn-transformer-anomaly-detection-graph-networks/), and graph kernel neural networks for graph classification and regression (https://projectech.in/projects/graph-kernel-neural-networks-graph-classification-regression/).

The Problem

Deep neural networks keep getting larger, and the devices students want to run them on — a single-board computer, a small edge module, a microcontroller-class board — keep staying small. The mismatch is the number of interconnections: a modern vision model carries far more weights than a low-resource device can store or evaluate quickly, and most of those weights are redundant. Pruning is the standard answer, removing interconnections that do not matter, but on a classic MAC neuron every weight feeds the sum, so removing weights changes the output and accuracy falls steeply once pruning gets aggressive. The gap this project addresses is structural rather than procedural: instead of pruning harder around a neuron that resists pruning, change the neuron itself so that most of its interconnections never mattered in the first place. The MAM neuron does exactly that — its output is the largest or smallest product, so every other interconnection can be removed without changing what the neuron computes — and the paper shows the idea scales from AlexNet and VGG-16 to ViT-B/16. The student build then faces the variant the paper does not cover: the pruned model running on a real low-resource edge device, with latency and energy measured, and classifying illustrated Indian street scenes.

Base paper at a glance

Base paper

• Paper: "A Multiply-And-Max/Min Neuron Paradigm for Aggressively Prunable Deep Neural Networks", Luciano Prono, Philippe Bich, Chiara Boretti, Mauro Mangia, Fabio Pareschi, Riccardo Rovatti, Gianluca Setti, IEEE Transactions on Neural Networks and Learning Systems, 2025, vol. 36, no. 8, pp. 14414–14427.
• DOI: https://doi.org/10.1109/TNNLS.2025.3527644 (IEEE Xplore document 10844336; open access). The authors' public code is at https://github.com/SSIGPRO/mamtorch, cited as the paper's reference implementation, not as this build's code.
• Problem the paper tackles: deep neural networks carry a massive number of trainable parameters that are greatly redundant, and pruning them is necessary for low-power, low-resource deployment — but on classic multiply-and-accumulate (MAC) neurons every interconnection feeds the sum, so aggressive pruning costs accuracy.
• What is implemented from the paper: the MAM map-reduce neuron, replacing the MAC sum reduction with a max/min selection over the multiplied values; MAM layers built from those neurons in AlexNet, VGG-16 and ViT-B/16; pruning approaches from single-shot to training-dependent and iterative techniques, including one-shot gradient-based pruning; and evaluation on the public CIFAR-10, CIFAR-100 and ImageNet-1K datasets.
• What is deliberately not claimed: no numeric figure is quoted as this build's result beyond the single comparison the paper reports (0.1% vs 38.2% remaining interconnections at a 6% accuracy decrease), labelled as the paper's own claim; no figure from any thesis or secondary source is used; demo console read-outs are illustrations, not measured results; the mamtorch repository is the paper's public code, not this build's code.
• Paper-reported results (the paper's own findings, not this build's measured results): the authors report that on ViT-B/16 fine-tuned on ImageNet-1K with one-shot gradient-based pruning, at a 6% decrease in accuracy, MAC-based layers need at least 38.2% remaining interconnections, while MAM-based layers achieve the same accuracy with only 0.1% remaining. The paper also states, as its own claim, that MAM layers are naturally and aggressively prunable with negligible performance loss, and that most existing pruning techniques work with MAM layers with little to no changes. The student build's report records only the figures its own pruning runs actually produce.

Own features

These are the student's own contribution, clearly distinct from the base paper:

• [Edge deployment with measured latency and energy] The pruned MAM model is deployed on a low-resource edge device — a single-board computer in the reference build — and latency per image and energy per 100 images are measured on that device, so the pruning saving is shown as a running system rather than a parameter count. The paper evaluates pruning on benchmark datasets only and does not deploy to an edge device.
• [Indian-scene image-classification demo] The pruned model classifies illustrated Indian street scenes — an auto-rickshaw, a street market, a temple, a train station, a cricket ground, a monsoon street — in an interactive console, so a reviewer can see the pruned model work on familiar scenes. The scenes are illustrations drawn for the demo, labelled as such wherever they appear; no Indian dataset is claimed, and the scenes are not CIFAR-10 or ImageNet-1K data.
• [Pruning console] An interactive console with a remaining-interconnections control that plots accuracy against pruning for MAC and MAM layers, with the paper's two anchor points (38.2% MAC, 0.1% MAM at a 6% accuracy decrease) marked as the paper's own figures and every other point labelled as an illustration. The paper runs its own pruning experiments; this console is the student's visualisation.
• [MAM vs MAC neuron explorer] A console that lets a reviewer set inputs and weights, see the four products, and compare the MAC sum against the MAM max/min selection side by side, so the viva can show exactly which interconnections a MAM neuron can drop without changing its output. The paper defines the neuron; this explorer is the student's illustration of the mechanism.

The pipeline runs as a visible chain, and each stage's output is shown in the demos so a student can explain it in a viva. First, a model is loaded — AlexNet, VGG-16 or ViT-B/16 — with its MAC layers replaced by MAM layers, so each neuron multiplies its inputs by their weights and then selects the largest or smallest product. The model is trained or fine-tuned on a public dataset: CIFAR-10, CIFAR-100 or ImageNet-1K in the paper's setup, with ViT-B/16 fine-tuned on ImageNet-1K for the headline comparison. Then pruning is applied: a pruning technique scores the interconnections — one-shot gradient-based pruning in the paper's headline setting — and the lowest-scoring interconnections are removed, leaving a chosen percentage remaining. Because a MAM neuron's output depends only on its extreme products, most interconnections can be removed without changing what the neuron computes, so accuracy falls far more slowly than on MAC layers. The pruned model is then deployed on a low-resource edge device, where latency per image and energy per 100 images are measured on the device itself. Finally the Indian-scene demo runs the pruned model on illustrated Indian street scenes in the console, with every scene and confidence read-out labelled as an illustration.

1. Load AlexNet, VGG-16 or ViT-B/16 and replace the MAC layers with MAM map-reduce layers.
2. Train or fine-tune on CIFAR-10, CIFAR-100 or ImageNet-1K (ViT-B/16 fine-tuned on ImageNet-1K for the headline comparison).
3. Score interconnections with a pruning technique, starting with one-shot gradient-based pruning as in the paper.
4. Remove the lowest-scoring interconnections, leaving a chosen percentage remaining.
5. Re-measure accuracy at each pruning level and record the remaining-interconnections curve.
6. Repeat with training-dependent and iterative pruning techniques to compare approaches.
7. Compare MAC and MAM layers at the same accuracy decrease — the paper's headline comparison is at a 6% decrease.
8. Deploy the pruned MAM model on a low-resource edge device.
9. Measure latency per image and energy per 100 images on the device itself.
10. Run the Indian-scene demo and record only the figures the student's own runs produce.

Tech stack:

• Python 3 · PyTorch · mamtorch
• MAM neurons · multiply-and-max/min layers
• ViT-B/16 · VGG-16 · AlexNet
• CIFAR-10 · CIFAR-100 · ImageNet-1K
• scikit-learn · NumPy · Matplotlib
• HTML · CSS · JavaScript demo consoles
• Git · Jupyter Notebook

Dataset & model details

• Dataset (paper and student build): CIFAR-10, CIFAR-100 and ImageNet-1K — the three public image-classification datasets from the paper. The student build evaluates on all three; the paper's headline comparison uses ViT-B/16 fine-tuned on ImageNet-1K. No dataset size or class count beyond the dataset names is claimed on this page.
• Dataset (demo consoles): Six illustrated Indian street scenes drawn for the demo (auto-rickshaw, street market, temple, train station, cricket ground, monsoon street) and a small illustrated neuron example with 4 inputs. They are not benchmark data, and they are labelled as such wherever they appear. No benchmark image is displayed on this page.
• Dataset (Indian extension): No published Indian image dataset is claimed. The Indian-scene demo is demonstrated in the console on illustrated scenes built for the demo, and it is labelled as such wherever it appears.
• Task: Image classification; input = one image, output = one class label.
• Model: The paper's system — MAM map-reduce layers replacing MAC layers, with a max/min selection over the multiplied values instead of a sum reduction, applied to AlexNet, VGG-16 and ViT-B/16. No architecture detail beyond the paper's description is claimed for it here. The authors' public code is at https://github.com/SSIGPRO/mamtorch.
• Metrics: Classification accuracy and the percentage of remaining interconnections, as in the paper, plus latency per image and energy per 100 images measured on the edge device; the student build's report records only the figures its own runs actually produce, and no figure is claimed before those runs.

MAM pruning delivers seven working capabilities: a MAM map-reduce neuron that replaces the MAC sum with a max/min selection, MAM layers in three paper models, pruning from single-shot to iterative techniques, evaluation on three public datasets, an edge deployment with measured latency and energy, an Indian-scene classification demo, and interactive demo consoles a reviewer can operate. The model never claims an accuracy figure before its own runs — the only number quoted is the paper's own reported comparison.

• [MAM map-reduce neuron] Each neuron multiplies its inputs by their weights and then selects the largest or the smallest product instead of summing all of them, so the neuron's output depends on just two interconnections and the rest can be pruned, exactly as the paper defines it.
• [MAM layers in AlexNet, VGG-16 and ViT-B/16] The paper's three test models rebuilt with MAM layers, so the pruning advantage is shown across a classic CNN, a deep CNN and a vision transformer rather than on a single architecture.
• [Pruning from single-shot to iterative] The paper's range of pruning approaches — single-shot, training-dependent and iterative techniques, including one-shot gradient-based pruning — applied to the MAM layers, with the remaining-interconnections curve recorded for each.
• [Public benchmark evaluation] The system is evaluated on the public CIFAR-10, CIFAR-100 and ImageNet-1K datasets, and only the figures the student's own runs produce are recorded in the report.
• [Edge deployment with measured latency and energy] The pruned MAM model runs on a low-resource edge device, and latency per image and energy per 100 images are measured on that device and reported as the build's own measurements.
• [Indian-scene classification demo] An interactive demo that classifies six illustrated Indian street scenes with the pruned model, with every scene and confidence read-out labelled as an illustration built for the demo.
• [Interactive demo consoles] A neuron explorer comparing the MAC sum with the MAM max/min selection, a pruning console with the paper's anchor points marked, and the edge deployment with the Indian-scene demo, so the mechanism is inspectable.

• Complete MAM source code (MAM map-reduce layers, AlexNet, VGG-16 and ViT-B/16 variants, pruning from single-shot to iterative techniques, public benchmark evaluation with accuracy and remaining interconnections)
• Edge deployment (the pruned MAM model running on a low-resource edge device, with latency and energy measured on the device)
• Interactive demo consoles (the web demos shown on this page): a MAM vs MAC neuron explorer, a pruning console with the paper's anchor points marked, and the edge deployment with the Indian-scene classification demo
• Project report PDF (background, base paper, methodology, experiments, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (MAM neurons, MAC vs MAM, pruning techniques, benchmark evaluation, edge deployment, limitations)
• Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked)
• Specific next step: message on WhatsApp for a quotation stating scope (MAM multiply-and-max/min neuron pruning for edge deep neural networks, AlexNet, VGG-16 and ViT-B/16 on CIFAR-10, CIFAR-100 and ImageNet-1K, plus an edge deployment with measured latency and energy and an Indian-scene demo), starting price Rs 28,000, and delivery under the 110-hour work plan as a built-to-order project

Work plan & timeline

Total work plan: 110 hours, split across six phases. Phase 1, base-paper study and environment setup: 15 hours — reading the Prono et al. paper, setting up Python, PyTorch and the authors' mamtorch reference code, and preparing the public CIFAR-10, CIFAR-100 and ImageNet-1K data. Phase 2, MAM layer implementation: 25 hours — the MAM map-reduce neuron, MAM layers replacing MAC layers, and the AlexNet, VGG-16 and ViT-B/16 variants. Phase 3, pruning experiments: 25 hours — single-shot, training-dependent and iterative pruning techniques, including one-shot gradient-based pruning, with the remaining-interconnections curves recorded. Phase 4, evaluation on public benchmarks: 15 hours — running the model on the three datasets and recording only the figures the student's own runs produce. Phase 5, own features: 15 hours — the edge deployment with latency and energy measurement, and the Indian-scene classification demo with the pruning console. Phase 6, presentation and viva preparation: 15 hours — PPT, demo walkthrough, and the viva Q&A document.

Support

Support covers setup help for the delivered code, a walkthrough of the system and the demo consoles, and fixes for defects in the delivered code. Guidance is also provided for adapting the report and presentation to the student's college format and for answering guide questions about the base paper, MAM neurons, MAC vs MAM, pruning techniques, benchmark evaluation, edge deployment, and the student's own contribution. Support does not cover re-running experiments on the student's personal machine beyond the setup walkthrough, and it does not invent results for experiments that were not run.