Pseudo-qubit diffusion

[Francesco215]

Hi everyone! Since this is an idea I wanted to explore, I guess it's best to put it here rather then in the issues section

Short summary

In short, the idea is to use an object that is similar to a qubit to do diffusion over.
Qubits, by their own nature are in a grey area between something that is digital (a bit), and something that is analog (a wave-function), therefore can be a good candidate for bit diffusion model.
A more detailed explanation can be found in the google doc. Also, I would love to have some comments if there are some parts that are not clear, or incorrect. There are no stupid question, so don't be shy.

The code

A first version of the code and its implementation are available in the GitHub repository and the Colab notebook , however it is still far from complete

Also, @LetteraUnica has helped me develop the idea and is helping me write the code

---

Useful links

Google doc with the full explanation:
https://docs.google.com/document/d/1TcuSNsGa-ey1p1p6nyIyhUkRRPtrYC3r9zdCG1F_QuU/edit?usp=sharing

GitHub repo:
https://github.com/Francesco215/Quantum-diffusion

Colab notebook:
https://colab.research.google.com/drive/1zdC9NcngtnesFzqyWMA_ghvWN7EsDRRW?usp=sharing

[mateibejan1]

Amazing initiative! Do you have any L2 or FID scores to report on train/val so we can quantitatively compare to the vanilla BitDiffusion?

Also, are there any relevant computational caveats or drawbacks when using qbits that you know of? We might want to take these into consideration when designing the PyTorch Lightning codebase.

[Francesco215]

Hi!

Amazing initiative! Do you have any L2 or FID scores to report on train/val so we can quantitatively compare to the vanilla BitDiffusion?

Thanks! For now we only have the metrics from the training, where the model does a single step.
The loss we use to do the training is the bit-wise binary cross entropy (soon I'll write why on the google doc).

In a single step the model is capable of bringing the cross entropy form ~5 to ~0.5.
In terms of bit-wise L2 loss, we start from noised images with a bit-wise MSE of ~0.25 and we reach ~0.16

Clearly there is still a lot of work to do, the main objective for now was to get the code running

Also, are there any relevant computational caveats or drawbacks when using qbits that you know of? We might want to take these into consideration when designing the PyTorch Lightning codebase.

The time and space complexity of the algorithm should be the same as the analog bits algorithm. As far as PyTorch lighting we didn't implement anything yet, but we plan to do it in the future

Thanks for the interest!