Paper deep dive
OrchNAS: Orchestrated Neural Architecture Search Service for Personalised Federated Edge Intelligence
Keya Patel, Sajib Mistry, Sheik Mohammad Mostakim Fattah, Aneesh Krishna
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:We propose OrchNAS, an energy-aware, personalised, federated edge intelligence framework that leverages a Neural Architecture Search Service to automatically design service-adaptive models for heterogeneous edge environments. The framework orchestrates the architecture search process on a server-side NAS service, enabling edge services to derive personalised architectures under device-level energy, computation, and memory constraints. We introduce an energy-aware global architecture search mechanism that learns a compact global representation across heterogeneous services. We develop an energy-efficient architecture selection mechanism that enables each service to derive a personalised subnet that satisfies its resource constraints via a progressive, greedy, energy-aware pruning strategy. We propose an energy-efficient personalised model optimisation scheme that updates service-adaptive parameters while preserving global representations, where a primal-dual optimisation mechanism enforces strict energy budgets during architecture adaptation. Experiments on real-world and benchmark datasets demonstrate the effectiveness of the proposed approach.
Tags
Links
- Source: https://arxiv.org/abs/2607.22805v1
- Canonical: https://arxiv.org/abs/2607.22805v1
Trouble viewing inline? Open PDF directly →
Full Text
61,652 characters extracted from source content.
Expand or collapse full text
OrchNAS: Orchestrated Neural Architecture Search Service for Personalised Federated Edge Intelligence Keya Patel, Sajib Mistry, Sheik Mohammad Mostakim Fattah, Aneesh Krishna Abstract We propose OrchNAS, an energy-aware, personalised, federated edge intelligence framework that leverages a Neural Architecture Search Service to automatically design service-adaptive models for heterogeneous edge environments. The framework orchestrates the architecture search process on a server-side NAS service, enabling edge services to derive personalised architectures under device-level energy, computation, and memory constraints. We introduce an energy-aware global architecture search mechanism that learns a compact global representation across heterogeneous services. We develop an energy-efficient architecture selection mechanism that enables each service to derive a personalised subnet that satisfies its resource constraints via a progressive, greedy, energy-aware pruning strategy. We propose an energy-efficient personalised model optimisation scheme that updates service-adaptive parameters while preserving global representations, where a primal–dual optimisation mechanism enforces strict energy budgets during architecture adaptation. Experiments on real-world and benchmark datasets demonstrate the effectiveness of the proposed approach. I Introduction The rapid growth of Edge Computing has enabled intelligent services to operate on heterogeneous edge devices, such as smartphones, Internet of Things (IoT) sensors, and autonomous vehicles [4]. These devices are used to train machine learning (ML) models for applications such as remote surveillance, health monitoring, and intelligent transportation [2]. Deploying ML models on edge devices for intelligent services is known as Edge Intelligence. These systems rely on AI-as-a-Service (AIaaS) platforms to manage models across devices, enabling lower latency, stronger privacy, and reduced communication overhead [4]. Federated Learning as a Service (FLaaS) is a cloud-based service paradigm that enables heterogeneous edge services, deployed on distributed edge devices, to collaboratively train machine learning models while keeping data local. Each service performs local training using its private data and shares only model updates with a central coordination server [26]. This approach supports privacy preservation and scalable edge intelligence across IoT environments. However, statistical heterogeneity across participating services remains a key challenge. Due to non-IID data distributions, services exhibit highly diverse data characteristics, which can hinder global model convergence and degrade performance. Personalised Federated Learning (PFL) adapts models to each service’s local data, improving performance in heterogeneous environments [21]. It allows each service to tailor the shared model to its local data, addressing statistical heterogeneity and improving effectiveness in FLaaS. For instance, in a health monitoring system, wearable edge services personalise the federated model to reflect individual physiological patterns. A key challenge in PFL is high energy consumption [7]. While personalisation improves model performance, it increases computational complexity due to additional local training and model adaptation [7]. Several PFL approaches address energy consumption through encoder-decoder-based personalisation and cluster-specific model design [7, 8]. These methods improve performance and reduce energy but rely on manually predefined architectures. A manual approach refers to designing model architectures and tuning hyperparameters based on human expertise. This process often involves iterative trial-and-error [28]. Such approaches present several limitations, including reliance on expert knowledge, time-consuming tuning, and limited generalisation across datasets and tasks [28]. Therefore, this paper investigates automated personalisation techniques to enable efficient, scalable and adaptable federated edge intelligence. Neural Architecture Search (NAS) Service is a cloud-based framework that automates neural architecture optimisation by orchestrating parallel training containers [10]. It systematically proposes candidate architectures, evaluates them via parallel training, and iteratively refines the search using performance feedback, with the resulting performance metrics serving as reward signals to guide subsequent search iterations [10]. This enables scalable architecture optimisation without manual design or search infrastructure. In Edge Intelligence, NAS Service facilitates cloud-based architecture design, evaluates models for device constraints, and delivers adaptive models to distributed services. NAS has demonstrated strong potential in automating the design of deep learning models [1, 9]. Existing studies integrate NAS into PFL to design client-specific models, improving performance and efficiency through resource-aware, structured search [1, 2]. In Edge Intelligence, services operate on devices with varying hardware capabilities, memory capacity, and energy constraints [2]. Consequently, accuracy-driven personalisation can increase energy usage, leading to rapid battery depletion and limited scalability [3]. For example, a complex service model that performs well on powerful devices may quickly drain the battery on resource-constrained devices, while a lightweight service model may limit performance on high-capacity devices. Since the architecture of a service model affects computational cost and energy consumption, using the same architecture across all services is inefficient. Therefore, personalisation should adapt both model parameters and architecture to match the device constraints. NAS-driven Federated training enables collaborative architecture search across distributed clients [1, 2, 3]. To the best of our knowledge, such approaches primarily focus on accuracy and search efficiency, with little attention given to energy consumption during personalised architecture adaptation. We identify three key challenges that make achieving energy efficiency more difficult in personalised federated NAS. • Energy Consumption of NAS: NAS is energy-intensive as it requires exploring and evaluating many architectures during the search process [9]. Each candidate model needs to be partially trained and validated to estimate its performance [9]. This repeated training increases computational and memory usage, thereby increasing energy consumption. In Edge Intelligence, NAS consumes more energy due to the distributed architecture search across multiple clients. • Global-Personalised Representation Learning: In personalised service, models learn global knowledge, while adapting to local data and resources [2]. Nevertheless, NAS introduces challenges in designing architectures that support both global and personalised components. If the global backbone is too large, it increases the computational load; if too small, it may fail to capture useful global features. Therefore, designing NAS architectures that balance accuracy and energy across service devices is a key challenge. • Service-Adaptive Architecture Search: In FLaaS, a service represents a participating edge node with distinct data distributions and resource constraints; therefore, models are tailored to each service. The integration of NAS introduces additional complexity, as architectures need to be optimised for each service under varying data distributions and resource constraints. For example, resource-constrained services, such as wearable and mobile devices, require lightweight architectures, whereas more capable services can support deeper models. However, searching and evaluating multiple architectures incurs significant computational overhead and energy consumption, particularly in resource-constrained environments. Therefore, designing energy-efficient service-adaptive architecture search remains a key challenge. To address these challenges, we design OrchNAS for Personalised Federated Edge Intelligence by leveraging NAS Service. OrchNAS optimises energy consumption across three critical levels: the NAS search space, the global service architecture, and personalised services. First, we introduce an energy-efficient global service architecture search method that learns a compact shared representation. The server generates candidate architectures through evolutionary mutation and selects the architecture that minimises training energy while maintaining effective global learning. Next, we develop an energy-efficient architecture selection mechanism that enables each service to derive a personalised service under its resource constraints. This is achieved through a progressive, greedy, energy-aware pruning strategy that removes high-computational-cost operations, producing lightweight architectures. Finally, we propose an energy-efficient personalised optimisation that updates service-adaptive parameters while preserving global representations. A primal-dual optimisation mechanism is integrated to enforce energy budgets by penalising constraint violations. This allows each service to obtain a personalised service tailored to its data distribution and resource capability while ensuring energy-efficient training. We evaluated OrchNAS across accuracy, energy efficiency, and scalability, validating its effectiveness for Personalised Federated Edge Intelligence. The key contributions of the paper are as follows: • A novel energy-efficient OrchNAS framework leveraging NAS services for the service-adaptive architecture design. • An energy-efficient global service architecture search using evolutionary mutation and energy-aware scoring to learn a global representation. • A service-adaptive architecture for personalised subnets under energy, computation, and memory constraints. • A primal–dual optimisation-based personalised training method that enforces energy budgets while preserving performance accuracy. I Related Work Prior work in Service Computing has focused on service composition, service selection, workflow optimisation, and resource-aware management, enabling efficient coordination of distributed services in edge environments [17, 18, 19, 31, 32, 33, 34]. This establishes a strong foundation for Edge Intelligence by enabling service deployment and efficient utilisation of distributed resources [17, 21]. However, such methods treat services as fixed computational units and do not consider adaptive architecture optimisation. To address heterogeneity, recent studies incorporate personalisation mechanisms that allow services to adapt models based on local data and resource constraints [20, 21]. Nevertheless, existing service-oriented edge intelligence frameworks largely emphasise training, composition, and resource scheduling, while overlooking automated model design [17, 21, 26]. NAS has recently emerged as a promising approach for advancing Personalised Edge Intelligence [1, 2, 3, 4, 5, 6]. SPIDER proposes a personalised NAS framework that searches for client-specific architectures using a shared supernet with weight sharing; however, it incurs high overhead due to supernet transmission and on-device NAS [1]. Similarly, FEDPNAS introduces a personalised NAS framework for FL that jointly learns a shared base architecture and client-specific personalised components. By incorporating context-aware operator sampling and a personalisation-aware training objective, the method improves model adaptation to heterogeneous client tasks [3]. More recently, PEACHES further extends this idea by combining shared base cells with personalised cells to improve model adaptability under heterogeneous edge environments [2]. PerFedRLNAS is a reinforcement learning (RL)-based federated NAS framework that automatically discovers personalised architectures for each client. A server-side supernet samples client-specific subnets for local training, while RL updates architecture parameters based on client performance [4]. HAPFNAS is a heterogeneity-aware personalised federated NAS framework that addresses statistical and resource heterogeneity using knowledge distillation, predictor-guided evolutionary search, and heterogeneous model aggregation [5]. A Personalised Federated Stochastic Differential Equation-based NAS (PerFedSDE-NAS) performs NAS directly on client devices, thereby preserving privacy in PFL. It combines a diffusion-based architecture generator, a performance predictor for candidate selection, and an improved supernet training and aggregation strategy to accelerate convergence [6]. Recent advances in NAS-based PFL has demonstrate significant progress. For example, SPIDER, FEDPNAS, and PEACHES enable personalised architecture adaptation across heterogeneous clients. Despite this significance, several limitations remain. Existing methods focus on improving predictive performance through personalisation and handling data or system heterogeneity, but they largely ignore the energy consumption of architecture search and training on resource-constrained edge devices [1, 2, 3, 4, 5]. Many of these frameworks [1, 6] rely on large supernets or complex NAS procedures, which introduce significant computational overhead and communication cost during federated training. For example, transmitting large supernet structures can substantially increase computation and energy usage on edge devices with limited battery capacity. Furthermore, current approaches do not explicitly incorporate device-level energy constraints into the architecture search process, leading to architectures that may achieve high accuracy but are impractical for energy-constrained edge environments. Consequently, there remains a lack of energy-aware personalised NAS frameworks that optimise model accuracy, personalisation, and device-level energy efficiency. Therefore, designing energy-efficient personalised federated edge intelligence via NAS for resource-constrained environments remains a critical open challenge. I Problem Formulation Let us consider an edge intelligence system based on FLaaS, consisting of a NAS Service platform and a set of edge services =1,2,…,KN=\1,2,…,K\. Each service k∈k operates on a device with varying compute capacity, memory, and energy constraints, and participates in collaborative learning while keeping its data local. The NAS Service operates as a cloud-based architecture search platform that orchestrates model architecture search and distributed training across services. Each service k∈k holds a private dataset Dk=(xk,j,yk,j)j=1nkD_k=\(x_k,j,y_k,j)\_j=1^n_k where (xk,j,yk,j)(x_k,j,y_k,j) denotes the input-label pair of the j-th sample and nk=|Dk|n_k=|D_k| represents the local dataset size. The local objective of service k is defined as fk(wk,ak|Dk)=1nk∑j=1nkL(xk,j,yk,j|wk,ak)f_k(w_k,a_k|D_k)= 1n_k _j=1^n_kL(x_k,j,y_k,j|w_k,a_k) (1) where wkw_k denotes the model parameters, aka_k represents the neural architecture deployed on service k, and L(⋅)L(·) is the loss function. To address statistical heterogeneity, PFL allows each service to maintain personalised model parameters minwkF(W)=∑k=1Kpkfk(wk|Dk)+ζR(W) _\w_k\F(W)= _k=1^Kp_kf_k(w_k|D_k)+ζ R(W) (2) where W=w1,…,wKW=\w_1,…,w_K\ denotes the set of personalized model parameters and R(W)R(W) encourages knowledge sharing among services. NAS Service optimises model parameters and architecture to adapt device constraints. Let the supernet search space be defined as =(E,O)A=(E,O), where E denotes network edges and O denotes candidate operations. Each service k is associated with resource constraints, compute capacity CkC_k, memory capacity MkM_k, and energy budget per round BkB_k. The computational complexity and model size of architecture aka_k are defined as F(ak)=FLOPs(ak),P(ak)=Params(ak)F(a_k)=FLOPs(a_k), P(a_k)=Params(a_k). The training energy consumption of service k is modelled as Ek(ak)=αkF(ak)TkE_k(a_k)= _kF(a_k)T_k (3) where αk _k denotes the device-specific energy coefficient and TkT_k represents the number of local training steps. The feasible architecture set for device k is therefore ℱk=ak∈|Ek(ak)≤Bk,F(ak)≤Ck,P(ak)≤MkF_k= \a_k \;|\;E_k(a_k)≤ B_k,\;F(a_k)≤ C_k,\;P(a_k)≤ M_k \ (4) Edge environments are inherently dynamic, with device states of service sk=(Ck,Mk,Bk)s_k=(C_k,M_k,B_k), such as compute capacity, memory capacity, and energy budget. We adopt a NAS Service which dynamically allocates architectures to dynamically changing device states. Let ak=(k,,sk,θs)a_k=O(k,A,s_k, _s) where θs _s represents the parameters of the NAS Service policy. The overall NAS Service optimisation problem for personalised, edge-intelligence can therefore be formulated as minwk,θs _\w_k\, _s ∑k=1Kpkfk(wk,ak|Dk)+ζR(W,A) _k=1^Kp_kf_k(w_k,a_k|D_k)+ζ R(W,A) (5) s.t. ak=(k,,sk,θs),∀k∈,ak∈ℱk a_k=O(k,A,s_k, _s),\;∀ k ,a_k _k where A=a1,…,aKA=\a_1,…,a_K\ denotes the set of service-specific architectures allocated by the NAS Service. The objective optimises the personalised service parameters and the architecture allocation while satisfying dynamically changing device-level resource constraints. IV Proposed Framework OrchNAS is an energy-aware framework that leverages NAS Service to automatically design energy-efficient, global and service-adaptive personalised services (see Fig. 1). OrchNAS offloads the NAS process to a server-side orchestration service. The server generates and manages candidate architectures, coordinates parallel evaluation across participating services, aggregates feedback, and updates the global service, while each service derives a personalised subnet that satisfies its own energy, computation, and memory constraints. The complete training pipeline is shown in Algorithm 1. Figure 1: Overview of the OrchNAS Framework Algorithm 1 OrchNAS Training Pipeline 1:Input: Search space A, Service set K, Service constraints Bkt,Ckt,Mkt,αkt,Tkt\B_k^t,C_k^t,M_k^t, _k^t,T_k^t\ 2:Output: Global Service w∗w , Personalised subnets ak∗\a_k \, Personalised parameters vk∗\v_k \ 3:Step 1: Initialization 4:w0←w^0← initialize global service parameters 5:b⊆←A_b ← initialize candidate pool 6:for each service k∈k do 7: vk0←v_k^0← initialize personalised parameters 8: ak0⊆←a_k^0 ← initialize subnet 9: ηk0←0 _k^0← 0 10:Step 2: Communication and Global Service Search 11:for t=1t=1 to T do 12: NAS Service selects participating services tK_t 13: NAS Service generates candidates bA_b via mutation 14: NAS orchestrator schedules parallel evaluation jobs 15: NAS Service broadcasts global service parameters wtw^t 16: for each service k∈tk _t in parallel do 17: Observe state Bkt,Ckt,Mkt,αkt,Tkt\B_k^t,C_k^t,M_k^t, _k^t,T_k^t\ 18: for each candidate architecture a∈ba _b do 19: E^kt(a)←αktF(a)Tkt E_k^t(a)← _k^tF(a)T_k^t 20: Skt(a)←ValAcckt(a)−λE^kt(a)S_k^t(a) _k^t(a)-λ E_k^t(a) 21: Send Skt(a)a∈b\S_k^t(a)\_a _b to NAS Service 22: at←argmaxa∈b∑k∈tpktSkt(a)a^t← _a _b _k _tp_k^tS_k^t(a) 23: NAS Service broadcasts selected global architecture ata^t 24: for each service k∈tk _t do 25: wkt+1←wt−γ∇wFk(wt,vkt,at)w_k^t+1← w^t-γ _wF_k(w^t,v_k^t,a^t) 26: Derive personalised subnet akta_k^t from ata^t 27: Step 3: Energy Feasibility and Greedy Pruning 28: Compute F(akt)F(a_k^t), P(akt)P(a_k^t), Ekt(akt)E_k^t(a_k^t) 29: if Ekt(akt)>BktE_k^t(a_k^t)>B_k^t or F(akt)>CktF(a_k^t)>C_k^t or P(akt)>MktP(a_k^t)>M_k^t then 30: Progressive Greedy Energy-Aware Pruning ( Algorithm 2) 31: Step 4: Personalised Service Optimisation 32: vkt+1←vkt−γ(∇vkFk(wt,vkt,akt)+μ(vkt−wt))v_k^t+1← v_k^t-γ ( _v_kF_k(w^t,v_k^t,a_k^t)+μ(v_k^t-w^t) ) 33: Step 5: Dual Update 34: ηkt+1←[ηkt+ρ(Ekt(akt)−Bkt)]+ _k^t+1← [ _k^t+ρ (E_k^t(a_k^t)-B_k^t ) ]_+ 35: Upload wkt+1w_k^t+1 to NAS Service 36: wt+1←∑k∈tpktwkt+1w^t+1← _k _tp_k^tw_k^t+1 37:return (w∗,ak∗,vk∗)(w ,\;a_k ,\;v_k ) IV-A System Overview Supernet Definition and Initialisation To efficiently explore the architecture search space, we adopt the one-shot NAS approach [29], where a single over-parameterised supernet represents all candidate architectures. All operations share weights within the supernet, allowing different architectures to inherit parameters without training each independently [29]. This significantly reduces computational cost compared to traditional NAS methods that train each candidate from scratch [29]. We define the Supernet A as a directed acyclic graph (DAG) representing the neural architecture search space, denoted as =(ℰ,)A=(E,O). Here, ℰ=e1,e2,…,eEE=\e_1,e_2,…,e_E\ denotes the set of edges connecting intermediate feature nodes, and each edge e∈ℰe is associated with a candidate operation set e=oe,1,oe,2,…,oe,OO_e=\o_e,1,o_e,2,…,o_e,O\. This supernet, therefore, represents the complete architecture search space from which service-adaptive architectures are derived. At initialisation, NAS orchestration service initialises the global service architecture parameters w0w^0 and an initial candidate pool b⊆A_b . Each service k∈k initialises its personalised parameters vk0v_k^0, an initial subnet ak0⊆a_k^0 , and a dual variable ηk0=0 _k^0=0. The dual variable is introduced to enforce the service-specific energy constraint during training. Initialising ηk0=0 _k^0=0 ensures that no energy penalty is imposed at the start of optimisation, stabilising the early training phase. At each communication round t, each selected service k∈tk _t estimates its current state kt=Bkt,Ckt,Mkt,αkt,TktC_k^t=\B_k^t,C_k^t,M_k^t, _k^t,T_k^t\ from local system statistics. The NAS Service then broadcasts the updated global parameters wtw^t and the candidate architecture pool to the selected services. The personalised parameters vktv_k^t and the subnet akta_k^t remain local and are not shared with the server. This preserves personalisation, reduces communication overhead, and protects service-specific information. IV-B Energy-Efficient Global Service Architecture Search To learn an energy-efficient global representation across heterogeneous services, we propose an energy-aware evolutionary search. Let b=a(1),a(2),…,a(m)A_b=\a^(1),a^(2),…,a^(m)\ denote the pool of candidate architectures derived from the supernet. At each communication round, the NAS Service updates the pool via evolutionary mutation. NAS Service generates new candidates by applying small structural mutations to previously selected architectures. Typical mutation operations include changing layer width, replacing operators on selected edges, or modifying local connectivity [30]. This strategy preserves previously discovered useful architectural patterns while evolving more energy-efficient alternatives. Once candidate architectures are generated, a NAS orchestration dispatches candidate architectures to trainer containers and coordinates their parallel evaluation. This orchestration mechanism enables scalable architecture search by allowing multiple candidate architectures to be evaluated simultaneously. For each candidate architecture a∈ba _b, service k estimates the per-round training energy as E^kt(a)=αktF(a)Tkt E_k^t(a)= _k^tF(a)T_k^t (6) where αkt _k^t is a time-varying service-specific energy coefficient, F(a)F(a) denotes the computational complexity (e.g., FLOPs) of architecture a at round TktT_k^t. Based on this, each service computes an energy-aware score Skt(a)=ValAcckt(a)−λE^kt(a),S_k^t(a)=ValAcc_k^t(a)-λ E_k^t(a), (7) where ValAcckt(a)ValAcc_k^t(a) is the validation accuracy of architecture a on service k at round t, and λ>0λ>0 controls the trade-off between performance and energy consumption. Each service sends the set of scores Skt(a)a∈b\S_k^t(a)\_a _b to the NAS Service, which selects the global architecture by maximising the weighted global score at=argmaxa∈b∑k∈tpktSkt(a)a^t= _a _b _k _tp_k^tS_k^t(a) (8) where tK_t is the set of participating services and pktp_k^t is the aggregation weight. The NAS Service then sends the selected architecture ata^t with shared parameters wtw^t, to participating services. Each service performs local stochastic gradient descent (SGD) [27] updates on global parameters while keeping its personalised parameters fixed: wkt+1=wt−γ∇wFk(wt,vkt,at)w_k^t+1=w^t-γ _wF_k(w^t,v_k^t,a^t) (9) where γ is the learning rate and Fk(w,v,a)F_k(w,v,a) is the local objective on service k. After local optimisation, the updated parameters wkt+1w_k^t+1 are uploaded to the NAS Service for aggregation. The global service architecture captures transferable features across services. By optimising architectures via energy-aware criteria (7)–(9), OrchNAS identifies compact architectures that preserve global knowledge while reducing computation and energy costs. IV-C Energy-Efficient Architecture Selection IV-C1 Dynamic Energy Modelling and Feasibility Constraints After the global service architecture update, each service k evaluates whether its current subnet akta_k^t satisfies device-level resource constraints under its current state. The architectural complexity is measured in terms of computational and memory cost as F(akt)=FLOPs(akt),P(akt)=Params(akt)F(a_k^t)=FLOPs(a_k^t), P(a_k^t)=Params(a_k^t), where F(akt)F(a_k^t) denotes the number of floating-point operations and P(akt)P(a_k^t) denotes the number of trainable parameters (model size). The per-round training energy is modelled as Ekt(akt)=αktF(akt)TktE_k^t(a_k^t)= _k^tF(a_k^t)T_k^t (10) where (akt)(a_k^t) is a service-specific energy coefficient capturing energy cost per floating-point operations at round t. Each service then enforces the following time-varying feasibility conditions: Ekt(akt)≤Bkt,F(akt)≤Ckt,P(akt)≤MktE_k^t(a_k^t)≤ B_k^t, F(a_k^t)≤ C_k^t, P(a_k^t)≤ M_k^t (11) where BktB_k^t is the available energy budget, CktC_k^t is the computational capacity, and MktM_k^t is the memory capacity at round t. These constraints ensure that the selected personalised architecture is feasible on the target service without excessive energy drain or resource overload under dynamic conditions. To satisfy each constraint, each service k refines its subnet akta_k^t through Progressive Greedy Energy-Aware Pruning. The goal of refinement is to solve a constrained local problem as minakt _a_k^t Fk(wkt,vkt,akt) F_k(w_k^t,v_k^t,a_k^t) (12) s.t. Ekt(akt)≤Bkt E_k^t(a_k^t)≤ B_k^t F(akt)≤Ckt F(a_k^t)≤ C_k^t P(akt)≤Mkt P(a_k^t)≤ M_k^t IV-C2 Greedy Edge-Wise Energy-Aware Pruning We adopt a Progressive Greedy Energy-Aware Pruning strategy (see Algorithm 2) that minimises an energy-regularised objective minaktFk(wkt,vkt,akt)+βEkt(akt) _a_k^tF_k(w_k^t,v_k^t,a_k^t)+β E_k^t(a_k^t) (13) where β>0β>0 controls the trade-off between model utility and energy usage. For each operation o on edge e, the service evaluates the impact of removing that operation from the subnet. The accuracy degration is computed (14) and energy reduction is computed as shown in (15) ΔAccot=Acc(akt)−Acc(akt∖o) _o^t=Acc(a_k^t)-Acc(a_k^t o) (14) ΔEot=Ekt(akt)−Ekt(akt∖o) E_o^t=E_k^t(a_k^t)-E_k^t(a_k^t o) (15) Each operator is ranked using the multi-objective score (16). A smaller score indicates that removing the operator yields large energy savings with limited accuracy degradation. Therefore, operators with the lowest scores are pruned first. The pruning process proceeds progressively across edges until the feasibility conditions in ((11)) are satisfied. Scoret(o)=ΔAccot−βΔEot.Score^t(o)= _o^t-β E_o^t. (16) This dynamic adaptation enables OrchNAS to respond to changes in data distributions, improving the practical deployability of personalised models in real-world edge environments (see Algorithm 2). While greedy edge-wise pruning reduces architectural complexity, it does not guarantee strict satisfaction of the energy constraint. Therefore, OrchNAS incorporates a primal-dual optimisation mechanism that continuously enforces the energy budget by penalising violations during training. These two mechanisms operate in complementary ways: pruning ensures structural feasibility, whereas primal–dual optimisation guarantees constraint satisfaction under standard saddle-point conditions. This design enables energy-efficient architecture search with reliable budget enforcement. Algorithm 2 Progressive Greedy Energy-Aware Pruning 1:Input: Supernet =(ℰ,e)A=(E,\O_e\); Subnet akta_k^t; Pruning coefficient β; Dynamic budgets Bkt,Ckt,MktB_k^t,C_k^t,M_k^t; Energy coefficient αkt _k^t 2:Output: Pruned subnet akt+1a_k^t+1 3:F(akt)←FLOPs(akt)F(a_k^t) (a_k^t) 4:P(akt)←Params(akt)P(a_k^t) (a_k^t) 5:Ekt(akt)←αktF(akt)τktE_k^t(a_k^t)← _k^tF(a_k^t) _k^t 6:Feasible(akt)⇔(Ekt(akt)≤Bkt)∧(F(akt)≤Ckt)∧(P(akt)≤Mkt)Feasible(a_k^t) (E_k^t(a_k^t)≤ B_k^t ) (F(a_k^t)≤ C_k^t ) (P(a_k^t)≤ M_k^t ) 7:while Feasible(akt)=falseFeasible(a_k^t)=false do 8: Abase←Acck(akt)A_base← Acc_k(a_k^t) 9: Ebase←Ekt(akt)E_base← E_k^t(a_k^t) 10: for each edge e∈ℰe do 11: if |akt(e)|≤1|a_k^t(e)|≤ 1 then 12: continue 13: for each operator o∈akt(e)o∈ a_k^t(e) do 14: a′←akt∖(e,o)a ← a_k^t \(e,o)\ 15: ΔAccot←Abase−Acck(a′) Acc_o^t← A_base-Acc_k(a ) 16:ΔEot←Ebase−Ekt(a′) E_o^t← E_base-E_k^t(a ) 17: Scoret(o)←ΔAccot−βΔEotScore^t(o)← Acc_o^t-β E_o^t 18: omin←argmino∈akt(e)Scoret(o)o_ ← _o∈ a_k^t(e)Score^t(o) 19: akt←akt∖(e,omin)a_k^t← a_k^t \(e,o_ )\ 20: if Feasible(akt)Feasible(a_k^t) then 21: break 22:akt+1←akta_k^t+1← a_k^t, return akt+1a_k^t+1 IV-D Energy-Efficient Personalised Model Optimisation Once a feasible service-specific subnet akta_k^t has been obtained, service k updates only its personalised parameters vkv_k, while keeping the global service architecture parameters fixed. Since the architecture is fixed at this stage, the energy term becomes constant with respect to vkv_k and no longer appears explicitly in the weight update. The personalised optimisation problem is minvkFk(wglobalt,vk,akt)+μ2‖vk−wglobalt‖2 _v_kF_k(w_global^t,v_k,a_k^t)+ μ2\|v_k-w_global^t\|^2 (17) where Fk(wglobalt,vk,akt)F_k(w_global^t,v_k,a_k^t) optimizes predictive performance on the service k’s data, μ>0μ>0 controls the strength of proximal regularization,μ2‖vk−wglobalt‖2 μ2\|v_k-w_global^t\|^2 prevents excessive divergence from the shared representation. The personalised service’s parameters are updated by SGD as vkt+1=vkt−γ(∇vkFk(wglobalt,vkt,akt)+μ(vkt−wglobalt))v_k^t+1=v_k^t-γ ( _v_kF_k(w_global^t,v_k^t,a_k^t)+μ(v_k^t-w_global^t) ) (18) This update balances minimising local empirical risk with maintaining consistency with the global representation. IV-D1 Primal–Dual Energy-Constrained Architecture Personalisation To ensure strict satisfaction of the energy constraint beyond structural pruning, we adopt a primal-dual optimisation framework that transforms the constrained personalisation problem into a saddle-point optimisation task [16]. The personalised parameters and architectures are optimised via gradient descent, while energy constraints are enforced through projected gradient ascent on dual variables using a Lagrangian formulation. For service k, the energy-constrained architecture search problem is formulated as minaktFk(wglobalt,vkt,akt)s.t.Ekt(akt)≤Bkt _a_k^tF_k(w_global^t,v_k^t,a_k^t) .t. E_k^t(a_k^t)≤ B_k^t (19) where Ekt(akt)E_k^t(a_k^t) denotes the per-round training energy, and BktB_k^t is service-specific energy budget. Lagrangian Formulation To solve the constrained problem, we introduce a non-negative dual variable ηkt≥0 _k^t≥ 0 for the energy constraint. The corresponding Lagrangian is defined as ℒkt(akt,ηkt)=Fk(wglobalt,vkt,akt)+ηkt(Ekt(akt)−Bkt)L_k^t(a_k^t, _k^t)=F_k(w_global^t,v_k^t,a_k^t)+ _k^t (E_k^t(a_k^t)-B_k^t ) (20) The constrained optimisation problem can therefore be transformed into the following saddle-point problem, which enables the framework to optimise architecture selection while dynamically enforcing the energy constraint. minaktmaxηkt≥0ℒkt(akt,ηkt) _a_k^t _ _k^t≥ 0L_k^t(a_k^t, _k^t) (21) • Primal Update (architecture update) Given the current dual variable ηkt _k^t, the architecture is updated to minimise the Lagrangian as shown in (22). In practice, this minimisation is realised through greedy pruning. A larger dual variable, ηkt _k^t, increases the penalty for energy consumption, encouraging lower-complexity architectures when the budget is violated. akt+1=argminak[Fk(wglobalt,vkt,ak)+ηktEkt(ak)]a_k^t+1= _a_k [F_k(w_global^t,v_k^t,a_k)+ _k^tE_k^t(a_k) ] (22) • Dual Update (Constraint enforcement) The dual variable is updated by projected gradient ascent by (23), where ρ>0ρ>0 is the dual step size and [⋅]+=max(0,⋅)[·]_+= (0,·) denotes projection onto the non-negative orthant. If the energy budget is violated, ηkt _k^t increases, thereby strengthening the penalty on energy consumption in subsequent rounds. If the energy budget is satisfied, the dual variable stabilises. This primal-dual mechanism ensures that the energy budget is satisfied while maintaining good predictive accuracy. ηkt+1=[ηkt+ρ(Ekt(akt+1)−Bkt)]+ _k^t+1= [ _k^t+ρ (E_k^t(a_k^t+1)-B_k^t ) ]_+ (23) Theorem 1 (Energy Constraint Satisfaction). Assume that the local objective function Fk(w,vk,ak)F_k(w,v_k,a_k) is convex and Lipschitz continuous, and the energy function Ek(ak)E_k(a_k) is bounded. Then, under appropriate learning rates, the above primal–dual updates ensure: lim supT→∞1T∑t=1T(Ek(akt)−Bkt)≤ϵ _T→∞ 1T _t=1^T (E_k(a_k^t)-B_k^t )≤ε (24) where ϵ=(ρ)ε=O(ρ) is constant dependent on dual step size,(Ek(akt)−Bkt)(E_k(a_k^t)-B_k^t) is constraint violation. The average violation over T rounds is 1T∑t=1T 1T _t=1^T, lim supT→∞ _T→∞ captures long-term behaviour. The bound ϵε indicates violations remain small. Proof- The result follows from standard saddle-point optimisation analysis[16]. The Lagrangian is convex in aka_k and linear in ηk _k. The dual update penalises constraint violations over time, and the cumulative constraint violation is bounded by (T)O( T). Dividing by T yields asymptotic satisfaction of the energy constraint. IV-E Server Aggregation and Global Update After completing local updates, each service uploads its updated global parameters wkt+1w_k^t+1 to the NAS Service. Personalised service parameters vkt+1v_k^t+1 and personalised subnet structures akt+1a_k^t+1 remain local and are not transmitted. The NAS Service aggregates the global parameters using weighted averaging as follows: wt+1=∑k∈tpktwkt+1pkt=|Dk|∑j∈t|Dj|w^t+1= _k _tp_k^tw_k^t+1 p_k^t= |D_k| _j _t|D_j| (25) where |Dk||D_k| denotes the data size of service k. This aggregation approximates a single global gradient descent step and enables the NAS Service to learn consistent global representations across heterogeneous data. The process is repeated T times. At convergence, the NAS Service obtains the final global parameters w∗w , while each service retains its personalised subnet ak∗a_k and parameters vk∗v_k . OrchNAS achieves a balanced trade-off between prediction accuracy and training energy, enabling scalable and energy-efficient personalised federated edge intelligence under dynamic service conditions. V Experiment Results and Analysis A series of experiments is designed to evaluate the proposed OrchNAS. We evaluate the efficiency of OrchNAS by comparing it with representative PFL and NAS-based methods. We further assess the effectiveness of the global architecture search, architecture selection, and personalised optimisation components using multiple baseline strategies. To analyse scalability, we increase the number of participating services and measure accuracy and energy consumption. We conducted a sensitivity analysis for a selected hyperparameter and system configuration. All experiments are implemented in Python on a system with 16 GB RAM and 500 GB of local storage. The source code and experimental details are publicly available.111https://github.com/keyadata/OrchNAS. V-A Experiment Set Up and Datasets We simulate a heterogeneous edge environment with 50 edge services coordinated by a central server. In each communication round, 10 services perform local SGD in architecture searching and training with momentum 0.9. Each service has dynamic resource constraints that may vary across communication rounds. Constraints, including device-specific energy, computation, and memory budgets, guide the architecture selection process to derive feasible personalised architectures for the service. To represent heterogeneous hardware capabilities, services are classified into low-, medium-, and high-resource groups. The architecture search space is defined by backbone depth 2,3,5\2,3,5\, channel width 32,64,128,192,256\32,64,128,192,256\, activation functions ReLU,GELU,tanh\ReLU,GELU, \, operation types standard,depthwise separable,inverted bottleneck\standard,\ depthwise separable,\ inverted bottleneck\, and kernel sizes 3,5,7\3,5,7\. This results in ||=3×5×3×3×3=405|A|=3× 5× 3× 3× 3=405 candidate architectures. We use publicly available datasets to evaluate the proposed OrchNAS framework, as they provide complementary environments for analysing NAS service in edge intelligence. CIFAR-10 [22], and Street View House Numbers (SVHN) [23] enable efficient exploration of the search space under relatively lightweight settings, while CIFAR-100 [22] and Tiny-ImageNet[24] introduce greater visual complexity and class diversity, making them suitable for evaluating the robustness of personalised architecture adaptation. ImageNet-100 [25] further provides a more challenging large-scale setting to assess the scalability of OrchNAS and the effectiveness of personalised subnet optimisation. All datasets are partitioned using a non-IID Dirichlet split to simulate real-world data heterogeneity. We train all methods for 100 rounds, with 20 local epochs per service and a batch size of 64. We measure accuracy, energy consumption (J), and FLOPs for the accuracy-energy trade-offs for efficient, effective and scalable personalised edge intelligence deployment. V-B Experiment 1: Efficiency of OrchNAS To evaluate the efficiency of OrchNAS, we compare it with representative PFL and NAS methods. SPIDER [1], PerFedRLNAS [4], and diffusion-driven personalised NAS [6]. These approaches explore personalised model architectures or adaptive training strategies to address data and device heterogeneity in FL environments. We include the Green-EDP [7] and MCFL [8] baselines, which focus on energy-aware training and client clustering for PFL. All methods are evaluated under the same experimental configuration to ensure a fair comparison. We conduct experiments on five datasets of varying complexity-CIFAR-10, CIFAR-100, SVHN, Tiny-ImageNet, and ImageNet-100 to comprehensively evaluate the performance of OrchNAS across diverse edge intelligence scenarios. For lightweight datasets (CIFAR-10 and SVHN), we use a small CNN [1] architecture to enable efficient architecture search under strict resource constraints. For more complex datasets (CIFAR-100, Tiny-ImageNet, and ImageNet-100), we adopt MobileNet-V2 [11] to reflect a realistic edge environment. We measure accuracy as the average classification accuracy across participating services on the test dataset, while energy consumption is estimated from the computational cost of each architecture, accounting for its FLOPs and local training workload under service-specific conditions. Table I summarises the efficiency results across all datasets. OrchNAS outperforms the baseline methods in both accuracy and resource efficiency. On CIFAR-10, OrchNAS achieves 91.0% accuracy (+1.1%) and reduces energy consumption by up to 30% and computational cost to 96M FLOPs. On ImageNet-100, it reaches 74.3% accuracy, exceeding the strongest NAS baseline by 2.2%, while reducing energy consumption by 19% and computational complexity to 235M FLOPs. Similar trends are observed on CIFAR-100 and Tiny-ImageNet, where OrchNAS achieves higher accuracy with lower energy and computational cost. On SVHN, it maintains strong performance under non-IID data and reduces energy consumption, demonstrating robustness in real-world edge scenarios. These results show that OrchNAS learns lightweight, energy-efficient personalised architectures across diverse datasets, improving accuracy, while reducing energy consumption and computational cost across heterogeneous edge services. TABLE I: Performance comparison of OrchNAS with baseline methods across multiple datasets Method CIFAR-10 CIFAR-100 SVHN Tiny-ImageNet ImageNet-100 Acc Energy FLOPs Acc Energy FLOPs Acc Energy FLOPs Acc Energy FLOPs Acc Energy FLOPs SPIDER[1] 86.7 52.4 125 62.3 88.1 210 92.1 35.2 78 58.4 120.5 260 70.8 142.5 310 PerFedRLNAS[4] 85.2 49.8 129 60.9 84.3 215 91.4 34.1 82 56.7 118.2 268 69.4 139.7 322 Diffusion NAS[6] 89.9 48.6 112 65.1 80.7 198 93.5 32.8 72 60.3 110.6 240 72.1 130.4 284 Green-EDP[7] 88.1 41.5 105 63.4 70.5 185 92.6 29.4 70 58.9 102.4 228 69.3 118.2 260 MCFL[8] 87.3 44.7 110 61.8 75.2 192 92.0 30.8 75 57.2 108.7 235 68.9 121.6 291 OrchNAS 91.0 36.9 96 67.8 62.4 170 94.2 26.1 65 63.5 92.1 210 74.3 105 235 V-C Experiment 2: Effectiveness of OrchNAS V-C1 Evaluation of Energy-Efficient Global Architecture Search We evaluate the effectiveness of the proposed energy-efficient global service search mechanism on CIFAR-10 using four baselines inspired by prior NAS approaches. These include Largest backbone, which selects the largest architecture in the search space to maximise model capacity [9]; Smallest Backbone, which selects the smallest architecture to minimise computational cost, similar to lightweight CNN designs for resource-constrained devices [12]; Accuracy-Only Search, which selects the architecture with the highest validation accuracy without considering energy consumption [9]; and Random Search, which randomly samples architectures from the search space and is widely used as a baseline in NAS evaluation [13]. As shown in Table I, OrchNAS achieves 85.2% test accuracy with 1.03 J energy and 79M FLOPs. This is more effective than the Largest Backbone (1.82 J, 120M FLOPs) and Accuracy-Only Search (1.56 J, 108M FLOPs). This improvement is due to the evolutionary mutation process, which explores diverse architectures and selects architectures with higher energy-aware scores. Also, the global service learns a compact global architecture that can be reused across services. This reduces redundant architecture search during the NAS process. Overall, OrchNAS balances prediction performance and energy efficiency in edge intelligence. TABLE I: Comparison of Global Architecture Search Strategies Method Val. Acc. Test Acc. Energy (J) FLOPs (M) Largest Backbone[9] 86.1 84.5 1.82 120 Smallest Backbone[12] 79.2 76.8 0.72 48 Accuracy-Only Search[3] 86.7 84.8 1.56 108 Random Search[13] 83.1 80.9 1.21 86 OrchNAS 85.9 85.2 1.03 79 V-C2 Evaluation of Energy-Efficient Architecture Selection We evaluate an energy-efficient architecture selection mechanism in which each service derives a personalised subnet from the global architecture via progressive pruning to satisfy device-level energy, computation, and memory constraints. We compare OrchNAS with several architecture adaptation strategies on CIFAR-10, inspired by prior work. No Adaptation directly deploys the global architecture without structural modification, meaning all clients use the same full model regardless of device constraints [5]. Random Pruning randomly removes network components until device constraints are satisfied, which is a common baseline in NAS evaluation [13]. FLOPs-Based Pruning removes operations according to their computational cost to reduce model complexity [9]. Uniform Scaling uniformly reduces the width of network layers to obtain a smaller model, a strategy widely used for resource-constrained devices [12]. Table I summarises the results in terms of personalised test accuracy, energy reduction, computational complexity, model size, and feasibility rate. Compared to baselines, the OrchNAS architecture selection mechanism achieves 84.2% classification accuracy with improving resource efficiency across heterogeneous services. The selected architectures reduce training energy consumption by 35.8%, demonstrating the effectiveness of the energy-aware selection strategy. In addition, OrchNAS identifies lightweight models with only 71M FLOPs and 0.88M parameters, which lowers computational and memory requirements for edge deployment. The method also achieves a 92.6% feasibility rate, indicating that most selected architectures satisfy device-level resource constraints, making the approach suitable for energy-constrained edge environments. OrchNAS progressively removes edges with the lowest energy-aware contribution in the supernet, preserving important feature paths while eliminating redundant computations. As a result, low-resource devices obtain compact subnet architectures, whereas high-resource devices retain larger architectures. This approach enables OrchNAS to derive service-adaptive personalised architectures while improving energy efficiency. TABLE I: Comparison of architecture selection methods Method Acc(%) Energy Red. (%) FLOPs (M) Params (M) Feas. Rate (%) No Adaptation[5] 85.4 0.0 108 1.42 41.2 Random Pruning[13] 80.1 24.5 82 1.01 76.8 FLOPs Pruning [9] 81.6 31.7 75 0.94 84.5 Uniform Scaling[12] 80.9 28.9 79 0.98 80.7 OrchNAS 84.2 35.8 71 0.88 92.6 V-C3 Evaluation of Energy-Efficient Personalised Optimisation We compare the energy-efficient personalised optimisation on CIFAR-10 using three baseline variants inspired by prior work: (i) Standard Federated Optimisation, which performs FL training without personalisation; (i) Personalised Training without Energy Regularisation, which updates personalised parameters but does not enforce energy constraints; and (i) Energy-Regularised Training without Dual Updates, which introduces energy regularisation but does not apply the primal–dual optimisation mechanism. Evaluation uses multiple metrics: Average personalised accuracy (mean accuracy across all services), worst-service accuracy (accuracy of the lowest-performing service), energy violation rate (percentage of services exceeding the energy budget), and average training energy consumption (mean energy required for local training). Table IV presents the results. OrchNAS achieves the highest personalised accuracy (85.1) and worst-service accuracy (79.3), showing performance and robustness across heterogeneous services. Also, OrchNAS significantly reduces energy budget violations to 4.8%, compared with 18.4% in standard FL optimisation and 26.7% in unconstrained personalised training with lowest average training energy consumption (1.07). This improvement is mainly due to the primal–dual optimisation mechanism. The primal update optimises personalised model parameters, and the dual update penalises energy violations. As a result, OrchNAS learns resource-aware personalised models that maintain strong accuracy while reducing energy consumption in edge intelligence. TABLE IV: Comparison of personalised model optimisation methods. Method Avg. Pers. Acc. Worst-Client Acc. Energy Viol. Rate (%) Avg. Train Energy Std. FL Optimisation [26] 80.1 74.2 18.4 1.62 Personalised w/o Energy Reg.[3] 84.3 78.1 26.7 1.74 Energy Reg. w/o Dual Update [7] 83.2 76.8 11.9 1.28 OrchNAS 85.1 79.3 4.8 1.07 V-D Experiment 3: Scalability Analysis of OrchNAS To evaluate the scalability of OrchNAS on ImageNet-100, we increase the number of participating edge services from 50 to 2500. The results in Fig. 2 show that the personalised accuracy increases from 74.3%74.3\% to 76.0%76.0\%, with minor fluctuations across intermediate scales. These variations are expected in large-scale federated environments due to stochastic client participation and non-IID data distributions. Nevertheless, the overall improvement indicates that the global architecture benefits from increased data diversity, enhancing generalisation across heterogeneous services. The training energy consumption increases from 0.72 J to 1.20 J as the number of services increases. However, this increase remains moderate relative to the scale of the system. This is because the NAS service performs architectural search centrally, reducing computation on edge services. Overall, OrchNAS scales effectively, maintaining stable performance while ensuring controlled growth in energy consumption across a large edge environment. Figure 2: Scalability of OrchNAS on ImageNet-100 V-E Experiment 4: Sensitivity Analysis of OrchNAS We further evaluate the robustness of OrchNAS under different hyperparameter settings and system configurations. We analyse the impact of the energy regularisation coefficient λ, the device energy budget. To ensure a controlled and interpretable analysis, we adopt fixed energy budgets while varying λ∈0,0.01,0.05,0.1λ∈\0,0.01,0.05,0.1\. This design isolates the effect of energy regularisation on the learned architectures and training behaviour. The results demonstrated that the smaller values of λ favour accuracy-oriented architectures with higher computational and energy cost, whereas increasing λ progressively shifts the search towards more compact and energy-efficient models, with only marginal accuracy degradation. Furthermore, under stricter energy budgets, OrchNAS consistently adapts by selecting smaller subnet architectures that satisfy device-level constraints. This behaviour is important in critical domains such as drone-based surveillance and wearable healthcare, where energy constraints are strict, and models must balance accuracy with efficient resource utilisation. The sensitivity analysis results are shown in Fig. 3 (a)(b). These results confirm the robustness of OrchNAS in balancing accuracy and efficiency under varying resource constraints. Figure 3: Sensitivity analysis of OrchNAS: (a) Effect of Energy Regularisation Coefficient λ and (b) Effect of Device Energy Budget V-F Discussion Our experiments show that OrchNAS improves model accuracy and reduces energy consumption across heterogeneous edge services. The NAS Service orchestration enables efficient exploration of the architecture space, and the energy-aware global architecture search, combined with personalised subnet selection, ensures that service-adaptive constraints are satisfied. This design enables the framework to deliver adaptive, efficient models suitable for real-world edge intelligence scenarios. One limitation of the framework is its focus on energy-aware optimisation, which does not fully capture trade-offs between accuracy, latency, and long-term resource usage. This limitation can lead to suboptimal model selection in scenarios where multiple objectives must be balanced. Future work can address this by incorporating multi-objective optimisation strategies. Another limitation is that personalised architecture search introduces additional computational overhead and limits scalability in large-scale deployments. This can be addressed by adopting global optimisation or group-based adaptation to reduce redundancy and improve scalability. VI Conclusion In this paper, we propose OrchNAS, an energy-aware personalised federated edge intelligence framework that leverages a NAS Service to automatically design service-adaptive architectures for heterogeneous edge environments. The framework integrates three key components: an energy-efficient global architecture search, an energy-efficient architecture selection mechanism, and a primal–dual optimisation-based personalised approach to enforce strict energy constraints. Together, these components enable effective coordination between global knowledge sharing and service-level adaptation. Experimental results on datasets show that OrchNAS consistently improves accuracy and significantly reduces energy consumption compared to existing PFL with NAS-based approaches. Moreover, the framework achieves high feasibility rates under dynamic service constraints and scales effectively with an increasing number of edge services, demonstrating its practicality for real-world deployments. Future work will explore multi-objective optimisation strategies and more efficient collaborative search mechanisms to further improve scalability and deployment efficiency in complex edge intelligence scenarios. References [1] E. Mushtaq, C. He, J. Ding, and S. Avestimehr, “SPIDER: Searching personalised neural architecture for federated learning,” arXiv:2112.13939, 2021. [2] J. Yan, J. Liu, H. Xu, Z. Wang, and C. Qiao, “PEACHES: Personalised federated learning with neural architecture search in edge computing,” IEEE Transactions on Mobile Computing, p. 10296–10312, 2024. [3] M. Hoang and C. Kingsford, “Personalized Neural Architecture Search for Federated Learning,” 2021. [4] D. Yao and B. Li, “PerFedRLNAS: One-for-all personalised federated neural architecture search,” in Proc. AAAI Conf. AI, vol. 38, no. 15, p. 16398–16406, 2024. [5] A. Yang and Y. Liu, “Heterogeneity-Aware Personalized Federated Neural Architecture Search,” Entropy, p. 759, 2025. [6] P. Liao, X. Wang, Y. Jin, W. Du, and H. Hu, “Neural architecture search driven by locally guided diffusion for personalised federated learning,” in Proc. IEEE/CVF (ICCV), p. 4222–4231, 2025. [7] J. A. Ruiz-Mill, N.Rodriguez-Barroso, and M.V Luzon, “Green-EDP: Aligning personalisation in federated learning and green artificial intelligence throughout the encoder-decoder architecture,”Progress in AI, p. 1–18, 2025. [8] A. Xiong, and et al., “A multi-task based clustering personalized federated learning method,” Big Data Mining and Analytics, p. 1017–1030, 2024. [9] T. Elsken, J. H. Metzen, and F. Hutter, “Neural architecture search: A survey,” Journal of ML Research, p. 1 21, 2019. [10] Google Cloud, ”Vertex AI NAS overview, Google Cloud Docs”, 2021. https://docs.cloud.google.com/vertex ai/docs/training/neural architecture search/overview [11] M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L.-C. Chen, “MobileNetV2: Inverted residuals and linear bottlenecks,” in Proc. IEEE Conf. Comput. Vis. Pattern Recognit., 2018, p. 4510–4520. [12] A. G. Howard, and et al., “MobileNets: Efficient convolutional neural networks for mobile vision applications,” arXiv:1704.04861, 2017. [13] L. Li and A. Talwalkar, “Random search and reproducibility for neural architecture search,” in Proc. Conf. UAI, 2019. [14] A. Krizhevsky and G. Hinton, “CIFAR-10 object recognition dataset,” Kaggle, 2009. [Online]. Available:https://w.kaggle.com/datasets/cifar-10 [15] O. Russakovsky and et al., “ImageNet large scale visual recognition challenge,” International Journal of CV, p. 211–252, 2015. [16] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein, “Distributed optimisation and statistical learning via the alternating direction method of multipliers,” Foundations and Trends in ML, p. 1–122, 2011. [17] S. Wang, A. Zhou, R. Bao, and W. Chou, “Towards green service composition approach in the cloud,” IEEE TSC, p. 532–545, 2018. [18] B. Shen and et al., “Dynamic task offloading with minority game for Internet of vehicles in cloud-edge computing,” in Proc. ICWS, 2020, p. 372–379. [19] D. D. Sanchez-Gallegos and A. Galaviz-Mosqueda, “On the continuous processing of health data in edge-fog-cloud computing by using micro/nanoservice composition,” in Proc. IEEE ICWS, 2020, p. 143–150. [20] Z. Zhao, C. Qiu, Y. Zhao, X. Wang, and H. Yao, “F2NAS: Flexible federated neural architecture search in green edge computing,” in Proc. IEEE, 2024. [21] D. Xu and et al., “Edge intelligence: Empowering intelligence to the edge of network,” Proc. IEEE, p. 1778–1837, 2021. [22] A. Krizhevsky, “Learning multiple layers of features from tiny images,” University of Toronto, 2009. [23] Y. Netzer and et al., “Reading digits in natural images with unsupervised feature learning,” in NIPS Workshop on DL and Unsupervised Feature Learning, 2011. [24] J. Deng, W. Dong, R. Socher, et al., “Tiny ImageNet (Stanford CS231N) [Dataset],” 2024. [Online]. Available: https://cstr.cn/32010.11.sjtu.scidata.00000019 [25] A. Howard, E. Park, and W. Kan, “ImageNet Object Localisation Challenge,” Kaggle, 2018. [Online]. https://kaggle.com/competitions/imagenet object localisation challenge [26] N. Kourtellis, K. Katevas, and D. Perino, “FLaaS: Federated Learning as a Service,” in Proc. 1st Workshop on Distributed ML, 2020, p. 7–13. [27] S. Lee, Q. Kang, A. Agrawal, A. Choudhary, and W.-k. Liao, “Communication-Efficient Local Stochastic Gradient Descent for Scalable Deep Learning,” in Proc. IEEE (Big Data), 2020, p. 718–727. [28] H. Shi, T. Ji, Z. Wang, S. Jin, and Y. Huang, “Automatic Neural Network Construction Based on Neural Tangent Kernel for IRS-Aided Beamforming,” IEEE Trans. Wireless Commun., p. 1155–1168, 2026. [29] Y. Feng, Y. Ou, and Y. Sun, “Accurate and robust NAS via a flexible supernet,” IEEE Transactions on N and Learning Systems, p. 1–15, 2026. [30] F. Ming, W. Gong, B. Xue, M. Zhang, and Y. Jin, “An evolutionary framework for multi-objective neural architecture search,” IEEE Transactions on Evolutionary Computation, p. 1–1, 2025. [31] X. Xia, S. M. M. Fattah, and M. A. Babar, “A Survey on UAV-enabled Edge Computing: Resource Management Perspective,”ACM Computing Surveys, p. 1–36, 2024. [32] M. Perera, S. Fattah, S. Mistry, and A. Krishna, ”Reinforcement Learning Controlled Adaptive PSO for Task Offloading in IIoT Edge Computing,” in ACM Web Conference 2025, 2025, p. 1249–1253. [33] S. M. M. Fattah, A. Bouguettaya, and S. Mistry, “Long-Term IaaS Provider Selection Using Short-Term Trial Experience,” in Proc. IEEE ICWS, 2019, p. 304–311. [34] K. Patel, S. Mistry, D. Kanneganti, and A. Krishna, “Context-Aware Selection of Machine Learning as a Service (MLaaS) in IoT Environments,” in Proc. WISE, Springer, 2024, p. 190–205.