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.

スクリーンショット 2020-11-23 18.18.08.png

Environnement d'exécution

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

Vue d'ensemble du code source
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.

classe Aperçu
gr.inputs Entrée à donner au modèle(Image, Textbox,Audio etc.)
gr.outputs Sortie du modèle(Image, Textbox,Audio etc.)
gr.Interface Définissez les fonctions, entrées et sorties à exécuter par Gradio et dessinez un écran Web.

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.

gradio2.png

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.

スクリーンショット 2020-11-23 18.18.08.png

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.

result.png

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

Recommended Posts

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
Une histoire qui facilite l'estimation de la surface habitable à l'aide d'Elasticsearch et de Python
Un script qui facilite la création de menus riches avec l'API de messagerie LINE
[Python] J'ai écrit un test de "Streamlit" qui facilite la création d'applications de visualisation.
J'ai essayé de créer un site qui permet de voir facilement les informations mises à jour d'Azure
Une histoire qui rend le débogage de modèle plus facile à voir dans l'environnement Django + SQLAlchemy
Essayez de modifier une nouvelle image à l'aide du modèle StyleGAN2 entraîné
[Go] Créez une commande CLI pour changer l'extension de l'image
[Ev3dev] Créez un programme qui capture LCD (écran) en utilisant python
Comment créer un wrapper qui préserve la signature de la fonction à envelopper
Je souhaite créer une application WEB en utilisant les données de League of Legends ①
Créez une application Web qui convertit le PDF en texte à l'aide de Flask et PyPDF2
[AWS Lambda] Créer un package de déploiement à l'aide de l'image Amazon Linux Docker
J'ai essayé de créer un modèle avec l'exemple d'Amazon SageMaker Autopilot
[Python3] Prenez une capture d'écran d'une page Web sur le serveur et recadrez-la davantage
J'ai écrit une classe qui facilite l'écriture en spécifiant les paroles de la partie lors de l'utilisation de Mecab avec python
J'ai créé un outil qui facilite un peu la création et l'installation d'une clé publique.
Procédure pour créer un Job qui extrait une image Docker et la teste avec des actions Github
J'ai créé une fonction pour découper l'image de python openCV, alors veuillez l'utiliser.
J'ai essayé d'utiliser PI Fu pour générer un modèle 3D d'une personne à partir d'une image