srgan | Pytorch implementation of Photo-Realistic Single Image | Computer Vision library

I've been working on reimplementing Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network (SRGAN), now I'm stuck with the given information in section 3.2. Based on the paper, the target HR should be in the range [-1,1], the input LR should be in the range [0,1], and MSE loss was calculated on images in range [-1,1].

The last sentence implies that the output from the generator network should be in [-1,1]. So that the content_loss = MSELoss(generator(output), target). Am I understanding correctly? But when I print the output from my generator network, whose laster is just a conv2d, it gives me images in the rage [0,1].

I'm not getting a good result by running SRResNet-MSE part, and I think maybe because the MSE loss is calculating on different ranges instead of just one [-1,1]?

But how can the output from my generator be in range [-1,1] if I still want to follow paper's architecture, which has conv2d as the last layer?

I also include my code Class Generator here

How can I save a jupyter notebook with outputs? I'm editing my notebook with Google Collab and want to save it as a .ipynb file with outputs shown, like here: https://nbviewer.jupyter.org/github/krasserm/super-resolution/blob/master/example-srgan.ipynb.

But when I Download .ipynb on Google Collab, you can't see the outputs in the resulting file. How can I get the outputs to show?

Related question: how can I have the outputs save in the Google Collab doc? Right now, the outputs always disappear on reload, even though I disabled the hide outputs on save.

I have images that are having very low quality and these images I have to use for person identification but with this quality it's difficult to detect. I want to enhance the quality of the images using deep learning/machine learning techniques. I have studied about SRCNN, perceptual Loss, SRResNet, SRGAN but most of the super image resolution techniques require original images for improving the quality of the images. So my question is there any deep learning techniques that can be used for the improving the quality of the images without using the original images.

I want to use including and after tensorflow2.0 in Docker. I want to use (https://github.com/tensorlayer/srgan).

My Dockerfile is

1. Context
2. The problem
3. Trying to solve the problem
4. Question
5. Related questions

I use a custom .tflite model I saved in the Firebase servers (https://firebase.google.com/docs/ml-kit/android/use-custom-models). This is my custom Super-Resolution images GAN generator: I give it a 32x32 image, and it gives me the super resolutioned 128x128 image. I am trying to use it in my Android app.

I followed the documentation whose I gave the link above.

The following exception is thrown:

I/System.out: com.google.firebase.ml.common.FirebaseMLException: Internal error has occurred when executing Firebase ML tasks

According to the Google Colab Python Interpreter, my expected input and output are the following:

[ 1 32 32 3]

class 'numpy.float32'>

[ 1 128 128 3]

class 'numpy.float32'>

So I must give my generator model a 32x32x3 image, and it must output a 128x128x3 image, everything is normal here :). This is the normal work of a SRGAN generator.

Here is the Android app source code... it includes both the configuration and the inference run of my generator model. Data to be sent is also shown.

I have written a TensorFlow / Keras Super-Resolution GAN. I've converted the resulting trained .h5 model to a .tflite model, using the below code, executed in Google Colab:

My question is composed by:

• A context in which I present my project, my working environment and my workflow
• The detailed problem
• The concerned parts of my code
• The solutions I tried to solve my problem
• The question reminder

I've written a Python Keras implementation of a downgraded version of the original Super-Resolution GAN. Now I want to test it using Google Firebase Machine Learning Kit, by hosting it in the Google servers. That's why I have to convert my Keras program to a TensorFlow Lite one.

I'm training my program on Google Colab working environment: there, I've installed TF 2.0.0-beta1 (this choice is motivated by this uncorrect answer: https://datascience.stackexchange.com/a/57408/78409).

Workflow (and problem):

1. I write locally my Python Keras program, keeping in mind that it will run on TF 2. So I use TF 2 imports, for example: from tensorflow.keras.optimizers import Adam and also from tensorflow.keras.layers import Conv2D, BatchNormalization

2. I send my code to my Drive

3. I run without any problem my Google Colab Notebook: TF 2 is used.

4. I get the output model in my Drive, and I download it.

5. I try to convert this model to the TFLite format by executing the following CLI: tflite_convert --output_file=srgan.tflite --keras_model_file=srgan.h5: here the problem appears.

Instead of outputing the TF Lite converted model from the TF (Keras) model, the previous CLI outputs this error:

ValueError: Unknown loss function:build_vgg19_loss_network

The function build_vgg19_loss_network is a custom loss function that I've implemented and that must be used by the GAN.

The custom loss function is implemented like that:

I am trying to replicate the example mentioned at this address by tensorlayer:

https://github.com/tensorlayer/srgan/blob/master/train.py

It has below import statements:

A single line in my model, tr.nn.Linear(hw_flat * num_filters*8, num_fc), is causing an OOM error on initialization of the model. Commenting it out removes the memory issue.