Implementing Generative Adversarial Network (GAN) training

[elahpeca]

neural-fortran in it's current state effectively supports supervised learning, where gradients are computed in the network%backward() method of each layer based on the derivative of the loss function with respect to target labels. However, training GANs requires computing gradients for the generator based on feedback from the discriminator, rather than explicit target labels for the generated data.

The standard approach to GAN training involves:

1. Generating data by the generator.
2. Evaluating the generated data by the discriminator.
3. Calculating the generator's loss based on the discriminator's output (so the goal is to fool the discriminator).
4. Calculating the gradient of this loss with respect to the generator's output.
5. Backpropagating this gradient through the generator to update its weights.

Currently, framework does not appear to provide a built-in mechanism for automatically computing the gradient of the loss with respect to intermediate network outputs (in our case, the generator's output). The backward method in the current implementation is tightly coupled with comparing the network's output to explicit target labels.

What potentially can be implemented:

1. Allow the backward method (or a new, dedicated method) to accept a pre-computed gradient from an external source. This would enable users to calculate gradients using custom logic (e.g., based on the output of another network like the discriminator in a GAN) and inject them for backpropagation.

2. A rudimentary system for tracking operations and automatically computing gradients of arbitrary tensors with respect to others. This could start with support for a limited set of fundamental operations and gradually expand.

[milancurcic]

Thank you @elahpeca for the suggestion and the ideas. I have no experience nor knowledge of GANs but can learn. Would you like to start with a minimal implementation and example application in a PR? I can help review, guide with implementation details, and answer any questions about the existing code structure.

[elahpeca]

Excellent! I'm happy to collaborate and work on this. From my perspective, this problem likely necessitates the implementation of an automatic differentiation library, even at a basic level, to facilitate gradient calculations. While gradient injection may work, it feels like a workaround. In fact, implementation of automatic differentiation will also improve the experience with existing implementations. In the near future, I will try to provide my minimal developments in this direction. I will be glad to receive your guidance.