Semi-supervised regression with generative adversarial networks

Abstract

The application relates to the field of artificial intelligence, and provides a method and system for performing semi-supervised regression by using a generative adversarial network (GAN), wherein the generative adversarial network comprises a generator comprising a first neural network and a discriminator comprising a second neural network. The method and system comprise: outputting, by the first neural network, generated samples obtained from random noise vectors; inputting, into the second neural network, the generated samples, a plurality of labeled training samples and a plurality of unlabeled training samples; and outputting, by the second neural network, predicted continuous labels for each of the generated samples and the unlabeled samples.

Description

[0001] Related applications cross-application

[0002] This application claims the benefit and priority of U.S. Provisional Patent Application No. 62 / 508,819, filed May 19, 2017, entitled "Semi-supervised Regression Using Generative Adversarial Networks," and the prior art of the same application, filed October 20, 2017, the contents of which are incorporated herein by reference. Technical Field

[0003] This invention relates to generative adversarial networks, and more particularly to semi-supervised regression learning in generative adversarial networks. Background Technology

[0004] Deep learning has achieved tremendous success in various fields such as natural language processing (NLP), autonomous driving, game theory, and unsupervised learning. Generative adversarial networks (GANs) have been developed to generate synthetic real images. GANs correspond to binary minimax games, where two models are trained simultaneously: a generative model G, which captures the data distribution; and a discriminative model D, which calculates the probability that a sample comes from the training data rather than the generator.

[0005] GAN schemes can be useful when there are insufficient training samples.

[0006] Despite recent progress in GANs, key issues remain regarding the evaluation, training, and labeling of generated samples. Summary of the Invention

[0007] An exemplary aspect of the present invention provides a method and system for performing semi-supervised regression using generative adversarial networks. In some examples, applying a GAN-based approach can generate realistic, high-quality samples and predict consecutive labels for generated samples and unlabeled samples in the training dataset.

[0008] In an exemplary embodiment, a GAN is disclosed for predicting continuous labels based on a training dataset containing only a finite number of labeled samples. It can also predict labels for unlabeled training samples and generated samples. The GAN can be applied to, for example, autonomous driving applications, such as determining steering angles.

[0009] According to a first aspect, there is provided a method for training a generative adversarial network (GAN) comprising a generator comprising a first neural network and a discriminator comprising a second neural network. The method comprises: the first neural network outputting generated samples obtained from random noise vectors; inputting the generated samples, a plurality of labeled training samples and a plurality of unlabeled training samples to the second neural network; the second neural network outputting a predicted continuous label for each of the generated samples and the unlabeled samples.

[0010] In some example embodiments, the second neural network outputs each continuous label as a normalized value. In some examples, the method comprises: the second neural network outputting a probability that the input sample is an actual sample.

[0011] In some example embodiments, the method comprises: determining a probability that a generated sample is an actual sample and based on the predicted continuous label for the generated sample. In some examples, determining the probability is performed by a kernel function based on whether the normalized value of the continuous label is within a predetermined range.

[0012] In some examples, the labeled training samples comprise a series of front-facing camera image samples of a moving vehicle, each of the labeled training samples labeled with a steering angle.

[0013] In some examples, prior to convergence of parameters of the neural networks, the method comprises: repeating the following operations: the first neural network outputting generated samples; inputting the generated samples, labeled training samples and unlabeled training samples to the second neural network; the second neural network outputting predicted continuous labels. During each repetition, computing a loss function for each of the second neural network and the first neural network; based on the computed loss functions, adjusting weight parameters of the second neural network and the first neural network.

[0014] In some examples, the loss function for the first neural network comprises a feature matching loss function based on a difference between outputs of an intermediate layer of the second neural network for the training samples and the generated samples, respectively. Further, in some configurations, the loss function for the second neural network is a combination of a supervised portion and an unsupervised portion. In some examples, the supervised portion is based on a difference between actual labels of the labeled samples provided to the second neural network and the predicted continuous labels.

[0015] According to a second aspect, there is provided a system for training a generative adversarial network (GAN) comprising a generator comprising a first neural network and a discriminator comprising a second neural network. The system comprises a processing device and a memory coupled to the processing device. The memory stores computer-executable instructions that, when executed by the processing device, cause the system to: define the first neural network and the second neural network; output, from the first neural network, generated samples obtained from random noise vectors; input, to the second neural network, the generated samples, a plurality of labeled training samples, and a plurality of unlabeled training samples; and output, from the second neural network, a predicted continuous label for each of the generated samples and the unlabeled samples.

[0016] In some examples of the system, the second neural network outputs each continuous label as a normalized value. In some examples, the system outputs, from the second neural network, a probability that the input sample is an actual sample. In some examples, the system is configured to determine a probability that a generated sample is an actual sample generated based on the predicted continuous label. In some examples, the system is configured to define a kernel function that determines the probability based on whether the normalized value of a continuous label is within a predetermined range.

[0017] According to another aspect, there is provided a computer program product comprising a computer readable medium storing computer-executable instructions for causing a processing system to perform a method of: defining a generative adversarial network (GAN) comprising a generator comprising a first neural network and a discriminator comprising a second neural network; outputting, from the first neural network, generated samples obtained from random noise vectors; inputting, to the second neural network, the generated samples, a plurality of labeled training samples, and a plurality of unlabeled training samples; and outputting, from the second neural network, a predicted continuous label for each of the generated samples and the unlabeled samples. BRIEF DESCRIPTION OF DRAWINGS

[0018] Reference will now be made to the drawings in which the exemplary embodiments of the application will be illustrated, by way of example, and will be described herein below.

[0019] Figure 1 is a block diagram of a generative adversarial network (GAN) provided by the first exemplary embodiment;

[0020] Figure 2is a block diagram of a GAN provided by a second example embodiment;

[0021] Figure 3 is a block diagram of a GAN provided by an example embodiment Figure 1 or Figure 2 is a block diagram of a generator of the GAN of

[0022] Figure 4 is a block diagram of a discriminator of the GAN of Figure 1

[0023] Figure 5 is a block diagram of a discriminator of the GAN of Figure 2

[0024] Figure 6 is a flowchart illustrating a method performed by a GAN of Figure 1 or Figure 2

[0025] Figure 7 illustrates an example of a semi-supervised regression system implemented by a GAN provided by an example embodiment;

[0026] Figure 8 illustrates a method implemented by the semi-supervised regression system of Figure 7

[0027] Figure 9 is a block diagram of a processing system that can be used to implement a GAN and a semi-supervised regression system provided by an example embodiment.

[0028] Similar reference numbers can be used throughout the different drawings to refer to similar components. DETAILED DESCRIPTION

[0029] A generative adversarial network (GAN) includes two separate deep networks: a generator network and a discriminator network. The generator network (commonly referred to in the art as a generator) is implemented by a first neural network, and the discriminator network (commonly referred to in the art as a discriminator) is implemented by a second neural network. The generator is trained to obtain a random variable z having a distribution P z (z) and to map the random variable z to an output value within a data distribution P data (x) of a training data set. The discriminator provides a training signal for the generator. The output distribution P model (x) of the generator should converge to the data distribution P data ​​​​(x). On the other hand, the discriminator is expected to distinguish actual samples (also referred to herein as real samples) from generated samples by giving an output of 1 or 0, respectively. During the GAN training process, the generator and discriminator are used to generate samples and classify the samples by improving each other's performance in an adversarial manner, respectively. In this regard, as described in "Generative Adversarial Nets," I. J. Goodfellow, J. P. Abadie, M. Mirza, B. Xu, D. W. Farley, S. Ozair, A. Courville, and Y. Bengio, Advances in Neural Information Processing Systems (NIPS) 2014, pp. 2672-2680 (2014), the generator and discriminator are trained in an adversarial manner. The following adversarial loss function can be used when training the generator and discriminator: https: / / arxiv.org / pdf / 1406.2661.pdf

[0030] Equation 1:

[0031]

[0032] GANs implement a binary minimax game, with the goal of deriving a Nash equilibrium point. Finding a solution to this game is not trivial, and much research has been conducted in this area, resulting in various types of GAN designs. Most of these GAN designs aim to improve training stability and the quality of the generated synthetic samples, and many of these GAN designs rely on heuristic methods to find a stable architecture, thus solving the problem of unstable training. GANs can be used to generate additional actual synthetic samples to be used as future training samples when actual training samples are insufficient. However, existing GAN systems lack the ability to effectively predict the labels of the generated synthetic samples.

[0033] ​Supervised learning techniques utilize labeled data samples. Supervised learning techniques improve the performance of a supervised task, such as classification, by learning based on labeled samples. Semi-supervised learning techniques utilize labeled and unlabeled data samples when labeling samples. Semi-supervised learning techniques improve the performance of a supervised task, such as classification, by learning based on additional unlabeled samples, requiring a smaller number of labeled samples for training. This makes semi-supervised learning techniques suitable for applications where the number of labeled samples in the training set is limited and obtaining labeled samples is expensive or difficult, such as autonomous driving. In this context, generative models, such as GANs, can be used to generate realistic samples that can be added to the training dataset in a semi-supervised manner. For example, in D. P. Kingma, S. Mohamed, D. J. Rezende, and M. Welling, "Semi-supervised learning with deep generative models," Advances in Neural Information Processing Systems, pp. 3581-3589 (2014), a semi-supervised learning method utilizing deep generative models is presented, illustrating the use of deep generative models and approximate Bayesian inference. Other semi-supervised techniques utilizing GANs have been proposed, including, for example, Improved GAN, Classification GAN, SGAN, and Triplet GAN. However, previous semi-supervised techniques utilizing GANs have generally focused on using a discrete number of classes for classification.

[0034] Classification techniques select a label for an input sample from a set number (K) of labels (e.g., in the example of capital letters, K = 26). On the other hand, regression methods assign a real number (e.g., a floating point data type) as a label for each sample. The cost of employing semi-supervised classification techniques for regression is the conversion of continuous labels of a dataset into a discrete number of classes. Converting continuous labels (in a regression problem) into a discrete number of classes (to produce a classification problem) introduces quantization error into the training. Furthermore, employing classification techniques for regression problems generally requires the network to have more outputs, and thus more network parameters, compared to regression techniques. Thus, using semi-supervised classification techniques for regression problems is complex and inefficient.

[0035] Accordingly, there is a need for a scheme that enables semi-supervised regression with GANs. In this regard, exemplary embodiments are described below in which a GAN generates synthetic samples as realistic, high-quality samples (e.g., generated samples that are indistinguishable from actual training samples) that predict a continuous label corresponding to the samples. In exemplary embodiments, regression is addressed in the context of semi-supervised learning. In contrast to classification tasks, which only have a finite number of classes, regression tasks are defined as predicting a continuous label for each of a plurality of samples of a given dataset. A continuous label represents a continuous value or real number (e.g., a floating point number).

[0036] An exemplary embodiment provides a GAN scheme for generating samples and predicting consecutive labels for the generated samples using a training dataset with only a finite number of labeled samples. This enables the training dataset and the generated samples to be used to train a more powerful deep network to be used in the regression task.

[0037] Figure 1 An exemplary embodiment of a GAN 100 for implementing semi-supervised regression is shown. The GAN 100 includes a generator 102 for generating actual generated samples x. gen set X gen Training samples x that are similar to or close to the actual labeled samples lab and the actual unlabeled training samples x unl The training dataset {X} lab X unl The GAN 100 also includes a discriminator 104, comprising a deep convolutional neural network (CNN), used to verify the generated sample x. gen and predicting the continuous labels of these samples The discriminator 104 outputs that the input sample x is an actual sample (i.e., the input sample x is a labeled training sample x). lab Or unlabeled training sample x unl Or is it a fake sample (i.e., the input sample x is a generated sample)? gen The predicted probability D(x) is used to verify the sample x.

[0038] exist Figure 1 middle:

[0039] Z: Random noise vector

[0040] X gen : Generated samples

[0041] X lab : Labeled training samples

[0042] X unl Unlabeled training samples

[0043] Predicted continuous labels

[0044] D(x): The predicted probability of input sample x being either an actual sample or a fake sample, where x∈{x...} gen x lab ,x unl .}

[0045] In an exemplary embodiment, the generator 102 is trained using the feature matching loss technique introduced in “An Improved Technique for Training GANs” published by T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Redford, and X. Chen in the 2016 Computational Research Knowledge Base ABS journal / 1606.03498 (https: / / arxiv.org / pdf / 1606.03498.pdf). The feature matching loss is... feature_matching The real (actual) sample {x} lab ,x unl The output of the intermediate layer of the discriminator 104 and the generated sample x gen The average of the absolute differences between them.

[0046] When training the generator 102, the feature matching loss is used. feature_matching Therefore, the loss function of the generator 102 can be expressed as:

[0047] Loss G =Loss feature_matching

[0048] exist Figure 1 In the example, discriminator 104 is configured with two outputs: one output is responsible for predicting consecutive labels. Another determination of the generated sample x gen D(x) represents the probability of a real sample or a fake sample. If the real continuous labels are mapped (or normalized) to the range [0, 1], an sigmoid nonlinearity in the last layer of the discriminator 104 network can be used. The discriminator 104 is trained using a combination of commonly used unsupervised GAN loss functions and supervised regression losses:

[0049] Loss D =L unsupervised +L supervised (Equation 3)

[0050]

[0051]

[0052] in:

[0053] z represents noise extracted from a uniform or normal distribution;

[0054] x and G(z) respectively describe the actual sample (x) unl x lab ) and the generated sample (x) gen ); y refers to the labeled training sample (xlab the true (actual) value of the label;

[0055] a predicted continuous label representing the sample;

[0056] only for labeled training samples x lab L is computed supervised ;

[0057] p data (x) is the distribution of the training samples (labeled and unlabeled).

[0058] “X. Mao, Q. Li, H. Xie, R. Y. K. Lau, Z. Wang and S. P. Smolley, Least Squares Generative Adversarial Networks, arXiv preprint arXN: 1611.04076, 2016” incorporates the unsupervised part of the above equations. Moreover, in the case of labeled training samples x lab , the supervised regression error (i.e. the difference between the predicted and true continuous label of the labeled training samples) is added to the discriminator loss function Loss D ; ; D helps training the GAN to generate continuous labels for the unlabeled training samples x unl or generated samples x gen .

[0059] Figure 2 Another exemplary embodiment provides a GAN 200, also for implementing semi-supervised regression, is shown. The GAN 200 is similar to the GAN 100, except for differences that will be apparent in the drawings and in the following description. The GAN 200 includes the same generator 102 as described above. However, the discriminator 204 of the GAN 200 differs from the discriminator 104 of the GAN 100 in that it includes a kernel function 208 after the discriminator CNN 206 outputs. Instead of having two outputs from the CNN 206 in the discriminator 104, only one regression output, i.e. the predicted continuous label is predicted by the CNN 206 in the discriminator 204, which is used as input to the kernel function 208, which is based on the predicted continuous label of the sample. A probability index value D(x) is assigned to each sample. In some examples, the kernel function 208 can be implemented in a layer of the discriminator CNN 206.

[0060] Thus, the discriminator 204 uses the individual kernel function 208 of the regression output of the CNN 206 to decide whether the predicted continuous label of a sample is real, rather than directly distinguishing between real and generated samples at the CNN 206. The kernel function 208 is responsible for assigning a probability index value to each input continuous label based on the assumption that the true label can be mapped / normalized to the range of 【0, 1】 . If the predicted continuous label is within the normalized range of the true label (i.e. between 0 and 1), the assigned probability index value D(x) is 1, otherwise the index value less than 1 will be assigned according to the distance between the predicted value of the continuous label and the target range of the true label, as represented by the following equation:

[0061]

[0062] In Figure 2 :

[0063] Z: random noise vector

[0064] X gen : generated sample

[0065] X lab : labeled training sample

[0066] X unl : unlabeled training sample

[0067] predicted label of an input sample

[0068] probability index value representing the actual degree of the input sample based on the predicted label

[0069] the discriminator loss function Loss D of the discriminator 204 is the same as the discriminator 104.

[0070] In exemplary embodiments, the training algorithm is implemented in Python using the Python library "Theano" to efficiently perform multi-dimensional array calculations, and the deep learning library "lasagna" to train and build neural networks in Theano. An exemplary embodiment of the training algorithm can be summarized as follows:

[0071] ​Input: Morning (z) of the generator 102. Labeled and unlabeled training samples (x lab , x unl ) of the discriminator 104 or 204.

[0072] Output: Generator 102 creates unseen real samples (x gen ).

[0073] Discriminator 104 or 204 provides: (i) probability D(x) of discriminating between the real (x lab , x unl ) and fake samples (x gen ); (ii) predicted continuous label

[0074] Method:

[0075] 1. Load data;

[0076] 2. Define the network of the generator and discriminator. The network is a stack of neural network layers in lasagne;

[0077] 3. Define the cost function (e.g. loss function) by using the output of the discriminator. Feature matching loss is described by using the difference between the generator and the intermediate layers of the discriminator;

[0078] 4. Define the initialized Theano functions for training the discriminator and the generator network;

[0079] 5. Define three other Theano functions for computing the test error and generated samples and the predicted label for the generated samples;

[0080] 6. Model training:

[0081] For each epoch:

[0082] I. If epoch == 0:

[0083] Run the initialization Theano function for initializing the parameters of the generator and the discriminator.

[0084] II. For each batch of training set:

[0085] Run the discriminator and generator functions alternatively.

[0086] These functions update the discriminator and the generator network parameters by minimizing the loss function of the network.

[0087] III. For each batch of test set:

[0088] The test error is computed using the Theano function.

[0089] IV. Reporting Results

[0090] In exemplary embodiments, the above-described GAN architecture can be applied on top of the improved GAN described in the above-cited paper "Improved Techniques for Training GANs" by T. Salimans, I. Goodfellow, W. Zaremba, V. Cheung, A. Redford, and X. Chen, published in the Journal of Machine Learning Research, Volume 16, Issue 1, 2016, https: / / arxiv.org / pdf / 1606.03498.pdf.

[0091] In exemplary embodiments, the generator 102 comprises a 4-layer deep CNN with batch normalization, as represented in Figure 3 In exemplary embodiments, the discriminator 104 or 204 comprises a 9-layer deep CNN with weight normalization and dropout. Figure 4 An example of a discriminator 104 is shown in Figure 5 An example of a discriminator 204 is shown in Figures 3 to 5 The exemplary generator and discriminator architectures shown in Figures 3 to 5 Figs. 1 and 2 are non-limiting examples. In other embodiments, generators and discriminators with different numbers of layers and different layer configurations can be used.

[0092] In at least some applications, the GANs 100 and 200 can be used to implement semi-supervised regression learning in a generative adversarial network. As a continuous label, the regression scheme GANs 100, 200 outperform classification using semi-supervised GANs in terms of performance in solving regression problems by avoiding the discretization error that is unavoidable when applying semi-supervised classification techniques to regression problems, in at least some applications. Furthermore, the GANs 100, 200 as described above can require fewer parameters and training time, and can also provide both classification and regression semi-supervised learning. The discriminators 104, 204 can efficiently handle the regression task while handling labeled and unlabeled samples.

[0093] In exemplary embodiments, the above-described improved GAN techniques provide a semi-supervised learning technique based on a generative model to solve regression problems. In the GANs 100, 200, the discriminator network 104, 204 is configured to: receive an input sample (e.g., a generated sample x gen , a labeled training sample x lab , or an unlabeled training sample x unl ); and predict a continuous label y and generating a probability index D(x) indicating whether the input sample is a fake sample (e.g., a generated sample) or an actual sample (e.g., a labeled training sample x lab or an unlabeled training sample x unl ). The GAN 100, 200 is for semi-supervised learning of a regression problem for predicting a continuous label of an input sample. One example of a continuous label is a steering angle, in which respect the GAN 100, 200 can be applied, e.g., for predicting a steering angle for autonomous driving. In the GAN 100, the discriminator 104 CNN has two outputs: (i) one for regression (predicted continuous label ); (ii) one for discrimination (probability D(x), discriminating between the real samples (x lab , x unl ) and the fake samples ). In the GAN 200, the discriminator 204 CNN 206 has a single output for regression (predicted continuous label ), which is applied to a kernel function 208, which outputs a discrimination index D(x) indicating how real the predicted continuous label is. The kernel function 208 operates based on the assumption that the continuous label of a real dataset sample (e.g., a training dataset sample) can be normalized between 【0, 1】. If the predicted continuous label is within the range of 【0, 1】, they are determined to be real labels and assigned a discrimination index D(x) = 1. If the predicted continuous label is outside the range, the discrimination index value becomes zero exponentially according to how much the predicted continuous label is outside the range.

[0094] As shown in Figure 6 , an example embodiment provides a method of performing semi-supervised regression with a generative adversarial network, comprising: outputting, from a generator network, a generated sample derived from a random noise vector (block 302); inputting, to a discriminator network, the generated sample, a plurality of labeled training samples, and a plurality of unlabeled training samples (block 304); outputting, from the discriminator network, for at least the generated sample, a predicted continuous label of the generated sample and a predicted probability that the sample is an actual sample or a fake sample (block 306).

[0095] The above method can be used to generate actual labeled samples, which can then be used as training samples for machine learning tasks in an artificial intelligence (AI) system. It should be understood that training data is critical for machine learning tasks. For supervised learning algorithms, training data needs to be properly labeled for quality training. Insufficient labeled training samples for supervised learning results in poor learning. However, collecting sufficient training samples and labeling them is time-consuming, difficult and expensive. The data collection cost for training samples varies from application to application, and one application with high training sample cost is training autonomous driving (AD) systems.

[0096] In this regard, the exemplary embodiments of the methods and systems described above in connection with Figures 1 to 6 Exemplary embodiments of the methods and systems described above in connection with

[0097] In recent years, autonomous driving (AD) has attracted the attention of researchers and industry. In order to make the driving task autonomous and replace human drivers, the AD system should be able to recognize its surrounding environment and take action accordingly. Machine learning can facilitate this task of the AD system. Machine learning is used for different purposes in AD systems, such as simulating driver behavior, vehicle detection, lane detection, and end-to-end learning. An example of end-to-end learning is described in M. Boiarski, D. Del Testa, D. Dworakowski, B. Firner, B. Flepp, P. Goyal, L. D. Jackel, M. Monfort, U. Muller, and J. Zhang, “End to end learning for self-driving cars,” arXiv:1604.07316v1 [cs.CV] 07316, 25, April 2016.

[0098] In Boiarski, a convolutional neural network (CNN) is trained in a supervised manner to map raw pixels of a single front-facing camera directly to steering commands. The CNN is able to learn remarkable road features from a combination of front-facing camera images and very sparse training signals (human-controlled steering angles) without the need to decompose the front-facing camera images into the road, lane line detection, semantic abstraction, path planning, or control.

[0099] In Bojarski's example, the AD system's training data comes from manually controlled steering signals combined with image data from a camera mounted on the moving vehicle. Physically collecting training data is both expensive and inefficient. Training the AD system requires a large number of training samples to ensure it can learn all possible scenarios, such as different driving states, road conditions, and weather conditions. The AD system's failure to recognize certain situations could lead to safety issues.

[0100] Therefore, in the exemplary embodiment, the above-described GAN-based semi-supervised regression system and method are used to generate labeled samples x. out Strong set X out The labeled sample x out This can then be used to train an AD system, including in the context of end-to-end training. Specifically, each of the output samples x... out This includes images from actual simulated front-facing cameras and consecutively labeled images in the form of steering angles. Based on the input to GAN 100 or 200 and the initial training dataset X. data To generate the output sample x out The input includes a noise signal z, and the initial training dataset X. data Including labeled training samples x lab and unlabeled training samples x unl In this regard, Figure 7 An example of a semi-supervised regression system 400 implemented using a GAN is shown, which is used to perform regression based on input noise z and an initial training dataset X. data Use GAN 100 or 200 to generate labeled training samples x out .

[0101] In system 400, the initial training dataset X data Samples x including L labeled samples lab and M unlabeled samples x unl Where M > L. In some exemplary embodiments, the number M of unlabeled samples is at least 10 times greater than the number of labeled samples. Each labeled sample x lab This represents an image captured by a front-facing camera on a moving vehicle, along with associated markers representing the steering angle. In one example, the image samples are in JPG file format, and the associated markers are represented as a concatenation of the JPG filename and the text indicating the steering angle. Each unmarked sample x unl This represents an image captured by a front-facing camera on a moving vehicle. In some exemplary embodiments, the initial training dataset X... data The labeled sample x labA moving vehicle has been used for the collection, while recording the images and steering angle.

[0102] Figure 8 An example embodiment provides a semi-supervised regression method 500 implemented on a system 400 is shown. In an example embodiment, the method 500 shown in the figure is implemented on a processing system 600 (described below) using the Python programming language and the Python libraries Theano and Lasagne Figure 8 The Adam optimization algorithm is used to iteratively update the discriminator and generator networks. In alternative embodiments, other programming languages, libraries and optimization algorithms can be used.

[0103] The method 500 begins with an initialization phase 501 that includes a step (block 502) of defining and initializing the CNNs used to implement the discriminator 104 or 204 and the generator 102. Although many different neural network architectures are possible, in an example embodiment the architectures described above in connection with Figure 3 and Figure 4 or Figure 5 are defined for the generator 102 and discriminator 104, 204, respectively.

[0104] The loss functions Loss D and Loss G for the discriminator 104, 204 and generator 102, respectively, are defined as part of the initialization phase 501. In an example embodiment, the loss function Loss G for the generator 102 is defined as the feature matching loss Loss feature_matching :

[0105] Loss G = Loss feature_matching

[0106] In an example embodiment, the loss function Loss D for the discriminator 104, 204 is defined as described above, i.e., combining the unsupervised GAN loss function and supervised regression loss, as represented by the following equation:

[0107] Loss D = L unsupervised + L supervised (Equation 3)

[0108]

[0109] L unsupervised = E x～pdata(x) [(D(x) - 1) 2]+E z～pz(z) [D(G(z)) 2 ] (Equation 5)

[0110] Variations of the above loss functions can be defined and applied in different embodiments.

[0111] As further shown in block 504, the discriminator D(x) 104, 204 is initialized with the initial set of discriminator parameters ω0, and the generator G(z) 102 is initialized with the initial set of generator parameters θ0. As shown in block 506, the Adam optimizer parameters are then set. In a non-limiting example, the learning rate a is set to 0.0005, the decay rate β is set to 0.5, and the batch size is set to 100. However, in other example embodiments, many other different combinations of Adam optimizer parameters can be used.

[0112] The initialization phase 501 is followed by an iterative training phase 508, which is repeated until the network parameters converge. In example embodiments, the training phase 508 is performed on a set of data sample batches, where each data sample batch includes a plurality of data samples. In the illustrated embodiment, the number of batches processed by each training phase 508 is equal to "m". As represented by blocks 510-518, for each epoch over the m batches (where 1 < i < m), the following actions are repeated for each batch of data samples. First, as shown in block 510, a data sample z is generated by the generator network G(z) 102 from the training data set X data actual image and label data samples x, y are obtained, the training data set X data is a source of labeled samples x lab (including image samples and associated true labels y) and unlabeled samples x unl . As shown in block 512, the discriminator D loss function Loss D is computed based on the current batch of samples; as shown in block 514, the obtained Loss D is provided to the Adam optimizer to obtain updated discriminator parameters ω. Then, as shown in block 516, the generator G(x) loss function Loss G is computed based on the current batch of samples; as shown in block 518, the obtained Loss G is provided to the Adam optimizer to obtain updated generator parameters θ. The actions shown in blocks 510-518 are repeated for all of the m batches in the current epoch, with the discriminator and generator network loss functions and parameters being computed and updated in an alternating manner.

[0113] As shown in box 522, after all m batches have been processed, it is determined whether the validation error on the test dataset is still decreasing. As is known in the art, the test dataset is a pre-determined dataset used to determine when the discriminator training reaches a level where the validation error reaches its minimum. A continuously decreasing validation error indicates that the generator weight parameters θ have not yet converged. If the validation error continues to decrease, training phase 508 proceeds to another iteration, repeating the actions described above in conjunction with boxes 510 to 518 for another period on m batches. In some examples, the same training dataset samples X... unl and X lab The newly generated samples x can be incorporated during subsequent repetitions of the training phase. gen Reuse.

[0114] In some exemplary embodiments, when the validation error of the test dataset no longer decreases, the GANs 100 and 200 of system 400 are considered trained. As shown in box 526, system 400 then trains and prepares to output the actual labeled data sample x. out Each of these includes a data sample (e.g., a front-facing camera image) and consecutive markers, where the consecutive markers are consecutive numbers between 0 and 1 (e.g., the steering angle associated with the front-facing camera image). Specifically, once the GANs 100 and 200 are trained, the generator G 102 is used to generate the actual generated sample x. gen The discriminators D104 and 204 are used to distinguish between such samples and unlabeled x. unl The sample application accurately predicts the continuous label Given the generated sample input, the output sample X out The generated sample x will be included gen and its associated predictions of continuous labels Given unlabeled training sample input, the output sample X out This will include previously unlabeled samples x unl and its newly associated predictions of continuous labels

[0115] Therefore, once trained, the GAN 100 and 200 can be used to generate actual labeled data x based on the noisy input z. out It is also used to label previously unlabeled actual data samples. In the exemplary application, each output labeled data sample x out This includes images from the front-facing camera and steering angle markers, which can then be used for end-to-end learning in an AD system. In some examples, the data X of the markers is output from system 400. outAt this point, for training purposes, they can be provided directly to the AD system as ground truth; in some examples, they can be stored for future use, e.g., in a database.

[0116] In some examples, the predicted steering angle label In some examples where the normalized value is between 0 and 1, a transformation function can be applied to map the normalized value to an actual steering angle. In some examples, the steering angle label can be broken down to 6 or more decimal places.

[0117] In some example embodiments, once the system 400 is trained, it can also be used to label data samples x unl applying the label, thereby converting a previously unlabeled real image to a labeled data sample x lab In some examples, once the system 400 is trained, the discriminator 104, 204 can be incorporated into an AD system for receiving real-time images from a front-facing camera on a moving vehicle, actively providing steering angle control for the moving vehicle.

[0118] A pseudo-code algorithm similar to the initialization phase 501 and training phase 508 shown in method 500 is represented in the following table:

[0119] Table 1 Semi-supervised regression with GAN. Default values: a = 0.0005, b = 0.5

[0120]

[0121]

[0122] The GAN architecture described above is not critical and is used as an example only. Any modifications to the layers of the CNN (e.g., weights, activation functions, and normalization methods) can be made to generate a different neural network.

[0123] Figure 9 is a block diagram of an example simplified processing system 600 that can be used to implement embodiments disclosed herein, providing a higher level of implementation example. Figure 6 and Figure 8 The method of and can be implemented using the example processing system 600 or variations of the processing system 600. For example, the processing system 600 can be a server or a desktop terminal, or any suitable processing system. Other processing systems suitable for implementing the embodiments described in this disclosure can be used, and can include components other than those discussed below. Although Figure 9 Although a single instance of each component is shown, there can be multiple instances of each component in the processing system 600.

[0124] The processing system 600 can include one or more processing devices 602, such as a processor, a graphics processing unit, a microprocessor, an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a dedicated logic circuit, or a combination thereof. The processing system 600 can also include one or more input / output (I / O) interfaces 604 that can enable connection with one or more suitable input devices 614 and / or output devices 616. The processing system 600 can include one or more network interfaces 606 for wired or wireless communication with a network (e.g., an intranet, the Internet, a P2P network, a WAN, and / or a LAN) or other nodes. The network interface 606 can include wired links (e.g., an Ethernet cable) and / or wireless links (e.g., one or more antennas) for intra-network and / or internetwork communication.

[0125] The processing system 600 can also include one or more storage units 608, which can include mass storage units, such as solid state disks, hard disk drives, disk drives, and / or optical disk drives. The processing system 600 can include one or more memories 610, which can include volatile or non-volatile memories (e.g., flash memory, random access memory (RAM), and / or read-only memory (ROM)). The non-transitory memory 610 can store instructions for execution by the processing device 602, such as to perform examples described in the present disclosure, e.g., to perform encoding or decoding. The memory 610 can include other software instructions, such as to implement an operating system and other applications / functions. In some examples, one or more data sets and / or modules can be provided by external memory (e.g., an external drive in wired or wireless communication with the processing system 600) or can be provided by a transitory or non-transitory computer-readable medium. Examples of non-transitory computer-readable media include RAM, ROM, erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, CD-ROM, or other portable memory.

[0126] A bus 612 can exist for communication between each of the aforementioned circuitry devices 600, including the processing device 602, the I / O interface 604, the network interface 606, the storage unit 608, and / or the memory 610. The bus 612 can be any suitable bus architecture, such as including a memory bus, a peripheral bus, or a video bus.

[0127] In Figure 9 the input device 614 (e.g., a keyboard, a mouse, a microphone, a touch screen, and / or a keypad) and the output device 616 (e.g., a display, a speaker, and / or a printer) are shown as external devices of the processing system 600. In other examples, one or more of the input device 614 and / or the output device 616 can be included as components of the processing system 600. In still other examples, there can be no input device 614 and output device 616, in which case the I / O interface 604 can not be needed.

[0128] The memory 610 can include instructions for semi-supervised regression mode 618 that, when executed, cause the processing system 600 to perform a method such as the method of Figure 6 or Figure 8 In other examples, the memory 610 can store a training data set X data and generated data samples x out in a database 628.

[0129] Although the present application can describe methods and processes with steps that are arranged in a certain order, one or more steps of the methods and processes can be omitted or changed, as appropriate. One or more steps can be performed in an order other than the order described in the present application.

[0130] Although the present application can be described in terms of methods, one of ordinary skill in the art will appreciate that the application is also directed to various components for performing at least some of the aspects and features of the methods, whether by hardware components, software, or any combination thereof. Thus, the technical solutions of the present application can be embodied in the form of a software product. Suitable software products can be stored in a pre-recorded storage device or other similar non-volatile or non-transitory computer-readable medium, such as including a DVD, a CD-ROM, a USB flash disk, a removable hard disk, or other storage media. The software product includes instructions tangibly stored thereon, which enable a processing device (e.g., a personal computer, a server, or a network device) to perform examples of the methods disclosed herein.

[0131] The application can be embodied in other specific forms without departing from the subject matter of the claims. The described exemplary embodiments are to be considered in all respects only as illustrative and not restrictive. Selected features from one or more of the above-described embodiments can be incorporated into an alternative embodiment, and the subject matter of such an embodiment will still fall within the scope of the application, understood in light of the disclosure.

[0132] All values and subranges within the scope of the disclosure are also disclosed. Additionally, although specific embodiments have been disclosed, other embodiments will occur to those skilled in the art. The disclosure of a system, device, or process herein using only one or a certain number of elements / component features is therefore intended to be non-limiting and any number of such elements / component features can be employed. Appropriate changes in the number of elements / component features, and the values of elements / component features, can be made to these example embodiments and other embodiments of the application while still being encompassed by aspects of the application.

[0133] Certain adaptations and modifications of the described embodiments can be made. Therefore, the above-discussed embodiments are merely meant as illustrative and not restrictive.

Claims

1. A method for training generative adversarial networks, characterized in that, The generative adversarial network includes: a generator comprising a first neural network; and a discriminator comprising a second neural network; the method includes: The generated samples are derived from the random noise vector by outputting the first neural network; The generated samples, multiple labeled training samples, and multiple unlabeled training samples are input into the second neural network. The labeled training samples include a series of front-facing camera image samples of a moving vehicle, each labeled with a steering angle. The unlabeled training samples represent samples of images captured by the front-facing camera of the moving vehicle. The second neural network outputs predicted continuous labels for each of the plurality of generated samples and unlabeled samples. The second neural network outputs each continuous label as a normalized value. The second neural network is used to predict the turning angle. The probability that a generated sample is an actual sample is determined based on the continuous labels predicted for the generated sample. The probability is determined according to a kernel function based on whether the normalized value of the continuous label is within a predetermined range.

2. The method according to claim 1, characterized in that, include: The second neural network outputs the probability that the input sample is an actual sample.

3. The method according to claim 1 or 2, characterized in that, Before the parameters of the neural network converge, the following are included: Repeat the following operations: output the generated samples derived from the first neural network; input the generated samples, labeled training samples, and unlabeled training samples into the second neural network; output the predicted continuous labels from the second neural network; During each repetition, the corresponding loss functions of the second neural network and the first neural network are calculated; based on the calculated loss functions, the weight parameters of the second neural network and the first neural network are adjusted.

4. The method according to claim 3, characterized in that, The loss function of the first neural network includes a feature matching loss function, which is based on the difference between the outputs of the intermediate layers of the second neural network used for the training samples and the generated samples, respectively.

5. The method according to claim 3, characterized in that, The loss function of the second neural network is a combination of the supervised and unsupervised parts.

6. The method according to claim 5, characterized in that, The supervision component is based on the difference between the actual labels and the predicted continuous labels of the samples of the labels provided to the second neural network.

7. A system for training generative adversarial networks, characterized in that, The generative adversarial network includes: a generator comprising a first neural network; and a discriminator comprising a second neural network. The system comprises: Processing equipment; A memory, coupled to the processing device, stores computer-executable instructions that, when executed by the processing device, cause the system to perform the following operations: Define the first neural network and the second neural network; The generated samples are derived from the random noise vector by outputting the first neural network; The generated samples, multiple labeled training samples, and multiple unlabeled training samples are input into the second neural network. The labeled training samples include a series of front-facing camera image samples of a moving vehicle, each labeled with a steering angle. The unlabeled training samples represent samples of images captured by the front-facing camera of the moving vehicle. The second neural network outputs predicted continuous labels for each of the multiple generated samples and unlabeled samples, and outputs each continuous label as a normalized value. The second neural network is used to predict the steering angle. When the instruction is executed by the processing device, it causes the system to determine the probability that the generated sample is an actual sample based on the continuous labels predicted for the generated sample. When the instruction is executed by the processing device, the system defines a kernel function to determine the probability based on whether the normalized value of the continuous label is within a predetermined range.

8. The system according to claim 7, characterized in that, When the instruction is executed by the processing device, the system outputs from the second neural network the probability that the input sample is an actual sample.

9. The system according to claim 7 or 8, characterized in that, The instructions, when executed by the processing device, cause the system to converge the parameters of the neural network before: Repeat the following operations: output the generated samples derived from the first neural network; input the generated samples, labeled training samples, and unlabeled training samples into the second neural network; The continuous labels predicted from the output of the second neural network; During each repetition, the corresponding loss functions of the second neural network and the first neural network are calculated; based on the calculated loss functions, the weight parameters of the second neural network and the first neural network are adjusted.

10. The system according to claim 9, characterized in that, The loss function of the first neural network includes a feature matching loss function, which is based on the difference between the outputs of the intermediate layers of the second neural network used for the training samples and the generated samples, respectively.

11. The system according to claim 9, characterized in that, The loss function of the second neural network is a combination of the supervised and unsupervised parts.

12. The system according to claim 11, characterized in that, The supervision component is based on the difference between the actual labels and the predicted continuous labels of the samples of the labels provided to the second neural network.

13. A computer-readable medium, characterized in that, The system stores computer-executable instructions for causing a processing system to perform the method according to any one of claims 1 to 6.

Images