Training a user authentication model with federated learning

Abstract

Certain aspects of the present disclosure provide techniques for authenticating a user based on a machine learning model, including receiving user authentication data associated with a user, generating an output from a neural network model based on the user authentication data, determining a distance between the output and an embedding vector associated with the user, comparing the determined distance to a distance threshold, and making an authentication decision based on the comparison.

Description

[0001] Cross-references to related applications

[0002] This application claims the rights and priority of Greek application No. 20200100335, filed on June 12, 2020, the entire contents of which are incorporated herein by reference.

[0003] introduction

[0004] This disclosure relates to various aspects of machine learning.

[0005] Machine learning can produce trained models (e.g., artificial neural networks, trees, or other structures) that represent a generalized fit to a previously known set of training data. Applying a trained model to new data produces inferences, which can be used to gain insights about the new data. In some contexts, applying a model to new data is described as “running inference” on the new data.

[0006] Machine learning models are increasingly being used across a variety of fields, including for classification, detection, and recognition tasks. For example, machine learning models are being used to perform complex tasks on electronic devices based on sensor data provided by one or more onboard sensors, such as automatically classifying features within an image (e.g., a face).

[0007] One example application of machine learning is user authentication, which is the task of accepting or rejecting a user based on their input data (e.g., biometric data). Generally, authentication models need to be trained on large amounts of diverse user data so that the model learns the different characteristics of the data and can reliably authenticate users. One approach is to centrally collect user data and train the authentication model there. However, this solution does not protect privacy because it requires direct access to users' personal data. In user authentication, both the raw input and the embedding vector are considered sensitive information.

[0008] Distributed training of user authentication models (such as using federated learning) suffers from similar problems because user embeddings are not predefined, and therefore typically need to be defined and associated with the user by a central server. However, this approach also fails to protect privacy, as the server would be aware of the user's embeddings, which are considered sensitive information.

[0009] Therefore, there is a need for improved methods to use federated learning to train user authentication models.

[0010] Brief Overview

[0011] Some aspects provide a method including: generating error-correcting codes; assigning a unique ID as an information bit vector to a user; obtaining a codeword based on the unique ID assigned to the user; and sending the codeword to the user.

[0012] A further aspect provides a method for training a machine learning model to perform user authentication, comprising: generating an output from a neural network model based on user input data; and training the neural network model using a loss function that maximizes the correlation between the output and an embedding vector associated with the user.

[0013] A further aspect provides a method for performing user authentication, comprising: receiving user authentication data associated with a user; generating an output from a neural network model based on the user authentication data; determining a distance between the output and an embedding vector associated with the user; comparing the determined distance with a distance threshold; and making an authentication decision based on the comparison.

[0014] Other aspects include: a processing system configured to perform the foregoing methods and those methods described herein; a non-transient computer-readable medium including instructions that, when executed by one or more processors of the processing system, cause the processing system to perform the foregoing methods and those methods described herein; a computer program product implemented on a computer-readable storage medium including code for performing the foregoing methods and those methods further described herein; and a processing system including means for performing the foregoing methods and those methods further described herein.

[0015] The following description and related figures illustrate certain illustrative features of one or more embodiments in detail. Brief description of the attached diagram

[0017] The accompanying drawings illustrate certain aspects of one or more embodiments and are therefore not intended to limit the scope of this disclosure.

[0018] Figure 1 An example of how a model can be trained to cluster input data around an embedding vector is described.

[0019] Figure 2 An example of a federated learning architecture is depicted.

[0020] Figure 3 An embodiment of a method for generating pairwise remote embeddings while protecting privacy is described.

[0021] Figure 4 An example of using error-correcting codes to generate embedding vectors is described.

[0022] Figure 5 An example simplified neural network classification model that can be used to train an authentication model is depicted.

[0023] Figure 6 Depicting, for example, the use of Figure 5The example method for training a model is described in the diagram.

[0024] Figure 7 Describing for Figure 5 An example inference structure for a simplified neural network classification model.

[0025] Figure 8 Describes the use of, for example, regarding Figure 5 and 6 The example method described is to use a trained model to authenticate users.

[0026] Figure 9 An example processing system that can be configured to perform the methods described herein is depicted.

[0027] Figure 10 Another example processing system is described that can be configured to perform aspects of the various methods described herein.

[0028] To facilitate understanding, the same reference numerals are used where possible to designate common elements in the various figures. Elements and features contemplated in one embodiment may be beneficially incorporated into other embodiments without further elaboration.

[0029] Detailed description

[0030] This disclosure provides apparatus, methods, processing systems, and computer-readable media for training user authentication models using federated learning.

[0031] A brief overview of using machine learning for user authentication

[0032] User authentication generally involves the task of verifying a user's identity based on some data provided by the user. In some cases, the input data can be sensor data, such as biometric data, like the user's voice, image, fingerprint, etc.

[0033] To construct user authentication as a machine learning problem, assume there exists a set of users u i For each user, i∈{1,...,n}, there is data D. i ={x i，j y i}, j∈{1, ...,T i}, where x i，j T is the j-th input from user i. i It is the number of data points for user i, and y i It is the corresponding output vector (which may be called the embedding).

[0034] In general, embedding refers to a method of representing discrete variables as continuous vectors. For example, embedding can map discrete (e.g., categorical) variables to vectors of continuous numbers. In the context of neural network models, embedding can be a learned continuous vector representation of discrete variables.

[0035] Machine learning model F can utilize the loss function Training is performed on the data points, where:

[0036]

[0037] In Equation 1 above, d1 and d2 are distance metrics. During training, for user i, Equation 1 seeks to minimize the output of model F (i.e., F(x)). i，j )) to its embedded y i The distance, while maximizing the output of model F to other embeddings y k The distance between k and i.

[0038] Suppose model F is deployed on user i's device. When performing a query using a new data point x', if the distance from the model's output to the embedding vector of user i is less than a threshold (i.e., d(F(x'), y')), the model is considered to be in a certain position. i If d ≤ τ, where d is the distance metric and τ is the threshold, then the model authenticates the user.

[0039] Figure 1 Example 100 illustrates how a model F can be trained to cluster data (e.g., cluster 102) around embedding vectors (e.g., 104) such that the model output minimizes the distance to the corresponding embedding vector of a user and maximizes the distance to the embedding vectors of other users. Note that in Figure 1 In the diagram, the various patterns within the ellipse (e.g., cluster 102) represent different clusters.

[0040] A brief overview of federated learning

[0041] Federated learning is a framework for training machine learning models on distributed data. In one example, there might be servers `s` and a set of users `u`. i , i∈{1,...,n}. Each user can access local data D. i ={x i，j y i，j}, j∈{1, ...,T i}, where (x i，j y i，j Let be the input / output pair of user i's j-th input and output. The goal of federated learning is to allow servers to train machine learning models on users' local data without direct access to the local data.

[0042] In one example, the federated learning framework can be implemented as follows. First, server s initializes a global model with weights w. Then, for r = {1, ..., R} training epochs (or epochs), server s sends the weights of the global model to a selected user c. Subsequently, the selected user trains the global model based on their local data to obtain a model update Δw for each selected user i ∈ c. i Subsequently, the selected user updates their model Δw. i The data is sent to server s. The server then updates the weights of the global model according to the following formula:

[0043]

[0044] Figure 2 Example 200 of a federated learning architecture is depicted, in which server 202 sends the weights w of a global machine learning model to a selected user (or user device) 204 for federated learning. Subsequently, user 204 updates the model Δw. i , i∈{1…k} are sent to server 202 so that it can update the weights of the global model according to Equation 2.

[0045] User authentication using federated learning

[0046] As mentioned above, authentication models need to be trained on a large amount of diverse user data so that the model learns the different characteristics of the data and can reliably distinguish and authenticate users. For example, a speaker recognition model can be trained on speech data of users with different ages, genders, accents, etc., to improve its ability to successfully authenticate users.

[0047] One approach is to centrally collect user data and train models in a conventional, centralized manner. However, this solution does not protect privacy because it requires direct access to users' personal data. In user authentication, both the raw input and the embedding vector are considered sensitive information. The embedding vector, in particular, needs to remain private because it is used to authenticate users.

[0048] Protecting data privacy is particularly important in user authentication applications, where models may be trained and tested in hostile environments. Specifically, leakage of embedding vectors makes authentication models vulnerable to both training-time and inference-time attacks.

[0049] Federated learning enables training using large amounts of user data while maintaining data privacy. However, in federated learning for user authentication models, user embeddings are not predefined.

[0050] One way to define an embedding is for the server to assign an ID (e.g., a one-hot vector) to each user. Therefore, user i utilizes the pair (x... ij Ui To train the model, where U i It is a one-hot representation of the user ID. However, this method has several drawbacks.

[0051] For example, this method does not protect privacy because the server will know the user's embedding information.

[0052] Furthermore, the size of the network output will equal the number of users, which limits the scalability of the solution. This is because one-hot vector mapping (or encoding) generally requires the output size of the neural network to equal the number of classes. Unfortunately, this requirement does not scale well for classification tasks with a large number of classes (such as user authentication for one user per class, and the problem is to classify tens of thousands or even more users). In such cases, the number of weights in the last layer of the classification model (e.g., the classification phase) becomes very large, which increases the size of the model and therefore the storage requirements of any device running the model, and also increases the computational complexity of the model.

[0053] This model size problem is particularly pronounced in federated learning environments because weights and gradients must be communicated multiple times between the server and the user (e.g., ...). Figure 2 As described, this results in significant communication overhead and power consumption. Therefore, implementing training and inference on resource-constrained user devices, such as battery-powered devices, mobile electronic devices, edge processing devices, Internet of Things (IoT) devices, and other low-power processing devices, becomes challenging.

[0054] Another drawback of one-hot mapping is that the number of classes (e.g., users in the case of authentication models) must be predetermined before training. In some applications, it is desirable for the model to be able to dynamically handle a variable number of classes without changing the architecture. For example, in a user classification task in a distributed learning context, the number of users may not be known in advance, and users may be added during training. Therefore, one-hot mapping has a significant limitation in federated learning environments where users may be added after training has begun.

[0055] Another challenge is how to train the model without knowing the embeddings of other users. Even when each user knows their own embedding vector, they still need access to the embeddings of other users in order to train the model using a loss function (such as defined in Equation 1 above) that seeks to maximize the pairwise distance between embeddings that vary from user to user. However, as mentioned above, each user's embedding vector is privacy-sensitive and therefore should not be shared with other users or servers. Therefore, the challenge lies in maximizing the pairwise distance between embeddings in a privacy-preserving manner.

[0056] The embodiments described herein provide a federated learning framework for training user authentication models, which includes at least two improvements to conventional modeling techniques for user authentication.

[0057] First, the embodiments described herein can implement a method for generating embedding vectors using error-correcting codes (ECC) in a privacy-preserving manner, guaranteeing the minimum pairwise distance between embeddings.

[0058] Secondly, the embodiments described herein can enable improved methods for training and authentication using embedding vectors, such as those generated using error-correcting codes.

[0059] Generate remote embeddings while protecting privacy

[0060] Figure 3 Describes the method for generating data for several (n) while maintaining privacy. u Example method 300 for pairwise remote embedding of (a) users. Method 300 can be, for example, by... Figure 2 The server 202 is executed.

[0061] Method 300 begins in step 302 based on the use of (n) c n m d) The error correction code (ECC) scheme is used as input to generate the error correction code, where n c It is the length of the code word. d is the number of information bits, and d is the minimum distance of the code.

[0062] Method 300 then proceeds to step 304, where a unique ID M is assigned to user i. i As an information bit vector.

[0063] Method 300 then proceeds to step 306, where based on M i To obtain code word C i .

[0064] Method 300 then proceeds to step 308, where codeword C is sent to the user. i .

[0065] Method 300 then proceeds to step 310, where the user changes the random position of the received codeword. 1 bit, and obtain y i As its individual embedding vector. In this example, the symbol Indicates the round-down operation.

[0066] Method 300 then proceeds to step 312, where model update data is received from the user, wherein the model update data is based on codeword C. iUser-specific embeddings based on this foundation i .

[0067] In some embodiments of method 300, obtaining codewords based on unique IDs includes using an error-correcting code (ECC) scheme. In some embodiments, the error-correcting code scheme includes a Bosch-Joher-Heim (BCH) decoding scheme. In some embodiments, the error-correcting code scheme ensures that the codeword associated with a user is at a threshold distance from any other codeword associated with any other user. For example, method 300 ensures that user embeddings are separated from each other and from codewords assigned by the server by at least d. min .

[0068] In some embodiments, method 300 further includes determining the number of parity bits of the codeword.

[0069] To demonstrate the scalability of method 300, the number of users can be set to an arbitrarily high number, such as n. u = 10 billion.

[0070] Subsequently, in the first example, for n c =255, the BCH code can be constructed as (255, 37, 91). Therefore,

[0071] In another example, for nc = 511, the BCH code can be constructed as (511, 40, 191). Therefore,

[0072] In another example, for n c =1023, the BCH code can be constructed as (1023, 36, 447). Therefore,

[0073] In another example, for n c =2047, the BCH code can be constructed as (2047, 34, 959). Therefore,

[0074] These examples demonstrate that even for a very large number of users, it is possible to construct codes with codeword lengths that are orders of magnitude smaller, while still ensuring high minimum separability.

[0075] Notice, Figure 3 This is merely one example of a method, and other methods that include fewer, additional, or alternative steps may also be consistent with this disclosure.

[0076] In addition, in other aspects, the server (e.g., Figure 2(202) can determine the length of the embedding vector and send that length to the user, who can then generate a random embedding vector based on that length.

[0077] For example, given the number of users and the desired minimum distance d min The server can determine the length n of the embedding vector according to the following formula. e The minimum distance between the random embedding vectors is greater than τ with a probability of at least q.

[0078]

[0079] in

[0080] And k is the number of user inputs.

[0081] Figure 4 An example of using the ECC method to generate embedding vectors is depicted.

[0082] For example, in step 310 of method 300, the user can change the codewords 401A-401C sent by the server. Each bit is used to generate the embeddings 405A-405C. This bit change generates random spaces 403A-403C around the codewords 401A-401C respectively.

[0083] In the worst-case scenario, the generated embedding (e.g., 405A) could be directed toward another user's codeword (e.g., 410C) and the embedding (405C), as in the example indicated by 402. However, even in the worst-case scenario, the generated embeddings are guaranteed to be at least d apart from each other and from the codeword assigned by the server. min Distance, such as in 404.

[0084] Training and authentication using the generated embeddings

[0085] Figure 5 Example 500 of a simplified neural network classification model that can be used to train a certification model is depicted. In this example, the input x is processed by a machine learning model (such as a neural network 502) and subsequently by a non-linear activation function 504 (such as a sigmoid) to generate the model output. In some examples, input x can be biometric data input used to perform user authentication, such as fingerprints, facial scans, iris scans, voice data, etc.

[0086] The sigmoid activation function 504 can be used to allow random binary embeddings. In random binary embeddings, a set of unique random binary embeddings (e.g., vectors) are generated with the smallest possible separation between them, and each of these vectors can be associated with a user. The size of the random binary embeddings can be chosen such that the minimum difference between any two embeddings is greater than a threshold difference with a high probability.

[0087] To achieve random binary embeddings, the model structure of a neural network-based classification model can be modified for both training and inference. Specifically, in the training context, the classification model structure is modified compared to the regular structure because the network's output (e.g., Z) is processed by a sigmoid nonlinear operation (e.g., 504). The sigmoid operation is an element-wise nonlinear function that maps each element of the input to a value between 0 and 1, and can be defined as:

[0088]

[0089] The Sigmoid function allows each element in the model's output vector (e.g., a bit in a binary vector) to be processed independently, instead of requiring the sum of the elements to be equal to 1, as is the case with Softmax.

[0090] The advantage of binary embedding is that it significantly reduces the number of parameters in the last layer of the model (e.g., a fully connected layer) compared to conventional methods (such as one-hot encoding).

[0091] As mentioned above, error-correcting codes can be used to generate initial embeddings with guaranteed minimum separation. When using decoded binary embedding methods, the embedding can be referred to as a codeword.

[0092] Generally, a codeword C can be generated by concatenating (·||·)M information bits and P parity bits (e.g., C = M||P), where P is a function of M. This encoding can advantageously guarantee the pairwise distance between any two codewords.

[0093] For the decoded binary embedding, the binary representation of the class (e.g., user ID) is used as the information bits M of the codeword C. Decoding can then be accomplished using various error-correcting code (ECC) schemes, such as Reed-Müller (RM) coding, convolution-based coding, and Bosch-Joher-Heim (BCH) codes, to name just a few examples.

[0094] Figure 6 Depicting, for example, the use of Figure 5 Example method 600 for training a model using the structure described in the text.

[0095] Initially, let the length of the model output be n. cEach output element can be 0 or 1 independently. To ensure that the model output elements are in the range [0, 1], the model output is activated by the sigmoid non-linear activation function, which, as described above, forces each output element into the range [0, 1].

[0096] Therefore, method 600 begins at step 602 with generating model output based on the sigmoid nonlinear function.

[0097] Method 600 then proceeds to step 604, where the model is trained using a loss function that maximizes the correlation between the model output and the embedding. In one example, the loss function is:

[0098]

[0099] Where y is the embedding vector. This loss function is used to increase the correlation between y and... The correlation between them. In other words, when y is 1, this loss function promotes... The loss function approaches 1, while when y is 0, it causes... Close to 0.

[0100] In some aspects, the embedding vectors are based on data from federated learning servers (such as...). Figure 2 The codeword received by server 202. As mentioned above, the codeword can be based on an error correction code scheme, such as regarding... Figure 3 As described.

[0101] Notice, Figure 6 This is merely one example of a method, and other methods that include fewer, additional, or alternative steps may also be consistent with this disclosure.

[0102] Figure 7 Describing for Figure 5 Example inference structure 700 for a simplified neural network classification model.

[0103] In this example, the inference structure includes the trained model 702 (e.g., based on...). Figure 6 The neural network model trained by the method described in the document (and the sigmoid nonlinear activation function 704).

[0104] The output of the sigmoid function is then compared with the user-related embedding based on the distance function 706. For example, the L2 norm (Euclidean) distance function can be used. Embeddings can be generated, as described above. Figure 3 The subject of discussion.

[0105] Then, at step 708, the distance metric d generated by the distance function 706 is compared with a predetermined threshold. This comparison determines whether the authentication was successful or failed.

[0106] Figure 8 Describes the use of, for example, about Figure 7 Example method 800 for authentication using the described model, which can, for example, be as follows: Figure 5 and 6 They were trained as described.

[0107] Method 800 begins at step 802 with receiving user authentication data. For example, user authentication data input may include audio data (e.g., voice samples), video or image data (e.g., pictures of faces or eyes), sensor data (e.g., fingerprint sensor or multi-point depth sensor), other biometric data, and combinations thereof.

[0108] Method 800 then proceeds to step 804, where a model output is generated based on user authentication data. In some embodiments, the model output... Based on the sigmoid nonlinear activation function (e.g., from...) Figure 7 The output of the sigmoid function 704 in (the code).

[0109] Method 800 then proceeds to step 806, where the model output is determined. The distance between the model output and the user's embedding y. In one example, for input x, the distance from the model output to the embedding vector is determined by... The L2 norm distance is calculated, where F is the model, y is the user's embedding vector, and... It is the model output generated by σ(F(x)).

[0110] Method 800 then proceeds to step 808, where the determined distance is compared with a threshold τ.

[0111] Method 800 then proceeds to step 810, where an authentication decision is made based on comparison. For example, if the distance d is less than a threshold τ, the input is authenticated; otherwise, the input is rejected.

[0112] In some embodiments, the threshold τ can be determined such that the True Class Rate (TPR) is greater than a value, such as p = 90%. TPR is defined as the ratio of correctly authenticated real users.

[0113] In some embodiments of method 800, a "warm-up phase" is performed on the model. During the warm-up phase, several user inputs x are collected. i And calculate the corresponding distance d i A threshold is then set so that a proportion p of the input is authenticated.

[0114] Notice, Figure 8This is merely one example of a method, and other methods that include fewer, additional, or alternative steps may also be consistent with this disclosure.

[0115] Example processing system

[0116] Figure 9 An example processing system 900 is depicted, which can be configured to perform various methods described herein (including, for example, regarding...). Figure 3 , 6 And aspects of the method described in 8. For example, the processing system 900 could be a user device participating in federated learning of a user authentication model, such as regarding Figure 2 As described.

[0117] The processing system 900 includes a central processing unit (CPU) 902, which in some examples may be a multi-core CPU. Instructions executed at the CPU 902 may be loaded, for example, from program memory associated with the CPU 902 or from memory 924.

[0118] The processing system 900 also includes additional processing components tailored for specific functions, such as a graphics processing unit (GPU) 904, a digital signal processor (DSP) 906, a neural processing unit (NPU) 908, a multimedia processing unit 910, and a wireless connectivity component 912.

[0119] NPUs (such as the 908) are generally configured to implement dedicated circuitry for the control and arithmetic logic used to execute machine learning algorithms, such as those for processing artificial neural networks (ANNs), deep neural networks (DNNs), random forests (RFs), etc. NPUs are sometimes alternatively referred to as neural signal processors (NSPs), tensor processing units (TPUs), neural network processors (NNPs), intelligent processing units (IPUs), or vision processing units (VPUs).

[0120] NPUs (such as the 908) can be configured to accelerate the execution of common machine learning tasks, such as image classification, sound classification, authentication, and various other prediction tasks. In some examples, multiple NPUs may be instantiated on a single chip (such as a system-on-a-chip (SoC)), while in other examples, multiple NPUs may be part of a dedicated neural network accelerator.

[0121] An NPU can be optimized for either training or inference, or in some cases, configured to balance performance between training and inference. For an NPU capable of performing both training and inference, these two tasks may typically still be performed independently.

[0122] NPUs designed to accelerate training are typically configured to speed up the optimization of new models. This involves a highly computationally intensive process: taking an existing dataset (often labeled or sublabeled), iterating over the dataset, and then tuning model parameters (such as weights and biases) to improve model performance. Generally, optimization based on incorrect predictions involves backtracking through the layers of the model and determining gradients to reduce prediction errors.

[0123] NPUs designed to accelerate inference are typically configured to operate on a trained model. Such NPUs can thus be configured to take new data segments as input and process those segments rapidly using an already trained model to generate model outputs (e.g., inference).

[0124] Despite Figure 9 Not described, but the NPU 908 can be implemented as part of one or more of the CPU 902, GPU 904 and / or DSP 906.

[0125] In some examples, the wireless connectivity component 912 may include sub-components for, for example, third-generation (3G) connectivity, fourth-generation (4G) connectivity (e.g., 4G LTE), fifth-generation connectivity (e.g., 5G or NR), Wi-Fi connectivity, Bluetooth connectivity, and other wireless data transmission standards. The wireless connectivity processing component 912 is further connected to one or more antennas 914.

[0126] The processing system 900 may also include one or more sensor processing units 916 associated with any type of sensor, one or more image signal processors (ISPs) 918 associated with any type of image sensor, and / or a navigation processor 920 that may include satellite-based positioning system components (e.g., GPS or GLONASS) and inertial positioning system components. In some embodiments, the sensor processing units may be configured to capture authentication data from a user, such as image data, audio data, biometric data, and other types of sensor data.

[0127] The processing system 900 may also include one or more input and / or output devices 922, such as screens, touch-sensitive surfaces (including touch-sensitive displays), physical buttons, speakers, microphones, etc.

[0128] In some examples, one or more processors of the processing system 900 may be based on the ARM or RISC-V instruction set.

[0129] The processing system 900 also includes a memory 924, which represents one or more static and / or dynamic memories, such as dynamic random access memory, flash-based static memory, etc. In this example, the memory 924 includes computer-executable components that can be executed by one or more of the aforementioned processors of the processing system 900.

[0130] In this example, memory 924 includes codeword modification component 924A, distance comparison component 924B, training component 924C, inference component 924D, model parameters 924E, model 924F (e.g., user authentication model), and authentication component 924G. The depicted components, as well as other components not depicted, can be configured to perform various aspects of the methods described herein.

[0131] Notice, Figure 9 This is merely one example of a processing system, and other processing systems with fewer, additional, or alternative aspects may also be consistent with this disclosure.

[0132] Figure 10 An example processing system 1000 is depicted, which can be configured to perform various methods described herein (including, for example, those concerning...). Figure 3 and 8 The described methods cover various aspects. For example, the processing system 1000 could be a server participating in federated learning of a user authentication model, such as regarding... Figure 2 As described.

[0133] The processing system 1000 includes a central processing unit (CPU) 1002, which in some examples may be a multi-core CPU. Instructions executed at the CPU 1002 may be loaded, for example, from program memory associated with the CPU 1002 or from memory 1024.

[0134] The processing system 1000 also includes additional processing components tailored for specific functions, such as a graphics processing unit (GPU) 1004, a digital signal processor (DSP) 1006, and a neural processing unit (NPU) 1008.

[0135] Despite Figure 10 It is not described, but the NPU 1008 can be implemented as part of one or more of the CPU 1002, GPU 1004 and / or DSP 1006.

[0136] The processing system 1000 may also include one or more sensor processing units 1016 associated with any type of sensor, one or more image signal processors (ISPs) 1018 associated with any type of image sensor, and / or a navigation processor 1020 that may include satellite-based positioning system components (e.g., GPS or GLONASS) and inertial positioning system components. In some embodiments, the sensor processing units may be configured to capture authentication data from a user, such as image data, audio data, biometric data, and other types of sensor data.

[0137] The processing system 1000 may also include one or more input and / or output devices 1022, such as screens, physical buttons, speakers, microphones, etc.

[0138] In some examples, one or more processors of the processing system 1000 may be based on the ARM or RISC-V instruction set.

[0139] The processing system 1000 may also include a hardware-based encoder / decoder 1012 configured to efficiently perform encoding and decoding functions. For example, the encoder / decoder 1012 may be configured to perform one or more of the following: the Bosch-Jochrey-Heim (BCH) decoding scheme, the Reid-Muller (RM) decoding scheme, and a convolution-based decoding scheme.

[0140] The processing system 1000 also includes a memory 1014, which represents one or more static and / or dynamic memories, such as dynamic random access memory, flash-based static memory, etc. In this example, the memory 1014 includes computer-executable components that can be executed by one or more of the aforementioned processors of the processing system 1000.

[0141] In this example, memory 1014 includes a codeword generation component 1014A, a user ID generation component 1014B, a distributed training component 1014C (e.g., configured to perform federated learning), an inference component 1014D, model parameters 1014E, a model 1014F (e.g., a user authentication model), and an error correction code component 1014G. The depicted components, as well as other components not depicted, can be configured to perform various aspects of the methods described herein.

[0142] Notice, Figure 10 This is merely one example of a processing system, and other processing systems with fewer, additional, or alternative aspects may also be consistent with this disclosure.

[0143] Example Terms

[0144] Examples of implementations are described in the following numbered clauses.

[0145] Clause 1: A method comprising: receiving user authentication data associated with a user; generating an output from a neural network model based on the user authentication data; determining a distance between the output and an embedding vector associated with the user; comparing the determined distance with a distance threshold; and making an authentication decision based on the comparison.

[0146] Clause 2: The method of Clause 1, wherein the user authentication data includes one or more of the following: audio data, video data, image data, sensor data, or biometric data.

[0147] Clause 3: The method of any of Clauses 1-2, wherein the neural network model is configured with a sigmoid nonlinear activation function for generating the output.

[0148] Clause 4: The method of any of Clauses 1-3, wherein: the distance between the output and the embedding vector associated with the user is based on The calculation is performed where x is the user authentication data, F is the neural network model, y is the embedding vector associated with the user, and σ(F(x)) generates the output.

[0149] Clause 5: The method of any of Clauses 1-4, wherein making an authentication decision further comprises: authenticating the user based on user authentication data if the distance between the output and the embedding vector associated with the user is less than the distance threshold.

[0150] Clause 6: The method of Clause 5, wherein: the distance threshold is configured such that the True Class Rate (TPR) is equal to or greater than 90%, and the TPR is defined as the ratio of users who are correctly authenticated.

[0151] Clause 7: A method comprising: generating an error-correcting code; assigning a unique ID as an information bit vector to a user; obtaining a codeword based on the unique ID assigned to the user; and sending the codeword to the user.

[0152] Clause 8: The method of Clause 7 further includes: modifying the codeword.

[0153] Clause 9: The method of Clause 8, wherein modifying the codeword comprises: the user changing a predetermined number of bits at random positions of the codeword to an embedding vector that varies from user to user.

[0154] Clause 10: The method of any of Clauses 8-9, wherein the predetermined number of bits is 1 bit.

[0155] Clause 11: The method of any of Clauses 7-10 further includes: receiving model update data from the user, wherein the model update data is based on a user-specific embedding on the codeword.

[0156] Clause 12: The method of any of Clauses 7-11, wherein the error correction code is based on (n c n m It is generated by d), where n c It is the length of the code word. It is the number of information bits, n u Let d be the number of users, and d be the minimum distance between codes.

[0157] Clause 13: The method of any of Clauses 7-12, wherein obtaining the codeword based on a unique ID includes using an error-correcting code scheme.

[0158] Clause 14: The method of Clause 13, wherein the error correction coding scheme includes the Bosch-Joher-Heim (BCH) decoding scheme.

[0159] Clause 15: The method of Clause 13, wherein the error correction code scheme ensures that the codeword associated with the user is at a threshold distance from any other codeword associated with any other user.

[0160] Clause 16: The method as described in Clause 13 further includes: determining the number of parity bits of the codeword.

[0161] Item 17: A method comprising: generating an output from a neural network model based on user input data; and training the neural network model using a loss function that maximizes the correlation between the output and an embedding vector associated with the user, wherein the embedding vector is based on codewords received from a federated learning server.

[0162] Item 18: The method of Item 17, wherein the neural network model includes a sigmoid non-linear activation function for generating the output.

[0163] Clause 19: The method of any of Clauses 17-18, wherein: the loss function is This is the output from the neural network model, where y is the embedding vector associated with the user, and the loss function is configured to increase y. The correlation between them.

[0164] Clause 20: The method of any of Clauses 17-19, wherein the codeword is based on an error-correcting code scheme.

[0165] Clause 21: The method of any of Clauses 17-20 further includes: determining one or more model updates based on training; and sending the model updates to a server.

[0166] Clause 22: A processing system comprising: a memory including computer-executable instructions; and a processor configured to execute the computer-executable instructions and cause the processing system to perform a method pursuant to any of Clauses 1-21.

[0167] Clause 23: A non-transient computer-readable medium comprising computer-executable instructions that, when executed by a processor of a processing system, cause the processing system to perform a method according to any one of Clauses 1-21.

[0168] Clause 24: A computer program product implemented on a computer-readable storage medium, the computer-readable storage medium including code for performing a method pursuant to any of Clauses 1-21.

[0169] Clause 25: A processing system comprising means for performing a method according to any one of Clauses 1-21.

[0170] Additional considerations

[0171] The foregoing description is provided to enable any person skilled in the art to practice the various embodiments described herein. The examples discussed herein are not intended to limit the scope, applicability, or embodiments set forth in the claims. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments. For example, changes may be made to the function and arrangement of the elements discussed without departing from the scope of this disclosure. Various procedures or components may be appropriately omitted, substituted, or added to various examples. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Moreover, features described with reference to some examples may be combined in others. For example, any number of aspects set forth herein may be used to implement an apparatus or practice a method. Furthermore, the scope of this disclosure is intended to cover such apparatuses or methods practiced using other structures, functionalities, or structures and functionalities that supplement or differ from the aspects of this disclosure set forth herein. It should be understood that any aspect of this disclosure disclosed herein may be implemented by one or more elements of the claims.

[0172] As used herein, the term “exemplary” means “serving as an example, instance, or illustration.” Any aspect described herein as “exemplary” should not be construed as superior to or better than the others.

[0173] As used herein, the phrase “at least one of” a list of items refers to any combination of those items, including a single member. As an example, “at least one of a, b, or c” is intended to cover: a, b, c, ab, ac, bc, and abc, as well as any combination with multiple identical elements (e.g., aa, aaa, aab, aac, abb, acc, bb, bbb, bbc, cc, and ccc, or any other ordering of a, b, and c).

[0174] As used herein, the term "determine" encompasses a wide variety of actions. For example, "determine" can include calculation, computation, processing, derivation, research, searching (e.g., looking in a table, database, or other data structure), ascertaining, and the like. Furthermore, "determine" can include receiving (e.g., receiving information), accessing (e.g., accessing data in memory), and the like. Moreover, "determine" can include parsing, selecting, choosing, building, and the like.

[0175] The methods disclosed herein include one or more steps or actions for implementing the method. These method steps and / or actions may be interchanged without departing from the scope of the claims. In other words, unless a specific order of steps or actions is specified, the order and / or use of specific steps and / or actions may be modified without departing from the scope of the claims. Furthermore, the various operations of the above methods can be performed by any suitable means capable of performing the corresponding functions. These means may include various hardware and / or software components and / or modules, including but not limited to circuits, application-specific integrated circuits (ASICs), or processors. Generally, where operations illustrated in the figures are present, these operations may have corresponding paired means with similar numbers plus functional components.

[0176] The following claims are not intended to be limited to the embodiments shown herein, but should be granted the full scope consistent with the language of the claims. Within the claims, references to singular elements are not intended to mean “one and only one” (unless specifically stated so), but rather “one or more.” Unless specifically stated otherwise, the term “some / a” refers to one or more. No element of the claims should be interpreted in accordance with the provisions of 35 USC §112(f) unless the element is expressly stated using the phrase “means for…” or, in the case of a method claim, the element is stated using the phrase “steps for…”. Elements of all aspects described throughout this disclosure that are now or hereafter known to a person skilled in the art are expressly incorporated herein by reference and are intended to be covered by the claims. Furthermore, nothing disclosed herein is intended to be donated to the public, whether or not such disclosure is expressly stated in the claims.

Claims

1. A method comprising: Assign a unique ID as an information bit vector to the user; The error correction coding scheme is used to obtain codewords based on the unique ID assigned to the user; Send the codeword to the user; Modifying the codeword, wherein modifying the codeword includes: the user changing a predetermined number of bits at random positions in the codeword to an embedding vector that varies from user to user, wherein the predetermined number of bits is... bits, where d represents the minimum distance of the error correction code; Receive model update data for a neural network model from the user, wherein the model update data is based on user-specific embeddings; Receive user authentication data associated with the user, wherein the user authentication data includes one or more of the following: audio data, video data, image data, sensor data, or biometric data; The output is generated from the neural network model based on the user authentication data. Determine the distance between the output and the user-specific embedding vector; Compare the determined distance with a distance threshold; and The authentication decision is made based on the comparison.

2. The method of claim 1, wherein the neural network model is configured with a sigmoid nonlinear activation function for generating the output.

3. The method of claim 1, wherein: The distance between the output and the embedding vector associated with the user is based on To calculate, x is the user authentication data. F is the neural network model. y is the embedding vector associated with the user, and This is the output of the model.

4. The method of claim 1, wherein making the authentication decision further comprises: If the distance between the output and the embedding vector associated with the user is less than the distance threshold, the user is authenticated based on the user authentication data.

5. The method of claim 4, wherein: The distance threshold is configured such that the True Class Reduction (TPR) is equal to or greater than 90%, and The TPR is defined as the percentage of users who are correctly authenticated.

6. The method of claim 1, wherein the error correction code is based on To generate, where n c It is the length of the code word. It is the number of information bits, n u It refers to the number of users.

7. The method of claim 1, wherein the error correction code scheme comprises the Bosch-Joher-Heim (BCH) decoding scheme.

8. The method of claim 1, wherein the error correction code scheme ensures that the codeword associated with the user is at a threshold distance from any other codeword associated with any other user, the method further comprising: Determine the number of parity bits in the codeword.

9. A processing system, comprising: Memory including computer-executable instructions; as well as A processor configured to execute the computer-executable instructions and cause the processing system to perform the method according to any one of claims 1-8.

10. A non-transient computer-readable medium comprising computer-executable instructions that, when executed by a processor of a processing system, cause the processing system to perform the method according to any one of claims 1-8.

11. A computer program product implemented on a computer-readable storage medium, said computer-readable storage medium comprising code for performing the method according to any one of claims 1-8.

12. A processing system comprising means for performing the method as described in any one of claims 1-8.

Images