Year: 2020

Abstract:
Image manipulation has attracted much research over the years due to the popularity and commercial importance of the task. In recent years, deep neural network methods have been proposed for many image manipulation tasks. A major issue with deep methods is the need to train on large amounts of data from the same distribution as the target image, whereas collecting datasets encompassing the entire distribution of images is impossible. In this paper, we demonstrate that simply training a conditional adversarial generator on the single target image is sufficient for performing complex image manipulations. We find that the key for enabling single image training is extensive augmentation of the input image and provide a novel augmentation method. Our network learns to map between a primitive representation of the image (e.g. edges and segmentation) to the image itself. At manipulation time, our generator allows for making general image changes by modifying the primitive input representation and mapping it through the network. We extensively evaluate our method and find that it provides remarkable performance.

text: Image manipulation has attracted much research over the years due to the popularity and commercial importance of the task. In recent years, deep neural network methods have been proposed for many image manipulation tasks. A major issue with deep methods is the need to train on large amounts of data from the same distribution as the target image, whereas collecting datasets encompassing the entire distribution of images is impossible. In this paper, we demonstrate that simply training a conditional adversarial generator on the single target image is sufficient for performing complex image manipulations. We find that the key for enabling single image training is extensive augmentation of the input image and provide a novel augmentation method. Our network learns to map between a primitive representation of the image (e.g. edges and segmentation) to the image itself. At manipulation time, our generator allows for making general image changes by modifying the primitive input representation and mapping it through the network. We extensively evaluate our method and find that it provides remarkable performance.

heading: 1 INTRODUCTION
text: Images capture a scene at a specific point in time. Viewers often wish the scene had been different e.g. that objects were arranged differently. Due to the popularity of this task, it has been the focus of much research and also of many companies and products e.g. Instagram and Photoshop. Deep learning methods have significantly boosted performance of image manipulation methods for which large training datasets can be obtained e.g. super-resolution or facial inpainting. User-captured photographs follow a long tailed distribution. Some classes of photographs are very common e.g. faces or cars. On the other hand a large proportion of photographs capture a rare object class or configuration. Training deep learning methods that capture the entire distribution images can be very hard, particularly for generative models that are slow and tricky to train. Training models on just the target image is emerging as an alternative to training deep models on large image datasets. Although this is counter-intuitive as deep learning methods typically require many training samples, single-image methods have recently demonstrated some promising results.
In this paper, we introduce a novel method for training deep conditional generative models from a single image. The objective differs from popular single-image methods e.g. Deep Image Prior and SinGAN that focus on unconditional image manipulation. The training image is first represented with a primitive representation, which can be unsupervised (an edge map, unsupervised segmentation), supervised (segmentation map, landmarks) or a combination of both. We use a standard adversarial conditional image mapping network to learn to map between the primitive representation and the image. In order to extend the training set (which simply consists of a single image), we perform extensive augmentations. The choice of augmentation method makes a significant difference to the method’s performance. We find the crop-and-flip augmentations typically used in conditional image generation are insufficient for providing a sufficiently rich training distribution. We propose to use a thin-plate-spline (TPS) augmentation method and show that it is key to the success of our method. After training, we are able to perform challenging image manipulation tasks by modifying the primitive representation. Our method is evaluated extensively and displays remarkable results.
Our contributions in this paper:
1. A general purpose approach for training conditional generators from a single image.
2. Proposing a TPS-based augmentation for conditional image generation, and demonstrating its importance for single image training.
3. A primitive representation allowing concurrent low and high-level image editing. 4. Extensive evaluations showing remarkable visual performance, and the introduction of a
new benchmark enabling quantitative evaluation of single image manipulation.

heading: 2 RELATED WORK
text: Classical image manipulation methods: Image manipulation has attracted research for decades from the image processing, computational photography and graphics communities. It would not be possible to survey the scope of this corpus of work in this paper. We refer the reader to the book by Szeliski (2010) for an extensive survey, and to the Photoshop software for a practical collection of image processing methods. A few notable image manipulation techniques include: Poisson Image Editing (Pérez et al., 2003), Seam Carving (Avidan & Shamir, 2007), PatchMatch (Barnes et al.) and ShiftMap (Pritch et al., 2007). Learning a high-resolution parametric function between a primitive image representation and a photo-realistic image was very challenging for pre-deep learning methods.
Deep conditional generative models: Image-to-image translation maps images from a source domain to a target domain, while preserving the semantic and geometric content of the input images. Most image-to-image translation methods use Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) that are used in two main scenarios: i) unsupervised image translation between domains (Zhu et al., 2017a; Kim et al., 2017; Liu et al., 2017; Choi et al., 2018) ii) serving as a perceptual image loss function (Isola et al., 2017; Wang et al., 2017; Zhu et al., 2017b). Existing methods for image-to-image translation require many labeled image pairs. Several methods e.g Dekel et al. (2017), are carefully designed for image manipulation, however they require large datasets which are mainly available for faces or interiors and cannot be applied to the long-tail of images.
Non-standard augmentations: Conditional generation models typically use crop and flip augmentations. Classification models also use chromatic and noise augmentation. Recently, methods have
been devised for learning augmentation for classification tasks e.g. AutoAugment (Cubuk et al., 2018). Mounsaveng et al. (2019) learned warping fields for augmenting classification networks. Thin-plate-spline transformation have been used in the medical domain e.g. Tang et al. (2019), but they are used for training on large datasets rather than a single sample. Zhao et al. (2019) learned augmentations for training segmentation networks from a single annotated 3D medical scan (using a technique similar to Kanazawa et al. (2016)) however they require a large unlabeled dataset of similar scans which is not available in our setting. TPS has also been used as a way of parametrizing warps for learning dense correspondences between images e.g. Han et al. (2018) and Lee et al. (2020).
Learning from a single image: Although most deep learning works use large datasets, seminal works showed that single image training is effective in some settings. Asano et al. (2019) showed that a single image can be used to learn deep features. Limited work has been done on training image generators from a single-image. Deep Image Prior (Ulyanov et al., 2018), retargeting (Shocher et al., 2018a) and super-resolution (Shocher et al., 2018b) from a single image. Recently, the seminal work of Shaham et al. (2019), presented a general approach for single image generative model training. However these methods are mainly focused on unconditional image manipulations (or very limited conditional manipulation). Our method is focused on conditional manipulations and is able to affect significantly more elaborate changes to images including to large objects in the scene.

heading: 3 DEEPSIM: LEARNING CONDITIONAL GENERATORS FROM A SINGLE IMAGE
text: We propose DeepSIM, a conditional generative adversarial network (cGAN) for learning to map from a primitive representation (e.g. edges, segmentation) to the image. The approach has several objectives: i) single image training ii) fidelity - the output should reflect the primitive representation iii) appearance - the output image should appear to come from the same distribution as the training image. We present a novel augmentation method that allows standard cGAN architectures to achieve these objectives. The particular type of augmentations used is critical as they provide a prior over the data. Having a good prior is important as the training set consists of merely a single image.

heading: 3.1 MODEL:
text: Our model design follows standard practice for cGAN models (particularly Pix2PixHD (Wang et al., 2017)). Let us denote our training image pair (x, y) where y ∈ Rdx×dy×3 is the input image (dx and dy are the number of rows and columns) and x ∈ Rdx×dy×dp is the corresponding image primitive (dp is the number of channels in the image primitive). We learn a generator network G : Rdx×dy×dp → Rdx×dy×3, which learns to map input image primitive x to the generated image G(x). The fidelity of the result is measured using the VGG perceptual loss `perc : (Rdx×dy×3,Rdx×dy×3) → R (Johnson et al., 2016) , which compares the differences between two images using a set of activations extracted from each image using a VGG network pre-trained on the ImageNet dataset (we follow the implementation in Wang et al. (2017)). We therefore write the reconstruction loss `rec:
`rec(x, y;G) = `perc(G(x), y) (1)
Conditional GAN loss: Following standard practice, we add an adversarial loss which measures the ability of a discriminator to differentiate between the (primitive, generated image) pair (x,G(x)) and the (primitive, true image) pair (x, y). The conditional discriminatorD : (Rdx×dy×dp ,Rdx×dy×3)→ [0, 1] is implemented using a deep classifier which maps a pair of primitive and corresponding image into the probability of the two being a groundtruth primitive-image pair. D is trained adversarially against the generator network G. The loss of the discriminator (`adv) is:
`adv(x, y;D,G) = log(D(x, y)) + log(1−D(x,G(x))) (2)
The combined loss `total is the sum of the reconstruction and adversarial losses, weighted by a constant α:
`total(x, y;D,G) = `rec(x, y;D) + α · `adv(x, y;D,G) (3)

heading: 3.2 AUGMENTATIONS:
text: When large datasets exist, finding the generator G and conditional discriminator D that optimize `total under the empirical data distribution can result in a strong generator G. However, as we only have a single image pair (x, y), this formulation severely overfits. This has the negative consequence of G not being able to generalize to new primitive inputs. In order to generalize to new primitive images, the size of the training dataset needs to be artificially increased so as to cover the range of expected primitives. Conditional generative models typically use simple crop and shift augmentations. We will later show (Sec. 4) that this simple augmentation strategy however will not generalize to primitive images with non-trivial changes. We first construct a non-smooth warp t by selecting a set of pixel locations (i, j) and perturbing them by a uniformly distributed shifts (di, dj) ∼ (U(−dxL , dx L ), U(− dy L , dy L )) s.t. t(i, j) = (i + di, j + dj) (we use L = 10). In order to have a simple transformation, we do not do this for every pixel but only for a set of 4 equispaced pixels along each axis of the image. We learn a warp f : (Rdx ,Rdy ) → (Rdx ,Rdy ) using a thinplate-spline (TPS) to smooth the random transformation t into a more realistic warp (i′, j′) = f(i, j). f is parameterized using a thin-plate spline (see Duchon (1977) for more details). The TPS loss LTPS consists of two terms, a loss that encourages f to be similar to t while the other encourages smoothness:
min ω LTPS = ∑ i,j ‖t(i, j)− f(i, j)‖2 + λ ∫ ∫ fxx + fyy + 2fxydxdy (4)
Where fxx, fxy, fyy denote the second order partial derivatives of f . λ is a regularization constant determining the smoothness of the warp. The optimization over the warp f can be performed very efficiently e.g. Donato & Belongie (2002). We denote the distribution of random TPS that can be generated using the above procedure as Ω.

heading: 3.3 OPTIMIZATION:
text: At training time, we sample random warps from the distribution Ω. We use each random warp f ∼ Ω to transform both the input primitive x and image y to create a new training pair (f(x), f(y)) (where we denote f(x)(i, j) = x(i′, j′) where (i′, j′) = f(i, j)). We optimize the generator and discriminator adversarially to minimize the expectation of the loss `total under the empirical distribution of random TPS warps:
D′, G′ = min G max D Ef∼Ω`total(f(x), f(y);D,G) (5)
We implemented the conditional GAN using the Pix2PixHD architecture. We kept the same hyperparameters as in the official repository except changing the number of iterations to 16000.

heading: 3.4 PRIMITIVE IMAGES:
text: In order to be able to edit the image, we condition our generator on a representation of the image that we call the image primitive. The required properties of the image primitives are being able to precisely specify the required output image and the ease of manipulation by image editor. These two objectives are in conflict, although the most precise representation of the edited image is the edited image itself, this level of manipulation is impossible to achieve by a human editor, in fact simplifying this representation is the very motivation for this work. Two standard image primitives used by previous conditional generators are the edge representation of the image and the semantic
instance/segmentation map of the image. Segmentation maps provide information on the high-level properties of the image, but give less guidance on the fine-details. Edge maps provide the opposite trade-off. To achieve the best of both worlds, we propose a novel primitive, which includes both the edge and segmentation maps combined together (we dub this representation - ”super primitive”). The advantages of this primitive representation will be shown in Sec. 5. Note that although Pix2PixHD proposes using a combination of segmentation maps and the edges of the instance maps, their representation is different from ours. The instance segmentation edges merely provide a method for overcoming the indexing issue present in instance maps, but do not provide the high-resolution of fine details in the edge maps as in our proposed approach. Our editing procedure is illustrated in App. B.

heading: 4 EXPERIMENTS

heading: 4.1 QUALITATIVE EVALUATION
text: We present many results of our method in the main paper and the appendix. In Fig. 1, our method is able to generate very high resolution images from single image training. In the top row we are able to perform fine changes to the facial images from edge primitives e.g. raising the nose and flipping the eyebrows. In the second row, we show complex shape transformations by using segmentation primitives. Our method was able to add a third wheel to the car and convert its shape into a sports car. This shows the power of the segmentation primitive, enabling major changes to the shape using simple operations. On the bottom row, we show that our method can perform free-form changes, completely changing the shape of an image while preserving fine texture.
In Fig. 4, we demonstrate the advantages of our single image model by comparing to two models that were trained on a large dataset. We present edges-to-image translation results on two different shoes. We can see that Pix2PixHD-MI (Pix2PixHD that was trained on the entire edge2shoes dataset, where ”MI” is an acronym for ”Multi Image”) is unable to capture the correct identity of the shoes as there are multiple possibilities for the appearance of the shoe given the edge image. BicycleGAN is able to take as input both the edge map and guidance for the appearance (style) of the required shoe. Although it is able to capture the general colors of the required shoe, it is unable to capture the fine details of the shoes (e.g. shoe laces and buckles). We believe that the loss of information is a general disadvantage of training on large datasets, a general mapping function becomes less specialized and therefore less accurate on individual images.
In Fig. 5, we present results on a paint-to-image task. Our method was trained to map from a rough paint image to an image of a tree, while SinGAN was trained using the authors’ best practice. We can see that SinGAN outputs an image which is more similar to the paint than a photorealistic image. Our method is able to change the shape of the tree to correspond to the paint while keeping the appearance of the tree and background as in the training image.

heading: 4.2 QUANTITATIVE EVALUATION
text: As previous single image generators have mostly operated on unconditional generation, there are no established datasets and metrics to conduct such an evaluation. We propose a new video-based benchmark for conditional single image evaluation over datasets spanning different scenes and primitives. A single frame from each video is designated for training, where the network is trained to map the primitive image to the designated training frame. The trained network is then used to map from primitive to image for all the other frames in the video and compute the prediction error using LPIPS (Zhang et al., 2018) and fidelity using SIFID (Shaham et al., 2019). We use all 16 video segments from the Cityscapes dataset (Cordts et al., 2016) provided by the code in vid2vid (Wang
et al., 2018) and Few-shot-vid2vid (Wang et al., 2019). These sequences are labelled aachen-000000 to aachen-000015 leftImg8bit. For each sequence, we train on frame 000000 and test using frames 000001 to 000029. We use the segmentation maps provided as image primitives. We also use the first 5 videos in the public release of the Oxford-BBC Lip Reading Sentences 2 (LRS2) dataset containing videos of different speakers. We extract their edges using a Canny edge detectorCanny (1986). In total, our evaluation set contains 464 Cityscapes frames and 239 LRS2 frames.
A visual evaluation on a few frames from the Cityscapes dataset can be seen in Fig. 6. We compare our method to the results of Pix2PixHD-SIA, where ”SIA” stands for ”Single Image Augmented” e.g. a Pix2PixHD model that was trained on a single image using random crop-and-flip warps but not TPS. We can observe that our method is able to synthesize very different scene setups from those seen in training, including different numbers and positions of people. Our method outperforms significantly in terms of fidelity and quality than Pix2PixHD-SIA indicating that our proposed TPS augmentation is critical for single image conditional generation.
Quantitative evaluations on Cityscapes and LRS2 are provided in Tab. 2 and Tab. 3. We report LPIPS and SIFID for each of the 5 LRS2 sequences and also for the average of 16 Cityscapes videos. We can observe that our method significantly outperforms Pix2PixHD-SIA in all comparisons.

heading: 5 ANALYSIS
text: Why use super-primitive(SP)? The choice of different input primitives conveys different information. Segmentations capture high-level aspects of the image while edge maps capture the low-level of the image better. Pix2PixHD proposed combining instance and semantic segmentation maps, however, this does not provide low-level details. We propose a new primitive, ”super primitive” (SP), that combines their strengths. Fig. 2 compares the three primitives. The edge representation is unable to capture the eye, presumably as it cannot capture its semantic meaning. The segmentation is unable to capture the details in the new background regions creating a smearing effect. SP is able to capture the eye as well as the low-level textures of the background region, showing its strong representational power. In Fig. 3 we present more manipulation results using SP. In the center column, we present
image reorganization results, where the positions of the rightmost cars were switched. As the objects were not of the same size, some empty image regions were filled using small changes to the edges. A more extreme result can be seen in the rightmost column, the car on the left was removed. This created a large empty image region. By filling in the missing details using edges, our method was able to successfully complete the background. An ablation is presented in App. E, showing the superiority of the SP representation. More comparisons are presented in App. D.
Is the cGAN loss necessary? We evaluated removing the cGAN loss used by our method (and Pix2PixHD), and using a VGG perceptual loss (the difference between the activations of a VGG network of output and groundtruth). The results on Cars are presented in App. F, we conclude that for such high-res images the cGAN is a better perceptual loss. We experimented with the VGG loss at lower resolutions, the results are reasonable, however the images are not as sharp as the cGAN loss.
Can methods trained on large-scale datasets generalize to infrequently occurring images? We present examples where this is not the case. Fig. 4 showed that BicycleGAN did not generalize as well as Pix2PixHD-MI for new (in-distribution) shoes. We show that in the more extreme case, where the image lies further from the source distribution used for training, current methods fails completely. We manually labelled the semantic and instance segmentation maps of the Cars image, and input it into a Pix2PixHD pre-trained by the authors on the Cityscapes dataset which contains street scenes of cars, roads and building. The results are presented in Tab. 4. We can see that a state-of-the-art method pre-trained on a large dataset does not generalize well to out-of-distribution inputs whereas our method, which is trained on a single image can perform well in such cases.
Augmentation for single image manipulation: Although we are the first to propose single-image training for manipulation using extensive non-linear augmentations, SinGAN can be seen as implicitly being an augmentation-based approach (for unconditional generation). In the first pyramid level it creates a low-resolution high-level random image generator, by mapping noise to low-res images. The later stages can be seen as a conditional generator which learns to map low-to high resolution images. Critically, it relies on a set of “augmented” input low-res images generated by the first stage GAN. So although this is not explicit in SinGAN, we think it also uses augmentations. On the other hand, Deep Image Prior indeed does not use any form of augmentation.
Runtime: As with other methods that train deep neural networks based on a single image, per-image training times are higher than when trained on large datasets. Our runtime is a function of the neural architecture we use and the number of iterations. Here specifically, we use the Pix2Pix-HD framework which has roughly comparable runtime to SinGAN for the same image size. The precise runtime depends on image size and the number of iterations used. When running all experiments on the same hardware (NVIDIA RTX-2080 Ti), smaller images e.g. the “Balloons” image showcased by SinGAN (size: 248X186) take SinGAN 50 minutes while DeepSIM (ours) takes 63 minutes. Runtime scales with the size of the image, so that large images such as the Cars image (640X320) take SinGAN 195 minutes while ours takes 185 minutes. Although this is not particularly fast, it is a general characteristic of many deep single image manipulation methods and not a particular issue of DeepSIM. We are optimistic that runtime optimizations in future work can significantly cut the runtime in all such methods, but this is not our focus.
Failure modes: Learning from a single image is very challenging and although our method makes encouraging progress, it has failure cases. We highlight three main failure modes (Fig. 8): i) generating unseen objects - the network is trained on just a single pair and is not aware of any other objects. When the manipulation requires generation of unseen objects, the network can do so incorrectly. ii) background duplication - when adding an object onto new background regions, the network can erroneously copy some background regions that originally surrounded the object, which may appear out-of-context. iii) interpolation in empty regions - as no guidance is given in empty image regions, the network hallucinates details, sometimes incorrectly. See App. C for further analysis.

heading: 6 CONCLUSION
text: We proposed a novel method for training conditional generators from a single training image based on thin-plate-spline augmentations. We demonstrated that our method is able to perform complex image manipulation at high-resolution. Single image methods have significant potential, they preserve image fine-details to a level not typically achieved by previous methods trained on large datasets. One limitation of single-image methods (including ours) is the requirement for training a separate network for every image, which can be expensive over a large dataset. Speeding up training of single-image generators is an important and promising direction for future work.

heading: A ADDITIONAL RESULTS
text: We present additional results of our method, DeepSIM, using the SP on a range of manipulations on different images.
Training SP Training Image Input SP Output Image
Changing the Posture of the Squirrel
Training SP Training Image Input SP Output Image
Changing the Shape of the Tail
Removing the Fork
Joining the Hamburger Halves
Training SP Training Image Input SP Output Image
Making the Beak Longer
Changing the Position of the Wings
Removing the Handcuffs
Removing the Right Hand
Training SP Training Image Input SP Output Image
Changing the Hat and Making the Face Longer
Making the Body Wider
Moving the Tree
Changing the Shape of the Tree
Training SP Training Image Input SP Output Image
Changing the Shape of the Lake
Adding More Lakes
Removing the Teeth of the Top Lama
Changing the Shape of the Ears of the Top Lama
Training SP Training Image Input SP Output Image
Adding Stems
Changing the Shape of the Horns
Adding the Left Paw

heading: B A STEP-BY-STEP DEMONSTRATION OF EDITING THE PRIMITIVE
text: Performing complex manipulations by our method is quite easy. In this figure we present a step-bystep example of editing a primitive representation using ”Paint”. It simply requires sampling the required color and painting over the primitive image. One may also ”borrow” edges from other areas of the image to fill in empty spaces.

heading: C EMPTY SPACE INTERPOLATION
text: In this section we stress test our method’s ability to handle regions with little guidance. In this example, the nose of the cat was shifted progressively downwards, forcing the network to interpolate the missing space. We observe the network synthesizes attractive images for moderate empty regions, however, as the empty region gets larger, the network looks for similar regions to fill the newly created void. These regions will often be areas which exhibit low amounts of detail in the primitive representation. In our case we can notice that for larger shifts, the empty space becomes greener until eventually it inpaints a background patch. We conclude that at a certain point, the network fails to learn the spatial relationship among objects in the image (i.e. that the background can not be placed on the cat’s face) and satisfies the given constraint using neighboring information (as was analysed above).
D VIDEO FRAMES
We present a qualitative comparison between different primitives on two frames from the LRS2 datasets. Although all primitives generate surprisingly good results, given the training on just a single image, super-primitive generates cleaner outputs with fewer artifacts.
Training Primitive Training Image Input Primitive Output Image Ground Truth
Training Primitive Training Image Input Primitive Output Image Ground Truth

heading: E ABLATION OF SP FOR THE CARS IMAGE
text: We present an ablation of the superprimitive (SP) representation for the Cars image. In Fig. 10, we present results for a manipulation on the Cars image using edge-only, segmentation-only and SP. We can see that SP generates attractive artifact free results.

heading: F AN ABLATION OF THE LOSS OBJECTIVE
text: We compare the results of our method, DeepSIM, using the original cGAN loss as in the base Pix2PixHD architecture vs. non-adversarial losses - the simple L1 loss and the percetual loss based on the difference of VGG activations. We can see that on this image both non-adversarial losses fail. Note that at lower resolutions non-adversarial losses do indeed succeed but do not generate results of comparable sharpness of the cGAN loss. Additionally, we performed the experiment with the cGAN but without the VGG perceptual loss, the results are presented below. It can be seen that without the VGG loss, the results are reduced in quality and contain grainy artifacts.
Training Perceptual Loss L1 Loss Ours w/o VGG Ours w/ VGG

heading: G TPS GENERALIZATION IMPROVEMENT
text: Let us consider the train and test edge-image pairs presented in Fig. 11. We input each edge map through an ImageNet-trained ResNet50 network and computed the activations at the end of the third residual block. For each pixel in the activation grid of the test image, we computed the nearestneighbor (1NN) distance to the most similar activation of the train image. We then performed 50 TPS augmentations to the training image, and repeated the 1NN computation with the training set now containing the activations of the original training image and its 50 augmentation. Let us compare the 1NN distances presented in Fig. 11 with and without TPS augmentations. Naturally, the 1NN distance decreased for the TPS-augmented training set due to its larger size. More interestingly, we can see that several face regions which prior to the augmentations did not have similar patches in the input, now have much lower distance (while more significant changes might not be possible to describe by TPS). In Fig. 11, we present the results of our method when trained on the training edge-image pair (shown in the leftmost column) and evaluated on the test edge. We can see that the prediction error (L1 difference between ResNet50 activations of the predicted and the true test image) appears to be strongly related to the 1NN distance with TPS-augmentations. This gives some evidence to the hypothesis that the network recalls input-output pairs seen in training. It also gives an explanation for the effectiveness of TPS training, namely increasing the range of input-output pairs thus generalizing to novel images.

heading: H TPS EXAMPLES
text: We present several examples of original and TPS augmented images and primitives. We can see that TPS introduces complex deformations to the samples, allowing much more expressive edits than when using simple ”flip and crop” augmentations.
Original TPS 1 TPS 2 TPS 3
Original TPS 1 TPS 2 TPS 3

Review summaries:
This paper proposed a single image-based manipulation method (DeepSIM) using conditional a generative model. The authors addressed this problem by proposing to learn the mapping between a set of primitive representation, which consists of edges and segmentation masks, and an image. They also adopted a thin-plate-splines (TPS) transformation as augmentation which enables the model to robustly manipulate an image by editing primitives.

This work proposes a method to design conditional generative models based on a single image. In particular, while some recent models have enabled one to sample (unconditionally) images from a generative model learned from a single image (like SinGAN), this work explores a way of conditioning the generation on a primitive, which can be user-specified. As a result, one can produce realistic modifications to a given image by modifying - or sketching - some primitive.

This paper provides an augmentation method to enable single image training. The network learns to map between a primitive representation of the image (e.g. edges and segmentation) to the image itself. During manipulation, the generator allows for making general image changes by modifying the primitive input representation and mapping it through the network.