Une histoire à laquelle j'ai pensé en essayant d'identifier les informations de plénitude du parking en utilisant l'image obtenue par la caméra Web et Razpai et le deep learning.

introduction

J'ai pris une photo du parking devant moi depuis la fenêtre du bureau toutes les 5 minutes et j'ai fait une vidéo pour jouer.

Youtube-Weekly Office Window

Au début, c'était juste amusant, mais quand je pensais «je me demande s'il y a autre chose que je peux faire», j'ai trouvé quelque chose comme le titre.

J'ai essayé de rendre ce résultat toujours disponible sur le site. Comme mentionné ci-dessus, les photos sont mises à jour toutes les 5 minutes.

Exemple de surveillance de l'état du parking

Bibliothèque à utiliser

Installez la bibliothèque à utiliser.

OpenCV

pip install -U pip
pip install python-opencv

Tensorflow

pip install tensorflow

Keras

pip install keras

Préparation

Commencez par créer les dossiers suivants.

├ img
│　├ 0-Beaucoup
│　├ 1-Peu
│　└ 2-hochet
└ models

Ensuite, enregistrez les images que vous souhaitez classer dans chaque dossier sous img. Cette fois, nous avons utilisé des images 2019 avec des données d'image pendant environ une semaine.

Beaucoup

Peu

hochet

Apprentissage

Apprenez les images en fonction de la classification des dossiers.

python

#Lecture de la bibliothèque
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

#Création de données d'étiquette
labels = []
for i in range(3):
    labels.append("{}-".format(i))
    
#Obtenez le nombre de fichiers image
n = []

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

#Lecture de fichier image
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

#Convertir les données d'image en données de tableau
X = np.array(imgX)
X = X / 255

#Divisé en données d'apprentissage / de vérification
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)

#Créer un modèle d'apprentissage
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'])

#Apprentissage
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))

#Enregistrer le modèle entraîné
mdlname = "models/mdl_parking_status.h5"
model.save(mdlname)

La sortie du milieu est omise et les résultats d'apprentissage sont les suivants.

validation loss:0.15308915078639984
validation accuracy:0.9653465151786804

Ce qui suit est un graphique du processus d'apprentissage.

Je pense que je peux apprendre d'une manière ou d'une autre.

identification

Identifié par le script suivant.

python

#Lecture de la bibliothèque
import glob
import cv2
from matplotlib import pyplot as plt
import numpy as np
import requests
import keras

#Chargement du modèle entraîné
mdlname = "models/mdl_parking_status.h5"
model = keras.models.load_model(mdlname)

#Créer des données d'étiquette
labels = []

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

labels.sort()

#Lecture d'image
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

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

#Affichage des résultats
print(pred)
print(labels[m])

Cliquez ici pour l'image acquise.

Les résultats de l'identification sont les suivants.

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

... peut-être terminé!