Créons une application de reconnaissance d'image en utilisant Python, Flask et PyTorch. En combinant ces trois éléments, vous pouvez facilement créer une application de démonstration à une vitesse explosive.

Préface

Qu'est-ce que Flask

Un framework Web pour Python. Django est un framework Web bien connu pour Python, mais Flask se vend léger. Comparé à Django, il a moins de fonctions et de bibliothèques d'extensions, mais les restrictions simplifient le code et vous pouvez facilement créer des applications. Il convient à la réalisation de prototypes d'applications Web car il est facile de créer un environnement.

Bonne compatibilité entre Flask, le traitement d'image et l'apprentissage automatique

Il est bien connu que Python dispose d'une multitude de bibliothèques liées à l'apprentissage automatique et est devenu la norme de facto. De plus, Python dispose de nombreuses bibliothèques de traitement d'images telles que OpenCV et Pillow (PIL), et il existe une mine d'informations sur le net. Dans ce contexte, l'utilisation de Python x Flask facilite l'utilisation de la bibliothèque d'apprentissage automatique et de la bibliothèque de traitement d'image, et vous pouvez facilement créer des applications.

Ce but

Lorsque vous téléchargez une image de numéro manuscrite à partir d'un navigateur, créons une application qui reconnaît le numéro et affiche le résultat.

Configuration de l'application

Construire un modèle d'apprentissage automatique

Cette fois, j'ai créé un modèle de reconnaissance de nombres manuscrits de MNIST en utilisant PyTorch.

Un exemple simple qui enregistre un modèle qui a appris MNIST avec PyTorch dans Google Colaboratory, le lit et l'utilise - Blog de programmation d'intelligence artificielle Créez un modèle d'apprentissage en vous référant à cet article. Quand je l'ai déplacé, j'ai obtenu 1 725 616 octets de mnist_cnn.pt.

Construire l'environnement

Si vous avez installé pip, vous pouvez créer l'environnement Flask avec pip install Flask. J'utilise également Pillow (PIL) et PyTorch cette fois, alors installez-les également.

Créer une application Web

La structure des répertoires et des fichiers est la suivante.

├── mnist_cnn.pt… Modèle de reconnaissance des nombres manuscrits
├── predict.py… Le script principal. Télécharger des fichiers et juger des images
├── statique… Placez le fichier téléchargé
│   ├── 20191213210438.png… Le fichier téléchargé ici est enregistré
│   ├── 20191213210253.png
│   └── 20191213210341.png
├── templates… html Où enregistrer le modèle
     ├── index.html

Le contenu de predict.py. Décrit la définition et le chargement de modèles d'apprentissage automatique et le traitement des applications Web. Si vous souhaitez en savoir plus sur la définition du modèle et le prétraitement des images, veuillez consulter les articles suivants. Pytorch × MNIST Handwritten Number Recognition Essayez de prédire l'image PNG comme entrée - Qiita

`predict.py`


#Chargez le module requis
#Flacon lié
from flask import Flask, render_template, request, redirect, url_for, abort

#En relation avec PyTorch
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import datasets, transforms

# Pillow(PIL)、datetime
from PIL import Image, ImageOps
from datetime import datetime

#Définition du modèle
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5, 1)
        self.conv2 = nn.Conv2d(20, 50, 5, 1)
        self.fc1 = nn.Linear(4 * 4 * 50, 500)
        self.fc2 = nn.Linear(500, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2, 2)
        x = x.view(-1, 4 * 4 * 50)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)


device = torch.device("cpu")
model = 0
model = Net().to(device)
#Charger le modèle de formation
model.load_state_dict(
    torch.load("./mnist_cnn.pt", map_location=lambda storage, loc: storage)
)
model = model.eval()

app = Flask(__name__)


@app.route("/", methods=["GET", "POST"])
def upload_file():
    if request.method == "GET":
        return render_template("index.html")
    if request.method == "POST":
        #Enregistrez le fichier téléchargé une fois
        f = request.files["file"]
        filepath = "./static/" + datetime.now().strftime("%Y%m%d%H%M%S") + ".png "
        f.save(filepath)
        #Charger le fichier image
        image = Image.open(filepath)
        #Converti pour être géré par PyTorch(Redimensionner, inversion noir et blanc, normalisation, ajout de dimension)
        image = ImageOps.invert(image.convert("L")).resize((28, 28))
        transform = transforms.Compose(
            [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
        )
        image = transform(image).unsqueeze(0)
        #Faire des prédictions
        output = model(image)
        _, prediction = torch.max(output, 1)
        result = prediction[0].item()

        return render_template("index.html", filepath=filepath, result=result)


if __name__ == "__main__":
    app.run(debug=True)

Le contenu de index.html. Le téléchargement de fichiers et l'affichage des résultats de reconnaissance sont décrits dans ce modèle HTML.

`index.html`


<html>
    <body>
        {% if result %}
          <IMG SRC="{{filepath}} " BORDER="1">Le résultat de la reconnaissance est{{result}}est<BR>
          <HR>
        {% endif %}
Veuillez sélectionner un fichier et envoyer<BR>
        <form action = "./" method = "POST" 
           enctype = "multipart/form-data">
           <input type = "file" name = "file" />
           <input type = "submit"/>
        </form>
     </body>
</html>

Démarrer et vérifier le fonctionnement

Lorsque vous exécutez python predicy.py, le serveur Web de Flask démarre et l'application démarre. À propos, le port par défaut de Flask est 5000. http://localhostかホスト名:5000/でアクセスするとWebアプリケーションが表示されます。 Lorsque vous téléchargez des numéros manuscrits Il affichera le résultat de la reconnaissance. Je peux le reconnaître correctement comme "9".

Résumé

Il semble difficile de créer une application Web qui reconnaît les images à l'aide de l'apprentissage automatique, et cela semble compliqué avec beaucoup de code, mais Flask le rend vraiment facile. Ce n'est pas la fin de la création d'un modèle d'apprentissage automatique, mais je pense que c'est quelque chose que diverses personnes utiliseront. Cependant, s'il est basé sur les commandes, les non-ingénieurs ne peuvent pas l'utiliser et il est difficile d'essayer diverses choses. Dans un tel cas, il est recommandé d'utiliser Flask pour réaliser un prototype rapide.

Python x Flask x PyTorch Construction facile d'une application Web de reconnaissance numérique