Feedback-based model compression

Abstract

A method in a first network node configured to communicate at least with a second network node and compress machine learning (ML) models is described. The method includes performing an ML model compression using a full ML model and a first compressed ML model that was previously compressed. The ML model compression generates a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model. The second compressed ML model includes a maximized number of weights that are shared with the first ML compressed model. The method also includes determining a difference between the first compressed ML model and the second compressed ML model. The determined difference includes at least one weight update. Further, the method also includes performing one or more actions associated with the second network node based on the determined difference.

Description

[0001] FEEDBACK-BASED MODEL COMPRESSION

[0002] TECHNICAL FIELD

[0003] The present disclosure relates to machine learning, and in particular, to compressing the footprint of machine learning models during model training.

[0004] BACKGROUND

[0005] The Third Generation Partnership Project (3GPP) has developed and is developing standards for Fourth Generation (4G) (also referred to as Long Term Evolution (LTE)) and Fifth Generation (5G) (also referred to as New Radio (NR)) wireless communication systems. Such systems provide, among other features, broadband communication between network nodes, such as base stations, and mobile wireless devices (WD), as well as communication between network nodes and between WDs. The 3GPP is also developing standards for Sixth Generation (6G) wireless communication networks.

[0006] Some conventional wireless communication systems use machine learning (ML) algorithms for making predictions and / or decisions. An ML algorithm may build a model from data, which may be used for making the predictions and / or the decisions. The data that is used to train the model is typically sampled from a distribution at a particular point in time. Over time, the underlying data distributions may change or drift. Therefore, a model may need to be retrained with more recent data, or even re-engineered.

[0007] Real production systems that make use of ML may need to manage retraining of ML models. A mechanism to detect that there is a drift and that the current model is underperforming may be used. Other mechanisms to collect new data, train a new model, evaluate the new model, and potentially replace the current model with the new model may also be used. This kind of continuous retraining can in some systems be performed automatically in a closed loop. Methods and frameworks for managing the design, training, deployment and operations of models are commonly referred to as MLOps. These systems do not have the capacity to store several models simultaneously, which complicates the update process. In addition, some of these systems have strict latency requirements limiting the time in which artificial intelligence support may be turned off during the update.

[0008] Training, Retraining and Inference

[0009] The data part of a ML model may be a set of model weights and a model architecture that determines how the weights are connected. When training a model, the result may include a new set of model weights and sometimes a new model architecture. The model weights may constitute the bulk of the ML model data.

[0010] Training or retraining a model is typically a resource consuming activity, in terms of processing and memory usage. Further, training algorithms may use mathematical optimization, such as gradient descent, to determine a set of model weights that minimize the model’s error or loss. Training algorithms can also utilize parallel and / or distributed computations and specialized hardware such as graphics processing units (GPUs), tensor processing units (TPUs), or field-programmable gate arrays (FPGAs).

[0011] A conventional neural network training algorithm is backpropagation.

[0012] B ackpropagation algorithm iterates over training data, computes the prediction error for test data and performs backwards passes to adjust the network weights in the negative direction of the gradient of the loss function to minimize the error. The training converges when reaching a particular threshold, e.g., a specific error or number of iterations over data.

[0013] Further, there are a few different strategies for when to retrain, such as to retrain when a drift has been detected, when a scheduled retraining is triggered, e.g., once per night or once per week, or when sufficient new data is available. In retraining, the previous model may be completely discarded, and a new model trained on a combination of new and old data. Alternatively, the previous model may primarily be updated with new data.

[0014] In some cases, inference or prediction making using the trained model is not a very resource or time-consuming task, unless the number of model weights is large. Complexity often lies in preparing data before using the model to make a predictions.

[0015] Edge ML

[0016] ML models and processing may be an integral part of modern software in a variety of applications running on cloud services, end user devices, embedded systems, etc. In telecommunication networks, ML is applicable across the entire network, from the top operations support systems (OSS) and / or business support systems (BSS) management systems to other sectors in the radio network. In some cases, close to the network edge, there are very few resources available for training and retraining compared to a central cloud environment.

[0017] Edge ML may refer to the situation when ML algorithms run locally on devices or nodes at a network edge close to the data generating source. These devices and / or nodes are typically resource constrained and often do not have the resource capabilities of training and retraining. As the number of ML use cases increases and as the complexity and size of models grow, local training and retraining becomes even more challenging. Local training may also not have access to all relevant data. An attempt to address these issues is to offload training and retraining to a centrally positioned node with sufficient computing resources and potentially more relevant data available.

[0018] Further, incrementally training and retraining models is an important approach in Edge ML. In some cases, each edge device only has access to its own locally generated data, and this data alone may not capture the broader statistical distribution of the task well. A global model may be trained with data collected from many or all edge devices, and then personalize each edge device model by incrementally training or retraining the model with local data. This is applicable to distributed learning techniques such as federated learning. Even though the training and retraining tasks may be offloaded, there are still challenges. For example, the data (or model weights in the case of federated learning) needs to be transmitted from the device to the central node, the centrally trained or retrained model need to be transmitted to the local device, and a new model update needs to be unpacked and installed onto the local device.

[0019] An example of an edge device may include a radio base station (RBS) that may be equipped with artificial intelligence support to handle a wide variety of tasks. As the devices are resource constrained, the available storage is typically very limited. FIG. 1 shows an example network node such as an RBS that is dependent on one or several models for operations. The models can be trained to support the environment and condition for each specific RBS. The models may be stored in random access memory (RAM) for fast operation.

[0020] The models in some network nodes, such as RBS nodes, typically need to be regularly updated. The update may be handled by a training system (TS) (i.e., network node configured as a training system) as shown in FIG. 2. In some cases, the TS is a continuous TS (CTS).

[0021] Data is collected from the radio base stations, and the models are updated and later re-deployed. The models are typically incrementally updated from previous versions, e.g., re-tuned to handle changes in the operating conditions. FIG. 3 shows a model updating pipeline associated with the TS. The collected data is used to retrain and update the current model. The training data used can be one or more RBSs.

[0022] However, conventional TSs may have issues such as:

[0023] • The size of the model update is very large. • The amount of memory in an edge device being limited. There may not be enough memory to have the current running model and the updated model in memory at the same time.

[0024] • Limited connectivity to the edge devices node put constraints on model size.

[0025] • Update time may interrupt operations of edge devices.

[0026] SUMMARY

[0027] Some embodiments advantageously provide methods, systems, and apparatuses for feedback-based model compression. Some embodiments provide efficient methods and mechanisms to ensure artificial intelligence edge devices (e.g., ML edge devices) are automatically updated online. For example, cyber-physical artificial intelligence systems with constrained resources may be updated. Some other embodiments provide minimization of the size of the ML models. Further, some embodiments describe compressing the result of incremental retraining. Some other embodiments provide an update phase of the MLOps lifecycle.

[0028] Some embodiments provide redundancy in the parameterization of several neural network models, e.g., compressing neural network models that is based on a hashing scheme which groups weights into hash buckets so that connections in the same hash bucket share a single value.

[0029] In some embodiments, a feedback loop is used to steer to the quantizing of the weights to reduce the number of updates. In some other embodiments, a feedback loop is used to steer the number of constant layers associated with a model.

[0030] In some embodiments, smaller model updates are obtained which in turn reduce memory footprint to store updates, increase the number of models that can be pushed to the RBS as the memory use has been optimized, shorten update time (improve downtime), and decrease communication bandwidth requirements (when compared to conventional processes).

[0031] According to one aspect, a method in a first network node configured to communicate at least with a second network node and compress machine learning (ML) models is described. The method includes performing an ML model compression using a full ML model and a first compressed ML model that was previously compressed. The ML model compression generates a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model. The second compressed ML model includes a maximized number of weights that are shared with the first ML compressed model. The method also includes determining a difference between the first compressed ML model and the second compressed ML model. The determined difference includes at least one weight update. Further, the method also includes performing one or more actions associated with the second network node based on the determined difference.

[0032] In some embodiments, the method further includes determining a weight associated with the full ML model (e.g., a weight from the model under training / compression) that has at least an impact on a performance metric. The method also includes for each weight of the full ML model, steering the weight associated with the full ML model towards a corresponding weight in the first compressed ML model and generating a quantized neural network associated with the second compressed ML model based on each steered weight.

[0033] In some other embodiments, the method further includes applying entropy coding to compress the quantized neural network associated with the second compressed ML model.

[0034] In some embodiments, the difference comprises a plurality of weight differences, and the method further includes identifying at least one weight difference of the plurality of weight differences that is smaller than a predetermined threshold and rounding the at least one weight difference to zero.

[0035] In some other embodiments, the number of weight differences of the at least one weight difference of the plurality of weight differences that is rounded to zero is maximized when the number of weights that are shared with the first ML compressed model is maximized.

[0036] In some embodiments, the method further includes performing a training that generates the full ML model using an objective function based on a training loss function and a regularization and incorporating an additional regularization to the objective function, the additional regularization being associated with weight differences that correspond to weights of a previous training.

[0037] In some other embodiments, the training is performed using an input ML model. The input ML model includes a plurality of layers. The method further includes selecting at least one layer of the plurality of layers based on a layer type of the at least one layer. For example, the selection may include performing a comparison between multiple models and concatenating at least one layer. The method also includes performing the training using the input ML model and the selected at least one layer, the training generating the full ML model.

[0038] In some embodiments, the layer type is one of a representational layer and a specific layer.

[0039] In some other embodiments, the representational layer includes a common layer, the common layer corresponding to a layer that is shared at least between the second network node and a third network node.

[0040] In some embodiments, the selected at least one layer is the common layer, and the training is performed using at least the common layer.

[0041] In some other embodiments, the one or more actions include one or both of transmitting the difference between the first compressed ML model and the second compressed ML model to the second network node and triggering the second network node to update a local ML model using the transmitted difference.

[0042] According to another aspect, a first network node configured to communicate at least with a second network node and compress machine learning (ML) models is described. The first network node is configured to perform an ML model compression using a full ML model and a first compressed ML model that was previously compressed. The ML model compression generates a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model. The second compressed ML model includes a maximized number of weights that are shared with the first ML compressed model. The first network node is configured to determine a difference between the first compressed ML model and the second compressed ML model, where the determined difference includes at least one weight update. Further, the first network node is configured to perform one or more actions associated with the second network node based on the determined difference.

[0043] In some embodiments, the first network node is further configured to determine a weight associated with the full ML model that has at least an impact on a performance metric, for each weight of the full ML model, steer the weight associated with the full ML model towards a corresponding weight in the first compressed ML model, and generate a quantized neural network associated with the second compressed ML model based on each steered weight.

[0044] In some other embodiments, the first network node is further configured to apply entropy coding to compress the quantized neural network associated with the second compressed ML model. In some embodiments, the difference includes a plurality of weight differences, and the first network node is further configured to identify at least one weight difference of the plurality of weight differences that is smaller than a predetermined threshold and round the at least one weight difference to zero.

[0045] In some other embodiments, the number of weight differences of the at least one weight difference of the plurality of weight differences that is rounded to zero is maximized when the number of weights that are shared with the first ML compressed model is maximized.

[0046] In some embodiments, the first network node is further configured to perform a training that generates the full ML model using an objective function based on a training loss function and a regularization and incorporate an additional regularization to the objective function. The additional regularization is associated with weight differences that correspond to weights of a previous training.

[0047] In some other embodiments, the training is performed using an input ML model, the input ML model includes a plurality of layers, and the first network node is further configured to select at least one layer of the plurality of layers based on a layer type of the at least one layer and perform the training using the input ML model and the selected at least one layer. The training generates the full ML model.

[0048] In some embodiments, the layer type is one of a representational layer and a specific layer.

[0049] In some other embodiments, the representational layer includes a common layer, where the common layer corresponds to a layer that is shared at least between the second network node and a third network node.

[0050] In some embodiments, the selected at least one layer is the common layer, and the training is performed using at least the common layer.

[0051] In some other embodiments, the one or more actions include one or both of transmitting the difference between the first compressed ML model and the second compressed ML model to the second network node and triggering the second network node to update a local ML model using the transmitted difference.

[0052] BRIEF DESCRIPTION OF THE DRAWINGS

[0053] A more complete understanding of the present embodiments, and the attendant advantages and features thereof, will be more readily understood by reference to the following detailed description when considered in conjunction with the accompanying drawings wherein: FIG. 1 shows an example network node such as an RBS that is dependent on one or several models for operations;

[0054] FIG. 2 shows an example network node (e.g., a training system (TS)) configured to perform model updates.

[0055] FIG. 3 shows an example model updating pipeline associated with a network node such as TS;

[0056] FIG. 4 is a block diagram of a network node configured to communicate at least with another network node according to some embodiments of the present disclosure;

[0057] FIG. 5 is a flowchart of an exemplary process in a network node according to some embodiments of the present disclosure;

[0058] FIG. 6 shows an example compression of ML models according to some embodiments of the present disclosure;

[0059] FIG. 7 shows an example quantization process according to some embodiments of the present disclosure;

[0060] FIG. 8 shows another example compression of ML models according to some embodiments of the present disclosure;

[0061] FIG. 9 shows yet another example compression of ML models according to some embodiments of the present disclosure;

[0062] FIG. 10 shows an example per-weight feedback-based compression process according to some embodiments of the present disclosure;

[0063] FIG. 11 shows example layers of a neural network model according to some embodiments of the present disclosure;

[0064] FIG. 12 shows an example compression of ML models using layer selection according to some embodiments of the present disclosure;

[0065] FIG. 13 shows example layers of a neural network model including common layers according to some embodiments of the present disclosure; and

[0066] FIG. 14 shows an example compression of ML models using selection of common layers according to some embodiments of the present disclosure.

[0067] DETAILED DESCRIPTION

[0068] Before describing in detail exemplary embodiments, it is noted that the embodiments reside primarily in combinations of apparatus components and processing steps related to feedback-based model compression. Accordingly, components have been represented where appropriate by conventional symbols in the drawings, showing only those specific details that are pertinent to understanding the embodiments so as not to obscure the disclosure with details that will be readily apparent to those of ordinary skill in the art having the benefit of the description herein. Like numbers refer to like elements throughout the description.

[0069] As used herein, relational terms, such as “first” and “second,” “top” and “bottom,” and the like, may be used solely to distinguish one entity or element from another entity or element without necessarily requiring or implying any physical or logical relationship or order between such entities or elements. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the concepts described herein. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises,” “comprising,” “includes” and / or “including” when used herein, specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0070] In embodiments described herein, the joining term, “in communication with” and the like, may be used to indicate electrical or data communication, which may be accomplished by physical contact, induction, electromagnetic radiation, radio signaling, infrared signaling or optical signaling, for example. One having ordinary skill in the art will appreciate that multiple components may interoperate and modifications and variations are possible of achieving the electrical and data communication.

[0071] In some embodiments described herein, the term “coupled,” “connected,” and the like, may be used herein to indicate a connection, although not necessarily directly, and may include wired and / or wireless connections.

[0072] The term “network node” used herein can be any kind of node comprised in a network which may further comprise any of an edge device or computing node, e.g., server, including but not limited to a core network node, wireless communication network base station (BS), radio base station (RBS), base transceiver station (BTS), base station controller (BSC), radio network controller (RNC), g Node B (gNB), evolved Node B (eNB or eNodeB), Node B, multi-standard radio (MSR) radio node such as MSR BS, multi-cell / multicast coordination entity (MCE), integrated access and backhaul (IAB) node, relay node, donor node controlling relay, radio access point (AP), transmission points, transmission nodes, Remote Radio Unit (RRU) Remote Radio Head (RRH), a core network node (e.g., mobile management entity (MME), self-organizing network (SON) node, a coordinating node, positioning node, MDT node, etc.), an external node (e.g., 3rd party node, a node external to the current network), nodes in distributed antenna system (DAS), a spectrum access system (SAS) node, an element management system (EMS), a training system (TS), a continuous TS, etc. The network node may also comprise test equipment.

[0073] Note that although terminology from one particular wireless system, such as, for example, 3GPP LTE and / or New Radio (NR), may be used in this disclosure, this should not be seen as limiting the scope of the disclosure to only the aforementioned system. Other wireless systems, including without limitation Wide Band Code Division Multiple Access (WCDMA), Worldwide Interoperability for Microwave Access (WiMax), Ultra Mobile Broadband (UMB) and Global System for Mobile Communications (GSM), may also benefit from exploiting the ideas covered within this disclosure. It is also contemplated that the disclosure herein can be implemented in other technologies where ML is used and where model training is performed. In other words, the use of communication networks to describe implementations is for convenience and ease of understanding and is not intended to limit applications solely to communication network modeling.

[0074] Note further, that functions described herein as being performed by a wireless device or a network node may be distributed over a plurality of wireless devices and / or network nodes. In other words, it is contemplated that the functions of the network node and wireless device described herein are not limited to performance by a single physical device and, in fact, can be distributed among several physical devices.

[0075] In some embodiments, the term “model” is used and may refer to an ML model, an artificial intelligence model, a neural network model, etc. In some embodiments, the term neural network may refer to a model. A neural network may include layers which may be connected to other layers. A layer may include one or more neurons or nodes which may be interconnected. Weights may be assigned to interconnections. A layer may be an input layer, a hidden layer, or an output layer. Layers may also be representational, specific, common, etc.

[0076] Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this disclosure belongs. It will be further understood that terms used herein should be interpreted as having a meaning that is consistent with their meaning in the context of this specification and the relevant art and will not be interpreted in an idealized or overly formal sense unless expressly so defined herein.

[0077] Referring again to the drawing figures, in which like elements are referred to by like reference numerals, there is shown in FIG. 4 a block diagram of a network node 16 configured to communicate at least with another network node 16 according to some embodiments of the present disclosure. More specifically, communication system 10 may comprise a plurality of network nodes 16a, 16b, 16c, etc. (referred to collectively as network nodes 16). In some embodiments, a network node 16 (e.g., network node 16a) may be configured as a training system and to communicate with another network node (e.g., network node 16b such as an RBS) and / or other node / device. Each network node 16 may be connectable to via a core network over a wired or wireless connection.

[0078] A network node 16 may be configured to include a node management unit 32 which is configured to perform any step and / or task and / or process and / or method and / or feature described in the present disclosure, e.g., network node functions.

[0079] Network node 16 provided in a communication system 10 may also include hardware 58 enabling it to communicate with other components of communication system 10. The hardware 58 may include a communication interface 60 for setting up and maintaining a wired or wireless connection with an interface of a different communication device of the communication system 10 (such as another network node 16 (e.g., network node 16b), another network node configured as an edge device, an RBS, etc.), as well as a radio interface 62 for setting up and maintaining at least a wireless connection 64 with any other component of communication system 10. The radio interface 62 may be formed as or may include, for example, one or more RF transmitters, one or more RF receivers, and / or one or more RF transceivers.

[0080] In the embodiment shown, the hardware 58 of the network node 16 further includes processing circuitry 68. The processing circuitry 68 may include a processor 70 and a memory 72. In particular, in addition to or instead of a processor, such as a central processing unit, and memory, the processing circuitry 68 may comprise integrated circuitry for processing and / or control, e.g., one or more processors and / or processor cores and / or FPGAs (Field Programmable Gate Array) and / or ASICs (Application Specific Integrated Circuitry) adapted to execute instructions. The processor 70 may be configured to access (e.g., write to and / or read from) the memory 72, which may comprise any kind of volatile and / or nonvolatile memory, e.g., cache and / or buffer memory and / or RAM (Random Access Memory) and / or ROM (Read-Only Memory) and / or optical memory and / or EPROM (Erasable Programmable Read-Only Memory).

[0081] Thus, the network node 16 further has software 74 stored internally in, for example, memory 72, or stored in external memory (e.g., database, storage array, network storage device, etc.) accessible by the network node 16 via an external connection. The software 74 may be executable by the processing circuitry 68. The processing circuitry 68 may be configured to control any of the methods and / or processes described herein and / or to cause such methods, and / or processes to be performed, e.g., by network node 16. Processor 70 corresponds to one or more processors 70 for performing network node 16 functions described herein. The memory 72 is configured to store data, programmatic software code and / or other information described herein. In some embodiments, the software 74 may include instructions that, when executed by the processor 70 and / or processing circuitry 68, causes the processor 70 and / or processing circuitry 68 to perform the processes described herein with respect to network node 16.

[0082] Further, processing circuitry 68 of the network node 16 may include training module 100 which is configured to perform any step and / or task and / or process and / or method and / or feature described in the present disclosure, e.g., training functions. Processing circuitry 68 may also include compression module 102 which is configured to perform any step and / or task and / or process and / or method and / or feature described in the present disclosure, e.g., model compression functions. Processing circuitry 68 may also include difference module 104 which is configured to perform any step and / or task and / or process and / or method and / or feature described in the present disclosure, e.g., determining a difference between models. Processing circuitry 68 may also include layer selection module 106 which is configured to perform any step and / or task and / or process and / or method and / or feature described in the present disclosure, e.g., layer selection functions. In some embodiments, any of steps and / or tasks and / or processes and / or methods and / or features performed by any of training module 100, compression module 102, difference module 104, and layer selection module 106 may be performed by node management unit 32 or any other component of network node 16.

[0083] Although FIG. 4 shows various “units” such as node management unit 32 as being within a respective processor, it is contemplated that these units may be implemented such that a portion of the unit is stored in a corresponding memory within the processing circuitry. In other words, the units may be implemented in hardware or in a combination of hardware and software within the processing circuitry. FIG. 5 is a flowchart of an exemplary process in a network node 16 (e.g., a first network node 16). One or more blocks described herein may be performed by one or more elements of network node 16 such as by one or more of processing circuitry 68 (including the node management unit 32), processor 70, radio interface 62 and / or communication interface 60. Network node 16 such as via processing circuitry 68 and / or processor 70 and / or radio interface 62 and / or communication interface 60 is configured to perform (Block S100) an ML model compression using a full ML model and a first compressed ML model that was previously compressed. The ML model compression generates a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model. The second compressed ML model includes a maximized number of weights 114 that are shared with the first ML compressed model. Network node 16 is further configured to determine (Block S102) a difference between the first compressed ML model and the second compressed ML model. The determined difference includes at least one weight update. Further, network node 16 is further configured to perform (Block S104) one or more actions associated with the second network node 16 based on the determined difference.

[0084] In some embodiments, the method further includes determining a weight 114 associated with the full ML model (e.g., a weight 114 from the model under training / compression) that has at least an impact on a performance metric. The method also includes for each weight 114 of the full ML model, steering the weight 114 associated with the full ML model towards a corresponding weight 114 in the first compressed ML model and generating a quantized neural network associated with the second compressed ML model based on each steered weight 114.

[0085] In some other embodiments, the method further includes applying entropy coding to compress the quantized neural network associated with the second compressed ML model.

[0086] In some embodiments, the difference comprises a plurality of weight differences, and the method further includes identifying at least one weight difference of the plurality of weight differences that is smaller than a predetermined threshold and rounding the at least one weight difference to zero.

[0087] In some other embodiments, the number of weight differences of the at least one weight difference of the plurality of weight differences that is rounded to zero is maximized when the number of weights 114 that are shared with the first ML compressed model is maximized. In some embodiments, the method further includes performing a training that generates the full ML model using an objective function based on a training loss function and a regularization and incorporating an additional regularization to the objective function, the additional regularization being associated with weight differences that correspond to weights of a previous training.

[0088] In some other embodiments, the training is performed using an input ML model. The input ML model includes a plurality of layers 110. The method further includes selecting at least one layer 110 of the plurality of layers 110 based on a layer type of the at least one layer 110. For example, the selection may include performing a comparison between multiple models and concatenating at least one layer 110. The method also includes performing the training using the input ML model and the selected at least one layer 110, the training generating the full ML model.

[0089] In some embodiments, the layer type is one of a representational layer 116 and a specific layer 118.

[0090] In some other embodiments, the representational layer 116 includes a common layer 120, the common layer 120 corresponding to a layer that is shared at least between the second network node and a third network node.

[0091] In some embodiments, the selected at least one layer 110 is the common layer 120, and the training is performed using at least the common layer 120.

[0092] In some other embodiments, the one or more actions include one or both of transmitting the difference between the first compressed ML model and the second compressed ML model to the second network node 16 and triggering the second network node 16 to update a local ML model using the transmitted difference.

[0093] Having described the general process flow of arrangements of the disclosure and having provided examples of hardware and software arrangements for implementing the processes and functions of the disclosure, the sections below provide details and examples of arrangements for feedback-based model compression.

[0094] In some embodiments, the term model is used with a subindex. Subindex “f” refers to “full model”, and subindex “c” refers to “compressed model”. A full ML model may be referred to as Modelf (tk+i) or Modelf (tk). ModeL (tk) may refer to a first compressed ML model that was previously compressed, and ModeL (tk+i) may refer to a second compressed ML model. Further, A(tk+i) may be referred to a difference or a delta. Some embodiments provide a method to compress incrementally trained ML models such as neural network models, e.g., to reduce the memory footprint, payload, and update time. In some other embodiments, models may be incrementally retrained with new data. That is, weights of a new model may initially be a copy of the previous model weights, and then incrementally updated during retraining. Some embodiments provide one or more ways to improve delta generation by minimizing the amount of change that is applied to a model when retraining. In some embodiments, minimizing the amount of change applied to a model refers to maximizing (e.g., increasing) the number of weights that a second compressed ML model shares with a first compressed ML model (i.e., a model previously compressed). By maximizing the number of weights that are shared, the size of the difference between the first and second compressed ML models may be reduced. In some embodiments, sharing weights may refer to weights of the first compressed ML model being identical to the corresponding weights of the second compressed ML model. In some embodiments, sharing weights may refer to the difference between weights of the first compressed ML model and the corresponding weights of the second compressed ML model being less than or equal to a predetermined threshold.

[0095] In some embodiments, network node 16 is configured to preform one or more actions based on the determined difference between models, which may include without being limited to transmitting the difference to an edge network node 16 such as an RBS and / or causing the edge network node 16 to update its local model or perform other actions.

[0096] Some embodiments provide one or more advantages and / or technical effects such as reduction of memory footprint, payload and update time associated with updating an RBS with an updated compressed ML model by transmitting and / or determining a difference between the first compressed ML model and the second compressed ML model where network node 16 generates the second compressed ML model at least by performing a constrained quantization of a full ML model and a first compressed ML model. The second compressed ML model includes a maximized number of weights that are shared with the first ML compressed model. For example, by determining the difference between the first compressed ML model and the second compressed ML model which resembles the first compressed model as close as possible, the network node 16 may reduce the size of the difference that is transmitted to an edge network node such an RBS, thereby reducing the memory footprint on the RBS and time required for the transmission of the difference. FIG. 6 shows an example compression of ML model(s) according to some embodiments of the present disclosure. More specifically, network node 16 may be configured as a TS to perform training and / or compression. Training module 100 receives an existing modelf (tk) from time tk and tunes it using data received up to time tk+i. Training module outputs a full model, i.e., modelf (tk+i). Once the updated modelf (tk+i), including layers 110 and neurons 112, is completed, it is fed into the next step in the pipeline (i.e., compression module 102) which uses quantization to reduce the size of modelf (tk+i). The compressed model, i.e., modeL (tk+i), is then sent to another network node 16 (e.g., an RBS). That is, training or retraining pipeline shown as training system may be updated with an additional step / module (i.e., compress module 102), which may be configured to reduce the memory footprint.

[0097] Quantization may be used to compress a model, where the memory footprint of the parameters is reduced. Using quantization, floating point weights with longer wordlengths may be transformed into fixed point representation with shorter word-length, which may have more than one advantage. It reduces the amount of storage and energy consumption, since energy scales (worse than linear) with word-length, and fixed-point arithmetic is more efficient than floating point. In some embodiments, quantization may lead to a performance cost, e.g., the more quantization, the higher the cost. One goal of the embodiments is to find a neural network or model with significantly quantized weights at an acceptable performance loss.

[0098] FIG. 7 shows an example quantization process according to some embodiments of the present disclosure. Network node 16 via node management unit 32 and / or compression module 102 may perform quantization of weights 114. For example, weight 114 of a 32- bit floating point (FP32) value (i.e., 0.34) may be quantized to an 8-bit integer (INT8) value (i.e., 64). Any other weight 114 of FP32 value may be quantized to a corresponding weight 114 of INT8 value as shown. That is, a model memory footprint is reduced by quantizing the individual weights 114 from 32-bit FP values to INT8, which results in a four-fold size reduction. A goal may be to perform the optimal quantization, where optimal means that the behavior of the quantized network should resemble the original network as close as possible, for some metric. That is, resembling the original network as close as possible may refer to the quantized network including a maximized number of parameters such as weights that are shared with the original network.

[0099] FIG. 8 shows another example compression of ML models according to some embodiments of the present disclosure. In order to further improve the compression, a difference module 104 may be configured to determine the difference between the current and updated model, i.e., modelc (tk) and modelc (tk+i). In some embodiments, only the updated weights are transmitted to another network node 16, e.g., RBS. Difference module 104 may be referred to as “Diff.” In some other embodiments, instead of transmitting the new weights to the other network nodes 16 (e.g., edge devices), a delta-update A (tk+i) is transmitted.

[0100] In some embodiments, for the weights 114 where the update is zero, network node 16 may not transmit any value. For example, if only 10% of the weights 114 were modified, only these updates may be transmitted to other network nodes 16 (e.g.,, edge devices, RBSs, etc.). Compression can be further improved by applying an entropy coding scheme, where common symbols (such as smaller delta values) are represented by the minimum number of bits. In addition, the method may also supply the information needed to insert the (possibly zero-valued) weights in the correct places.

[0101] Feedback quantization to reduce delta

[0102] Some embodiments provide optimization of the quantization to increase the number of weight updates that become zero. That is, the quantization may be performed with the objective to end up with model layers 110 that are close to previously quantized model layers 110. FIG. 9 shows another example compression of ML models using a feedback loop according to some embodiments of the present disclosure. The method may include obtaining an updated quantized weight matrix that resembles the previous version as much as possible. In some embodiments, to address weights (e.g., all weights) being modified in the update process, a feedback connection between modelc (tk) and compression module 102 may be established, which adds the previous compressed model modeL (tk) to the compression-step. Compression is performed with the additional condition that the resulting new compressed modeL (tk+i) is to be as similar to the previous one as possible.

[0103] FIG. 10 shows an example per-weight feedback-based compression process according to some embodiments of the present disclosure. In this example, the quantization described may be referred to a constrained quantization, e.g., where the quantization is constrained with respect to the previous compressed model modeL (tk). When reducing the precision from FP32 values to INT8, network node may truncate in way to increase similarity. This can be formulated as an optimization problem with a given budget for deviations from a “perfect” truncation. In some embodiments, the term truncate may refer to reducing the number of bits from a value to another such as from 32 bits to 8 bits. In some other embodiments, the performance of the model should be used as a value function.

[0104] In some embodiments, network node 16 may be configured to find the weight 114 that has the least impact on the performance metric, steer this weight 114 towards the corresponding weight 114 in the previously quantized neural network (i.e., model), and repeat the process until all weights 114 are quantized. In some embodiments, the term steer or steering refers to equating weight 114 to the corresponding weight 114. In some other embodiments, steering refers to changing the weight 114 to be close to the corresponding weight 114, e.g., the difference between both weights is less than a predetermine difference threshold. After optimization, a new model (e.g., quantized network) that is “close” to the original is obtained, since it shares a number of weights 114. Entropy coding to compress the quantized network. Entropy coding may comprise representing common symbols (such as smaller delta values) by a minimum number of bits. Specifically, since the new and original models (e.g., neural networks) are close, the difference, the “delta” between models is determined and compressed. In some embodiments, delta is ideally composed of zeros and small values that appear frequently, so the entropy of the delta or difference is low. In some other embodiments, the quantized network / model may be applied layer by layer, as a per layer basis may result in a “soft” move from the old to the new weights 114. In some embodiments, a validation step for all these intermediate networks / models may be completed.

[0105] In some embodiments, using a Diff-step (i.e., determining a difference between models) to produce a model delta-update may be used to reduce transport bandwidth by using a delta approach and not sending the full model. The delta between a binary representation of two floating point numbers may be typically large, no matter if the numerical difference is small, which may lead to large delta-updates. An iterative process including the following may be performed:

[0106] • Calculating a quantization factor as a function of lossy delta between the modelf at times tk and tk+i using SZ compression with a given error bound.

[0107] • Finding an appropriate error bound which results in good compression while not deteriorating the model performance.

[0108] • The error bound may be then applied to all layers.

[0109] In some other embodiments provide operating on a per-weight basis, where small deltas (i.e., predetermined differences) are identified and basically rounded off to zero.

[0110] Feedback-based training to reduce delta In addition to the feedback-based quantization where the quantized weight update is steered towards being zero, the training module 100 may be configured to avoid updating the less significant weights. This can be done using a modified training loss.

[0111] In supervised learning, n samples of input, output pairs (x,, yi), i E {1, ... , n}, may be used, and the task is to learn a model f with model weights w that takes x as input and predicts y. Stochastic Gradient Descent (SGD) is a fundamental algorithm for training neural networks that seeks to find the weights w that minimize a training objective function. The objective function in supervised learning can be formulated as follows, where L is a training loss function, and R is a regularization or penalty function and a controls the regularization strength.

[0112] E(w) = ^i=^{yi.f(xd) + aR(w)

[0113] A purpose of regularization is to keep the weights from growing indefinitely, to prevent overfitting. Regularization functions may be, for example:

[0114] The objective function may be modified by incorporating additional regularization or penalty on large weight deltas compared to the previously trained model weights. A balance may be stricken between good predictive model performance while keeping the delta of the weights from the previous model small (e.g., less than a predetermined threshold).

[0115] The new weights w can be expressed as the previous model weights wpplus the delta 8, as w = wp+ 8. Each individual weight difference may be referred to as 8t, where t G {1, . . , T] and T is the number of weights.

[0116] The objective function may be formulated using the additional regularization term where p determines the strength of U, for example p = (1 — a).

[0117] Different functions U that constrain 8 may be selected, depending on what information is available at training. For example:

[0118] 1. U (8) = J 18t| , total (absolute) weights difference.

[0119] 2. U (8) = v(8t) total weights compression cost difference, where the compression cost for 8tis given by the function v. Typical choice for v is a differentiable and monotonically increasing function of the (absolute) difference.

[0120] Feedback-based layer-freeze to reduce delta

[0121] For many deep neural networks, the layers play different roles. For example, for convolutional neural network used in image recognition, the first layers extract image features such as lines, circles, etc., which are then used by the subsequent layers as elements that represents a cat or a dog. Similarly, in large language models there is the concept of a foundation model that is trained on a large corpus. This model can then be retrained for a specialized purpose (e.g., a support chat hot) only modifying the last layers of the model.

[0122] FIG. 11 shows example layers of a neural network model according to some embodiments of the present disclosure. Layers 110 may be representational layers 116 and specific layers 118. In some embodiments, the representational layers 116 may extract features from the input data. These features may then be used by the specific layers 118 to perform prediction and / or classification, or any other functions. In some embodiments, representational layers and / or specific layers 118 (e.g., the border between feature generating and feature consuming layers) may be used treat neural networks and have existing networks adopted to new applications.

[0123] Further, categorizing or determining layer types may be useful in reducing the size of the delta or output of the difference module 104. Network node 16 may identify, either dynamically or statically, which layers are subject to retraining. The training system shown in FIG. 14 may be augmented with a feedback loop that dynamically selects which layers 110 of the model to freeze. In some embodiments, a neural network model may for some use case be divided into representational layers 116, which may rarely need to be updated and specific layers 118 which may be regularly re-tuned.

[0124] FIG. 12 shows an example compression of ML models using layer selection according to some embodiments of the present disclosure. The training system may be augmented with another feedback loop that dynamically selects layers 110 such as representational layers 116. In some embodiments, the selected layers 110 are not used for training and / or updating a model, instead the unselected layers 110 are used. Any of the steps associated with this feedback loop may be performed by layer selection module 106. Training and updating of a model for a specific network node 16 (e.g., RBS) is performed in addition to fixating one or more representational layers 116 in the model to reduce the size of the delta output A (tk+i). Input to training module may include training data (tk+i) and the previous model parameters associated to modelf (tk). When training an update of the model, the layer selection module 106 (and / or training module 100) can choose to keep then first n representational layers 116 of the previous model fixed and concentrate learning efforts on the remaining specific layers 118. The performance of the new model is measured, and based on the resulting metrics the training could be repeated with a different value of n, with the goal of finding an / / -value that gives sufficient performance while keeping the first n layers unchanged. After training, network node 16 transmits only the updated specific layers 118 to the other network node 16 (e.g., RBS). Any of the steps of the process shown in FIG. 17 (or any other embodiments of the present disclosure) may be based on plain linear search, bisection, or heuristics.

[0125] Feedback common layer selection to reduce delta

[0126] In some embodiments, models from multiple edge network nodes 16 such as base stations may be retrained using the same TS (e.g., network node 16 of FIG. 12). Edge network nodes 16 of the same type that share the same model architecture (e.g., where the neural network structure is identical) can benefit from combined training. That is, data from all similar edge network nodes 16 can be used to train other edge network nodes 16. FIG. 13 shows example layers 110 of a neural network model including common layers 120 according to some embodiments of the present disclosure. Common layers 120 may refer to representational layers 116 that are shared by more than one device such as edge network node 16 (e.g., RBS, base stations, etc.).

[0127] In some embodiments, network node 16 (e.g., configured as TS) may train one common model on all data from all edge network nodes 16 (e.g., RBS, bases stations, radio nodes, etc.) and split this neural network into a set of first layers, i.e., representational layers 116, and second layers that are the remaining layers, i.e., specific layers 118. A new sub-category of the representational layers 116 is added and is referred to as common layers 120. As a result, a set of specific models that share the first set of layers is obtained. In some other embodiments, this first set of layers (i.e., common layers 120) is trained on all available data, and is therefore functionally complete and sufficient, and will not change over time, or at all. Therefore, delta-updates of the custom models may only cover the remaining specific layers 118, i.e., a delta update covers only a subset of all layers 110 and is therefore smaller in size. In some embodiments, common layers 120 may be useful for more than one RBS, such as without modification. In some other embodiments, for a specific RBS or set of RBSs, representational layers may not need to be modified, i.e., specific layers may be the only ones that adopt any changes. Network node 16 (e.g., TS) may extract the initial common layers 120 of the globally trained model to be used as the initial layers for every individual local model that we then build. A globally trained model may be a model trained by network node 16 (e.g., TS) based on all input data (e.g., from each RBS of a group of RBSs). The local models (i.e., in the edge network nodes 16 such as RBSs) may have several layers that are the same. Since the common layers 120 are the same, delta updates will be zero or close to zero for all the local models for these layers. The common layers 120 may be trained on all available data, and therefore generate useful features for various scenarios, thereby being sufficient and stable over time. The remaining layers 110, that will be trained specifically for each local model, may also use delta coding, but the difference may depend on the local changes, i.e., per base station.

[0128] Network node 16 (e.g., TS) may update the global model if the overall data characteristics have changed over a longer period. To determine how many layers may be common, heuristics may be used, or several different local models may be trained with different number of common layers 120 from the global model. The best tradeoff between compression and model performance may also be determined.

[0129] FIG. 14 shows an example compression of ML models using selection of common layers 120 according to some embodiments of the present disclosure. In this nonlimiting example, models are trained independently for a plurality of RBSs, while relying on a common model or (smaller set of models) trained on all available data. Training module 100 may have access to the trained parameters from a common model based on all training data associated with the common layer 120, as well as the parameters from the previous specific model for the same RBS (i.e., representational layers 116). Training module 100 may select how many representational layers 116 to copy from the common model associated with the common layers 120, as well as how many layers to copy from the previous specific model associated with the specific layers 118. The training is then optimized towards a solution with sufficient performance where the layers from the common and previous specific models are used to minimize the number of updated parameters in the new model.

[0130] As will be appreciated by one of skill in the art, the concepts described herein may be embodied as a method, data processing system, computer program product and / or computer storage media storing an executable computer program. Accordingly, the concepts described herein may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects all generally referred to herein as a “circuit” or “module.” Any process, step, action and / or functionality described herein may be performed by, and / or associated to, a corresponding module, which may be implemented in software and / or firmware and / or hardware. Furthermore, the disclosure may take the form of a computer program product on a tangible computer usable storage medium having computer program code embodied in the medium that can be executed by a computer. Any suitable tangible computer readable medium may be utilized including hard disks, CD-ROMs, electonic storage devices, optical storage devices, or magnetic storage devices.

[0131] Some embodiments are described herein with reference to flowchart illustrations and / or block diagrams of methods, systems and computer program products. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer (to thereby create a special purpose computer), special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in the flowchart and / or block diagram block or blocks.

[0132] These computer program instructions may also be stored in a computer readable memory or storage medium that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer readable memory produce an article of manufacture including instruction means which implement the function / act specified in the flowchart and / or block diagram block or blocks.

[0133] The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions / acts specified in the flowchart and / or block diagram block or blocks.

[0134] It is to be understood that the functions / acts noted in the blocks may occur out of the order noted in the operational illustrations. For example, two blocks shown in succession may in fact be executed substantially concurrently or the blocks may sometimes be executed in the reverse order, depending upon the functionality / acts involved. Although some of the diagrams include arrows on communication paths to show a primary direction of communication, it is to be understood that communication may occur in the opposite direction to the depicted arrows.

[0135] Computer program code for carrying out operations of the concepts described herein may be written in an object oriented programming language such as Python, Java® or C++. However, the computer program code for carrying out operations of the disclosure may also be written in conventional procedural programming languages, such as the "C" programming language. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer. In the latter scenario, the remote computer may be connected to the user's computer through a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).

[0136] Many different embodiments have been disclosed herein, in connection with the above description and the drawings. It will be understood that it would be unduly repetitious and obfuscating to literally describe and illustrate every combination and subcombination of these embodiments. Accordingly, all embodiments can be combined in any way and / or combination, and the present specification, including the drawings, shall be construed to constitute a complete written description of all combinations and subcombinations of the embodiments described herein, and of the manner and process of making and using them, and shall support claims to any such combination or subcombination.

[0137] It will be appreciated by persons skilled in the art that the embodiments described herein are not limited to what has been particularly shown and described herein above. In addition, unless mention was made above to the contrary, it should be noted that all of the accompanying drawings are not to scale. A variety of modifications and variations are possible in light of the above teachings without departing from the scope of the following claims.

Claims

What is claimed is:

1. A method in a first network node (16) configured to communicate at least with a second network node (16) and compress machine learning, ML, models, the method comprising: performing (S100) an ML model compression using a full ML model and a first compressed ML model that was previously compressed, the ML model compression generating a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model, the second compressed ML model including a maximized number of weights (114) that are shared with the first ML compressed model; determining (S 102) a difference between the first compressed ML model and the second compressed ML model, the determined difference comprising at least one weight update; and performing (S104) one or more actions associated with the second network node (16) based on the determined difference.

2. The method of Claim 1, wherein the method further includes: determining a weight (114) associated with the full ML model that has at least an impact on a performance metric; for each weight (114) of the full ML model, steering the weight (114) associated with the full ML model towards a corresponding weight (114) in the first compressed ML model; and generating a quantized neural network associated with the second compressed ML model based on each steered weight (114).

3. The method of Claim 2, wherein the method further includes: applying entropy coding to compress the quantized neural network associated with the second compressed ML model.

4. The method of any one of Claims 1-3, wherein the difference comprises a plurality of weight differences, and the method further includes: identifying at least one weight difference of the plurality of weight differences that is smaller than a predetermined threshold; and rounding the at least one weight difference to zero.

5. The method Claim 4, wherein the number of weight differences of the at least one weight difference of the plurality of weight differences that is rounded to zero is maximized when the number of weights (114) that are shared with the first ML compressed model is maximized.

6. The method of any one of Claims 1-5, wherein the method further includes: performing a training that generates the full ML model using an objective function based on a training loss function and a regularization; and incorporating an additional regularization to the objective function, the additional regularization being associated with weight differences that correspond to weights (114) of a previous training.

7. The method of Claim 6, wherein the training is performed using an input ML model, the input ML model comprises a plurality of layers, and the method further includes: selecting at least one layer (110) of the plurality of layers (110) based on a layer type of the at least one layer (110); and performing the training using the input ML model and the selected at least one layer (110), the training generating the full ML model.

8. The method of Claim 7, wherein the layer type is one of a representational layer (116) and a specific layer (118).

9. The method of Claim 8, wherein the representational layer (116) includes a common layer (120), the common layer (120) corresponding to a layer (110) that is shared at least between the second network node (16) and a third network node (16).

10. The method of Claim 9, wherein the selected at least one layer (110) is the common layer (120), and the training is performed using at least the common layer (120).

11. The method of any one of Claims 1-10, wherein the one or more actions include one or both of:transmitting the difference between the first compressed ML model and the second compressed ML model to the second network node (16); and triggering the second network node (16) to update a local ML model using the transmitted difference.

12. A first network node (16) configured to communicate at least with a second network node (16) and compress machine learning, ML, models, the first network node (16) being configured to: perform an ML model compression using a full ML model and a first compressed ML model that was previously compressed, the ML model compression generating a second compressed ML model at least by performing a constrained quantization of the full ML model based on the first compressed ML model, the second compressed ML model including a maximized number of weights (114) that are shared with the first ML compressed model; determine a difference between the first compressed ML model and the second compressed ML model, the determined difference comprising at least one weight update; and perform one or more actions associated with the second network node (16) based on the determined difference.

13. The first network node (16) of Claim 12, wherein the first network node (16) is further configured to: determine a weight (114) associated with the full ML model that has at least an impact on a performance metric; for each weight (114) of the full ML model, steer the weight (114) associated with the full ML model towards a corresponding weight (114) in the first compressed ML model; and generate a quantized neural network associated with the second compressed ML model based on each steered weight (114).

14. The first network node (16) of Claim 13, wherein the first network node (16) is further configured to: apply entropy coding to compress the quantized neural network associated with the second compressed ML model.

15. The first network node (16) of any one of Claims 12-14, wherein the difference comprises a plurality of weight differences, and the first network node (16) is further configured to: identify at least one weight difference of the plurality of weight differences that is smaller than a predetermined threshold; and round the at least one weight difference to zero.

16. The first network node (16) of Claim 15, wherein the number of weight differences of the at least one weight difference of the plurality of weight differences that is rounded to zero is maximized when the number of weights (114) that are shared with the first ML compressed model is maximized.

17. The first network node (16) of any one of Claims 12-16, wherein the first network node (16) is further configured to: perform a training that generates the full ML model using an objective function based on a training loss function and a regularization; and incorporate an additional regularization to the objective function, the additional regularization being associated with weight differences that correspond to weights (114) of a previous training.

18. The first network node (16) of Claim 17, wherein the training is performed using an input ML model, the input ML model comprises a plurality of layers (110), and the first network node (16) is further configured to: select at least one layer (110) of the plurality of layers (110) based on a layer type of the at least one layer (110); and perform the training using the input ML model and the selected at least one layer (110), the training generating the full ML model.

19. The first network node (16) of Claim 18, wherein the layer type is one of a representational layer (116) and a specific layer (118).

20. The first network node (16) of Claim 19, wherein the representational layer (116) includes a common layer (120), the common layer (120) corresponding to a layer(110) that is shared at least between the second network node (16) and a third network node (16).

21. The first network node (16) of Claim 20, wherein the selected at least one layer (110) is the common layer (120), and the training is performed using at least the common layer (120).

22. The first network node (16) of any one of Claims 12-21, wherein the one or more actions include one or both of: transmitting the difference between the first compressed ML model and the second compressed ML model to the second network node (16); and triggering the second network node (16) to update a local ML model using the transmitted difference.

Images