[PYTHON] Bilderkennung mit CNN Pferden und Hirschen

Einführung

Als ich zum ersten Mal maschinell lernte, interessierte ich mich für die Bilderkennung und beschloss, es zu versuchen, aber ich fragte mich, welchen Ansatz ich wählen sollte. Daher gab es einen Kurs namens "Bilderkennung mit CNN" von Aidemy, also nahm ich daran teil und entschied mich für CNN.

Das erste, woran ich dachte, war die Klassifizierung von Rennpferden, weil ich Pferderennen mag. Als [Rennpferd = Pferd, auf dem ein Reiter reitet] dachte ich darüber nach, etwas zu machen, das als [Pferd] erkannt werden kann, sei es ein Rennpferd oder ein nacktes Pferd.

** Klassifizierung ist Pferd und Hirsch. ** ** ** Der Grund ist, dass ich beim Sammeln von Pferdebildern auch den CIFAR-10-Datensatz verwendet habe, aber im CIFAR-10 war ein Reh. Ich wollte etwas Ähnliches wie ein Tier ausprobieren, also war es genau richtig.

Inhaltsverzeichnis

1. Bildersammlung
2. Verarbeitung der gesammelten Bilder
3. Bildauffüllung
4. Verwandeln Sie das Bild in Trainings- / Verifizierungsdaten
5. Modellbau und Speichern
6. Grafische Darstellung der Ergebnisse
7. Testen Sie mit einem anderen Bild

Bildersammlung

Das Folgende wurde für die Bildersammlung verwendet.

• Google Images Download
• bing_image_downloader API

Suchwort "Rennpferd" "Rennpferd" "Cheval de Course" ca. 1400 Blatt Suchwort "Hirsch" ca. 800

• Datensatz
• CIFAR-10 Pferd 100 1 Stück
• CIFAR-10 Hirsch 999 Blatt

Verarbeitung gesammelter Bilder

Der Datensatz ist perfekt verarbeitet, sodass wir die Bilder verarbeiten, die wir aus dem Internet aufgenommen haben.

1. Löschen Sie doppelte Bilder

Verwenden Sie Bild-Hash (Phash), um doppelte Bilder zu extrahieren. Ordner mit demselben Bild in ImageHash erkennen Ich habe den hier zitierten und bearbeiteten Code verwendet.

from PIL import Image, ImageFile
import imagehash
import os

#Überspringen Sie keine großen Bilder
ImageFile.LOAD_TRUNCATED_IMAGES = True


#phash Gibt die Differenz zwischen den Hashwerten zweier Bilder aus
def image_hash(img, otherimg):
    #Geben Sie Phash an
    hash = imagehash.phash ( Image.open ( img ) )
    other_hash = imagehash.phash ( Image.open ( otherimg ) )
    return hash - other_hash


#Erkennen Sie die kleinere Bildgröße
def minhash(img, otherimg):
    # (Breite,Höhe)Taple
    hash_size = Image.open ( img ).size
    otherhash_size = Image.open ( otherimg ).size
    if hash_size == otherhash_size:
        return 0
    if hash_size < otherhash_size:
        return 1


#Speichern Sie das Verzeichnis mit den Bildern, die Sie suchen möchten, im folgenden Pfad
default_dir = 'Pfad, in dem das Verzeichnis mit den Bildern gespeichert wird'
#Rufen Sie das Verzeichnis mit den Bildern ab, die Sie nachschlagen möchten
img_dir = os.listdir ( default_dir )
#Rufen Sie den Pfad mit dem Bild ab, das Sie nachschlagen möchten
img_dir_path = os.path.join ( default_dir, img_dir[0] )

#Holen Sie sich eine Liste der Bilder
img_list = os.listdir ( img_dir_path )
#Wenn zwei oder mehr Bilder vorhanden sind, ermitteln Sie den Pfad des Bildes und listen Sie es auf
img_path = [os.path.join ( img_dir_path, i ) for i in img_list
            if len ( os.path.join ( img_dir_path, i ) ) > 2]
#Holen Sie sich die Anzahl der Bilder in einem Ordner
img_list_count = len ( img_list )

i = 0
delete_list = []

# image_hash(),minhash()Vergleichen Sie Bilder nach Ordner mit
while i < img_list_count:
    #Fortschritt
    print ( 'Laufen: ', str ( i + 1 ) + '/' + str ( img_list_count ) )
    # i +Vergleichen Sie nicht dasselbe Bild mit dem im zweiten Vergleich mit 1
    for j in range ( i + 1, img_list_count ):
        #Wenn die Differenz zwischen den Hashwerten 10 oder weniger beträgt, wird sie als dasselbe Bild erkannt.
        if image_hash ( img_path[i], img_path[j] ) < 10:
            print ( img_path[i] + ' | vs | ' + img_path[j] )
            #Wenn die Bildgröße gleich ist, löschen Sie einen Pfad_In Liste speichern
            if minhash ( img_path[i], img_path[j] ) == 0:
                if not img_path[j] in delete_list:
                    delete_list.append ( img_path[i] )
            #Löschen Sie den Pfad mit der kleineren Bildgröße_In Liste speichern
            if minhash ( img_path[i], img_path[j] ) == 1:
                delete_list.append ( img_path[i] )
            j += 1
    i += 1

#Zeigen Sie den Bildpfad an, den Sie löschen möchten
print ( delete_list )


#Zum Öffnen des zu löschenden Bildes
# def open_folder(path):
#     subprocess.run ( 'explorer {}'.format ( path ) )
#
# for i in range ( len ( delete_list ) ):
#     open_folder ( delete_list[i] )


#Wenn Sie mit dem Löschen fortfahren möchten
# for i in delete_list:
#     try:
#         os.remove( i )
#     except OSError :
#         pass

Verweise

Vergleichen Sie die Bildähnlichkeit zwischen ORB und Perceptual Hash mithilfe von Python

Bildähnlichkeit mit Perceptual Hash berechnen

2. Löschen Sie nicht verwandte Bilder und konvertieren Sie Bilder in das RGB-Format

Ich habe die Bilder manuell gelöscht, von denen ich dachte, dass sie nicht zum Lernen verwendet werden können.

Informationen zur Konvertierung in das RGB-Format finden Sie hier. Bilder für maschinelles Lernen vorverarbeiten

Auf diese Weise ist das verarbeitete Bild fertig.

--Pferdeordner Insgesamt ca. 1400 Blatt → 438 Blatt

• Hirschordner Ca. 800 Blatt → 139 Blatt insgesamt

Verwenden Sie das Plusbild CIFAR-10 für das obige Bild.

Bildauffüllung

459 Fotos von Pferd Ordner API aufgenommen, Hirschordner API + CIFAR-10 1138 Blatt Wird mit ImageDataGenerator aufgeblasen.

Sie können das Modell mit fit_generator () und flow () so wie es ist trainieren, diesmal jedoch nur zum einfachen Auffüllen.

Speichern Sie das generierte Image auf Ihrem Laufwerk.

from keras.preprocessing.image import ImageDataGenerator
import os


datagen = ImageDataGenerator(rotation_range=20,  #Zufällig rotierender Drehbereich (Einheit: Grad)
                             width_shift_range=0.2,  #Zufällig parallele Bewegung in horizontaler Richtung, Verhältnis zur Breite des Bildes
                             height_shift_range=0.2,  #Zufällig parallele Bewegung in vertikaler Richtung, Verhältnis zur vertikalen Breite des Bildes
                             shear_range=0.2,  #Scherungsgrad. Durch Erhöhen der Größe wirkt das Bild diagonal gequetschter oder gedehnter (Einheit: Grad).
                             zoom_range=0.2,  #Die Rate, mit der das Bild zufällig komprimiert und vergrößert wird. Mindestens 1-Auf Zoombereich komprimiert, bis zu 1+zoom_Erweitert auf Reichweite
                             horizontal_flip=True)  #Nach dem Zufallsprinzip horizontal drehen

root_dir = './data/padding'  #Pfad mit dem Bildordner, den Sie aufblasen möchten
targetsize = (128, 128)  #Verarbeitungsgröße
save_dir = os.listdir(root_dir)  #Ordnername zum Speichern des aufgeblasenen Bildes
save_path = os.path.join('./data/save', save_dir[0])  #Wo soll das aufgeblasene Bild gespeichert werden?
increase = len(os.listdir(os.path.join(root_dir, save_dir[0])))  #Anzahl der Bilder im Bildordner, die Sie aufblasen möchten
increase_count = 1  #Mit dieser Anzahl von Mustern pro Blatt aufblasen(increase✕increase_Bilder erhöhen sich um die Anzahl der Zählungen)

#Erstellen, wenn das Zielverzeichnis nicht vorhanden ist
if not os.path.exists(save_path):
    os.makedirs(save_path)

# flow_from_directory()Bild, mit dem Sie aufblasen möchten(Ordner)Und verarbeiten und speichern Sie das aufgeblasene Bild gleichzeitig
ffd = datagen.flow_from_directory(
    directory=root_dir,
    target_size=targetsize,
    color_mode='rgb',
    batch_size=increase,
    save_to_dir=save_path)

[next(ffd) for i in range(increase_count)]

Pferdeordner 2000 Blatt 2000 Hirschordner Ist bereit.

Verweise

Keras - Trainingsbilder mit Keras ImageDataGenerator erhöhen Ändern Sie Keras CNN, um ImageDataGenerator zu verstehen classifier_from_little_data_script_1.py [Aufblasen von Trainingsbildern mit Keras ImageDataGenerator](https://intellectual-curiosity.tokyo/2019/07/03/keras%E3%81%AEimagedatagenerator%E3%81%A7%E5%AD%A6% E7% BF% 92% E7% 94% A8% E7% 94% BB% E5% 83% 8F% E3% 82% 92% E6% B0% B4% E5% A2% 97% E3% 81% 97% E3% 81% 99% E3% 82% 8B% E6% 96% B9% E6% B3% 95 /) Image Preprocessing

importieren

Der Import bis zu "Grafik der Ergebnisse" ist wie folgt

#Code zum Ausführen von plaidML mit Karas
import plaidml.keras
plaidml.keras.install_backend()

from sklearn.model_selection import train_test_split
from keras.callbacks import ModelCheckpoint
from keras.layers import Conv2D, MaxPooling2D, Dense, Dropout, Flatten
from keras.models import Sequential
from keras.utils import np_utils
from keras import optimizers
from keras.preprocessing.image import img_to_array, load_img
import keras
import glob
import numpy as np
import matplotlib.pyplot as plt

Verwandeln Sie Bilder in Trainings- / Verifizierungsdaten

• Vereinheitlichen Sie alle Bildgrößen --Anordnung
• Geteilt durch 80% der Trainingsdaten und 20% der Verifizierungsdaten

#Bildverzeichnispfad
root_dir = './data/'
#Name des Bildverzeichnisses
baka = ['horse', 'deer']

X = []  #Liste, in der 2D-Daten von Bildern gespeichert sind
y = []  #Etikette(Richtige Antwort)Liste zum Speichern von Informationen über

for label, img_title in enumerate(baka):
    file_dir = root_dir + img_title
    img_file = glob.glob(file_dir + '/*')
    for i in img_file:
        img = img_to_array(load_img(i, target_size=(128, 128)))
        X.append(img)
        y.append(label)

#4-dimensionale Liste von Numpy-Arrays(*, 244, 224, 3)
X = np.asarray(X)
y = np.asarray(y)

#Konvertieren Sie Pixelwerte von 0 in 1
X = X.astype('float32') / 255.0
#Beschriften Sie Eins-In Hot Label konvertieren
y = np_utils.to_categorical(y, 2)

#Teilen Sie die Daten
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=0)
xy = (X_train, X_test, y_train, y_test)
# .Speichern Sie mit npy
np.save('./npy/train.npy', xy)
#Bilddaten zum Lernen(Zeilenhöhe),Spaltenbreite),Farbe (3))Bestätigung von(Eingabeebeneneingabe_Gleich wie Form)
print('3D:', X_train.shape[1:])

Modellbau und Sparen

Dieser Teil ist Versuch und Irrtum Verwenden Sie ModelCheckpoint in den Rückrufen von model.fit (), um das Modell für jede Epoche zu speichern. Schließlich bleibt das gesamte Modell, wenn val_loss der Mindestwert ist, im hdf5-Format. Modelle und Grafiken sind ** diejenigen mit der höchsten Genauigkeitsrate im Abschlusstest. ** ** **

#Eingabeebene,Versteckte Ebene(Aktivierungsfunktion:relu)
model.add ( Conv2D ( 32, (3, 3), activation='relu', padding='same', input_shape=X_train.shape[1:] ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Conv2D ( 32, (3, 3), activation='relu', padding='same' ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Conv2D ( 64, (3, 3), activation='relu' ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Conv2D ( 128, (3, 3), activation='relu' ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Flatten () )
model.add ( Dense ( 512, activation='relu' ) )
model.add ( Dropout ( 0.5 ) )

#Ausgabeschicht(2 Klassenklassifikation)(Aktivierungsfunktion:softmax)
model.add ( Dense ( 2, activation='softmax' ) )

#Kompilieren (Lernrate:1e-3, Verlustfunktion: kategorisch_Crossentropie, Optimierungsalgorithmus: RMSprop, Bewertungsfunktion: Genauigkeit(Richtige Antwortrate)）
rms = optimizers.RMSprop ( lr=1e-3 )
model.compile ( loss='categorical_crossentropy',
                optimizer=rms,
                metrics=['accuracy'] )

#Modell-Epoche lernen
epoch = 50
#Pfad zum Speichern des Modells
fpath = f'./model/model.{epoch:02d}-.h5'
#Überprüfen Sie, ob Sie das Modell für jede Epoche speichern möchten
mc = ModelCheckpoint (
    filepath=fpath,
    monitor='val_loss',  #Was, um die Bewertung zu überprüfen
    verbose=1,
    save_best_only=True,  # val_Das neueste optimale Verlustmodell wird nicht überschrieben
    save_weights_only=False,  #Wenn False, speichern Sie das gesamte Modell
    mode='min',  #Das Ziel der Prüfung ist val_Da es sich um einen Verlust handelt, geben Sie das Minimum an
    period=1 )  #Zu überprüfendes Epochenintervall

#Lernen Sie mit dem gebauten Modell
history = model.fit (
    X_train,
    y_train,
    batch_size=64,
    epochs=epoch,
    callbacks=[mc],
    validation_data=(X_test, y_test) )

Grafische Darstellung der Ergebnisse

Die in der Grafik angezeigte Zahl ist nicht die Zahl in model.h5, sondern die Zahl in der letzten Epoche.

#Visualisierung
fig = plt.figure(figsize=(18, 6))  #Fenstererstellung

#Richtiges Antwortraten-Diagramm
plt.subplot(1, 2, 1)  #Zeigen Sie zwei nebeneinander auf der rechten Seite an
plt.plot(history.history['acc'], label='acc', ls='-', marker='o')  #Genauigkeit der Trainingsdaten
plt.plot(history.history['val_acc'], label='val_acc', ls='-', marker='x')  #Genauigkeit der Trainingsdaten
plt.title(f'Training and validation accuracy \n val_acc {score[1]:.4f}')  #Titel
plt.xlabel('epoch')  #Horizontale Achse
plt.ylabel('accuracy')  #Vertikale Achse
plt.legend(['acc', 'val_acc'])  #Gebrauchsanweisung
plt.grid(color='gray', alpha=0.2)  #Rasteranzeige

#Verlustdiagramm
plt.subplot(1, 2, 2)  #Zeigen Sie zwei nebeneinander auf der linken Seite an
plt.plot(
    history.history['loss'], label='loss', ls='-', marker='o')  #Verlust von Trainingsdaten
plt.plot(history.history['val_loss'], label='val_loss', ls='-', marker='x')  #Verlust von Trainingsdaten
plt.title(f'Training and validation loss \n val_loss {score[0]:.4f}')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['loss', 'val_loss'])
plt.grid(color='gray', alpha=0.2)

#sparen
plt.savefig('1.png')

plt.show()

Gespeichertes Modell

Epoch 15/50 ･ ･ ･ ･ ･ ･ 3200/3200 [==============================] - 122s 38ms/step - loss: 0.1067 - acc: 0.9625 - val_loss: 0.1872 - val_acc: 0.9363

Weil der Graph nicht stabil ist Epoche 15 hat den minimalen Wert für val_loss erreicht. val_loss: 0.1872 - val_acc: 0.9363

Es ist möglich, dass die Lernrate hoch und die Anzahl der Daten gering ist. In der zweiten Hälfte kommt es zu Überlernen.

Auf dieser Grundlage basierende Verbesserungen werden am Ende dieses Artikels unter "** Versucht **" beschrieben. Infolgedessen hat es nicht funktioniert ...

Test mit einem anderen Bild

Bereiten Sie ein völlig anderes Bild vor und unterscheiden Sie es anhand des gespeicherten Modells.

#Code zum Ausführen von plaidML mit Karas
import plaidml.keras
plaidml.keras.install_backend()

from keras.preprocessing.image import img_to_array, load_img
from keras.models import load_model
import numpy as np
import glob


#Modelldatenpfad
hdf_path = './model/model.20-val_loss 0.2648 - val_acc 0.8793.h5'
#Modell laden
model = load_model(hdf_path)

#Verzeichnis mit zu testenden Bildern
img_path = './baka/'
#Holen Sie sich 14 Bilder
img_list = glob.glob(img_path + '*')
size = (128, 128, 3)

for index, i in enumerate(img_list):
    #Ändern Sie die Größe und laden Sie Bilder und ordnen Sie sie an
    test_img = img_to_array(load_img(i, target_size=size))
    # 0~Bereich bis 1
    test_img = test_img / 255
    #In einem 4-dimensionalen Array
    test_img = test_img[np.newaxis, ...]
    #Prognose
    pre = model.predict(test_img)
    if np.max(pre[0]) == pre[0, 0]:
        print(f'{img_list[index]} -> {pre}Ist ein Pferd')
    if np.max(pre[0]) == pre[0, 1]:
        print(f'{img_list[index]} -> {pre}Hirsch')

Eine hohe Zahl auf der linken Seite des Arrays ist ein Pferd, und eine hohe Zahl auf der rechten Seite ist ein Reh.

Hirsch1.jpg-> [[0.08649362 0.9135064]] ist ein Hirsch Hirsch2.jpg-> [[5.096481e-06 9.999949e-01]] ist ein Hirsch Hirsch3.jpg-> [[0.01137464 0.9886254]] ist ein Hirsch pher4.jpg-> [[0.04577665 0.9542234]] ist ein Hirsch Hirsch5.jpg-> [[1.0562457e-07 9.9999988e-01]] ist ein Hirsch Hirsch6.jpg-> [[0.10744881 0.89255124]] ist ein Hirsch Hirsch7.jpg-> [[0.5856648 0.41433516]] ist ein Pferd Horse1.jpg-> [[0.00249346 0.99750656]] ist ein Hirsch Horse10.jpg-> [[0.6968936 0.30310643]] ist ein Pferd Horse2.jpg-> [[0.90138936 0.09861059]] ist ein Pferd Horse3.jpg-> [[9.9987268e-01 1.2731158e-04]] ist ein Pferd Horse4.jpg-> [[9.9999964e-01 4.1403896e-07]] ist ein Pferd Horse5.jpg-> [[9.999294e-01 7.052123e-05]] ist ein Pferd Horse6.jpg-> [[9.9999738e-01 2.6105645e-06]] ist ein Pferd Horse7.jpg-> [[0.93193245 0.06806755]] ist ein Pferd Horse8.jpg-> [[0.01251398 0.987486]] ist ein Hirsch Horse9.jpg-> [[0.00848716 0.99151284]] ist ein Hirsch

Die korrekte Rücklaufquote betrug 76,47%.

Horse10.jpg wurde als [Pferd] beurteilt, aber Horse8.jpg und Horse9.jpg wurden als [Hirsch] beurteilt, was der Hauptzweck der Beurteilung von Rennpferden war.

Mir wurde klar, dass ich immer noch nicht genug studiert habe, ob die Ursache der Datensatz, die Datengröße oder etwas anderes ist.

Hier sind einige der Dinge, die ich versucht habe.

Was ich versucht habe Teil 1

Datensatz ändern

• Pferdeordner ändern

1. Erhöhen Sie die Anzahl der Fotos von der Vorderseite des Rennpferdes um 21
2. Legen Sie nur die gepolsterten 459 Blätter in den Pferdeordner (Verwenden Sie nicht 1 Pferd 1001 von CIFAR-10)

• Füllen Sie den Hirschordner so auf, dass er mit dem Pferdeordner übereinstimmt (Dies verwendet 999 Hirsche von CIFAR-10)

Pferdeordner → 2295 Blatt Hirschmappe → 2295 Blatt Und obwohl ich die Ebene nicht geändert habe, habe ich die Lernrate auf 1e-4 gesenkt.

Epoch 27/30 ･ ･ ･ ･ ･ ･ 3672/3672 [==============================] - 139s 38ms/step - loss: 0.1167 - acc: 0.9570 - val_loss: 0.1760 - val_acc: 0.9227

Der Graph ist nicht stabil Testergebnisse

Falsch Hirsch1.jpg-> [[0.5788138 0.42118627]] ist ein Pferd pher5.jpg-> [[0.5183205 0.48167947]] ist ein Pferd Horse8.jpg-> [[0.0699899 0.93001]] ist ein Hirsch Richtige Antwort Horse9.jpg-> [[0.612066 0.38793397]] ist ein Pferd Horse10.jpg-> [[0.7463752 0.2536248]] ist ein Pferd

Die richtige Antwortrate ist um 70,59% gesunken.

Was ich versucht habe Teil 2

Dieses Mal wurde die Lernrate weiter auf 1e-5 reduziert und die Chargengröße auf 32 eingestellt. Ich habe die Ebenen nicht geändert. Der Graph ist stabil geworden. Die korrekte Antwortrate des Tests betrug jedoch 47,06%, was erheblich niedriger war.

Was ich versucht habe # 3

Ich habe viele andere Dinge mit dem obigen Datensatz versucht, aber ich habe nicht die erwarteten Ergebnisse erhalten, also habe ich den Datensatz erneut geändert.

• Pferdeordner ändern --Verwenden Sie 1 Pferd 1001 von CIFAR-10, das nicht verwendet wurde Das Aufblasen ist jedoch nur für diejenigen gedacht, die aus dem Internet abgeholt haben (459 Blatt → 1275 Blatt).
• Der Hirschordner hat sich nicht geändert, nur die Nummer

Pferdeordner → 2276 Blatt Hirschmappe → 2276 Blatt

Reduzierte auch die Anzahl der Schichten

#Eingabeebene,Versteckte Ebene(Aktivierungsfunktion:relu)
model.add ( Conv2D ( 32, (3, 3), activation='relu', padding='same', input_shape=X_train.shape[1:] ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Conv2D ( 32, (3, 3), activation='relu', padding='same' ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Conv2D ( 64, (3, 3), activation='relu' ) )
model.add ( MaxPooling2D ( pool_size=(2, 2) ) )

model.add ( Flatten () )
model.add ( Dense ( 64, activation='relu' ) )
model.add ( Dropout ( 0.5 ) )

#Ausgabeschicht(2 Klassenklassifikation)(Aktivierungsfunktion:softmax)
model.add ( Dense ( 2, activation='softmax' ) )

Kompilieren (Lernrate: 1e-4, Verlustfunktion: kategoriale Kreuzentropie, Optimierungsalgorithmus: RMSprop, Bewertungsfunktion: Genauigkeit (korrekte Antwortrate)) Epoche Epochen = 20, Stapelgröße batch_size = 32

Epoch 18/20 3641/3641 [==============================] - 131s 36msstep - loss 0.2647 - acc 0.8846 - val_loss 0.2948 - val_acc 0.8716

Die Grafik ist tendenziell etwas stabil, aber die korrekte Antwortrate des Tests betrug 64,71%.

Berücksichtigung aus dem Testbild

Ich habe verschiedene Dinge ausprobiert, einschließlich der Sigmoid-Funktion. Hirsch1.jpg hat eine hohe Wahrscheinlichkeit, als Pferd beurteilt zu werden. Darüber hinaus wird das Frontbild des Rennpferdes von Horse8.jpg und Horse9.jpg eher als Hirsch beurteilt. Möglicherweise sind nicht genügend Daten vorhanden.

abschließend

Es gibt immer noch verschiedene Techniken, um die Genauigkeitsrate zu erhöhen, aber ich möchte hier einmal fertig werden und die Herausforderung erneut annehmen. Abschwächung der Lernrate, Lernen im Ensemble, Transferlernen, EfficientNet usw.

Ich habe nicht die gewünschten Ergebnisse erzielt, konnte jedoch die Bilderkennung mit CNN ausprobieren.

Verweise

Einteilung in 2 Typen (Klassen) durch Keras Welche Optimierungsmethode zeigt die beste Leistung beim Lernen von CNN Ich habe tatsächlich eine KI erstellt und veröffentlicht, die bestimmt, ob die Schokolade, die ich am Valentinstag bekommen habe, meine Lieblingsschokolade ist (2019) Betriebsmethode beim Umgang mit einem Array von Bildern usw. Identifikation der Freunde mit TensorFlow + Keras - Teil 2: Lernen mit einem einfachen CNN Grundlegendes Grundwissen für Superanfänger CNN einfach mit Keras erstellen Eine Maschine, die eine schöne Frau nicht unterscheiden kann, ist nur eine Maschine: Datensatzgenerierung für maschinelles Lernen durch Python Erstellen einer Steigungsgruppendiskriminierungs-KI durch Bilderkennung Erstellen Sie eine KI, mit der Sie Ayataka durch Bilderkennung auswählen können Passen Sie die Hyperparameter in MNIST an, um das Verlust- / Genauigkeitsdiagramm anzuzeigen CNN mit Keras Speichern Sie das beste Modell (Verwendung von ModelCheckpoint) Eine Geschichte über die Verwendung von Deep Learning, um ein Programm zur Diskriminierung von Schauspielerinnen zu erstellen, das genau wie Sie aussieht DNN-Implementierung in Keras Laden Sie ein mit KERAS trainiertes Modell und identifizieren Sie ein Bild