SYSTEM AND METHOD FOR PHOTOREALISTIC IMAGE SYNTHESIS USING UNSUPERVISED SEMANTIC FEATURE DISENTANGLEMENT

Abstract

Disclosed herein is a method to disentangle linear-encoded facial semantics from facial images without external supervision. The method uses linear regression and sparse representation learning concepts to make the disentangled latent representations easily interpreted and manipulated. Generated facial images are decomposed into multiple semantic features and latent representations are extracted to capture interpretable facial semantics. The semantic features may be manipulated to synthesize photorealistic facial images by sampling along vectors representing the semantic features, thereby changing the associate semantics.

Description

BACKGROUND

Generative Adversarial Networks (GANs) have realized great success in synthesizing photo-realistic images, given a set of latent codes. Despite the rapid boost in image quality, the interpretability of the generation process has become another major area of research. In general, interpretability requires latent codes to encode disentangled semantic information of the image. Further, ideally, well-disentangled semantics are supposed to be factorized to practically interpretable components and each component should be linear-encoded in the latent space as representation.

StyleGAN is a GAN for producing an unlimited number of (often convincing) portraits of fake human faces. The StyleGAN architecture provides an intermediate latent space to support the disentanglement property for face generation. Consequently, facial semantics are linear-encoded as latent representations.

Based on StyleGAN, sampling along a linear-encoded representation vector in latent space will change the associated facial semantic accordingly. This makes it possible to manipulate face generations to meet a target requirement. However, mapping particular facial semantics to a latent representation vector relies on training offline classifiers with manually labeled datasets. Thus, they require artificially defined semantics and provide the associated labels for all facial images. The disadvantages for training with labeled facial semantics include: (1) extra effort demanded on human annotations for each new attributes proposed; (2) each semantics is defined artificially, and the scope of semantics is limited to the linear combination of such definitions; and (3) by only training on each of the labeled semantics independently, insights on the connections among different semantics are unavailable.

SUMMARY

Disclosed herein is a system and method for manipulating linear-encoded facial semantics from facial images generated by StyleGAN without external supervision. The method derives from linear regression and sparse representation learning concepts to make the manipulated latent representations easily interpreted. The method starts by coupling StyleGAN with a stabilized 3D deformable facial reconstruction method to decompose single-view GAN generations into multiple semantics. Latent representations are then extracted to capture interpretable facial semantics.

The disclosed invention provides an unsupervised method to minimize the demand for human annotation. A novel unsupervised framework is specified to disentangle and manipulate facial semantics under the StyleGAN environment, while still maintaining the interpretability for semantics as in labeled datasets.

FIG. 1 shows facial manipulation results produced by sampling along latent representations in StyleGAN, learned by the unsupervised framework disclosed herein. Column 1 shows original generations. Columns 2-4 show manipulation on univariate environmental semantics. Columns 5-9 show manipulation on localized facial semantics.

The disclosed framework uses decorrelation regularization on StyleGAN to further enhance disentanglement for the latent representations. In addition, mutual reconstruction is introduced to stabilize training of an unsupervised 3D deformable face reconstruction method, such that it serves as an initial facial semantic extractor.

For univariate semantics (e.g., yaw angle, pose, lighting) a linear regression method to capture perturbations from latent space is disclosed. For pixel-level semantics (e.g., shape and texture), a localized representation learning algorithm is disclosed to capture sparse semantic perturbations from latent space.

All methods disclosed herein are based on a label-free training strategy. Only StyleGAN is trained with an in-the-wild face dataset. Therefore, a significant amount of human involvement in facial representation learning is not needed.

The goal of the facial representation disentanglement method disclosed herein is to capture linear-encoded facial semantics. With a given collection of coarsely aligned faces, a Generative Adversarial Network (GAN) is trained to mimic the overall distribution of the data. To better learn linear-encoded facial semantics, StyleGAN is re-implemented and trained. Further, the method improves the capability of the latent space trained by StyleGAN to disentangle by adding a decorrelation regularization. After training a StyleGAN model, the faces it generates are used as training data to train a 3D deformable face reconstruction method. A mutual reconstruction strategy stabilizes the training significantly. Then, a record is kept of the latent code from StyleGAN and linear regression is applied to disentangle the target semantics in the latent space.

Taking the reconstruction of the yaw angle as an example, the latent representation is manipulated as a data augmentation for training. Finally, a localized representation learning method to disentangle canonical semantics is disclosed.

BRIEF DESCRIPTION OF THE DRAWINGS

By way of example, a specific exemplary embodiment of the disclosed system and method will now be described, with reference to the accompanying drawings, in which:

FIG. 1 illustrates facial manipulation results by sampling along latent representations learned by the unsupervised framework disclosed herein.

FIG. 2 is an illustration showing the canonical albedo map of samples in CASIA WebFace after training.

FIG. 3 is a schematic diagram showing implementation of mutual reconstruction during training.

FIG. 4 is a schematic representation of the method for photorealistic image synthesis.

DETAILED DESCRIPTION

Decorrelating Latent Code in StyleGAN—In StyleGAN design, a latent code z∈^d×1 is randomly generated from random noise, for example a Gaussian distribution. Then, a mapping network takes z as input and outputs a latent code w∈^d×1. Space is proven to facilitate the learning of more disentangled representations. The disentangled representation can be further enhanced by decorrelating latent codes in . A more decorrelated latent space enforces more independent dimensions to encode information, and therefore encourages disentanglement in representations. To maximize the utilization of all dimensions in , all Pearson correlation coefficients p_ij should be zero and the variance of all dimensions Var[w_i] should be the same value, where i, j are the subscripts of dimensions in space.

Therefore, decorrelation regularization is introduced via a loss function:

$\begin{array}{cc}{ℒ}_{\mathrm{decorr}}=-\sum _{i\ne j}\left(\log \left(1-❘p_{ij}❘\right)\right)+\sum _i{\left(\mathrm{Var}\left[w_i\right]-\sum _j\left(\mathrm{Var}\left[w_j\right]\right)\right)}^2& \left(1\right)\end{array}$

• • where:
  • and p_ij and Var[w_i] are estimated by sampling w from the mapping network (z), given z˜(0,I).

The overall objective for the GAN with decorrelation regularization follows:

$\begin{array}{cc}\underset{ℱ,𝒢}{\min }\underset{𝒟}{\max }{ℒ}_{\mathrm{GAN}}+{ℒ}_{\mathrm{decorr}}& \left(2\right)\end{array}$

• • where:
  • and are the generator and discriminator for the GAN, respectively.

Here the mapping network is the only one to update with the new loss, _decorr.

Stabilized Training for 3D Face Reconstruction—An unsupervised 3D deformable face reconstruction method takes a roughly aligned face image and decomposes the faces into multiple semantics (e.g., view, lighting, albedo, and depth (y_v,y_l,y_a and y_d. respectively). During training, it uses these decomposed semantics to reconstruct the original input image I with the reconstruction loss:

_recon = |I−Î|   (3)

• • where:
  • Î=(y_v,y_l,y_a,y_d);
  • is a confidence network; and
  • is a 3D face renderer.

This method is used to pre-decompose some external facial semantics (e.g., pose and lighting), from StyleGAN generations.

However, the 3D face reconstruction algorithm struggles to estimate the pose of profile or near-profile faces. Even worse, if the dataset contains a decent number of profile and near-profile faces (e.g., CASIA WebFace), the 3D reconstruction fails to learn physically sounded semantics, as shown in FIG. 2(a), and collapses into a sub-optimal state. That is, the algorithm tries to use extreme values to estimate the texture and shape of each face independently, which deviates far away from the actual texture and shape of the face.

To address this problem, a mutual reconstruction strategy is disclosed and is and is illustrated in FIG. 3. In general, human faces are very similar in shape and texture. Therefore, each face image should still be able to reconstruct itself comparatively if its shape and texture are swapped with another face. Eventually, the strategy prevents the model from using extreme values to fit individual reconstruction, and the model learns to reconstruct faces with a minimum variance of the shape and texture among all samples, even for profile faces, as shown in FIG. 2(b). Following this idea, during training, the albedo and depth map between two images are swapped with a probability E to perform the reconstruction with the alternative loss:

_recon=(I,I′|I−Î′|   (4)

• • where:
  • Î′=(y_y,y_l,y_a′,y_d′);
  • is a mutual confidence network; and
  • all terms with a prime notation (′) originate from another image I′.

The overall loss to reconstruct each image then becomes:

(1−ϵ)_recon+ϵ_recon   (5)

As a result, the shape and texture of faces with deviated facial semantics can be robustly estimated. Moreover, because images are now reconstructed from two images, the confidence map in the original work should be yielded by these two images accordingly. The two images are simply concatenated channel-wise as input to the confidence network, where the top image provides environmental semantics and the bottom image provides texture and shape information.

Disentangle Semantics with Linear Regression—With the 3D face reconstruction algorithm, face images generated by StyleGAN are decomposed to pose, lighting, depth, and albedo. The ultimate goal of disentangling semantics is to find a vector v∈ in StyleGAN, such that it only takes control of the target semantics.

Semantic Gradient Estimation—Consider a semantics y of a generated face image (w) that can be measured by a function ƒ(⋅). The linear approximation of the gradient ∇y with respect to the latent code w satisfies:

ƒ((w₁))≈ƒ((w₀))+∇y(w₀(w₁−w₀)   (6)

Note that in general, the gradient at location w₀, ∇y(w₀), is a function of latent code w₀. However, with StyleGAN, it is observed that many semantics can be linear-encoded in the disentangled latent space . It can therefore be assumed that all of the semantics can be linear-encoded. In other words, the gradient is now independent of the input latent code w₀. This yields:

ƒ((w₁))≈ƒ((w₀))+(w₁−w₀)

simplified as:

Δy≈Δw   (7)

• • where:
  • ΔY=ƒ((w₁))−ƒ((w₀); and
  • Δw=w₁−w₀.

Semantic Linear Regression—It is now obvious that in the ideal case, the target vector v=∇y. While in a real world scenario, the gradient ∇y is hard to estimate directly because back-propagation only captures local gradient, making it less robust to noises. Therefore, a linear regression model to capture global linearity for gradient estimation is disclosed. N pairs of (w₁, w₀) are randomly sampled. Images are generated with StyleGAN and their semantics are estimated. Finally, all samples of differences are concatenated, denoted as ΔY∈^N×1 for semantics and ΔW∈^N×d for latent codes. The objective is to minimize:

$\begin{array}{cc}\underset{v}{\min }{\Delta Y-\Delta \mathrm{Wv}}_2^2& \left(8\right)\end{array}$

There exists a closed-form solution when N>d:

v=(ΔΔW)⁻¹ΔΔY   (9)

Image Manipulation for Data Augmentation—One useful application for guided image manipulation is to perform data augmentation. Data augmentation has proven to be efficient when dealing with unbalanced data during training. One related problem within an unsupervised framework is the inaccurate estimation of extreme yaw angle. This problem worsens when dealing with generations from CASIA StyleGAN because it contains a large number of facial images, only a small portion of which are profile faces (i.e., an unbalanced yaw distribution).

Disclosed herein is a data augmentation strategy based on self-supervised facial image manipulation. The end goal is to help the 3D face reconstruction network estimate the extreme yaw angle accurately. With the linear regression method previously discussed, manipulation vectors v for univariate semantics, including the yaw angle, denoted as v_yaw, can be learned. Recall that extrapolating along v beyond its standard deviation, yields samples with more extreme values for the associated semantics. Particularly, images with an extreme yaw angle can be generated to neutralize the unbalanced yaw distribution and train the 3D face reconstruction algorithm. Therefore, by seeing more profile faces deliberately, the system can better estimate extreme yaw angles.

The data augmentation strategy is performed alongside the training of 3D face reconstruction. To be specific, v is estimated and updated with a historical moving average (e.g., momentum=0.995) every 10 iterations. Then, augmentation is achieved by extrapolating a latent vector w_i^(s) via:

w _i ^(s) =w _i − vv+s·σ _w v   (10)

• • where:
  • w_i is a random sample drawn from (z);
  • s is the scaling factor for the interpolation/extrapolation along the unit length manipulation vector v; and
  • σ_w is the standard deviation for v.

In this case v=v_yaw. Finally, the 3D face reconstruction method is trained with the augmented generations (w_i^(s)).

Localized Representation Learning—In the case where ƒ(⋅) returns canonical outputs (i.e., depth and albedo maps), the outputs consist of pixels in spatial dimensions wherein the pixel values are highly correlated as the latent code changes. However, every pixel-level gradient estimation (i.e., v from Eq. (9) is independently calculated and is thus extremely redundant. To address this problem, the goal for canonical semantics is re-formulated to find the manipulation vectors I that capture interpretable combinations of pixel value variations. Define a Jacobian matrix J_v∈^S×d, which is the concatenation of all canonical pixel-level v. Here, S is the overall number of spatial and RGB dimensions of a given depth and albedo map.

One trivial definition of {circumflex over (v)} is that it maximizes ∥J_v^*{circumflex over (v)}∥₂². Ideally, a disentangled representation to manipulate interpretable facial semantics is expected. That is, interpolation along V should result in a significant but localized (i.e., sparse) change across the image domain (e.g., some {circumflex over (v)} only control eye variations while some only control mouth variations, etc.). However, ∥J_v^*{circumflex over (v)}∥₂² captures the global pixel value perturbation. Thus, the localized canonical representation learning is derived by solving:

$\begin{array}{cc}\underset{U,\hat{V}}{\min }{J_v^{*}-U{\hat{V}}^{\top }}_F^2+\alpha {U}_1+\beta \sum _{i\ne j}{\left({\hat{v}}_i^{\top }{\hat{v}}_j\right)}^2& \left(11\right)\end{array}$ $s.t.{{\hat{v}}_p}_2=1$

• • where:
  • p, i, j∈{1, . . . , P}; and
  • P is the number of components to learn.

Each column in U=[u₁, . . . , u_p]∈^S×P is a sparse component of the canonical albedo and depth perturbation and {circumflex over (V)}=[{circumflex over (v)}₁, . . . , {circumflex over (v)}_P]∈_d×P consists of the associated latent representation in space. α and β are tuning parameters to control the trade-off among the reconstruction accuracy of J_v^*, sparsity of perturbation in semantics and orthogonality of associated latent representations.

FIG. 4 shows one embodiment of a method 400 of the invention in which facial images may be manipulated by varying the facial semantics. In a first step, a random code 402, which, in some embodiments may be, for example, Gaussian noise, is input to generator 404 to generate a facial image 406. As described herein, the generator may be, for example, StyleGAN or StyleGAN-2, but other facial generators may also be used.

Once a facial image 406 has been generated by generator 404, semantic extractor 408 then extracts semantic features from the facial image. Semantic extractor 408 may be a network trained to extract specific semantic features from the facial image. For example, the semantic extractor 408 shown in the exemplary embodiment of FIG. 4 has been trained to extract semantic features representing pose, lighting, shape and texture.

Various semantic features 410 may be manipulated without changing the identity of the facial image. For example, semantic features representing pose and lighting can be manipulated and the identity of the facial image will not change. For identity-invariant features 412, for example, pose and lighting, the features may be extracted using a linear regression model.

Other semantic features 412 may be manipulated only to a certain extent before they become identity-variant. That is, if these features are changed too much, then the facial image 406 assumes a new identity. Such features 412 may be extracted via a localized semantics learning method. In the end, a vector of a certain length (which may be, in some embodiments, 512) for each independent semantic is acquired. By sampling along the acquired vectors, the associated semantic changes accordingly.

The overall design of the disclosed system can be sued for photo manipulation with a target demand. This is particularly useful in data augmentation for tasks that require a large number of training data but wherein only a limited number of training samples are available. The code-to-image generator to image-to-code-to-image generator can also be replaced, such that the generated images are identical to the input image. Additionally, the method may be used for image editing wherein the disentangled semantics are used to perform directed editing demands to modify the image.

An unsupervised learning framework for disentangling linear-encoded facial semantics from facial images generated by StyleGAN has been disclosed herein. The system can robustly decompose facial semantics from any single view GAN generation and disentangle facial semantics. Additionally, a method to perform guided data augmentation to counteract the problem brought by unbalanced data is disclosed.

As would be realized by one of skill in the art, the disclosed method described herein can be implemented by a system comprising a processor and memory, storing software that, when executed by the processor, performs the functions comprising the method.

As would further be realized by one of skill in the art, many variations on implementations discussed herein which fall within the scope of the invention are possible. Moreover, it is to be understood that the features of the various embodiments described herein were not mutually exclusive and can exist in various combinations and permutations, even if such combinations or permutations were not made express herein, without departing from the spirit and scope of the invention. Accordingly, the method and apparatus disclosed herein are not to be taken as limitations on the invention but as an illustration thereof. The scope of the invention is defined by the claims which follow.

Claims

1. A method comprising: obtaining a random facial image;inputting the facial image to a semantic extractor trained to extract one or more semantic features from the facial image; andmanipulating the one or more semantic features to modify the facial image.

2. The method of claim 1 wherein the random facial image is generated by a generative adversarial network based on a random input.

3. The method of claim 2 wherein the generative adversarial network is StyleGAN or StyleGAN-2.

4. The method of claim 1 wherein the one or more semantic features are represented by a feature vector and further wherein the semantic features are manipulated by sampling of the associated feature vector.

5. The method of claim 3 wherein the random input is a latent code generated from a Gaussian distribution.

6. The method of claim 5 further comprising: mapping the latent code to a disentangled latent space; andperforming decorrelation regularization on the disentangled latent space.

7. The method of claim 6 wherein the decorrelation regularization is implemented using a decorrelation loss function.

8. The method of claim 7 wherein the mapping is implemented with a mapping network and further wherein the decorrelation loss function is applied only to the mapping network.

9. The method of claim 4 further comprising: performing linear encoding of the semantic features in the disentangled latent space.

10. The method of claim 9 wherein the linear encoding is performed using an estimated semantic gradient.

11. The method of claim 10 wherein the semantic gradient is estimated using a semantic linear regression model.

12. The method of claim 11 wherein one or more of the semantic features are canonical, further comprising: using localized semantic learning to find manipulation vectors that capture interpretable combinations of pixel variations in the canonical semantic feature vectors.

13. The method of claim 3 further comprising: using the extracted features as training data for the generative adversarial network to reconstruct the facial image using a reconstruction loss.

14. The method of claim 13 further comprising using facial images generated by the trained generative adversarial network to train a deformable face reconstruction method.

15. A system comprising: a processor; andmemory, storing software that, when executed by the processor, performs the method of claim 12.

16. A system comprising: a processor; andmemory, storing software that, when executed by the processor, performs the method of claim 14.