Our autoencoder does okay, but is not as flexible and is quite bad at decoding the image compared to typical image compression algorithms. We are only able to input 64x64 images into our model. This constraint makes it particularly difficult for us to compare this approach directly with our other algorithms. Our reconstructed images are much lower quality and introduce a lot of artifacts compared to our original images. They look much blurrier grainier, and sometimes forget important details from the original image. 

At the bottleneck, our image is represented as a 24x4x4 (384 element) tensor. This is from a 3x64x64 (12,288 element) image. 

Assuming we save the tensor as doubles (8 bytes), our representation would be 3072 bytes (384*8). Our images in a raw format are about 12,288 bytes. Using these numbers, we would have a 0.25 compression ratio. 

We could resolve the image size limitation by potentially breaking up images into blocks and passing them into the model, but this would probably require us to find a new dataset and retrain the model with larger images. We could achieve a somewhat higher compression ratio using some kind of entropy coding, such as Huffman or arithmetic coding. Unfortunately, the autoencoder doesn't seem to be worth further exploring. The image quality is reduced too greatly and offers a poor compression ratio compared to standard compression algorithms. So, we have decided to leave our exploration of autoencoders off here. However, during our research about machine learning approaches to image compression, we learned about HIFIC, which uses GANs to expand on the autoencoder and achieves much better compression results. See that page for more info.