Caffe2 - Kurzanleitung

In den letzten Jahren hat sich Deep Learning zu einem großen Trend im maschinellen Lernen entwickelt. Es wurde erfolgreich angewendet, um zuvor unlösbare Probleme in zu lösen Vision, Speech Recognition and Natural Language Processing(NLP). Es gibt viele weitere Bereiche, in denen Deep Learning angewendet wird und die sich als nützlich erwiesen haben.

Caffe (Convolutional Architecture for Fast Feature Embedding) ist ein Deep-Learning-Framework, das bei entwickelt wurde Berkeley Vision and Learning Center (BVLC). Das Caffe-Projekt wurde von Yangqing Jia während seiner Promotion ins Leben gerufen. an der University of California - Berkeley. Caffe bietet eine einfache Möglichkeit, mit tiefem Lernen zu experimentieren. Es ist in C ++ geschrieben und bietet Bindungen fürPython und Matlab.

Es unterstützt viele verschiedene Arten von Deep-Learning-Architekturen wie z CNN (Convolutional Neural Network), LSTM(Langzeit-Kurzzeitgedächtnis) und FC (vollständig verbunden). Es unterstützt die GPU und ist daher ideal für Produktionsumgebungen mit tiefen neuronalen Netzen geeignet. Es unterstützt auch CPU-basierte Kernel-Bibliotheken wieNVIDIA, CUDA Deep Neural Network Bibliothek (cuDNN) und Intel Math Kernel Library (Intel MKL).

Im April 2017 kündigte das in den USA ansässige Social-Networking-Dienstleistungsunternehmen Facebook Caffe2 an, zu dem jetzt RNN (Recurrent Neural Networks) gehört. Im März 2018 wurde Caffe2 in PyTorch fusioniert. Caffe2-Entwickler und Community-Mitglieder haben Modelle zur Lösung verschiedener Probleme erstellt. Diese Modelle stehen der Öffentlichkeit als vorgefertigte Modelle zur Verfügung. Caffe2 hilft den Erstellern bei der Verwendung dieser Modelle und beim Erstellen eines eigenen Netzwerks, um Vorhersagen für den Datensatz zu treffen.

Bevor wir auf die Details von Caffe2 eingehen, lassen Sie uns den Unterschied zwischen verstehen machine learning und deep learning. Dies ist erforderlich, um zu verstehen, wie Modelle in Caffe2 erstellt und verwendet werden.

Maschinelles Lernen v / s Deep Learning

Bei jedem Algorithmus für maschinelles Lernen, sei es ein traditioneller oder ein Deep-Learning-Algorithmus, spielt die Auswahl der Merkmale im Datensatz eine äußerst wichtige Rolle, um die gewünschte Vorhersagegenauigkeit zu erzielen. Bei traditionellen Techniken des maschinellen Lernens ist diefeature selectionwird hauptsächlich durch menschliche Inspektion, Urteilsvermögen und tiefes Domänenwissen durchgeführt. Manchmal können Sie sich an einige getestete Algorithmen für die Funktionsauswahl wenden.

Der traditionelle Ablauf des maschinellen Lernens ist in der folgenden Abbildung dargestellt -

Beim Deep Learning erfolgt die Funktionsauswahl automatisch und ist Teil des Deep Learning-Algorithmus. Dies ist in der folgenden Abbildung dargestellt -

In Deep-Learning-Algorithmen feature engineeringerfolgt automatisch. Im Allgemeinen ist das Feature-Engineering zeitaufwändig und erfordert ein gutes Fachwissen. Um die automatische Merkmalsextraktion zu implementieren, fordern die Deep-Learning-Algorithmen normalerweise eine große Datenmenge an. Wenn Sie also nur Tausende und Zehntausende von Datenpunkten haben, liefert die Deep-Learning-Technik möglicherweise keine zufriedenstellenden Ergebnisse.

Bei größeren Daten liefern die Deep-Learning-Algorithmen im Vergleich zu herkömmlichen ML-Algorithmen bessere Ergebnisse mit dem zusätzlichen Vorteil, dass weniger oder gar keine Features entwickelt werden.

Nachdem Sie einige Einblicke in das tiefe Lernen erhalten haben, lassen Sie uns einen Überblick über Caffe geben.

Ein CNN trainieren

Lassen Sie uns den Prozess zum Trainieren eines CNN zum Klassifizieren von Bildern lernen. Der Prozess besteht aus den folgenden Schritten:

  • Data Preparation- In diesem Schritt beschneiden wir die Bilder mittig und ändern ihre Größe so, dass alle Bilder für Training und Test dieselbe Größe haben. Dies erfolgt normalerweise durch Ausführen eines kleinen Python-Skripts für die Bilddaten.

  • Model Definition- In diesem Schritt definieren wir eine CNN-Architektur. Die Konfiguration wird in gespeichert.pb (protobuf)Datei. Eine typische CNN-Architektur ist in der folgenden Abbildung dargestellt.

  • Solver Definition- Wir definieren die Solver-Konfigurationsdatei. Solver führt die Modelloptimierung durch.

  • Model Training- Wir verwenden das integrierte Caffe-Dienstprogramm, um das Modell zu trainieren. Das Training kann viel Zeit und CPU-Auslastung in Anspruch nehmen. Nach Abschluss des Trainings speichert Caffe das Modell in einer Datei, die später für Testdaten und die endgültige Bereitstellung für Vorhersagen verwendet werden kann.

Was ist neu in Caffe2?

In Caffe2 finden Sie viele gebrauchsfertige vorgefertigte Modelle und nutzen häufig die Community-Beiträge neuer Modelle und Algorithmen. Die von Ihnen erstellten Modelle können mithilfe der GPU-Leistung in der Cloud problemlos skaliert werden und können mit ihren plattformübergreifenden Bibliotheken auch auf die Verwendung von Massen auf Mobilgeräten reduziert werden.

Die in Caffe2 gegenüber Caffe vorgenommenen Verbesserungen lassen sich wie folgt zusammenfassen:

  • Mobile Bereitstellung
  • Neue Hardware-Unterstützung
  • Unterstützung für verteilte Schulungen in großem Maßstab
  • Quantisierte Berechnung
  • Stresstest auf Facebook

Vorgefertigte Modelldemo

Die Website des Berkeley Vision and Learning Center (BVLC) bietet Demos ihrer vorgefertigten Netzwerke. Ein solches Netzwerk zur Bildklassifizierung ist unter dem hier angegebenen Link verfügbarhttps://caffe2.ai/docs/learn-more#null__caffe-neural-network-for-image-classification und ist im folgenden Screenshot dargestellt.

Im Screenshot wird das Bild eines Hundes klassifiziert und mit seiner Vorhersagegenauigkeit gekennzeichnet. Es heißt auch, dass es nur gedauert hat0.068 secondsum das Bild zu klassifizieren. Sie können ein Bild Ihrer Wahl ausprobieren, indem Sie die Bild-URL angeben oder das Bild selbst in den unten auf dem Bildschirm angegebenen Optionen hochladen.

Jetzt, da Sie genügend Einblicke in die Funktionen von Caffe2 haben, ist es Zeit, Caffe2 selbst zu experimentieren. Um die vorgefertigten Modelle zu verwenden oder Ihre Modelle in Ihrem eigenen Python-Code zu entwickeln, müssen Sie zuerst Caffe2 auf Ihrem Computer installieren.

Auf der Installationsseite der Caffe2-Site, die unter dem Link verfügbar ist https://caffe2.ai/docs/getting-started.html Folgendes wird angezeigt, um Ihre Plattform und den Installationstyp auszuwählen.

Wie Sie im obigen Screenshot sehen können, Caffe2 unterstützt mehrere beliebte Plattformen, einschließlich der mobilen.

Jetzt werden wir die Schritte für verstehen MacOS installation an dem alle projekte in diesem tutorial getestet werden.

MacOS-Installation

Es gibt vier Arten der Installation:

  • Vorgefertigte Binärdateien
  • Aus der Quelle erstellen
  • Docker-Bilder
  • Cloud

Wählen Sie je nach Wunsch einen der oben genannten Optionen als Installationstyp aus. Die hier gegebenen Anweisungen beziehen sich auf den Caffe2-Installationsort fürpre-built binaries. Es verwendet Anaconda fürJupyter environment. Führen Sie den folgenden Befehl an Ihrer Konsolenaufforderung aus

pip install torch_nightly -f 
https://download.pytorch.org/whl/nightly/cpu/torch_nightly.html

Darüber hinaus benötigen Sie einige Bibliotheken von Drittanbietern, die mit den folgenden Befehlen installiert werden:

conda install -c anaconda setuptools
conda install -c conda-forge graphviz  
conda install -c conda-forge hypothesis
conda install -c conda-forge ipython
conda install -c conda-forge jupyter
conda install -c conda-forge matplotlib
conda install -c anaconda notebook
conda install -c anaconda pydot
conda install -c conda-forge python-nvd3
conda install -c anaconda pyyaml
conda install -c anaconda requests
conda install -c anaconda scikit-image
conda install -c anaconda scipy

Einige der Tutorials auf der Caffe2-Website erfordern auch die Installation von zeromq, die mit dem folgenden Befehl installiert wird -

conda install -c anaconda zeromq

Windows / Linux-Installation

Führen Sie den folgenden Befehl an Ihrer Konsolenaufforderung aus:

conda install -c pytorch pytorch-nightly-cpu

Wie Sie bemerkt haben müssen, benötigen Sie Anaconda, um die obige Installation zu verwenden. Sie müssen die zusätzlichen Pakete wie in installiert installierenMacOS installation.

Installation testen

Um Ihre Installation zu testen, finden Sie unten ein kleines Python-Skript, das Sie ausschneiden und in Ihr Juypter-Projekt einfügen und ausführen können.

from caffe2.python import workspace
import numpy as np
print ("Creating random data")
data = np.random.rand(3, 2)
print(data)
print ("Adding data to workspace ...")
workspace.FeedBlob("mydata", data)
print ("Retrieving data from workspace")
mydata = workspace.FetchBlob("mydata")
print(mydata)

Wenn Sie den obigen Code ausführen, sollte die folgende Ausgabe angezeigt werden:

Creating random data
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]
Adding data to workspace ...
Retrieving data from workspace
[[0.06152718 0.86448082]
[0.36409966 0.52786113]
[0.65780886 0.67101053]]

Der Screenshot der Installationstestseite wird hier als Kurzreferenz angezeigt -

Nachdem Sie Caffe2 auf Ihrem Computer installiert haben, fahren Sie mit der Installation der Lernprogrammanwendungen fort.

Tutorial Installation

Laden Sie die Quelle der Tutorials mit dem folgenden Befehl auf Ihrer Konsole herunter:

git clone --recursive https://github.com/caffe2/tutorials caffe2_tutorials

Nach Abschluss des Downloads finden Sie in der Python mehrere Python-Projekte caffe2_tutorialsOrdner in Ihrem Installationsverzeichnis. Der Screenshot dieses Ordners dient zur schnellen Durchsicht.

/Users/yourusername/caffe2_tutorials

Sie können einige dieser Tutorials öffnen, um zu sehen, was die Caffe2 codesieht aus wie. Die nächsten beiden in diesem Tutorial beschriebenen Projekte basieren größtenteils auf den oben gezeigten Beispielen.

Es ist jetzt an der Zeit, eigene Python-Codierungen vorzunehmen. Lassen Sie uns verstehen, wie man ein vorab trainiertes Modell von Caffe2 verwendet. Später lernen Sie, Ihr eigenes triviales neuronales Netzwerk für das Training Ihres eigenen Datensatzes zu erstellen.

Bevor Sie lernen, ein vorab geschultes Modell in Ihrer Python-Anwendung zu verwenden, überprüfen Sie zunächst, ob die Modelle auf Ihrem Computer installiert sind und über den Python-Code zugänglich sind.

Wenn Sie Caffe2 installieren, werden die vorab trainierten Modelle in den Installationsordner kopiert. Auf dem Computer mit Anaconda-Installation sind diese Modelle im folgenden Ordner verfügbar.

anaconda3/lib/python3.7/site-packages/caffe2/python/models

Überprüfen Sie den Installationsordner auf Ihrem Computer auf das Vorhandensein dieser Modelle. Sie können versuchen, diese Modelle mit dem folgenden kurzen Python-Skript aus dem Installationsordner zu laden:

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

Wenn das Skript erfolgreich ausgeführt wird, wird die folgende Ausgabe angezeigt:

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

Dies bestätigt, dass die squeezenet Das Modul ist auf Ihrem Computer installiert und für Ihren Code zugänglich.

Jetzt können Sie Ihren eigenen Python-Code für die Bildklassifizierung mit Caffe2 schreiben squeezenet vorgeübtes Modul.

In dieser Lektion lernen Sie, ein vorab trainiertes Modell zu verwenden, um Objekte in einem bestimmten Bild zu erkennen. Du wirst benutzensqueezenet vorab trainiertes Modul, das die Objekte in einem bestimmten Bild mit großer Genauigkeit erkennt und klassifiziert.

Öffne ein neues Juypter notebook und befolgen Sie die Schritte zum Entwickeln dieser Bildklassifizierungsanwendung.

Bibliotheken importieren

Zuerst importieren wir die erforderlichen Pakete mit dem folgenden Code:

from caffe2.proto import caffe2_pb2
from caffe2.python import core, workspace, models
import numpy as np
import skimage.io
import skimage.transform
from matplotlib import pyplot
import os
import urllib.request as urllib2
import operator

Als nächstes haben wir einige eingerichtet variables - -

INPUT_IMAGE_SIZE = 227
mean = 128

Die für das Training verwendeten Bilder haben offensichtlich unterschiedliche Größen. Alle diese Bilder müssen für ein genaues Training in eine feste Größe konvertiert werden. Ebenso müssen die Testbilder und das Bild, das Sie in der Produktionsumgebung vorhersagen möchten, in die Größe konvertiert werden, die der während des Trainings verwendeten entspricht. Daher erstellen wir eine oben genannte VariableINPUT_IMAGE_SIZE Wert haben 227. Daher werden wir alle unsere Bilder in die Größe konvertieren227x227 bevor Sie es in unserem Klassifikator verwenden.

Wir deklarieren auch eine Variable namens mean Wert haben 128, die später zur Verbesserung der Klassifizierungsergebnisse verwendet wird.

Als nächstes werden wir zwei Funktionen zur Verarbeitung des Bildes entwickeln.

Bildverarbeitung

Die Bildverarbeitung besteht aus zwei Schritten. Die erste besteht darin, die Größe des Bildes zu ändern, und die zweite darin, das Bild zentral zuzuschneiden. Für diese beiden Schritte werden zwei Funktionen zum Ändern der Größe und zum Zuschneiden geschrieben.

Bildgröße ändern

Zuerst schreiben wir eine Funktion zum Ändern der Bildgröße. Wie bereits erwähnt, ändern wir die Größe des Bildes auf227x227. Definieren wir also die Funktionresize wie folgt -

def resize(img, input_height, input_width):

Wir erhalten das Seitenverhältnis des Bildes, indem wir die Breite durch die Höhe teilen.

original_aspect = img.shape[1]/float(img.shape[0])

Wenn das Seitenverhältnis größer als 1 ist, bedeutet dies, dass das Bild breit ist, dh im Querformat. Wir passen jetzt die Bildhöhe an und geben das verkleinerte Bild mit dem folgenden Code zurück:

if(original_aspect>1):
   new_height = int(original_aspect * input_height)
   return skimage.transform.resize(img, (input_width,
   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Wenn das Seitenverhältnis ist less than 1zeigt es die portrait mode. Wir passen die Breite jetzt mit dem folgenden Code an:

if(original_aspect<1):
   new_width = int(input_width/original_aspect)
   return skimage.transform.resize(img, (new_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Wenn das Seitenverhältnis gleich ist 1Wir nehmen keine Höhen- / Breitenanpassungen vor.

if(original_aspect == 1):
   return skimage.transform.resize(img, (input_width,
   input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Der vollständige Funktionscode dient unten als Kurzreferenz -

def resize(img, input_height, input_width):
   original_aspect = img.shape[1]/float(img.shape[0])
   if(original_aspect>1):
      new_height = int(original_aspect * input_height)
      return skimage.transform.resize(img, (input_width,
	   new_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect<1):
         new_width = int(input_width/original_aspect)
         return skimage.transform.resize(img, (new_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)
   if(original_aspect == 1):
         return skimage.transform.resize(img, (input_width,
         input_height), mode='constant', anti_aliasing=True, anti_aliasing_sigma=None)

Wir werden nun eine Funktion zum Zuschneiden des Bildes um seine Mitte schreiben.

Bildausschnitt

Wir erklären das crop_image Funktion wie folgt -

def crop_image(img,cropx,cropy):

Wir extrahieren die Abmessungen des Bildes mit der folgenden Anweisung:

y,x,c = img.shape

Wir erstellen einen neuen Ausgangspunkt für das Bild mit den folgenden zwei Codezeilen:

startx = x//2-(cropx//2)
starty = y//2-(cropy//2)

Schließlich geben wir das zugeschnittene Bild zurück, indem wir ein Bildobjekt mit den neuen Dimensionen erstellen -

return img[starty:starty+cropy,startx:startx+cropx]

Der gesamte Funktionscode dient unten als Kurzreferenz -

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]

Jetzt werden wir Code schreiben, um diese Funktionen zu testen.

Bild verarbeiten

Kopieren Sie zunächst eine Bilddatei in images Unterordner in Ihrem Projektverzeichnis. tree.jpgDatei wird in das Projekt kopiert. Der folgende Python-Code lädt das Bild und zeigt es auf der Konsole an:

img = skimage.img_as_float(skimage.io.imread("images/tree.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')

Die Ausgabe ist wie folgt -

Beachten Sie, dass die Größe des Originalbilds beträgt 600 x 960. Wir müssen dies an unsere Spezifikation von anpassen227 x 227. Rufen Sie unsere früher definiertenresizeFunktion erledigt diesen Job.

img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')

Die Ausgabe ist wie unten angegeben -

Beachten Sie, dass jetzt die Bildgröße ist 227 x 363. Wir müssen das beschneiden227 x 227für den endgültigen Feed zu unserem Algorithmus. Zu diesem Zweck nennen wir die zuvor definierte Erntefunktion.

img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')

Unten erwähnt ist die Ausgabe des Codes -

Zu diesem Zeitpunkt hat das Bild eine Größe 227 x 227und ist bereit für die weitere Verarbeitung. Wir tauschen jetzt die Bildachsen aus, um die drei Farben in drei verschiedene Zonen zu extrahieren.

img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)

Unten ist die Ausgabe angegeben -

CHW Image Shape: (3, 227, 227)

Beachten Sie, dass die letzte Achse jetzt die erste Dimension im Array ist. Wir werden nun die drei Kanäle mit dem folgenden Code zeichnen:

pyplot.figure()
for i in range(3):
   pyplot.subplot(1, 3, i+1)
   pyplot.imshow(img[i])
   pyplot.axis('off')
   pyplot.title('RGB channel %d' % (i+1))

Die Ausgabe ist unten angegeben -

Schließlich führen wir einige zusätzliche Verarbeitungen für das Bild durch, z. B. das Konvertieren Red Green Blue zu Blue Green Red (RGB to BGR)Entfernen des Mittelwerts für bessere Ergebnisse und Hinzufügen der Achse für die Stapelgröße mithilfe der folgenden drei Codezeilen:

# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)

Zu diesem Zeitpunkt befindet sich Ihr Bild in NCHW formatund ist bereit für die Einspeisung in unser Netzwerk. Als nächstes laden wir unsere vorab trainierten Modelldateien und geben das obige Bild zur Vorhersage ein.

Vorhersagen von Objekten im verarbeiteten Bild

Wir richten zuerst die Pfade für die ein init und predict Netzwerke, die in den vorgefertigten Modellen von Caffe definiert sind.

Festlegen von Modelldateipfaden

Denken Sie aus unserer früheren Diskussion daran, dass alle vorgefertigten Modelle in der installiert sind modelsMappe. Wir richten den Pfad zu diesem Ordner wie folgt ein:

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")

Wir haben den Weg zum init_net Protobuf-Datei der squeezenet Modell wie folgt -

INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')

Ebenso haben wir den Weg zum predict_net protobuf wie folgt -

PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')

Wir drucken die beiden Pfade zu Diagnosezwecken -

print(INIT_NET)
print(PREDICT_NET)

Der obige Code zusammen mit der Ausgabe dient hier als Kurzreferenz -

CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)

Die Ausgabe wird unten erwähnt -

/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/init_net.pb
/anaconda3/lib/python3.7/site-packages/caffe2/python/models/squeezenet/predict_net.pb

Als nächstes erstellen wir einen Prädiktor.

Prädiktor erstellen

Wir lesen die Modelldateien mit den folgenden zwei Anweisungen:

with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()

Der Prädiktor wird erstellt, indem Zeiger auf die beiden Dateien als Parameter an die übergeben werden Predictor Funktion.

p = workspace.Predictor(init_net, predict_net)

Das pObjekt ist der Prädiktor, der zum Vorhersagen der Objekte in einem bestimmten Bild verwendet wird. Beachten Sie, dass jedes Eingabebild im NCHW-Format vorliegen muss, wie wir es zuvor getan habentree.jpg Datei.

Objekte vorhersagen

Das Vorhersagen der Objekte in einem bestimmten Bild ist trivial - nur eine einzige Befehlszeile ausführen. Wir nennenrun Methode auf der predictor Objekt für eine Objekterkennung in einem bestimmten Bild.

results = p.run({'data': img})

Die Vorhersageergebnisse sind jetzt in der verfügbar results Objekt, das wir zur besseren Lesbarkeit in ein Array konvertieren.

results = np.asarray(results)

Drucken Sie die Abmessungen des Arrays zum besseren Verständnis mit der folgenden Anweisung:

print("results shape: ", results.shape)

Die Ausgabe ist wie unten gezeigt -

results shape: (1, 1, 1000, 1, 1)

Wir werden jetzt die unnötige Achse entfernen -

preds = np.squeeze(results)

Die oberste Prädikation kann jetzt abgerufen werden, indem Sie die nehmen max Wert in der preds Array.

curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)

Die Ausgabe ist wie folgt -

Prediction: 984
Confidence: 0.89235985

Wie Sie sehen, hat das Modell ein Objekt mit einem Indexwert vorhergesagt 984 mit 89%Vertrauen. Der Index von 984 macht für uns wenig Sinn, um zu verstehen, welche Art von Objekt erkannt wird. Wir müssen den stringifizierten Namen für das Objekt anhand seines Indexwerts ermitteln. Die Art der Objekte, die das Modell zusammen mit den entsprechenden Indexwerten erkennt, ist in einem Github-Repository verfügbar.

Nun werden wir sehen, wie der Name für unser Objekt mit dem Indexwert 984 abgerufen wird.

Stringifizierendes Ergebnis

Wir erstellen ein URL-Objekt für das Github-Repository wie folgt:

codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac0
71eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"

Wir lesen den Inhalt der URL -

response = urllib2.urlopen(codes)

Die Antwort enthält eine Liste aller Codes und deren Beschreibungen. Nachfolgend sind einige Zeilen der Antwort aufgeführt, damit Sie verstehen, was sie enthält.

5: 'electric ray, crampfish, numbfish, torpedo',
6: 'stingray',
7: 'cock',
8: 'hen',
9: 'ostrich, Struthio camelus',
10: 'brambling, Fringilla montifringilla',

Wir iterieren nun das gesamte Array, um unseren gewünschten Code von 984 mit a zu finden for Schleife wie folgt -

for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

Wenn Sie den Code ausführen, wird die folgende Ausgabe angezeigt:

Model predicts rapeseed with 0.89235985 confidence

Sie können das Modell jetzt auf einem anderen Bild ausprobieren.

Vorhersage eines anderen Bildes

Um ein anderes Bild vorherzusagen, kopieren Sie einfach die Bilddatei in das imagesOrdner Ihres Projektverzeichnisses. Dies ist das Verzeichnis, in dem unsere früherentree.jpgDatei wird gespeichert. Ändern Sie den Namen der Bilddatei im Code. Wie unten gezeigt, ist nur eine Änderung erforderlich

img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)

Das Originalbild und das Vorhersageergebnis sind unten dargestellt -

Die Ausgabe wird unten erwähnt -

Model predicts pretzel with 0.99999976 confidence

Wie Sie sehen, kann das vorab trainierte Modell Objekte in einem bestimmten Bild mit großer Genauigkeit erkennen.

Vollständige Quelle

Die vollständige Quelle für den obigen Code, der ein vorab trainiertes Modell zur Objekterkennung in einem bestimmten Bild verwendet, wird hier als Kurzreferenz angegeben.

def crop_image(img,cropx,cropy):
   y,x,c = img.shape
   startx = x//2-(cropx//2)
   starty = y//2-(cropy//2)
   return img[starty:starty+cropy,startx:startx+cropx]
img = skimage.img_as_float(skimage.io.imread("images/pretzel.jpg")).astype(np.float32)
print("Original Image Shape: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Original image')
img = resize(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after resizing: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Resized image')
img = crop_image(img, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
print("Image Shape after cropping: " , img.shape)
pyplot.figure()
pyplot.imshow(img)
pyplot.title('Center Cropped')
img = img.swapaxes(1, 2).swapaxes(0, 1)
print("CHW Image Shape: " , img.shape)
pyplot.figure()
for i in range(3):
pyplot.subplot(1, 3, i+1)
pyplot.imshow(img[i])
pyplot.axis('off')
pyplot.title('RGB channel %d' % (i+1))
# convert RGB --> BGR
img = img[(2, 1, 0), :, :]
# remove mean
img = img * 255 - mean
# add batch size axis
img = img[np.newaxis, :, :, :].astype(np.float32)
CAFFE_MODELS = os.path.expanduser("/anaconda3/lib/python3.7/site-packages/caffe2/python/models")
INIT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'init_net.pb')
PREDICT_NET = os.path.join(CAFFE_MODELS, 'squeezenet', 'predict_net.pb')
print(INIT_NET)
print(PREDICT_NET)
with open(INIT_NET, "rb") as f:
   init_net = f.read()
with open(PREDICT_NET, "rb") as f:
   predict_net = f.read()
p = workspace.Predictor(init_net, predict_net)
results = p.run({'data': img})
results = np.asarray(results)
print("results shape: ", results.shape)
preds = np.squeeze(results)
curr_pred, curr_conf = max(enumerate(preds), key=operator.itemgetter(1))
print("Prediction: ", curr_pred)
print("Confidence: ", curr_conf)
codes = "https://gist.githubusercontent.com/aaronmarkham/cd3a6b6ac071eca6f7b4a6e40e6038aa/raw/9edb4038a37da6b5a44c3b5bc52e448ff09bfe5b/alexnet_codes"
response = urllib2.urlopen(codes)
for line in response:
   mystring = line.decode('ascii')
   code, result = mystring.partition(":")[::2]
   code = code.strip()
   result = result.replace("'", "")
   if (code == str(curr_pred)):
      name = result.split(",")[0][1:]
      print("Model predicts", name, "with", curr_conf, "confidence")

Zu diesem Zeitpunkt wissen Sie, wie Sie ein vorab trainiertes Modell verwenden, um die Vorhersagen für Ihren Datensatz durchzuführen.

Als nächstes lernen Sie, wie Sie Ihre definieren neural network (NN) Architekturen in Caffe2und trainieren Sie sie auf Ihrem Datensatz. Wir werden nun lernen, wie man eine triviale Einzelschicht-NN erstellt.

In dieser Lektion lernen Sie, a zu definieren single layer neural network (NN)in Caffe2 und führen Sie es auf einem zufällig generierten Datensatz aus. Wir werden Code schreiben, um die Netzwerkarchitektur, die Druckeingabe, die Ausgabe, die Gewichte und die Bias-Werte grafisch darzustellen. Um diese Lektion zu verstehen, müssen Sie vertraut seinneural network architectures, es ist terms und mathematics in ihnen verwendet.

Netzwerkarchitektur

Betrachten wir, dass wir eine einzelne Schicht NN bauen möchten, wie in der folgenden Abbildung gezeigt -

Mathematisch wird dieses Netzwerk durch den folgenden Python-Code dargestellt:

Y = X * W^T + b

Wo X, W, b sind Tensoren und Yist die Ausgabe. Wir werden alle drei Tensoren mit zufälligen Daten füllen, das Netzwerk betreiben und die untersuchenYAusgabe. Um das Netzwerk und die Tensoren zu definieren, bietet Caffe2 mehrereOperator Funktionen.

Caffe2-Betreiber

In Caffe2, Operatorist die Grundeinheit der Berechnung. Das Caffe2Operator wird wie folgt dargestellt.

Caffe2 bietet eine vollständige Liste der Betreiber. Für das Netzwerk, das wir derzeit entwerfen, verwenden wir den Operator FC, der das Ergebnis der Übergabe eines Eingabevektors berechnetX in ein vollständig verbundenes Netzwerk mit einer zweidimensionalen Gewichtsmatrix W und einen eindimensionalen Vorspannungsvektor b. Mit anderen Worten, es berechnet die folgende mathematische Gleichung

Y = X * W^T + b

Wo X hat Abmessungen (M x k), W hat Abmessungen (n x k) und b ist (1 x n). Die AusgabeY wird von Dimension sein (M x n), wo M ist die Chargengröße.

Für die Vektoren X und Wwerden wir die verwenden GaussianFillOperator, um einige zufällige Daten zu erstellen. Zur Erzeugung von Vorspannungswertenb, wir werden verwenden ConstantFill Operator.

Wir werden nun unser Netzwerk definieren.

Netzwerk erstellen

Importieren Sie zunächst die erforderlichen Pakete -

from caffe2.python import core, workspace

Definieren Sie als Nächstes das Netzwerk durch Aufrufen core.Net wie folgt -

net = core.Net("SingleLayerFC")

Der Name des Netzwerks wird als angegeben SingleLayerFC. Zu diesem Zeitpunkt wird das Netzwerkobjekt net erstellt. Es enthält bisher keine Schichten.

Tensoren erstellen

Wir werden nun die drei Vektoren erstellen, die von unserem Netzwerk benötigt werden. Zuerst erstellen wir einen X-Tensor durch AufrufenGaussianFill Betreiber wie folgt -

X = net.GaussianFill([], ["X"], mean=0.0, std=1.0, shape=[2, 3], run_once=0)

Das X Vektor hat Dimensionen 2 x 3 mit dem mittleren Datenwert von 0,0 und der Standardabweichung von 1.0.

Ebenso schaffen wir W Tensor wie folgt -

W = net.GaussianFill([], ["W"], mean=0.0, std=1.0, shape=[5, 3], run_once=0)

Das W Vektor ist von Größe 5 x 3.

Schließlich schaffen wir Voreingenommenheit b Matrix der Größe 5.

b = net.ConstantFill([], ["b"], shape=[5,], value=1.0, run_once=0)

Jetzt kommt der wichtigste Teil des Codes und das definiert das Netzwerk selbst.

Netzwerk definieren

Wir definieren das Netzwerk in der folgenden Python-Anweisung:

Y = X.FC([W, b], ["Y"])

Wir nennen FC Operator auf den Eingabedaten X. Die Gewichte sind in angegebenWund Voreingenommenheit in b. Die Ausgabe istY. Alternativ können Sie das Netzwerk mit der folgenden ausführlicheren Python-Anweisung erstellen.

Y = net.FC([X, W, b], ["Y"])

Zu diesem Zeitpunkt wird das Netzwerk einfach erstellt. Bis wir das Netzwerk mindestens einmal ausführen, enthält es keine Daten. Bevor wir das Netzwerk ausführen, werden wir seine Architektur untersuchen.

Netzwerkarchitektur drucken

Caffe2 definiert die Netzwerkarchitektur in einer JSON-Datei, die durch Aufrufen der Proto-Methode für die erstellte Datei überprüft werden kann net Objekt.

print (net.Proto())

Dies erzeugt die folgende Ausgabe -

name: "SingleLayerFC"
op {
   output: "X"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 2
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "W"
   name: ""
   type: "GaussianFill"
   arg {
      name: "mean"
      f: 0.0
   }
   arg {
      name: "std"
      f: 1.0
   }
   arg {
      name: "shape"
      ints: 5
      ints: 3
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   output: "b"
   name: ""
   type: "ConstantFill"
   arg {
      name: "shape"
      ints: 5
   }
   arg {
      name: "value"
      f: 1.0
   }
   arg {
      name: "run_once"
      i: 0
   }
}
op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

Wie Sie in der obigen Auflistung sehen können, werden zuerst die Operatoren definiert X, W und b. Untersuchen wir die Definition vonWals Beispiel. Die Art vonW wird angegeben als GausianFill. Dasmean ist als float definiert 0.0wird die Standardabweichung als float definiert 1.0, und die shape ist 5 x 3.

op {
   output: "W"
   name: "" type: "GaussianFill"
   arg {
      name: "mean" 
	   f: 0.0
   }
   arg { 
      name: "std" 
      f: 1.0
   }
   arg { 
      name: "shape" 
      ints: 5 
      ints: 3
   }
   ...
}

Untersuchen Sie die Definitionen von X und bfür Ihr eigenes Verständnis. Lassen Sie uns abschließend die Definition unseres Single-Layer-Netzwerks betrachten, die hier wiedergegeben wird

op {
   input: "X"
   input: "W"
   input: "b"
   output: "Y"
   name: ""
   type: "FC"
}

Hier ist der Netzwerktyp FC (Vollständig verbunden) mit X, W, b als Eingänge und Yist die Ausgabe. Diese Netzwerkdefinition ist zu ausführlich und für große Netzwerke wird es mühsam, ihren Inhalt zu untersuchen. Glücklicherweise bietet Caffe2 eine grafische Darstellung für die erstellten Netzwerke.

Grafische Darstellung des Netzwerks

Um die grafische Darstellung des Netzwerks zu erhalten, führen Sie das folgende Code-Snippet aus, das im Wesentlichen nur aus zwei Zeilen Python-Code besteht.

from caffe2.python import net_drawer
from IPython import display
graph = net_drawer.GetPydotGraph(net, rankdir="LR")
display.Image(graph.create_png(), width=800)

Wenn Sie den Code ausführen, wird die folgende Ausgabe angezeigt:

Bei großen Netzwerken ist die grafische Darstellung äußerst nützlich beim Visualisieren und Debuggen von Netzwerkdefinitionsfehlern.

Schließlich ist es jetzt Zeit, das Netzwerk auszuführen.

Netzwerk ausführen

Sie führen das Netzwerk aus, indem Sie die RunNetOnce Methode auf der workspace Objekt -

workspace.RunNetOnce(net)

Nachdem das Netzwerk einmal ausgeführt wurde, werden alle unsere zufällig generierten Daten erstellt, in das Netzwerk eingespeist und die Ausgabe wird erstellt. Die Tensoren, die nach dem Ausführen des Netzwerks erstellt werden, werden aufgerufenblobsin Caffe2. Der Arbeitsbereich besteht aus demblobsSie erstellen und speichern im Speicher. Dies ist Matlab ziemlich ähnlich.

Nachdem Sie das Netzwerk ausgeführt haben, können Sie das überprüfen blobs dass der Arbeitsbereich Folgendes enthält print Befehl

print("Blobs in the workspace: {}".format(workspace.Blobs()))

Sie sehen die folgende Ausgabe -

Blobs in the workspace: ['W', 'X', 'Y', 'b']

Beachten Sie, dass der Arbeitsbereich aus drei Eingabeblobs besteht - X, W und b. Es enthält auch den aufgerufenen Ausgabe-BlobY. Lassen Sie uns nun den Inhalt dieser Blobs untersuchen.

for name in workspace.Blobs():
   print("{}:\n{}".format(name, workspace.FetchBlob(name)))

Sie sehen die folgende Ausgabe -

W:
[[ 1.0426593 0.15479846 0.25635982]
[-2.2461145 1.4581774 0.16827184]
[-0.12009818 0.30771437 0.00791338]
[ 1.2274994 -0.903331 -0.68799865]
[ 0.30834186 -0.53060573 0.88776857]]
X:
[[ 1.6588869e+00 1.5279824e+00 1.1889904e+00]
[ 6.7048723e-01 -9.7490678e-04 2.5114202e-01]]
Y:
[[ 3.2709925 -0.297907 1.2803618 0.837985 1.7562964]
[ 1.7633215 -0.4651525 0.9211631 1.6511179 1.4302125]]
b:
[1. 1. 1. 1. 1.]

Beachten Sie, dass die Daten auf Ihrem Computer oder tatsächlich bei jedem Durchlauf des Netzwerks unterschiedlich sind, da alle Eingaben zufällig erstellt werden. Sie haben jetzt erfolgreich ein Netzwerk definiert und auf Ihrem Computer ausgeführt.

In der vorherigen Lektion haben Sie gelernt, ein triviales Netzwerk zu erstellen und es auszuführen und seine Ausgabe zu untersuchen. Der Prozess zum Erstellen komplexer Netzwerke ähnelt dem oben beschriebenen Prozess. Caffe2 bietet eine Vielzahl von Operatoren zum Erstellen komplexer Architekturen. Wir empfehlen Ihnen, die Caffe2-Dokumentation auf eine Liste der Bediener zu überprüfen. Nachdem Sie den Zweck verschiedener Betreiber untersucht haben, können Sie komplexe Netzwerke erstellen und diese schulen. Für das Training des Netzwerks bietet Caffe2 mehrerepredefined computation units- das sind die Betreiber. Sie müssen die geeigneten Betreiber auswählen, um Ihr Netzwerk für die Art von Problem zu schulen, die Sie lösen möchten.

Sobald ein Netzwerk zu Ihrer Zufriedenheit trainiert wurde, können Sie es in einer Modelldatei speichern, die den zuvor trainierten Modelldateien ähnelt. Diese geschulten Modelle können zum Nutzen anderer Benutzer in das Caffe2-Repository aufgenommen werden. Oder Sie setzen das trainierte Modell einfach für Ihre eigene private Produktion ein.

Zusammenfassung

Mit Caffe2, einem Deep-Learning-Framework, können Sie mit verschiedenen Arten von neuronalen Netzen experimentieren, um Ihre Daten vorherzusagen. Die Caffe2-Site bietet viele vorgefertigte Modelle. Sie haben gelernt, eines der vorab trainierten Modelle zum Klassifizieren von Objekten in einem bestimmten Bild zu verwenden. Sie haben auch gelernt, eine neuronale Netzwerkarchitektur Ihrer Wahl zu definieren. Solche benutzerdefinierten Netzwerke können mit vielen vordefinierten Operatoren in Caffe trainiert werden. Ein trainiertes Modell wird in einer Datei gespeichert, die in eine Produktionsumgebung übernommen werden kann.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved