CNN: Том и Джерри… Вы можете поймать меня?

CNN: Том и Джерри… Вы можете поймать меня?

В предыдущей главе мы говорили о том, «как построить модель CNN» для классификации изображений, классифицируя собаку и кошку. В этом блоге мы будем применять модель CNN с видеовходом.

Как работать с видеоданными?

Собственно, видео создано из серии изображений. Итак, нам нужно извлечь изображение кадр за кадром из видео. Вот и все!!!

В этом примере мы создадим модель CNN, чтобы рассчитать экранное время «Тома» и «Джерри».

Начнем!!!

Шаг 0. Во-первых, нам нужно импортировать необходимое в нашу модель.

import cv2 # для захвата видео
import math # для математических операций
import matplotlib.pyplot as plt # для построения изображений
%matplotlib inline
import pandas as pd
from keras.preprocessing import image # для предварительной обработки изображений
import numpy as np # для математических операций
from keras.utils import np_utils
from skimage.transform import resize # для изменения размера изображений

Шаг 1. Прочтите видео про Тома и Джерри, извлеките из него кадры и сохраните их как изображения.

#########################################
#Шаг — 1: Чтение видео, извлекать из него кадры и сохранять их как изображения
################################### ######
count = 0
videoFile = «Tom and jerry.mp4»
cap = cv2.VideoCapture(videoFile) # захват видео с заданного пути
frameRate = cap.get(5) #частота кадров
x=1
while(cap.isOpened()):
frameId = cap.get(1) #номер текущего кадра
> ret, frame = cap.read()
if (ret != True):
break
if (frameId % math.floor(frameRate) == 0):
имя_файла = "frame%d.jpg" % count;count+=1
cv2.imwrite(имя файла, кадр)
cap.release()
print ("Готово!")
> img = plt.imread('frame0.jpg') # чтение изображения по его имени
plt.imshow(img)

# визуализировать изображение (кадр)
img = plt.imread(‘frame0.jpg’) # чтение изображения по его имени
plt.imshow(img)

Шаг 2. Пометьте несколько изображений для обучения модели

#########################################
#Шаг — 2: Метка несколько изображений для обучения модели
######################################## #
#0 — ни JERRY, ни TOM
#1 — для JERRY
#2 — для TOM
data = pd.read_csv('mapping.csv') # чтение csv file
data.head() # печатаем первые пять строк файла

#читаем изображения, которые мы будем делать на основе их имен
X = [ ] # создаем пустой массив
для img_name в data.Image_ID:
img = plt.imread('' + img_name )
X.append(img) # сохранение каждого изображения в массиве X
X = np.array(X) # преобразование списка в массив

# закодировать три класса с помощью to_categorical()
y = data.Class
dummy_y = np_utils.to_categorical(y) # один класс горячего кодирования

#Изменить размер всего изображения с помощью функции resize()
image =[]
for i in range(0,X.shape[0]):
a = resize(X[i], save_range =True, output_shape=(224,224)).astype(int) #reshape to 224*224*3
image.append(a)

X = np.массив (изображение)

#Предварительная обработка
from keras.applications.vgg16 import preprocess_input
X = preprocess_input(X, mode = ‘tf’) #предварительная обработка входных данных

#validation установлен для проверки производительности модели на невидимых изображениях
из sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X, dummy_y, test_size=0.3, random_state=42) # подготовка набора для проверки

Шаг 3. Создание модели

#########################################
#Шаг 3. Создание модель
########################################
# импортировать необходимые библиотеки для построения модели
из keras.models import Sequential
из keras.applications.vgg16 import VGG16
из keras.layers import Dense, InputLayer, Dropout

# загрузите предварительно обученную модель VGG16 и сохраните ее как base_model
base_model = VGG16(weights=’imagenet’, include_top=False, input_shape=(224, 224, 3)) # include_top=False, чтобы удалить верхний слой

# делать прогнозы, используя эту модель для X_train и X_valid, получать функции, а затем использовать эти функции для повторного обучения модели
X_train = base_model.predict(X_train)
X_valid = base_model.predict(X_valid)
X_train.shape, X_valid.shape

#Форма X_train и X_valid: (208, 7, 7, 512), (90, 7, 7, 512) = › изменить форму на 1D.
X_train = X_train.reshape(208, 7* 7*512) # преобразование в 1-D
X_valid = X_valid.reshape(90, 7*7*512)

#Предварительно обработайте изображение и сделайте его центрированным по нулю, что поможет модели быстрее сходиться
train = X_train/X_train.max() # центрирование данных
X_valid = X_valid/X_train.max()

########################################
#Build the Model_This шаг может быть разделен на 3 подэтапа:
#Построение модели
#Компиляция модели
#Обучение модели

# я. Построение модели
model = Sequential()
model.add(InputLayer((7*7*512,))) # входной слой
model.add(Dense(units=1024, активация ='sigmoid')) # скрытый слой
model.add(Dense(3, активация='softmax')) # выходной слой

#проверить сводку модели с помощью функции summary():
model.summary()

# ii. Компиляция модели
model.compile(loss=’categorical_crossentropy’, Optimizer=’adam’, metrics=[‘accuracy’])

# III. Обучение модели
model.fit(train, y_train, epochs=100, validation_data=(X_valid, y_valid))
#################### #####################

Шаг 4. Расчет экрана времени

#########################################
#Шаг 4: Расчет экранное время
#########################################

# загрузите видео и извлеките кадры
count = 0
videoFile = «Tom and Jerry 3.mp4»
cap = cv2.VideoCapture(videoFile)
frameRate = cap.get( 5) #частота кадров
x=1
while(cap.isOpened()):
frameId = cap.get(1) #номер текущего кадра
ret, frame = cap .read()
if (ret != True):
break
if (frameId % math.floor(frameRate) == 0):
filename =”test%d .jpg” % count;count+=1
cv2.imwrite(имя файла, кадр)
cap.release()
print («Готово!»)

# загрузите файл test.csv, содержащий имена всех извлеченных кадров
test = pd.read_csv(‘test.csv’)

#импортируйте изображения для тестирования, а затем измените их форму в соответствии с требованиями вышеупомянутой предварительно обученной модели:
test_image = []
для img_name в test.Image_ID:
img = plt.imread(' ' + img_name)
test_image.append(img)
test_img = np.array(test_image)

test_image = []
for i in range(0,test_img.shape[0]):
a = resize(test_img[i], save_range=True, output_shape=(224,224)).astype(int )
test_image.append(a)
test_image = np.array(test_image)

### предварительно обработайте изображения, используйте функцию base_model.predict() для извлечения признаков из этих изображений с помощью предварительно обученной модели VGG16, преобразуйте эти изображения в одномерную форму и сделайте их центрированными по нулю:
# предварительная обработка изображения
test_image = preprocess_input(test_image, mode='tf')

# извлечение признаков из изображений с помощью предварительно обученной модели
test_image = base_model.predict(test_image)

# преобразование изображений в 1D-форму
test_image = test_image.reshape(186, 7*7*512)

# изображения с нулевым центром
test_image = test_image/test_image.max()

########################################

Шаг 5. Сделайте прогноз

#########################################
#Шаг 5: Делайте прогнозы для остальных изображений
##########################################

прогнозы = model.predict_classes (test_image)

########################################

Шаг 6. Захватите их на экране!!!

#########################################
#Шаг 6: Расчет экранное время Тома и Джерри
######################################## #

print("Экранное время ДЖЕРРИ равно", Predictions[predictions==1].shape[0], "секунды")
print("Экранное время ТОМА равно", Predictions[predictions==2] .shape[0], «секунды»)

########################################

Выходы…

Экранное время JERRY составляет 5 секунд
Экранное время TOM составляет 131 секунду

Наконец, мы можем рассчитать экранное время как для «Тома», так и для «Джерри», предсказав изображение или кадр (извлеченный из видео) с помощью модели CNN.

Надеюсь, тебе понравится!

Ссылка: https://www.analyticsvidhya.com/blog/2018/09/deep-learning-video-classification-python/