Paper deep dive
APQF: Agentic Profiling-Guided Structured Pruning and Mixed-Precision Quantization with Adaptive Fine-Tuning
Sadegh Jafari, Mohiuddin Bilwal, Fan Zhou, Brian Gelder, Ali Jannesari
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/8/2026, 3:15:08 AM
Summary
The paper introduces APQF, an agentic, profiling-guided framework for model compression that combines structured pruning, mixed-precision quantization-aware training (QAT), and adaptive fine-tuning. It utilizes a multi-agent system where a profiling agent measures layer sensitivity and computational cost, which drives an LLM-guided planner to assign per-layer pruning ratios and bit-widths. The framework employs knowledge distillation and parameter-efficient fine-tuning (PEFT) for accuracy recovery. Evaluated on ResNet, VGG7, ViT, DeiT, and Swin models across ImageNet-1k and CIFAR-10, APQF achieves significant compute reduction (13-18x) while maintaining or improving accuracy compared to baselines and existing joint pruning/quantization methods.
Entities (17)
Relation Signals (16)
APQF → evaluatedon → VGG7
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
APQF → evaluatedon → ViT
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
APQF → evaluatedon → Swin
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
APQF → evaluatedon → DeiT
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
APQF → evaluatedon → ResNet
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
APQF → uses → Structured Pruning
confidence 95% · APQF adopts structured pruning.
APQF → uses → Mixed-Precision Quantization
confidence 95% · APQF combines structured pruning with mixed-precision quantization-aware training.
APQF → usesdataset → ImageNet-1K
confidence 95% · We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Modern deep neural networks achieve strong performance, but their scale makes them costly and slow, especially on resource-constrained edge devices. Pruning and quantization address this, but rely on manual, expert choices and on algorithms that are hard to apply across architectures. Uniform settings also ignore how differently individual layers respond to compression, which costs accuracy. We introduce APQF, an agentic profiling-guided framework that combines structured pruning, mixed-precision quantization-aware training, and accuracy recovery in one automated pipeline. A profiling agent measures how cost is distributed across the model and how sensitive each part is to pruning, and this evidence drives per-layer pruning ratios, per-layer bit-widths, and the recovery strategy, all proposed by LLM planners and validated before execution. To our knowledge, APQF is the first framework to combine LLM-guided, profiling-grounded decisions with a fully training-aware pruning and quantization pipeline for both CNNs and vision transformers. We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10. On ImageNet it cuts compute to 5.6-7.7 percent of the original bit-operations, a 13-18x reduction, while keeping accuracy close to the baseline, and under a 200K-image budget it stays roughly 17 points higher in Top-1 than existing joint pruning and quantization methods. On CIFAR-10 it compresses further than that method on four of five architectures. On VGG7 it reaches 93.15 percent using only 0.41 percent of baseline bit-operations, the only method at that compression level to improve on its full-precision baseline. Ablations show that uniform compression loses the most accuracy at matched compute, and that withholding profiling data from the planner hurts every model. Six LLM planners, including free open-weight ones, all reach 97.4-97.9 percent on Swin-Tiny.
Tags
Links
- Source: https://arxiv.org/abs/2608.05499v1
- Canonical: https://arxiv.org/abs/2608.05499v1
Trouble viewing inline? Open PDF directly →
Full Text
88,287 characters extracted from source content.
Expand or collapse full text
APQF: AGENTIC PROFILING-GUIDED STRUCTURED PRUNING AND MIXED-PRECISION QUANTIZATION WITH ADAPTIVE FINE-TUNING Sadegh Jafari Department of Computer Science Iowa State University Ames, IA, USA sadegh@iastate.edu Mohiuddin Bilwal Department of Computer Science Iowa State University Ames, IA, USA moh596@iastate.edu Fan Zhou Department of Computer Science Iowa State University Ames, IA, USA fanzhou@iastate.edu Brian Gelder Department of Agricultural and Biosystems Engineering Iowa State University Ames, IA, USA bkgelder@iastate.edu Ali Jannesari Department of Computer Science Iowa State University Ames, IA, USA jannesar@iastate.edu August 7, 2026 ABSTRACT Modern deep neural networks achieve strong performance across many domains, but their scale makes them costly and slow, especially on resource-constrained edge devices. Pruning and quantization address this, but they rely on manual, expertise-driven choices, and their algorithms are often complex and hard to apply across different architectures. Uniform settings also ignore how differently individual modules respond to compression, which causes large accuracy loss. We introduce APQF, an agentic profiling-guided framework that combines structured pruning, mixed- precision quantization-aware training, and accuracy recovery in one automated pipeline. A profiling agent measures how cost is distributed across the model and how sensitive each part is to pruning. This evidence then drives a pruning agent that sets per-layer pruning ratios and a quantization agent that assigns per-layer bit-widths, while a fine-tuning agent recovers accuracy according to how much was lost and a separate evaluation agent measures every model under the same protocol. APQF is the first framework to combine LLM-guided, profiling-grounded decisions with a fully training-aware pipeline of structured pruning and mixed-precision quantization-aware training with recovery, across both convolutional networks and vision transformers. We evaluate APQF on ResNet, VGG7, ViT, DeiT, and Swin using ImageNet-1k and CIFAR-10. On ImageNet-1K it reduces compute to between 5.6 and 7.7 percent of the original bit-operations, a 13 to 18 times reduction, while keeping accuracy close to the baseline, and under a 200K-image training budget it stays roughly 17 points higher in Top-1 accuracy than existing joint pruning and quantization methods. On CIFAR-10 it compresses further than the competing joint method on four of five architectures, and DeiT-Tiny, ResNet-50, and Swin-Tiny end up more accurate than their uncompressed originals. On VGG7, it reaches 93.15 percent accuracy using only 0.41 percent of the baseline bit-operations, the only method at that level of compression to improve on its full-precision baseline. An ablation shows that uniform compression loses the most accuracy at matched compute, while withholding the measured profiling data from the LLM planner reduces accuracy on every model tested. On Swin-Tiny, six LLM planners, including free open-weight ones, all reach 97.4 to 97.9 percent accuracy, so the framework does not depend on a premium model. arXiv:2608.05499v1 [cs.CV] 6 Aug 2026 A PREPRINT - AUGUST 7, 2026 1 Introduction Modern deep neural networks (DNNs) are used in many applications across different domains [1,2]. Their strong performance has made it possible to speed up tasks that previously required manual work and specialized expertise [3]. Computer vision architectures, including both CNNs and ViTs, have also been widely used in recent years, in areas ranging from agriculture [4,3] to medicine [5,6]. One of the main challenges with these models is that, despite their strong performance, their growing scale imposes substantial computational and memory costs [7]. This makes it difficult to run them on everyday edge devices, or even on ordinary computers. In addition, larger models take longer to produce a prediction, and this added inference time causes delays in applications where users expect a fast response [8]. It is therefore important to make these models smaller and faster while keeping their performance close to that of the original model. This is the goal of model compression. The most widely used model compression techniques are pruning, which removes redundant weights or structures from the network [7]; quantization, which represents weights and activations at lower numerical precision [9]; and knowledge distillation, which transfers the behavior of a large teacher model into a smaller student [10]. Applying these techniques well is not straightforward, because each architecture distributes its computational cost and its redundancy differently. A good compression strategy therefore has to identify which parts of a given model are redundant and which are sensitive to the task, compress the redundant parts, and then recover the accuracy lost in the process, so that the compressed model stays as close as possible to the original. 1.1 Problem Statement 1.1.1 Manual and Expertise-Driven Compression A first difficulty lies in deciding how to compress a given network. Many pruning and quantization methods rely on hand-designed heuristics to decide what to remove or how aggressively to quantize, such as ranking weights or filters by their magnitude or norm [11,12]. Choosing and tuning these criteria, along with the per-layer pruning ratios and bit-widths, requires expert knowledge and considerable manual effort, and the choices that work for one model rarely transfer to another [13]. This difficulty is compounded by the fact that different architectures organize their computation and their internal dependencies in very different ways, so building a method that is model-agnostic and applies consistently across both convolutional networks and transformers is itself an engineering challenge; dependency- graph pruning was proposed precisely to make structured pruning generalize across architectures [14]. As a result, compressing a new model well still depends heavily on human expertise and trial and error. 1.1.2 Uniform Compression Ignores Layer Sensitivity Many existing methods apply pruning and quantization uniformly, using a single pruning ratio and a single bit-width for the entire model. This ignores the fact that layers differ widely in how sensitive they are; removing or heavily quantizing one layer may have little effect, while doing the same to another can sharply degrade accuracy [15], and pruning one part of the model can also change the behavior of the layers that depend on it [14,13]. A uniform setting therefore compresses some layers too aggressively and others too little at any given target. Even methods that support non-uniform pruning ratios or mixed precision often still rely on a human to decide which layers to prune, by how much, and at what bit-width, or on hand-designed sensitivity proxies rather than on measured, empirical sensitivity; and in many cases their algorithms are tied to a particular architecture and cannot easily be extended to others. This burden is made worse by the fact that the right choice is not fixed; the same architecture can behave differently on different datasets, so a configuration that works in one setting does not necessarily carry over to another. Designing an algorithm that can make these per-layer pruning and quantization decisions automatically, and adapt them to the given model and dataset, is therefore difficult. 1.1.3 Data-Hungry Joint Optimization Some approaches, such as GETA [16], are data-hungry; because they re-optimize the entire network into a sparse, low-precision subnetwork through end-to-end gradient training, they need a large amount of training data to compress the model while keeping its accuracy high. As we show later, under a limited training budget, GETA fails to recover accuracy, whereas our method remains data-efficient. This makes such methods difficult to use in settings where data or compute is limited. 1.1.4 Profiling Disconnected from Decisions Compressing a model well requires knowing where its redundant parts are for a specific dataset. This means using data to measure how the model actually reacts to compression; building a per-layer sensitivity map, and understanding how parameters and computation are distributed across the architecture [17]. Profiling tools can provide exactly this 2 A PREPRINT - AUGUST 7, 2026 kind of information, but in practice they are typically used for manual inspection rather than to drive the compression process automatically [18]. As a result, the measurement of where a model spends its cost and where it is redundant stays disconnected from the decisions about what to prune and quantize, even though understanding how compression affects the model should be one of the main inputs to those decisions. 1.2 Proposed Approach and Contributions To address these problems, we propose APQF, an agentic, profiling-guided framework for model optimization that combines structured pruning, mixed-precision quantization, and fine-tuning in a single automated pipeline. APQF is built from a set of cooperating agents that profile a target model, decide how to compress it, and recover its accuracy, so that the core compression decisions are made automatically and grounded in measured evidence rather than manual heuristics. To our knowledge, APQF is the first framework to combine LLM-guided, profiling-grounded decisions with a fully training-aware pipeline that performs sequential structured pruning and mixed-precision quantization-aware training with recovery, across both convolutional and transformer architectures.The main contributions of this thesis are as follows: •Profiling agent. A profiling component that produces a per-layer sensitivity map and a compact architecture brief, showing how parameters and computation are distributed, where the cost bottlenecks are, and how the model reacts to pruning. This measured evidence grounds all subsequent compression decisions. •LLM-guided pruning and recovery. Multi-stage structured pruning in which the LLM assigns a per-layer pruning ratio from the profiling data, followed by adaptive recovery in which the LLM selects the fine-tuning method (PEFT or full) and its hyperparameters, all in an automated process. •LLM-guided mixed-precision QAT with distillation. Quantization-aware training in which the LLM assigns a per-layer bit-width and the quantized model is trained under a knowledge-distillation objective against a full-precision teacher, with an additional optional distillation stage that further recovers accuracy after quantization. The strategy and its hyperparameters are chosen by the LLM with minimal user intervention. •Architecture-agnostic pipeline. A single framework that operates on both convolutional and transformer architectures (ResNet, VGG, ViT, DeiT, and Swin) without architecture-specific rules. •Data-efficient compression. APQF prunes a pretrained model from measured sensitivity and recovers it with parameter-efficient or full fine-tuning together with knowledge distillation. In several of our experiments, this reaches the accuracy of competing methods with less training data or fewer training epochs, because it does not re-optimize the entire network from scratch. • LLM-agnostic and future-proof design. Because APQF makes its decisions through an LLM accessed via a standard API, it is not tied to any single model; it works with a range of planners, from inexpensive open models to premium ones, and can directly benefit from stronger future LLMs without any change to the framework. 2 Related Work The expansion of deep learning has accelerated the adoption of deep neural networks. However, the significant improvement in model accuracy has been accompanied by a substantial increase in model depth, width, and parameter count, resulting in much higher computational complexity, memory size, and energy consumption [19]. These increasing resource requirements have become a key challenge to deploying modern deep neural networks on resource-constrained platforms, including smartwatches, IoT nodes, and intelligent sensors [20]. Consequently, considerable research efforts have focused on developing efficient model compression techniques that reduce computational cost while maintaining predictive performance. Moreover, the popularity of Large Language Models (LLMs) in recent years has led to a growing interest in compressing neural networks for devices with flexible hardware requirements [21]. Among these techniques, pruning, quantization, and knowledge distillation are the most widely accepted approaches for reducing inference cost and model size, while parameter-efficient fine-tuning (PEFT) has become a standard tool for adapting and recovering models at low training cost [22, 23, 24, 25]. 2.1 Profiling Model profiling evaluates a neural network’s computational and structural characteristics by extracting execution information at the model or layer level. Details such as computational cost, memory consumption, latency, and resource utilization help identify performance bottlenecks and deployment constraints [26,27]. Unlike theoretical metrics such as FLOPs (Floating Point Operations) [28], profiling reflects a model’s actual runtime behavior on the target 3 A PREPRINT - AUGUST 7, 2026 hardware and is commonly used to guide compression by identifying expensive or redundant components to prune or quantize [17]. Tools such as PyTorch Profiler [29], TensorFlow Profiler [30], NVIDIA nvprof [31], and CUPTI [32] expose fine-grained runtime traces, but these are typically used for manual inspection rather than to drive automated compression [18]. In APQF, profiling directly guides compression. The profiling agent uses ptflops [33] to measure the per-layer distribution of parameters and multiply–accumulate operations (MACs) and the PyTorch Profiler [29] to record execution time, and it performs an empirical sensitivity analysis by pruning each structural group and measuring the resulting accuracy change. This information is aggregated into a compact architecture summary that grounds the LLM’s pruning and quantization decisions in measured evidence. 2.2 Pruning Pruning is a model compression technique that removes redundant weights or structures from a neural network to lower its size and computation. It works by identifying redundant weights, channels, or layers in the model and removing them with little or no effect on performance [7]. Pruning can be categorized into Structured [12], Unstructured [11], and Semi-Structured Pruning [13]. These three techniques differ mostly in the level at which parameters are removed and in their deployment characteristics. Unstructured pruning removes individual weights and typically produces the largest compression ratio [34]. Nevertheless, its irregular sparsity frequently necessitates the use of specialized sparse compute libraries or hardware to achieve inference speedups [13]. Semi-structured pruning removes weights using predetermined sparsity patterns in order to attain both structural regularity and high model accuracy. Representative patterns, such as 2:4 sparsity, allow efficient execution on supported hardware while reducing the accuracy loss often observed at high pruning ratios [21,13]. Structured pruning, on the other hand, removes entire network components, producing a regular architecture that can be executed quickly on standard hardware without the need for specialized sparse compute support. Structured pruning is a popular model compression technique for resource-constrained applications due to its efficient deployment and practical acceleration [13]. APQF adopts structured pruning. Specifically, it builds on DepGraph [14], a dependency-graph-based method that groups coupled channels and prunes them consistently across layers so that the pruned model remains structurally valid. 2.3 Quantization Quantization reduces the numerical precision of a model to lower its storage cost and enable efficient inference on integer hardware [9]. It represents model weights and activations using low-precision values. Quantization methods are generally categorized as post-training quantization (PTQ) or quantization-aware training (QAT) [35]. PTQ quantizes a pretrained model without retraining, making it computationally efficient. However, because the parameters are not adapted to the quantized representation, PTQ can suffer from substantial accuracy degradation, particularly at low bit-widths [36]. In contrast, QAT simulates quantization during training, allowing the model to adapt to low-precision weights and activations. QAT generally preserves accuracy better than PTQ under aggressive quantization, although it requires additional training [37]. Early low-precision methods include ternary and binary weight quantization, such as TWN and LR-Net [38,39]. RQ and WAGE extend low-precision optimization to weights and activations [40,41], while DQ learns mixed-precision configurations through differentiable optimization [42]. Other approaches, including DJPQ, Bayesian Bits, and GETA, combine pruning with mixed-precision quantization in unified compression procedures [43, 44, 16]. Because APQF targets high accuracy under aggressive compression, it combines structured pruning with mixed- precision QAT. After pruning, the framework assigns a bit-width to each surviving layer and simulates low-precision execution using Brevitas [45]. 2.4 Knowledge Distillation Knowledge distillation (KD) transfers knowledge from a large, complex teacher model to a smaller, lightweight student model while maintaining performance [46]. This is commonly achieved by training the student with a combined loss that blends hard-target supervision from the ground-truth labels with the softened output distribution of the teacher [47]. Learning from the teacher’s soft predictions, rather than from labels alone, transfers richer information about class relationships and allows the student to approach the teacher’s accuracy at a fraction of its size [48]. As a result, KD is widely used to deploy efficient models on resource-constrained devices without significant accuracy loss. APQF employs response-based knowledge distillation following Hinton et al. [10]. A frozen full-precision teacher guides the quantized student through a weighted combination of temperature-scaled KL divergence and hard-label cross-entropy. 4 A PREPRINT - AUGUST 7, 2026 2.5 Parameter-Efficient Fine-Tuning (PEFT) Foundation models now dominate a wide range of domains, such as language-specific and multimodal tasks. To achieve task-specific performance in real-world applications, these models are typically fine-tuned on unseen downstream datasets [49]. Parameter-Efficient Fine-Tuning (PEFT) is a cost-effective fine-tuning strategy that reduces the number of updated parameters and the computational complexity while still achieving suitable downstream task performance [50]. Compared to full fine-tuning, which updates all model parameters, PEFT modifies only a small number of parameters while keeping the majority of the pretrained model frozen. Existing PEFT methods can be broadly categorized into adapter-based, prompt-based, and selective methods [51]. Among these, low-rank adaptation methods have been widely adopted due to their simplicity, parameter efficiency, and strong performance [52]. Several low-rank variants have since been proposed, including LoRA [52], DoRA [53], PiSSA [54], rsLoRA [55], and LoRA+ [56], which differ in how they parameterize, initialize, scale, or optimize the low-rank adapters. APQF uses these methods for post-pruning accuracy recovery, and we describe each one in detail in the Methodology section. 2.6 Agentic Reasoning Frameworks Agentic reasoning is the component of an AI agent that handles decision making and allows the agent to perform tasks autonomously, using conditional logic or heuristics and relying on perception and memory to pursue goals and optimize for a successful outcome. In this setting, large language models (LLMs) are increasingly used not only as generative tools but as autonomous agents that carry out multi-step reasoning by interacting with tools or environments [57]. Prompting strategies such as Chain-of-Thought [58,59] show that LLMs can construct their own step-by-step reasoning process, while ReAct [60] and STaR [61] demonstrate that they can generate intermediate reasoning steps that improve both interpretability and accuracy. These abilities extend to tasks requiring sequential planning, tool use, and API invocation, allowing LLMs to interact with and control external systems [62,63,64,65]. Unlike conventional LLMs that produce a response in a single forward pass, agentic frameworks maintain a dynamic context throughout the reasoning process and adapt to new tasks through in-context learning without retraining [66]. Such frameworks are commonly categorized into single-agent, tool-augmented, and multi-agent approaches, and have shown strong performance on complex reasoning problems, establishing agentic reasoning as a practical approach for autonomous and organized decision making in modern foundation models. Building such agentic systems in practice requires a convenient way to access and switch between different LLMs. OpenRouter is a unified gateway service that addresses this challenge by routing requests to different models, allowing multiple LLMs to be integrated into a single application through one interface [67]. It provides access to a broad selection of models from multiple platforms [68] through a common API, exposing a broad selection of commercial and open-source models under one interface. In this work, we use OpenRouter to access the LLMs used by the different agents in APQF, which allows us to run the framework with a range of LLM planners through a single, consistent interface. 2.7 Agentic and Joint Compression Methods The most closely related work either guides compression with LLM-based agentic reasoning or jointly optimizes pruning and quantization. Our prior work, ProfilingAgent [69], introduced a profiling-guided multi-agent LLM system that automates structured pruning and post-training dynamic quantization by reasoning over static metrics such as MACs and parameter counts and dynamic signals such as latency and memory to design architecture-specific strategies. In a similar spirit, Kodathala and Vunnam [70] use a foundation model as an adaptive pruning agent that selects which layers to prune from weight–activation and gradient sensitivity profiles, using self-reflection and checkpoint rollback to preserve knowledge in large language models. A second line of work jointly optimizes pruning and quantization without an LLM. GETA [16] performs automatic joint structured pruning and quantization-aware training on arbitrary networks through a quantization-aware dependency graph and a partially projected gradient method that enforces layer-wise bit constraints. DJPQ [43] formulates joint pruning and mixed-precision quantization as a single differentiable objective, combining variational information- bottleneck structured pruning with learned bit-widths to reduce bit-operations (BOPs). Bayesian Bits [44] unifies quantization and pruning through a gradient-based decomposition that doubles the bit-width in residual steps, where an additional 0-bit option treats pruning as the extreme case of quantization. APQF builds on this prior work but differs by combining LLM-guided, profiling-grounded decisions with a fully training-aware pipeline, applying multi-stage structured pruning, adaptive PEFT-based recovery, and mixed-precision quantization-aware training with knowledge distillation across both convolutional and transformer architectures. 5 A PREPRINT - AUGUST 7, 2026 3 Methods And Procedures APQF is a profiling-guided model compression through structured pruning followed by quantization. The frame- work is organized around five main agents: the ProfilingAgent, PrunerAgent, FineTuningAgent, QuantAgent, and EvaluationAgent. Together, these agents form an end-to-end pipeline that profiles a target vision model, applies LLM-guided multi-stage structured pruning, performs adaptive fine-tuning for post-pruning accuracy recovery, applies mixed-precision quantization-aware training, performs post-quantization recovery using knowledge distillation, and finally evaluates the compressed model. We apply APQF to both convolutional and transformer-based image classifi- cation models, including ResNet [1], ViT [71], DeiT [72], and Swin [73], on the ImageNet [74] and CIFAR-10 [75] datasets. As shown in Figure 1, APQF starts with a pretrained vision model and first sends it to the ProfilingAgent. The ProfilingAgent analyzes the model structure, measures pruning sensitivity, and produces an architecture brief. This information is then used by the PrunerAgent to perform LLM-guided multi-stage structured pruning toward a target compression level. After each stage, the FineTuningAgent adaptively recovers the lost accuracy, and the pipeline returns to the PrunerAgent for the next stage until the target parameter reduction is met. Once the pruning target is reached, the QuantAgent applies LLM-planned mixed-precision quantization-aware training, followed by an optional post-QAT knowledge distillation recovery stage. Finally, the EvaluationAgent measures the accuracy and compression performance of the final model. Pretrained vision model ProfilingAgent Per-Group Pruning sensitivity + Architecture brief PrunerAgent LLM-guided multi-stage pruning FineTuningAgent Adaptive recovery (PEFT/full) QuantAgent LLM-planned mixed-precision QAT FineTuningAgent (KD) Optional post-QAT distillation EvaluationAgent ↻ next stage until target met LLM-guided agentData & evaluationLLM-guided recovery Figure 1: Overall workflow of the APQF framework This section describes each component of the APQF framework in detail. It explains the role of each agent, how information flows between agents, and how the overall pipeline combines profiling, pruning, recovery, quantization, and evaluation to study the accuracy-compression trade-off of vision models. 6 A PREPRINT - AUGUST 7, 2026 3.1 Profiling Agent The ProfilingAgent is the first analysis stage in APQF. The purpose of the ProfilingAgent is to build a detailed understanding of the target model before any compression is applied. Modern vision models contain a large number of layers and modules whose contributions to accuracy are highly uneven. Some are redundant and can be pruned with little effect, while others are sensitive and largely determine the model’s accuracy. A central design goal of APQF is to be architecture-agnostic, so that the framework can operate on model families ranging from convolutional networks (CNNs) to vision transformers (ViTs). For this reason, it analyzes the model at the level of modules, layers, blocks, and dependency groups rather than relying on a fixed architecture-specific pruning rule. As shown in Figure 2, the ProfilingAgent performs two complementary forms of profiling. The first is static cost profiling, which produces a map of the model’s resource usage. Usingptflops[33], the agent measures how multiply–accumulate operations (MACs) and parameters are distributed across the modules, blocks, and layers of the network, and usingtorch.profiler[29] it records the CPU and GPU execution time of the different parts of the model. Because this raw profiling output is verbose and would overwhelm the reasoning of the downstream agents, it is passed to an LLM that aggregates it into a compact architecture brief summarizing the model’s structure and its cost distribution. Static cost profiling ptflops + torch.profiler DepGraph sensitivity sweep prune at each PRUNING_RATIO → eval Sensitivity CSV Δaccuracy, params/MAC cut Architecture brief LLM aggregation PrunerAgent LLM-guided pruning decisions ↻ group × ratio Figure 2: ProfilingAgent workflow producing the sensitivity CSV and architecture brief The second and most important form of profiling is the DepGraph sensitivity sweep, which empirically measures how prunable each structural group is. Given a set of pruning ratios specified by the user, the agent uses dependency-graph (DepGraph) structured pruning [14] to prune each architecture-aware group at each ratio, evaluates the resulting model, and records the corresponding accuracy drop together with the achieved parameter and MAC reduction. Repeating this over all groups and ratios yields a per-group accuracy–cost sensitivity table, which is saved as a CSV file. Together, the sensitivity CSV and the architecture brief constitute the output of the ProfilingAgent. These two artifacts are consumed by the downstream pruning and quantization agents, which rely on them to make informed, model-specific compression decisions. 3.2 Pruning Agent The PrunerAgent is the first compression agent in APQF. Its role is to reduce the number of model parameters through LLM-guided structured pruning. Before pruning begins, the user specifies the target parameter-reduction percentage and the maximum number of pruning stages. Rather than pruning the model to the target in a single step, the PrunerAgent 7 A PREPRINT - AUGUST 7, 2026 approaches the target gradually through a sequence of LLM-guided pruning stages, interleaved with adaptive accuracy recovery. As shown in Figure 3, pruning is performed as a multi-stage, target-seeking process. The PrunerAgent is guided by the profiling data produced once by the ProfilingAgent including the per-group sensitivity table and the architecture brief, which it reuses across all stages. At the start of each stage, it issues a prompt asking the LLM to propose a pruning strategy, combining this profiling data with the user’s compression target and the current state of the process, the parameter reduction achieved so far, the remaining gap to the target, the groups selected and recovery decisions made in previous stages. APQF builds on DepGraph structured pruning [14], which groups coupled channels so they can be pruned consistently across layers. Unlike standard DepGraph, which applies a single user-set pruning ratio, APQF lets the LLM assign a per-group (per-layer) pruning ratio, making the structured pruning LLM-guided rather than uniform. The LLM proposes a pruning strategy by selecting candidate dependency groups that are expected to remove redundant parameters while causing minimal accuracy degradation. Before the strategy is applied, APQF validates the proposed groups against the measured profiling data to ensure that the selected groups, pruning ratios, and layer names are valid before pruning is executed. Config (user-set) target reduction %, number of stages LLM pruning proposal select groups to close the gap Cumulative prune + evaluate measure Top-1 drop δ Post-pruning recovery decide by δ & stage Skip recovery δ < τ₁ PEFT recovery intermediate, δ ≥ τ₁ LLM-chosen PEFT Two-stage recovery final stage, δ ≥ τ₂ PEFT → full fine-tune Target reached? reduction ≥ target or no stages left QuantAgent next stage gap remains target reached δ = Top-1 drop · τ₁ = fine-tune threshold (2%) · τ₂ = strong-drop threshold (4%) Figure 3: Multi-stage target-seeking pruning with adaptive fine-tuning The PrunerAgent operates in close interaction with the FineTuningAgent, as illustrated in Figure 3. After a stage is pruned, the model is evaluated and its Top-1 accuracy dropδis measured. The framework then adaptively decides how to recover the lost accuracy based on user-defined thresholds. When the accuracy drop is small (δ < τ 1 ), recovery is skipped, since fine-tuning would provide little benefit and may even degrade the model through overfitting. When the drop is moderate (δ ≥ τ 1 ) on an intermediate stage, the model is recovered using parameter-efficient fine-tuning (PEFT) before proceeding. On the final stage, when the accuracy drop is large (δ ≥ τ 2 ), the framework applies a stronger two-stage recovery consisting of a PEFT phase followed by full fine-tuning. The mechanics of these recovery procedures are described in Section 3.4. 8 A PREPRINT - AUGUST 7, 2026 A key design choice is how pruning is applied across stages. Instead of applying each new pruning stage directly on top of the previously pruned model, APQF accumulates the selected dependency groups across stages and replays the cumulative pruning strategy from the original model. This avoids a common issue in dependency-graph pruning, where pruning an already-pruned checkpoint may produce little additional parameter reduction and stall before the target is reached. In this design, the stages accumulate structural pruning decisions, while intermediate evaluation and recovery provide feedback for the next LLM-guided decision. The final post-pruning checkpoint is selected from the last cumulative pruning stage, optionally after adaptive fine-tuning when recovery is triggered and improves accuracy. Intermediate fine-tuning is included to make the pruning loop recovery-aware. Rather than judging each pruning stage only by the immediate post-pruning accuracy drop, APQF evaluates how much of the degradation can be recovered. This provides the next pruning stage with a more realistic estimate of the remaining model capacity and prevents the LLM planner from becoming overly conservative after temporary accuracy loss. Thus, multi-stage fine-tuning serves as an accuracy-feedback mechanism for target-seeking pruning, while the cumulative pruning strategy continues to control structural parameter reduction. This process repeats stage by stage including pruning, evaluating, and adaptively recovering until the measured cumulative parameter reduction reaches the user’s target (within a tolerance) or the maximum number of stages is exhausted. The complete procedure is summarized in Algorithm 1. Algorithm 1: Multi-stage target-seeking pruning with adaptive recovery Input: model M 0 ; profiling data (sensitivity table, architecture brief); target reduction ρ ⋆ ; stages N ; tolerance ε; thresholds τ 1 < τ 2 Output: final post-pruning checkpoint M ; selected groups G M ← M 0 ; G←∅ // selected groups for k = 1 to N do ρ← parameter reduction of M // relative to M 0 G k ← LLMPROPOSE(ρ ⋆ ,ρ,ρ ⋆ − ρ, history) // target, current, gap, history if G k invalid then G k ← REPAIR(G k ) // one repair retry if G k invalid then Return failure G← G∪ G k M ← PRUNE(M 0 ,G) // cumulative replay from original ρ← parameter reduction of M ; δ ← Top-1 drop of M reached ← (ρ≥ ρ ⋆ − ε); last ← reached or (k = N ) // last pruning stage? if δ < τ 1 then keep pruned M // recovery not needed else if last and δ ≥ τ 2 then M ft ← TWOSTAGE(M ) // PEFT, then full fine-tune else M ft ← PEFT(M ) // light recovery M ← better of pruned M and M ft // keep-better if reached then Return M Return M Here M 0 is the original model, M the current checkpoint, G the cumulative set of selected pruning groups and G k the groups added at stage k, δ the Top-1 accuracy drop, and M ft the fine-tuned candidate compared against the pruned model in the keep-better step. 3.3 Quantization Agent The QuantAgent applies LLM-guided mixed-precision quantization-aware training (QAT) to the pruned model produced by the PrunerAgent. To decide how aggressively each layer can be quantized, it draws on the same profiling evidence used earlier, including the ProfilingAgent architecture brief and the structured-pruning sensitivity table. This information comes with information specific to the pruned model, such as the PrunerAgent results from the preceding pruning stage and the actual list of quantizable modules (the surviving convolutional and linear layers) extracted from the pruned checkpoint. The agent also verifies that the checkpoint’s parameter count matches the pruning results, ensuring that the quantization strategy is generated for the correct pruned model. 9 A PREPRINT - AUGUST 7, 2026 As shown in Figure 4, the LLM proposes a mixed-precision strategy that assigns a bit-width to each quantizable layer, chosen from2, 4, 6, 8, 16, 32, where the lowest 2-bit setting is reserved for specific architectures (e.g., VGG). The proposal is conditioned on the profiling evidence and on a user-selected prompt type, including conservative, balanced, or aggressive, which controls how strongly the strategy favors lower bit-widths. Before training, APQF validates the proposed strategy against the real surviving modules, rejecting invalid layer names or bit-widths so that quantization is only applied to modules that actually exist in the pruned model. Pruned model + pruning results Profiling brief architecture summary Prompt type user-set aggressiveness LLM mixed-precision strategy per-layer bitwidths ∈ 2*,4,6,8,16,32 QAT training with KD student ← frozen teacher (always) LLM-set hyperparams Post-QAT KD (optional) FineTuningAgent · LLM hyperparams EvaluationAgent optional Skip post - QATKD Instrument + calibrate insert fake-quant, then calibrate Figure 4: QuantAgent workflow for LLM-guided mixed-precision quantization The validated strategy is then implemented by instrumenting the model with simulated quantization modules from Brevitas [45] at the assigned bit-widths and calibrating them on a small data sample. Because this is quantization-aware training, the quantized model is trained rather than quantized in a single shot. The quantized student is optimized via knowledge distillation (KD) [10] from a frozen full-precision teacher. Letz s andz t be the student and teacher logits, σ(·)the softmax,Tthe distillation temperature, andythe ground-truth label. Define the temperature-softened output distributions q s = σ(z s /T ) and q t = σ(z t /T ). The quantized student minimizes L KD = T 2 KL(q t ∥q s ), L CE = CE(z s ,y),(1) whereKL(·∥·)denotes the Kullback–Leibler divergence [76] between the softened teacher and student distributions, CE(·,·)is the cross-entropy against the ground-truth label, and the factorT 2 rescales the distillation gradient so that it remains comparable in magnitude to the cross-entropy term. The two losses are combined through a KD weight α∈ [0, 1]: L = αL KD + (1− α)L CE ,(2) 10 A PREPRINT - AUGUST 7, 2026 whereL KD is the soft-target distillation loss that encourages the student to reproduce the teacher’s full class distribution, andL CE is the standard hard-label classification loss. The LLM selects the QAT training hyperparameters, such as the learning rate, number of epochs, warmup steps, weight decay, batch size, and number of calibration samples, to maximize the accuracy recovery under the chosen bit-width assignment, while the distillation temperature and KD weight can be selected by the user. Finally, APQF supports an optional post-QAT KD stage. Whereas the KD inside QAT guides the model while it learns its low-bit representation and is an inherent part of quantization, the post-QAT KD is a separate recovery pass applied to the already-quantized model after QAT has finished. It uses the same distillation objective but serves only to recover additional accuracy when QAT has degraded the model; it is optional and is kept only if it improves accuracy. This stage is carried out by the FineTuningAgent and is described in Section 3.4. 3.4 FineTuning Agent The FineTuningAgent is a shared recovery component that is invoked by two other agents in APQF. It is called by the PrunerAgent to restore accuracy after structured pruning (Section 3.2), and by the QuantAgent to perform the optional post-quantization recovery (Section 3.3). In both roles, the recovery method and its hyperparameters are chosen by an LLM planner, which adapts the recovery to the specific model and to the amount of degradation observed, and every proposed plan is validated before it is executed. 3.4.1 Post-pruning recovery For post-pruning recovery, the FineTuningAgent supports full fine-tuning, several parameter-efficient fine-tuning (PEFT) methods, and a two-stage recovery mode. In full fine-tuning, all model parameters are updated using a small learning rate. This provides stronger recovery capacity but is more expensive and can overfit when the recovery set is limited. In PEFT recovery, only a small number of additional adapter parameters are trained while most of the pruned backbone remains frozen. This makes PEFT suitable for intermediate pruning stages, where the goal is to recover enough accuracy to guide the next pruning decision without fully retraining the model.APQF implements five PEFT variants: •LoRA (Low-Rank Adaptation) injects a trainable low-rank update∆W = BAinto each target layer while freezing the original weights, so that only the small matrices A and B (of rank r) are trained [52]. •DoRA (Weight-Decomposed Low-Rank Adaptation) decomposes each weight into a magnitude and a direction and applies a low-rank update to the directional component, improving stability and expressiveness over standard LoRA [53]. • rsLoRA (rank-stabilized LoRA) rescales the low-rank update so that training remains stable at higher adapter ranks, allowing larger ranks without degrading convergence [55]. •PiSSA starts the low-rank update from the most significant directions of the pretrained weight matrix instead of random values, which improves the starting point. It applies to linear layers only, so it is not used for convolutional (CNN) recovery [54]. • LoRA+ assigns different learning rates to the two low-rank matrices, accelerating convergence relative to standard LoRA [56]. The LLM planner selects which method to use for a given model, together with its hyperparameters, such as the adapter rank, the scaling factor, the learning rate, and the number of epochs. The proposed plan is validated before execution; for instance, PiSSA is rejected for convolution-only models. For the strongest recovery, which is used at the final pruning stage when the accuracy drop is large, the FineTuningAgent applies a two-stage procedure. In the first stage, a PEFT method (for example, rsLoRA) is trained as a warm-up, and its adapters are then merged back into the weights; in the second stage, all parameters are unfrozen and fine-tuned with a small learning rate. This combines the efficiency and stability of PEFT with the higher capacity of full fine-tuning. 3.4.2 Post-quantization knowledge distillation The FineTuningAgent also implements the optional post-QAT recovery invoked by the QuantAgent. In this role, the already-quantized model is treated as the student, and a full-precision model serves as the teacher. The teacher is configurable; it can be either the pruned model or the original uncompressed model, as selected by the user (a specific checkpoint may also be provided). The student is fine-tuned with a small learning rate under the same combined distillation objective used during QAT (Eq. 2), minimizing the soft-target KD loss together with the hard-label cross- entropy loss. Here, the LLM planner selects recovery hyperparameters, including the number of epochs, learning rate, 11 A PREPRINT - AUGUST 7, 2026 weight decay, warmup steps, distillation temperature, KD weight, and the number of calibration batches. Because this recovery pass may not always help, the resulting checkpoint is retained only if it improves accuracy over the quantized model. 3.5 Evaluation Agent The EvaluationAgent is a deterministic component used to measure the accuracy and efficiency of models produced at different stages of APQF. Unlike the ProfilingAgent, PrunerAgent, QuantAgent, and the fine-tuning planners, the EvaluationAgent does not use an LLM. Instead, it loads the selected checkpoint and evaluates it on a fixed validation manifest, which is a set of validation images drawn once with a fixed random seed and balanced across classes, so that the baseline, pruned, fine-tuned, and quantized models are all compared on the same examples. For each evaluated model, the EvaluationAgent reports Top-1 accuracy, Top-5 accuracy, parameter count, and the relative bit-operations (Rel. BOPs). Bit-operations weight each layer’s multiply–accumulate count by the precision at which that layer executes, so that the gains from pruning and from quantization are captured in a single number. For a network with layersl = 1,...,L, where layerlperformsM l multiply–accumulate operations and its weights and activations are represented with b (l) w and b (l) a bits, BOPs = L X l=1 M l b (l) w b (l) a .(3) Pruning reducesM l by removing channels, while quantization reducesb (l) w andb (l) a , so both forms of compression lower the same quantity. Since APQF applies pruning and quantization together, neither the parameter count nor the bit-width alone reflects the full compression, which makes Rel. BOPs a stronger measure of the compressed model’s cost than either metric on its own. The reported metric normalizes the compressed model against the original full-precision model, in which every layer runs at 32 bits, Rel. BOPs = P l ̃ M l b (l) w b (l) a 32 2 P l M l × 100%,(4) where ̃ M l denotes the multiply–accumulate count of layerlafter pruning andM l that of the original model. Layers left in full precision keepb (l) w = b (l) a = 32 . Because the metric is expressed relative to the model’s own full-precision cost, it is architecture-normalized and therefore comparable across models and across implementations, with lower values indicating a cheaper model. Accuracy and parameter count are used inside the pipeline, the first to decide whether pruning recovery is needed and the second to track progress toward the reduction target, while Rel. BOPs is computed at the end to compare the final compressed model against the original baseline. 4 Results The goal of this section is to assess APQF across different models and datasets. In each case, the objective of compression is to preserve accuracy while making the model cheaper to run by applying pruning and quantization. Because APQF combines structured pruning with quantization, it reduces both the compute and the numerical precision of the model. We summarize these gains primarily through the number of bit operations (BOPs), together with the reduction in model size. Beyond raw compression, we also show that APQF is architecture-agnostic, operating effectively on both convolutional networks (CNNs) and vision transformers (ViTs), and we use a set of ablation studies to demonstrate the importance of the framework’s individual novelties, including the role of the LLM in producing better compression decisions. In the following, we describe the experimental setup, including the models, datasets, hardware, and evaluation metrics; report the main compression and accuracy results alongside comparisons with other methods; and present ablation studies that isolate the contribution of each design choice to the LLM’s role in the pipeline. 4.1 Experimental Setup This section describes the datasets, model architectures, implementation settings, evaluation metrics, and comparison methods used to evaluate APQF. 4.1.1 Datasets and Preprocessing We evaluate APQF on the ImageNet-1k and CIFAR-10 image-classification datasets. ImageNet-1K, is made up of 1,281,167 training pictures and 50,000 validation images spread over 1,000 object classes. ImageNet’s immense 12 A PREPRINT - AUGUST 7, 2026 magnitude and variety have made it the recognized benchmark for training and assessing deep learning models in image classification, object identification, and transfer learning [74,77]. CIFAR-10 contains 60,000 color images of size 32 × 32 pixels organized into 10 item classes, with 50,000 for training and 10,000 for testing. Each class comprises 6,000 images from many categories. Because of its small size and balanced class distribution, the CIFAR-10 is widely used for developing and evaluating computer vision algorithms, particularly in research on model compression, pruning, quantization, knowledge distillation, and neural network architecture design [75]. In APQF, ImageNet and CIFAR-10 are organized in an ImageFolder-style structure. For evaluation, images are preprocessed using each model’s associated image processor, which applies the resizing, cropping, and normalization defined by the model’s own configuration; the same preprocessing is used for every checkpoint to keep comparisons fair. During fine-tuning and quantization-aware training, we apply standard data augmentation; images are resized to 1.15×the target resolution, randomly cropped with a scale between0.8and1.0, horizontally flipped, and color-jittered in brightness, contrast, and saturation, before being converted to tensors and normalized with the model’s mean and standard deviation. 4.2 Model Architectures and Implementation Details APQF is designed as a model-agnostic framework whose agents can operate across different vision architectures. To evaluate this capability, we conduct experiments on five representative model families, including the CNN-based ResNet and VGG architectures and the transformer-based ViT, DeiT, and Swin architectures. Where available, APQF loads pretrained or fine-tuned ImageNet-1K and CIFAR-10 checkpoints from the Hugging Face Hub. Hugging Face provides a unified interface for accessing and integrating pretrained computer vision models with PyTorch, enabling consistent model loading across the evaluated architectures [78, 79]. Locally stored checkpoints are used for models that are not obtained from the Hugging Face Hub. ResNet has been a breakthrough in deep learning for image classification tasks, and various ResNet variants have been built over the years to improve its performance even more [80]. For the purposes of this research, we have explored the ResNet-20 and ResNet-50 model variants; the main difference between them is the number of layers. ResNet-50 contains 50 layers and about 25.6M parameters. It is a widely used backbone. A smaller configuration, ResNet-20, has 20 layers. These models introduced residual learning to make deep neural networks easier to train [1]. VGG7 is a lightweight VGG variant that uses stacked3× 3convolutional layers to extract hierarchical image features. Its simple and uniform architecture makes it a useful baseline for evaluating model compression methods [81, 82]. Vision transformers (ViTs) have significantly advanced deep learning in computer vision. Compared to Convolutional Neural Networks (CNNs), Vision Transformer (ViTs) utilize self-attention to extract local and global characteristics from image input, which are then fed directly into a fully networked multilayer perceptron head via residual connections [6]. Google’s Vision Transformer is a transformer encoder-based architecture that converts an image into a series of fixed-size picture patches that are linearly embedded and processed utilizing self-attention techniques. In this study, we use a ViT model pretrained on ImageNet-21K and subsequently fine-tuned on ImageNet-1K [71]. Data-efficient Image Transformer (DeiT) is a ViT architecture designed for efficient training on ImageNet-1K without large-scale external pretraining. It introduces a distillation token that enables the transformer to learn from a CNN teacher while preserving its attention-based architecture, achieving competitive image classification performance with lower training requirements [72]. Swin Transformer is a hierarchical vision transformer that applies self-attention within local windows and uses shifted windows to exchange information across regions. This design supports multi-scale feature extraction with computational complexity that scales linearly with image size [73]. Implementation environment. The experiments were conducted on computing nodes equipped with either an NVIDIA H200 GPU with 141 GB of memory or an NVIDIA A100 GPU with 40 GB of memory. APQF was implemented in Python 3.11.6 using PyTorch 2.6.0 with CUDA 12.4. 4.3 Results on ImageNet We evaluate APQF on ImageNet using two metrics. The first is Top-1 accuracy on the validation set, which we report as the base accuracy of the original model, the final accuracy after compression, and their difference∆, so the accuracy cost of compression is directly visible. The second is the relative bit-operations (Rel. BOPs), the ratio of the compressed model’s bit-operations to those of the original FP32 model. Since BOPs weight each layer’s multiply–accumulate operations by its weight and activation bit-widths, Rel. BOPs captures both the pruning and the quantization gains in a single number, where lower is better. 13 A PREPRINT - AUGUST 7, 2026 The results here use a deliberately constrained setting. Each model is trained on only a 200K-image subset of ImageNet, using 200 images per class, and evaluated on the full 50,000-image validation set. The quantization agent uses its conservative prompt, and the optional post-quantization knowledge-distillation stage is disabled and left as a source of further improvement. Table 1: APQF compression results on ImageNet (conservative mixed-precision QAT on pruned models; 200K training / 50K validation samples). DatasetModelBase Top-1 (%)Final Top-1 (%)∆ Top-1Rel. BOPs (%) ImageNet DeiT-Tiny66.5267.90+1.385.63 ResNet-5080.1372.73 −7.407.74 Swin-Tiny80.6174.16 −6.456.17 ViT-Small79.8776.50 −3.375.93 Table 1 reports four architectures covering both CNN and transformer families. Across all of them APQF cuts the compute cost to about 5.6–7.7% of the original, roughly a 13–18×reduction in bit-operations, while keeping accuracy close to the baseline. DeiT-Tiny is only lightly pruned and even improves (+1.38), whereas the more heavily compressed ResNet-50 and Swin-Tiny show larger but still moderate drops. Given the small training budget, the conservative quantization, and the absence of post-QAT recovery, these results show that APQF reaches large compute reductions at a modest accuracy cost. As shown in Figure 5, under a constrained training budget of 200K images, GETA’s [16] single-run joint pruning– quantization optimization fails to recover accuracy, dropping to 51–59% Top-1, whereas APQF retains 68–77%. For a fair comparison, we run GETA ourselves using the same configuration provided in their released code. The gap reflects a fundamental difference in how the two methods reach their compressed models. Although both start from the same pretrained weights, GETA re-optimizes the entire network into a sparse and quantized subnet through its joint optimizer, which needs large-scale training data to converge. In contrast, APQF prunes the pretrained model directly from measured sensitivity and recovers accuracy through knowledge distillation and parameter-efficient fine-tuning, making it substantially more data-efficient 46810121416 Rel. BOPs (%) — lower is better −30 −25 −20 −15 −10 −5 0 5 Δ Top-1 (points) — higher is better DeiT-Tiny DeiT-Tiny ResNet-50 ResNet-50 Swin-Tiny Swin-Tiny ViT-Small ViT-Small APQF (ours) GETA Figure 5: Accuracy–compute trade-off on ImageNet under a 200K training budget. Each model has an APQF point (circle) and a GETA point (diamond) joined by a dashed line. APQF attains near-zero accuracy loss at low relative BOPs, whereas GETA degrades substantially, reflecting its higher data requirement Table 2 compares the two methods when both have access to the full ImageNet training set. GETA is trained on all of the data for its full training schedule, following its released configuration. APQF instead reuses the model produced by its limited-data pipeline and simply activates the optional post-quantization knowledge-distillation stage for only around five epochs on the full training set. Even with this short additional recovery, APQF matches GETA’s accuracy to within a few points while achieving roughly a3×lower relative BOPs, because APQF combines structured pruning with aggressive mixed-precision quantization whereas GETA relies primarily on structured pruning. 14 A PREPRINT - AUGUST 7, 2026 Table 2: APQF vs. GETA on ImageNet with full-data training, where APQF additionally uses the optional post- quantization KD stage (∼5 epochs). ModelMethodBase→ Final (%)∆ Top-1Rel. BOPs (%) ViT-Small GETA81.43→ 80.12 −1.3119.37 APQF79.87→ 78.26 −1.615.73 DeiT-Tiny GETA72.01→ 72.88+0.8716.95 APQF66.52→ 69.51+2.996.11 Swin-Tiny GETA80.92→ 80.09 −0.8321.84 APQF80.61→ 77.59 −3.027.23 We compare against GETA using the authors’ reproducible baseline configuration for each architecture. For the released GETA implementation, weight-only quantization is the stable and general path for ResNet and transformer backbones. We attempted to enable activation quantization in GETA, but doing so was not a simple flag change, and it exposed pruning-dependency and subnet-construction failures for ResNet and ViT-style models. Enabling joint weight and activation quantization in GETA would therefore require nontrivial modifications to the baseline implementation, which would no longer be the authors’ original method. In contrast, our method supports joint pruning with both weight and activation quantization across these architectures. Since activation quantization usually makes optimization harder and can reduce accuracy, achieving better accuracy and Rel. BOPs while quantizing activations is a stronger result than comparing only weight quantization. 4.4 Results on CIFAR-10 Table 3 compares APQF and GETA on CIFAR-10, where both methods start from identical fine-tuned checkpoints so the baselines are matched.The small differences in base accuracy arise because each method measures accuracy with its own evaluation pipeline, using different preprocessing and validation sampling. Since∆is computed relative to each method’s own measured baseline, these differences do not affect the fairness of the comparison, as each method’s accuracy change is assessed against its own starting point. Across the five architectures, APQF compresses more while retaining higher accuracy in most cases. It reaches lower relative BOPs on four of the five models and improves over its own baseline on three of them, whereas GETA loses several points of accuracy on ResNet-50, Swin-Tiny, and ViT-Small. GETA is ahead only on ResNet-20 in accuracy and on ViT-Small in relative BOPs. Table 3: APQF vs. GETA on CIFAR-10, using identical finetuned checkpoints (baseline-matched).∆is the accuracy change relative to each method’s own baseline; bold marks the better value. ModelMethodBase→ Final (%)∆ Top-1Rel. BOPs (%) DeiT-Tiny GETA91.75→ 91.05 −0.7011.90 APQF91.90→ 95.01+3.118.49 ResNet-50 GETA96.55→ 93.09 −3.467.68 APQF95.83→ 96.62+0.797.65 Swin-Tiny GETA97.20→ 91.46 −5.7415.12 APQF96.78→ 97.92+1.145.11 ViT-Small GETA98.51→ 92.16 −6.353.59 APQF98.46→ 98.27 −0.194.27 ResNet-20 GETA91.70→ 91.42 −0.284.50 APQF92.12→ 91.55 −0.572.90 4.4.1 VGG7 on CIFAR-10 Table 4 compares APQF with quantization-only and combined pruning–quantization methods on VGG7/CIFAR-10. The results for the comparison methods are taken from the corresponding publications. APQF is evaluated using our FP32 VGG7 reproduction, which achieves92.95%accuracy. Therefore, its∆Acc and relative BOPs are calculated with respect to this baseline, whereas the corresponding values for prior methods use their reported93.05%baseline. Among the methods combining pruning and quantization, APQF provides a favorable accuracy–efficiency trade-off. At the same reported relative BOP budget of0.41%, APQF achieves93.15%accuracy compared with92.57%for GETA, an improvement of0.58percentage points. At a lower budget of0.36%, APQF still exceeds GETA by0.11points while requiring fewer bit-operations. The highest-accuracy Bayesian Bits configuration achieves93.23%accuracy at0.51% relative BOPs. APQF achieves an accuracy within0.08percentage points of this result while using approximately 15 A PREPRINT - AUGUST 7, 2026 20%fewer bit-operations (0.41%versus0.51%). The lower-cost Bayesian Bits configuration reduces relative BOPs to 0.29%, but its accuracy decreases by1.27points relative to its higher-accuracy configuration. APQF is also the only method operating below0.5%relative BOPs that improves upon its own FP32 baseline, achieving∆Acc = +0.20. The conventional quantization-only baselines, including TWN, LR-Net, RQ, and WAGE, require approximately1.56%– 6.24% relative BOPs, corresponding to approximately 4–17 times the cost of the APQF configurations. DQ reaches a comparable BOP range of0.48%–0.54%, but with substantially lower accuracy. Overall, these results demonstrate the benefit of combining structured pruning with mixed-precision quantization. Table 4: VGG7 on CIFAR-10: comparison of quantization and joint pruning–quantization methods. A✓in “Prune” denotes structured pruning, while×indicates that pruning is not applied. “Quant.” lists the quantization scheme (W = weights, A = activations).∆Acc is the change from each method’s FP32 baseline; Rel. BOPs is relative to that baseline (lower is better). MethodPrune Quant.Acc. (%) ∆AccRel. BOPs (%) Baseline–93.05–100.00 TWN [38]×✓ (ternary W, 2/32)92.56 −0.496.24 LR-Net [39] ×✓ (1-bit W)93.18+0.133.11 RQ (8/8) [40]×✓ (W+A, 8/8)93.30+0.256.24 RQ (4/4) [40]×✓ (W+A, 4/4)92.04 −1.011.56 WAGE [41]×✓ (W+A, 2/8)93.22+0.171.56 DQ [42]×✓ (mixed W+A)91.59 −1.460.48 DQ-restrict [42] ×✓ (mixed W+A)91.59 −1.460.54 DJPQ [43] ✓ (mixed W+A)91.54 −1.510.48 DJPQ-restrict [43] ✓ (mixed W+A)91.43 −1.620.46 B (μ=0.01) [44]✓ (mixed W+A)93.23+0.180.51 B (μ=0.1) [44]✓ (mixed W+A)91.96 −1.090.29 GETA [16]✓ (mixed W+A)92.57 −0.480.41 APQF (ours) † ✓ (mixed W+A)92.68 −0.270.36 APQF (ours) † ✓ (mixed W+A)93.15+0.200.41 † APQF is compressed from our VGG7 reproduction (92.95% FP32); ∆Acc and Rel. BOPs are relative to that baseline. 4.4.2 Ablation Study We conduct an ablation study on CIFAR-10 to isolate the contribution of the main components of APQF, shown in Figure 6. The full method is compared against two reduced variants at roughly matched relative BOPs, so accuracy is compared at equal compute. The first variant, Uniform, removes the LLM’s adaptive per-layer decisions and instead applies standard dependency-graph (DepGraph) pruning [14] followed by Brevitas quantization [45]. It uses a single pruning ratio for every layer and one fixed bit-width across the whole model, set so that its relative BOPs matches the full method. The second variant, w/o profiling, still uses the LLM to produce the pruning and quantization strategy, but the LLM no longer receives the measured profiling data. It therefore makes its decisions from its own prior knowledge of the architecture rather than from measured sensitivity. Across all four models, Uniform causes the largest accuracy drop, confirming that the LLM’s per-layer pruning ratios and mixed precision are the main drivers of accuracy at a given compute budget, while removing the profiling data causes a smaller but consistent drop, showing that grounding the LLM in measured sensitivity further improves its decisions. Together, these results show that the different parts of APQF each contribute to its performance. 4.4.3 Robustness to the LLM Planner To test how much APQF depends on the specific model used as its LLM planner, we run the full pipeline on Swin-Tiny with six different LLMs while keeping everything else fixed. Figure 7 plots the resulting accuracy against relative BOPs, with each point colored by an overall accuracy-efficiency ranking and labeled with its OpenRouter price. Accuracy stays within a narrow band of 97.4 to 97.9 percent across all six models, while the relative BOPs and the cost per token vary substantially. This shows that APQF is robust to the choice of LLM and does not rely on a single premium model. It performs well even with inexpensive or free planners such as DeepSeek and Gemma, which reach accuracy comparable to the much more expensive Claude Opus 4.8 and GPT-5.5. Claude Opus 4.8, used by default in our main experiments, attains the highest accuracy, while Qwen3.7 Max and DeepSeek V4 Pro reach comparable accuracy at a fraction of the cost. 16 A PREPRINT - AUGUST 7, 2026 DeiT-Tiny ResNet-50 Swin-Tiny ViT-Small 80 85 90 95 100 Top-1 accuracy (%) bars = Top-1 accuracy (left axis) ● = Rel. BOPs (right axis) APQF (full)UniformAPQF w/o profiling 0 2 4 6 8 10 12 14 16 Rel. BOPs (%) Figure 6: CIFAR-10 ablation. Bars are Top-1 accuracy (left axis); dots are Rel. BOPs (right axis). APQF (full) uses per-layer pruning ratios and mixed precision, Uniform uses one ratio and one bit-width for all layers, and APQF w/o profiling removes the profiling agent. At matched compute, Uniform loses the most accuracy while removing profiling costs less. (Left axis from 78%.) 3.54.04.55.05.56.06.5 Rel. BOPs (%) — lower is better 97.2 97.4 97.6 97.8 98.0 98.2 Top-1 accuracy (%) — higher is better color: overall accuracy–efficiency (green best → red worst) price: input / output per 1M tokens (OpenRouter, USD) Figure 7: Effect of the LLM planner (Swin-Tiny, CIFAR-10). Each point is one LLM, colored by accuracy–efficiency ranking (green best, red worst) and labeled with its OpenRouter price per 1M tokens. Accuracy stays stable across a wide cost range 17 A PREPRINT - AUGUST 7, 2026 5 Summary and Discussion Vision models are now used across a wide range of domains, but their size makes them expensive to adapt and deploy, and their inference latency and memory footprint often exceed what resource-constrained hardware can provide. Compressing them is therefore necessary, yet deciding how to compress a particular model is still largely a manual process built on expert judgment and repeated trial and error, and settings that work well for one architecture seldom transfer to another. We introduced APQF, an agentic, profiling-guided framework that combines structured pruning, mixed-precision quantization, and accuracy recovery in a single automated pipeline. Rather than applying fixed heuristics or one uniform rule to every layer, APQF harnesses the reasoning ability of large language models to plan compression from measured profiling evidence, so that the per-layer pruning ratios, the per-layer bit-widths, and the recovery strategy are decided automatically instead of being hand-tuned. To our knowledge, this is the first framework to combine LLM-guided, profiling-grounded decisions with a fully training-aware pipeline that performs sequential structured pruning together with mixed-precision quantization-aware training and recovery. Five cooperating agents carry this out. The ProfilingAgent produces an architecture brief and a pruning sensitivity map that ground every later decision in measurement. The PrunerAgent performs multi-stage structured pruning toward the user’s parameter-reduction target, calling the FineTuningAgent to recover accuracy between stages, and the QuantAgent then assigns per-layer bit-widths and trains the quantized model with knowledge distillation from a full-precision teacher. The EvaluationAgent measures every checkpoint on the same fixed validation set, and every strategy an LLM proposes is validated against the actual model before it is executed. We demonstrated that basing the compression decisions on measured profiling evidence yields a better accuracy- efficiency trade-off than uniform compression, and that the same pipeline applies to different architectures without modification, since only the profiling data changes from one model to the next. Compared against established non- agentic compression frameworks on models ranging from convolutional networks to vision transformers, APQF matched or exceeded their accuracy in most settings while producing models with lower computational cost. Because APQF compresses a pretrained model by recovering it rather than re-optimizing the whole network, it retains considerably more accuracy than joint optimization methods when the training budget is limited. The planning itself is performed through a standard API, so the framework is not tied to any single language model. Our experiments show that it works with freely available open-weight planners as well as with the most expensive commercial ones, and the choice is left to the user, so APQF can also benefit directly from stronger planners as they become available. The same approach could be extended to further compression techniques and to tasks beyond image classification. 6 Limitations and Future Work APQF currently targets image classification models, and although it covers both convolutional networks and vision transformers, the idea itself is not specific to classification. We intend to apply the same approach to other foundation models, such as the Segment Anything Model for segmentation, and to models outside vision. We also believe it can be extended to compress large language models and vision-language models, since nothing in the profiling and planning mechanism depends on the task, and we see clear potential for it to expand to further model families and datasets. Using language models as planners carries a limitation inherent to them, since the same request can yield a different plan on a different run. We limit this with carefully designed prompts and by controlling the sampling temperature, but the planner can still occasionally fail to produce a usable strategy. Such failures were rare with strong models and more frequent with cheap or free ones, and also in the ablation where the profiling evidence was withheld, which suggests the planner relies on that evidence to stay within a valid design space. Better prompting and stronger planners would reduce this further. Strong commercial models are expensive, but as our experiments show, APQF is not tied to any single one and can take advantage of cheaper models as well as of stronger ones that appear in the future. Compression is most valuable on large models, but pruning, fine-tuning, and quantization-aware training on those models are themselves computationally expensive. This is especially true in vision, where the experiments run on large datasets such as ImageNet, and where a single configuration involves repeated rounds of pruning, recovery, and quantization-aware training. Carrying out this research therefore required multiple GPUs, and the available compute limited how many configurations and repeated runs we could explore. Some human involvement also remains. The user still selects which language model to use for which agent, a few of its sampling settings, and some distillation hyperparameters, and to keep the comparison with other methods fair the user also specifies how much to prune and how aggressively to quantize. These choices are made through the configuration 18 A PREPRINT - AUGUST 7, 2026 file, and in practice they also help the planner produce valid pruning, quantization, and recovery strategies, since leaving them entirely open raises the failure rate. Acknowledgment This work used GPU resources on the NCSA Delta GPU system, provided through ACCESS allocations AGR250012, CIS250538, and CIS240379, which made it possible to carry out the experiments presented here. We thank Dr. Christopher Quinn for his guidance and support, and Aishwarya Sarkar, PhD candidate, for her help during the early stages of this work. References [1]Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. [2]Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 conference of the North American chapter of the association for computational linguistics: human language technologies, volume 1 (long and short papers), pages 4171–4186, 2019. [3]Vikram Rangarajan, Fereshteh Shahoveisi, Benjamin D Waldo, and Sadegh Jafari. Identification of plant-parasitic nematode genera in turfgrass using deep learning algorithms. Scientific Reports, 2025. [4] Andreas Kamilaris and Francesc X Prenafeta-Boldú. Deep learning in agriculture: A survey. Computers and electronics in agriculture, 147:70–90, 2018. [5] Geert Litjens, Thijs Kooi, Babak Ehteshami Bejnordi, Arnaud Arindra Adiyoso Setio, Francesco Ciompi, Mohsen Ghafoorian, Jeroen Awm Van Der Laak, Bram Van Ginneken, and Clara I Sánchez. A survey on deep learning in medical image analysis. Medical image analysis, 42:60–88, 2017. [6] Mohamad Abou Ali, Fadi Dornaika, and Ignacio Arganda-Carreras. White blood cell classification: Convolutional neural network (cnn) and vision transformer (vit) under medical microscope. Algorithms, 16(11):525, 2023. [7] Zhuo Li, Hengyi Li, and Lin Meng. Model compression for deep neural networks: A survey. Computers, 12(3):60, 2023. [8]Md Maruf Hossain Shuvo, Syed Kamrul Islam, Jianlin Cheng, and Bashir I. Morshed. Efficient acceleration of deep learning inference on resource-constrained edge devices: A review. Proceedings of the IEEE, 111(1):42–91, 2022. [9] Aojun Zhou, Anbang Yao, Yiwen Guo, Lin Xu, and Yurong Chen. Incremental network quantization: Towards lossless cnns with low-precision weights. arXiv preprint arXiv:1702.03044, 2017. [10]Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NIPS Deep Learning and Representation Learning Workshop, 2015. [11]Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. Advances in neural information processing systems, 28, 2015. [12] Determine Filters’Importance. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 3, 2016. [13]Hongrong Cheng, Miao Zhang, and Javen Qinfeng Shi. A survey on deep neural network pruning: Taxonomy, comparison, analysis, and recommendations. IEEE Transactions on Pattern Analysis and Machine Intelligence, 46(12):10558–10578, 2024. [14]Gongfan Fang, Xinyin Ma, Mingli Song, Michael Bi Mi, and Xinchao Wang. Depgraph: Towards any structural pruning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 16091– 16101, 2023. [15] Zhen Dong, Zhewei Yao, Amir Gholami, Michael W. Mahoney, and Kurt Keutzer. HAWQ: Hessian AWare quantization of neural networks with mixed-precision. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 293–302, 2019. [16]Xiaoyi Qu, David Aponte, Colby Banbury, Daniel P Robinson, Tianyu Ding, Kazuhito Koishida, Ilya Zharkov, and Tianyi Chen. Automatic joint structured pruning and quantization for efficient neural network training and compression. In Proceedings of the Computer Vision and Pattern Recognition Conference, pages 15234–15244, 2025. 19 A PREPRINT - AUGUST 7, 2026 [17]Joe Lorentz, Assaad Moawad, Thomas Hartmann, and Djamila Aouada. Profiling the real world potential of neural network compression. In 2022 IEEE International Conference on Omni-layer Intelligent Systems (COINS), pages 1–6. IEEE, 2022. [18] Hanpeng Hu, Chenyu Jiang, Yuchen Zhong, Yanghua Peng, Chuan Wu, Yibo Zhu, Haibin Lin, and Chuanxiong Guo. dpro: A generic performance diagnosis and optimization toolkit for expediting distributed dnn training. Proceedings of Machine Learning and Systems, 4:623–637, 2022. [19]Kehan Zhu, Fuyi Hu, Yuanbing Ding, Wei Zhou, and Ruxin Wang. A comprehensive review of network pruning based on pruning granularity and pruning time perspectives. Neurocomputing, 626:129382, 2025. [20]Dat Ngo, Hyun-Cheol Park, and Bongsoon Kang. Edge intelligence: A review of deep neural network inference in resource-limited environments. Electronics, 14(12):2495, 2025. [21]Elias Frantar and Dan Alistarh. Sparsegpt: Massive language models can be accurately pruned in one-shot. In International conference on machine learning, pages 10323–10337. PMLR, 2023. [22]Kazi Rafat, Sadia Islam, Abdullah Al Mahfug, Md Ismail Hossain, Fuad Rahman, Sifat Momen, Shafin Rahman, and Nabeel Mohammed. Mitigating carbon footprint for knowledge distillation based deep learning model compression. Plos one, 18(5):e0285668, 2023. [23] Leila Malihi and Gunther Heidemann. Efficient and controllable model compression through sequential knowledge distillation and pruning. Big Data and Cognitive Computing, 7(3):154, 2023. [24] Mauricio Fadel Argerich and Marta Patiño-Martínez. Measuring and improving the energy efficiency of large language models inference. IEEE Access, 12:80194–80207, 2024. [25]Lingling Xu, Haoran Xie, S Joe Qin, Xiaohui Tao, and Fu Lee Wang. Parameter-efficient fine-tuning methods for pretrained language models: A critical review and assessment. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2026. [26] Robert Hundt, Naveen Kumar, Jose Baiocchi Paredes, Scott Goodson, Clive Verghese, Prasanna Rengasamy, Kelvin Le, Jiya Zhang, Charles Alaras, Yin Zhang, et al. Xprof: An open, scalable, and extensible profiling system for the modern ml stack. In Ninth Conference on Machine Learning and Systems, 2026. [27]Cheng Li, Abdul Dakkak, Jinjun Xiong, Wei Wei, Lingjie Xu, and Wen-mei Hwu. Xsp: Across-stack profiling and analysis of machine learning models on gpus. In 2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS), page 326–327. IEEE, May 2020. [28]Raphael Hunger. Floating point operations in matrix-vector calculus. Technical report, Associate Institute for Signal Processing, 2005. [29]PyTorch Team. Pytorch profiler.https://pytorch.org/docs/stable/profiler.html, 2024. Accessed: 2025-05-09. [30] TensorFlow Team. Tensorflow profiler guide.https://w.tensorflow.org/tensorboard/tensorboard_ profiling_keras, 2024. Accessed: 2025-05-03. [31]NVIDIA Corporation.CUDA Profiler User’s Guide.https://docs.nvidia.com/cuda/ profiler-users-guide/index.html, 2024. Accessed: 2025-05-03. [32]NVIDIA Corporation. Cuda profiling tools interface (cupti) documentation.https://docs.nvidia.com/ cupti/index.html, 2024. Accessed: 2025-05-03. [33] Vladislav Sovrasov. ptflops: a flops counting tool for neural networks in pytorch framework, 2018-2024. [34]Yang He and Lingao Xiao. Structured pruning for deep convolutional neural networks: A survey. IEEE transactions on pattern analysis and machine intelligence, 46(5):2900–2919, 2023. [35]Xiaotian Zhao, Ruge Xu, and Xinfei Guo. Post-training quantization or quantization-aware training? that is the question. In 2023 China Semiconductor Technology International Conference (CSTIC), pages 1–3. IEEE, 2023. [36] Jiawei Liu, Lin Niu, Zhihang Yuan, Dawei Yang, Xinggang Wang, and Wenyu Liu. Pd-quant: Post-training quantization based on prediction difference metric. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 24427–24437, 2023. [37]Mengzhao Chen, Wenqi Shao, Peng Xu, Jiahao Wang, Peng Gao, Kaipeng Zhang, and Ping Luo. Efficientqat: Efficient quantization-aware training for large language models. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 10081–10100, 2025. [38]Fengfu Li, Bin Liu, Xiaoxing Wang, Bo Zhang, and Junchi Yan. Ternary weight networks. arXiv preprint arXiv:1605.04711, 2016. 20 A PREPRINT - AUGUST 7, 2026 [39]Oran Shayer, Dan Levi, and Ethan Fetaya. Learning discrete weights using the local reparameterization trick. arXiv preprint arXiv:1710.07739, 2017. [40] Christos Louizos, Matthias Reisser, Tijmen Blankevoort, Efstratios Gavves, and Max Welling. Relaxed quantiza- tion for discretized neural networks. arXiv preprint arXiv:1810.01875, 2018. [41]Shuang Wu, Guoqi Li, Feng Chen, and Luping Shi. Training and inference with integers in deep neural networks. arXiv preprint arXiv:1802.04680, 2018. [42]Stefan Uhlich, Lukas Mauch, Fabien Cardinaux, Kazuki Yoshiyama, Javier Alonso Garcia, Stephen Tiedemann, Thomas Kemp, and Akira Nakamura. Mixed precision dnns: All you need is a good parametrization. arXiv preprint arXiv:1905.11452, 2019. [43]Ying Wang, Yadong Lu, and Tijmen Blankevoort. Differentiable joint pruning and quantization for hardware efficiency. In European Conference on Computer Vision, pages 259–277. Springer, 2020. [44] Mart Van Baalen, Christos Louizos, Markus Nagel, Rana Ali Amjad, Ying Wang, Tijmen Blankevoort, and Max Welling. Bayesian bits: Unifying quantization and pruning. Advances in neural information processing systems, 33:5741–5752, 2020. [45] Giuseppe Franco, Pablo Monteagudo-Lago, Ian Colbert, Alessandro Pappalardo, and Nicholas J Fraser. Xil- inx/brevitas, 2026. [46]Qing Xu. Deep model compression via knowledge distillation for time-series data analytics: from in-domain to cross-domain scenarios. PhD thesis, Nanyang Technological University, 2026. [47]Junjie Yang, Junhao Song, Xudong Han, Ziqian Bi, Tianyang Wang, Chia Xin Liang, Xinyuan Song, Yichao Zhang, Qian Niu, Benji Peng, et al. Feature alignment and representation transfer in knowledge distillation for large language models. arXiv preprint arXiv:2504.13825, 2025. [48] Amir Moslemi, Anna Briskina, Zubeka Dang, and Jason Li. A survey on knowledge distillation: Recent advancements. Machine Learning with Applications, 18:100605, 2024. [49]Dan Zhang, Tao Feng, Lilong Xue, Yuandong Wang, Yuxiao Dong, and Jie Tang. Parameter-efficient fine-tuning for foundation models. arXiv preprint arXiv:2501.13787, 2025. [50]Luping Wang, Sheng Chen, Linnan Jiang, Shu Pan, Runze Cai, Sen Yang, and Fei Yang. Parameter-efficient fine-tuning in large language models: a survey of methodologies. Artificial Intelligence Review, 58(8):227, 2025. [51]Zhengqing Yuan, Weixiang Sun, Yixin Liu, Huichi Zhou, Rong Zhou, Yiyang Li, Zheyuan Zhang, Wei Song, Yue Huang, Haolong Jia, et al. Efficientllm: Efficiency in large language models. arXiv preprint arXiv:2505.13840, 2025. [52]Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Liang Wang, Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. Iclr, 1(2):3, 2022. [53] Shih-Yang Liu, Chien-Yi Wang, Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang-Ting Cheng, and Min-Hung Chen. Dora: Weight-decomposed low-rank adaptation. In Forty-first International Conference on Machine Learning, 2024. [54]Fanxu Meng, Zhaohui Wang, and Muhan Zhang. Pissa: Principal singular values and singular vectors adaptation of large language models. Advances in Neural Information Processing Systems, 37:121038–121072, 2024. [55]Damjan Kalajdzievski.A rank stabilization scaling factor for fine-tuning with lora.arXiv preprint arXiv:2312.03732, 2023. [56]Soufiane Hayou, Nikhil Ghosh, and Bin Yu. Lora+: Efficient low rank adaptation of large models. arXiv preprint arXiv:2402.12354, 2024. [57]Junde Wu, Jiayuan Zhu, and Yuyuan Liu. Agentic reasoning: Reasoning llms with tools for the deep research. arXiv preprint arXiv:2502.04644, 9, 2025. [58] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824–24837, 2022. [59]Aman Madaan and Amir Yazdanbakhsh. Text and patterns: For effective chain of thought, it takes two to tango. arXiv preprint arXiv:2209.07686, 2022. [60]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023. 21 A PREPRINT - AUGUST 7, 2026 [61]Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah Goodman. Star: Bootstrapping reasoning with reasoning. Advances in Neural Information Processing Systems, 35:15476–15488, 2022. [62] Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Chuyuan Fu, Keerthana Gopalakrishnan, Karol Hausman, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022. [63] Bill Yuchen Lin, Yicheng Fu, Karina Yang, Faeze Brahman, Shiyu Huang, Chandra Bhagavatula, Prithviraj Ammanabrolu, Yejin Choi, and Xiang Ren. Swiftsage: A generative agent with fast and slow thinking for complex interactive tasks. Advances in Neural Information Processing Systems, 36:23813–23825, 2023. [64] Joon Sung Park, Joseph O’Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S Bernstein. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology, pages 1–22, 2023. [65] Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. Advances in Neural Information Processing Systems, 36:68539–68551, 2023. [66]Bingxi Zhao, Lin Geng Foo, Ping Hu, Christian Theobalt, Hossein Rahmani, and Jun Liu. Llm-based agentic reasoning frameworks: A survey from methods to scenarios. arXiv preprint arXiv:2508.17692, 2025. [67]Konstantinos I Roumeliotis and Nikolaos D Tselikas. Chatgpt and open-ai models: A preliminary review. Future Internet, 15(6):192, 2023. [68] Paulina Morillo, Kevin Bastidas, Bryan Guevara, Alex Terreros, and Julio Proaño. Scalable microservices for llm-vs-llm interaction in board games. In MODELSWARD, pages 300–306, 2026. [69]Sadegh Jafari, Aishwarya Sarkar, Mohiuddin Bilwal, and Ali Jannesari. Profilingagent: Profiling-guided agentic reasoning for adaptive model optimization. arXiv preprint arXiv:2509.05584, 2025. [70]Sai Varun Kodathala and Rakesh Vunnam. Llms can compress llms: Adaptive pruning by agents. arXiv preprint arXiv:2601.09694, 2026. [71]Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020. [72]Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. In International conference on machine learning, pages 10347–10357. PMLR, 2021. [73]Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. In Proceedings of the IEEE/CVF international conference on computer vision, pages 10012–10022, 2021. [74] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pages 248–255. Ieee, 2009. [75] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. [76] Solomon Kullback and Richard A Leibler. On information and sufficiency. The annals of mathematical statistics, 22(1):79–86, 1951. [77] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015. [78]Hatem Feki, Manel Abdellatif, and Mohammed Sayagh. An empirical study on hugging face trends, topics and challenges on stack overflow. In 2025 IEEE 49th Annual Computers, Software, and Applications Conference (COMPSAC), pages 1297–1307. IEEE, 2025. [79]Charaf Eddine Mechalkh and Marya Douniazad Fennouh. Exploring the Use of Large Language Models for Lossless Text Compression. PhD thesis, UNIVERSITY OF KASDI MERBAH OUARGLA. [80]Thode Sai Prajwal and Ilavarasi AK. A comparative study of resnet-pretrained models for computer vision. In Proceedings of the 2023 Fifteenth International Conference on Contemporary Computing, pages 419–425, 2023. [81]Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. [82]Ibrahim Yousef Alshareef, Ab Al-Hadi Ab Rahman, Nuzhat Khan, and Hasan Alqaraghuli. End-to-end discrete cosine transform integration in spectral convolutional neural networks for resource-efficient deep learning. Applied Soft Computing, page 114599, 2026. 22