[PYTHON] J'ai essayé d'utiliser l'apprentissage en profondeur pour extraire la partie où la plante est montrée de la photo de la véranda, mais cela n'a pas fonctionné, je vais donc résumer le contenu des essais et erreurs. Partie 2
Dernier synopsis
Un stock qui a commencé avec un petit effort. Cependant, je n'ai jamais imaginé qu'une nouvelle infection à coronavirus prévaudrait, et j'ai probablement échoué à faire un investissement sans omission, et les économies que j'avais économisées jusqu'à présent pour acheter ma maison sont devenues complètement vides, et je suis devenu désespéré et désespéré. Quand je marchais le long du pont du lac, on m'a demandé par derrière: "Ça fait un moment. Comment vas-tu?!" ...
... c'est une blague, et je continue l'article sur le thème de l'extraction d'objets à partir de photos!
Considération
Après la première partie, même si je change certains paramètres, cela n'a aucun effet, et seul le temps vide s'écoule ...
Pendant ce temps, j'ai soudainement imaginé «l'apprentissage par transfert». C'est une méthode pour réaliser une identification très précise à partir d'une petite quantité de données en utilisant la sortie du modèle entraîné ...
Je ne sais pas du tout comment le faire, mais pour le moment, j'ai décidé de l'essayer avec mes connaissances!
Apprentissage
Lisez les mêmes données que la première partie, laissez le modèle entraîné l'identifier et laissez le réseau neuronal entraîner le résultat comme entrée.
python
from glob import glob
import random
X = []
y = []
dirs = ["9*/*.jpg ", "0*/*.jpg "]
i = 0
min = 1500
for d in dirs:
files = glob(d)
files = random.sample(files, min if len(files) > min else len(files))
for f in files:
X.append(f)
y.append(i)
i += 1
import pandas as pd
df = pd.DataFrame({"X" : X, "y" : y})
from keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions
#Obtenez un modèle formé de VGG16
model_VGG16 = VGG16()
import cv2
import numpy as np
from keras.preprocessing import image
X = []
y = []
cnt = 0
for idx in df.index:
f = df.loc[idx, "X"]
l = df.loc[idx, "y"]
print("\r{:05} : [{}] {}".format(cnt, l, f), end="")
i += 1
#Chargement des images
img = image.load_img(f, target_size=model_VGG16.input_shape[1:3])
X.append(image.img_to_array(img))
y.append(l)
cnt += 1
print()
#Prétraitement
X = np.array(X)
X = preprocess_input(X)
#Identification par VGG16
preds = model_VGG16.predict(X)
print('preds.shape: {}'.format(preds.shape)) # preds.shape: (1, 1000)
#Définir le résultat de l'identification comme entrée
X = preds
from sklearn import model_selection
test_size = 0.2
#Split pour l'apprentissage, la validation et les tests
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=test_size, random_state=42)
X_valid, X_test, y_valid, y_test = model_selection.train_test_split(X_test, y_test, test_size=.5, random_state=42)
from keras.utils.np_utils import to_categorical
y_train = to_categorical(y_train)
y_valid = to_categorical(y_valid)
y_test = to_categorical(y_test)
from keras.layers import Dense
from keras.models import Sequential
#Créer un modèle d'apprentissage
model = Sequential()
model.add(Dense(64, input_dim=len(X_train[0]), activation='relu'))
model.add(Dense(64, activation='sigmoid'))
model.add(Dense(len(y_train[0]), activation='softmax'))
#compiler
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
#Apprentissage
history = model.fit(
X_train, y_train, batch_size=25, epochs=60,
verbose=1, shuffle=True,
validation_data=(X_valid, y_valid))
import matplotlib.pyplot as plt
#Évaluation et affichage du système de généralisation
score = model.evaluate(X_test, y_test, batch_size=32, verbose=0)
print('validation loss:{0[0]}\nvalidation accuracy:{0[1]}'.format(score))
#acc, val_tracé acc
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")
plt.show()
#loss, val_tracé des pertes
plt.plot(history.history["loss"], label="loss", ls="-", marker="o")
plt.plot(history.history["val_loss"], label="val_loss", ls="-", marker="x")
plt.ylabel("loss")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()
Courir! !!
validation loss:0.0818712607031756
validation accuracy:0.9797570705413818
Oh! Qu'est-ce que c'est ça? !!
Identification et marquage
python
import cv2
import numpy as np
div = 10
cl = (0, 0, 255)
i = 0
#Obtenez une liste d'images de test
testFiles = glob("test/*.JPG")
testFiles.sort()
for f in testFiles:
print(f.split("/")[-1])
#Lire le fichier
img = cv2.imread(f)
img_output = cv2.imread(f)
#print(img.shape)
h, w, c = img.shape
print(f, h, w, c)
#Obtenez le côté court et définissez la taille de division
size = h if h < w else w
size = int(size / 10)
print(size)
i = 0
k = 0
while size * (i + 1) < h:
j = 0
while size * (j + 1) < w:
#Obtenir une image fractionnée
img_x = img[size*i:size*(i+1), size*j:size*(j+1)]
#Identification par VGG16
img_test = cv2.resize(img_x, model_VGG16.input_shape[1:3])
img_test = cv2.cvtColor(img_test, cv2.COLOR_BGR2RGB)
X = np.array([img_test])
X = preprocess_input(X)
preds = model_VGG16.predict(X)
#identification
pred = model.predict(preds, batch_size=32)
m = np.argmax(pred[0])
#La précision est 85%Lorsqu'il est identifié comme une plante
if pred[0][m] > 0.85 and m == 1:
#Dessinez un carré rouge où il est identifié comme une plante
cv2.rectangle(img_output, (size*j + 5, size*i + 5), (size*(j+1) - 5, size*(i+1) - 5), cl, thickness=2)
j += 1
k += 1
i += 1
img_output = img_output[0:size*i, 0:size*j]
f_new = "predicted/{}".format(f.split("/")[-1])
cv2.imwrite(f_new, img_output)
print()
Courir! !!
Parfait! !!
L'apprentissage par transfert est incroyable! ... peut être différent de l'apprentissage par transfert au sens original. Transpiration
Au fait, je ne l'ai pas marqué à la main. Lol
Eh bien, que ferons-nous ensuite?
Recommended Posts