[Python] Ich habe versucht, das Mitgliederbild der Idolgruppe mithilfe von Keras zu beurteilen
Artikelinhalt
Die Bildbeurteilungsverarbeitung wurde unter Verwendung von Keras durchgeführt. Grundsätzlich habe ich es erstellt, indem ich den Artikel, auf den ich mich bezog, umgeleitet habe, sodass ich nur die Punkte schreibe, die ich als Memo entworfen habe.
Referenz
Erstellen einer CNN-Bilderkennung mit Python und Keras
Umgebung
Python：3.7.4 Keras：2.3.4 tensorflow：1.13.1
Verfassung
Dieses Mal lernte ich das Bild einer Idolgruppe namens "// Necopla //".
Erstellt einen Ordner für jedes Mitglied unter dem Ordner img für Mitgliederbilder und platziert Bilder für jedes Mitglied.
Was ich getan habe
Bildaufnahme
Ich habe das Bild jedes Mitglieds von Twitter erhalten.
import json
import config
from urllib import request
from requests_oauthlib import OAuth1Session
from time import sleep
# API-Schlüsseleinstellung (definiert in einer anderen Datei config.py)
CK = config.CONSUMER_KEY
CS = config.CONSUMER_SECRET
AT = config.ACCESS_TOKEN
ATS = config.ACCESS_TOKEN_SECRET
# Authentifizierungsprozess
twitter = OAuth1Session(CK, CS, AT, ATS)
# Endpunkt der Zeitleistenerfassung
get_time_line_url = "https://api.twitter.com/1.1/statuses/user_timeline.json"
# Erwerbskonto
necopla_menber = ['@yukino__NECOPLA', '@yurinaNECOPLA', '@riku_NECOPLA', '@miiNECOPLA', '@kaori_NECOPLA', '@sakuraNECOPLA', '@miriNECOPLA', '@renaNECOPLA']
necopla_name = {'@yukino__NECOPLA': 'yukino',
'@yurinaNECOPLA': 'yurina',
'@riku_NECOPLA': 'riku',
'@miiNECOPLA': 'mii',
'@kaori_NECOPLA': 'kaori',
'@sakuraNECOPLA': 'sakura',
'@miriNECOPLA': 'miri',
'@renaNECOPLA': 'rena'}
# Parameterdefinition
params = {'q': '-filter:retweets',
'max_id': 0, #ID, um zu beginnen
'count': 200}
for menber in necopla_menber:
print(menber)
del params ['max_id'] # ID löschen, um die Erfassung zu starten
# Holen Sie sich die letzten 200 Tweets / Holen Sie sich Tweets, die älter als die in params ['max_id'] festgelegte ID sind, ab dem zweiten Mal
index = 1
for j in range(100):
params['screen_name'] = menber
res = twitter.get(get_time_line_url, params=params)
print(params)
print(res.status_code)
if res.status_code == 200:
#API verbleibende Anzahl
limit = res.headers['x-rate-limit-remaining']
print("API remain: " + limit)
if limit == 1:
sleep(60*15)
n = 0
tweets = json.loads(res.text)
# Verlassen Sie die Schleife, wenn Sie keine Tweets von dem Konto erhalten, das Sie verarbeiten
print(len(tweets))
if len(tweets) == 0:
break
# Per Tweet verarbeiten
for tweet in tweets:
if 'extended_entities' in tweet:
for media in tweet['extended_entities']['media']:
url = media['media_url']
if url != '':
request.urlretrieve(url, './img/' + necopla_name[menber] + '/' + necopla_name[menber] + '_' + str(index).zfill(5) + url[-4:] )
index += 1
if len(tweets) >= 1:
print('max_id set')
params['max_id'] = tweets[-1]['id']-1
Bei diesem Vorgang werden Bilder von Twitter jedes Mitglieds erfasst und die Bilder unter dem Ordner mit dem Namen jedes Mitglieds gespeichert.
Bildsortierung
Als nächstes habe ich die Bilder aussortiert. Ich habe 1200 für viele Mitglieder und ungefähr 300 für wenige Mitglieder. Daraus löschte ich Ansagen, Essen, Two-Shot-Bilder usw. und beschränkte mich manuell auf nur die Bilder, die alleine angezeigt werden.
Wir haben die Bilder jedes Mitglieds weiter auf 250 eingegrenzt, entsprechend dem Mitglied mit der geringsten Anzahl von Bildern nach dem Eingrenzen.
Bildbeurteilung
coding:utf-8
import keras
from keras.preprocessing.image import load_img, img_to_array
from keras.callbacks import LambdaCallback
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dense, Dropout, Activation, Flatten
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from keras.models import model_from_json
from PIL import Image
import glob
necopla_name = ['yukino', 'yurina', 'riku', 'mii', 'kaori', 'sakura', 'miri', 'rena']
member_color = ['black', 'blue', 'red', 'green', 'magenta', 'aqua', 'purple', 'yellow']
image_size = 50
epochs = 100
hw = {"height":image_size, "width":image_size}
print('Load images...')
X = []
Y = []
for index, name in enumerate(necopla_name):
dir = "./image/" + name
files = glob.glob(dir + "/*.jpg ")
for i, file in enumerate(files):
image = Image.open(file)
image = image.convert("RGB")
image = image.resize((image_size, image_size))
data = np.asarray(image)
X.append(data)
Y.append(index)
X = np.array(X)
Y = np.array(Y)
X = X.astype('float32')
X = X / 255.0
# Konvertieren Sie das richtige Etikettenformat
Y = np_utils.to_categorical(Y, 8)
print('Create test data...')
# Trainingsdaten und Testdaten
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.20)
print('Build model...')
# Erstellen Sie CNN
model = Sequential()
model.add(Conv2D(32, (3, 3), padding='same',input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(8))
model.add(Activation('softmax'))
# kompilieren
model.compile(loss='categorical_crossentropy',optimizer='SGD',metrics=['accuracy'])
json_string = ''
passage_array = [[0] * epochs] * len(necopla_name)
passage_array = []
for i in range(len(necopla_name)):
passage_array.append([0] * epochs)
# Am Ende des Lernens ausführen
def on_train_end(logs):
print('----- saving model...')
model.save_weights("necopla_image_model" + 'w.hdf5')
model.save("necopla_image_model.hdf5")
# Am Ende der Epoche ausführen
def on_epoch_end(epoch, logs):
print ('##' + str (Epoche + 1) + 'th time')
print('## yurina.jpg evaluate...')
img = load_img('yurina.jpg', target_size=(hw["height"], hw["width"]))
TEST = img_to_array(img) / 255
pred = model.predict(np.array([TEST]), batch_size=1, verbose=0)
print (">> Berechnungsergebnis ↓ \ n" + str (pred))
print (">> Dieses Bild ist" "+ necopla_name [np.argmax (pred)] +" ".")
for i, p in enumerate(pred):
for j, pp in enumerate(p):
passage_array[j][epoch] = pp
print('## yukino.jpg evaluate...')
img = load_img('yukino.jpg', target_size=(hw["height"], hw["width"]))
TEST = img_to_array(img) / 255
pred = model.predict(np.array([TEST]), batch_size=1, verbose=0)
print (">> Berechnungsergebnis ↓ \ n" + str (pred))
print (">> Dieses Bild ist" "+ necopla_name [np.argmax (pred)] +" ".")
print_callback = LambdaCallback(on_epoch_end=on_epoch_end,on_train_end=on_train_end)
# Ausbildung
history = model.fit(X_train, y_train, epochs=epochs, callbacks=[print_callback])
# Bewertung & Ausgabe des Bewertungsergebnisses
print(model.evaluate(X_test, y_test))
print('Output picture...')
x_datas = range(1, epochs+1)
y_datas = [ i / 10 for i in range(0, 10) ]
plt.xlim(1, epochs + 1)
plt.ylim(0, 1)
fig = plt.figure(figsize=(6, 4), dpi=72, facecolor="black", edgecolor="black", linewidth=2)
ax = plt.subplot(1, 1, 1)
for i, passage in enumerate(passage_array):
ax.plot(passage, color=member_color[i], label=necopla_name[i])
fig.savefig("passege.png ", edgecolor="black")
plt.close()
Grundsätzlich werden die meisten Codes, auf die ich mich bezog, umgeleitet.
Als einen Punkt, den ich mir ausgedacht hatte, wollte ich sehen, wie der Lernprozess aussehen würde, also fügte ich die folgenden zwei Punkte hinzu.
・ Beurteilen Sie das Bild am Ende der Epoche ・ Zeigen Sie das Berechnungsergebnis für jedes Element in einem Diagramm an
Um das Bild zu beurteilen, geben Sie die Bilder von zwei Mitgliedern als Eingabe ein und bestätigen Sie, wer beurteilt wird.
## Erstes Mal
yurina.jpg evaluate...
>> Berechnungsergebnis ↓
[[0.12650199 0.12684263 0.12742536 0.12854463 0.11904926 0.1264687
0.1201202 0.12504727]]
>> Dieses Bild ist "mii".
yukino.jpg evaluate...
>> Berechnungsergebnis ↓
[[0.13068683 0.12408765 0.1275352 0.12792543 0.12050408 0.13144182
0.11644448 0.1213745 ]]
>> Dieses Bild ist "Sakura".
Epoch 2/100
1600/1600 [==============================] - 12s 8ms/step - loss: 2.0785 - accuracy: 0.1456
## Zweites Mal
yurina.jpg evaluate...
>> Berechnungsergebnis ↓
[[0.12513563 0.12735145 0.12925902 0.12473622 0.12179873 0.12717892
0.11717195 0.12736808]]
>> Dieses Bild ist "Riku".
yukino.jpg evaluate...
>> Berechnungsergebnis ↓
[[0.12863007 0.12423173 0.12936181 0.12356193 0.12369796 0.13277659
0.11367439 0.1240655 ]]
>> Dieses Bild ist "Sakura".
(Weggelassen)
## 100. Mal
yurina.jpg evaluate...
>> Berechnungsergebnis ↓
[[4.8989324e-10 8.2380754e-01 7.1863423e-07 3.2110822e-03 1.7282969e-01
1.9806185e-08 3.1989657e-05 1.1890962e-04]]
>> Dieses Bild ist "yurina".
yukino.jpg evaluate...
>> Berechnungsergebnis ↓
[[6.1400205e-01 2.8108407e-03 4.0069546e-04 1.0979763e-03 3.1650570e-01
6.4887889e-02 8.5816224e-05 2.0912322e-04]]
>> Dieses Bild ist "Yukino".
Der erste gab das falsche Ergebnis zurück, aber als er das 100. Mal erreichte, kamen beide, um ein korrektes Urteil zu fällen.
Die folgende Grafik zeigt die Berechnungsergebnisse am Ende jeder Epoche. Die Grafik zeigt nur das Beurteilungsergebnis des Bildes von "yurina".
Das Blau der Grafik ist "Yurina" und das Rosa ist "Kaori".
Als Ergebnis erwartete ich ein Diagramm, in dem die blaue Linie gegen 1 konvergiert.
Wenn wir uns dieses Ergebnis ansehen, können wir sehen, dass es schwierig ist, diese beiden Personen mit den aktuellen Trainingsdaten zu beurteilen.
Impressionen
Es ist ehrlich gesagt interessant. Vorerst habe ich versucht, es umzusetzen, während ich darüber nachdachte, es für das Studium zu machen, aber ich werde versuchen, beim Lesen von Büchern usw. mehr zu lernen, um Ideen zur Verbesserung der Genauigkeit zu finden.
Recommended Posts