[PYTHON] Erstellen Sie mit Azure Custom Vision explosionsartig ein Bildklassifizierungsmodell und implementieren Sie es mit Flask
Überblick
Während der Lernsitzung erstellte ich eine überwachte Lernwebanwendung unter Verwendung von Bilddaten unter Bezugnahme auf die folgenden Bücher.
Leitfaden zum maschinellen Lernen, um in der Praxis zu lernen
Die erstellte Anwendung lautet wie folgt. URL:https://pokemonclassfication.herokuapp.com/
Wenn Sie ein Pokemon-Bild hochladen, wird das Bild klassifiziert und die geschätzten Pokemon-Informationen werden angezeigt. Wir nutzen Azures Custom Vision für unsere Analysemodelle und Flask für unser Webframework.
Dieser Artikel beschreibt hauptsächlich Folgendes.
- Erstellen Sie mit Google Image Crawler ein Skript zur Erfassung von Bilddaten
- Erstellen Sie mit Custom Vison ein Analysemodell
- Modellvalidierung
- Implementierung unter Verwendung der Custom Vision API
Eine ausführliche Erläuterung der Flask-Implementierung finden Sie im Buch "<a href = "https://www.amazon.co.jp/dp/B07XKXFXCQ/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1". > Leitfaden zur praktischen Nutzung des maschinellen Lernens "und" Offizielle Referenz " Empfohlen zu lesen.
Klicken Sie hier, um den Web-App-Code anzuzeigen: App-Code für die Pokemon-Bildklassifizierung
1. Erstellen Sie mit Google Image Crawler ein Skript zur Erfassung von Bilddaten
Eine große Anzahl von Bildern ist erforderlich, um ein Bildklassifizierungsmodell beim überwachten Lernen zu erstellen. Das manuelle Sammeln von Bildern ist schließlich eine Verschwendung von Arbeit, daher möchte ich es bis zu einem gewissen Grad automatisieren.
- Automatisch gesammelte Bilder und Bilder, die für das Modell nicht nützlich sind, werden aufgenommen, sodass am Ende eine gewisse manuelle Auswahl erforderlich ist.
Das Bildersammlungsskript verwendet den Python-Paket icrawler. Anstatt nur zu sammeln, werden 20% der gesammelten Bilder als Testdaten verwendet, sodass sie in separaten Ordnern gesammelt werden. Der verwendete Code lautet wie folgt.
collect_img_poke.py
import os
import glob
import random
import shutil
from icrawler.builtin import GoogleImageCrawler
#Stammverzeichnis zum Speichern von Bildern
root_dir = 'pokemon/'
#Pokemon-Bildsuchschlüsselwortliste
pokemonnames = ['Pikachu','Zenigame','Menschliche Eidechse','Fushigidane','Cavigon']
#Anzahl der gesammelten Bilddaten
data_count = 100
for pokemonname in pokemonnames:
crawler = GoogleImageCrawler(storage={'root_dir':root_dir + pokemonname + '/train'})
filters = dict(
size = 'large',
type = 'photo'
)
#Crawlen durchführen
crawler.crawl(
keyword=pokemonname,
filters=filters,
max_num=data_count
)
#Löschen Sie alle Dateien, wenn das Testverzeichnis aus dem letzten Lauf vorhanden ist
if os.path.isdir(root_dir + pokemonname + '/test'):
shutil.rmtree(root_dir + pokemonname + '/test')
os.makedirs(root_dir + pokemonname + '/test')
#Holen Sie sich eine Liste der Download-Dateien
filelist = glob.glob(root_dir + pokemonname + '/train/*')
#Extrahieren Sie 20% der Anzahl der Downloads als Testdaten
test_ratio = 0.2
testfiles = random.sample(filelist, int(len(filelist) * test_ratio))
for testfile in testfiles:
shutil.move(testfile, root_dir + pokemonname + '/test/')
Das Obige ist Leitfaden zum maschinellen Lernen, um in der Praxis zu lernen Es ist fast das gleiche wie der in beschriebene Inhalt. Dieser Code allein funktioniert jedoch ab dem 13. September 2020 nicht mehr.
Es scheint, dass die Ursache darin besteht, dass sich die API der Google-Bildsuche geändert hat. Hier ist eine Problemumgehung dafür. Referenz: Google Crawler ist nicht verfügbar # 65
Es scheint, dass die Analysemethode von /icrawler/builtin/google.py wie folgt geändert werden sollte. Der auskommentierte Inhalt ist der Inhalt vor der Änderung.
def parse(self, response):
soup = BeautifulSoup(
response.content.decode('utf-8', 'ignore'), 'lxml')
#image_divs = soup.find_all('script')
image_divs = soup.find_all(name='script')
for div in image_divs:
#txt = div.text
txt = str(div)
#if not txt.startswith('AF_initDataCallback'):
if 'AF_initDataCallback' not in txt:
continue
if 'ds:0' in txt or 'ds:1' not in txt:
continue
#txt = re.sub(r"^AF_initDataCallback\({.*key: 'ds:(\d)'.+data:function\(\){return (.+)}}\);?$",
# "\\2", txt, 0, re.DOTALL)
#meta = json.loads(txt)
#data = meta[31][0][12][2]
#uris = [img[1][3][0] for img in data if img[0] == 1]
uris = re.findall(r'http.*?\.(?:jpg|png|bmp)', txt)
return [{'file_url': uri} for uri in uris]
Sie können das Verzeichnis, in dem icrawler tatsächlich vorhanden ist, mit der folgenden Methode überprüfen.
>>import icrawler
>>icrawler.__path__
['/~~~~~~~~/python3.7/site-packages/icrawler']
Ich denke übrigens, es hat die folgende Hierarchie.
├── pokemon
│ ├ Pikachu
│ │ ├── test
│ │ └── train
│ ├ Menschliche Eidechse
│ │ ├── test
│ │ └── train
│ ├ Zenigame
│ │ ├── test
│ │ └── train
│ ├ Fushigidane
│ │ ├── test
│ │ └── train
│ └ Cavigon
│ ├── test
│ └── train
│
└── collect_img_poke.py
2. Erstellen Sie mit Custom Vison ein Analysemodell
Custom Vision ist einer der Azure-Dienste, mit denen Sie Modelle zur Analyse der Bildklassifizierung ohne Programmierung erstellen können. Ein weiteres Feature ist, dass es einfach ist, als API zu veröffentlichen. Um dies nutzen zu können, benötigen Sie ein Azure-Abonnement. Sie können es einen Monat lang kostenlos nutzen. Azure-Registrierung Custom Vision Portal
Im Folgenden finden Sie Informationen zum Erstellen von Custom Vision mit GUI. Schnellstart: Erstellen eines Klassifikators mit benutzerdefinierter Vision
Im Folgenden finden Sie die einfachen Schritte nach der Anmeldung beim Custom Vision-Portal.
- Wählen Sie Neues Projekt, um Ihr erstes Projekt zu erstellen. Das Dialogfeld Neues Projekt erstellen wird angezeigt. Beachten Sie die Einstellungen für das Textfeld und die folgenden Einstellungen für die Kontrollkästchen.
-
Klicken Sie auf Bild hinzufügen.
-
Kennzeichnen Sie das Bild und laden Sie es hoch. Dieses Mal lade ich Bilder von Pikachu, Hitokage, Zenigame, Fushigidane und Kavigon hoch.
- Klicken Sie in der oberen rechten Ecke auf Train, wählen Sie Quick Training und klicken Sie dann im modalen Fenster auf Train.
Die Bildklassifizierungsanwendung wird durch das obige Verfahren erstellt. Die Informationen des Konstruktionsmodells lauten wie folgt.
Die Genauigkeit ist diesmal nicht gut, da die automatisch gesammelten Bilder ohne Prüfung hochgeladen werden. Wenn Sie die Genauigkeit verbessern möchten, überprüfen Sie bitte die automatisch gesammelten Bilder. Vielleicht sind Pikachu und Leute, die cosplayen, gemischt.
-
Klicken Sie dann einfach oben links auf die Schaltfläche Veröffentlichen. Dieses Analysemodell wird als API im Web veröffentlicht.
-
Klicken Sie auf die Vorhersage-URL, um Informationen zum Herstellen einer Verbindung zur API zu erhalten.
Dieses Mal verwenden wir zum Hochladen und Verwenden des Bildes die unten im Bild beschriebene URL und den Vorhersageschlüssel.
Die Funktion von Azure Custom Vision besteht darin, dass Sie mit dem oben beschriebenen Verfahren auf einfache Weise ein Bildklassifizierungsmodell erstellen und es als API im Web veröffentlichen können.
3. Modellvalidierung
Lassen Sie das Konstruktionsmodell das für den Test heruntergeladene Bild analysieren und die Genauigkeitsrate überprüfen. Erstellen Sie die folgenden Dateien in derselben Hierarchie wie collect_img_poke.py. Führen Sie die Datei aus, nachdem Sie die öffentliche URL und den Schlüssel des erstellten Modells festgelegt haben.
predictions_poke_test.py
import glob
import requests
import json
base_url = '<API URL>'
prediction_key = '<Key>'
poke_root_dir = 'pokemon/'
#Liste der zu überprüfenden Pokemon-Namen
pokemonnames = ['Pikachu','Zenigame','Menschliche Eidechse','Fushigidane','Cavigon']
for pokename in pokemonnames:
testfiles = glob.glob(poke_root_dir + pokename + '/test/*')
data_count = len(testfiles)
true_count = 0
for testfile in testfiles:
headers = {
'Content-Type': 'application/json',
'Prediction-Key': prediction_key
}
params = {}
predicts = {}
data = open(testfile, 'rb').read()
response = requests.post(base_url, headers=headers, params=params, data=data)
results = json.loads(response.text)
try:
#Schleife um die Anzahl der Tags im Vorhersageergebnis
for prediction in results['predictions']:
#Speichern Sie das vorhergesagte Pokémon in Verbindung mit seiner Wahrscheinlichkeit
predicts[prediction['tagName']] = prediction['probability']
#Wählen Sie das Pokémon mit der höchsten Wahrscheinlichkeit als Vorhersageergebnis
prediction_result = max(predicts, key=predicts.get)
#Erhöhen Sie die Anzahl der richtigen Antworten, wenn die Vorhersageergebnisse übereinstimmen
if pokename == prediction_result:
true_count += 1
#Bildgröße>Drücken Sie bei 6 MB, bis Sie einen Fehler im Custom Vision-Limit erhalten.
except KeyError:
data_count -= 1
continue
#Berechnung der richtigen Antwortrate
accuracy = (true_count / data_count) * 100
print('Pokemon Name:' + pokename)
print('Richtige Antwortrate:' + str(accuracy) + '%')
Es ist in Ordnung, wenn das folgende Ergebnis ausgegeben wird. Die Genauigkeit des Modells ist gering, aber Sie treffen wahrscheinlich eine grobe Beurteilung anhand der Farbe.
>>>python predictions_poke_test.py
Pokemon Name:Pikachu
Richtige Antwortrate:95.45454545454545%
Pokemon Name:Zenigame
Richtige Antwortrate:95.23809523809523%
Pokemon Name:Menschliche Eidechse
Richtige Antwortrate:81.81818181818183%
Pokemon Name:Fushigidane
Richtige Antwortrate:85.0%
Pokemon Name:Cavigon
Richtige Antwortrate:95.83333333333334%
4. Implementierung unter Verwendung der Custom Vision API
Diese App ist in Flask implementiert. Der Umriss der App ist unten dargestellt.
Mit der Web-App können Sie das hochgeladene Bild mit Custom Vision analysieren und das Analyseergebnis abrufen. Aus dem Analyseergebnis werden detaillierte Informationen in der Datenbank erfasst, und diese Informationen werden in HTML eingebettet und auf dem Bildschirm angezeigt. Dieses MTV-Modell wird von Flask und Django verwendet. Weitere Informationen zu Flask finden Sie unter " Handbuch zur praktischen Anwendung des maschinellen Lernens" </ Überprüfen Sie "a>" und " Offizielle Referenz ". Hier beschreiben wir von der Zusammenarbeit mit Cusom Vision entsprechend ② bis ⑤ in der Abbildung bis zur Erfassung von DB-Informationen.
Klicken Sie hier, um den vollständigen Code anzuzeigen: Pokemon Image Classification App-Code
Unten ist der entsprechende Code.
models.py
import flaski.database
import requests
import json
import os
base_url = '<API URL>'
prediction_key = '<Key>'
POKEMON_FOLDER = './static/images/pokemon/'
#Vorhersagewahrscheinlichkeitsschwelle (Prozent)
threshold = 60
#Holen Sie sich Pokemon-Informationen aus der Datenbank und geben Sie sie im Wörterbuchtyp zurück
def get_pokemon_data(pokemonname):
ses = flaski.database.db_session()
pokemon = flaski.database.Pokemon
pokemon_data = ses.query(pokemon).filter(pokemon.pokemon_name == pokemonname).first()
pokemon_data_dict = {}
if not pokemon_data is None:
pokemon_data_dict['pokemon_name'] = pokemon_data.pokemon_name
pokemon_data_dict['wiki_url'] = pokemon_data.wiki_url
pokemon_data_dict['picture_path'] = os.path.join(POKEMON_FOLDER, pokemon_data.pokemon_name + '.png')
return pokemon_data_dict
#Modell-API aufrufen
def callAPI(uploadFile):
#Vorausschauende Ausführung
headers = {
'Content-Type': 'application/json',
'Prediction-Key': prediction_key
}
params = {}
predicts = {}
data = open(uploadFile, 'rb').read()
response = requests.post(base_url, headers=headers, params=params, data=data)
response_list = json.loads(response.text)
result = []
try:
#Schleife um die Anzahl der Tags im Vorhersageergebnis
for prediction in response_list['predictions']:
if len(get_pokemon_data(prediction['tagName'])) != 0:
#Nehmen Sie eine mit einer Wahrscheinlichkeit an, die größer als der Schwellenwert ist
if prediction['probability'] * 100 > threshold:
result.append(get_pokemon_data(prediction['tagName']))
return result
#Bildgröße>Wenn es 6 MB sind, drücken Sie es zusammen, bis ein Fehler aufgrund der Einschränkung von Custom Vision auftritt.
except KeyError:
return result
Bei der Def-Call-API (uploadFile) wird ein Bild in Custom Vision hochgeladen und Daten erfasst. Dies entspricht fast dem Inhalt des in 3. Modellüberprüfung beschriebenen Skripts. Der Unterschied besteht darin, dass der Vorhersagewahrscheinlichkeitsschwellenwert (Prozentsatz): Schwellenwert so eingestellt ist, dass nur präzisere Informationen erhalten werden können. Im Fall des obigen Codes erhalten wir Informationen zu Pokemon mit einer Genauigkeit von 60% oder mehr.
def get_pokemon_data (pokemonname) ist mit der DB-Tabelle verbunden, die von Flask durch den folgenden Prozess erstellt wurde. Dann werden die Informationen eines bestimmten Pokémon durch den Filterprozess erfasst.
ses = flaski.database.db_session()
pokemon_data = ses.query(pokemon).filter(pokemon.pokemon_name == pokemonname).first()
Auf diese Weise erleichtert Flask das Abrufen von DB-Informationen ohne Verwendung von SQL. Sie können auch DB-Tabellen mit Code erstellen.
Der obige Code wird verwendet, um die Analyseergebnisse von Custom Vision abzurufen. Wie Sie sehen, ist die Entwicklung einer App mit Custom Vision sehr einfach.
Schließlich
Azure Custom Vision war ein guter Ausgangspunkt für die Entwicklung von Apps für maschinelles Lernen, da es das Erstellen von Bildklassifizierungsmodellen erleichtert. Trotz der detaillierten Erklärung in dem Buch, auf das ich mich bezog, war der Grund, warum ich den Artikel schrieb, dass es einen Teil gab, der aufgrund des im letzten Jahr veröffentlichten Buches (Crawler usw.) verschiedene Spezifikationsänderungen nicht bewältigen konnte. Daher beschreibt dieser Artikel die neu implementierten Inhalte. Ich erwähne nicht viel über die Implementierung von Flask, weil es durch das Lesen des Buches verständlich ist.
Ich hoffe, dieser Artikel gibt Ihnen einen flauschigen Überblick über das Erstellen von Apps für maschinelles Lernen.
Recommended Posts