Master Systèmes Electroniques Et Energies Renouvelables

Homework :
Créer et entraîner un modèle de
perceptron avec une fonction d'activation
Heaviside pour la détection de la couleur
noire

Réalisé par : Ayman Ouhajji

 Afin de repérer la couleur noire en recourant à une fonction d'activation fondée sur la
Heaviside, les étapes de la procédure sont exposées de manière détaillée ci-dessous

1. Collecte et préparation des données :

Si l'objectif est de rassembler et de préparer des données en vue de la détection de la couleur noire en
utilisant un réseau de neurones, voici un exposé détaillé des étapes à suivre dans le processus.

Collecte des données :

• Acquérez des exemples d'images ou de pixels, qu'ils renferment ou non la couleur noire. Pour
entraîner notre modèle, vous avez la possibilité d'utiliser des échantillons positifs (contenant la
couleur noire) ainsi que des échantillons négatifs (dépourvus de couleur noire).

Étiquetage des données :

• Procédez à l'attribution précise d'étiquettes à vos données afin d'indiquer la présence ou

l'absence de la couleur noire dans chaque exemple.

Prétraitement des données :

Formatage des données

• Préparez vos données de manière à ce qu'elles soient prêtes à être utilisées en tant qu'entrée
pour le réseau de neurones. Si vous manipulez des images, cela pourrait impliquer le
redimensionnement des images, l'extraction des valeurs de pixels, ainsi que la normalisation.

Extraction des caractéristiques

• Si votre travail implique des images, vous avez la possibilité d'extraire les caractéristiques
pertinentes pour la détection de la couleur noire. Pour chaque pixel, par exemple, vous pouvez
extraire les valeurs NVB (noire, vert, bleu) ainsi que d'autres caractéristiques si cela s'avère
nécessaire.

Encodage des étiquettes

• Dans le cas où vos étiquettes sont textuelles (par exemple, 'noire' ou 'non noire'), il est
nécessaire de les convertir en valeurs numériques. Une approche courante pourrait être
d'utiliser 1 pour représenter la présence de noire et 0 pour son absence.

Séparation des ensembles d'entraînement et de test

• Effectuez la division de vos données en ensembles distincts d'entraînement et de test.

L'ensemble d'entraînement sera dédié à l'apprentissage du modèle, tandis que l'ensemble de
test servira à évaluer ses performances

2. Définition du modèle
• Élaborez un réseau de neurones de type perceptron avec une seule couche. Optez pour la
fonction de Heaviside en tant que fonction d'activation pour la couche de sortie.
3. Définition du modèle
• Élaborez un réseau de neurones de type perceptron avec une seule couche. Optez pour la
fonction de Heaviside en tant que fonction d'activation pour la couche de sortie.

4. Entraînement du modèle
• Employez vos données d'entraînement pour l'apprentissage du modèle. Veillez à ce que les
étiquettes correspondent correctement aux données d'entrée (1 pour noire, 0 pour non noire).

5. Évaluation du modèle
• Procédez à l'évaluation des performances du modèle en utilisant des données de test distinctes.
Cela permettra d'observer la manière dont le modèle prédit la présence ou l'absence de la
couleur noire.

Le code phyton :
• Élaborer et entraîner un modèle de perceptron doté d'une fonction d'activation Heaviside pour
la détection de la couleur noire.
• import numpy as np
•
• # Définition des données d'entraînement
• X_train = np.array([[0.8, 0.2], [0.4, 0.9], [0.3, 0.5], [0.7, 0.8]]) #
Caractéristiques des échantillons (par exemple, les valeurs NVB)
• y_train = np.array([1, 0, 0, 1]) # Étiquettes de classe (1 pour noir, 0
pour non noir)
•
• # Définition de la fonction d'activation Heaviside
• def heaviside(x):
• return np. where(x >= 0, 1, 0)
•
• # Définition de la classe Perceptron
• class Perceptron:
• def _init_(self, input_size):
• self.weights = np.zeros(input_size)
•
• def predict(self, inputs):
• summation = np.dot(inputs, self.weights)
• return heaviside(summation)
•
• def train(self, inputs, labels, epochs, lr):
• for _ in range(epochs):
• for i in range(len(inputs)):
• prediction = self.predict(inputs[i])
• error = labels[i] - prediction
• self.weights += lr * error * inputs[i]
•
• # Création du modèle de perceptron
• input_size = X_train.shape[1]
• model = Perceptron(input_size)
•
• # Entraînement du modèle
• epochs = 100
• learning_rate = 0.1
• model.train(X_train, y_train, epochs, learning_rate)
•
• # Définition des données de test
• X_test = np.array([[0.6, 0.3], [0.2, 0.7], [0.1, 0.4], [0.9, 0.6]]) #
Caractéristiques des échantillons de test
•
• # Prédiction avec le modèle entraîné
• predictions = []
• for i in range(len(X_test)):
• prediction = model.predict(X_test[i])
• predictions.append(prediction)
•
• # Affichage des prédictions
• for i in range(len(X_test)):
• print(f"Échantillon {i+1}: Prédiction={predictions[i]}")
RESUME :

Dans cet exemple, nous abordons le problème de la détection de la couleur noire à partir des
caractéristiques d'échantillons. Chaque échantillon est représenté par des valeurs normalisées NVB (Noir,
Vert, Bleu), formant ainsi un tableau de deux valeurs. L'objectif est de classer les échantillons en deux
catégories : 1 pour les échantillons noire et 0 pour les échantillons non noire.

Pour résoudre ce problème, nous faisons appel à un modèle de perceptron utilisant la fonction
d'activation Heaviside. Le perceptron, en tant que modèle d'apprentissage supervisé, apprend à classifier
les échantillons en ajustant les poids associés aux caractéristiques. La fonction d'activation Heaviside
transforme la somme pondérée des caractéristiques en une prédiction binaire (0 ou 1).

Le code commence par définir les données d'entraînement (X_train et y_train), où X_train contient les
caractéristiques des échantillons, et y_train contient les étiquettes de classe correspondantes.

Ensuite, la fonction d'activation Heaviside est définie, renvoyant 1 si l'entrée est supérieure ou égale à
zéro, sinon elle renvoie 0.

La classe Perceptron est ensuite définie avec les méthodes init, predict et train. La méthode init initialise
les poids du perceptron à zéro. La méthode predict calcule la prédiction en effectuant une somme
pondérée des caractéristiques et en appliquant la fonction d'activation Heaviside. La méthode train
entraîne le modèle en ajustant les poids en fonction de l'erreur de prédiction.

Le modèle de perceptron est créé en instanciant la classe Perceptron avec la taille d'entrée correspondant
au nombre de caractéristiques dans X_train. Ensuite, le modèle est entraîné en appelant la méthode train
avec les données d'entraînement, le nombre d'époques et le taux d'apprentissage.

Les données de test (X_test) sont ensuite définies pour prédire les étiquettes des échantillons de test. Les
prédictions sont stockées dans la liste predictions.

Enfin, les prédictions sont affichées à l'écran pour chaque échantillon de test.