<jupyter_start><jupyter_text>Rappel - Fonctionnement d'un carnet web iPython* Pour exécuter le code contenu dans une cellule d'un carnet iPython, cliquez dans la cellule et faites (⇧↵, shift-enter) * Le code d'un carnet iPython s'exécute séquentiellement de haut en bas de la page. Souvent, l'importation d'une bibliothèque Python ou l'initialisation d'une variable est préalable à l'exécution d'une cellule située plus bas. Il est donc recommandé d'exécuter les cellules en séquence. Enfin, méfiez-vous des retours en arrière qui peuvent réinitialiser certaines variables.  Identification d'objets à partir de photos - jeu de données CIFAR-10 Labo réseau convolutif - architecture de baseInspiration: TensorFlow Tutorial Tutoriel TensorFlow - Réseau neuronal convolutif  Jeu de données - photos CIFAR-10L'ensemble de données CIFAR-10 (Canadian Institute For Advanced Research) comporte 60 000 photographies en couleur de 32×32 pixels d'objets de 10 classes différentes. Il est relativement simple d'atteindre une précision de 80 %. On peut obtenir des performances de 90 % avec ces données avec des réseaux neuronaux convolutifs. * 0 : avion* 1 : automobile* 2 : oiseau* 3 : chat* 4 : chevreuil* 5 : chien* 6 : grenouille* 7 : cheval* 8 : bateau* 9 : camion<jupyter_code>import os
import matplotlib.pyplot as plt

import tensorflow as tf
print("TensorFlow version:",tf.__version__)
import keras
print("Keras version:",keras.__version__)

# Importer le jeu de données CIFAR-10
from keras.datasets import cifar10

dic_noms_classe = { 
    0 : "avion",
    1 : "automobile",
    2 : "oiseau",
    3 : "chat",
    4 : "chevreuil",
    5 : "chien",
    6 : "grenouille",
    7 : "cheval",
    8 : "bateau",
    9 : "camion",
}

# Lire le jeu de données CIFAR-10 et le diviser entre
# les données d'entrainement et les données de test
(attributs_entrainement, classes_cibles_entrainement), (attributs_test, classes_cibles_test) = cifar10.load_data()

# résumé des données 
print()
print('Entraînement: attributs=%s, classes-cibles=%s' % (attributs_entrainement.shape, classes_cibles_entrainement.shape))
print('Test: attributs=%s, classes-cibles=%s' % (attributs_test.shape, classes_cibles_test.shape))

# Afficher les 24 premières images
print()
print("Quelques images avec leur étiquette de classe-cible...")
%matplotlib inline
# définir lagrill d'affichage des images
fig, axes = plt.subplots(nrows=4,ncols=6,figsize=(10,8))
for i_rangee in range(0,4):
    for i_colonne in range(0,6):
        axes[i_rangee,i_colonne].set_title(dic_noms_classe[int(classes_cibles_entrainement[i_rangee*6+i_colonne])],
                                           fontsize=10)
        axes[i_rangee,i_colonne].imshow(attributs_entrainement[i_rangee*6+i_colonne])
plt.show()<jupyter_output>TensorFlow version: 2.5.0
Keras version: 2.5.0

Entraînement: attributs=(50000, 32, 32, 3), classes-cibles=(50000, 1)
Test: attributs=(10000, 32, 32, 3), classes-cibles=(10000, 1)

Quelques images avec leur étiquette de classe-cible...<jupyter_text>Prétraitement des données<jupyter_code># Conversion des classes-cibles en vecteurs binaires à un bit discriminant
from tensorflow.keras.utils import to_categorical

classes_cibles_entrainement = to_categorical(classes_cibles_entrainement)
classes_cibles_test = to_categorical(classes_cibles_test)

# Normalisation

def normalisation(entrainement, test):
    # convertir de nombres entiers à nombres décimaux
    entrainement_normalise = entrainement.astype('float32')
    test_normalise = test.astype('float32')
    # normalisation à un nombre entre 0 et 1
    entrainement_normalise = entrainement_normalise / 255.0
    test_normalise = test_normalise / 255.0
    return entrainement_normalise, test_normalise

attributs_entrainement, attributs_test = normalisation(attributs_entrainement, attributs_test)

print("Normalisation terminée!")<jupyter_output>Normalisation terminée!<jupyter_text>Modèle de base - réseau convolutif<jupyter_code>## Construction du modèle

from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense

print("Création d'un modèle de base...")

input_shape = (32, 32, 3)
batch_size = 32
# nombre de classes
nombre_classes_cibles = 10

modele_de_base = Sequential()

# Apprentissage et extraction des attributs
# couche convolutive
modele_de_base.add(Conv2D(32, 
                          kernel_size=(3,3),
                          activation='relu',
                          kernel_initializer='glorot_uniform',
                          padding='same',
                          strides=(1,1),
                          input_shape=input_shape))
# couche de sous-échantillonnage (pooling)
modele_de_base.add(MaxPooling2D(pool_size=(2,2)))

# Classification des images par un perceptron multicouche
# aplatissement des représentations en un vecteur unique
modele_de_base.add(Flatten())
# couche cachée intégralement connectée
modele_de_base.add(Dense(128,
                         activation='relu'))
# couche de sortie intégralement connectée
modele_de_base.add(Dense(nombre_classes_cibles, 
                         activation='softmax'))

print()
print("Description du modèle de base:")
modele_de_base.summary()
# Compilation du modèle
modele_de_base.compile(loss="categorical_crossentropy", 
                       optimizer="adam", 
                       metrics=["accuracy"])

print("Modèle de base compilé")<jupyter_output>Modèle de base compilé<jupyter_text>Entraînement du modèle<jupyter_code># Entraînement du modèle
print("Entraînement du modèle de base...")

batch_size = 128
epochs = 15

traces_entrainement = modele_de_base.fit(attributs_entrainement,
                                         classes_cibles_entrainement,
                                         batch_size=batch_size,
                                         epochs=epochs,
                                         validation_split=0.1)<jupyter_output>Entraînement du modèle de base...
Epoch 1/15
352/352 [==============================] - 44s 64ms/step - loss: 1.7787 - accuracy: 0.3646 - val_loss: 1.2831 - val_accuracy: 0.5536
Epoch 2/15
352/352 [==============================] - 22s 62ms/step - loss: 1.2451 - accuracy: 0.5632 - val_loss: 1.1566 - val_accuracy: 0.5980
Epoch 3/15
352/352 [==============================] - 28s 80ms/step - loss: 1.1087 - accuracy: 0.6133 - val_loss: 1.0972 - val_accuracy: 0.6112
Epoch 4/15
352/352 [==============================] - 30s 84ms/step - loss: 1.0117 - accuracy: 0.6489 - val_loss: 1.0444 - val_accuracy: 0.6332
Epoch 5/15
352/352 [==============================] - 26s 73ms/step - loss: 0.9522 - accuracy: 0.6667 - val_loss: 1.0419 - val_accuracy: 0.6410
Epoch 6/15
352/352 [==============================] - 28s 78ms/step - loss: 0.8762 - accuracy: 0.6936 - val_loss: 1.0058 - val_accuracy: 0.6522
Epoch 7/15
352/352 [==============================] - 26s 72ms/step - loss: 0.8371 - accuracy: 0.7081 [...]<jupyter_text>Évaluation du modèle<jupyter_code># Évaluation du modèle
print()
print("Évaluation du modèle de base...")

resultats = modele_de_base.evaluate(attributs_test, classes_cibles_test, verbose=0)
print("Exactitude test: {:.2f}%".format(resultats[1]*100))<jupyter_output>Évaluation du modèle de base...
Exactitude test: 65.22%<jupyter_text>Affichage des courbes d'entraînement<jupyter_code># Affichage des courbes d'entraînement
hauteur = 8
plt.subplots(figsize=(hauteur,1.618*hauteur))
plt.subplot(211)
plt.title('Erreur entropie croisée')
plt.plot(traces_entrainement.history['loss'], color='blue', label='courbe entraînement')
plt.plot(traces_entrainement.history['val_loss'], color='orange', label='courbe test')
plt.ylabel("Erreur")
plt.xlabel("Nombre d'époques")
plt.legend()
plt.show()
# tracer l'exactitude
plt.subplots(figsize=(hauteur,1.618*hauteur))
plt.subplot(212)
plt.title('\nExactitude de la classification')
plt.plot(traces_entrainement.history['accuracy'], color='blue', label='courbe entraînement')
plt.plot(traces_entrainement.history['val_accuracy'], color='orange', label='courbe test')
plt.ylabel("Exactitude")
plt.xlabel("Nombre d'époques")
plt.legend()
plt.show()
# Sauvegarde du graphique en format .png
# nom_graphique = "modele_de_base-courbes_entraînement.png"
# plt.savefig(nom_graphique)
# plt.close()
print("Carnet IPython exécution terminée!")<jupyter_output>Carnet IPython exécution terminée!
{'fraction_non_alphanumeric': 0.12514827995255043, 'fraction_numerical': 0.04661921708185053, 'mean_word_length': 4.299182903834066, 'pattern_counts': {'":': 0, '<': 19, '<?xml version=': 0, '>': 19, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 10, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '401622', 'license': 'Apache-2.0', 'n_tokens_mistral': 3186, 'n_tokens_neox': 2908, 'n_words': 688, 'path': 'Labos/Lab-CIFAR_10/Identification_Objets-ResConv-CIFAR_10.ipynb', 'repo_name': 'ClaudeCoulombe/VIARENA', 'size': '8430'}