Hallo. In meiner Arbeit bin ich nicht im Ingenieurwesen und es gibt nicht viele Dinge, die ich über das, was ich getan habe, schreiben kann. Jetzt, wo ich etwas Zeit habe, möchte ich zusammenfassen, was ich ein wenig gelernt habe. Adventskalender Ich habe keine Angst! Sie können einen Artikel schreiben, den Sie gerade gemacht haben! Das ist eins ...

Angenommener Leser

Ich habe viel über maschinelles Lernen gehört, aber ich habe die Implementierung nicht so sehr angesprochen, also werde ich darauf eingehen. Die beabsichtigten Leser sind also diejenigen, die das maschinelle Lernen noch nie berührt haben, aber interessiert sind und einen Blick auf die Implementierung des maschinellen Lernens werfen möchten. Erfahrene Menschen haben warme Augen und es wäre hilfreich, wenn Sie auf die Fehler hinweisen könnten: smile_cat:

Thema

Wenn Sie kein leicht verständliches Thema haben, wissen Sie nicht, welches Ziel Sie anstreben sollen, und Sie verlieren sich. Wenn ich diesmal ein Bild gebe, klassifiziere ich, was auf dem Bild zu sehen ist. Lassen Sie uns einen Bildklassifikator erstellen.

Alles ist in Ordnung, aber lassen Sie uns zuerst entscheiden, welche Art von Klassifikator verwendet werden soll. Ich war in letzter Zeit süchtig nach Curry, also werde ich versuchen, einen Gewürzbildklassifikator zu erstellen.

Unser Blog Vielen Dank für Ihre Mitarbeit.

Vorausgesetztes Wissen

Da der Bildklassifizierer ein eingängiges Thema ist, gibt es viele Tutorial-Artikel. Es wird jedoch empfohlen, das Ganze mit den folgenden Artikeln zu verstehen, anstatt ohne vorausgesetzte Kenntnisse mit dem Lesen zu beginnen.

Einführung in neuronale Netze von Grund auf, für die keine mathematischen Kenntnisse erforderlich sind [Verständnis der "Grundlagen neuronaler Netze" - Einführung in Deep Learning | Teil 1](https://www.imagazine.co.jp/%E3%83%8B%E3%83%A5%E3%83 % BC% E3% 83% A9% E3% 83% AB% E3% 83% 8D% E3% 83% 83% E3% 83% 88% E3% 83% AF% E3% 83% BC% E3% 82% AF % E3% 82% 92% E7% 90% 86% E8% A7% A3% E3% 81% 99% E3% 82% 8B% E3% 80% 80% EF% BD% 9E% E3% 83% 87% E3 % 82% A3% E3% 83% BC% E3% 83% 97 /)

Unter dem Referenzlink finden Sie auch Wörter, die wie Fachbegriffe aussehen.

Mach ein Tutorial

Tensorflow (Tensorflow * 1) Wir werden ein Tutorial zum Transferlernen (* 2) machen. Lernen mit TensorFlow Hub übertragen.

Ich habe es gemäß dem Punkt der Version von 2019/12 geschrieben, aber wenn es eine Änderung gibt, hoffe ich, dass Sie es auf eine schöne Weise lesen können. Der Code für jeden Abschnitt wurde neu gedruckt, aber die Ergebnisse sind bis auf einige nicht enthalten. Lesen Sie ihn daher bitte, während Sie ihn selbst ausführen.

(* 1) Tensorflow ist eine der von Google erstellten Bibliotheken für maschinelles Lernen. wiki (* 2) Dies ist eine Methode zum Umleiten eines Modells, das in einer anderen Aufgabe gelernt wurde, als das Lernen auf eine andere Aufgabe zu übertragen. In diesem Fall verbessert sich die Genauigkeit nur, wenn eine relativ große Datenmenge vorbereitet wird. Es scheint, dass es mit einer relativ kleinen Anzahl von Blättern gelöst werden kann. Wenn Sie eine Programmiersprache beherrschen, ist die zweite Beherrschung schneller. Referenz

Setup In diesem Lernprogramm wird Google Colaboratory (im Folgenden: Colab * 3) verwendet. Klicken Sie daher oben auf "In Google Colab ausführen", um es zu aktivieren. Wenn der Colab-Bildschirm geöffnet wird, führen Sie ihn in der Reihenfolge von oben aus. Platzieren Sie den Cursor um [] oben links im Code und Sie sollten die Schaltfläche Ausführen sehen.

from __future__ import absolute_import, division, print_function, unicode_literals

import matplotlib.pylab as plt

import tensorflow as tf

Sie importieren hier verschiedene Bibliotheken. Die Beschreibung von "future .." dient der Aufrechterhaltung der Kompatibilität von Python2-3. import matplotlib.pylab as plt ist eine Bibliothek für Plots, die Sie später verwenden werden.

!pip install -q -U tf-hub-nightly
import tensorflow_hub as hub

from tensorflow.keras import layers

Die Beschreibung von ! Pip install -q -U tf-hub-nightly ist die Installation der Python-Bibliothek. tensorflow_hub ist eine Bibliothek zur Verwendung einer Plattform (Tensorflow Hub), die die Verwendung vorab trainierter Modelle vereinfacht. tensorflow.keras ist eine Bibliothek für maschinelles Lernen, die anscheinend von einem Google-Ingenieur erstellt wurde, aber von anderen als Tensorflow verwendet werden kann.

Es ist erstaunlich, wie einfach es ist, auf einer virtuellen Maschine zu laufen, indem man sie einfach in Text schreibt.

(* 3) Colaboratory ist eine Jupyter-Notebook-Umgebung, die vollständig in der Cloud ausgeführt wird. Es sind keine Einstellungen erforderlich und Sie können es kostenlos verwenden. Mit Colaboratory können Sie Code schreiben und ausführen, Analysen speichern und freigeben, auf leistungsstarke Computerressourcen zugreifen und vieles mehr - alles kostenlos über Ihren Browser. Von Willkommen im Labor

Übrigens, wenn Sie einen solchen Fehler erhalten, sollten Sie dem Support folgen und die [RESTART RUNTIME] -Taste und dann die große Wiedergabetaste drücken.

An ImageNet classifier Es ist ein Punkt, um die Bildklassifizierung unter Verwendung des trainierten Modells zu versuchen.

Download the classifier

classifier_url ="https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2" #@param {type:"string"}

Die URL des trainierten Klassifikators. Wie ich im Tutorial geschrieben habe, spielt es keine Rolle, ob es [das hier platzierte] ist (https://tfhub.dev/s?module-type=image-classification&q=tf2).

IMAGE_SHAPE = (224, 224)

classifier = tf.keras.Sequential([
    hub.KerasLayer(classifier_url, input_shape=IMAGE_SHAPE+(3,))
])

Poke das trainierte Modell als Schicht des neuronalen Netzwerks. Es scheint notwendig zu sein, das Format des gegebenen Bildes anzugeben, also geben Sie es durch (Breite, Höhe, Kanal). Kanal (Anzahl der Farben) 3 wird später hinzugefügt. Hat es eine tiefe Bedeutung?

Run it on a single image Wenn Sie bereit sind, lassen Sie uns mit einem geeigneten Bild unterscheiden.

import numpy as np
import PIL.Image as Image

grace_hopper = tf.keras.utils.get_file('image.jpg','https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg')
grace_hopper = Image.open(grace_hopper).resize(IMAGE_SHAPE)
grace_hopper

[grace_hopper](https://ja.wikipedia.org/wiki/%E3%82%B0%E3%83%AC%E3%83%BC%E3%82%B9%E3%83%BB%E3% 83% 9B% E3% 83% 83% E3% 83% 91% E3% 83% BC) wird erworben.

grace_hopper = np.array(grace_hopper)/255.0
grace_hopper.shape

Es scheint, dass Sie eine Typkonvertierung durchführen.

result = classifier.predict(grace_hopper[np.newaxis, ...])
result.shape

Wenn Sie den Bilddaten eine Dimension hinzufügen und die Vorhersage ausführen, erhalten Sie ein Array von Vektoren mit 1001 Elementen (um genau zu sein, ndarray).

predicted_class = np.argmax(result[0], axis=-1)
predicted_class

Dieses 1001-Element stellt die Wahrscheinlichkeit jeder Klasse dar (in diesem Fall das abgeleitete Element). Nehmen wir also das Element mit der maximalen Wahrscheinlichkeit heraus. Der Wert 653 wird zurückgegeben. Dies ist die Sache, auf die dieser Klassifikator geschlossen hat.

Decodethe predictions

labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')
imagenet_labels = np.array(open(labels_path).read().splitlines())

Laden Sie die Etiketten herunter und packen Sie sie in ein Array, um herauszufinden, was die vorherigen Ergebnisse zeigen. Wie Sie sofort sehen können, indem Sie direkt auf die URL zugreifen, entspricht sie dem zuvor erwähnten Element 1001.

plt.imshow(grace_hopper)
plt.axis('off')
predicted_class_name = imagenet_labels[predicted_class]
_ = plt.title("Prediction: " + predicted_class_name.title())

Verwenden Sie die Bildanzeigebibliothek, um das 653. Bild auszugeben. Das Ergebnis ist Militäruniform. Herzliche Glückwünsche.

Simple transfer learning Ab hier ist die Produktion. Der aktuelle war "Sie können einen trainierten Klassifikator wie diesen verwenden", Als nächstes lautet "Ich werde einen Klassifikator mit den Bildern erstellen, die ich gesammelt habe".

Dataset In diesem Tutorial verwenden wir ein Blumenbild. Lassen Sie uns abschließend diesen Datensatz entsprechend austauschen, um ihn zu einem anderen Klassifikator zu machen.

data_root = tf.keras.utils.get_file(
  'flower_photos','https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
   untar=True)

Datensatz herunterladen

image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255)
image_data = image_generator.flow_from_directory(str(data_root), target_size=IMAGE_SHAPE)

Tauchen Sie in den ImageDataGenarator ein, um die Bilder gut zu verarbeiten. Übrigens können Sie die Klassifizierung von Bildern sehen, indem Sie die Bildgruppe von der obigen URL herunterladen. Es fühlt sich an, als würde man für jedes Verzeichnis bestimmte Bilder sammeln.

for image_batch, label_batch in image_data:
  print("Image batch shape: ", image_batch.shape)
  print("Label batch shape: ", label_batch.shape)
  break

Iterieren Sie image_data, um ein Array aus image_batch und label_batch zu erstellen.

Run the classifier on a batch of images Um mit dem Zustand nach dem Lernen zu vergleichen, klassifizieren wir den nicht gelernten Zustand.

result_batch = classifier.predict(image_batch)
result_batch.shape

Machen wir die gleiche Vorhersage wie zuvor.

predicted_class_names = imagenet_labels[np.argmax(result_batch, axis=-1)]
predicted_class_names

Es gibt 32 Klassifizierungsergebnisse. Überprüfen Sie es mit dem Bild.

plt.figure(figsize=(10,9))
plt.subplots_adjust(hspace=0.5)
for n in range(30):
  plt.subplot(6,5,n+1)
  plt.imshow(image_batch[n])
  plt.title(predicted_class_names[n])
  plt.axis('off')
_ = plt.suptitle("ImageNet predictions")

Bei den Ergebnissen ist das ganz anders. Dies kann daran liegen, dass sie aus 1001 Objekten ausgewählt wurden, aber überhaupt nicht korrekt sind.

Download the headless model Machen wir also unseren eigenen Klassifikator.


feature_extractor_url = "https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2" #@param {type:"string"}

Wie üblich werden wir das trainierte Modell vom Tensorflow-Hub herunterladen. Der Extraktor sieht aus wie ein Extraktor.


feature_extractor_layer = hub.KerasLayer(feature_extractor_url,
                                         input_shape=(224,224,3))

Erstellen Sie eine Ebene, um in das Modell einzutauchen.


feature_batch = feature_extractor_layer(image_batch)
print(feature_batch.shape)

Es werden 1280 Vektoren für jedes Bild zurückgegeben. Sie versuchen, Bilder aus verschiedenen Elementen zu klassifizieren.


feature_extractor_layer.trainable = False

Dieses Mal wird der Extraktor-Teil nicht abgestimmt. Geben Sie ihn daher an, damit er nicht gelernt wird.

Attach a classification head


model = tf.keras.Sequential([
  feature_extractor_layer,
  layers.Dense(image_data.num_classes, activation='softmax')
])

model.summary()

Ich schiebe die Extraktorinstanz, die ich gerade erstellt habe, in den Klassifikator. Sie zeigen auch eine Zusammenfassung des von Ihnen erstellten Modells an.


predictions = model(image_batch)

predictions.shape

Ich überprüfe die Form des Tensors.

Train the model


model.compile(
  optimizer=tf.keras.optimizers.Adam(),
  loss='categorical_crossentropy',
  metrics=['acc'])

Kompilieren Sie das Modell. Optimierer: Es scheint, dass es verschiedene Typen gibt. Referenz Verlust (Verlustfunktion): Eine Funktion, die für das Training verwendet wird, um den Verlust so gering wie möglich zu halten. Dies scheint verschieden zu sein. Referenz Metriken (Bewertungsfunktion): Ein Wert, der zur Bewertung der Leistung eines Modells verwendet wird, jedoch nicht für das Training wie eine Verlustfunktion verwendet wird. Dies scheint auch verschieden zu sein. Referenz

class CollectBatchStats(tf.keras.callbacks.Callback):
  def __init__(self):
    self.batch_losses = []
    self.batch_acc = []

  def on_train_batch_end(self, batch, logs=None):
    self.batch_losses.append(logs['loss'])
    self.batch_acc.append(logs['acc'])
    self.model.reset_metrics()

Es ist eine Funktionsdefinition zur Beobachtung der Werte der Verlustfunktion und der Bewertungsfunktion.

steps_per_epoch = np.ceil(image_data.samples/image_data.batch_size)

batch_stats_callback = CollectBatchStats()

history = model.fit_generator(image_data, epochs=2,
                              steps_per_epoch=steps_per_epoch,
                              callbacks = [batch_stats_callback])

Beginnen Sie mit fit_generator zu lernen. Sie geben die Anzahl der Lernvorgänge usw. an. Referenz Das Lernen wird einige Zeit dauern.

plt.figure()
plt.ylabel("Loss")
plt.xlabel("Training Steps")
plt.ylim([0,2])
plt.plot(batch_stats_callback.batch_losses)

Es ist der Übergang der Verlustfunktion. Es ist gut, dass es allmählich abnimmt.

plt.figure()
plt.ylabel("Accuracy")
plt.xlabel("Training Steps")
plt.ylim([0,1])
plt.plot(batch_stats_callback.batch_acc)

Es ist der Übergang der Bewertungsfunktion. Das ist so, dass es sich gut anfühlt.

Check the predictions Lassen Sie uns endlich klassifizieren.

class_names = sorted(image_data.class_indices.items(), key=lambda pair:pair[1])
class_names = np.array([key.title() for key, value in class_names])
class_names

Nehmen wir eine Klasse, die tatsächlich existiert. Es gibt nur 5 Typen.

predicted_batch = model.predict(image_batch)
predicted_id = np.argmax(predicted_batch, axis=-1)
predicted_label_batch = class_names[predicted_id]

Vorhersage wie zuvor, Abrufen des Maximalwerts und Beschriften.

label_id = np.argmax(label_batch, axis=-1)

Reservieren Sie das richtige Etikett

plt.figure(figsize=(10,9))
plt.subplots_adjust(hspace=0.5)
for n in range(30):
  plt.subplot(6,5,n+1)
  plt.imshow(image_batch[n])
  color = "green" if predicted_id[n] == label_id[n] else "red"
  plt.title(predicted_label_batch[n].title(), color=color)
  plt.axis('off')
_ = plt.suptitle("Model predictions (green: correct, red: incorrect)")

Wenn die Antwort korrekt ist, wird sie in Grün ausgegeben, und wenn sie nicht erfolgreich ist, wird sie in Rot ausgegeben. Ich denke, Sie haben im Allgemeinen Recht. Yosage.

Danach wird das Tutorial noch eine Weile fortgesetzt und der Export des erlernten Modells wird geschrieben. Da dies jedoch das Ende der Verwendung ist, werde ich es von nun an weglassen.

Erstellen Sie Ihren eigenen Klassifikator

Jetzt erstellen wir Ihren eigenen Klassifikator mit dem Code, der im Tutorial veröffentlicht wurde. Dieses Mal werde ich mir ein Ziel setzen, bis es sich auf Colab bewegt.

Bildersammlung

Die Bildersammlung ist für die Bildklassifizierung unerlässlich.

Bild herunterladen

google-images-download ist nützlich. (Achten Sie auf die Lizenz des heruntergeladenen Bildes)

Es kann über pip installiert werden. Wenn Sie also einen Mac verwenden, können Sie es wie folgt verwenden.

pip install google_images_download
googleimagesdownload --keywords "Das Bild, das Sie finden möchten"

Bildsortierung

Wenn Sie versuchen, das heruntergeladene Bild so zu verwenden, wie es ist, gibt es viel Müll und Sie können es nicht verwenden. Entfernen wir also seltsame Bilder, während wir die Bilder einzeln betrachten. Diese Arbeit war die schwerste ..

Am Ende erstellen wir einen Status, in dem für jedes Verzeichnis wie dieses bestimmte saubere Bilder gesammelt werden.

Paket und Upload

Laden Sie die tar-komprimierte Datei vorerst irgendwo hoch, damit sie von Colab heruntergeladen werden kann. Ich habe es auf Google Drive hochgeladen. Laden Sie im Fall von GoogleDrive tar.gz hoch, rufen Sie einen gemeinsam nutzbaren Link ab und ersetzen Sie den ID-Teil durch den folgenden Link. https://drive.google.com/uc?export=download&id=XXXXXXXXXXXXXXXXXXXXX

Reflektiert im Colab-Code

Ich habe eine Colab-Datei vorbereitet, die nur den Teil extrahiert, der den Sortierer hier macht. Ersetzen Sie daher bitte den xxxx-Teil.

Hat es funktioniert?

Es sieht so aus an meiner Hand. image (85).png

abschließend

Ich konnte die Oberseite des maschinellen Lernens erleben, aber ich habe das Gefühl, dass das Bild des Klassifikators möchte, dass die von mir aufgenommenen Bilder klassifiziert werden. Ich möchte etwas schaffen, das sich etwas lockerer anfühlt, indem ich eine Umgebung aufbaue. Ich werde durchhalten.

[PYTHON] Erster Bildklassifikator