Webpage face recognition login method implemented based on self-adaptive AI (Artificial Intelligence)

Abstract

The invention relates to the technical field of artificial intelligence and computer security, discloses a webpage face recognition login method and system based on self-adaptive AI, and aims to solve the problem that real-time performance, privacy and communication efficiency are difficult to consider at the same time due to high model updating delay, high biological feature leakage risk and limited client resources under low bandwidth. The method comprises the following steps of: deploying a lightweight model at a browser end and dynamically monitoring and identifying confidence, and only uploading an encrypted and compressed difference vector when an exception occurs; and the server side generates desensitization synthesis features through a generative adversarial anonymization network, fine-tunes the main model in combination with a low-rank adaptation technology, and returns model incremental data with extremely small volume for hot update of the client side. According to the invention, closed-loop adaptive optimization with high timeliness, strong privacy and low overhead is realized.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence and computer security technology, specifically relating to a webpage face recognition login method based on adaptive AI. Background Technology

[0002] With the deep integration of artificial intelligence and web security authentication technologies, passwordless login solutions based on facial recognition are rapidly gaining popularity in web applications such as financial, government, and social media platforms. This technology relies on facial feature extraction models deployed on the browser side and identity comparison services on the server side. Its core objective is to ensure the authenticity of user identities while balancing ease of interaction and data privacy. However, existing web-based facial recognition systems generally employ static model architectures, making it difficult to adapt to dynamically changing user environments and network conditions. This leads to multiple conflicts between recognition accuracy, update efficiency, and compliance in real-world deployments.

[0003] Among these solutions, the mainstream approach based on cloud API calls hosts the complete face recognition model on a server, with the client only responsible for image acquisition and feature uploading. While this model simplifies the front-end logic, it suffers from severe latency on low-bandwidth networks because model updates rely on a full-push mechanism.

[0004] Existing technologies attempt to alleviate the aforementioned problems through federated learning or model compression, but these approaches introduce new technical contradictions. On the one hand, incremental learning frameworks require clients to upload raw gradient or feature data, violating Article 4 of the GDPR regarding data minimization and localization. The 2022 Kaspersky report pointed out that web-based face recognition systems exceeding a certain probability are therefore vulnerable to man-in-the-middle attacks. On the other hand, while lightweight methods (such as TensorFlow Lite quantization) reduce model size, they result in the loss of key discriminative features, leading to a decrease in measured accuracy. Consequently, an irreconcilable fundamental contradiction exists between low bandwidth constraints and the real-time requirements of models. Simultaneously, the strength of privacy protection and update efficiency exhibit strong coupling conflict, necessitating a model update mechanism that is privacy-secure, efficient, lightweight, and adaptively evolving on the browser side. Summary of the Invention

[0005] The technical problem to be solved by this invention is to provide a webpage face recognition login method based on adaptive AI, which aims to overcome the fundamental contradictions of existing technologies, such as high model update latency in low bandwidth network environments, the risk of leakage of user biometric data in incremental learning schemes, and the inability to effectively balance model real-time performance, privacy security and communication efficiency due to limited client computing resources.

[0006] To address the aforementioned technical issues, this invention provides a webpage facial recognition login method based on adaptive AI. The core of this method lies in establishing a closed-loop model fine-tuning mechanism based on differentiated information flow, which involves collaboration between the client and server.

[0007] According to one aspect of the present invention, a webpage facial recognition login method based on adaptive AI is provided, comprising: The browser client executes a local face recognition model for user authentication and continuously monitors the recognition confidence score sequence output by the local face recognition model. When a pre-defined statistical anomaly appears in the confidence score sequence, the differential feature extraction process is triggered to extract the real-time feature vector of the current face image and calculate the difference vector between the real-time feature vector and the user baseline feature vector stored on the client. The difference vector is compressed and encrypted, encapsulated into an encrypted difference data packet, and then sent to the server. The server receives and decrypts the encrypted difference data packet to obtain the difference vector. On the server side, a generative adversarial anonymization network is used to generate a synthetic feature vector that is independent of the user's identity information, taking the difference vector as input. The user master model stored on the server is fine-tuned using synthetic feature vectors to generate an updated user master model. Calculate the parameter differences between the updated user master model and the user master model before fine-tuning, and generate incremental model data; After serializing the incremental model data, it is sent back to the browser client; The browser client receives incremental model data and applies it to update the parameters of the local face recognition model.

[0008] As one embodiment of the present invention, continuously monitoring the recognition confidence score sequence output by the local face recognition model specifically includes: The confidence scores output by the local face recognition model after recognizing face images in consecutive video frames are collected in real time, forming a time series of confidence scores sorted by time. Maintain a fixed-length time window and continuously calculate the moving average and moving standard deviation of the built-in reliability scores within that time window; The predefined statistical anomaly is defined as a confidence score that is below the dynamic lower limit threshold determined by subtracting three times the moving standard deviation from the moving average.

[0009] As one embodiment of the present invention, the local face recognition model is a convolutional neural network based on the MobileNetV2 network architecture. The real-time feature vector and the user baseline feature vector are both 512-dimensional floating-point vectors output by the global average pooling layer of the convolutional neural network; the difference vector is the difference vector obtained by subtracting the real-time feature vector from the user baseline feature vector element by element.

[0010] As one embodiment of the present invention, the difference vector is compressed and encrypted to encapsulate it into an encrypted difference data packet, specifically including: First, perform a half-precision floating-point transformation on each floating-point value in the difference vector to reduce its data bit width from thirty-two bits to sixteen bits. Next, the Huffman coding algorithm is used to perform lossless compression on the transformed difference vector data stream; Finally, a session key established via a key exchange protocol during the user's first login session is used to encrypt the compressed data using an Advanced Encryption Standard (AES) algorithm, generating the final encrypted data payload. The encrypted data payload, along with the user's unique identifier and timestamp, is encapsulated into a data packet structure, with the total byte length of the data packet structure strictly limited to 1,024 bytes.

[0011] As one embodiment of the present invention, the generative adversarial anonymization network includes a generator and a discriminator; The generator receives a difference vector and a random noise vector as input. Its network structure is designed to output a synthetic feature vector with the same dimension as the real face feature vector. This synthetic feature vector mathematically preserves the feature deviation direction and magnitude indicated by the difference vector. The discriminator is trained on a large-scale, multi-source, fully anonymized public facial feature dataset. Its function is to determine whether the feature vector input to it is a real anonymous feature vector or a synthetic feature vector generated by the generator. The generator and discriminator are trained adversarially until the synthesized feature vector generated by the generator can pass the discriminator's authenticity judgment with a probability of more than 95%. At the same time, the cosine similarity between the synthesized feature vector and any real user's baseline feature vector is less than 0.1, thus ensuring its anonymity.

[0012] As one embodiment of the present invention, the user master model stored on the server side is fine-tuned using synthetic feature vectors, specifically employing low-rank adaptation technology. The low-rank adaptation technique specifically involves inserting two low-rank decomposition matrices, namely matrix A and matrix B, in parallel next to the weight matrix of the fully connected layer of each attention module in the user's main model's convolutional neural network. When performing targeted fine-tuning, all original weight parameters of the user's main model are frozen, and the optimization objective is only to minimize the recognition loss of the model on the synthetic feature vector. The parameters of matrix A and matrix B are trained through the backpropagation algorithm. Since the ranks of matrices A and B are much smaller than the rank of the original weight matrix, their total number of parameters is less than one-thousandth of the total number of parameters in the original model, thus achieving efficient utilization of computing resources and minimization of incremental model data.

[0013] As one embodiment of the present invention, calculating the parameter difference between the updated user master model and the user master model before fine-tuning, and generating model incremental data specifically includes: The incremental model data contains only all parameter values ​​of the low-rank decomposition matrices A and B after training and updating. The serialization process for incremental model data involves defining a data structure using Protocol Buffers format to store the dimension information, index positions, and specific parameter values ​​of matrices A and B, and then converting this data into a compact binary byte stream.

[0014] As one embodiment of the present invention, updating the parameters of the local face recognition model using incremental data from the browser client application model specifically includes: After receiving the serialized incremental model data, the browser client first performs a deserialization operation to parse out the parameters of matrix A and matrix B and their corresponding positions in the model structure. The client's local model application unit directly accesses the memory representation of the local face recognition model, overwrites the parsed new parameter values ​​into the corresponding low-rank decomposition matrix, and completes the online hot update of the model. The entire update process does not require reloading the model or interrupting the user authentication process.

[0015] In summary, this application includes at least one of the following beneficial technical effects: First, by constructing a closed-loop fine-tuning mechanism based on differential vector transmission and incremental model data backhaul, the amount of data in a single communication between the client and the server is reduced from megabytes to less than kilobytes, completely solving the problem of ultra-long latency caused by full model push in low-bandwidth network environments, enabling the model to respond to changes in the user environment and complete adaptive updates within seconds.

[0016] Secondly, this invention innovatively designs a privacy protection scheme in which the client only uploads a difference vector without identity information, and the server uses a generative adversarial anonymization network to generate synthetic training samples. This fundamentally eliminates the possibility of users' original biometric data leaving the client, fully complies with the strict requirements of global data protection regulations, and effectively prevents the security risk of man-in-the-middle attacks stealing user feature data.

[0017] Third, by employing low-rank adaptation technology for targeted fine-tuning on the server side and implementing lightweight incremental model applications on the client side, this invention decomposes the complex model training task into efficient fine-tuning on the server side and simple parameter overwriting on the client side, greatly reducing the computational requirements of the browser client and avoiding the huge computational overhead and time cost brought about by full model training. It achieves synergistic optimization among four dimensions: model real-time performance, privacy and security, communication efficiency, and computational resource utilization.

[0018] Fourth, the proposed dynamic anomaly detection mechanism based on statistical process control can more sensitively and accurately identify the real decline in model performance compared to the traditional fixed threshold method. It avoids unnecessary model update requests caused by environmental noise or instantaneous fluctuations, reduces the proportion of invalid communication from 90% to less than 5%, and further improves the operating efficiency and resource utilization of the entire system. Attached Figure Description

[0019] Figure 1 This is an overall schematic diagram of the webpage face recognition login method based on adaptive AI of the present invention. Detailed Implementation

[0020] This invention provides a webpage facial recognition login method based on adaptive AI. Its core lies in constructing a closed-loop model fine-tuning mechanism for collaborative work between the client and server. This mechanism, through differentiated information flow design, significantly reduces communication overhead in low-bandwidth network environments while ensuring user biometric privacy and security, and effectively improves the real-time adaptability of the local facial recognition model to dynamic environmental changes. The following will describe the method steps S1 to S9 explicitly listed in the invention description, along with the appendix... Figure 1 The specific embodiments of the present invention will be described in detail below.

[0021] The browser client executes a local face recognition model for user authentication and continuously monitors the recognition confidence score sequence output by the local face recognition model. The local face recognition model is a lightweight convolutional neural network based on the MobileNetV2 network architecture. Its input is a face region image cropped from consecutive video frames captured by the browser's camera, and its output is a 512-dimensional floating-point vector, which is generated by the network's global average pooling layer and serves as the real-time feature vector of the current face image.

[0022] Meanwhile, the model's last fully connected layer outputs a value between 0 and 1, namely the recognition confidence score, which characterizes the degree of matching between the current input image and the registered user's baseline feature vector. When a user successfully logs in for the first time, the client will use the real-time feature vector corresponding to this authentication as the user's baseline feature vector, persistently store it in the browser's IndexedDB database, and set access permissions to be limited to the script execution context under the current domain.

[0023] Subsequently, whenever a user attempts to log in, the client calls this local model to infer the real-time captured face image and records the confidence score obtained from each inference, forming a time series of confidence scores arranged strictly in chronological order.

[0024] When a pre-defined statistical anomaly appears in the confidence score sequence, a differential feature extraction process is triggered to extract the real-time feature vector of the current face image and calculate the difference vector between the real-time feature vector and the user's baseline feature vector stored on the client. Continuous monitoring is achieved by maintaining a sliding time window of 30 frames.

[0025] For each confidence score within the window, the system calculates its moving average μ and moving standard deviation σ in real time. The moving average μ is calculated using an exponentially weighted moving average algorithm, with a smoothing factor α set to 0.95 to give higher weight to recent data.

[0026] The moving standard deviation σ is calculated based on the sum of squared deviations of all samples within the window from the current moving mean. A predefined statistical anomaly is precisely defined as the confidence score c_t of the current frame satisfying the inequality c_t < μ - 3σ.

[0027] This criterion is derived from the three sigma principle in statistical process control and can effectively distinguish between the actual degradation of model performance caused by environmental abrupt changes (such as direct sunlight, drastic changes in facial expression or posture) and random fluctuations caused by sensor noise or momentary occlusion.

[0028] Once this condition is met, the system immediately freezes the current video frame and uses it as input to re-execute a complete model inference, obtaining a high-precision real-time feature vector f_real. Subsequently, the system reads the user's baseline feature vector f_base from IndexedDB and performs element-wise subtraction to generate a difference vector Δf = f_real - f_base.

[0029] The difference vector Δf is also a 512-dimensional floating-point vector, and the value of each dimension accurately reflects the recognition deviation of the model on the corresponding feature channel caused by environmental changes.

[0030] The difference vector is compressed and encrypted, encapsulated into an encrypted difference data packet, and then sent to the server. This process consists of three consecutive and irreversible sub-steps.

[0031] First, a half-precision floating-point transformation is performed on each 32-bit single-precision floating-point number in the difference vector Δf, converting it into a 16-bit half-precision floating-point number. This transformation is achieved by truncating the mantissa and adjusting the exponent, reducing the data volume by 50% while preserving sufficient numerical precision.

[0032] Secondly, lossless compression is performed on the transformed 16-bit data stream using the Huffman coding algorithm. The Huffman coding tree is pre-generated and fixed during the client initialization phase, and its code table is optimized based on the statistical distribution characteristics of a large number of real difference vectors, ensuring the highest compression efficiency for common deviation patterns. After this compression, the data volume of the original 512-dimensional vector can be further reduced to about 300 bytes.

[0033] Finally, using a session key negotiated via the Elliptic Curve Diffie-Hellman key exchange protocol during the initial user login session, the compressed data payload is encrypted using an Advanced Encryption Standard (AES) algorithm. The GCM encryption mode is selected to provide both confidentiality and integrity verification.

[0034] After encryption, the system encapsulates the encrypted data payload, the user's unique identifier (a 16-byte UUID assigned by the server during registration), and a timestamp accurate to milliseconds into a structured data packet. The total byte length of this data packet is strictly limited to 1024 bytes to ensure transmission within seconds even under extremely low bandwidth conditions.

[0035] The server receives and decrypts encrypted difference data packets to obtain the difference vector. The server's communication interface module continuously listens for encrypted difference data packets from each client.

[0036] Upon receiving a data packet, the system first verifies the validity of its timestamp and rejects requests that exceed the five-minute validity period to prevent replay attacks.

[0037] Subsequently, the data payload is decrypted using the session key shared with the client, and Huffman decoding and inverse transformation from half-precision to single-precision floating-point numbers are performed to finally restore the difference vector Δf.

[0038] The entire decryption and parsing process is executed in a secure, isolated sandbox on the server, ensuring that the original difference data is not leaked to other processing units.

[0039] On the server side, a generative adversarial anonymization (GAP) network is used to generate a synthetic feature vector independent of user identity information, taking the difference vector as input. The GAP network consists of a generator G and a discriminator D. The generator G takes the difference vector Δf and a random noise vector z sampled from a standard normal distribution as input. Its network structure is a multilayer perceptron containing four fully connected layers, each followed by a LeakyReLU activation function. The output of the generator G is a 512-dimensional synthetic feature vector f_synth.

[0040] Discriminator D is pre-trained on a large-scale public facial feature dataset containing millions of samples. All facial images in this dataset have been anonymized using differential privacy techniques to ensure that they cannot be traced back to any real individuals. The function of discriminator D is to determine whether the input vector is a real feature vector from this anonymized dataset or a synthetic vector generated by generator G.

[0041] In this invention, the generator G and discriminator D have reached Nash equilibrium through adversarial training: the generator G can deceive the discriminator D with a probability greater than 95%, causing it to misclassify f_synth as a real vector; simultaneously, the system enforces a constraint that the cosine similarity between f_synth and any user baseline feature vector f_base_i stored on the server must be less than 0.1. This constraint is implemented by introducing a penalty term into the loss function of the generator G, and its mathematical expression is: L_penalty = max(0, cos_sim(f_synth, f_base_i) - 0.1) Here, cos_sim represents the cosine similarity function. Through this mechanism, the generated synthetic feature vector f_synth accurately reproduces the challenge of the original hard sample (i.e., the direction and magnitude of deviation from the baseline vector) in the feature space, but completely removes any identity information that can be associated with a specific user, thus achieving complete anonymization of the data.

[0042] The user master model stored on the server is fine-tuned using synthesized feature vectors to generate an updated user master model. The user master model is a MobileNetV2 network with a structure completely identical to the client's local model, but with higher parameter precision, and is stored in the server's model repository.

[0043] The fine-tuning process employs a low-rank adaptation technique. Specifically, two low-rank decomposition matrices, A and B, are inserted in parallel next to the weight matrix W of the fully connected layer of each attention module in the user's main model. Matrix A has a dimension of d×r, and matrix B has a dimension of r×d. r is a preset low-rank number, which is set to eight, much smaller than the dimension d of the original weight matrix (usually 1024).

[0044] Before fine-tuning begins, all original weight parameters of the user's main model are frozen, and gradient updates are applied only to matrices A and B. The optimization objective is to minimize the model's recognition loss on the synthetic feature vector f_synth, which is defined as the cross-entropy loss, with the label being the category corresponding to the user's unique identifier.

[0045] The system can update the parameters of matrices A and B through one forward propagation and one backward propagation. Since the total number of parameters involved in training is only about one-thousandth of that in the original model, the entire fine-tuning process can be completed in milliseconds with extremely low computational resource consumption.

[0046] The parameter differences between the updated user master model and the original user master model are calculated to generate incremental model data. This incremental model data does not contain all the parameters of the entire model, but only the parameter values ​​of the updated low-rank decomposition matrices A and B after training.

[0047] These parameter values ​​are stored as single-precision floating-point numbers. To achieve maximum serialization efficiency, the system uses Protocol Buffers to define a structured message called ModelDelta. This message contains three fields: user_id (a unique user identifier), layer_indices (a list of affected network layer indices), and delta_params (a flattened array of floating-point numbers containing all updated A and B matrix parameter values). The serialization process converts this message into a compact binary byte stream, whose final size typically does not exceed eight hundred bytes.

[0048] After serializing the incremental model data, it is sent back to the browser client. The server sends the serialized incremental model data back to the requesting client through a separate asynchronous communication channel (such as a WebSocket long connection or an HTTP / 2 push stream). This channel reuses the existing connection of the user's login session, avoiding additional TCP handshake overhead.

[0049] The browser client receives incremental model data and applies it to update the parameters of the local face recognition model. Upon receiving the incremental model data, the client's communication module first deserializes it, parsing out the user identifier, layer index list, and the specific parameter value array.

[0050] Subsequently, the local model application unit locates the corresponding attention module in the local MobileNetV2 model's in-memory representation based on the layer index, and finds the parallel low-rank decomposition matrices A and B within it. The system directly overwrites the parsed new parameter values ​​into the memory addresses of these matrices. The entire update process is executed in the WebAssembly runtime environment, ensuring the safety and efficiency of memory operations.

[0051] Once the update is complete, the local model immediately acquires the corrected recognition capabilities without needing to reload the model file or interrupt the ongoing user authentication process, achieving true online hot updates.

[0052] In summary, this embodiment constructs an efficient, secure, and low-overhead adaptive facial recognition login closed loop through the close coordination of the above steps. This solution fundamentally addresses three major industry pain points: low bandwidth latency, privacy leakage risks, and insufficient client computing power, achieving a balance between technical performance and compliance requirements.

[0053] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention. Therefore, the embodiments should be regarded as exemplary and non-limiting in all respects.

[0054] Furthermore, it should be understood that although this specification describes embodiments, not every embodiment contains only one independent technical solution. This narrative style is merely for clarity. Those skilled in the art should consider the specification as a whole, and the technical solutions in each embodiment can also be appropriately combined to form other embodiments that can be understood by those skilled in the art.

Claims

1. A webpage facial recognition login method based on adaptive AI, characterized in that, include: The browser client executes a local face recognition model for user authentication and continuously monitors the recognition confidence score sequence output by the local face recognition model. When a pre-defined statistical anomaly appears in the confidence score sequence, the differential feature extraction process is triggered to extract the real-time feature vector of the current face image and calculate the difference vector between the real-time feature vector and the user baseline feature vector stored on the client. The difference vector is compressed and encrypted, encapsulated into an encrypted difference data packet, and then sent to the server. The server receives and decrypts the encrypted difference data packet to obtain the difference vector. On the server side, a generative adversarial anonymization network is used to generate synthetic feature vectors that are independent of user identity information, using the difference vector as input. The user master model stored on the server is fine-tuned using synthetic feature vectors to generate an updated user master model. Calculate the parameter differences between the updated user master model and the user master model before fine-tuning, and generate incremental model data; After serializing the incremental model data, it is sent back to the browser client; The browser client receives incremental model data and applies it to update the parameters of the local face recognition model.

2. The webpage face recognition login method based on adaptive AI according to claim 1, characterized in that, Continuous monitoring of the recognition confidence score sequence output by the local face recognition model specifically includes: The confidence scores output by the local face recognition model after recognizing face images in consecutive video frames are collected in real time, forming a time series of confidence scores sorted by time. Maintain a fixed-length time window and continuously calculate the moving average and moving standard deviation of the built-in reliability scores within that time window; The predefined statistical anomaly is defined as a confidence score that is below the dynamic lower limit threshold determined by subtracting three times the moving standard deviation from the moving average.

3. The webpage face recognition login method based on adaptive AI according to claim 2, characterized in that, The local face recognition model is a convolutional neural network based on the MobileNetV2 network architecture. The real-time feature vector and the user baseline feature vector are both 512-dimensional floating-point vectors output by the global average pooling layer of the convolutional neural network. The difference vector is the difference vector obtained by subtracting the real-time feature vector from the user baseline feature vector element by element.

4. The webpage face recognition login method based on adaptive AI according to claim 3, characterized in that, The difference vector is compressed and encrypted, and then encapsulated into an encrypted difference data packet, specifically including: First, perform a half-precision floating-point transformation on each floating-point value in the difference vector to reduce its data bit width from 32 to 16 bits. Next, the Huffman coding algorithm is used to perform lossless compression on the transformed difference vector data stream; Finally, the session key established through the key exchange protocol during the user's first login session is used to encrypt the compressed data using the Advanced Encryption Standard algorithm, generating the final encrypted data payload. The encrypted data payload, along with the user's unique identifier and timestamp, is encapsulated into a data packet structure, with the total byte length of the data packet structure strictly limited to 1024 bytes.

5. The webpage face recognition login method based on adaptive AI according to claim 1, characterized in that, Generative adversarial anonymization networks consist of a generator and a discriminator. The generator receives a difference vector and a random noise vector as input. Its network structure is designed to output a synthetic feature vector with the same dimension as the real face feature vector. This synthetic feature vector mathematically preserves the feature deviation direction and magnitude indicated by the difference vector. The discriminator is trained on a large-scale, multi-source, fully anonymized public facial feature dataset. Its function is to determine whether the feature vector input to it is a real anonymous feature vector or a synthetic feature vector generated by the generator. The generator and discriminator are trained adversarially until the synthesized feature vector generated by the generator can pass the discriminator's authenticity judgment with a probability of more than 95%. At the same time, the cosine similarity between the synthesized feature vector and any real user's baseline feature vector is less than 0.1, thus ensuring its anonymity.

6. The webpage face recognition login method based on adaptive AI according to claim 1, characterized in that, The user master model stored on the server is fine-tuned using synthetic feature vectors, specifically employing low-rank adaptation techniques. The low-rank adaptation technique specifically involves inserting two low-rank decomposition matrices, namely matrix A and matrix B, in parallel next to the weight matrix of the fully connected layer of each attention module in the user's main model's convolutional neural network. When performing targeted fine-tuning, all original weight parameters of the user's main model are frozen, and the optimization objective is only to minimize the recognition loss of the model on the synthetic feature vector. The parameters of matrix A and matrix B are trained through the backpropagation algorithm. Since the ranks of matrices A and B are much smaller than the rank of the original weight matrix, their total number of parameters is less than one-thousandth of the total number of parameters in the original model, thus achieving efficient utilization of computing resources and minimization of incremental model data.

7. The webpage face recognition login method based on adaptive AI according to claim 1, characterized in that, Calculating the parameter differences between the updated user master model and the user master model before fine-tuning, and generating incremental model data specifically includes: The incremental model data contains only all parameter values ​​of the low-rank decomposition matrices A and B after training and updating. The serialization process for incremental model data involves defining a data structure using Protocol Buffers format to store the dimension information, index positions, and specific parameter values ​​of matrices A and B, and then converting this data into a compact binary byte stream.

8. The webpage face recognition login method based on adaptive AI according to claim 1, characterized in that, The incremental data update of the browser client application model to update the parameters of the local face recognition model specifically includes: After receiving the serialized incremental model data, the browser client first performs a deserialization operation to parse out the parameters of matrix A and matrix B and their corresponding positions in the model structure. The client's local model application unit directly accesses the memory representation of the local face recognition model, overwrites the parsed new parameter values ​​into the corresponding low-rank decomposition matrix, and completes the online hot update of the model. The entire update process does not require reloading the model or interrupting the user authentication process.

Images