CycleGAN

CycleGAN is a model for unpaired image-to-image translation: given one collection of images from a domain $X$, such as photographs of horses, and an unrelated collection from a domain $Y$, such as photographs of zebras, it learns to translate an image from either domain into the other without ever seeing a matching pair. Jun-Yan Zhu, Taesung Park, Phillip Isola and Alexei A. Efros presented it at ICCV 2017 under the title “Unpaired Image-to-Image Translation Using Cycle-Consistent Adversarial Networks”. It trains two GAN generators, $G: X \to Y$ and $F: Y \to X$, each judged by a discriminator in its target domain, and ties them together with a cycle-consistency loss: translating an image to the other domain and back should return the original. The generators are convolutional networks with residual blocks, and the discriminators are the patch discriminators of pix2pix, the paired model by an overlapping group of authors on which CycleGAN builds.

The image-to-image translation article surveys the task, its datasets and the methods that followed; this article covers the model in detail. Unless a version is named, details come from the ICCV version of the paper. That version gives no value for the loss weight and refers to its arXiv version for the datasets, architectures, training procedures and several results; the arXiv version was not read for this article, and these details are taken from the official code, which the article names each time.

Problem Addressed

A paired translator such as pix2pix learns from examples $\{x_i, y_i\}$ in which each output is the target for its input. Zhu et al. (§1) point out that such pairs are hard to obtain: few datasets exist for semantic segmentation and they are small, artistic stylization would need an artist to author every output, and for object transfiguration, turning a zebra into a horse, the desired output is not even well defined. Unpaired data, by contrast, is often plentiful (§6): a set of Monet paintings and a set of landscape photographs, with no painting of any photographed scene.

With only two sets, the supervision is at the level of sets. An adversarial loss can train $G$ so that the distribution of $G(x)$ is indistinguishable from that of $Y$, but this does not pair individual inputs and outputs in a meaningful way: infinitely many mappings induce the same output distribution, and a network of enough capacity can map the inputs to any permutation of the target images (§1, §3.2). The authors also found the adversarial objective hard to optimize alone; standard procedures often led to mode collapse, in which all inputs map to the same output (§1).

Their remedy borrows the idea of back-translation from language: a sentence translated from English to French and back should return the original sentence. If $G$ and $F$ are translators in opposite directions, they should be inverses of each other, and both mappings should be bijections (§1). Earlier unpaired methods had linked the domains differently. CoGAN and cross-modal scene networks share weights between two networks to learn a common representation, and several concurrent methods keep input and output close in a predefined space, such as class labels, pixels (Shrivastava et al.) or deep features (Taigman et al.). Zhu et al. present CycleGAN as needing neither a task-specific similarity function nor a shared low-dimensional embedding (§2). The idea of using transitivity as a training signal had precedents in tracking, structure from motion, shape matching and dense correspondence, where Zhou et al. and Godard et al. had used cycle-consistency losses to supervise CNNs (§2).

Architecture

CycleGAN has four networks: the generators $G: X \to Y$ and $F: Y \to X$, and the discriminators $D_Y$, which tells real images of $Y$ from translations $G(x)$, and $D_X$, which tells real images of $X$ from translations $F(y)$ (§3, Fig. 3). Unlike pix2pix, whose discriminator sees the input together with the output, each discriminator sees a single image; there is no paired input to condition on.

Generators

The generators adapt the architecture of Johnson et al.’s networks for style transfer and super-resolution: two stride-2 convolutions, several residual blocks and two fractionally strided convolutions, with instance normalization (§4). In the official PyTorch code (ResnetGenerator in networks.py), a $7 \times 7$ convolution with 64 channels is followed by two $3 \times 3$ stride-2 convolutions to 128 and 256 channels, a stack of residual blocks at a quarter of the input resolution, two $3 \times 3$ transposed convolutions back up, and a final $7 \times 7$ convolution with a tanh output. Each residual block holds two $3 \times 3$ convolutions; the $7 \times 7$ convolutions and those in the blocks use reflection padding, and every layer but the last is followed by instance normalization without learned scale and shift, and by ReLU (except the second convolution of each block). The default is nine residual blocks (resnet_9blocks) for $256 \times 256$ training crops; the original Torch code defaults to six blocks and $128 \times 128$ crops. Because the generator downsamples twice, image sides must be multiples of 4, and the code resizes images slightly to make them so (docs/tips.md).

Instance normalization normalizes each channel of each image by its own spatial mean and variance, at test time as well as in training, a choice the normalization layers article traces to feed-forward style transfer. The code applies it in the discriminators too.

Discriminators

The discriminators are $70 \times 70$ PatchGANs, which classify overlapping $70 \times 70$ patches as real or fake. Such a patch discriminator has fewer parameters than a whole-image one and runs fully convolutionally on images of any size (§4). The pix2pix article describes the PatchGAN, its receptive field and the effect of the patch size in detail; CycleGAN’s code uses the same NLayerDiscriminator with three stride-2 layers, here applied to a single three-channel image rather than to an input–output pair.

Training

Adversarial losses

For $G$ and $D_Y$ the adversarial objective is the original GAN loss,

$$\mathcal{L}_{GAN}(G, D_Y, X, Y) = \mathbb{E}_{y \sim p_{data}(y)}[\log D_Y(y)] + \mathbb{E}_{x \sim p_{data}(x)}[\log(1 - D_Y(G(x)))] \qquad \text{(Eq. 1)},$$

which $G$ minimizes and $D_Y$ maximizes; $\mathcal{L}_{GAN}(F, D_X, Y, X)$ is defined the same way for the reverse direction (§3.1). In the experiments the negative log-likelihood is replaced by the least-squares loss of Mao et al. (LSGAN), which the authors found more stable in training and better in quality (§4):

$$\mathcal{L}_{LSGAN}(G, D_Y, X, Y) = \mathbb{E}_{y \sim p_{data}(y)}[(D_Y(y) - 1)^2] + \mathbb{E}_{x \sim p_{data}(x)}[D_Y(G(x))^2] \qquad \text{(Eq. 5)}.$$

The ICCV text does not say which player minimizes Eq. 5. In the official code $D_Y$ minimizes it, halved, and the generator minimizes $\mathbb{E}_x[(D_Y(G(x)) - 1)^2]$, pushing the score of its outputs toward the label for real images: GANLoss with gan_mode = lsgan is a mean squared error to the label 1 for real and 0 for fake, applied to every patch score. Mao et al. motivate the least-squares loss by the vanishing gradients of the sigmoid cross-entropy loss. They show that minimizing their objective minimizes a Pearson $\chi^2$ divergence when the labels for fake, real and the generator’s target, $a$, $b$ and $c$, satisfy $b - c = 1$ and $b - a = 2$; the 0–1 labels of CycleGAN’s code ($a = 0$, $b = c = 1$) are the other choice they give, which sets $c = b$ so that the generator makes its samples as real as possible (§3.2).

Cycle consistency

The adversarial losses alone leave the pairing free. CycleGAN adds a forward cycle $x \to G(x) \to F(G(x)) \approx x$ and a backward cycle $y \to F(y) \to G(F(y)) \approx y$, enforced with an $L^1$ penalty (§3.2):

$$\mathcal{L}_{cyc}(G, F) = \mathbb{E}_{x \sim p_{data}(x)}\big[\lVert F(G(x)) - x \rVert_1\big] + \mathbb{E}_{y \sim p_{data}(y)}\big[\lVert G(F(y)) - y \rVert_1\big] \qquad \text{(Eq. 2)}.$$

The authors also tried an adversarial loss between $F(G(x))$ and $x$ in place of the $L^1$ norm, without improvement (§3.2). The full objective is

$$\mathcal{L}(G, F, D_X, D_Y) = \mathcal{L}_{GAN}(G, D_Y, X, Y) + \mathcal{L}_{GAN}(F, D_X, Y, X) + \lambda\, \mathcal{L}_{cyc}(G, F) \qquad \text{(Eq. 3)},$$

solved as $G^*, F^* = \arg\min_{G,F} \max_{D_X, D_Y} \mathcal{L}$ (Eq. 4). The ICCV text does not give $\lambda$; both official codes default to $\lambda = 10$ for each direction (lambda_A and lambda_B).

Zhu et al. note that the model can be read as two autoencoders, $F \circ G: X \to X$ and $G \circ F: Y \to Y$, whose intermediate representation is a translation of the image into the other domain. Because an adversarial loss pushes that representation toward the distribution of the other domain, the setup is a special case of the adversarial autoencoder of Makhzani et al., which trains an autoencoder’s bottleneck to match a target distribution (§3.3).

Identity loss

For painting→photo, the authors added a loss that keeps a generator close to the identity when it is given a real image of its own target domain, a technique they adopt from Taigman et al. (§5.2):

$$\mathcal{L}_{identity}(G, F) = \mathbb{E}_{y \sim p_{data}(y)}\big[\lVert G(y) - y \rVert_1\big] + \mathbb{E}_{x \sim p_{data}(x)}\big[\lVert F(x) - x \rVert_1\big].$$

Without it, $G$ and $F$ were free to change the tint of an image when there was no need to: between Monet’s paintings and Flickr photographs, paintings of daytime were often mapped to photographs taken at sunset, since both mappings are equally valid under the adversarial and cycle losses (§5.2). The loss needs input and output to have the same number of channels. In both official codes it is on by default, with weight lambda_identity = 0.5 multiplying $\lambda$, so the identity term carries weight 5 when $\lambda = 10$. The PyTorch repository’s FAQ (docs/qa.md, as of November 2026) describes it as used for the “photo to painting” application, where the paper names painting→photo, and suggests weights of 1.0 or 0.1 when a generator inverts the colours of its input early in training and never undoes it; a smaller initialization variance is its other remedy.

Procedure

Two further techniques stabilize training (§4). Besides the least-squares loss, the discriminators are updated with a history of generated images rather than only the latest ones, following Shrivastava et al., to reduce model oscillation: an image buffer stores 50 previously generated images. In the code (util/image_pool.py), once the buffer is full each newly generated image is, with probability one half, swapped for a randomly chosen stored image, which the discriminator then sees in its place.

The remaining details are in the official code (cycle_gan_model.py and the option files, as of November 2026):

• Update order. Each iteration computes $G(x)$, $F(G(x))$, $F(y)$ and $G(F(y))$, takes one Adam step on both generators together for the sum of both adversarial losses, both cycle losses and the identity losses, and then one step on both discriminators, each fed real images and images drawn from its buffer.
• Optimizer and schedule. Adam with learning rate 0.0002 and $\beta_1 = 0.5$; 100 epochs at that rate and 100 more decaying linearly to zero; weights initialized from a normal distribution with mean 0 and standard deviation 0.02.
• Data. Batch size 1 (the repository’s tips state that all experiments in the paper used 1); images resized to $286 \times 286$, randomly cropped to $256 \times 256$ and flipped horizontally at random; each batch of $X$ is paired with a randomly drawn image of $Y$ (unaligned_dataset.py). No dropout in the generators.
• Memory. Four networks must fit in memory together, so the tips recommend training on crops for high-resolution images and testing on full images, where only the generators are needed.

Inference

Translation is a single forward pass of one generator, $G$ for $X \to Y$ or $F$ for $Y \to X$. Neither generator takes a noise input, so the mapping is deterministic: the repository’s FAQ says the authors tried adding noise in several ways in both pix2pix and CycleGAN but often found that outputs did not vary much with it. Since the generators are fully convolutional, they can run at test time on images larger than the training crops.

Performance

Comparison with other unpaired methods

Zhu et al. evaluated on paired datasets, training without the pairs and using the pairs only for evaluation, with the datasets and measures of pix2pix (§5.1). The baselines were CoGAN, which learns a GAN per domain with shared early layers; BiGAN/ALI, whose objective of jointly learning a generator and its inverse they applied to images instead of latent codes; “pixel loss + GAN”, an adversarial loss plus an $L^1$ penalty between input and output following Shrivastava et al.; “feature loss + GAN”, the same penalty on VGG-16 relu4_2 features; and pix2pix trained on the pairs, as an upper bound. All but CoGAN used CycleGAN’s architecture and details (§5.1.1).

Workers on Amazon Mechanical Turk judged realism in a real-versus-fake test on maps and aerial photos of Google Maps (Table 1):

Method	Map→photo: rated real	Photo→map: rated real
CoGAN	0.6% ± 0.5%	0.9% ± 0.5%
BiGAN/ALI	2.1% ± 1.0%	1.9% ± 0.9%
Pixel loss + GAN	0.7% ± 0.5%	2.6% ± 1.1%
Feature loss + GAN	1.2% ± 0.6%	0.3% ± 0.2%
CycleGAN	26.8% ± 2.8%	23.2% ± 3.4%

CycleGAN fooled workers on about a quarter of trials in both directions; the baselines almost never did. The ICCV version refers to the arXiv version for the procedure, and the image-to-image translation article notes that Zhu et al. warn their numbers are not comparable with pix2pix’s.

On Cityscapes, label maps were translated into photos and scored with the FCN-score, by segmenting the generated photos with a pretrained FCN and comparing with the input labels (Table 2), and photos were translated into label maps and scored against the ground truth (Table 3):

Method	Labels→photo: per-pixel acc.	Per-class acc.	Class IoU	Photo→labels: per-pixel acc.	Per-class acc.	Class IoU
CoGAN	0.40	0.10	0.06	0.45	0.11	0.08
BiGAN/ALI	0.19	0.06	0.02	0.41	0.13	0.07
Pixel loss + GAN	0.20	0.10	0.04	0.47	0.11	0.07
Feature loss + GAN	0.06	0.04	0.01	0.50	0.10	0.06
CycleGAN	0.52	0.17	0.11	0.58	0.22	0.16
pix2pix (paired)	0.71	0.25	0.18	0.85	0.40	0.32

CycleGAN led every unpaired baseline and stayed below pix2pix trained on pairs. The pix2pix rows differ from the pix2pix paper’s own tables, where $L^1$ + cGAN scored a per-pixel accuracy of 0.66 for labels→photo and 0.83 for photo→labels (pix2pix, Tables 1 and 5); the ICCV text of CycleGAN does not explain the difference. The pix2pix article describes the FCN-score protocol.

Ablations

Removing either the adversarial loss or the cycle loss substantially degraded the results on Cityscapes labels↔photos (§5.1.3, Fig. 6). The cycle loss alone, and the adversarial loss with only the backward cycle $G(F(y)) \approx y$, failed to produce images like the target domain; the adversarial loss alone, and with only the forward cycle $F(G(x)) \approx x$, collapsed, producing identical label maps whatever the input photo (Fig. 6 caption). A cycle in one direction only often caused training instability and mode collapse, especially for the direction whose cycle had been removed. The quantitative ablation is in the arXiv version.

Applications

Section 5.2 shows applications without paired data; the authors note that translations of training images were often more appealing than those of test images (§5.2).

• Object transfiguration between visually similar classes of ImageNet, each with about 1,000 training images: horse↔zebra and apple↔orange (Fig. 7). The repository’s dataset notes give 939 horse and 1,177 zebra images (keywords “wild horse” and “zebra”) and 996 apple and 1,020 orange images (docs/datasets.md).
• Season transfer between winter and summer photographs of Yosemite from Flickr (Fig. 7).
• Collection style transfer between landscape photographs from Flickr and paintings from WikiArt by Monet, Van Gogh, Cézanne and Ukiyo-e artists (Fig. 8). Unlike neural style transfer, which matches the Gram-matrix statistics of one style image, CycleGAN learns the style of a whole collection; Fig. 11 compares it with Gatys et al.’s method given one representative painting or all of the collection.
• Photo generation from paintings, with the identity loss, shown on Monet paintings from the training set, since generalizing to new Monet paintings is not a pressing problem (Fig. 9).
• Photo enhancement: smartphone photos of flowers translated toward DSLR photos with shallower depth of field (Fig. 10); the figure shows some of the most successful results, and average performance was considerably worse.

Later work applied the recipe in other fields. In histopathology, StainGAN adapts CycleGAN to translate between the appearances of two slide scanners, as the stain normalization article describes, which also reports a study in which CycleGAN normalization changed the apparent size of nuclei.

Strengths

• No pairs. Two unrelated collections suffice, which opens problems such as painting↔photo, where pairs cannot exist.
• One general recipe. The same objective and networks served style, season, object and photo-enhancement tasks, with no task-specific similarity function (§2).
• Two translators at once. Training yields both directions, and each serves as the other’s constraint.

Limitations

The paper’s own discussion (§6, Fig. 12) and the official documentation report these failure cases and limits:

• Geometric changes. Translations that involve colour and texture often succeed; those needing geometric change rarely do. On dog→cat, the translation degenerated into minimal changes to the input. The repository’s dataset notes say the same of cats↔dogs, which “completely fails”, while landscape paintings↔photographs works much better than portrait paintings↔landscape photographs (docs/datasets.md).
• Training distribution. The horse→zebra model failed on an image unlike its training data, a horse with a rider, because the wild horse and zebra synsets of ImageNet it was trained on contain no such images.
• Gap to paired training. A gap to paired methods remained, and some of it may be impossible to close without supervision: on photos→labels the model sometimes permuted the labels of tree and building. The authors suggest weak or semi-supervised data as a remedy.
• One output per input. The generators are deterministic, so a one-to-many problem gets one answer. Huang et al. (2018, §4) call cycle consistency too strong a constraint for multimodal translation and state that, if it is enforced, the translation model degenerates to a deterministic function (their proof is in supplementary material not read here); this motivated MUNIT, and MUNIT’s diversity measurements, which include CycleGAN, are in the image-to-image translation article.
• Bijection assumed. The cycle loss asks $G$ and $F$ to be inverses, which presumes that the two domains carry the same information. Park et al. (2020) call the bijective assumption behind cycle consistency often too restrictive, and perfect reconstruction difficult when images of one domain carry information the other lacks (§1–§2). An aerial photo holds more information than its map; as the image-to-image translation article describes, Chu, Zhmoginov and Sandler (2017) found that a CycleGAN trained on maps hid details of the aerial photo, such as dots on a roof, in a low-amplitude, high-frequency signal in the generated map. That article summarizes their further findings.
• Evaluation. The repository’s FAQ calls the automatic evaluation of results an open research problem and notes that FID scores the outputs while ignoring their correspondence with the inputs.

Historical Importance

CycleGAN appeared in 2017 with two independent works built on the same idea. DiscoGAN (Kim et al., ICML 2017) and DualGAN (Yi et al., ICCV 2017, “in these same proceedings”, as Zhu et al. put it) also couple two GANs with reconstruction losses in both directions; UNIT’s authors cite CycleGAN and DiscoGAN as the two contemporary papers that independently introduced the cycle-consistency constraint. Later unpaired methods kept the cycle in some form: in CUT’s survey of the field (Park et al., 2020, §2), cycle consistency had become “the de facto method” for enforcing correspondence, used between image domains, between images and latent codes, or between latent codes and images.

Its training recipe also carried over: CUT follows CycleGAN’s setting, with the same ResNet generator, PatchGAN and least-squares loss, except that the cycle loss is replaced (Park et al., 2020, §4).

Variants

DiscoGAN

Kim, Cha, Kim, Lee and Kim (ICML 2017) aimed to discover relations between two domains and constrained the relation to be a bijection: $G_{AB}$ should be the inverse of $G_{BA}$. Their DiscoGAN couples two GANs with a reconstruction loss in each direction, where the distance can be MSE, cosine distance or hinge loss (§2.3), and they argue with a one-dimensional illustration that adding one reconstruction loss to a GAN does not resolve mode collapse (§2.3). In a two-dimensional toy experiment, a standard GAN and a GAN with one reconstruction loss failed to cover all ten target modes, while DiscoGAN covered them without collapse (§3.1). The networks are encoder–decoders at $64 \times 64$, trained with batch normalization and minibatches of 200. Experiments include car→car with azimuth preserved, face attributes, chair→car, edges→photos and handbag↔shoe (§3).

DualGAN

Yi, Zhang, Tan and Gong (ICCV 2017) took their inspiration from dual learning in machine translation. Their primal generator $G_A: U \to V$ and dual $G_B: V \to U$ are U-Nets with dropout as noise, and their discriminators are $70 \times 70$ PatchGANs, as in pix2pix (§3.2). The objective uses the Wasserstein critic loss with weight clipping and RMSProp rather than the log loss (§3.1, §3.3; see Wasserstein GAN), with $L^1$ reconstruction losses weighted by $\lambda_U, \lambda_V$ typically in $[100, 1000]$. They describe CycleGAN’s cycle-consistency loss as essentially the same as their reconstruction loss (§2).

UNIT

Liu, Breuel and Kautz (NIPS 2017) start from the observation that infinitely many joint distributions have the same two marginals and assume a shared latent space: corresponding images map to the same latent code $z$. Each domain has a VAE–GAN, with the last encoder layers and first generator layers shared between domains, plus a VAE-like cycle term. They show that the shared-latent assumption implies cycle consistency but not the reverse (§2). On satellite→map translation, average pixel accuracy over five runs was 0.569 for their framework without weight sharing, which reduces to CycleGAN, 0.568 without the cycle term, and 0.600 with both (§4). They name two limitations: a unimodal translation model from the Gaussian latent space, and unstable training (§6).

MUNIT

Huang, Liu, Belongie and Kautz (ECCV 2018) split each image into a domain-invariant content code and a domain-specific style code, and translate by combining the content code with a style code sampled from the target domain, so one input gives many outputs. The decoder applies the style through adaptive instance normalization, and a bidirectional reconstruction loss on images and on latent codes replaces the image cycle; it implies a weaker “style-augmented” cycle consistency (§3–§5).

CUT

Park, Efros, Zhang and Zhu (ECCV 2020) dropped the reverse generator. Contrastive Unpaired Translation (CUT) keeps CycleGAN’s generator, PatchGAN and LSGAN and replaces the cycle loss with a patchwise contrastive loss: features of each output patch should match those of the input patch at the same location rather than other patches of the same input (§3–§4). In their Table 1, horse→zebra FID was 77.2 for CycleGAN and 45.5 for CUT, Cityscapes FID 76.3 and 56.4, and training took 0.40 against 0.24 seconds per iteration (the caption says per sample) and 4.81 against 3.33 GB of GPU memory on horse→zebra with an NVIDIA GTX 1080 Ti; a faster variant without the identity loss, FastCUT, scored FID 73.4 on horse→zebra. The image-to-image translation article covers CUT’s results further.

Later work by the authors

The official PyTorch repository’s README (as of November 2026) points to CUT and to the authors’ one-step translators pix2pix-turbo and CycleGAN-Turbo, built on a pretrained text-to-image diffusion model.

Implementations

• Torch (Lua): junyanz/CycleGAN, the original code, BSD licence; last commit 40b4498 of September 2023 as of November 2026. The PyTorch repository’s README recommends it for reproducing the paper’s results. Its options default to $128 \times 128$ crops, the six-block ResNet generator, instance normalization, LSGAN, $\lambda = 10$, an identity weight of 0.5 and a 50-image buffer.
• PyTorch: junyanz/pytorch-CycleGAN-and-pix2pix, BSD licence, shared with pix2pix; last commit 2a7afba of August 2025 as of November 2026. The README states support for PyTorch 2.4 and later and says it produces results comparable to or better than the Torch code. The CycleGAN model defaults to resnet_9blocks, the $70 \times 70$ “basic” PatchGAN, instance normalization, LSGAN, $\lambda = 10$ in each direction, an identity weight of 0.5 and a 50-image buffer.