[PYTHON] Créez une page Web qui exécute un modèle qui augmente la résolution de l'image à l'aide de gradio, ce qui facilite la création d'un écran Web

Aperçu

Afin de montrer efficacement les performances du modèle sous forme de démonstration après avoir créé le modèle par apprentissage en profondeur, etc., il est plus familier et préférable pour de nombreuses personnes (en particulier les non-ingénieurs) de le montrer dans l'interface graphique plutôt que de l'exécuter dans CUI. Cependant, il est difficile de créer un écran GUI qui correspond au modèle à chaque démo, et la plupart des développeurs en ont assez d'apprendre le modèle et d'ajuster les paramètres, il y a donc toujours la motivation d'implémenter l'interface graphique. Non (← C'est dû à l'expérience personnelle et j'avoue le désaccord).

À ce moment-là, j'ai trouvé quelque chose appelé Gradio qui peut créer une interface graphique Web simple avec un minimum de codage, alors j'ai essayé de l'utiliser.

Cette fois, nous développerons une méthode pour exécuter ESRGAN, qui est une méthode GAN qui agrandit la résolution de l'image publiée sur Tensorhub de 4 fois, à partir de WebGUI.

L'écran Web créé ressemble à ce qui suit.

• Gradio
• GitHub --sey323 / gradio-esrgan: Un programme qui exécute ESRGAN sur un écran Web

Environnement d'exécution

• Ubuntu18.04
• Python3.8.0

Ceux qui veulent se lancer tout de suite

Après avoir exécuté la commande suivante, accédez à http://127.0.0.1:7860/.

git clone https://github.com/sey323/gradio-esrgan.git
cd gradio-esrgan
pip install -r requirements.txt
python gradio-esrgan.py

la mise en oeuvre

0. Vue d'ensemble

import gradio as gr
import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/captain-pool/esrgan-tf2/1")


def predict(
    inp,
):
    """
Utilisez ESRGAN pour convertir l'image d'entrée en résolution 4x.
    https://tfhub.dev/captain-pool/esrgan-tf2/1
    inp :
Image d'entrée
    """
    h, w, c = inp.shape  #Obtenir la taille de l'image à partir de l'image d'entrée
    inp = inp.reshape((-1, h, w, c))
    inp = tf.cast(inp, tf.float32)
    output = model(inp)
    output = tf.cast(tf.clip_by_value(output[0], 0, 255), tf.uint8)
    return output


def gradio_gui():
    """
Définir l'écran Gui pour gradio
    """
    image = gr.inputs.Image(label="Input Image",)
    output = gr.outputs.Image(label="Output Image", type="numpy")

    interface = gr.Interface(fn=predict, inputs=image, outputs=output)
    interface.launch()


if __name__ == "__main__":
    gradio_gui()

1. Installation du moyeu tensorflow, gradio

Installation du hub tensorflow

Installez le hub Tensorflow en vous référant au Site officiel.

pip install "tensorflow>=2.0.0"
pip install --upgrade tensorflow-hub

Installez gradio

Installez en vous référant au Site officiel.

pip install gradio

2. Utilisez le modèle de hub Tensorflow

En vous référant au site officiel de TensorFlow Hub, téléchargez le modèle ESRGAN qui convertit l'image basse résolution utilisée cette fois en haute résolution et créez un programme à utiliser. J'ai créé une méthode qui convertit l'image d'entrée dans un format qui peut être appris par Tensorflow et renvoie une image haute résolution afin qu'elle puisse être exécutée par Gradio.

import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/captain-pool/esrgan-tf2/1")


def predict(
    inp,
):
    """
Utilisez ESRGAN pour convertir l'image d'entrée en résolution 4x.
    https://tfhub.dev/captain-pool/esrgan-tf2/1
    inp :
Image d'entrée
    """
    h, w, c = inp.shape  #Obtenir la taille de l'image à partir de l'image d'entrée
    inp = inp.reshape((-1, h, w, c))
    inp = tf.cast(inp, tf.float32)
    output = model(inp)
    output = tf.cast(tf.clip_by_value(output[0], 0, 255), tf.uint8)
    return output

3. Définition de l'écran Web à l'aide de gradio

gradio est à peu près divisé en trois classes.

En plus des images, vous pouvez également sélectionner du texte, de l'audio, des cases à cocher, des curseurs, etc. pour les entrées et les sorties, afin de pouvoir répondre de manière flexible au modèle que vous utilisez. ESRGAN utilisé cette fois utilise uniquement Image pour l'entrée et la sortie, donc sélectionnez Image. L'image est transmise sous la forme d'un "oreiller".

Gradio | Docs

python

import gradio as gr

~~~~réduction~~~~~

def gradio_gui():
    """
Définir l'écran Gui pour gradio
    """
    image = gr.inputs.Image(label="Input Image",)
    output = gr.outputs.Image(label="Output Image", type="numpy")

    interface = gr.Interface(fn=predict, inputs=image, outputs=output)
    interface.launch()


if __name__ == "__main__":
    gradio_gui()

Contrôle de fonctionnement

Après avoir contrôlé le programme ci-dessus, exécutez-le avec la commande suivante.

python

$ python gradio-esrgan.py 
2020-11-23 01:39:34.566267: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7f9d83e7e520 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-11-23 01:39:34.566291: I tensorflow/compiler/xla/service/service.cc:176]   StreamExecutor device (0): Host, Default Version
Running locally at: http://127.0.0.1:7860/
To get a public link for a hosted model, set Share=True
Interface loading below...
<IPython.lib.display.IFrame object at 0x147170040>

L'URL sera affichée après l'exécution, alors accédez-y.

• http://127.0.0.1:7860/

Lorsque vous accédez à l'écran Web, l'écran ci-dessus s'affiche. Le panneau de gauche montre l'élément d'entrée spécifié dans gr.inputs, et la sortie montre l'élément de sortie spécifié dans gr.outputs.

Essayez d'agrandir l'image de Mandrill. L'image à saisir peut être glissée et déposée dans la zone de saisie. Après avoir attendu quelques secondes, l'image traitée sera affichée dans la zone "SORTIE IMAGE". Téléchargez l'image du clic droit en l'enregistrant et comparez-la à l'image agrandie.

L'image de gauche est agrandie à la même taille par le Finder et l'image de droite est générée. On peut confirmer que les lignes de fourrure et les lignes de contour sont exprimées beaucoup plus nettement dans celle agrandie par ESRGAN.

À la fin

En utilisant Gradio, j'ai pu créer un écran Web qui me permet de publier facilement un modèle créé avec Tensorflow. La définition de l'écran Web n'a besoin d'être décrite que pour les trois modules, donc une fois que vous vous y êtes habitué, vous pouvez créer une page Web en moins de 10 minutes.

GradioHub a une variété d'autres échantillons intéressants, alors voyez ici ce qui se passe lorsque vous utilisez d'autres textes et audio.

Gradio | Hub