Caching Techniques for Reducing the Communication Cost of Federated Learning in IoT Environments

Ahmad Alhonainy (1); Praveen Rao (1) ((1) University of Missouri; USA)

REVIEW 5 major objections 6 minor 23 references

Caching Techniques for Reducing the Communication Cost of Federated Learning in IoT Environments

T0 review · 5 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read Threshold-based server-side caching cuts federated learning communication by up to 20 percent while preserving or improving model accuracy.

desk verdict A modest server-side caching idea for FL with a tautological communication saving and an unverified accuracy claim; the evidence as presented doesn't justify the conclusions. read the letter →

arxiv 2507.17772 v1 pith:E6Z7EW6L submitted 2025-07-19 cs.DC cs.AIcs.CVcs.LG

Ahmad Alhonainy (1) , Praveen Rao (1) ((1) University of Missouri , USA) This is my paper · ORCID

classification cs.DCcs.AIcs.CVcs.LG

keywords FederatedLearningCommunicationEfficiencyCachingStrategiesInternetofThingsEdgeComputingUpdateFilteringCacheReplacementPoliciesModelAccuracy

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

Federated learning lets edge devices train a shared model without uploading raw data, but every training round sends model updates back to the server, which is expensive in bandwidth-limited IoT settings. This paper argues that most of those updates are unnecessary: an update is worth sending only when its norm is large enough, and smaller updates can be withheld or replaced with a cached copy from a previous round. Using three cache replacement policies (FIFO, LRU, and a priority-based one), the server stores a bounded set of useful updates and reuses them when a client does not transmit. On standard benchmarks the scheme cuts total communication by up to 20 percent, with a worked example dropping MobileNetV2 traffic on CIFAR-10 from 1052 MB to 886 MB while increasing accuracy from 97.37 to 98.18 percent. If this holds, FL becomes more practical for constrained edge deployments such as smart-city sensors and medical devices.

What carries the argument

The significance threshold $\tau$ on the update norm $\delta_i^{(t)} = \|\Delta_i^{(t)}\|$ is the central filter: an update is transmitted only when $\delta_i^{(t)} \geq \tau$, and otherwise it is withheld or served from a server-side cache of capacity $C$. The cache is managed by three replacement policies — FIFO, LRU, and the priority-based rule $\mathrm{Priority}_i = \alpha \cdot \mathrm{Accuracy}_i + \beta \cdot \mathrm{Recency}_i$ — which decide which updates to keep under memory limits. During aggregation, the server can substitute a cached update for a client that did not transmit, and the cache-hit counter measures how often this substitution occurs. The threshold converts the question 'is this update worth sending?' into a cheap scalar comparison, and the cache converts that decision into 'is there a previously good version to reuse?'.

What would settle it

Run the same threshold-based caching on data that is strongly skewed across clients (non-IID) and compare round-by-round accuracy against no-cache FedAvg; if the 30 percent threshold loses more than a percentage point of accuracy in early rounds and never recovers, the claim that communication can be cut without hurting accuracy fails. A simpler check: plot the distribution of update norms across rounds; if small-norm updates occur frequently in early rounds, the threshold assumption is violated there.

Watch

Extended reading notes

Core claim

The central discovery is that a simple norm threshold on client updates, applied at the server before deciding whether to transmit, turns out to be enough to reduce bandwidth without hurting the model, because the server can substitute a stored copy of a previously useful update. The paper's evidence is that accuracy does not merely hold: it rises across all three tested architectures, with the largest gain being 2.4 percent for EfficientNetB0. The explanation offered is that cache reuse discards noisy low-magnitude updates while recycling updates already shown to help, effectively acting as a regularizer.

Load-bearing premise

The load-bearing premise is that a client update with a small norm can be omitted or replaced by a stale cached update without degrading the global model.

Editorial extensions

If this is right

Deploying FL on bandwidth-constrained edge hardware becomes feasible without sacrificing model quality, because the saved bytes come from skipping redundant updates rather than shrinking the model.
The threshold $\tau$ gives operators a tunable knob: lower thresholds send more updates and train faster, while higher thresholds save more bandwidth with accuracy held up by cache reuse.
Memory-aware replacement policies keep server-side cache growth bounded, so a single server can support more clients before hitting device memory limits.
Because the filter looks only at update vectors and not at data content, the same mechanism should apply to any federated task, not just image classification.

Reading between the lines

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

The threshold rule is implicitly a sparsity assumption: most updates are small. A testable extension would be to measure the distribution of $\|\Delta_i^{(t)}\|$ across rounds and clients early in training, when gradients tend to be large and informative; if small-norm updates occur mostly late in training, the benefit may concentrate in later rounds.
The accuracy gains reported (e.g., +2.4% for EfficientNetB0) suggest caching may act as a denoiser. An explicit convergence analysis comparing FedAvg with and without update substitution on non-IID data would separate this regularizing effect from plain variance reduction.
The priority score uses $\mathrm{Accuracy}_i$ and $\mathrm{Recency}_i$, but the paper does not define how $\mathrm{Accuracy}_i$ is measured for an update; a concrete instantiation would make PBR reproducible and testable.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Briefly: this is a modest idea with a weak empirical package. The application of FIFO, LRU, and priority-based replacement to server-side filtering of federated updates is new in a narrow sense — I don't see that exact combination in the cited caching-enabled FL work — but the paper doesn't demonstrate that it works. The mechanisms are described clearly enough that the algorithm is reproducible, and the authors do cite the relevant compression and caching literature (DGC, TernGrad, FedCache). Running on real edge devices like Jetson Nano and Raspberry Pi is a plus, and the threshold-based filtering is a sensible direction to explore.

That said, the load-bearing claims don't hold up. The communication reduction is tautological: the cost formula counts only updates above threshold, so any threshold trivially reduces bytes sent. The abstract's 'up to 20%' never appears in the results; the one reported figure is 15.8%. The accuracy claim, which has to carry the paper, is unsupported. There is no training protocol (rounds, local epochs, learning rate, data split), no error bars, no baseline learning curves, and no comparison against DGC or TernGrad. The reported accuracy gains — including 97.30% to 99.70% for EfficientNetB0 on CIFAR-10 — are suspiciously high and unexplained. The explanation that the cache reuses 'previously effective' updates is an assertion, not an analysis.

The memory-efficiency claim has a straightforward internal contradiction. Section VII-C defines cache memory as the sum of stored update sizes. With capacity C ≤ 8 and DenseNet121 updates around 32 MB in float32, the cache should cap near 256 MB. The figure reports 2.50 GB for 3 clients and 4.20+ GB for 12 clients. Those numbers are not the quantity the paper defines, so the memory claim is also unverified.

The core idea is plausible — selective reuse of stale updates could help or hurt depending on the setting, and that is exactly why careful experiments are needed. The paper doesn't provide them. There is also no code or data release, which further limits reproducibility.

For whom is this? A researcher working on FL communication compression might want to test the simple threshold-and-cache filter on their own setup. But as a paper, it is not ready for serious review. If it crossed my desk, I would desk-reject or send it back for a major rewrite with real experimental discipline: baseline curves, error bars, comparisons to existing methods, and a corrected memory measurement.

Referee Report

5 major / 6 minor

Summary. The paper proposes FICache, a server-side caching framework for federated learning in IoT environments. Clients transmit a model update only when its norm exceeds a threshold tau; otherwise the server can reuse a cached update from an earlier round. Three replacement policies (FIFO, LRU, and Priority-Based Replacement) are evaluated. The authors claim that this reduces total communication by up to 20% while maintaining or improving model accuracy, based on experiments with MobileNetV2, EfficientNetB0, and DenseNet121 on CIFAR-10 and a histopathology dataset. The only concrete communication figure is a 15.8% reduction (1052 MB to 886 MB) for MobileNetV2 at a 30% threshold; accuracy improvements of up to 2.4% are reported, and memory usage is discussed in Section VII-C.

Significance. The problem is relevant: reducing communication cost is a key obstacle to federated learning on edge devices, and a simple server-side caching mechanism could be practically useful if it truly preserved accuracy. The paper addresses a real deployment scenario using Jetson Nano, Raspberry Pi, and Flower, which makes the intent practical. However, the current evidence does not support the central claims: the communication saving is essentially a consequence of the threshold definition, the accuracy results lack any statistical or protocol support, and the memory numbers are internally inconsistent. The paper also provides no code, no convergence analysis, and no comparison against the cited compression baselines. If the accuracy and memory claims could be substantiated, the idea would merit attention, but the manuscript in its present form is not sufficient for publication.

major comments (5)

[VII-A, Eq. (1)] The communication-saving component of the central claim is mostly tautological. Equation (1) defines CommCost_T by summing only updates with δ_i^(t) ≥ τ, so any positive threshold mechanically reduces the byte count relative to a baseline that transmits every update. The only concrete reduction shown is 15.8% (1052 MB to 886 MB) for MobileNetV2, not the 'up to 20%' claimed in the abstract and conclusion. The authors should report the communication reduction for every configuration, state the exact no-cache baseline, and demonstrate that the saving is not merely an artifact of the counting rule.
[VII-B] The accuracy-maintenance claim is unsubstantiated because the experimental protocol is not reported. The paper does not state the number of rounds, local epochs, learning rate, batch size, client participation rule, data partition (IID vs non-IID), or how τ is normalized 'relative to improvement magnitude'. No error bars, standard deviations, or learning curves are provided, and the reported gains (e.g., EfficientNetB0 rising from 97.30% to 99.70%) are presented as single final accuracies. A single-run comparison against a no-cache baseline cannot support a claim of improved accuracy.
[V-A, VI-E] The mechanism's core assumption—that low-norm updates can be withheld or replaced by stale cached updates without harming the global model—is never tested in isolation. Stale updates are computed against an outdated global model and are therefore biased; whether they help or hurt is an empirical question that depends on training phase, client sparsity, and data heterogeneity. Without a convergence analysis, an ablation that varies τ from 0 to large values, or experiments under non-IID and sparse-client settings, the paper provides no evidence that accuracy is maintained rather than degraded by the thresholding step.
[VII-C, Eq. (3), Fig. 5] The memory-efficiency results are internally inconsistent. Equation (3) defines server cache memory as the sum of cached update sizes, and Section VI-D fixes cache capacity C at 3, 4, 6, or 8; with DenseNet121 updates of roughly 32 MB in float32, the maximum cache memory should be well under 256 MB. Figure 5, however, reports 2.50 GB for 3 clients and 4.20+ GB for 12 clients, which is more than ten times the formula's bound. The authors must clarify whether Fig. 5 reports cache memory as defined or total server process memory (as suggested by Section VI-E), and report both consistently.
[II, VII] No experimental comparison is made against the communication-compression baselines cited in Related Work (DGC, TernGrad) or against simple baselines such as transmitting the update only every k rounds. The paper therefore does not establish that caching, rather than arbitrary update skipping or a fixed transmission schedule, yields the claimed accuracy–communication trade-off.

minor comments (6)

[VI-D] The sentence 'The server cache size C is varied across 3, 4, 6, and 8 clients' is confusing because C is defined as the number of cached updates, not the number of clients; please rephrase.
[V-D] The priority score Priority_i = α·Accuracy_i + β·Recency_i uses Accuracy_i and Recency_i, but neither is defined; in particular, it is unclear how a single client update's 'accuracy' is measured without a validation set.
[VII-D] The XGBoost experiment for predicting the best caching strategy lacks essential details: the features collected, label construction, train/test split, and cross-validation procedure are not described, so Figure 6 cannot be interpreted.
[VI-E] CacheHits_T is defined but never reported; without cache-hit statistics, the claimed reuse of 'previously effective' updates cannot be evaluated.
[Figures 3–5] The captions should state the model, threshold, cache strategy, and experimental conditions; currently they are too generic to support the surrounding claims.
[Abstract and Conclusion] The claim of 'up to 20%' communication reduction is not supported by the 15.8% figure shown in Section VII-A; please either report the configuration that achieves 20% or amend the claim.

Circularity Check

1 steps flagged · score 6.0 of 10

Communication savings are definitional: the cost metric counts only updates passing the threshold, so the reported reduction is built into the metric; accuracy gains are unverified but not circular.

self definitional [Section VII-A, Communication Cost Reduction, CommCost_T equation]
"CommCost_T = Σ_{t=1}^T Σ_{i∈C(t)} 1[δ_i^(t) ≥ τ] · Size(Δ_i^(t)) ... The indicator function 1[δ_i^(t) ≥ τ] ensures that only significant updates (above threshold) are counted ... using a 30% threshold with MobileNetV2 on CIFAR-10 lowers the total communication volume from 1052 MB to 886 MB—a reduction of over 15%."

The communication-cost metric is defined by the same threshold rule the method applies. Since the sum only counts updates with ‖Δ_i^(t)‖ ≥ τ, raising τ mechanically removes terms from the sum; the reported 15% reduction is an arithmetic consequence of the definition, not an independently measured outcome. Thus the headline 'reduces communication' reduces by construction to 'the filter drops some updates'. The accuracy half of the paper is a separate empirical claim, so the circularity is partial rather than total.

full rationale

No self-citations are load-bearing, no uniqueness theorem is imported, and no fitted parameter is renamed as a prediction. The one genuine circular step is the communication-cost result: Sec. VII-A defines CommCost_T with the indicator 1[δ_i^(t) ≥ τ], which is exactly the transmission rule from Sec. V-A. Therefore the measured byte reduction is forced by the metric's definition and cannot serve as independent evidence for the method. The accuracy improvements (MobileNetV2 97.37→98.18, EfficientNetB0 97.30→99.70, DenseNet121 99.15→99.39) are not circular: they are empirical claims that would need training protocol, baselines, and error bars to verify, and their absence is a reproducibility/correctness problem rather than circularity. Similarly, Sec. VII-C's memory figures (2.50–4.20 GB) are inconsistent with cache capacity C≤8 and typical DenseNet update sizes; this is an internal-consistency issue, not a circular-derivation issue. Overall score 6 reflects that one of the two central claims—communication saving—reduces by construction, while the accuracy claim retains independent content.

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

The central claim rests on thresholding and cache reuse assumptions rather than a derivation. Most numerical choices (tau, alpha, beta, gamma, C) are hand-selected and not fully reported, which limits how much the paper adds beyond the stated framework.

free parameters (4)

Significance threshold tau = 1%, 10%, 30% of improvement magnitude (values chosen, not disclosed as absolute)
Controls whether an update is transmitted and directly sets the communication-accuracy trade-off. It is a hand-chosen hyperparameter (Sections V-A and VI-D).
Priority weights alpha and beta = not reported
Weight accuracy and recency in the PBR priority score; values are not given, so the strategy is not fully reproducible (Section V-D).
Priority selection threshold gamma = not reported
Determines which updates enter the selected set S(t); it is tunable and not specified (Section V-D).
Cache capacity C = 3, 4, 6, 8 clients
Server cache size is varied manually, and its unit (clients rather than bytes or updates) is inconsistent with the memory formula in Section VII-C.

assumptions (4)

domain assumption Client updates with norm below tau are insignificant and can be withheld or replaced by a cached prior update without hurting the global model.
Introduced in Section V-A; the entire communication saving and accuracy claim depends on this premise.
domain assumption Cached updates from earlier rounds remain useful for current aggregation.
Cache hits reuse stale updates, but no staleness bound or convergence argument is provided (Sections V-A and VI-E).
domain assumption Communication is synchronous and clients have sufficient local compute capability.
Stated in Section III as assumptions; this limits applicability but does not by itself break the central claim.
standard math The global objective minimization setup and FedAvg baseline are standard.
Section I uses the standard FL objective from McMahan et al.; this is accepted background.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Caching Techniques for Reducing the Communication Cost of Federated Learning in IoT Environments." pith.science (2026). https://pith.science/paper/E6Z7EW6L

@misc{pith2026250717772,
  author       = {Pith},
  title        = {Pith review of: Caching Techniques for Reducing the Communication Cost of Federated Learning in IoT Environments},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/E6Z7EW6L}},
  note         = {Machine review of arXiv:2507.17772}
}

read the original abstract

Federated Learning (FL) allows multiple distributed devices to jointly train a shared model without centralizing data, but communication cost remains a major bottleneck, especially in resource-constrained environments. This paper introduces caching strategies - FIFO, LRU, and Priority-Based - to reduce unnecessary model update transmissions. By selectively forwarding significant updates, our approach lowers bandwidth usage while maintaining model accuracy. Experiments on CIFAR-10 and medical datasets show reduced communication with minimal accuracy loss. Results confirm that intelligent caching improves scalability, memory efficiency, and supports reliable FL in edge IoT networks, making it practical for deployment in smart cities, healthcare, and other latency-sensitive applications.

Figures

Figures reproduced from arXiv: 2507.17772 by the authors.

**Figure 1.** Overview of FL steps inspired by [15] V. CACHING STRATEGIES In our proposed framework, the central server maintains a cache to store selected client updates that are deemed significant for aggregation. The goal is to reduce communication overhead by avoiding redundant transmissions of low-impact updates while preserving model accuracy. To manage this cache effectively under memory constraints, we evaluate three cla… view at source ↗

**Figure 2.** Client-Server Strategy A. Caching Workflow As shown in [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 4.** Accuracy improvement with cache vs. no cache across [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗

Figures from the paper (3 more)

**Figure 3.** Figure 3: Comparison of total communication cost and accuracy [PITH_FULL_IMAGE:figures/full_fig_p004_3.png]

**Figure 5.** Figure 5: Memory usage for FICache across 3, 6, and 12 clients. [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]

**Figure 6.** Figure 6: Confusion matrix of classifier predictions across [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

23 extracted references · 15 canonical work pages

[1]

Communication-efficient learning of deep networks from decentralized data,

B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial intelligence and statistics . PMLR, 2017, pp. 1273– 1282

2017
[2]

Machine learning-based cache replacement policies: A survey,

P. Pratheeksha and S. A. Revathi, “Machine learning-based cache replacement policies: A survey,” International Journal of Engineering and Advanced Technology (IJEAT) , vol. 10, no. 6, pp. 19–22, August

work page
[3]

Learning multiple layers of features from tiny images,

A. Krizhevsky, G. Hinton et al. , “Learning multiple layers of features from tiny images,” 2009

2009
[4]

Deep gradient compression: Reducing the communication bandwidth for distributed training,

Y . Lin, S. Han, H. Mao, Y . Wang, and W. J. Dally, “Deep gradient compression: Reducing the communication bandwidth for distributed training,” arXiv preprint arXiv:1712.01887 , 2017

arXiv 2017
[5]

Terngrad: Ternary gradients to reduce communication in distributed deep learning,

W. Wen, C. Xu, F. Yan, C. Wu, Y . Wang, Y . Chen, and H. Li, “Terngrad: Ternary gradients to reduce communication in distributed deep learning,” Advances in neural information processing systems , vol. 30, 2017

work page 2017
[6]

In-edge ai: Intelligentizing mobile edge computing, caching and communication by federated learning,

X. Wang, Y . Han, C. Wang, Q. Zhao, X. Chen, and M. Chen, “In-edge ai: Intelligentizing mobile edge computing, caching and communication by federated learning,” Ieee Network, vol. 33, no. 5, pp. 156–165, 2019

work page 2019
[7]

Achieving optimal cache utility in con- strained wireless networks through federated learning,

S. Chilukuri and D. Pesch, “Achieving optimal cache utility in con- strained wireless networks through federated learning,” in 2020 IEEE 21st International Symposium on” A World of Wireless, Mobile and Multimedia Networks”(WoWMoM). IEEE, 2020, pp. 254–263

work page 2020
[8]

Federated edge intelligence and edge caching mechanisms. information 2023, 14, 414,

A. Karras, C. Karras, K. Giotopoulos, D. Tsolis, K. Oikonomou, and S. Sioutas, “Federated edge intelligence and edge caching mechanisms. information 2023, 14, 414,” 2023

work page 2023

Show all 23 references

[9]

Cache- enabled federated learning systems,

Y . Liu, L. Su, C. Joe-Wong, S. Ioannidis, E. Yeh, and M. Siew, “Cache- enabled federated learning systems,” in Proceedings of the Twenty- fourth International Symposium on Theory, Algorithmic Foundations, and Protocol Design for Mobile Networks and Mobile Computing, 2023, pp. 1–11

2023
[10]

Fedcache: A knowledge cache-driven federated learning architecture for personalized edge intelligence,

Z. Wu, S. Sun, Y . Wang, M. Liu, K. Xu, W. Wang, X. Jiang, B. Gao, and J. Lu, “Fedcache: A knowledge cache-driven federated learning architecture for personalized edge intelligence,” IEEE Transactions on Mobile Computing, vol. 23, no. 10, pp. 9368–9382, 2024

2024
[11]

Flower: A friendly federated learning research framework,

D. J. Beutel, T. Topal, A. Mathur, X. Qiu, J. Fernandez-Marques, Y . Gao, L. Sani, K. H. Li, T. Parcollet, P. P. B. de Gusm ˜ao et al. , “Flower: A friendly federated learning research framework,” arXiv preprint arXiv:2007.14390, 2020

2007 arXiv
[12]

Jetson nano developer kit,

NVIDIA, “Jetson nano developer kit,” https://developer.nvidia.com/ embedded/jetson-nano, n.d., accessed: 2025-06-28

2025
[13]

Raspberry pi 4 model b,

Raspberry Pi Foundation, “Raspberry pi 4 model b,” https:// www.raspberrypi.com/products/raspberry-pi-4-model-b/, n.d., accessed: 2025-06-28

2025
[14]

Chameleon: A large-scale, reconfigurable exper- imental environment for cloud research,

Chameleon Cloud, “Chameleon: A large-scale, reconfigurable exper- imental environment for cloud research,” https://chameleoncloud.io/, 2023, accessed: 2025-06-28

2023
[15]

Image- based crop disease detection with federated learning,

D. Mamba Kabala, A. Hafiane, L. Bobelin, and R. Canals, “Image- based crop disease detection with federated learning,” Scientific Reports, vol. 13, no. 1, p. 19220, 2023

2023
[16]

Python system and process utilities,

Psutil, “Python system and process utilities,” https://psutil.readthedocs. io/, n.d., accessed: 2025-06-29

2025
[17]

Wireshark: Go deep,

Wireshark, “Wireshark: Go deep,” https://www.wireshark.org/, n.d., ac- cessed: 2025-06-29

2025
[18]

Tcpdump & libpcap,

Tcpdump & libpcap, “Tcpdump & libpcap,” http://www.tcpdump.org/, n.d., accessed: 2025-06-29

2025
[19]

Lung and colon cancer histopathological image dataset (lc25000),

A. A. Borkowski, M. M. Bui, L. B. Thomas, C. P. Wilson, L. A. DeLand, and S. M. Mastorides, “Lung and colon cancer histopathological image dataset (lc25000),” arXiv preprint arXiv:1912.12142 , 2019

1912 arXiv
[20]

Mobilenets: Efficient convo- lutional neural networks for mobile vision applications,

A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, and H. Adam, “Mobilenets: Efficient convo- lutional neural networks for mobile vision applications,” arXiv preprint arXiv:1704.04861, 2017

2017 arXiv
[21]

Efficientnet: Rethinking model scaling for con- volutional neural networks,

M. Tan and Q. Le, “Efficientnet: Rethinking model scaling for con- volutional neural networks,” in International conference on machine learning. PMLR, 2019, pp. 6105–6114

2019
[22]

Densely connected convolutional networks,

G. Huang, Z. Liu, L. Van Der Maaten, and K. Q. Weinberger, “Densely connected convolutional networks,” in Proceedings of the IEEE confer- ence on computer vision and pattern recognition , 2017, pp. 4700–4708

2017
[2021]

Available: https://doi.org/10.35940/ijeat.F2907.0810621

[Online]. Available: https://doi.org/10.35940/ijeat.F2907.0810621

Pith tools

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

[1] [1]

Communication-efficient learning of deep networks from decentralized data,

B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial intelligence and statistics . PMLR, 2017, pp. 1273– 1282

2017

[2] [2]

Machine learning-based cache replacement policies: A survey,

P. Pratheeksha and S. A. Revathi, “Machine learning-based cache replacement policies: A survey,” International Journal of Engineering and Advanced Technology (IJEAT) , vol. 10, no. 6, pp. 19–22, August

work page

[3] [3]

Learning multiple layers of features from tiny images,

A. Krizhevsky, G. Hinton et al. , “Learning multiple layers of features from tiny images,” 2009

2009

[4] [4]

Deep gradient compression: Reducing the communication bandwidth for distributed training,

Y . Lin, S. Han, H. Mao, Y . Wang, and W. J. Dally, “Deep gradient compression: Reducing the communication bandwidth for distributed training,” arXiv preprint arXiv:1712.01887 , 2017

arXiv 2017

[5] [5]

Terngrad: Ternary gradients to reduce communication in distributed deep learning,

W. Wen, C. Xu, F. Yan, C. Wu, Y . Wang, Y . Chen, and H. Li, “Terngrad: Ternary gradients to reduce communication in distributed deep learning,” Advances in neural information processing systems , vol. 30, 2017

work page 2017

[6] [6]

In-edge ai: Intelligentizing mobile edge computing, caching and communication by federated learning,

X. Wang, Y . Han, C. Wang, Q. Zhao, X. Chen, and M. Chen, “In-edge ai: Intelligentizing mobile edge computing, caching and communication by federated learning,” Ieee Network, vol. 33, no. 5, pp. 156–165, 2019

work page 2019

[7] [7]

Achieving optimal cache utility in con- strained wireless networks through federated learning,

S. Chilukuri and D. Pesch, “Achieving optimal cache utility in con- strained wireless networks through federated learning,” in 2020 IEEE 21st International Symposium on” A World of Wireless, Mobile and Multimedia Networks”(WoWMoM). IEEE, 2020, pp. 254–263

work page 2020

[8] [8]

Federated edge intelligence and edge caching mechanisms. information 2023, 14, 414,

A. Karras, C. Karras, K. Giotopoulos, D. Tsolis, K. Oikonomou, and S. Sioutas, “Federated edge intelligence and edge caching mechanisms. information 2023, 14, 414,” 2023

work page 2023