DCGAN | Deep Convolutional Generative Adversarial Networks on MNIST | Machine Learning library

You can use the code in the tutorial fine, you just need to adapt the generator a bit. Let me break it for you. Here is the generator code from the tutorial:

You just can't do that. As you said, your network expects 100 dimensional input which is normally sampled from standard normal distribution:

So the generator's job is to take this random vector and generate 3x64x64 image that is indistinguishable from real images. Input is a random 100 dimensional vector sampled from standard normal distribution. I don't see any way to input your image into the current network without modifying the architecture and retraining the new model. If you want to try a new model, you can change input to occluded images, apply some conv. / linear layers to reduce the dimensions to 100 then keep the rest of the network same. This way network will try to learn to generate images not from latent vector but from the feature vector extracted from occluded images. It may or may not work.

EDIT I've decided to give it a go and see if network can learn with this type of conditioned input vectors instead of latent vectors. I've used the tutorial example you've linked and added a couple of changes. First a new network for receiving input and reducing it to 100 dimensions:

If working with data where batch size is the first dimension then you can interchange real_cpu.size(0) with len(real_cpu) or with len(data[0]). However when working with some models like LSTMs you can have batch size at second dimension, and in such case you couldn't go with len, but rather real_cpu.size(1) for example

The DCGAN described a concrete architecture where Conv layers were used for the downsampling of the feature maps. If you carefully design your Conv layers, you can do without a Linear layer but that does not mean that it will not work when you use a Linear layer to downsample (especially as the very last layer). The DCGAN paper just found out it worked better to use Conv layers instead of Linear to downsample.

If you want to maintain this architecture, you can change the kernel size or padding or stride to give you exactly a single value in the last layer. Refer to the Pytorch documentation on Conv layers to see what the output size should be, given an input size

Your model's output is not consistent with your criterion.

If you want to keep the model and change the criterion:

Use BCELoss instead of CrossEntropyLoss. Note: You will need to cast your labels to float before passing them in. Also consider removing the Sigmoid() from the model and using BCEWithLogitsLoss.

If you want to keep the criterion and change the model:

CrossEntropyLoss expects the shape (..., num_classes). So for your 2 class case (real & fake), you will have to predict 2 values for each image in the batch which means you will need to alter the output channels of the last layer in your model. It also expects the raw logits, so you should remove the Sigmoid().

I figured it out eventually. Used .dropna(how='any', inplace = True) after droping unwanted columns and it solved the problem. Now my result is generating at 93.57% accuracy.

So, I finally found what was causing the issue. It is related with the layers in the discriminator model, which is not even included in the code chunk above as I thought that was not the problem (because when I tested the discriminator as a standalone model, it worked). Here is how it is defined:

Pure PyTorch does not provide metrics out of the box, but it is very easy to define those yourself.

Also there is no such thing as "extracting metrics from model". Metrics are metrics, they measure (in this case accuracy of discriminator), they are not inherent to the model.

In your case, you are looking for binary accuracy metric. Below code works with either logits (unnormalized probability outputed by discriminator, probably last nn.Linear layer without activation) or probabilities (last nn.Linear followed by sigmoid activation):

Try the following: