|

HiDDeN: Hiding Data With Deep Networks (Zhu et al., 2018)

HiDDeN learns to hide a binary message through changes to an image. A recipient uses a decoder to recover the message from the received pixels without the original image. Jiren Zhu, Russell Kaplan, Justin Johnson and Li Fei-Fei study both secret communication and watermark recovery after image distortion. The authors report that training with simulated distortions lets the learned encoding survive cropping, blurring and JPEG compression. Their objective balances message recovery, image distortion and detection by an adversarial classifier. Zhu et al., HiDDeN: Hiding Data With Deep Networks (2018).

Why learn how to hide the message?

An image can carry a message that must remain recoverable after its pixels change. The paper separates two requirements. Steganography hides the presence of a message from an observer. Watermarking prioritizes recovering the message after distortion. These requirements compete with the amount of information embedded and with image quality.

The authors propose optimizing those objectives jointly. The encoder learns pixel changes, while the decoder learns how to recover the bits. Training with a chosen distortion changes the recovery task. The authors describe retraining for a new distortion as a way to adapt the embedding rule. Different random initializations also produce different learned embedding strategies.

What networks does HiDDeN train?

The paper trains three convolutional networks. Encoder E receives a cover image and a binary message. Decoder D predicts that message from the received image. Adversary A classifies an image as a cover or an encoded image. Its classification supplies an additional training signal to the encoder.

Noise layer N sits between E and D and has no learned parameters. It transforms the encoded image before decoding. Some transformations also use the cover image. E and D share the message-recovery objective; A has a separate classification objective. The cover has height H, width W and C channels. The message contains L bits. The encoded image has the cover’s dimensions, while the received image can have different spatial dimensions.

Encoder E, noise layer N, decoder D and adversary A, with their loss paths highlighted

Zhu et al. (2018), Figure 2. Highlights identify the four components.

How does the message enter every image location?

A convolution processes a local region, but its embedding decision needs access to the message. Appendix A repeats every message bit across the image. The encoder concatenates that message volume with its image features and the original cover. Each location in the next convolution therefore receives the complete message.

In the released PyTorch re-implementation, a 30-bit message becomes a 128×128×30 volume. Four convolution, batch-normalization and rectified-linear-unit blocks produce 64 feature channels. Concatenation creates 97 channels. One further block produces 64 channels, followed by a linear 1×1 convolution returning the image. Appendix A specifies these stages and no activation after the final convolution.

HiDDeN encoder EAppendix A architecture; layer dimensions and parameter totals from experiment/shapes_params.json.HiDDeN encoder EReleased PyTorch re-implementation · height × width × channelsCover128×128×3Original image4 CBR blocks128×128×6464 channels eachConcatenate128×128×9730 + 64 + 3CBR → 1×1 conv128×128×64→ 128×128×3Message: 30 → repeat → 128×128×30Original cover joins the same fusion boundaryCBR = 3×3 convolution, stride 1, padding 1 → BatchNorm → ReLU169,347 parameters · final 1×1 convolution: linear, no activation
HiDDeN encoder E (open full size)

We measured the worked example on Boat with the combined checkpoint. At crop pixel (60,60), the red-channel cover value was 219. The encoded float value was 214.6263, a signed change of −4.3737. Serialization rounded it to 215. Thresholding the decoded PNG values at 0.5 recovered 29/30 bits.

Measured Boat message replication, four pixel matrices, rounding arithmetic, all decoder values and the mismatched bit

We measured the red-channel block y=60:64, x=60:64. Displayed decimals are rounded; the PNG decoder values determine the bits.

How can the decoder read an image after cropping?

A crop changes the number of received pixels. A decoder tied to one flattened image size would require a fixed spatial extent. Appendix A instead uses convolutions followed by global spatial averaging. The average produces one value per message channel regardless of the received height H′ and width W′.

The decoder contains seven blocks with 64 channels and one block with L channels. Each block applies convolution, batch normalization and a rectified linear unit. A final L-to-L linear layer predicts the message. The paper rounds those predictions for evaluation. In the released PyTorch re-implementation, the full-image path ends in a 1×1×30 pooled tensor and 30 real-valued outputs. Cropped inputs pass through the same convolution and pooling stages at their received dimensions.

HiDDeN decoder DAppendix A architecture; layer dimensions and parameter totals from experiment/shapes_params.json.HiDDeN decoder DReleased PyTorch re-implementation · native received dimensionsReceivedH′×W′×3Native pixels7 CBR blocksH′×W′×6464 channels each1 CBR blockH′×W′×3030 channelsAverage → linear1×1×30 → 3030 → 30 valuesCBR = 3×3 convolution → BatchNorm → ReLU; spatial sizes preserved242,556 parameters · global spatial average · final linear prediction
HiDDeN decoder D (open full size)

Why train with dropout, cropout and crop?

Lossless training supplies no recovery objective for a distorted image. The paper inserts noise before decoding so that message loss reaches the encoder through the distortion. Dropout and cropout undo selected embedding changes. Both retain a fraction p of encoded pixels and take the remaining pixels from the original cover.

Dropout samples positions independently. Cropout retains one random square region while preserving the image dimensions through cover substitution. A crop retains a square region and discards the surrounding image entirely. Here p means retained area, rather than retained side length. The authors motivate cover substitution because a fixed replacement value could identify altered positions. The decoder receives neither a substitution mask nor the original crop coordinates. Gaussian noise layers apply blur controlled by kernel width σ.

How do JPEG-Mask and JPEG-Drop support training?

JPEG rounds frequency coefficients, interrupting the gradient used to train the encoder. The paper replaces that operation with differentiable coefficient removal. A fixed discrete cosine transform, or DCT, maps each 8×8 block into frequency coefficients. An inverse transform returns the altered coefficients to image pixels.

JPEG-Mask keeps 25 low-frequency coefficients in luminance channel Y and 9 in each chrominance channel U and V. It sets the other coefficients to zero. JPEG-Drop instead randomly zeros coefficients. A coefficient receives a greater drop probability when actual JPEG quantizes it more coarsely. The transform filters remain fixed. The authors report training with both approximations and evaluating recovery under real JPEG compression. Actual JPEG uses quality factor Q to control compression strength; the approximations are separate training operations.

Figure 4 frequency grids with fixed JPEG-Mask zeros and stochastic JPEG-Drop zeros highlighted

Zhu et al. (2018), Figure 4. Highlights mark the two coefficient-removal patterns.

Why train an adversary alongside the image loss?

An image reconstruction loss measures pixel differences. The adversary supplies a learned cover-versus-encoded classification signal. The encoder receives that signal through its adversarial loss, while the adversary trains to recognize encoded images. This branch operates during training; message recovery uses the decoder.

Appendix A describes three convolution, batch-normalization and rectified-linear-unit blocks with 64 channels. Spatial averaging feeds a linear classification head. The diagram gives the layer path in the released PyTorch re-implementation. The authors’ adversary ablation removes this classification branch from training. They report visible artifacts in the combined-noise example trained using image reconstruction loss alone. Both adversary settings were tuned individually, so the illustrated pair represents those separately tuned models.

HiDDeN adversary AAppendix A architecture; layer dimensions and parameter totals from experiment/shapes_params.json.HiDDeN adversary AReleased PyTorch re-implementation · classification during trainingInput image128×128×3One image3 CBR blocks128×128×6464 channels eachGlobal average1×1×64Flatten: 64Linear head64 → 1One logitCBR = 3×3 convolution → BatchNorm → ReLU76,097 parameters · image-quality training branchThe adversary ablation removes this branch; encoder and decoder remain.
HiDDeN adversary A (open full size)

What does each loss optimize?

The image loss L_I is mean squared pixel error between cover I_co and encoded image I_en. Message loss L_M is mean squared error between input bits M_in and predicted values M_out. Adversarial loss L_G uses A(I_en), the discriminator’s stated probability that an image is encoded. L_A is its classification objective. The weights λI and λG control image distortion and adversarial influence. The paper prints the following logarithmic expressions and minimization objectives. E_data denotes an expectation over input images and messages; log denotes the logarithm.

L_I = ||I_co − I_en||² / (C H W)
L_M = ||M_in − M_out||² / L
L_G = log(1 − A(I_en))
L_A = log(1 − A(I_co)) + log(A(I_en))
minimize over E,D: E_data[L_M + λI L_I + λG L_G]
minimize over A:   E_data[L_A]

Section 4.2 sets λI=0.7 and λG=0.001 for color watermarking. The message term has unit weight. Image size and message length normalize their respective squared errors.

How are training images and messages selected?

The networks need many image-message pairs to learn a shared encoding rule. The authors report training on 10,000 COCO cover images and evaluating on 1,000 images unseen during training. Each message bit is sampled uniformly at random. Images are resized to the dimensions required by each experiment.

They use Adam with learning rate 10⁻³ and its default hyperparameters, with batches of 12 images. A single-noise model trains for 200 epochs. A model trained with multiple noise layers runs for 400 epochs. The watermarking setting uses 128×128 color images represented in YUV and messages of 30 bits. Specialized models each train against a selected distortion and strength.

Does combined noise apply every distortion in sequence?

A single watermark may encounter several possible kinds of processing. Appendix C trains one combined model by swapping the selected noise layer between minibatches. Each minibatch uses a selected distortion, rather than a chain of all distortions.

The collection has eleven choices: dropout with retained fractions 0.3 and 0.7; cropout at 0.3 and 0.7; crop at 0.3 and 0.7; Gaussian blur with σ=2 and σ=4; JPEG-Drop; JPEG-Mask; and identity. Each choice changes the image presented to the decoder. The authors evaluate this shared model on the individual distortion families, alongside models specialized to a single family.

All parts of HiDDeN

The encoder turns the cover and message into an encoded image. The selected noise operation creates the decoder’s received image. Message loss connects the predicted bits to the input message. Image loss connects the encoded image to the cover. The adversary supplies its classification signal from cover and encoded images. Joint encoder-decoder training and separate adversary training optimize these paths. At reception, the decoder predicts the message from the received pixels.

All parts of HiDDeNAppendix A architecture; layer dimensions and parameter totals from experiment/shapes_params.json.All parts of HiDDeNJoint encoder / decoder training; separate adversary classificationCover + bitsImage + messageEncoder EEncoded imageNoise NReceived imageDecoder DPredicted bitsAdversary ACover / encoded classifierMessage loss: input ↔ decoded bitsImage loss: cover ↔ encoded imageAdversarial loss: encoded classification
All parts of HiDDeN (open full size)

What experiments did the authors run?

The authors report experiments on capacity, steganalysis, neural steganography, JPEG transfer, image quality, robustness and Digimarc.

Steganography capacity and image quality

The authors train an identity-noise model on grayscale 16×16 patches with 52 message bits. They apply it patch by patch to BOSS images of 512×512 pixels. They report 0.203 bits per pixel and bit error below 10⁻⁵. HUGO, WOW and S-UNIWARD use 0.200 bits per pixel. Figure 6 includes cover and encoded-image details for the visual comparison.

ATS steganalysis with known and unknown weights

The authors give the artificial-training-set steganalyzer ATS 250 covers and 250 encoded images per algorithm. With the target encoder’s weights available, they report 98% detection. For unknown weights, ATS receives five independently initialized models and evaluates a sixth, yielding 50% detection. They report 70% for HUGO and 68% for both WOW and S-UNIWARD.

Comparison with prior neural steganography

The authors compare against Hayes and Danezis [21] at matched image dimensions. Figure 7 reports HiDDeN bit error below 10⁻⁵ at both 0.1 and 0.2 bits per pixel. The prior method has error 2×10⁻³ at 0.1 bits per pixel. The figure also presents the encoded images for the quality comparison.

JPEG approximation transfer

The authors train separate JPEG-Mask and JPEG-Drop watermarking models. Figure 5 plots recovery across training epochs under the approximation and under actual JPEG at Q=50. They report transfer from both differentiable approximations to actual compression. Dashed curves evaluate the training approximation; solid curves evaluate JPEG.

Figure 5 JPEG-Mask and JPEG-Drop training curves with real-JPEG recovery segments highlighted

Zhu et al. (2018), Figure 5. Both panels retain the approximation and JPEG legends.

Image quality and the adversary

The authors report peak signal-to-noise ratio, or PSNR, separately for Y, U and V color channels. Their means use the watermarking evaluation set. The combined-noise adversary examples were tuned individually. They describe visible artifacts in the example trained without the adversary.

Training noiseY PSNR (dB)U PSNR (dB)V PSNR (dB)
Identity44.6345.4446.90
Combined33.5538.9239.38

Source: Zhu et al. (2018), Figure 8.

Figure 8 image examples with the combined models trained with and without an adversary highlighted

Zhu et al. (2018), Figure 8. Highlights identify the individually tuned combined-noise pair.

Fixed-strength robustness

The authors evaluate bit accuracy on 1,000 unseen images. Identity denotes training without distortion. Specialized denotes training on the evaluated distortion family; JPEG specialization uses JPEG-Mask. Combined uses the Appendix C collection. The authors report 85% specialized accuracy and 63% combined accuracy under actual JPEG at Q=50. For cropout at retained fraction 0.3, they report 97% and 94%.

Received distortionStrengthIdentity (%)Specialized (%)Combined (%)
IdentityNone100—100
Dropoutp=0.38610093
Cropoutp=0.3839794
Cropp=0.0355110088
Gaussian blurσ=27010096
Actual JPEGQ=50508563

Source: Zhu et al. (2018), Figure 9.

Distortion-strength sweeps

The authors vary retained fractions for dropout, cropout and crop, blur width, and JPEG quality. Figure 10 marks the specialized models’ training strengths with stars. Its JPEG curves evaluate actual compression, while the specialized model trains on JPEG-Mask. The combined model uses the same weights across these distortion families.

Figure 10 individual strength-sweep panels and shared legend, with training-strength stars and JPEG curve segment highlighted

Zhu et al. (2018), Figure 10. Stars mark specialized training strengths.

Digimarc comparison

The authors test ten Digimarc watermarks on its recommended 256×256 images. They estimate a 64-bit message and use a half-rate error-correction proxy to relate HiDDeN bit accuracy to whole-message success. At crop retention 0.1, they report at least 95% specialized and combined bit accuracy, while Digimarc recovers none of the ten messages. They report poorer HiDDeN results for frequency-domain distortions.

Other tests and stated limits

Appendix D supplies additional encoded-image examples. The authors identify geometric transforms, contrast changes and other lossy compression schemes as future robustness targets. Their Digimarc protocol uses estimated capacity and an error-correction proxy because the package exposes whole-message success rather than bit errors.

Our test: can the released message survive image changes?

We used the released PyTorch re-implementation with its combined epoch-400 and identity epoch-200 checkpoints. Our code and numeric results are on GitHub.

SettingValue
ImagesUSC-SIPI Airplane and Boat; 512×512 sources
Working inputCentral 128×128 crop; box (192,192)–(320,320); RGB
Message101100101100101100101100101100; 30 bits; no error correction
InferenceCPU float32; evaluation mode; threshold ≥0.5
SerializationNormalize to [−1,1]; clip output; map to 0–255; round to nearest, ties to even; reopen PNG
Real JPEGQ=95/75/50/30; Pillow; 4:2:0 subsampling
Center cropRetained area 0.7/0.3/0.1/0.035; sides 107/70/40/24; native decoding
DropoutEncoded-pixel retention 0.7/0.3/0.1; cover substitution; 20 seeded draws
BlurGaussian σ=0.5/1/2/4; radius ceil(3σ); reflection padding
Secondary crop20 seeded random locations per retained area
Seed20180908; fixed image/strength/draw offsets; shared masks across models

The released models use RGB, a one-logit discriminator head and a six-choice training mixture with resize, without Gaussian blur or JPEG-Drop. Encoding predicts the image directly. We normalized each cover as uint8/127.5−1. Each attack started from the reopened encoded PNG. The decoder received real-valued pixels and returned unconstrained values; each value at least 0.5 became a one. Each attacked image was saved before decoding.

We measured clean PNG recovery of 29/30 for the combined checkpoint on each image and 30/30 for the identity checkpoint on each image. Whole-message recovery therefore occurred for the identity checkpoint on both clean inputs. We measured RGB PSNR against the cover of 31.18 dB on Airplane and 32.55 dB on Boat for combined, and 36.33 dB and 39.65 dB for identity.

Measured Airplane source, crop, encoded images, signed residuals at gain 8 and received images with correct-bit counts for both checkpoints
Measured Boat source, crop, encoded images, signed residuals at gain 8 and received images with correct-bit counts for both checkpoints

We measured the displayed received images. Residual display is 128+8×(encoded PNG−cover), clipped to byte range. Enlargements use nearest neighbors.

Encoded image fidelity · We measured RGB PSNRSaved PNG decoding; combined and identity checkpoints; Airplane and Boat.Encoded image fidelityWe measured · RGB PSNR (dB)Airplane / combined31.18Boat / combined32.55Airplane / identity36.33Boat / identity39.65Reference: central cover; received: encoded PNG
Encoded image fidelity · We measured RGB PSNR

We measured JPEG Q=50 recovery of 16/30 and 19/30 on Airplane and Boat with combined weights. At center-crop retention 0.035, we measured 22/30 and 25/30. Gaussian blur at σ=2 gave 23/30 and 21/30. Each transformation was applied separately.

Real JPEG · We measured correct bits /30Saved PNG decoding; combined and identity checkpoints; Airplane and Boat.Real JPEGWe measured · correct bits /30CombinedIdentityAirplane010203095755030Airplane combined, 95: 23/30; range 23–23; 1 drawsAirplane combined, 75: 14/30; range 14–14; 1 drawsAirplane combined, 50: 16/30; range 16–16; 1 drawsAirplane combined, 30: 13/30; range 13–13; 1 drawsAirplane identity, 95: 14/30; range 14–14; 1 drawsAirplane identity, 75: 12/30; range 12–12; 1 drawsAirplane identity, 50: 10/30; range 10–10; 1 drawsAirplane identity, 30: 12/30; range 12–12; 1 drawsQuality QBoat010203095755030Boat combined, 95: 20/30; range 20–20; 1 drawsBoat combined, 75: 18/30; range 18–18; 1 drawsBoat combined, 50: 19/30; range 19–19; 1 drawsBoat combined, 30: 18/30; range 18–18; 1 drawsBoat identity, 95: 15/30; range 15–15; 1 drawsBoat identity, 75: 9/30; range 9–9; 1 drawsBoat identity, 50: 11/30; range 11–11; 1 drawsBoat identity, 30: 11/30; range 11–11; 1 drawsQuality QEach point: one saved received image
Real JPEG · We measured correct bits /30
Center crop · We measured correct bits /30Saved PNG decoding; combined and identity checkpoints; Airplane and Boat.Center cropWe measured · correct bits /30CombinedIdentityAirplane01020300.70.30.10.035Airplane combined, 0.7: 28/30; range 28–28; 1 drawsAirplane combined, 0.3: 27/30; range 27–27; 1 drawsAirplane combined, 0.1: 28/30; range 28–28; 1 drawsAirplane combined, 0.035: 22/30; range 22–22; 1 drawsAirplane identity, 0.7: 30/30; range 30–30; 1 drawsAirplane identity, 0.3: 29/30; range 29–29; 1 drawsAirplane identity, 0.1: 26/30; range 26–26; 1 drawsAirplane identity, 0.035: 22/30; range 22–22; 1 drawsRetained target area pBoat01020300.70.30.10.035Boat combined, 0.7: 28/30; range 28–28; 1 drawsBoat combined, 0.3: 27/30; range 27–27; 1 drawsBoat combined, 0.1: 27/30; range 27–27; 1 drawsBoat combined, 0.035: 25/30; range 25–25; 1 drawsBoat identity, 0.7: 30/30; range 30–30; 1 drawsBoat identity, 0.3: 30/30; range 30–30; 1 drawsBoat identity, 0.1: 27/30; range 27–27; 1 drawsBoat identity, 0.035: 22/30; range 22–22; 1 drawsRetained target area pEach point: one saved received image
Center crop · We measured correct bits /30
Cover-substitution dropout · We measured correct bits /30Saved PNG decoding; combined and identity checkpoints; Airplane and Boat.Cover-substitution dropoutWe measured · correct bits /30CombinedIdentityAirplane01020300.70.30.1Airplane combined, 0.7: 27.6/30; range 26–29; 20 drawsAirplane combined, 0.3: 26.05/30; range 23–28; 20 drawsAirplane combined, 0.1: 18.35/30; range 17–20; 20 drawsAirplane identity, 0.7: 28.3/30; range 27–29; 20 drawsAirplane identity, 0.3: 20.2/30; range 18–23; 20 drawsAirplane identity, 0.1: 14.85/30; range 13–17; 20 drawsRetained encoded pixels pBoat01020300.70.30.1Boat combined, 0.7: 28.4/30; range 28–29; 20 drawsBoat combined, 0.3: 27.1/30; range 27–28; 20 drawsBoat combined, 0.1: 25.4/30; range 24–27; 20 drawsBoat identity, 0.7: 28.05/30; range 27–29; 20 drawsBoat identity, 0.3: 23.3/30; range 21–24; 20 drawsBoat identity, 0.1: 16.9/30; range 15–20; 20 drawsRetained encoded pixels pPoints: mean; whiskers: min–max
Cover-substitution dropout · We measured correct bits /30
Gaussian blur · We measured correct bits /30Saved PNG decoding; combined and identity checkpoints; Airplane and Boat.Gaussian blurWe measured · correct bits /30CombinedIdentityAirplane01020300.5124Airplane combined, 0.5: 28/30; range 28–28; 1 drawsAirplane combined, 1: 26/30; range 26–26; 1 drawsAirplane combined, 2: 23/30; range 23–23; 1 drawsAirplane combined, 4: 17/30; range 17–17; 1 drawsAirplane identity, 0.5: 30/30; range 30–30; 1 drawsAirplane identity, 1: 16/30; range 16–16; 1 drawsAirplane identity, 2: 16/30; range 16–16; 1 drawsAirplane identity, 4: 14/30; range 14–14; 1 drawsSigma (pixels)Boat01020300.5124Boat combined, 0.5: 28/30; range 28–28; 1 drawsBoat combined, 1: 27/30; range 27–27; 1 drawsBoat combined, 2: 21/30; range 21–21; 1 drawsBoat combined, 4: 17/30; range 17–17; 1 drawsBoat identity, 0.5: 30/30; range 30–30; 1 drawsBoat identity, 1: 16/30; range 16–16; 1 drawsBoat identity, 2: 14/30; range 14–14; 1 drawsBoat identity, 4: 15/30; range 15–15; 1 drawsSigma (pixels)Each point: one saved received image
Gaussian blur · We measured correct bits /30

For dropout and random-location cropping, we measured 20 seeded draws per image, checkpoint and strength. Points show the mean correct-bit count; whiskers show its observed minimum and maximum. Dropout uses the original cover to replace unretained encoded pixels. The decoder receives only the resulting image. Random-location crop boxes and dropout masks are fixed across the checkpoints.

Random-location crop · We measured correct bits /30Saved PNG decoding; combined and identity checkpoints; Airplane and Boat.Random-location cropWe measured · correct bits /30CombinedIdentityAirplane01020300.70.30.10.035Airplane combined, 0.7: 27.95/30; range 27–28; 20 drawsAirplane combined, 0.3: 27.75/30; range 27–28; 20 drawsAirplane combined, 0.1: 26.7/30; range 25–29; 20 drawsAirplane combined, 0.035: 24.6/30; range 20–28; 20 drawsAirplane identity, 0.7: 29.35/30; range 23–30; 20 drawsAirplane identity, 0.3: 29.45/30; range 26–30; 20 drawsAirplane identity, 0.1: 26/30; range 23–29; 20 drawsAirplane identity, 0.035: 21.8/30; range 19–26; 20 drawsRetained target area pBoat01020300.70.30.10.035Boat combined, 0.7: 28/30; range 28–28; 20 drawsBoat combined, 0.3: 27.5/30; range 27–28; 20 drawsBoat combined, 0.1: 26.15/30; range 24–28; 20 drawsBoat combined, 0.035: 25.1/30; range 23–27; 20 drawsBoat identity, 0.7: 29.95/30; range 29–30; 20 drawsBoat identity, 0.3: 29.7/30; range 27–30; 20 drawsBoat identity, 0.1: 25.4/30; range 23–27; 20 drawsBoat identity, 0.035: 21.65/30; range 20–24; 20 drawsRetained target area pPoints: mean; whiskers: min–max
Random-location crop · We measured correct bits /30

Conditions and limits

Message recovery requires the decoder associated with the encoder’s learned embedding rule. Blind decoding uses the received image without its original cover. The simulated cover-substitution attack needs the cover when constructing the received image. The measurements concern the named source crops, fixed message, released checkpoints and specified transformations. They cover separate changes to the encoded PNG and include raw bit recovery without error correction. Statistical detection of an encoded image is a separate task from reading its message. The paper’s ATS experiment depends on access to encoder weights.

Implementation details

The released PyTorch re-implementation uses RGB inputs, a one-logit discriminator and binary cross-entropy with logits. Appendix A specifies a two-logit adversary; Section 4.2 uses YUV. The released combined mixture selects among identity, dropout, cropout, crop, resize and JPEG approximation. It omits Gaussian blur and JPEG-Drop from Appendix C. Its JPEG mask uses zigzag coefficient selection. The authors’ Lua encoder also places cover concatenation after an additional post-message block. The parameter totals below belong to the pinned PyTorch modules.

Network moduleParametersInput → output shape
Encoder (model.encoder)169,347128×128×3 + 30 → 128×128×3
Decoder (model.decoder)242,556H′×W′×3 → 30
Discriminator (model.discriminator)76,097128×128×3 → 1 logit

Checkpoint SHA-256 values:

combined epoch-400:
ef9741110627561a634bf54a9fae82d3c3b8b4621596a5770f5aa8f8a31b532d
identity epoch-200:
71118462194d647f6f5c08dd35f95d4f53db11a9bd2758f3bd336b46aafa5916

References

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *