[PYTHON] Eine Geschichte, bei der ich darüber nachdachte, die Informationen über die Fülle des Parkplatzes anhand des von der Webkamera und Razpai erhaltenen Bildes und durch tiefes Lernen zu ermitteln.

Einführung

Ich machte alle 5 Minuten ein Foto vom Parkplatz vor mir aus dem Fenster des Büros und machte ein Video zum Spielen.

Youtube-Weekly Office Window

Am Anfang hat es einfach Spaß gemacht, aber als ich dachte "Ich frage mich, ob ich noch etwas tun kann", habe ich mir so etwas wie den Titel ausgedacht.

Ich habe versucht, dieses Ergebnis immer auf der Website verfügbar zu machen. Wie oben erwähnt, werden die Fotos alle 5 Minuten aktualisiert.

Beispiel für die Überwachung des Parkplatzstatus

Bibliothek zu verwenden

Installieren Sie die zu verwendende Bibliothek.

OpenCV

pip install -U pip
pip install python-opencv

Tensorflow

pip install tensorflow

Keras

pip install keras

Vorbereitung

Erstellen Sie zunächst die folgenden Ordner.

├ img
│　├ 0-Viele
│　├ 1-Wenige
│　└ 2-Rassel
└ models

Speichern Sie als Nächstes die Bilder, die Sie klassifizieren möchten, in jedem Ordner unter img. Dieses Mal haben wir 2019 Bilder mit Bilddaten für ungefähr eine Woche verwendet.

Viele

Wenige

Rassel

Lernen

Lernen Sie Bilder nach Ordnerklassifizierung.

python

#Bibliothek gelesen
import glob
import cv2
from matplotlib import pyplot as plt
import numpy as np

import keras
import tensorflow as tf

from sklearn import model_selection
from keras.utils.np_utils import to_categorical
from keras.layers import Activation, Conv2D, Dense, Flatten, MaxPooling2D, Dropout
from keras.models import Sequential

import random

#Etikettendatenerstellung
labels = []
for i in range(3):
    labels.append("{}-".format(i))
    
#Holen Sie sich die Anzahl der Bilddateien
n = []

for l in labels:
    files = glob.glob("img/{}*/*.jpg ".format(l))
    print("{} : {}".format(l, len(files)))
    
    n.append(len(files))

#Lesen der Bilddatei
imgX = []
y = []

k = 0

for l in labels:
    
    print(l)
    
    files = glob.glob("img/{}*/*.jpg ".format(l))
    files.sort()
    print(len(files), end=" -> ")
    
    j = int(min(n) * 1.5)
    if j > len(files):
        j = len(files)
    
    files = random.sample(files, j)
    print(len(files))
    
    i = 0

    for f in files:
        img = cv2.imread(f)
        h, w, c = img.shape
        img = img[int(h/2):h, :]
        img = cv2.resize(img, (100, 100))
        imgX.append(img)
        y.append(k)
        
        print("\r{}".format(i), end="")

        i += 1

    print()
    k += 1

#Konvertieren Sie Bilddaten in Array-Daten
X = np.array(imgX)
X = X / 255

#Aufgeteilt in Lern- / Verifizierungsdaten
test_size = 0.2

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)

y_train = to_categorical(y_train)
y_valid = to_categorical(y_valid)
y_test = to_categorical(y_test)

#Erstellen eines Lernmodells
input_shape = X[0].shape

model = Sequential()

model.add(Conv2D(
    input_shape=input_shape, filters=64, kernel_size=(5, 5), 
    strides=(1, 1), padding="same", activation='relu'))

model.add(MaxPooling2D(pool_size=(4, 4)))

model.add(Conv2D(
    filters=32, kernel_size=(5, 5), 
    strides=(1, 1), padding="same", activation='relu'))

model.add(Conv2D(
    filters=32, kernel_size=(5, 5), 
    strides=(1, 1), padding="same", activation='relu'))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(
    filters=16, kernel_size=(5, 5), 
    strides=(1, 1), padding="same", activation='relu'))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Flatten())
model.add(Dense(1024, activation='sigmoid'))
model.add(Dense(2048, activation='sigmoid'))

model.add(Dense(len(labels), activation='softmax'))

model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

#Lernen
history = model.fit(
    X_train, y_train, batch_size=400, epochs=200, 
    verbose=1, shuffle=True,
    validation_data=(X_valid, y_valid))

score = model.evaluate(X_test, y_test, batch_size=32, verbose=0)
print('validation loss:{0[0]}\nvalidation accuracy:{0[1]}'.format(score))

#Speichern Sie das trainierte Modell
mdlname = "models/mdl_parking_status.h5"
model.save(mdlname)

Die Ausgabe in der Mitte wird weggelassen und die Lernergebnisse sind wie folgt.

validation loss:0.15308915078639984
validation accuracy:0.9653465151786804

Das Folgende ist eine grafische Darstellung des Lernprozesses.

Ich denke ich kann irgendwie lernen.

Identifizierung

Identifiziert durch das folgende Skript.

python

#Bibliothek gelesen
import glob
import cv2
from matplotlib import pyplot as plt
import numpy as np
import requests
import keras

#Geladenes trainiertes Modell laden
mdlname = "models/mdl_parking_status.h5"
model = keras.models.load_model(mdlname)

#Etikettendaten erstellen
labels = []

for lbl in glob.glob("img/*"):
    labels.append(lbl.split("/")[-1])

labels.sort()

#Bild lesen
img_url = "https://map.blueomega.jp/parking/img.jpg "
req = requests.get(img_url)
img_org = np.fromstring(req.content, dtype='uint8')
img_org = cv2.imdecode(img_org, 1)

h, w, c = img_org.shape
img = img_org[int(h/2):h, :]
img = cv2.resize(img, (100, 100))
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)

X = np.array([img])
X = X / 255

#Identifizierung
pred = model.predict(X, batch_size=32)
m = np.argmax(pred[0])

#Ergebnisanzeige
print(pred)
print(labels[m])

Klicken Sie hier für das aufgenommene Bild.

Die Identifikationsergebnisse sind wie folgt.

[[9.2753559e-01 7.2361618e-02 1.0272356e-04]]
0-Viele

... vielleicht fertig!