A method for cross-domain adaptive learning

Abstract

Techniques are provided for cross-domain adaptive learning. A target domain feature extraction model is tuned from a source domain feature extraction model trained on a source dataset, where the tuning is performed using a mask generation model trained on a target dataset, and the tuning is performed using the target dataset.

Description

[0001] Cross-references to related applications

[0002] This application claims priority to U.S. Patent Application No. 17 / 648,415, filed January 19, 2022, and U.S. Provisional Patent Application No. 63 / 139,714, filed January 20, 2021, the entire contents of each of which are incorporated herein by reference.

[0003] introduction

[0004] This disclosure relates to various aspects of cross-domain adaptive learning.

[0005] Machine learning has been applied to a wide variety of tasks, such as image recognition and speech (or speaker) identification. Typically, machine learning models (such as convolutional neural networks) are trained to learn features of a specific domain. Therefore, such models often do not generalize well beyond this limited domain, or even to closely related tasks. For example, a model trained to classify flower images is unlikely to perform well in classifying animal images.

[0006] Furthermore, training machine learning models typically requires a large number of training samples (often called paradigms). If too few samples are available, the accuracy of the trained model is usually poor. Efforts have been made to adapt existing models (trained with a large number of samples for one domain) to other domains with fewer available samples. However, current methods do not generalize well and show limited accuracy even when adapted to similar domains. Specifically, as the domains become increasingly different, existing methods used to adapt trained models fail to provide reasonable accuracy.

[0007] Therefore, more effective techniques are needed to adapt models to perform accurately in different domains using a small number of training samples in the target domain.

[0008] Brief Overview

[0009] Some aspects provide a computer-implemented method comprising: tuning a target domain feature extraction model based on a source domain feature extraction model trained on a source dataset, wherein: the tuning is performed using a mask generation model trained on a target dataset, and the tuning is performed using the target dataset.

[0010] Other aspects relate to: an apparatus configured to perform the methods described herein; and a non-transient computer-readable medium comprising computer-executable instructions that, when executed by a processor of the apparatus, cause the apparatus to perform the methods described herein.

[0011] The following description and related figures illustrate certain illustrative features of one or more aspects. Brief description of the attached diagram

[0013] The accompanying drawings depict certain features of each aspect and are therefore not intended to limit the scope of this disclosure.

[0014] Figure 1 An example workflow for training a source domain feature extractor to serve as the backbone of a target domain feature extractor is described.

[0015] Figure 2 An example workflow for training a mask generator to assist in the adaptation to the target domain is described.

[0016] Figure 3 An example workflow for tuning a target domain feature extractor for the target domain is described.

[0017] Figure 4 An example workflow for using a trained domain feature extractor and classifier in a target domain is described.

[0018] Figure 5 This section describes an example flowchart illustrating methods for training and tuning machine learning models for a target domain.

[0019] Figure 6 A sample flowchart illustrating the method used to train the source domain feature extractor is shown.

[0020] Figure 7 Here is another example flowchart illustrating the method used to train the mask generator.

[0021] Figure 8 Another example flowchart illustrating the methods used to train a target domain feature extractor and classifier is shown.

[0022] Figure 9 This is a flowchart illustrating a method for classifying input data in a target domain using a target domain feature extraction model.

[0023] Figure 10 Here is another example flowchart illustrating the method used to train a target domain feature extraction model.

[0024] Figure 11 An example block diagram depicts an explanation of a processing system configured to train and tune machine learning models for a target domain.

[0025] To facilitate understanding, the same reference numerals are used wherever possible to designate common elements shared by all figures. Elements and features conceived of one aspect can be beneficially incorporated into other aspects without further elaboration.

[0026] Detailed description

[0027] Various aspects of this disclosure provide apparatus, methods, processing systems, and non-transient computer-readable media for adapting machine learning models to different domains using a small number of training samples.

[0028] Traditional machine learning relies on a large number of diverse labeled training samples to avoid model overfitting and achieve reasonable accuracy during inference. For example, to train a neural network to accurately classify flowers in images, the network must be iteratively trained and refined using a large number of images, each with a corresponding label indicating which type(s) of flowers(s) is present. If only a few such labeled samples are available, the model will tend to overfit to the specific samples used and will perform poorly (e.g., with very low accuracy) for other new images.

[0029] In some aspects of this disclosure, self-supervised techniques are used to train a feature extraction model for a source domain. In one aspect, self-supervised learning relies on the data itself to provide supervision, rather than artificially created labels. By using this self-supervision and suppressing the use of labels on training samples in the source domain (e.g., by suppressing the use of supervised learning), the feature extraction model learns to extract features from the input data, rather than learning to classify the data as in traditional supervised learning. In some aspects, this source domain feature extraction model can then be refined to serve as a domain feature extractor for a target domain using relatively few samples; this can be referred to as “one-off” learning (when using a single sample) or “small-scale” learning (when using a small number of samples). In the aspects described herein, this transformation from a source domain feature extractor for the source domain to a target domain feature extractor for the target domain can be referred to as refinement, training, tuning, fine-tuning, adaptation, etc.

[0030] In some respects, to enhance the accuracy of the target model, the system can also train a mask generator (e.g., a layer, subnetwork, or network model) to help select salient features from the output of the source domain feature extractor based on the target domain. The generated masks can improve the training of the target source extractor by forcing it to focus on the selected features. This can help the model generalize well by selectively using features that are predictive of the target domain, which can prevent overfitting and reduce the number of target domain samples required to achieve high accuracy and other performance improvements.

[0031] Advantageously, aspects of this disclosure require relatively few training samples for the target domain, yet still achieve high task accuracy (e.g., classification). For example, while there may be thousands of samples for the source domain, the target model can be trained using fewer than one hundred samples (including single, five, ten, twenty, fifty, etc., in various implementations).

[0032] This adaptation has broad applicability to improve the accuracy of machine learning models in domains where few paradigms are available. For example, in speaker verification (verifying an individual's identity based on their voice), a model can be trained using source domain data (e.g., data from a first group of speakers) and then adapted to a target domain (e.g., associated with a single new speaker) using the techniques described in this paper to provide improved verification accuracy, even when there are significant differences in speaking styles between the source and target domains.

[0033] As another example, a model can be trained to perform image recognition in a source domain (e.g., recognizing flowers), and then the model can be adapted to a target domain with a small number of samples (e.g., classifying satellite images, medical images, etc.).

[0034] Similarly, for image verification, such as verifying biometric data (e.g., facial data, iris data, handwriting style, etc.), a general model can be trained using source data and fine-tuned using target data specific to a particular user. For example, the techniques described in this paper can be used to train a model to distinguish between genuine and counterfeit fingerprints, where there can be significant differences between domains. As yet another example, advanced driver assistance systems can be refined to classify driver engagement levels using a relatively small sample size of data from a specific driver.

[0035] In some aspects discussed in this paper, the source domain and the target domain can each be modeled as input spaces. and mark space The corresponding joint distribution on The marginal distribution of the input space can be represented as... Generally speaking, it can be seen from Medium sampling example ,in It is input, and These are the corresponding labels. Therefore, the source and target domains can be jointly distributed. and They are respectively represented as and On the one hand, due to domain differences, the source margin distribution... Possibly related to the target marginal distribution Very different. Furthermore, the categories in the target domain may be completely novel (where...) and (There is no overlap between them). In all aspects of this disclosure, the system can first use a source distribution. A relatively large amount of sampled data is used to train the model. Subsequently, it can be based on data from the target distribution. The relatively small amount of sampled data is used to adapt the model to the target domain.

[0036] The aspects of this disclosure can be applied to a wide variety of machine learning tasks and can generally improve the accuracy of models in any number of task domains.

[0037] Example workflow for training a source domain feature extractor

[0038] Figure 1 An example workflow 100 is described for training the source domain feature extractor 120 to serve as the backbone of the target domain feature extractor.

[0039] exist Figure 1 In this example, a set of source domain samples 105 is used to train the source domain feature extractor 120. In this example, source domain samples 105 are training paradigms in a source domain where a relatively large number of samples are available (e.g., at least an order of magnitude more than the number of samples available in the target domain). For example, if the source domain corresponds to a classification of animals, then source domain samples 105 could include images of animals. In some respects, each source domain sample 105 is associated with a corresponding label indicating its category. However, during self-supervised learning, the label (if present) can be ignored.

[0040] As explained, one or more of the source domain samples 105 can be directly provided as input to the source domain feature extractor 120, which outputs a set of source features 130 for each input source domain sample 105. Generally, the source features 130 are represented by a multidimensional value tensor, where each dimension corresponds to a specific feature.

[0041] In one respect, the source domain feature extractor 120 is a neural network (e.g., or a portion thereof, such as one or more layers of a neural network). For example, the source domain feature extractor 120 may correspond to a neural network that includes an input layer and one or more hidden layers but no fully connected classifier or output layer. That is, the output from the last layer of the network may be a set of features (e.g., source features 130) or embeddings, rather than a classification of the input data.

[0042] In workflow 100, enhancement component 110 is used to enhance source domain samples 105 (e.g., in training batches) using various transformations to generate enhanced samples 115. These transformations may include, for example, rotation, color conversion (e.g., to grayscale), translation, addition of noise, inversion, etc. These transformations allow the system to learn features of the source domain in a self-supervised manner, independent of the input labels.

[0043] In some aspects, a single augmented sample 115 is generated for each source domain sample 105. In other aspects, any number of augmented samples 115 can be generated for each source domain sample 105. As explained, each augmented sample 115 is processed by the source domain feature extractor 120 to generate a corresponding set of augmented features 125. In one aspect, the augmented features 125 have the same dimension as the source features 130. Although the explained workflow 100 depicts discrete augmented features 125 and source features 130 for conceptual clarity, the source domain feature extractor 120 is typically unaware of whether the input has been transformed, and the resulting features may be indistinguishable in other respects.

[0044] Loss component 135 can receive and process the augmentation features 125 and source features 130 associated with each source domain sample 105 to generate a loss 140. This loss 140 is used to refine the source domain feature extractor 120. Generally, any suitable self-supervised loss function can be used. In at least one aspect, augmented samples and original samples are used to compute the contrastive loss 140, wherein the contrastive loss 140 is based at least in part on the difference or contrast between the source domain samples and the augmented samples.

[0045] On the one hand, it can be used 105 training samples (source domain samples) are used to execute workflow 100, where the samples are represented as For each sample The system can first obtain A random (or pseudo-random) transformation (leading to) (115 enhanced samples), of which the first Each instance of transformation is represented as ,and On one hand, the system can use the contrastive (e.g., cross-entropy) loss defined in Equation 1 to force the transformed instance... near and stay away , .

[0046] (1)

[0047] In Equation 1, It is a source domain feature extraction model (e.g., Figure 1 (120 in the middle) It is a distance metric. It is the batch size of the source dataset. It is the number of enhancements. These are the original samples from the source dataset, and These are transformed samples from the source dataset. In one respect, Euclidean distance is used as the distance metric. .

[0048] In all respects, this self-supervised loss (which is computed without regard to the source label) enables the source domain feature extractor 120 to learn more general features beyond the source domain.

[0049] Example workflow for training a mask generator for a target domain.

[0050] Figure 2 An example workflow 200 for training a mask generator to assist in the adaptation to the target domain is described.

[0051] Generally, workflow 200 can be used to generate one or more masks that select task-relevant features (e.g., features that help classify and / or distinguish categories of input data in the target domain) and task-independent features (e.g., features that do not help distinguish categories in the target domain). Using such masks can improve the accuracy of the final model by allowing the system to generalize from the original source domain to the target domain.

[0052] exist Figure 2 In this process, each sample in the target domain sample set 205 is provided to the source domain feature extractor 120 (e.g., a neural network trained using the workflow 100 discussed above) to generate a corresponding set of target features 210 (e.g., in the embedding). In one aspect, the target features 210 have the same characteristics as the reference features. Figure 1 The source feature 130 and the augmented feature 125 discussed have the same dimensions.

[0053] Each target domain sample 205 is a training paradigm for the target domain. Generally, the target domain differs from the source domain in some substantial respect. For example, the target domain may include one or more categories that do not exist in the source domain. In at least one respect, the categories may be completely discrete, such that none of the categories in the target domain exist in the source domain, and vice versa.

[0054] In some respects, the source and target domains can also differ in other ways. For example, the source domain can use color images, while the target domain uses grayscale. Similarly, the source domain can use input data that includes perspective (e.g., animal images reflecting spatial depth or dimension), while the target domain does not have such perspective (e.g., planar X-ray images).

[0055] Target features 210 are provided to mask generator 215. Mask generator 215 may include a neural network that receives an input feature set (e.g., a tensor) and outputs a corresponding mask. The mask typically has the same dimensions as the input tensor (e.g., the same dimensions as the target features 210) and specifies a value between 0 and 1 for each feature. In some aspects, the value can be either 1 or 0 for each feature, for example, a binary output mask.

[0056] In one example, the source domain feature extractor 120 (trained based on the source domain) is represented as... Given a batch of 205 target domain samples For each sample, the source domain feature extractor 120 can be used to generate target features 210. These features are input into the mask generator 215 (which can be represented as...). To obtain the mask .

[0057] In some respects, the mask is converted to a binary mask 220. For example, the system can convert the mask to a binary mask by converting any value less than 0.5 to 0 and any value greater than or equal to 0.5 to 1 (or using some other cutoff value). In this way, the binary mask can be used to selectively pass or suppress features from the input. Figure 2 In the illustrated example, the black portion of binary mask 220 represents a binary mask value (e.g., 1), while the white portion of binary mask 220 represents another binary mask value (e.g., 0).

[0058] In some aspects, generating the binary mask 220 involves adding logical noise to the mask's values ​​and applying a linear or nonlinear activation function to the resulting values. That is, in order to generate the binary mask... The system can use probability procedures. For example, let... For the mask generator 215 and the first The first sample and the first The system generates logical noise, corresponding to the unbounded output probability (logit) for each dimension. , making and The noise can then be added to each probability using Equation 2 to generate a mask. ,in It is a sigmoid operation and It is a temperature parameter.

[0059] (2)

[0060] The addition of this noise to the probabilities can be used to test different binary masks suitable for the target task during training. To backpropagate the discrete mask during training, the system can use a pass-through estimator during backpropagation using Equation 2 and a hard thresholding operation during forward propagation. In at least one aspect, the hard thresholding operation involves if... Then Set to 1, otherwise Set to 0. During inference mode, logical noise can be... When the value is 0, a hard thresholding operation is performed on the mask, so the system can generate deterministic output.

[0061] As explained, operation 225 is then used to apply mask 220 (which may be a binary mask) to target features 210 to generate a set of positive features 230 and a set of negative features 235. In some respects, task-relevant features may be referred to as positive features, while task-irrelevant features may be referred to as negative features.

[0062] In at least one aspect, operation 225 is an element-wise product operation (e.g., Hadamard product). In some aspects, given features... and mask , affirmative feature 230 can be represented as Furthermore, the negation feature 235 can be represented as ,in It is an element-wise product. It is a vector or tensor of multiple 1s with an appropriate dimension (e.g., equal to the dimension of the feature tensor), and It is by A mask vector or tensor composed of n elements, where the nth element is... Each element is represented as .

[0063] As explained, positive feature 230 and negative feature 235 are then processed by loss component 135 to generate loss 240, which is used to refine mask generator 215.

[0064] Generally, the mask generator 215 is trained to ensure positive features 230 ( ) are distinguishable between target categories, while negative features ( No. Therefore, the mask generator 215 can be trained to make and Statistically, it is divergent.

[0065] In some respects, in order to generate distinctive affirmative features The loss component 135 uses the cross-entropy loss function. For example, the system can use a linear classifier to process the positive features 230 to generate a classification. This classification, along with the actual label of the corresponding target domain sample 205, can be used together to calculate the cross-entropy loss, as in Equation 3.

[0066] (3)

[0067] In Equation 3, It is the cross-entropy criterion. It is used to affirm features A linear classifier, and It was used to generate target features The target domain sample 205 is labeled, and then the target features are processed using a mask. Affirmative features were generated. .

[0068] In one respect, in order to base on the negative feature 235 ( The loss is calculated using the maximum entropy criterion in Equation 4 below, where... It is used for negation features A linear classifier, and yes The entropy output by the softmax function.

[0069] (4)

[0070] In some respects, as discussed above, the loss component 135 further calculates the loss to ensure that the positive feature 230 and the negative feature 235 are statistically divergent. Therefore, if There are two feature sets (affirmative set) With the negation set If the statistical distance between the two sides is calculated, the system can use Equation 5 to minimize the divergence loss. In one respect, the exponential term in Equation 5 can be used to provide a more stable and smaller gradient when approaching optimality.

[0071] (5)

[0072] In workflow 200, loss component 135 may combine positive loss, negative loss, and / or divergence loss to generate total loss 240, which is used to refine mask generator 215. In at least one aspect, the loss terms defined above in Equations 3, 4, and 5 are weighted and combined to obtain the total loss of mask generator 215, as defined below in Equation 6.

[0073] (6)

[0074] In Equation 6, , and These are weights for each corresponding loss component. On one hand, these weights are configurable hyperparameters. On the other hand, these weights are trainable parameters. For example, weights can be learned using exponential decay. , and ,and It can be defined as:

[0075] .

[0076] Then, training samples from a given batch can be used to... Averaging is performed to obtain the final loss, which spans... , and Backpropagation is performed to update the corresponding parameters. On the one hand, the parameters of the source domain feature extractor 120 are frozen and unchanged during the training of the mask generator 215.

[0077] In this way, the mask generator 215 is iteratively refined based on samples in the target domain to generate a mask given an input feature set.

[0078] Example workflow for adapting a source domain feature extractor to generate a target domain feature extractor.

[0079] Figure 3 An example workflow 300 for tuning a target domain feature extractor 305 for a target domain is described. Workflow 300 can be used as a fine-tuning stage to adapt the target domain feature extractor 305 to the target domain. In workflow 300, the target domain feature extractor 305 and the task classifier 315 are trained on target domain data 205. Since the target domain may contain only a relatively small number of labeled data samples, in some respects, the system regularizes the target domain feature extractor 305 to generate positive features using a trained mask generator 215, as discussed in more detail below.

[0080] Each of the target domain samples 205 is passed through a trained source domain feature extractor 120 to generate a corresponding target feature(s) 210 for each target domain sample 205. Each corresponding tensor of the target feature 210 is then passed through a trained mask generator 215 to generate a corresponding mask 220 (which may be a binary mask, as discussed above). Each mask 220 is then applied (e.g., using an element-wise multiplication operation) to the corresponding target feature 210 to produce a corresponding set of positive features 230.

[0081] The target domain feature extractor 305 can be a machine learning model (or a portion thereof) (such as a neural network) trained to extract features from input data (e.g., target domain sample 205). In one aspect, the target domain feature extractor 305 is initialized using the parameters of the trained source domain feature extractor 120. That is, while the source domain feature extractor 120 can be initialized with random values, the target domain feature extractor 305 can be initialized using the values ​​of the trained source domain feature extractor 120. These parameters can then be refined or “tuned” to generate the trained target domain feature extractor 305. This allows the original source domain feature extractor 120 to be adapted to the target domain.

[0082] set up It is the target domain feature extractor 305, which is based on the source domain feature extractor The parameters are initialized.

[0083] Given one or more target domain samples 205, the target domain feature extractor 305 is used to generate a corresponding task feature set 310. That is, given a batch of target domain samples... For each sample, the system generates a feature tensor or vector. .

[0084] exist Figure 3 In this context, for each target domain sample 205, the corresponding target features 310 and affirmative features 230 are used by the loss component 135 to compute a loss 330. In some respects, as discussed above, the loss component 135 generates a loss 330 to regularize the target domain feature extractor 305 based on relevant or salient features (e.g., to ensure that the feature domain of the target domain feature extractor 305 is similar to the features of the affirmative feature tensor 230).

[0085] In some cases, in order to ensure the characteristics of the target domain Based on the approximate relevance (affirmative) features, the system can generate relevant target tensors or vectors. The regularization loss can then be defined using Equation 7, where... It is the Euclidean distance (also known as the Euclidean norm or 2-norm) of a tensor or vector from the origin.

[0086] (7)

[0087] In workflow 300, task features 310 are also provided to task classifier 315. Task classifier 315 and target domain feature extractor 305 can each be a neural network model, or different aspects of a single neural network model. For example, target domain feature extractor 305 can be used as one or more initial layers (e.g., an input layer and one or more hidden layers), while task classifier 315 can include one or more fully connected layers located at the end of the network for classifying the features.

[0088] Each set of task features 310 is provided to the task classifier 315 to generate a corresponding classification 320. That is, features It can be provided as input to the task classifier 315 ( To generate classification 320. In one aspect, task classifier 315 is a linear classifier (e.g., a classifier that classifies input data based on a linear combination of input features).

[0089] The loss component 135 can calculate the loss 330 based at least in part on the cross-entropy loss between the classification 320 and the corresponding target label 325 of the original input target domain sample 205. This cross-entropy loss can be calculated using the following Equation 8.

[0090] (8)

[0091] In Equation 8, It is the cross-entropy criterion. It is used for target features A linear classifier, and It was used to generate target features The target domain sample 205 is labeled.

[0092] As explained, regularization loss The task loss (calculated using task feature 310 and positive feature 230) and the task loss (calculated using target labeling and classification) can be weighted and combined to obtain a total loss 330, which can be defined using the following Equation 9.

[0093] (9)

[0094] In Equation 9, This is a weighted value used to adjust the contribution of each loss component. On one hand, this weight is a configurable hyperparameter. On the other hand, These can be trainable parameters. For example, they can be learned using exponential decay. ,and It can be defined as .

[0095] It is possible to perform training on a given batch of training samples. Average the results to obtain the final loss for that batch or training epoch, and then this loss can be applied across... (Target Domain Feature Extractor 305) and (Task classifier 315) is backpropagated to update their respective parameters. Generally, the parameters of source domain feature extractor 120 and mask generator 215 are not updated during the training of target domain feature extractor 305 and task classifier 315.

[0096] After training samples 205 have been used to refine the target domain feature extractor 305 and the task classifier 315, the target feature extractor 305 and the task classifier 315 can be used to classify new input data in the target domain without using the source domain feature extractor 120 or the mask generator 215. Advantageously, because the target domain feature extractor 305 is instantiated from the source domain feature extractor 120 trained using a large amount of source data, it can extract features with greater accuracy and diversity than using only the target domain data. Additionally, by starting with a trained source domain feature extractor (rather than a randomly instantiated model), the training of the target domain feature extractor can be performed with significantly fewer computational resources and requires less time. Furthermore, because self-supervision can be used to train the source domain feature extractor 120, it can generalize well to dissimilar domains. Moreover, by training and using the mask generator 215 based on target domain samples, the source domain feature extractor 120 can be specifically tuned for the target domain, which significantly increases the final accuracy of the model.

[0097] Example workflow for using a trained target domain feature extractor and classifier

[0098] Figure 4 An example workflow 400 is described for using the trained target domain feature extractor 305 and classifier 315 for the target domain.

[0099] In this example, one or more labeled samples from the target domain have been used to train the target domain feature extractor 305 and the task classifier 315. Although depicted as discrete components for conceptual clarity, in some respects, the target domain feature extractor 305 and the task classifier 315 are implemented using a single neural network or other type of machine learning model.

[0100] Once the target domain feature extractor 305 and the task classifier 315 are trained and deployed for use, target domain data 405 can be provided to the target domain feature extractor 305. Generally, target domain data 405 is received or captured unlabeled or unclassified input data used for classification in the target domain (assuming classification is the desired task). For example, if the target domain is to classify medical abnormalities in medical images, target domain data 405 may include one or more images (e.g., X-ray or MRI images) that may or may not contain such abnormalities.

[0101] The target domain feature extractor 305 processes each sample of the target domain data 405 to generate a corresponding set of features 410. As discussed above, this set of features 410 may include a multidimensional set of numerical values ​​(e.g., vectors or tensors). These features 410 are then provided to the task classifier 315, which outputs a classification 415 for each input set of features 410. For example, the classification 415 may categorize the target domain data 405 into one or more classes within the target domain.

[0102] Using workflow 400 to generate category 415 can be represented as follows: ,in This is a test sample (e.g., target domain data 405). It is the target domain feature extractor 305, and It's a task classifier 315. In some respects, it can... The output uses a softmax operation to obtain the individual class probabilities. Based on these probabilities, the most likely class can be selected and output as the classification 415 for the input target domain data 405.

[0103] Example methods for training machine learning models for a target domain.

[0104] Figure 5 This is an example flowchart illustrating 500 methods for training and tuning machine learning models for a target domain.

[0105] Method 500 begins at box 505, where the system is trained using a source domain sample set (e.g., Figure 1 The source domain samples (105) are used to train the source domain feature extractor (e.g., Figures 1-3 (Source domain feature extractor 120). As discussed above, source domain samples typically correspond to training data for the source domain. Source domain samples may or may not have associated labels.

[0106] Training a source domain feature extractor typically involves refining the extractor using a self-supervised loss function that does not consider the labels of the source domain samples. In at least one aspect, the self-supervised loss function is a contrastive loss computed based on the source domain samples and the corresponding augmented or transformed sample set (e.g., a loss computed based on the contrast between datasets), as discussed above.

[0107] In various aspects, stochastic gradient descent, training batch sets, etc., can be used to train the source domain feature extractor. See below for reference. Figure 6 The process of training the source domain feature extractor is described in more detail.

[0108] In box 510, the training system uses a source domain feature extractor and a target domain sample set (e.g., Figure 2-3 The target domain samples 205) are used to train the mask generator (e.g., Figure 2 (Mask generator 215). Target domain samples typically correspond to labeled training data for the target domain. In some respects, although the source and target domains may often involve similar tasks (e.g., both involve classifying images), the source and target domains can be relatively divergent. That is, the distribution of the input data can be significantly different in each domain. Furthermore, the relevant categories in each domain may not overlap at all.

[0109] A mask generator produces an output mask (which can be a binary mask or can be converted to a binary mask) that can be used to select and suppress specific features output by the source domain feature extractor when training a model in the target domain. As discussed above, using a mask generator can help the model learn to adapt to the target domain. In various ways, training the mask generator can be performed using stochastic gradient descent, training batch sets, etc. See below for further details. Figure 7 The process of training the mask generator is described in more detail.

[0110] In box 515, the training system instantiates a target domain feature extractor (e.g., target domain feature extractor 305) and a task classifier (e.g., task classifier 315). In some aspects, the target domain feature extractor is instantiated using the parameters of the source domain feature extractor. That is, the parameters of the source domain feature extractor can be used to initialize the parameters of the target domain feature extractor instead of using random or pseudo-random values. As mentioned above, this reduces the time and computational resources required to train the target domain feature extractor because fewer samples are used. Furthermore, by adapting the target domain feature extractor to the source domain feature extractor, the accuracy of the target domain feature extractor is improved compared to training the target domain feature extractor based on random initialization.

[0111] Method 500 then continues to box 520, where the training system uses labeled target domain samples to refine (or train) the target domain feature extractor and classifier. In some respects, the system uses a mask generator to help refine the parameters of the target domain feature extractor and / or classifier, as discussed above. In various respects, training of the target domain feature extractor and task classifier can be performed using stochastic gradient descent, using training batch sets, etc. See below for further details. Figure 8 The process of training the target domain feature extractor and classifier is described in more detail.

[0112] Example methods for training source domain feature extraction models

[0113] Figure 6 This is a flowchart illustrating an example method 600 for training a source domain feature extractor. In one aspect, method 600 provides... Figure 5 Additional details for box 505 in the middle.

[0114] Method 600 begins at box 605, where the training system receives source domain samples. As discussed above, source domain samples are typically some form of input data for a source domain. Source domain samples may or may not include labels or classifications, as the training system does not use labels during training.

[0115] For example, in image classification tasks, source domain samples can include images. Similarly, for speech recognition or verification tasks, source domain samples can include audio of the user speaking. For driver alertness tasks, source domain samples can include data related to the driver's state (e.g., eye movements, head orientation, grip, etc.).

[0116] In box 610, the training system generates one or more augmented samples based on the source domain samples (e.g., Figure 1 The augmented sample 115 in the example is also called the transformed sample. In some cases, generating augmented samples involves applying one or more transformations (e.g., rotation, translation, cropping, additive noise, color change, inversion, etc.) randomly or pseudo-randomly to the source domain samples. On one hand, configurable hyperparameters can be used to control the number of augmented samples as well as the type and scale of the transformation.

[0117] In box 615, the training system uses a source domain feature extractor to generate a tensor of source features for the received source domain samples. The source feature tensor is a numerical multidimensional tensor or vector, where each dimension of the tensor corresponds to a specific feature. In one respect, the size of the feature tensor (e.g., the number of features) is a configurable hyperparameter of the training system.

[0118] In box 620, the training system similarly generates a corresponding augmentation feature set for each corresponding augmented sample (e.g., Figure 1(Enhanced features 125). The training system does this by feeding each enhanced sample as input to the source domain feature extractor. In all respects, the size or dimension of the enhanced feature set matches the size or dimension of the source features.

[0119] Method 600 then continues to box 625, whereby the training system computes one or more loss metrics based on source features and augmentation features. In some respects, the training system uses the sets of source features and augmentation features to compute a contrastive loss. For example, the training system can use Equation 1 (as above) to compute a loss metric based on received source domain samples.

[0120] In box 630, the training system determines whether the current batch is complete. Generally, the size of each batch is a configurable hyperparameter. If the batch is not complete, method 600 returns to box 605 to process the next source domain sample.

[0121] If the training system determines at box 630 that the current batch has been completed, method 600 continues to box 635, where the training system refines one or more parameters of the source domain feature extractor based on the computed loss. For example, the training system may determine the aggregation loss (e.g., by averaging the losses) based on the losses generated for each source domain sample in the batch. In some aspects, the training system refines the source domain feature extractor by using backpropagation techniques to refine the model's internal parameters.

[0122] Method 600 then proceeds to box 640, where the training system determines whether training of the source domain feature extractor is complete. Various termination criteria can be used to define training completion in various aspects. For example, termination criteria may include a defined number of batches or epochs, the length of time spent training the extractor, the model accuracy on test and / or validation data, etc.

[0123] If training is not complete, method 600 returns to box 605 to begin the next batch of training. If the training system determines at box 640 that the training of the source domain feature extractor is complete, method 600 terminates at box 645. Once the source domain feature extractor has been trained for the source domain, it can be used to train the mask generator and refined to generate the target domain feature extractor, as discussed above.

[0124] Example methods for training a mask generator for a target domain.

[0125] Figure 7 This is an example flowchart illustrating method 700 for training a mask generator. In one aspect, method 700 provides... Figure 5 Additional details for box 505 in the middle.

[0126] Method 700 begins at box 705, where the training system receives target domain samples. As discussed above, target domain samples are typically some form of input data for a target domain. In one aspect, target domain samples are associated with labels or other classifications.

[0127] For example, in the image classification domain, target domain samples may include an image and a corresponding label indicating the correct category of that image. Similarly, for the speech recognition or verification domain, target domain samples may include audio of a user speaking, along with labels or indications regarding the speaker's identity (or whether the speaker has been verified). For the driver alertness domain, target domain samples may include data related to the driver's state (e.g., eye movement, head orientation, grip, etc.), along with indications regarding whether the driver was sufficiently alert when the data was collected.

[0128] In box 710, the training system uses a source domain feature extractor to generate a target feature set from the received target domain samples. In one aspect, the target feature set is a numerical multidimensional tensor, where each dimension of the tensor corresponds to a specific feature. In some cases, the size of the target feature tensor (e.g., the number of features) matches the size of the source features discussed above and is a configurable hyperparameter of the training system.

[0129] In box 715, the training system generates a mask based on target features (e.g., Figure 2 (See section 220). In one aspect, the training system does this by providing the target features as input to a mask generator, which can be a neural network. A mask is typically a set of values ​​ranging from 0 to 1, where the size or dimension of the mask matches the size or dimension of the target features. That is, for each feature or dimension in the target feature set, there exists a corresponding value in the mask.

[0130] In some respects, masks can be used to generate binary masks. That is, while the generated mask can include a variety of values ​​between 0 and 1, the training system can generate a binary mask that includes only 0 or 1 for each value. In some respects, converting a mask to a binary mask involves comparing each value to a threshold (e.g., setting all values ​​less than 0.5 to zero and all other values ​​to 1). In some respects, the training system can add logical noise to the mask (e.g., using Equation 2 above) and then apply an activation function to set the value for each dimension.

[0131] In box 720, the training system generates a set of positive features (e.g., ...) by applying a mask (e.g., a binary mask) to the target features. Figure 2 (230 in the text). On the one hand, positive features are generated by calculating the element-wise product between the mask and the target features, as discussed above.

[0132] Additionally, in box 725, the training system generates a negative feature set by applying a (binary) mask to the target features (e.g., Figure 2 (235 in the text). On the one hand, negation features are generated by calculating the element-wise product between the mask's negation and the target feature, as discussed above.

[0133] Method 700 continues to box 730, wherein the training system computes one or more loss metrics based on (a plurality of) positive features and / or (a plurality of) negative features. In some respects, the training system uses positive and negative features to compute three loss metrics: positive loss based on positive features, negative loss based on negative features, and divergence loss based on both positive and negative features.

[0134] In at least one aspect, the training system uses one or more minimum cross-entropy techniques (such as using Equation 3 above) to calculate the affirmative loss. Similarly, the training system can use one or more maximum entropy techniques (such as using Equation 4 above) to calculate the negative loss. Furthermore, the training system can use one or more maximum mean difference techniques (such as using Equation 5 above) to calculate the divergence loss.

[0135] In some respects, the training system can then compute the total loss of the training process by aggregating the individual loss metrics. For example, the training system can sum the individual loss components together. In some respects, this sum is a weighted aggregation (e.g., using Equation 6 above), where the specific weights applied to each component of the loss can be trainable parameters or configurable hyperparameters.

[0136] In box 735, the training system can then determine whether the current training batch is complete. In one aspect, the size of each batch is a configurable hyperparameter. If the batch is not complete, method 700 returns to box 705 to process the next target domain sample.

[0137] If the training system determines at box 735 that the current batch is complete, method 700 continues to box 740, where the training system refines one or more parameters of the mask generator based on the computed loss. For example, the training system may determine the aggregation loss (e.g., by averaging the losses) based on the losses generated for each target domain sample in the batch. In some respects, the training system refines the mask generator by using backpropagation techniques to refine the model's internal parameters. As mentioned above, the parameters of the source domain feature extraction model can remain unchanged when the mask generator is refined.

[0138] Method 700 then proceeds to box 745, where the training system determines whether the training of the mask generator is complete. Various termination criteria can be used to define training completion in various aspects. For example, termination criteria may include a defined number of batches or epochs, the length of time taken to train the mask generator, reaching a threshold loss, etc.

[0139] If training is not complete, method 700 returns to box 705 to begin the next batch of training. If the training system determines at box 745 that the mask generator training is complete, method 700 terminates at box 750. Once the mask generator has been trained for the target domain, it can be used to refine the source domain feature extractor to generate the target domain feature extractor, as discussed above.

[0140] Example methods for training target feature extraction and classifier models

[0141] Figure 8 This is a flowchart illustrating an example method 800 for training a target domain feature extractor and classifier. In one aspect, method 800 provides... Figure 5 Additional details for box 520 in the middle.

[0142] Method 800 begins at box 805, where the training system receives target domain samples. As discussed above, target domain samples are typically some form of input data for a target domain. In one aspect, target domain samples are associated with labels or other classifications.

[0143] In box 810, the training system uses a source domain feature extractor to generate a target feature set from the received target domain samples. As discussed above, the target feature set can be a numerical multidimensional tensor, where each dimension of the tensor corresponds to a specific feature.

[0144] In box 815, the training system generates a mask by processing the target features using a mask generator. In various respects, the generated mask can be a set of values ​​ranging from 0 to 1, or it can be a binary mask (which can be generated based on a continuous mask).

[0145] Method 800 then proceeds to box 820, where the training system generates a positive feature set by applying a (binary) mask to the generated target features. As discussed above, this can be performed by computing the element-wise product between the (binary) mask and the target features, as discussed above.

[0146] In box 825, the training system uses target domain samples to generate a task feature set. Task features are generated by processing the target domain samples using a target domain feature extractor. In some respects, the target domain feature extractor is initialized using the parameters of the (trained) source domain feature extractor. Initially, the target domain feature extractor is aligned with the source domain feature extractor, and the outputs will be the same (or similar). However, as training progresses and the parameters of the target domain feature extractor are refined for the target domain (while the parameters of the source domain feature extractor remain fixed), their outputs will diverge.

[0147] In box 830, the training system uses a task classifier to classify the generated task features, as discussed above. Method 800 then continues to box 835.

[0148] In box 835, the training system computes one or more loss metrics based on the generated task features(s) and the positive feature set. This loss component can be used to regularize the target domain feature extractor based on the features selected by the generated mask. Since the mask generator is trained using target domain samples, the target domain feature extractor is thus adapted to the target domain. In at least one aspect, the training system uses one or more distance techniques (such as by using Equation 7 above) to compute the feature loss.

[0149] In box 840, the training system may similarly compute one or more loss metrics based on the generated task features(s) and the generated classification(s) for the target domain samples. In at least one aspect, the training system uses one or more minimum cross-entropy techniques (such as by using Equation 8 above) to compute the task loss.

[0150] In some respects, the training system can then compute the total loss of the training process by aggregating individual loss metrics. For example, the training system can sum the individual loss components together. In some respects, this sum is a weighted aggregation (e.g., using Equation 9 above), where the specific weights applied to each component of the loss can be trainable parameters or configurable hyperparameters.

[0151] In box 845, the training system can then determine whether the current training batch is complete. In one aspect, the size of each batch is a configurable hyperparameter. If the batch is not complete, method 800 returns to box 805 to process the next target domain sample.

[0152] If the training system determines at box 845 that the current batch is complete, method 800 continues to box 850, where the training system refines one or more parameters of the task classifier and the target domain feature extractor based on the computed loss. For example, the training system may determine the aggregation loss (e.g., by averaging the losses) based on the losses generated for each target domain sample in the batch. In some respects, the training system refines the intrinsic parameters of the model to refine the task classifier and the target domain feature extractor by using backpropagation techniques. In all respects, although the target domain feature extractor and the task classifier are refined, the parameters of the source domain feature extraction model and the mask generator are fixed.

[0153] Method 800 then proceeds to box 855, where the training system determines whether training of the target domain feature extractor and the task classifier is complete. Various termination criteria can be used to define training completion in various aspects. For example, termination criteria may include a defined number of batches or epochs, the length of time spent training the model, etc.

[0154] If training is not complete, method 800 returns to box 805 to begin the next batch of training. If the training system determines at box 855 that the training of the task classifier and the target domain feature extractor is complete, method 800 terminates at box 860. The target domain feature extractor and the task classifier can then be used to classify new input data against the target domain, as discussed above.

[0155] Example methods for training machine learning models for a target domain.

[0156] Figure 9 This is a flowchart illustrating a method 900 for classifying input data in a target domain using a target domain feature extraction model, based on some aspects disclosed in this paper.

[0157] Method 900 begins at box 905, where the inference system receives input data from the target domain. In some aspects, the inference system uses a trained target model (e.g., as described above). Figures 1-3 and Figures 5-8 The training system discussed is a discrete system (trained by the system in question). In other respects, inference and training can be performed using a single system or device. Generally, the input data corresponds to received or collected unlabeled data used for classification (such as...). Figure 4 Target domain data 405).

[0158] In box 910, the inference system uses a target domain feature extractor to generate a feature set for the input data. For example, the inference system can use a target domain feature extractor to process the input data, which is based on the above reference. Figures 1-3 and Figures 5-8The techniques discussed are for training and tuning.

[0159] In box 915, the inference system can use a task classifier to classify the generated feature set. For example, the inference system can use a task classifier to process the feature set, which uses the above-mentioned reference... Figures 1-3 and Figures 5-8 The techniques discussed are used for training.

[0160] In box 920, the inference system returns the generated classifications(s) for the input data. In this way, the inference system can use models trained in the source domain and adapted to the target domain to generate classifications. This improves the operation of the model and the inference system by achieving more accurate classifications, while reducing the need to train on samples in the target domain.

[0161] Example methods for training machine learning models for a target domain.

[0162] Figure 10 This explains, based on some aspects disclosed in this paper, the training of target domain feature extraction models (e.g., Figure 3 The flowchart of method 1000 (305) in the middle.

[0163] Method 1000 begins at box 1005, where the training system trains the source domain feature extraction model based on the source dataset.

[0164] In some respects, self-supervised loss functions are used to train source domain feature extraction models. In other respects, self-supervised loss functions include contrastive loss functions.

[0165] In some aspects, method 1000 also includes enhancing the source dataset by performing one or more transformations on one or more samples of the source dataset. Additionally, in some aspects, the contrastive loss function includes Equation 1 above.

[0166] In box 1010, the training system trains the mask generation model based on the target dataset (e.g., Figure 2 (215 in the text), where the mask generation model takes the output from the trained source domain feature extraction model as input.

[0167] In some respects, training a mask generation model involves generating a positive feature set based on a target dataset and the mask generation model, and generating a negative feature set based on a target dataset and the mask generation model.

[0168] Additionally, in some aspects, method 1000 also includes using a mask generation model to generate a mask set (e.g., Figure 2(220 in the original text), and generating a binary mask set based on the mask set. In some aspects, generating a binary mask set based on the mask set includes adding logical noise to the mask set and applying a non-linear activation function to the mask set. In at least one aspect, the non-linear activation function includes the sigmoid function.

[0169] In some aspects, a loss function that includes a cross-entropy loss component based on the positive feature set is used to train the mask generation model. Additionally, in some aspects, the loss function also includes a maximum entropy loss component based on the negative feature set. Furthermore, in some aspects, the loss function also includes a divergence loss component based on both the positive and negative feature sets.

[0170] In some respects, the loss function also includes a first weighting parameter for the cross-entropy loss component, a second weighting parameter for the maximum entropy loss component, and a third weighting parameter for the divergence loss component.

[0171] In box 1015, the training system generates a target domain feature extraction model based on the source domain feature extraction model (e.g., Figure 3 (305 in the text). In some respects, target domain feature extraction models include neural network models.

[0172] In box 1020, the training system uses a mask generation model and the target dataset to tune the target domain feature extraction model.

[0173] In some aspects, a loss function including a regularization loss component is used to train the target domain feature extraction model. In at least one aspect, the regularization loss component includes an Euclidean distance function. Additionally, in some aspects, the loss function also includes a cross-entropy loss component.

[0174] In some respects, for a given sample, the cross-entropy loss component is configured to generate a cross-entropy loss value based on the positive features generated by the mask generation model based on the given sample and the classification output generated by the linear classification model based on the given sample.

[0175] In at least one respect, the loss function also includes weighting parameters for the regularization loss components.

[0176] In some respects, method 1000 also includes using a target domain feature extraction model to generate inferences.

[0177] Example system for adaptive machine learning

[0178] In some respects, it is possible to perform actions on one or more devices regarding Figure 1-10The methods and workflows described. For example, training and inference can be performed on a single device or distributed across multiple devices. Typically, the model will be trained on a powerful computing device and then deployed to other less powerful devices (e.g., mobile devices) to perform inference.

[0179] Figure 11 This is a block diagram illustrating processing system 1100, which can be configured to perform aspects of the various methods described herein, including, for example, those concerning... Figure 1-10 The method described.

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

[0181] The processing system 1100 also includes additional processing components tailored for specific functions, such as a graphics processing unit (GPU) 1104, a digital signal processor (DSP) 1106, and a neural processing unit (NPU) 1110.

[0182] Despite Figure 11 Not described, but the NPU 1110 can be implemented as part of one or more of the CPU 1102, GPU 1104 and / or DSP 1106.

[0183] The processing system 1100 also includes input / output 1108. In some aspects, input / output 1108 may include one or more network interfaces, thereby allowing the processing system 1100 to be coupled to one or more other devices or systems via a network (such as the Internet).

[0184] Although not included in the aspects described, the processing system 1100 may also include one or more additional input and / or output devices 1108, such as screens, physical buttons, speakers, microphones, etc.

[0185] The processing system 1100 also includes a memory 1114, 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 1114 includes computer-executable components that can be executed by one or more of the aforementioned processors of the processing system 1100.

[0186] In this example, memory 1114 includes enhancement component 110, source domain feature extractor 120, loss component 135, mask generator 215, target domain feature extractor 305, and task classifier 315. The depicted components, as well as other undepicted components, can be configured to perform various aspects of the method described herein. Memory 1114 also includes a set of source domain samples 105 and target domain samples 205, as discussed above.

[0187] Example Terms

[0188] Item 1: A method comprising: training a source domain feature extraction model based on a source dataset; training a mask generation model based on a target dataset, wherein the mask generation model takes as input the output from the trained source domain feature extraction model; generating a target domain feature extraction model based on the source domain feature extraction model; and tuning the target domain feature extraction model using the mask generation model and the target dataset.

[0189] Clause 2: The method of Clause 1, wherein the source domain feature extraction model is trained using a self-supervised loss function.

[0190] Clause 3: The method of any of Clauses 1 to 2, wherein the self-supervised loss function includes the contrastive loss function.

[0191] Clause 4: The method of any of Clauses 1 to 3 further includes: enhancing the source dataset by performing one or more transformations on one or more samples of the source dataset.

[0192] Clause 5: The method of any of Clauses 1 to 4, wherein the contrastive loss function includes ,in It is a source domain feature extraction model. It is a distance metric. It is the batch size of the source dataset. It is the number of enhancements. It is the original sample of the source dataset and These are transformed samples from the source dataset.

[0193] Clause 6: The method of any of Clauses 1 to 5, wherein training the mask generation model comprises: generating a positive feature set based on the target dataset and the mask generation model; and generating a negative feature set based on the target dataset and the mask generation model.

[0194] Clause 7: The method of any of Clauses 1 to 6 further includes: generating a mask set using a mask generation model; and generating a binary mask set based on the mask set.

[0195] Clause 8: The method of any of Clauses 1 to 7, wherein generating a binary mask set based on the mask set comprises: adding logical noise to the mask set; and applying a nonlinear activation function to the mask set.

[0196] Clause 9: The method of any of Clauses 1 to 8, wherein the nonlinear activation function includes the sigmoid function.

[0197] Clause 10: The method of any of Clauses 1 to 9, wherein the mask generation model is trained using a loss function that includes a cross-entropy loss component based on a set of positive features.

[0198] Clause 11: The method of any of Clauses 1 to 10, wherein the loss function further includes a maximum entropy loss component based on the negative feature set.

[0199] Clause 12: The method of any of Clauses 1 to 11, wherein the loss function further includes a divergence loss component based on a positive feature set and a negative feature set.

[0200] Clause 13: The method of any of Clauses 1 to 12, wherein the loss function further comprises: a first weighting parameter for the cross-entropy loss component; a second weighting parameter for the maximum entropy loss component; and a third weighting parameter for the divergence loss component.

[0201] Clause 14: The method of any of Clauses 1 to 13, wherein the target domain feature extraction model is trained using a loss function that includes a regularized loss component.

[0202] Clause 15: The method of any of Clauses 1 to 14, wherein the regularization loss component comprises the Euclidean distance function.

[0203] Clause 16: The method of any of Clauses 1 to 15, wherein the loss function further includes a cross-entropy loss component.

[0204] Clause 17: The method of any of Clauses 1 to 16, wherein, for a given sample, the cross-entropy loss component is configured to generate a cross-entropy loss value based on positive features generated by a mask generation model based on the given sample and a classification output generated by a linear classification model based on the given sample.

[0205] Clause 18: The method of any of Clauses 1 to 17, wherein the loss function further includes weighting parameters for the regularization loss components.

[0206] Clause 19: The method of any of Clauses 1 to 18, wherein the target domain feature extraction model includes a neural network model.

[0207] Clause 20: The method of any of Clauses 1 to 19 further includes: using a target domain feature extraction model to generate inference.

[0208] Item 21: A method comprising: tuning a target domain feature extraction model based on a source domain feature extraction model trained on a source dataset, wherein: the tuning is performed using a mask generation model trained on a target dataset, and the tuning is performed using the target dataset.

[0209] Clause 22: The method of Clause 21 further includes any of Clauses 2 to 20.

[0210] Clause 23: A system comprising: a memory including computer-executable instructions; and one or more processors configured to execute the computer-executable instructions and cause the processing system to perform a method pursuant to any of Clauses 1 to 22.

[0211] Clause 24: A non-transient computer-readable medium comprising computer-executable instructions that, when executed by one or more processors of a processing system, cause the processing system to perform a method according to any one of Clauses 1 to 22.

[0212] Clause 25: 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 one of Clauses 1 to 22.

[0213] Additional considerations

[0214] The foregoing description is provided to enable any person skilled in the art to practice the various aspects described herein. The examples discussed herein are not intended to limit the scope, applicability, or aspects set forth in the claims. Various modifications to these aspects will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other aspects. For example, the function and arrangement of the elements in discussion may be altered 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 complement or differ from the aspects 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.

[0215] 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.

[0216] As used in this article, 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).

[0217] 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., searching 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.

[0218] 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 drawings are present, these operations may have corresponding paired means with similar numbers plus functional components.

[0219] The following claims are not intended to be limited to the aspects 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 for cross-domain adaptive machine learning, comprising: A source domain feature extraction model is used to train a target domain feature extraction model, wherein the source domain feature extraction model has been trained on a source dataset, and the training includes: Use the target dataset and the source domain feature extraction model to generate one or more target features; One or more masks are generated using the one or more target features and a mask generation model trained only on the target dataset; A task feature set is generated by applying the one or more masks to the one or more target features; and The loss is generated using the one or more target features and the task feature set; and Deploy a trained target domain feature extraction model for use in at least one of the following: Voice recognition or verification Image verification Image classification, Advanced driver assistance systems, or Driver alertness task.

2. The method as described in claim 1, wherein, The source domain feature extraction model is trained using a self-supervised loss function.

3. The method as described in claim 2, wherein, The self-supervised loss function includes the contrastive loss function.

4. The method of claim 3, further comprising: The source dataset is enhanced by performing one or more transformations on one or more samples of the source dataset.

5. The method of claim 1, wherein, Training the mask generation model includes: Generate a positive feature set based on the target dataset and the mask generation model; and A negative feature set is generated based on the target dataset and the mask generation model.

6. The method of claim 5, further comprising: Use the mask generation model to generate a mask set; as well as A binary mask set is generated based on the mask set.

7. The method of claim 6, wherein, Generating the binary mask set based on the mask set includes: Add logical noise to the mask set; and A nonlinear activation function is applied to the mask set.

8. The method of claim 7, wherein, The nonlinear activation function includes the sigmoid function.

9. The method of claim 5, wherein, The mask generation model is trained using a loss function that includes a cross-entropy loss component based on the positive feature set.

10. The method of claim 9, wherein, The loss function further includes a maximum entropy loss component based on the negative feature set.

11. The method of claim 10, wherein, The loss function further includes a divergence loss component based on the positive feature set and the negative feature set.

12. The method of claim 11, wherein, The loss function further includes: The first weighting parameter for the cross-entropy loss component; The second weighting parameter for the maximum entropy loss component; and The third weighting parameter for the divergence loss component.

13. The method of claim 1, wherein, Generating the loss involves using a loss function that includes a regularized loss component.

14. The method of claim 13, wherein, The regularization loss component includes the Euclidean distance function.

15. The method of claim 14, wherein, The loss function further includes a cross-entropy loss component.

16. The method of claim 15, wherein, For a given sample, the cross-entropy loss component is configured to generate a cross-entropy loss value based on the positive features of the task feature set generated by the mask generation model based on the given sample and the classification output generated by the linear classification model based on the given sample.

17. The method of claim 15, wherein, The loss function further includes weighting parameters for the regularization loss components.

18. The method of claim 1, wherein, The target domain feature extraction model includes a neural network model.

19. The method of claim 1, further comprising: The trained target domain feature extraction model is used to generate inferences.

20. A processing system, comprising: Memory including computer-executable instructions; as well as One or more processors, the one or more processors being configured to execute the computer-executable instructions and cause the processing system to perform operations including: A source domain feature extraction model is used to train a target domain feature extraction model, wherein the source domain feature extraction model has been trained on a source dataset, and the training includes: Use the target dataset and the source domain feature extraction model to generate one or more target features; One or more masks are generated using the one or more target features and a mask generation model trained only on the target dataset; A task feature set is generated by applying the one or more masks to the one or more target features; and The loss is generated using the one or more target features and the task feature set; and Deploy a trained target domain feature extraction model for use in at least one of the following: Voice recognition or verification Image verification Image classification, Advanced driver assistance systems, or Driver alertness task.

21. The processing system of claim 20, wherein, The source domain feature extraction model is trained using a self-supervised loss function.

22. The processing system of claim 21, wherein, The self-supervised loss function includes the contrastive loss function.

23. The processing system of claim 22, wherein the operation further comprises: The source dataset is enhanced by performing one or more transformations on one or more samples of the source dataset.

24. The processing system of claim 20, wherein, Training the mask generation model includes: A positive feature set is generated based on the target dataset and the mask generation model; A negative feature set is generated based on the target dataset and the mask generation model; The mask generation model is used to generate a mask set; and A binary mask set is generated based on the mask set.

25. The processing system of claim 24, wherein, Generating the binary mask set based on the mask set includes: Add logical noise to the mask set; and A nonlinear activation function is applied to the mask set.

26. The processing system of claim 25, wherein, The mask generation model is trained using a loss function, which includes: The cross-entropy loss component is based on the affirmative feature set; The maximum entropy loss component based on the negation feature set; and The divergence loss component is based on the positive feature set and the negative feature set.

27. The processing system of claim 26, wherein, The loss function further includes: The first weighting parameter for the cross-entropy loss component; The second weighting parameter for the maximum entropy loss component; and The third weighting parameter for the divergence loss component.

28. The processing system of claim 20, wherein: Generating the loss involves using a loss function that includes a regularized loss component, and The regularization loss component includes the Euclidean distance function.

29. The processing system of claim 20, wherein, The operation further includes: using the trained target domain feature extraction model to generate inference.

Images