Prosecution Insights
Last updated: November 04, 2026
Application No. 18/737,953

MODEL TRAINING METHOD AND FACE RECOGNITION METHOD BASED ON ADAPTIVE SPLIT LEARNING-FEDERATED LEARNING

Non-Final OA §103
Filed
Jun 08, 2024
Priority
Apr 02, 2022 — CN 2022103453239 +1 more
Examiner
SESAY, HASSAN RAMADAN
Art Unit
2146
Tech Center
2100 — Computer Architecture & Software
Assignee
Xidian University
OA Round
1 (Non-Final)
0%
Grant Probability
At Risk
1-2
OA Rounds
6m
Est. Remaining
0%
With Interview

Examiner Intelligence

Grants only 0% of cases
0%
Career Allowance Rate
0 granted / 1 resolved
-55.0% vs TC avg
Minimal +0% lift
Without
With
+0.0%
Interview Lift
resolved cases with interview
Typical timeline
2y 11m
Avg Prosecution
12 currently pending
Career history
16
Total Applications
across all art units

Statute-Specific Performance

§101
34.9%
-5.1% vs TC avg
§103
39.5%
-0.5% vs TC avg
§102
11.6%
-28.4% vs TC avg
§112
14.0%
-26.0% vs TC avg
Black line = Tech Center average estimate • Based on career data from 1 resolved cases

Office Action

§103
DETAILED ACTION Notice of Pre-AIA or AIA Status The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA . Drawings New corrected drawings in compliance with 37 CFR 1.121(d) are required in this application because Figures 2,4, and 6-8 are all illegible due to grayscale and illegible text. Applicant is advised to employ the services of a competent patent draftsperson outside the Office, as the U.S. Patent and Trademark Office no longer prepares new drawings. The corrected drawings are required in reply to the Office action to avoid abandonment of the application. The requirement for corrected drawings will not be held in abeyance. Claim Rejections - 35 USC § 103 In the event the determination of the status of the application as subject to AIA 35 U.S.C. 102 and 103 (or as subject to pre-AIA 35 U.S.C. 102 and 103) is incorrect, any correction of the statutory basis (i.e., changing from AIA to pre-AIA ) for the rejection will not be considered a new ground of rejection if the prior art relied upon, and the rationale supporting the rejection, would be the same under either status. The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action: A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made. The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows: 1. Determining the scope and contents of the prior art. 2. Ascertaining the differences between the prior art and the claims at issue. 3. Resolving the level of ordinary skill in the pertinent art. 4. Considering objective evidence present in the application indicating obviousness or nonobviousness. Claim(s) 1-2, 5, and 8-10 are rejected under 35 U.S.C. 103 as being unpatentable over Zhu R. et al, (US. Patent Application Publication 20220114475 A1) effectively filed on April 14, 2022, (hereafter Zhu), in view of Aggarwal D. et al, "FedFace: Collaborative Learning of Face Recognition Model", available at https://ieeexplore.ieee.org/abstract/document/9484386?casa_token=PGCGegVlxroAAAAA:J_q_7zpPAKamqosVM7qAexw96Ivfl2MZGoYFWpa3Cn7RDmn7gAfdRDSLqvmFD3-vRyfm3evb, effectively published on July 20, 2021, (hereafter Aggarwal). Claim 1: Regarding claim 1, Zhu teaches “A model training method based on adaptive split learning-federated learning, applied to a ring structured federated learning (RingSFL) system comprising: a server and a plurality of user terminals, and the model training method comprising:” See Zhu in paragraph [0041] describing, “A known approach to train a machine learning model related to a task from a large dataset is to split the dataset into several parts and build a distributed cluster of client computing systems (also referred to simply as clients) for training the machine learning model. Such an approach is referred to as distributed machine learning. A decentralized distributed machine learning (DDML) system is a system for distributed machine learning in which there is no central server, and instead clients are directly connected in a decentralized topology.” Further, see Zhu in paragraph [0042] describing, “In this example, the DDML system 20 has four clients, namely client A 22A, client B 22B, client C 22C and client D 22D (generally referred to as clients 22), which are connected in a ring topology. Each client 22 only interacts with its neighbor. A neighbor of a given client is defined as another client that has a direct connection with the given client.” Further, see Zhu in paragraph [0055] describing, “Each client 102 may independently be an end user device, a network device, a private network, or other singular or plural entity that holds private local data. In the case where a client 102 is an end user device, the client 102 may be or may include such devices as a client device/terminal, user equipment/device (UE), wireless transmit/receive unit (WTRU), mobile station, fixed or mobile subscriber unit, cellular telephone, station (STA), personal digital assistant (PDA), smartphone, laptop, computer, tablet, wireless sensor, wearable device, smart device, machine type communications device, smart (or connected) vehicles, or consumer electronics device, among other possibilities.” Here, Zhu establishes a model training method of a decentralized distributed machine learning system that uses ring topology, which can be seen as a ring structured federated learning system, decentralized learning is a way of federated learning where each client acts as its own server and each of the clients can be seen as user terminals as shown. Further, Zhu teaches “uploading, by each user terminal, device information thereof to the server, and allocating, by the server, a respective propagation step length and a respective aggregation weight to each user terminal based on the device information obtained from the plurality of user terminals; wherein the propagation step length represents a number of propagation network layers;” See Zhu in paragraph [0048] describing, “Each respective client send an update of its local model (i.e. local model update) to the central node.” Further, see Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes a respective propagation step length with the performance of backpropagation from a respective client or user terminal that has a gradient which can be seen as the propagation step length as it has a set or number of parameters. As known in the art clients in federated learning can be seen as propagation network layers and the clients in this embodiment are in represented by the gradient established as the propagation step length, which can be seen as the propagation network layers, these are allocated by the client which acts as a server in a decentralized learning approach well known in the art. The parameter is associated to be a weight as well which can be seen as an aggregation weight for the client or user terminal. Further, Zhu teaches “in a current-round training, obtaining, by each user terminal, a current-round global model from the server, and taking, by each user terminal, itself as a start node of a ring topology formed by the plurality of user terminals to perform local joint processing of start nodes respectively corresponding to the plurality of user terminals for a preset number of times, thereby to obtain a locally-updated model parameter of each start node with respect to the current-round training;” See Zhu in paragraph [0048] describing, “In an example round of training, the central node sends the latest learned parameters of the central model (referred to hereinafter as central model parameters) to each client (or a selected number of the clients). Each client updates the parameters of its respective local model (referred to hereafter as local model parameters) to match the central model parameters, then uses its local dataset (e.g., the entire local dataset, a mini-batches of data randomly sampled from its local dataset) to train its local model.” Further, see Zhu in paragraph [0042] describing, “In this example, the DDML system 20 has four clients, namely client A 22A, client B 22B, client C 22C and client D 22D (generally referred to as clients 22), which are connected in a ring topology. Each client 22 only interacts with its neighbor. A neighbor of a given client is defined as another client that has a direct connection with the given client. For example, client A 22A is directly connected to client B 22B and client D 22D, hence client B 22B and client D 22D are neighbors of client A 22A, but client C 22C is not a neighbor of client A 22A. Each client 22 stores a respective local dataset (local datasets A, B, C, D 28A, 28B, 28C, 28D, generally referred to as local dataset 28). Each client 22 also executes a machine learning algorithm to learn the parameters of a local machine learning model (local models A, B, C, D, 26A, 26B, 26C, 26D, generally referred to as local model 26) using the respective local dataset 28.” Further, Zhu teaches “wherein the local joint processing of each start node comprises: performing forward propagation and backward propagation on a current-time local model of the start node in the current-round training based on a batch…of the start node;” See Zhu in paragraph [0043] describing, “An example round of training in the DDML system 20 is now described. First, each given client 22 obtains data randomly sampled from its local data 28 (or a mini-batch of data randomly sampled from its local dataset 28), denoted as ξi where the subscript i denotes the ith client 22. Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient.” Here, Zhu establishes forward and backpropagation or backward propagation on a respective local model in an example round of training of a decentralized distributed machine learning system. As known in the art, each client in a decentralized leaning system can act as a start node at any point as already established and the local model of the client can be seen as a current-time model, as known in the art in decentralized machine learning each client or node has its own personal clock so the local model of that client can be a current-time model in the example round of training which can also be seen as the current-round of training. Further, Zhu teaches “and updating the current-time local model of the start node based on weighted gradients generated by the start nodes in the local joint processing; wherein a current-time local model corresponding to first local joint processing of each start node in the current-round training is the current-round global model;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0048] describing, “In an example round of training, the central node sends the latest learned parameters of the central model (referred to hereinafter as central model parameters) to each client (or a selected number of the clients). Each client updates the parameters of its respective local model (referred to hereafter as local model parameters) to match the central model parameters, then uses its local dataset (e.g., the entire local dataset, a mini-batches of data randomly sampled from its local dataset) to train its local model. During training of its local model, each client computes an update to its respective local model (i.e. an update to the parameters of its local model). Each respective client send an update of its local model (i.e. local model update) to the central node. The central node aggregates local model updates received from the clients (e.g., computes an average of all received local model updates) and updates the central model based on the average of local model updates (i.e. updates the parameters of the central model based on an average of the updates of the parameters of each local model).” Here, Zhu establishes a current-time local model with the latest parameters of the central model and the central model can be seen as the current round global model as known in the art central model is a global model, the example round of training can be seen as the current-round and each client described can be seen as each start node. Further, Zhu teaches “the forward propagation and the backward propagation are completed by combining partial network trainings respectively performed by the plurality of user terminals in the ring topology by using the respective propagation step lengths;” See Zhu in paragraph [0043] describing, “An example round of training in the DDML system 20 is now described. First, each given client 22 obtains data randomly sampled from its local data 28 (or a mini-batch of data randomly sampled from its local dataset 28), denoted as ξi where the subscript i denotes the ith client 22. Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes partial network trainings with the mini-batch or randomly sampled batch of data and this is done by each client or user terminal that performs both forward and backward propagation using the respective partial network trainings. As established the gradient used can be seen as a propagation step length. Further, see Zhu in paragraph [0042] describing, “ In this example, the DDML system 20 has four clients, namely client A 22A, client B 22B, client C 22C and client D 22D (generally referred to as clients 22), which are connected in a ring topology. Each client 22 only interacts with its neighbor. A neighbor of a given client is defined as another client that has a direct connection with the given client.” Here, Zhu establishes the DDML system established previously using a ring topology. Further, Zhu teaches “and in the backward propagation, each user terminal obtains a corresponding one of the weighted gradients by using the propagation step length thereof and the aggregation weight corresponding to the start node, and transmits an output layer gradient thereof;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0044] describing, “Each client 22 shares its respective gradient with its neighbor clients 22, as indicated in FIG. 2, according to an AllReduce process.” Further, Zhu teaches “uploading, by each user terminal, the locally-updated model parameter for the current-round training to the server for aggregation, and obtaining a current-round updated global model;” See Zhu in paragraph [0048] describing, “The responsibilities of the central node includes coordinating communications with clients, aggregating updates to local models received from clients, model management, among others. Each client has a respective private, local dataset that is used for training a respective local model. At any time, each client has only access to its own local dataset and cannot share data contained in its local dataset with any other client, including the central server. In an example round of training, the central node sends the latest learned parameters of the central model (referred to hereinafter as central model parameters) to each client (or a selected number of the clients).” Further, Zhu teaches “determining, by the server, whether the current-round updated global model meets a convergence condition;” See Zhu in paragraph [0093] describing, “At 518, a determination is made whether a predefined convergence condition (e.g., any suitable convergence condition as discussed previously) has been satisfied. The determination whether the convergence condition is satisfied may be performed by the task owner client 110, or may be performed by individual clients 102. If the convergence condition is not satisfied, the method 500 returns to step 508 to perform another round of training. If the convergence condition is satisfied, the method 500 proceeds to step 520.” Further, Zhu teaches “in response to the current-round updated global model failing to meet the convergence condition, taking the current-round updated global model as the current-round global model, and returning to perform the step of in the current-round training, obtaining, by each user terminal, the current-round global model from the server;” See Zhu in paragraph [0093] describing, “At 518, a determination is made whether a predefined convergence condition (e.g., any suitable convergence condition as discussed previously) has been satisfied. The determination whether the convergence condition is satisfied may be performed by the task owner client 110, or may be performed by individual clients 102. If the convergence condition is not satisfied, the method 500 returns to step 508 to perform another round of training. If the convergence condition is satisfied, the method 500 proceeds to step 520.” Further, see Zhu in paragraph [0048] describing, “Each client has a respective private, local dataset that is used for training a respective local model. At any time, each client has only access to its own local dataset and cannot share data contained in its local dataset with any other client, including the central server. In an example round of training, the central node sends the latest learned parameters of the central model (referred to hereinafter as central model parameters) to each client (or a selected number of the clients). Each client updates the parameters of its respective local model (referred to hereafter as local model parameters) to match the central model parameters, then uses its local dataset (e.g., the entire local dataset, a mini-batches of data randomly sampled from its local dataset) to train its local model. During training of its local model, each client computes an update to its respective local model (i.e. an update to the parameters of its local model). Each respective client send an update of its local model (i.e. local model update) to the central node. The central node aggregates local model updates received from the clients (e.g., computes an average of all received local model updates) and updates the central model based on the average of local model updates (i.e. updates the parameters of the central model based on an average of the updates of the parameters of each local model).” Here, Zhu explicitly establishes returning to a step of performing another round of training when a condition is not satisfied or failed to meet. Obtaining of the current round central or global model updates from the clients or user terminals from a central node or server is established, in addition when a client obtains a central model at can act as its own server in decentralized federated learning as established and known in the art. Further, Zhu teaches “and in response to the current-round updated global model meeting the convergence condition, determining the current-round updated global model as…” See Zhu in paragraph [0093] describing, “At 518, a determination is made whether a predefined convergence condition (e.g., any suitable convergence condition as discussed previously) has been satisfied. The determination whether the convergence condition is satisfied may be performed by the task owner client 110, or may be performed by individual clients 102. If the convergence condition is not satisfied, the method 500 returns to step 508 to perform another round of training. If the convergence condition is satisfied, the method 500 proceeds to step 520.” Further, see Zhu in paragraph [0097] describing, “At 520, after satisfying the convergence condition, each client 102 stores the respective trained local model 104 that includes the respective set of learned local model parameters. The trained local model 104 may then be deployed by each client 102 independently for prediction in an inference phase.” Zhu does not appear to explicitly teach “…of a face image set…; …a trained face recognition model.”, However in the same field of art, Aggarwal teaches “…of a face image set…;” See Aggarwal in 1. Introduction section on page 2 describing, “In an effort to facilitate distributed training of face recognition systems from face images available on mobile devices, we propose a framework, called FedFace, that learns an accurate face recognition model from multiple mobile devices in a collaborative manner without sending training face images outside of the device.” Further, Aggarwal teaches “…a trained face recognition model.” See Aggarwal in 1. Introduction section on page 2 describing, “In an effort to facilitate distributed training of face recognition systems from face images available on mobile devices, we propose a framework, called FedFace, that learns an accurate face recognition model from multiple mobile devices in a collaborative manner without sending training face images outside of the device.” It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base reference of Zhu with the teachings of Aggarwal by using Zhu’s teachings of a system for distributed federated learning using ring topology, and incorporate with Aggarwal’s teachings of federated learning trained recognition model. One of ordinary skill in the art would be motivated to do so because by integrating Aggarwal’s frameworks into the methods of Zhu, which are both in the same field of art of federated learning, one of ordinary skill in the art would bring “work [that] is the first to conduct a comprehensive evaluation of training face recognition models under the FL setup and to show that training with additional face images in a federated setting can help boost the performance of a pre-trained AFR system.” (Aggarwal, section 2 Related Work on page 2). Claim 2: Regarding claim 2, Zhu in view of Aggarwal teaches the limitations of claim 1. Further, Zhu teaches “The model training method as claimed in claim 1, wherein the steps of uploading, by each user terminal, device information thereof to the server, and allocating, by the server, a respective propagation step length and a respective aggregation weight to each user terminal based on the device information obtained from the plurality of user terminals, comprise:” See Zhu in paragraph [0048] describing, “Each respective client send an update of its local model (i.e. local model update) to the central node.” Further, see Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes a respective propagation step length with the performance of backpropagation from a respective client or user terminal that has a gradient which can be seen as the propagation step length as it as a set or number of parameters which can be the propagation network layers, these are allocated by the client which acts as a server in a decentralized learning approach well known in the art. The parameter is associated to be a weight as well which can be seen as an aggregation weight for the client or user terminal. Further, Zhu teaches “uploading, by each user terminal, a computation capability value thereof…” See Zhu in paragraph [0116] describing, “For example, each client 102 may (e.g., periodically such as after each round of training or in response to a request from the scheduler 202) report to the scheduler 202 its respective status such as resource usage (e.g., memory usage), utilization of bandwidth of the communication link connecting the clients 102 and/or progress in training (e.g., number of training rounds conducted, or change in loss function between training rounds), among others. The scheduler 202 may use this information as input to an optimization algorithm, to manage data traffic, resource usage, execution time, etc.” Further, see Zhu in paragraph [0100] describing, “The scheduler 202 may reside in a trusted third-party node (e.g., a server or private cloud computing platform) that is able to communicate (e.g., via broadcast or via direct connections) with each client 102 in the system 600.” Here, Zhu establishes sending a status of resource usage and utilization of a bandwidth which can be seen as a computation capability value by each client or user terminal to a scheduler which is established to be compromised in a server. Further, Zhu teaches “calculating, by the server, the propagation step length of each user terminal by using a pre-established propagation step length computation formula based on the computation capability values of the plurality of user terminals; wherein the propagation step length computation formula is determined according to a pre-established optimization problem regarding computation time;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes a respective propagation step length with the performance of backpropagation from a respective client or user terminal that has a gradient which can be seen as the propagation step length as also established in previous limitations, this gradient also computes a loss function. Further, see Zhu in paragraph [0116] describing, “For example, each client 102 may (e.g., periodically such as after each round of training or in response to a request from the scheduler 202) report to the scheduler 202 its respective status such as resource usage (e.g., memory usage), utilization of bandwidth of the communication link connecting the clients 102 and/or progress in training (e.g., number of training rounds conducted, or change in loss function between training rounds), among others. The scheduler 202 may use this information as input to an optimization algorithm, to manage data traffic, resource usage, execution time, etc.” Here, Zhu establishes a different embodiment of clients which establishes resource usage and utilization of a bandwidth which can be seen as a computation capability value by each client or user termina in relation to a loss function. The formula given in paragraph [0043] can be seen as the pre-established formula propagation step-formula as well as the gradient calculation does calculate a loss function and in paragraph [0116] the resource usage is in relation to execution time and an optimization algorithm which can be seen as a pre-established optimization problem regarding computation time and in an analogous system the formula in relation to a loss function can be determined by this pre-established optimization problem. Further, see Zhu in paragraph [0100] describing, “The scheduler 202 may reside in a trusted third-party node (e.g., a server or private cloud computing platform) that is able to communicate (e.g., via broadcast or via direct connections) with each client 102 in the system 600.” Here, Zhu establishes sending to a scheduler which is established to be compromised in a server. Further, Zhu teaches “and sending, by the server, the respective propagation step length and the respective aggregation weight to each user terminal.” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes a respective propagation step length with the performance of backpropagation from a respective client or user terminal that has a gradient which can be seen as the propagation step length as it as a set or number of parameters which can be the propagation network layers, these are allocated by the client which acts as a server in a decentralized learning approach well known in the art. The parameter is associated to be a weight as well which can be seen as an aggregation weight for the client or user terminal. Further, see Zhu in paragraph [0044] describing, “Each client 22 shares its respective gradient with its neighbor clients 22, as indicated in FIG. 2, according to an AllReduce process.” Here, Zhu establishes sending this gradient established to be seen as a propagation step length to that contains parameters or weights to other clients or user terminals. Zhu does not appear to explicitly teach “…and a number of training samples corresponding to the face image training set thereof to the server; calculating, by the server, a total number of the training samples of the plurality of user terminals, and determining a ratio of the number of the training samples of each user terminal to the total number of the training samples as the aggregation weight of each user terminal;”, However in the same field of art, Aggarwal teaches “…and a number of training samples corresponding to the face image training set thereof to the server; ” See Aggarwal in 3.2 Federated Learning section on page 4 describing, “3. The server receives the updated model parameters (θit,Wit) from all the participating client nodes and updates the global model parameters by taking a weighted average of them as follows: PNG media_image2.png 50 290 media_image2.png Greyscale where ni is the no. of training samples on the ith client and n is the total no. of training samples across all client nodes. 4. Finally, the updated global parameters are transmitted to each of the clients and steps 2 − 4 are repeated until convergence. Our objective is to enhance the face recognition performance of a pre-trained AFR model at the server by utilizing the face images available only on end user devices (clients) such as mobile phones under the extreme case where each client has face images of only one identity.” Further, Aggarwal teaches “calculating, by the server, a total number of the training samples of the plurality of user terminals, and determining a ratio of the number of the training samples of each user terminal to the total number of the training samples as the aggregation weight of each user terminal;” See Aggarwal in 3.2 Federated Learning section on page 4 describing, “3. The server receives the updated model parameters (θit,Wit) from all the participating client nodes and updates the global model parameters by taking a weighted average of them as follows: PNG media_image2.png 50 290 media_image2.png Greyscale where ni is the no. of training samples on the ith client and n is the total no. of training samples across all client nodes. 4. Finally, the updated global parameters are transmitted to each of the clients and steps 2 − 4 are repeated until convergence. Our objective is to enhance the face recognition performance of a pre-trained AFR model at the server by utilizing the face images available only on end user devices (clients) such as mobile phones under the extreme case where each client has face images of only one identity.” It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base reference of Zhu with the teachings of Aggarwal by using Zhu’s teachings of a system for distributed federated learning using ring topology, and incorporate with Aggarwal’s teachings of federated learning trained recognition model. One of ordinary skill in the art would be motivated to do so because by integrating Aggarwal’s frameworks into the methods of Zhu, which are both in the same field of art of federated learning, one of ordinary skill in the art would bring “work [that] is the first to conduct a comprehensive evaluation of training face recognition models under the FL setup and to show that training with additional face images in a federated setting can help boost the performance of a pre-trained AFR system.” (Aggarwal, section 2 Related Work on page 2). Claim 5: Regarding claim 5, Zhu in view of Aggarwal teaches the limitations of claim 1. Further, Zhu teaches “The model training method as claimed in claim 1, wherein for each start node, the forward propagation in the local joint processing of each start node comprises: forward propagating, by the start node, at least one layer corresponding to the propagation step length of the start node by using… and transmitting, by the start node, a feature map output by a local network corresponding to the forward propagation of the start node…” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Here, Zhu establishes forward propagation of each client which can be seen as a start node, and establishes a respective propagation step length with the performance of backpropagation from a respective client or user terminal that has a gradient which can be seen as the propagation step length as it as a set or number of parameters which can be the layers, the local model described can be seen as the current-time local model. Further, see Zhu in paragraph [0069] describing, “Before further discussion, some notation is introduced. ƒ(w; ξ) denotes a machine learning model (i.e., a function) having a set of parameters (e.g. weights) denoted as w, and accepting an input feature representation or map (which may be random) denoted as tensor ξ. The private local dataset 106 at the ith client 102 is denoted as Di. In examples where model aggregation makes use of weighted aggregation techniques (e.g., weighted average), αi denotes a coefficient for weighting the contribution from the ith client 102 during model aggregation. It should be noted that, generally, subscripts will denote the client 102 and superscripts will denote iterations (or training rounds).” Here, Zhu establishes a feature map vector with ξ. As established in previous excerpt this is a part of the gradient that is transmitted in the ring topology which also established to have any client act as a starting node which also corresponds to forward propagation. Further, Zhu teaches “…and an output layer serial number of the user terminal corresponding to the start node to a next user terminal along a forward direction of the ring topology starting from the start node;” See Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ” Here, Zhu shows clients seen as user terminals with identifications for each client with Client A, B, C, and D, which can be seen as the serial number as it is an identification of the client and each client outputs a gradient or layer denoted by its identification letter or serial number in a forward direction of a shown ring topology. Further, Zhu teaches “for each forward current node traversed sequentially along the forward direction of the ring topology, taking a next layer corresponding to an output layer serial number of a previous user terminal along the forward direction of the ring topology as a start layer of the forward current node, forward propagating at least one layer corresponding to the propagation step length of the forward current node by using a computation result transmitted by the previous user terminal from the start layer of the forward current node, and transmitting a computation result obtained by a local network corresponding to the forward propagation of the forward current node to a next user terminal along the forward direction of the ring topology; wherein the forward current node is one of the plurality of user terminals traversed except the start node in the ring topology, and an end node is a last user terminal of the plurality of user terminals traversed in the ring topology; except the end node, each forward current node transmits an output layer serial number thereof to a next user terminal;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”. Further, see Zhu in paragraph [0054] describing, “For example, one client 102 may store multiple different local models and/or may have access to multiple different local datasets. In some example embodiments, the local model 104 and local dataset 106 may be stored by a respective client 102 within data storage may include one or more a physical machines, virtual machines (e.g., in the case where the client 102 is a private network) or containers.” Here, Zhu establishes all the clients traversing sequentially in a forward direction to a neighbor client in a ring topology, each client can act as a forward current node and the calculated gradient of the client being traversed can be seen as the propagation step length layer and the computation result. Each of the clients can also act as a start node and end node in the shown ring topology of Fig. 2 in addition to a current forward node, for example Client A could be the start node, B the current forward node and C the end node, as mentioned in the previous limitation the labeled client letter A-D can each be seen as a serial number or identification and this identification is labeled with the gradient output to the neighbor client or next user terminal. Each client is also established to be a private or local network and each client transmits a computation result as shown by Fig. 2. Because, any client can act as the end node as shown in the ring topology of Fig. 2 every forward current node can transmit the established letter labeled with a gradient as the output layer serial number to a next client or user terminal, since any user terminal can act as the end node it does not have to transmit the output layer. For example clients A, B, and C can each be current forward nodes transmitting the established output layers from A to B and from B to C and from C to D the transmitting can end at D making client D be the end node and every client except for D can transmit the output layer in this instance, as known by decentralized federated learning, making except the end node or client D, each forward current node or client can transmit the output layer serial number thereof to a next client or user terminal. Further, Zhu teaches “the computation result obtained by the local network is a feature map output by the local network corresponding to the forward propagation of the forward current node;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0069] describing, “Before further discussion, some notation is introduced. ƒ(w; ξ) denotes a machine learning model (i.e., a function) having a set of parameters (e.g. weights) denoted as w, and accepting an input feature representation or map (which may be random) denoted as tensor ξ.” Here, Zhu establishes a computed gradient which can be seen as the computation result, as established each client can be seen as a local network and the gradient computed consist of a tensor ξ which is established as a feature map, this corresponds to an established forward propagation of each client in which each client can be seen as a forward current node. Zhu does not appear to explicitly teach “…the batch of the face image training set thereof from a first layer of the current-time local model,…; and a computation result of the end node is a face recognition result; comparing, by the start node, the face recognition result transmitted by the end node with a sample label in the batch of the face image training set to obtain a comparison result, and calculating a network loss value corresponding to the start node according to the comparison result.”, Further, Aggarwal teaches “…the batch of the face image training set thereof from a first layer of the current-time local model,…” See Aggarwal in 3.2 Federated Learning section on page 4 describing, “1. In the tth communication round, the server sends the global model parameters θt and the class embedding matrix Wt to all the client nodes. 2. The ith client updates the global model at iteration t based on the local data Si and the loss function PNG media_image4.png 46 250 media_image4.png Greyscale as follows PNG media_image5.png 60 244 media_image5.png Greyscale 3. The server receives the updated model parameters (θit,Wit) from all the participating client nodes and updates the global model parameters by taking a weighted average of them as follows: PNG media_image2.png 50 290 media_image2.png Greyscale where ni is the no. of training samples on the ith client and n is the total no. of training samples across all client nodes. 4. Finally, the updated global parameters are transmitted to each of the clients and steps 2 − 4 are repeated until convergence. Our objective is to enhance the face recognition performance of a pre-trained AFR model at the server by utilizing the face images available only on end user devices (clients) such as mobile phones under the extreme case where each client has face images of only one identity.” Here, Aggarwal establishes a batch of the face image training set from clients, each client uses a local dataset to train a global model, that local dataset that trains can be seen as a first layer, and inputting or transmitting a face image into a face feature extractor apart of face recognition system, an face recognition result is established with the face verification stage that decides if faces belong to the same identity which can be seen as the face recognition result and the attribute information can be the face features. Further, Aggarwal teaches “and a computation result of the end node is a face recognition result;” See Aggarwal in 3.1. Problem Setup section on page 4 describing, “At the face verification stage, we use the face feature extractor fθ to extract the d-dimensional face representation. A distance metric (e.g., cosine similarity) between the two face features defines the similarity between the two face images. If the score is above a certain threshold τ, we say that the two faces belong to the same identity; otherwise we decide that the two face images do not belong to the same identity.” Here, Aggarwal establishes a face recognition result with computed similarity in the face verification stage that decides if faces belong to the same identity which can be seen as the face recognition result and because a similarity is computed it can also be seen as a computation result. Further, Aggarwal teaches “comparing, by the start node, the face recognition result transmitted by the end node with a sample label in the batch of the face image training set to obtain a comparison result, and calculating a network loss value corresponding to the start node according to the comparison result.” See Aggarwal in 3.2 Federated Learning section on page 4 describing, “1. In the tth communication round, the server sends the global model parameters θt and the class embedding matrix Wt to all the client nodes. 2. The ith client updates the global model at iteration t based on the local data Si and the loss function PNG media_image4.png 46 250 media_image4.png Greyscale as follows PNG media_image5.png 60 244 media_image5.png Greyscale 3. The server receives the updated model parameters (θit,Wit) from all the participating client nodes and updates the global model parameters by taking a weighted average of them as follows: PNG media_image2.png 50 290 media_image2.png Greyscale where ni is the no. of training samples on the ith client and n is the total no. of training samples across all client nodes. 4. Finally, the updated global parameters are transmitted to each of the clients and steps 2 − 4 are repeated until convergence. Our objective is to enhance the face recognition performance of a pre-trained AFR model at the server by utilizing the face images available only on end user devices (clients) such as mobile phones under the extreme case where each client has face images of only one identity. Conventional FL algorithms cannot be directly applied to such an instance because of two major reasons: In the tth communication round, the server cannot transmit the entire classification matrix Wt to all users since the class embeddings contain sensitive information that can be potentially used to identify the user. Therefore, for the ith user, the server only communicates the parameters of the feature extractor θt and the class embedding wit associated with that user. The loss function (Eqn. 1) encourages the instance embedding to be similar to the positive class embedding (lpos) while at the same time minimizing the similarity between the instance embedding and the negative class embeddings (lneg). In the current setting, the ith user only has access to face images of the ith identity and its positive class embedding wi. Therefore, it cannot compute lneg while updating the model parameters on its local data as it does not have access to the negative class embeddings. Optimizing only the positive part of the loss function (lpos) would lead to a trivial solution where all the face images and the class embeddings collapse into a single point in the feature space resulting in sub-optimal performance.” Further, see Aggarwal in 3.1. Problem Setup section on page 4 describing, “Formally, given an input face image x, the face feature extractor fθ : X →ℛd embeds the input instance into a d-dimensional feature vector fθ(x). A fully connected layer with a softmax activation function parameterized by the class embedding matrix W ∈ ℛC×d (C represents the total number of identities), then maps this feature vector to the logits or scores for each identity. The kth row of the class embedding matrix, wk, is referred to as the class embedding of the kth class. The logit for the kth class is thus computed as wTk⋅fθ(x). A general overview of training a DNN-based AFR system is shown in Fig. 2. The training objective is as follows: PNG media_image6.png 92 634 media_image6.png Greyscale where the first term defines the positive part (lpos) and the second term defines the negative part (lneg) of the loss function. d represents the distance function between the two input quantities. α and β are hyper-parameters denoting the weight of each term. v denotes the margin and c and y are the identity labels and the ground-truth identity label respectively. It essentially tries to accomplish the following: Maximize the similarity between the instance embedding fθ(x) and the positive class embedding wy where the instance x belongs to the identity y. Minimize the similarity between the instance embedding fθ(x) and the negative class embeddings wc for all identities c ≠ y, where the instance x belongs to the identity y. At the face verification stage, we use the face feature extractor fθ to extract the d-dimensional face representation. A distance metric (e.g., cosine similarity) between the two face features defines the similarity between the two face images. If the score is above a certain threshold τ, we say that the two faces belong to the same identity; otherwise we decide that the two face images do not belong to the same identity. In the FL setup, we consider the realistic scenario where each of the client nodes actually correspond to individual user devices such as mobile phones which contain face images of only the owner of the device, rather than a central face dataset with multiple identities. Let us assume that there are C mobile devices or client nodes. The server contains a face recognition system fθ0 trained on a publicly available dataset. The ith client node contains ni instances from one identity (the owner of the device). Therefore, the ith client has access to the dataset Si, where Si=(xi1,yi),…,(xini,yi). Our objective is to enhance the performance of the face recognition system available on the server by collaboratively learning from the data on each of the clients without sharing training face images outside of the device.” Here, Aggarwal a process of comparing a face recognition result from the face extractor where the parameters in relation to the face extractor are transmitted to other users or end node. The function for this process shows a loss value being calculated that corresponds to the face extractor which is established to be a part of the recognition result and a number or batch of training samples in relation to image data is established. The face extractor gets face image data that has identity labels making the samples used be seen as sample labels. Each client can act as a start or end node in this federated learning process. It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base reference of Zhu with the teachings of Aggarwal by using Zhu’s teachings of a system for distributed federated learning using ring topology, and incorporate with Aggarwal’s teachings of federated learning trained recognition model. One of ordinary skill in the art would be motivated to do so because by integrating Aggarwal’s frameworks into the methods of Zhu, which are both in the same field of art of federated learning, one of ordinary skill in the art would bring “work [that] is the first to conduct a comprehensive evaluation of training face recognition models under the FL setup and to show that training with additional face images in a federated setting can help boost the performance of a pre-trained AFR system.” (Aggarwal, section 2 Related Work on page 2). Claim 8: Regarding claim 8, Zhu in view of Aggarwal teaches the limitations of claim 1. Further, Zhu teaches “The model training method as claimed in claim 1, wherein the step of uploading, by each user terminal, the locally-updated model parameter for the current-round training to the server for aggregation, comprises: uploading, by each user terminal, the locally-updated model parameter for the current-round training to the server;” See Zhu in paragraph [0048] describing, “Each client has a respective private, local dataset that is used for training a respective local model. At any time, each client has only access to its own local dataset and cannot share data contained in its local dataset with any other client, including the central server. In an example round of training, the central node sends the latest learned parameters of the central model (referred to hereinafter as central model parameters) to each client (or a selected number of the clients). Each client updates the parameters of its respective local model (referred to hereafter as local model parameters) to match the central model parameters, then uses its local dataset (e.g., the entire local dataset, a mini-batches of data randomly sampled from its local dataset) to train its local model. During training of its local model, each client computes an update to its respective local model (i.e. an update to the parameters of its local model). Each respective client send an update of its local model (i.e. local model update) to the central node. The central node aggregates local model updates received from the clients (e.g., computes an average of all received local model updates) and updates the central model based on the average of local model updates (i.e. updates the parameters of the central model based on an average of the updates of the parameters of each local model).” Further, Zhu teaches “and obtaining, by the server, an average value of the locally-updated model parameters of the plurality of user terminals as a parameter of the current-round updated global model.” See Zhu in paragraph [0048] describing, “Each respective client send an update of its local model (i.e. local model update) to the central node. The central node aggregates local model updates received from the clients (e.g., computes an average of all received local model updates) and updates the central model based on the average of local model updates (i.e. updates the parameters of the central model based on an average of the updates of the parameters of each local model).” Claim 9: Regarding claim 9, Zhu in view of Aggarwal teaches the limitations of claim 1. Further, Zhu teaches “The model training method as claimed in claim 1, wherein the server is a base station in a cellular network, and each user terminal is a user terminal device in the cellular network.” See Zhu in paragraph [0055] describing, “Each client 102 may independently be an end user device, a network device, a private network, or other singular or plural entity that holds private local data. In the case where a client 102 is an end user device, the client 102 may be or may include such devices as a client device/terminal, user equipment/device (UE), wireless transmit/receive unit (WTRU), mobile station, fixed or mobile subscriber unit, cellular telephone, station (STA), personal digital assistant (PDA), smartphone, laptop, computer, tablet, wireless sensor, wearable device, smart device, machine type communications device, smart (or connected) vehicles, or consumer electronics device, among other possibilities. In the case where a client 102 is a network device, the client 102 may be or may include a base station (BS) (erg eNodeB or gNodeB), router, access point (AP), personal basic service set (PBSS) coordinate point (PCP), among other possibilities.” Here, Zhu establishes a client device established to be a user device or user terminal device that can be a base station, network device, and cellular telephone or device. Since the client can act as its own server in decentralized federated learning as known in the art, the client can be seen as a base station in a cellular network and also a user device in a cellular network because it can be a base station and cellular telephone and network device. Claim 10: Regarding claim 10, Zhu in view of Aggarwal teaches the limitations of claim 1. Further, Zhu teaches “…wherein the target terminal is the server or one of the plurality of user terminals in the RingSFL system;” See Zhu in paragraph [0042] describing, “In this example, the DDML system 20 has four clients, namely client A 22A, client B 22B, client C 22C and client D 22D (generally referred to as clients 22), which are connected in a ring topology.” Zhu does not appear to explicitly teach “A face recognition method based on adaptive split learning-federated learning, applied to a target terminal, wherein the face recognition method comprises the following steps: acquiring the trained face recognition model obtained through the model training method as claimed in claim 1, and an image to be recognized;…; and inputting the image to be recognized into the trained face recognition model to obtain a face recognition result; wherein the face recognition result comprises attribute information of a face in the image to be recognized, and the attribute information comprises identity information.”, Further, Aggarwal teaches “A face recognition method based on adaptive split learning-federated learning, applied to a target terminal, wherein the face recognition method comprises the following steps: acquiring the trained face recognition model obtained through the model training method as claimed in claim 1, and an image to be recognized;…” See Aggarwal in 1. Introduction section on page 2 describing, “In an effort to facilitate distributed training of face recognition systems from face images available on mobile devices, we propose a framework, called FedFace, that learns an accurate face recognition model from multiple mobile devices in a collaborative manner without sending training face images outside of the device.”. Further, see Aggarwal in 3.1. Problem Setup section on page 4 describing, “Our objective is to enhance the performance of the face recognition system available on the server by collaboratively learning from the data on each of the clients without sharing training face images outside of the device.” Further, Aggarwal teaches “and inputting the image to be recognized into the trained face recognition model to obtain a face recognition result; wherein the face recognition result comprises attribute information of a face in the image to be recognized, and the attribute information comprises identity information.” See Aggarwal in 3.1. Problem Setup section on page 3 describing, “Face recognition systems are essentially embedding based classifiers i.e., both the classes (identities) and the input instance are embedded into a high dimensional Euclidean space. The similarity between the embedded input and the class embedding represents the likelihood of the in-stance belonging to that particular class. Formally, given an input face image x, the face feature extractor fθ : X →ℛd embeds the input instance into a d-dimensional feature vector fθ(x).” Further, see Aggarwal in 3.1. Problem Setup section on page 4 describing, “At the face verification stage, we use the face feature extractor fθ to extract the d-dimensional face representation. A distance metric (e.g., cosine similarity) between the two face features defines the similarity between the two face images. If the score is above a certain threshold τ, we say that the two faces belong to the same identity; otherwise we decide that the two face images do not belong to the same identity.” Here, Aggarwal establishes inputting a face image into a face feature extractor apart of face recognition system, an face recognition result is established with the face verification stage that decides if faces belong to the same identity which can be seen as the face recognition result and the attribute information can be the face features. It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base reference of Zhu with the teachings of Aggarwal by using Zhu’s teachings of a system for distributed federated learning using ring topology, and incorporate with Aggarwal’s teachings of federated learning trained recognition model. One of ordinary skill in the art would be motivated to do so because by integrating Aggarwal’s frameworks into the methods of Zhu, which are both in the same field of art of federated learning, one of ordinary skill in the art would bring “work [that] is the first to conduct a comprehensive evaluation of training face recognition models under the FL setup and to show that training with additional face images in a federated setting can help boost the performance of a pre-trained AFR system.” (Aggarwal, section 2 Related Work on page 2). Claim(s) 6 is rejected under 35 U.S.C. 103 as being unpatentable over Zhu R. et al, in view of Aggarwal D. et al, and further in view of Dimitriadis D. et al, (US. Patent Application Publication 20220036178 A1) effectively filed on July 31, 2020 (hereafter, Dimitriadis). Claim 6: Regarding claim 6, Zhu in view of Aggarwal teaches the limitations of claim 5. Further, Zhu teaches “The model training method as claimed in claim 5, wherein for each start node, the backward propagation in the local joint processing of each start node comprises: transmitting, by the start node, the network loss value and the aggregation weight corresponding to the start node to the end node;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0044] describing, “Each client 22 shares its respective gradient with its neighbor clients 22, as indicated in FIG. 2, according to an AllReduce process. The AllReduce process is performed among the client’s 22 to compute the mean of gradients of all clients 22. The result of the AllReduce process is that all clients 22 have a local model that is updated based on the mean of gradients from all clients 22. That is, the local model 26 at each client 22 is updated based on the mean of the gradients ΔwA, ΔwB, ΔwC and ΔwD.”Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”. Here, Zhu establishes backward propagation in a local joint processing of each client and as established each client can act as a start and end node, each client computes a loss and a gradient that corresponds to weights and means of other client gradients which can be seen as an aggregation weight, the gradient is then transmitted as shown in Fig. 2. Further, Zhu teaches “backward propagating, by the end node, at least one layer corresponding to the propagation step length of the end node from a last layer of the current-time local model by using the network loss value, calculating, by the end node, a local network gradient of a local network corresponding to the backward propagation of the end node,…and storing the weighted gradient corresponding to the end node;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0044] describing, “Each client 22 shares its respective gradient with its neighbor clients 22, as indicated in FIG. 2, according to an AllReduce process. The AllReduce process is performed among the clients 22 to compute the mean of gradients of all clients 22. The result of the AllReduce process is that all clients 22 have a local model that is updated based on the mean of gradients from all clients 22. That is, the local model 26 at each client 22 is updated based on the mean of the gradients ΔwA, ΔwB, ΔwC and ΔwD.”Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”. Here, Zhu establishes backward propagation of each client and as established each client can act as a start and end node, each client computes a gradient that can be seen as the layer, calculated local network gradient, and weighted aggregation gradient. A loss is also established to be computed and a mean of the gradients or weighted gradient is established to be updated at local model of each client, which can be seen as storing the weighted gradient. Further, Zhu teaches “and transmitting the output layer gradient of a local network corresponding to the end node and an output layer serial number of the end node to a next user terminal along a backward direction of the ring topology;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”.Here, Zhu establishes a computed gradient, as established each client can be seen as a local network and the gradient and as seen in Fig. 2, a gradient is transmitted, each client can act as a start or end node in this ring topology so the transmission to a neighbor client of an output gradient with a labeled gradient with client identification letter can be seen as transmitting an output gradient layer and output layer serial number being of end node to a next user terminal, which any client can also be seen as, in a backward direction in this ring topology. Further, Zhu teaches “for each backward current node traversed sequentially along the backward direction of the ring topology, taking a next layer corresponding to an output layer serial number of a previous user terminal along the backward direction of the ring topology as a start layer of the backward current node, backward propagating at least one layer corresponding to the propagation step length of the backward current node by using an output layer gradient transmitted by the previous user terminal from the start layer of the backward current node, calculating a local network gradient corresponding to the backward propagation of the backward current node,…and storing the weighted gradient of the backward current node; and transmitting an output layer gradient and an output layer serial number of a local network corresponding to the backward current node to a next user terminal along the backward direction of the ring topology; wherein the backward current node is one of the plurality of user terminals traversed except the start node and the end node in the ring topology;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”.Here, Zhu establishes a computed gradient, as established each client can be seen as a local network and the gradient and as seen in Fig. 2, a gradient is transmitted, each client can act as a start, end or backward current end node in this ring topology so the transmission to a neighbor client of an output gradient with a labeled gradient with client identification letter can be seen as transmitting an output gradient layer and output layer serial number being of end node to a next user terminal, which any client can also be seen as, in a backward direction in this ring topology. As established in previous limitations the gradients correspond to propagation length steps, in Fig. 2 Client A could be an end node and it could transmit backwards to Client D which can be the current backward current node and Client D can transmit the next layer to Client C which can be the start node. Because, any client can act as the start node as shown in the ring topology of Fig. 2 every backward current node can be traversed to transmit the established letter labeled with a gradient as the output layer serial number to a next client or user terminal, since any user terminal or client can act as the start node it does not have to traverse and transmit the gradient. For example clients A, B, and C can each be current backward nodes traversing from A to B and from B to C and from C to D the traversing can end at D making client D be the start node and every client except for D can traverse in this instance, as known by decentralized federated learning, making except the start node or client D, each backward current node or client traverse in a ring topology. Further, Zhu teaches “and taking, by the start node, a next layer corresponding to an output layer serial number of a previous user terminal in the backward direction of the ring topology as a start layer of the start node, backward propagating, by the start node, at least one layer corresponding to the propagation step length of the start node from the start layer of the start node by using an output layer gradient transmitted by the previous user terminal, calculating, by the start node, a local network gradient corresponding to the backward propagation thereof,…and storing the weighted gradient.” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in Fig. 2 describing, “ PNG media_image3.png 602 376 media_image3.png Greyscale ”.Here, Zhu establishes a computed gradient, as established each client can be seen as a local network and the gradient and as seen in Fig. 2, a gradient is transmitted, each client can act as a start, end or backward current end node in this ring topology so the transmission to a neighbor client of an output gradient with a labeled gradient with client identification letter can be seen as transmitting an output gradient layer and output layer serial number being of end node to a next user terminal, which any client can also be seen as, in a backward direction in this ring topology. Each client is capable of calculating a gradient which can be seen as a local network gradient that corresponds to backward propagation. As established in previous limitations the gradients correspond to propagation length steps, in Fig. 2 Client A could be an end node and it could transmit backwards to Client D which can be the current backward current node and Client D can transmit the next layer to Client C which can be the start node. Neither Zhu or Aggarwal appear to explicitly teach “…multiplying, by the end node, the local network gradient with the aggregation weight of the start node to obtain a weighted gradient corresponding to the end node…; …and multiplying the local network gradient with the aggregation weight of the start node to obtain a weighted gradient of the backward current node…; …and multiplying, by the start node, the local network gradient with the aggregation weight of the start node to obtain the weighted gradient corresponding to the start node…”, However in the same field of art, Dimitriadis teaches “…multiplying, by the end node, the local network gradient with the aggregation weight of the start node to obtain a weighted gradient corresponding to the end node…” See Dimitriadis in paragraph [0081] describing, “After the weight factor selector 340 selects the selected weight factors 322 from the available sets of weight factors 336 and 338, the gradient aggregator 318 is configured to generate a global gradient 324 based on the selected weight factors 322 and the gradients 316 provided as input to the gradient aggregator 318. In some examples, generating the global gradient 324 includes applying, to each gradient 316, the selected weight factor 322 that was generated with respect to the gradient 316 to form weighted gradients 323 (e.g., multiplying the gradient 316 by the weight factor 322) and then combining or aggregating all of the weighted gradients 323 to form the global gradient 324 (e.g., summing all of the weighted gradients 323 and dividing the result by a quantity of gradients to achieve average gradient values).” Further, see Dimitriadis in paragraph [0028] describing, “Further, the organization of the system 200 (e.g., the clients 211-215 being separate from the gradient aggregator 218 and the global model 202) and that the clients are enabled to generate gradients 216 locally and provide those gradients to the gradient aggregator 218 in lieu of providing private or otherwise sensitive data sets enables the system 200 to advantageously train the global model based on a variety of different data sets from different sources without compromising the security and/or privacy concerns of those data sets.” Here, Dimitriadis describes a process of multiplying a global gradient which can be the local network gradient with an aggregation weight to obtain a weighted gradient. Dimitriadis then establishes clients that generate gradients, as known in a federated learning system and in distributed federated learning, in an analogous system any of the client can act as start, end, or current node and each of the clients are able to generate the gradients locally. Further, Dimitriadis teaches “…and multiplying the local network gradient with the aggregation weight of the start node to obtain a weighted gradient of the backward current node…” See Dimitriadis in paragraph [0081] describing, “After the weight factor selector 340 selects the selected weight factors 322 from the available sets of weight factors 336 and 338, the gradient aggregator 318 is configured to generate a global gradient 324 based on the selected weight factors 322 and the gradients 316 provided as input to the gradient aggregator 318. In some examples, generating the global gradient 324 includes applying, to each gradient 316, the selected weight factor 322 that was generated with respect to the gradient 316 to form weighted gradients 323 (e.g., multiplying the gradient 316 by the weight factor 322) and then combining or aggregating all of the weighted gradients 323 to form the global gradient 324 (e.g., summing all of the weighted gradients 323 and dividing the result by a quantity of gradients to achieve average gradient values).” Further, see Dimitriadis in paragraph [0028] describing, “Further, the organization of the system 200 (e.g., the clients 211-215 being separate from the gradient aggregator 218 and the global model 202) and that the clients are enabled to generate gradients 216 locally and provide those gradients to the gradient aggregator 218 in lieu of providing private or otherwise sensitive data sets enables the system 200 to advantageously train the global model based on a variety of different data sets from different sources without compromising the security and/or privacy concerns of those data sets.” Here, Dimitriadis describes a process of multiplying a global gradient which can be the local network gradient with an aggregation weight to obtain a weighted gradient. Dimitriadis then establishes clients that generate gradients, as known in a federated learning system and in distributed federated learning, in an analogous system any of the client can act as a start or backward current node and each of the clients are able to generate the gradients locally. Further, Dimitriadis teaches “…and multiplying, by the start node, the local network gradient with the aggregation weight of the start node to obtain the weighted gradient corresponding to the start node…” See Dimitriadis in paragraph [0081] describing, “After the weight factor selector 340 selects the selected weight factors 322 from the available sets of weight factors 336 and 338, the gradient aggregator 318 is configured to generate a global gradient 324 based on the selected weight factors 322 and the gradients 316 provided as input to the gradient aggregator 318. In some examples, generating the global gradient 324 includes applying, to each gradient 316, the selected weight factor 322 that was generated with respect to the gradient 316 to form weighted gradients 323 (e.g., multiplying the gradient 316 by the weight factor 322) and then combining or aggregating all of the weighted gradients 323 to form the global gradient 324 (e.g., summing all of the weighted gradients 323 and dividing the result by a quantity of gradients to achieve average gradient values).” Further, see Dimitriadis in paragraph [0028] describing, “Further, the organization of the system 200 (e.g., the clients 211-215 being separate from the gradient aggregator 218 and the global model 202) and that the clients are enabled to generate gradients 216 locally and provide those gradients to the gradient aggregator 218 in lieu of providing private or otherwise sensitive data sets enables the system 200 to advantageously train the global model based on a variety of different data sets from different sources without compromising the security and/or privacy concerns of those data sets.” Here, Dimitriadis describes a process of multiplying a global gradient which can be the local network gradient with an aggregation weight to obtain a weighted gradient. Dimitriadis then establishes clients that generate gradients, as known in a federated learning system and in distributed federated learning, in an analogous system any of the client can act as a start node and each of the clients are able to generate the gradients locally. It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base references of Zhu and Aggarwal with the teachings of Dimitriadis by using Zhu’s teachings of a system for distributed federated learning using ring topology, and Aggarwal’s teachings of federated learning trained recognition model, and incorporate with and Dimitriadis’s teachings of training a global model and generating a plurality of gradients. One of ordinary skill in the art would be motivated to do so because by integrating Dimitriadis’s frameworks into the methods of Zhu and Aggarwal, which are all in the same field of art of federated learning, one of ordinary skill in the art would bring a “disclosure [that] addresses the challenges of efficiently performing distributed or federated model training using a plurality of data sets. The DGA process described herein can achieve fast convergence speed and high accuracy in general distributed computer environments, especially if the data sets consist of various types of data with unbalanced distributions.” (Dimitriadis, paragraph [0014]). Claim(s) 7 is rejected under 35 U.S.C. 103 as being unpatentable over Zhu R. et al, in view of Aggarwal D. et al, further in view of Dimitriadis D. et al, and further in view of Pezeshki H. et al, (US. Patent Application Publication 20220182802 A1) effectively filed on December 3, 2020 (hereafter, Pezeshki). Claim 7: Regarding claim 7, Zhu in view of Aggarwal, and further in view of Dimitriadis teaches the limitations of claim 6. Further, Zhu teaches “The model training method as claimed in claim 6, wherein the step of updating the current-time local model of the start node based on weighted gradients generated by the start nodes in the local joint processing, comprises: calculating a sum of weighted gradients corresponding to the start node based on the weighted gradients generated in the local joint processing performed by the start nodes;” See Zhu in paragraph [0043] describing, “Each given client 22 executes a machine learning algorithm to perform forward propagation using the data randomly sampled from its local dataset 28 (or the mini-batch of data randomly sampled from its local dataset 28) to obtain a prediction for its local model 26, compute a loss for its local model 26 in accordance with a loss function, perform backpropagation to update its respective local model 26, and compute a gradient. The gradient may be represented as: PNG media_image1.png 54 116 media_image1.png Greyscale where wi denotes the set of parameters (or weights) of the local model 26 at the ith client 22, and ƒ(wi; ξi) is the local model 26 at the ith client 22.” Further, see Zhu in paragraph [0044] describing, “Each client 22 shares its respective gradient with its neighbor clients 22, as indicated in FIG. 2, according to an AllReduce process. The AllReduce process is performed among the clients 22 to compute the mean of gradients of all clients 22. The result of the AllReduce process is that all clients 22 have a local model that is updated based on the mean of gradients from all clients 22. That is, the local model 26 at each client 22 is updated based on the mean of the gradients ΔwA, ΔwB, ΔwC and ΔwD.” Further, see Zhu in paragraph [0088] describing, “At 514, each given client 102 aggregates the set(s) of local model parameters received at 512. For example, the set(s) of local model parameters may be aggregated by computing a weighted sum or weighted average.” Here, Zhu establishes a local model of all clients, in which any client can be a start node as established and weighted gradients are established with the gradient represented with parameters or weights and a mean of all the gradients from all the gradients that corresponds to any client or start node. A calculated weighted sum is also established for each given client. Local joint processing is performed by each client with the propagation process in the ring topology described. None of Zhu, Aggarwal, or Dimitriadis appear to explicitly teach “and calculating a product of the sum of the weighted gradients corresponding to the start node and a preset learning rate, and subtracting the product from a parameter of the current-time local model of the start node to obtain an updated current-time local model of the start node, thereby when the local joint processing does not correspond to the preset number of times, using the updated current-time local model for next local joint processing.”, However in the same field of art, Pezeshki teaches “and calculating a product of the sum of the weighted gradients corresponding to the start node and a preset learning rate, and subtracting the product from a parameter of the current-time local model of the start node to obtain an updated current-time local model of the start node, thereby when the local joint processing does not correspond to the preset number of times, using the updated current-time local model for next local joint processing.” See Pezeshki in paragraph [0081] describing, “In some aspects, the federated learning configuration may indicate a number of training epochs to be performed by the UE 405 during the local training time period. In aspects in which the number of training epochs is greater than one, the federated learning configuration may indicate a learning rate. The learning rate is a parameter that indicates the amount that the parameters w(n) are to be adjusted with respect to the gradients after an epoch and for an immediately following epoch. For example, a new parameter (e.g., neural network weight) may be computed by subtracting a product of the corresponding gradient and the learning rate from the existing parameter. In some aspects, the learning rate may be indicated as a function of the number of training epochs.” It would have been obvious to one of ordinary skill in the art before the effective filing date of the claimed invention to combine the base references of Zhu, Aggarwal, and Dimitriadis with the teachings of Pezeshki by using Zhu’s teachings of a system for distributed federated learning using ring topology, Aggarwal’s teachings of federated learning trained recognition model, and Dimitriadis’s teachings of training a global model and generating a plurality of gradients, and incorporate with Pezeshki’s teachings of federated learning configuration. One of ordinary skill in the art would be motivated to do so because by integrating Pezeshki’s frameworks into the methods of Zhu, Aggarwal and Dimitriadis, which are all in the same field of art of federated learning, one of ordinary skill in the art would bring “A UE 120 [that] may train a machine learning component such as a neural network by optimizing a set of model parameters, w(n), associated with the machine learning component, where n is the federated learning round index. The set of UEs 120 may be configured to provide local updates to the base station 110 multiple times (e.g., periodically, on demand, upon updating a local machine learning component, etc.).” (Pezeshki, paragraph [0067]). Allowable Subject Matter Claims 3-4 are objected to as being dependent upon a rejected base claim, but would be allowable if rewritten in independent form including all of the limitations of the base claim and any intervening claims. Conclusion Any inquiry concerning this communication or earlier communications from the examiner should be directed to HASSAN R SESAY whose telephone number is (571)272-8493. The examiner can normally be reached Monday-Friday 8am-5pm. Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice. If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Usmaan Saeed can be reached at (571) 272-4046. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300. Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000. /HASSAN RAMADAN SESAY/Examiner, Art Unit 2146 /USMAAN SAEED/Supervisory Patent Examiner, Art Unit 2146
Read full office action

Prosecution Timeline

Jun 08, 2024
Application Filed
Oct 27, 2026
Non-Final Rejection mailed — §103 (current)

Strategy Recommendation AI-generated — please review before filing

Get a prosecution strategy drawn from examiner precedents, rejection analysis, and claim mapping.
Typically takes 5-10 seconds — AI-generated, attorney review required before filing

Prosecution Projections

1-2
Expected OA Rounds
0%
Grant Probability
0%
With Interview (+0.0%)
2y 11m (~6m remaining)
Median Time to Grant
Low
PTA Risk
Based on 1 resolved cases by this examiner. Grant probability derived from career allowance rate.

Sign in with your work email

Enter your email to receive a magic link. No password needed.

Personal email addresses (Gmail, Yahoo, etc.) are not accepted.

Free tier: 3 strategy analyses per month