[PYTHON] [Deep Learning] Nogisaka Gesichtserkennung ~ Für Anfänger ~
Einführung
Hallo. Ich war schon immer an Bilderkennung interessiert und hatte vage Kenntnisse, aber ich habe noch keinen Code geschrieben. Dieses Mal möchte ich einen Artikel für Anfänger schreiben. Vielen Dank.
Verfahren
- Bildkratzen
- Löschen Sie dasselbe Bild
- Machen Sie die Bildnamen seriell
- Schneiden Sie nur das Gesichtsteil aus
- Trennen Sie Lehrerdaten und Testdaten
- Lehrerdaten aufblasen
- Lernen Sie die Verwendung von Google Colaboratory
1. Bildkratzen
Sammeln Sie zunächst Mitgliederbilder. Es gibt Bildsuchdienste wie Bing und Yahoo, aber in diesem Artikel werden wir Bilder sammeln, indem wir die Ergebnisse der Google-Bildsuche kratzen. Den Originalcode erhalten Sie von hier. Der Originalcode kann jedoch nicht heruntergeladen werden (Stand April 2020). Es gibt einen Patch für dieses Problem als Pull-Anforderungen, daher verwenden wir dieses Mal den Code.
Beispiel für die Verwendung von google_images_download.py
cd google_images_download/
python google_images_download.py -k "Asuka Saito"
python google_images_download.py -k "site:twitter.com Asuka Saito"
Mit diesem Programm können Sie nur bis zu 100 Exemplare gleichzeitig herunterladen. Wenn Sie weitere Bilder sammeln möchten, ändern Sie bitte das Suchwort. Sie können auch das Suchwort "site: url" verwenden, um nur die Bilder herunterzuladen, die der URL entsprechen.
Referenzartikel
Der Download von Google-Bildern hat nicht funktioniert, entspricht also
2. Löschen Sie dasselbe Bild
Löschen Sie als Nächstes genau dieselben Bilddaten aus den in 1 gesammelten Bildern. Die Algorithmen sind in der folgenden Abbildung zusammengefasst.
In 1. wird der 8-Bit x 3 (RGB) -Vektor in 1 Bit (Schwarzweiß) konvertiert. Zu diesem Zeitpunkt wird die Monochromkonvertierung unter Verwendung eines Algorithmus namens Floyd-Steinberg-Dithering durchgeführt. ([a](https://ja.wikipedia.org/wiki/%E3%83%95%E3%83%AD%E3%82%A4%E3%83%89-%E3%82%B9%E3 % 82% BF% E3% 82% A4% E3% 83% B3% E3% 83% 90% E3% 83% BC% E3% 82% B0% E3% 83% BB% E3% 83% 87% E3% 82 % A3% E3% 82% B6% E3% 83% AA% E3% 83% B3% E3% 82% B0), [b](https://pillow.readthedocs.io/en/stable/reference/Image. html), c)). Der Code für die Monochromkonvertierung ist unten dargestellt. Ich habe auf den Code von [hier] verwiesen (https://qiita.com/ikuo0/items/7406d6eaa9e9457e03ee).
def img2vec(filename):
img = Image.open(filename)
img = img.resize((200, 200), resample=Image.BILINEAR) #Schrumpfen
img = img.convert('1') #Binarisierung
#img.save(get_mono_filename(filename)) #Wenn Sie das Bild überprüfen möchten
img = np.array(img)
#In eine Matrix vom Typ int konvertieren
int_img = img.astype(np.int)
return int_img
Dann berechnen Sie die Norm.
def calnorm(vec):
norm = np.linalg.norm(vec)
return norm
Ordnen Sie die Normen in absteigender Reihenfolge an. Verwenden Sie die Sortierfunktion, um die Werte in einer beliebigen Spalte zu sortieren.
def fig_norm_list_cal(list_fig):
#Machen Sie eine Liste, die jede Feige und Norm zusammenfasst
#Beispiel
# fig_norm_list = [[fig, norm], [fig.A, 2], [fig.B, 3],...[figZ, 5]]
fig_norm_list = fig_norm_mat(list_fig)
#Ordnen Sie die Größen der Norm in absteigender Reihenfolge an
#http://sota1235.com/blog/2015/04/23/python_sort_twodime.html
fig_norm_list = sorted(fig_norm_list, key = lambda x: x[1])
#nd.In Array-Typ konvertieren
fig_norm_list = np.array(fig_norm_list)
return fig_norm_list
Überprüfen Sie die Normwerte nacheinander und löschen Sie diejenigen mit demselben Wert.
def del_fig_list_cal(fig_norm_list):
#Listen Sie die zu löschenden Dateien auf
del_fig_list = []
#Das Endergebnis zählt nicht
for i in range(fig_norm_list.shape[0] - 1):
if (fig_norm_list[i, 1] == fig_norm_list[i+1, 1]):
del_fig_list.append(str(fig_norm_list[i, 0]))
return del_fig_list
Löschen Sie die Datei mit der oben berechneten Datei del_fig_list und os.remove ().
3. Machen Sie die Bildnamen seriell
Dieser Code bestimmt gleichzeitig auch die Erweiterung.
#Ändern Sie den Namen des Bildes in eine Seriennummer
def fig_rename():
i = 1
j = 1
k = 1
list_fig = listfig()
for pre_filename in list_fig:
if ((".jpg " in pre_filename) == True ):
os.rename(pre_filename, path + "/fig_data/" + str(i) + '.jpg')
i += 1
elif ((".png " in pre_filename) == True):
os.rename(pre_filename, path + "/fig_data/" + str(j) + '.png')
j += 1
elif ((".jpeg " in pre_filename) == True):
os.rename(pre_filename, path + "/fig_data/" + str(k) + '.jpeg')
k += 1
else:
pass
return
Referenzartikel
Programm zur Suche nach demselben Bild
4. Schneiden Sie nur das Gesichtsteil aus
Das Bild kann etwas anderes als ein Gesicht enthalten, oder es kann mehrere Gesichter enthalten. Sie müssen dies zu einem Nur-Gesicht-Bild formen, das Sie zum Lernen verwenden können. Hier haben wir die Gesichtserkennung von Haar-Cascade verwendet, die standardmäßig in OpenCV installiert ist.
import cv2
import os
import glob
path = os.getcwd()
def listfig():
#.Holen Sie sich andere Dateien als py
#https://qiita.com/AAAAisBraver/items/8d40d9c2d624ecee105d
filename = path + "/face_detect_test/" + "*[!.py]"
list_fig = glob.glob(filename)
return list_fig
def jud_ext(filename):
if ((".jpg " in filename) == True):
ext = '.jpg'
elif ((".png " in filename) == True):
ext = '.png'
elif ((".jpeg " in filename) == True):
ext = '.jpeg'
else:
ext = 'end'
return ext
def main():
face_cascade_path = '/home/usr/anaconda3/pkgs/libopencv-4.2.0-py36_2'\
'/share/opencv4/haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(face_cascade_path)
#Bilderlistenerstellung
fig_list = listfig()
#Aus der Bilderliste mit for-Anweisung extrahiert
j = 1 #Nummerieren Sie Bilder, bevor Sie Gesichter erkennen
k = 0 #Zählen Sie zu kleine Bilder
for fig_name in fig_list:
#fig_Identifizieren Sie die Namenserweiterung
ext = jud_ext(fig_name)
#Wenn Ende, Ende
if (ext == 'end'):
break
#Bild wird geladen
src = cv2.imread(fig_name)
src_gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(src_gray)
#Schneiden Sie den Gesichtsteil aus
i = 1 #Falls ein Bild zwei oder mehr Gesichter enthält
for x, y, w, h in faces:
#cv2.rectangle(src, (x, y), (x + w, y + h), (255, 0, 0), 2)
#Schneiden Sie nur das Gesichtsteil von src
face = src[y: y + h, x: x + w]
#face_gray = src_gray[y: y + h, x: x + w]
#Stellen Sie sicher, dass auf jeder Seite mindestens 64 Pixel vorhanden sind
if face.shape[0] < 64:
print('\ntoo small!!\n')
print('\n{}\n'.format(fig_name))
k += 1
continue
#Hinweis: (64,64)Wird nicht unter 64x64 Pixel gespeichert
face = cv2.resize(face, (64, 64))
#Gesicht speichern
cv2.imwrite(path + '/face_detect_test/clip_face/' + 'face' + str(i) + str(j) + ext, face)
i += 1
j += 1
print("too small fig is {}".format(k))
if __name__ == '__main__':
main()
Ich werde einen Teilcode-Auszug erklären. Verwenden Sie zunächst den folgenden Code, um die Erweiterung des Bildes zu bestimmen.
def jud_ext(filename):
if ((".jpg " in filename) == True):
ext = '.jpg'
elif ((".png " in filename) == True):
ext = '.png'
elif ((".jpeg " in filename) == True):
ext = '.jpeg'
else:
ext = 'end'
return ext
Das Bild, das ich verwendet habe, hatte nur die Formate JPG, PNG und JPEG, also habe ich den Code geschrieben, um diese drei zu beurteilen. Der Grund für die Bestimmung der Bildausdehnung besteht darin, das Bild nach dem Ausschneiden des Gesichtsbilds mit derselben Ausdehnung zu speichern.
Der folgende Code wird beim Schneiden des Gesichts verwendet. Zu diesem Zeitpunkt wird die Auflösung in 64x64 konvertiert. Dies ist eine Maßnahme zur Reduzierung der Datengröße. Die Funktion cv2.resize speichert keine Bilder, die kleiner als 64x64 sind.
Wie ich später bemerkte, ist es jedoch äußerst schwierig, das Gesichtsbild manuell zu beurteilen. Ich denke, Sie können es bei 128 x 128 speichern.
def main():
face_cascade_path = '/home/usr/anaconda3/pkgs/libopencv-4.2.0-py36_2'\
'/share/opencv4/haarcascades/haarcascade_frontalface_default.xml'
face_cascade = cv2.CascadeClassifier(face_cascade_path)
#Bilderlistenerstellung
fig_list = listfig()
#Aus der Bilderliste mit for-Anweisung extrahiert
j = 1 #Nummerieren Sie Bilder, bevor Sie Gesichter erkennen
k = 0 #Zählen Sie zu kleine Bilder
for fig_name in fig_list:
#fig_Identifizieren Sie die Namenserweiterung
ext = jud_ext(fig_name)
#Wenn Ende, Ende
if (ext == 'end'):
break
#Bild wird geladen
src = cv2.imread(fig_name)
src_gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(src_gray)
#Schneiden Sie den Gesichtsteil aus
i = 1 #Falls ein Bild zwei oder mehr Gesichter enthält
for x, y, w, h in faces:
#cv2.rectangle(src, (x, y), (x + w, y + h), (255, 0, 0), 2)
#Schneiden Sie nur das Gesichtsteil von src
face = src[y: y + h, x: x + w]
#face_gray = src_gray[y: y + h, x: x + w]
#Stellen Sie sicher, dass auf jeder Seite mindestens 64 Pixel vorhanden sind
if face.shape[0] < 64:
print('\ntoo small!!\n')
print('\n{}\n'.format(fig_name))
k += 1
continue
#Hinweis: (64,64)Wird nicht unter 64x64 Pixel gespeichert
face = cv2.resize(face, (64, 64))
#Gesicht speichern
cv2.imwrite(path + '/face_detect_test/clip_face/' + 'face' + str(i) + str(j) + ext, face)
i += 1
j += 1
print("too small fig is {}".format(k))
5. Trennen Sie Lehrerdaten und Testdaten
Gesichtsfotos werden durch Zuweisung von 80% der Lehrerdaten und 20% der Testdaten unterteilt. Ich habe den folgenden Code verwendet.
import os
import random
import shutil
import glob
path = os.getcwd()
names = ["ikuta_face", "saito_asuka_face", "shiraishi_face"]
#Sammeln Sie Bildnamen in einer Liste
def listfig(tar_dir):
#.Holen Sie sich andere Dateien als py
#https://qiita.com/AAAAisBraver/items/8d40d9c2d624ecee105d
filename = path + tar_dir + "*[!.py]"
list_fig = glob.glob(filename)
return list_fig
def main():
for name in names:
#Bildverzeichnisliste abrufen
face_list = listfig("/dataset_face_fig/" + name + "/")
# face_Shuffle-Liste
random.shuffle(face_list)
# face_Verschieben Sie 20% vom Anfang der Liste in das Testverzeichnis
for i in range(len(face_list)//5):
shutil.move(str(face_list[i]), str(path + "/dataset_face_fig/test/" + name))
if __name__ == "__main__":
main()
Überprüfen Sie nach dem Trennen der Bilddaten, ob die Daten korrekt sind. Wenn bei der Google-Bildsuche ein Fehler auftritt, wird möglicherweise ein Bild gespeichert, das nichts damit zu tun hat. In meinem Fall gab es die folgenden Fälle.
- Saito Asukas Suchergebnisse enthalten ein Foto von Seirai Hayakawas Gesicht. ――Es wird schwierig, zwischen Asuka Saito und Nanase Nishino zu unterscheiden.
- Gestalt bricht zusammen, was es schwierig macht, das Gesicht zu identifizieren.
Wie ich bereits erwähnt habe, hatte ich bei dieser Arbeit Probleme mit einem 64x64-Image.
6. Lehrerdaten aufblasen
Nach dem Sortieren der Bilder besteht der nächste Schritt darin, die Bilder zu verarbeiten, um die Lehrerdaten zu erhöhen. Der Quellcode wird unten angezeigt.
import os
import glob
import traceback
import cv2
from scipy import ndimage
path = os.getcwd()
#Sammeln Sie Bildnamen in einer Liste
def listfig(tar_dir):
#.Holen Sie sich andere Dateien als py
#https://qiita.com/AAAAisBraver/items/8d40d9c2d624ecee105d
filename = path + tar_dir + "*[!.py]"
list_fig = glob.glob(filename)
return list_fig
#Drehen Sie das Bild
def fig_rot(img, ang):
img_rot = ndimage.rotate(img,ang)
img_rot = cv2.resize(img_rot,(64,64))
return img_rot
#Verlängerungsurteil
def jud_ext(filename):
if ((".jpg " in filename) == True):
ext = '.jpg'
elif ((".png " in filename) == True):
ext = '.png'
elif ((".jpeg " in filename) == True):
ext = '.jpeg'
else:
ext = 'end'
try:
raise Exception
except:
traceback.print_exc()
return ext
def main():
#Geben Sie das Verzeichnis an, das die zu vergrößernden Lehrerdaten enthält
names = ["ikuta_face", "saito_asuka_face", "shiraishi_face"]
for name in names:
# /dataset_face_fig/name/Holen Sie sich die Bilderliste aus dem Verzeichnis
train_fig_list = listfig("/dataset_face_fig/" + "/" + name + "/")
i = 1 #Decken Sie den Bildnamen nicht ab
for train_fig in train_fig_list:
ext = jud_ext(train_fig)
#Bild laden
img = cv2.imread(train_fig)
#Drehung
for ang in [-10, 0, 10]:
# j = 1 #Decken Sie den Bildnamen nicht ab
img_rot = fig_rot(img, ang)
#Bild speichern
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + ext, img_rot)
#Schwellenwertverarbeitung
img_thr = cv2.threshold(img_rot, 100, 255, cv2.THRESH_TOZERO)[1]
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + 'thr' + ext, img_thr)
#Unschärfeverarbeitung
img_filter = cv2.GaussianBlur(img_rot, (5, 5), 0)
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + 'fil' + ext, img_filter)
i += 1
return
if __name__ == "__main__":
main()
Drehen Sie ein Bild, um es auf drei zu erhöhen. Danach werden für jedes Bild eine Schwellenwertverarbeitung und eine Unschärfeverarbeitung durchgeführt. In 3x3 sind neun Bilder für ein Bild enthalten. Unten finden Sie einen Auszug aus dem Kerncode.
def main():
#Geben Sie das Verzeichnis an, das die zu vergrößernden Lehrerdaten enthält
names = ["ikuta_face", "saito_asuka_face", "shiraishi_face"]
for name in names:
# /dataset_face_fig/name/Holen Sie sich die Bilderliste aus dem Verzeichnis
train_fig_list = listfig("/dataset_face_fig/" + "/" + name + "/")
i = 1 #Decken Sie den Bildnamen nicht ab
for train_fig in train_fig_list:
ext = jud_ext(train_fig)
#Bild laden
img = cv2.imread(train_fig)
#Drehung
for ang in [-10, 0, 10]:
# j = 1 #Decken Sie den Bildnamen nicht ab
img_rot = fig_rot(img, ang)
#Bild speichern
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + ext, img_rot)
#Schwellenwertverarbeitung
img_thr = cv2.threshold(img_rot, 100, 255, cv2.THRESH_TOZERO)[1]
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + 'thr' + ext, img_thr)
#Unschärfeverarbeitung
img_filter = cv2.GaussianBlur(img_rot, (5, 5), 0)
cv2.imwrite(path + '/dataset_face_fig/train/' + name + "/" + str(i) + '_' + str(ang) + 'fil' + ext, img_filter)
i += 1
return
7. Lernen Sie die Verwendung von Google Colaboratory
Danach müssen Sie 1. die Bilddaten beschriften und 2. lernen. Von hier aus werde ich versuchen, Google Colaboratory (Colab) zu verwenden. Colab bietet eine hochspezifizierte CPU und GPU, die Hochgeschwindigkeitsberechnungen ermöglichen. Colab kann von jedem verwendet werden, der ein Google-Konto hat. Führen Sie zunächst den folgenden Code aus, um das Google-Laufwerk bereitzustellen. Dadurch erhalten Sie Zugriff auf die Daten in Google Drive. Die Ausführung ist "Umschalt + Eingabetaste".
from google.colab import drive
drive.mount('/content/drive')
import tensorflow as tf
tf.test.gpu_device_name()
Als nächstes werden wir die Bilddaten beschriften und trainieren. Zunächst wird der Quellcode unten angezeigt.
#Machen Sie alles von der Beschriftung bis zum Lernen
#Debugger
%pdb off
import os
import glob
import cv2
import numpy as np
from keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D
from keras.models import Sequential
from keras.utils.np_utils import to_categorical
from tqdm import tqdm
import matplotlib.pyplot as plt
import pickle
import datetime
path = os.getcwd()
print(path)
%cd /content/drive/My\ Drive/dataset_face_fig
#Sammeln Sie Bildnamen in einer Liste
def listfig(tar_dir):
#.Holen Sie sich andere Dateien als py
#.Holen Sie sich andere Dateien als py
#https://qiita.com/AAAAisBraver/items/8d40d9c2d624ecee105d
filename = tar_dir + "*[!.py]"
list_fig = glob.glob(filename)
return list_fig
#Personenurteil
def jud_hum(filename):
if (("ikuta" in filename) == True):
ext = 0
elif (("saito_asuka" in filename) == True):
ext = 1
elif (("shiraishi" in filename) == True):
ext = 2
else:
ext = 'end'
try:
raise Exception
except:
traceback.print_exc()
return ext
#Kennzeichnung von Lehrerdaten
def label_training(names):
#Kennzeichnung von Lehrerdaten
x_train = []
y_train = []
for name in tqdm(names):
face_fig_list = glob.glob("/content/drive/My Drive/dataset_face_fig/train/" + name + "/" + "*")
print(face_fig_list)
for face_fig_filename in tqdm(face_fig_list):
face_img = cv2.imread(face_fig_filename)
b,g,r = cv2.split(face_img)
face_img = cv2.merge([r,g,b])
x_train.append(face_img)
kind_hum = jud_hum(face_fig_filename)
y_train.append(kind_hum)
print(y_train)
print("y_train length")
print(len(y_train))
# x_train, y_Zug retten
f = open('x_train.txt', 'wb')
#Dump-Liste zu f
pickle.dump(x_train, f)
f = open('y_train.txt', 'wb')
#Dump-Liste zu f
pickle.dump(y_train, f)
return x_train, y_train
#Kennzeichnung der Testdaten
def label_test(names):
#Kennzeichnung der Testdaten
x_test = []
y_test = []
for name in tqdm(names):
# face_fig_list = listfig("/content/drive/My Drive/dataset_face_fig/" + name)
face_fig_list = glob.glob("/content/drive/My Drive/dataset_face_fig/test/" + name + "/" + "*")
# print("/content/drive/My Drive/dataset_face_fig/" + name)
print(face_fig_list)
for face_fig_filename in tqdm(face_fig_list):
face_img = cv2.imread(face_fig_filename)
b,g,r = cv2.split(face_img)
face_img = cv2.merge([r,g,b])
x_test.append(face_img)
kind_hum = jud_hum(face_fig_filename)
y_test.append(kind_hum)
# x_test, y_Test speichern
f = open('x_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(x_test, f)
f = open('y_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(y_test, f)
print(y_test)
print("y_test length")
print(len(y_test))
return x_test, y_test
def cnn(x_train, y_train, x_test, y_test):
#Modelldefinition
model = Sequential()
model.add(Conv2D(input_shape=(64, 64, 3), filters=32,kernel_size=(3, 3),
strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(3, 3),
strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=32, kernel_size=(3, 3),
strides=(1, 1), padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation('sigmoid'))
model.add(Dense(3))
model.add(Activation('softmax'))
#kompilieren
model.compile(optimizer='sgd',
loss='categorical_crossentropy',
metrics=['accuracy'])
#Lernen
history = model.fit(x_train, y_train, batch_size=32,
epochs=50, verbose=1, validation_data=(x_test, y_test))
#Bewertung und Anzeige des Generalisierungssystems
score = model.evaluate(x_test, y_test, batch_size=32, verbose=0)
print('validation loss:{0[0]}\nvalidation accuracy:{0[1]}'.format(score))
model.save("my_model.h5")
type(history)
return history
def learn_monitor_plot(history):
#acc, val_gem. Grundstück
plt.plot(history.history["accuracy"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_accuracy"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
now = datetime.datetime.now()
plt.savefig("learning_cpu_" + now.strftime('%Y%m%d_%H%M%S') + '.png')
def main():
print("ok")
names = ["ikuta_face", "saito_asuka_face", "shiraishi_face"]
#Kennzeichnung von Lehrerdaten und Ausbildungsdaten
x_train, y_train = label_training(names)
x_test, y_test = label_test(names)
#Bilddatenformung
x_train = np.array(x_train)
x_test = np.array(x_test)
#Formatierung der Etikettendaten
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
#Tiefes Lernen
learn_history = cnn(x_train, y_train, x_test, y_test)
#Graph
learn_monitor_plot(learn_history)
main()
%cd /content
Das zu beschriftende Teil ist unten dargestellt.
#Personenurteil
def jud_hum(filename):
if (("ikuta" in filename) == True):
ext = 0
elif (("saito_asuka" in filename) == True):
ext = 1
elif (("shiraishi" in filename) == True):
ext = 2
else:
ext = 'end'
try:
raise Exception
except:
traceback.print_exc()
return ext
#Kennzeichnung von Lehrerdaten
def label_training(names):
#Kennzeichnung von Lehrerdaten
x_train = []
y_train = []
for name in tqdm(names):
face_fig_list = glob.glob("/content/drive/My Drive/dataset_face_fig/train/" + name + "/" + "*")
print(face_fig_list)
for face_fig_filename in tqdm(face_fig_list):
face_img = cv2.imread(face_fig_filename)
b,g,r = cv2.split(face_img)
face_img = cv2.merge([r,g,b])
x_train.append(face_img)
kind_hum = jud_hum(face_fig_filename)
y_train.append(kind_hum)
print(y_train)
print("y_train length")
print(len(y_train))
# x_train, y_Zug retten
f = open('x_train.txt', 'wb')
#Dump-Liste zu f
pickle.dump(x_train, f)
f = open('y_train.txt', 'wb')
#Dump-Liste zu f
pickle.dump(y_train, f)
return x_train, y_train
#Kennzeichnung der Testdaten
def label_test(names):
#Kennzeichnung der Testdaten
x_test = []
y_test = []
for name in tqdm(names):
# face_fig_list = listfig("/content/drive/My Drive/dataset_face_fig/" + name)
face_fig_list = glob.glob("/content/drive/My Drive/dataset_face_fig/test/" + name + "/" + "*")
# print("/content/drive/My Drive/dataset_face_fig/" + name)
print(face_fig_list)
for face_fig_filename in tqdm(face_fig_list):
face_img = cv2.imread(face_fig_filename)
b,g,r = cv2.split(face_img)
face_img = cv2.merge([r,g,b])
x_test.append(face_img)
kind_hum = jud_hum(face_fig_filename)
y_test.append(kind_hum)
# x_test, y_Test speichern
f = open('x_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(x_test, f)
f = open('y_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(y_test, f)
print(y_test)
print("y_test length")
print(len(y_test))
return x_test, y_test
data = cv2.imread('filepath')
print(data.shape)
# (64, 64, 3)
Extrahieren Sie 3 2D-Datenfelder mit cv2.split (Daten vom Typ ndarray). Beachten Sie, dass zu diesem Zeitpunkt Blau, Grün und Rot in dieser Reihenfolge extrahiert werden. Erstellen Sie eine Liste mit cv2.merge ([r, g, b]) und fügen Sie sie mit append zu x_train oder x_test hinzu. Das Laden des Images mit der GPU hat einige Zeit gedauert, daher habe ich den Code geschrieben, um nur die Image-Daten vorübergehend in Drive zu speichern.
# x_test, y_Test speichern
f = open('x_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(x_test, f)
f = open('y_test.txt', 'wb')
#Dump-Liste zu f
pickle.dump(y_test, f)
Die Berechnung von 1 Epoche auf der CPU dauert ungefähr 5 Sekunden, auf der GPU jedoch weniger als 1 Sekunde. Versuch es bitte. Das Ergebnis ist wie folgt.
Die Genauigkeit beträgt ca. 80%.
Zusammenfassung
Zum ersten Mal schrieb ich einen vollständigen Code und führte eine Bilderkennung durch. In Zukunft möchte ich ein anderes Netzwerk studieren und nutzen. Wir freuen uns auf Ihre Fragen und Kommentare. Vielen Dank, dass Sie so weit gelesen haben.
Referenzartikel
Klassifizieren Sie das Gesicht eines Nogisaka-Mitglieds nach CNN
Recommended Posts