Convolutional Neural Network

Convolution

Couche de convolutions

Une couche de convolution seule ne permet pas de faire grand chose, mais en les associant, on peut apprendre des formes de plus en plus complexes. Dans le cas de la reconnaissance faciale par exemple:

Pooling

Padding

Stride

Architecture

  1. Convolutional base
    Un CNN commence par une suite de convolutions.
    On peut considérer cette phase comme une phase de détection des caractéristiques présentes dans l’image.

  2. Dense head
    Le résultat des convolutions est passé à un réseau neuronal artificiel classique,
    qui utilise l’association de caractéristiques trouvées pour classifier l’image.

Flatten

En pratique

python 
# Import libraries
import tensorflow as tf

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

# Import data
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

train_images = train_images / 255.0
test_images  = test_images / 255.0

class_names  = ['airplane', 'automobile', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck']

# Create model
model = models.Sequential()

#> Convolutional base
model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same'))

#> Dense layers
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

#> Compiling
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Train
history = model.fit(train_images, train_labels, epochs=4, 
                    validation_data=(test_images, test_labels))

# Evaluate
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print(test_acc)

The convolutional classifier

Optimisations

Transfer learning

python 
IMG_SHAPE = (IMG_SIZE, IMG_SIZE, 3)

# Create the base model from the pre-trained model MobileNet V2
base_model = tf.keras.applications.MobileNetV2(
  input_shape=IMG_SHAPE,                                               
  include_top=False,                                                  
  weights='imagenet')

base_model.trainable = False

# Add dense layers
model = tf.keras.Sequential([
  base_model,
  tf.keras.layers.GlobalAveragePooling2D(),
  keras.layers.Dense(1)
])

# Define optimizer
model.compile(optimizer=tf.keras.optimizers.RMSprop(lr=0.0001),
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=['accuracy'])

# We can evaluate the model right now to see how it does before training it on our new images
loss0, accuracy0 = model.evaluate(validation_batches, steps=20)

# Train it on our images
history = model.fit(train_batches,
                    epochs=3,
                    validation_data=validation_batches)

print(history.history['accuracy'])

import tensorflow_hub as hub

pretrained_base = tf.keras.models.load_model(
    '../input/cv-course-models/cv-course-models/inceptionv1'
)
pretrained_base.trainable = False

model = keras.Sequential([
    pretrained_base,
    layers.Flatten(),
    layers.Dense(6, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

ImageNet subtrees

Augmenter les données

Si le dataset est petit, on peut facilement créer de nouvelles images à partir des images existantes — tourner, inverser, zoomer, rogner, etc.

Beginner’s Guide:CNNs and Data Augmentation

python 
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator

#--------------------------------------
# VIEW TRANSFORMATIONS

# creates a data generator object that transforms images
datagen = ImageDataGenerator(
  rotation_range=40,
  width_shift_range=0.2,
  height_shift_range=0.2,
  shear_range=0.2,
  zoom_range=0.2,
  horizontal_flip=True,
  fill_mode='nearest')

# pick an image to transform
test_img = train_images[20]
img = image.img_to_array(test_img)   # convert image to numpy array
img = img.reshape((1,) + img.shape)  # reshape image

i = 0

# this loop runs forever until we break,
# saving images to current directory with specified prefix
for batch in datagen.flow(
    img,
    save_prefix='test',
    save_format='jpeg'
):
    plt.figure(i)
    plt.imshow(image.img_to_array(batch[0]))

    # show 4 images then stop
    i += 1
    if i > 4:
        break

plt.show()

#--------------------------------------
# TRAIN MODEL USING GENERATOR

train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(150, 150),
    batch_size=32,
    class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
    validation_dir,
    target_size=(150, 150),
    batch_size=32,
    class_mode='binary')

history = model.fit(
    train_generator,
    steps_per_epoch=100,
    epochs=100,
    validation_data=validation_generator,
    validation_steps=50)
This site is open source. Improve this page.