Klasifikace obrázků pomocí TensorFlow a Keras

Jak vytvořit konvoluční neuronovou síť (CNN) pro klasifikaci obrázků pomocí TensorFlow a Keras? V tomto příkladu budeme používat dataset CIFAR-10, který obsahuje 60 000 barevných obrázků v 10 třídách, s 6000 obrázky na třídu. Dataset je rozdělen na 50000 trénovacích obrázků a 10000 testovacích obrázků.

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

# Načtení datasetu CIFAR10
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# Normalizace pixelových hodnot do rozsahu 0 až 1
train_images, test_images = train_images / 255.0, test_images / 255.0

# Vytvoření konvolučního základu
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

# Přidání plně propojených vrstev
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

# Kompilace a trénování modelu
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

history = model.fit(train_images, train_labels, epochs=10, 
                    validation_data=(test_images, test_labels))

# Vyhodnocení modelu
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Tento kód vytvoří konvoluční neuronovou síť s třemi konvolučními vrstvami a dvěma plně propojenými vrstvami. Model je trénován na 10 epoch a nakonec je vyhodnocen na testovacím datasetu.

Tento kód můžete použít tak, že ho vložíte do skriptu Pythonu nebo do notebooku Jupyter a spustíte ho. Aby tento kód fungoval, musíte mít nainstalované knihovny TensorFlow a matplotlib. Tyto knihovny můžete nainstalovat pomocí nástroje pip pro správu balíčků Pythonu:

pip install tensorflow matplotlib

Když spustíte tento kód, stáhne se dataset CIFAR-10 a trénovací obrázky budou normalizovány na rozsah 0 až 1. Poté se vytvoří konvoluční neuronová síť s třemi konvolučními vrstvami a dvěma plně propojenými vrstvami. Model se poté zkompiluje a natrénuje na 10 epoch. Nakonec se model vyhodnotí na testovacích datech a vypíše se přesnost testování.

Výstupem bude přesnost modelu na testovacích datech, která ukazuje, jak dobře model klasifikuje obrázky, které nikdy předtím neviděl. Můžete také experimentovat s různými nastaveními, jako je počet epoch, počet vrstev v modelu nebo typy aktivace, abyste zlepšili přesnost svého modelu.

A jak vložit obrázek na možnost testování?

Abychom mohli vložit obrázek pro testování, budeme muset upravit náš kód tak, aby obsahoval funkci pro načítání a předzpracování obrázku. Následující kód ukazuje, jak to lze udělat:

import numpy as np
from tensorflow.keras.preprocessing import image as kp_image

def load_and_process_image(image_path):
    # Load image
    img = kp_image.load_img(image_path, target_size=(32, 32))

    # Convert image to array and preprocess for mobilenet
    img_array = kp_image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array = img_array / 255.0  # normalize to [0,1]

    return img_array

# Load your image
image_path = 'path_to_your_image.jpg'  # replace with your image path
img_array = load_and_process_image(image_path)

# Use the model to predict the class
prediction = model.predict(img_array)
predicted_class = np.argmax(prediction[0], axis=-1)

print('Predicted class:', predicted_class)

Tento kód vloží obrázek, který chcete testovat, načte ho, převede na pole numpy, normalizuje ho na rozsah [0,1], pak použije model pro předpověď třídy obrázku. Výstupem je index třídy s nejvyšší pravděpodobností.

Upozorňuji, že musíte nahradit 'path_to_your_image.jpg' skutečnou cestou k obrázku, který chcete testovat. Navíc tento kód předpokládá, že vaše obrázky jsou stejných rozměrů, jako obrázky, na kterých byl model trénován (v tomto případě 32×32 pixelů). Pokud nejsou, musíte je přeškálovat na správnou velikost.

Zde je celý kód s přidanou funkcí pro načítání a testování obrázku:

import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from tensorflow.keras.losses import sparse_categorical_crossentropy
from tensorflow.keras.optimizers import Adam
import numpy as np
from tensorflow.keras.preprocessing import image as kp_image

# Model configuration
batch_size = 50
img_width, img_height, img_num_channels = 32, 32, 3
loss_function = sparse_categorical_crossentropy
no_classes = 10
no_epochs = 25
optimizer = Adam()
validation_split = 0.2
verbosity = 1

# Load CIFAR-10 data
(input_train, target_train), (input_test, target_test) = cifar10.load_data()

# Determine shape of the data
input_shape = (img_width, img_height, img_num_channels)

# Parse numbers as floats
input_train = input_train.astype('float32')
input_test = input_test.astype('float32')

# Normalize data
input_train = input_train / 255
input_test = input_test / 255

# Create the model
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(no_classes, activation='softmax'))

# Compile the model
model.compile(loss=loss_function,
              optimizer=optimizer,
              metrics=['accuracy'])

# Fit data to model
model.fit(input_train, target_train,
          batch_size=batch_size,
          epochs=no_epochs,
          verbose=verbosity,
          validation_split=validation_split)

# Generate generalization metrics
score = model.evaluate(input_test, target_test, verbose=0)
print(f'Test loss: {score[0]} / Test accuracy: {score[1]}')

# Define the function to load and preprocess the image
def load_and_process_image(image_path):
    # Load image
    img = kp_image.load_img(image_path, target_size=(32, 32))

    # Convert image to array and preprocess for mobilenet
    img_array = kp_image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array = img_array / 255.0  # normalize to [0,1]

    return img_array

# Load your image for testing
image_path = 'path_to_your_image.jpg'  # replace with your image path
img_array = load_and_process_image(image_path)

# Use the model to predict the class
prediction = model.predict(img_array)
predicted_class = np.argmax(prediction[0], axis=-1)

print('Predicted class:', predicted_class)

Upozorňuji, že musíte nahradit 'path_to_your_image.jpg' skutečnou cestou k obrázku, který chcete testovat.