Fascicule IA

République Tunisienne
Ministère de l’Enseignement Supérieur et de la Recherche

Scientifique
Université de Monastir
Faculté des Sciences de Monastir (FSM)
Département Physique
Intelligence Artificielle
Enseignant : Ayadi Wadhah

Année Universitaire: 2021/2022
Présentation du TP
Parcours : 3ème année Systèmes Embarqués
Semestre : S1
Intitulé du module : Intelligence Artificielle
Nombre d’heures : XX
Système d’évaluation : Contrôle continu
Résumé
Les TP de l'intelligence artificielle sont s’adressés aux étudiants de troisième année Systèmes
Embarqués. Ils permettent aux étudiants d’approfondir leurs connaissances dans le domaine de
l'intelligence artificielle et à maîtriser tous ce qui est vu en cours en se basant sur le langage
Python et sous l’outil Py Charm.
Objectif Général
Ces travaux pratiques ont pour but d'approfondir les compétences acquises par les étudiants
en intelligence artificielle (Python) :
 Familiariser avec l’outil PyCharm et le langage de programmation Python,
 Écrire et simuler quelques codes simples,
 Comprendre quelques notions de réseaux de neurones (perceptron) et implémenter
quelques algorithmes simples dans le but de représenter les portes logiques : NOT, AND
et OR,
 Comprendre la notion de régression linéaire simple et implémenter un exemple,
 Apprendre à mettre en œuvre un réseau de neurones simple et implémenter un exemple.
2
Contenu théorique
TP 1 : Prise en main de Python.

TP 2 : Introduction aux réseaux de neurones.
TP 3 : Régression linéaire simple.
TP 4 : Classification des images à l'aide d'un réseau de neurones.
3
AYADI Wadhah TP1 : Prise en main de Python
Intelligence Artificielle TP 1 : Prise en main de AU : 2021/2022

Python Filière : LSE3
I. Objectif
L’objectif de ce TP est de:
1. Familiariser avec l’outil PyCharm et le langage de programmation Python.
2. Écrire et simuler quelques codes simples.
3. Apprendre à simuler quelques applications à travers les principaux éléments constitutifs des
programmes.
II. Prise en main de Python
1. Commentaires
Ironiquement, la première chose que nous allons faire est de montrer comment dire à un
ordinateur d'ignorer une partie d'un programme. Le texte écrit dans un programme mais non
exécuté par l'ordinateur est appelé commentaire. Python interprète n'importe quoi après un #
comme un commentaire.
#it's a comment
print("Hello World!")
2. Chaînes multi-lignes
Les chaînes Python sont très flexibles, mais si nous essayons de créer une chaîne qui occupe
plusieurs lignes, nous nous retrouvons face à face avec une SyntaxError. Python propose une
solution : les chaînes multilignes. En utilisant trois guillemets (""" ou ''') au lieu d'un, nous
disons au programme que la chaîne ne se termine qu'au prochain triple guillemet.
3. fonction print()
print("Hello World!")
print(100)
pi = 3.14159
print(pi)
4
La fonction print() est utilisée pour afficher du texte, des nombres ou d'autres informations
imprimables sur la console.
Il prend un ou plusieurs arguments et affichera chacun des arguments sur la console séparés par
un espace. Si aucun argument n'est fourni, la fonction print() affichera une ligne vide.
4. Chaînes
Une chaîne est une séquence de caractères (lettres, chiffres, espaces ou ponctuation) entourés
de guillemets. Il peut être mis entre guillemets " ou guillemets simples ".
Si une chaîne doit être divisée en plusieurs lignes, la barre oblique inverse \ peut être utilisée
pour indiquer que la chaîne continue sur la ligne suivante.
user = "User Full Name"

game = 'Monopoly'
longer = "This string is broken up \
over multiple lines"
5. Formes de chaîne
Python utilise plusieurs formes de chaîne. L'opérateur "%" est utilisé pour former un ensemble
de variables enfermées dans un "tuple" (une liste de taille fixe), avec une chaîne qui contient du
texte normal ainsi que des "spécificateurs d'arguments", des symboles spéciaux comme "%s"
et "%d".
Disons que vous avez une variable appelée "nom" avec votre nom d'utilisateur dedans, et que
vous souhaitez ensuite imprimer (un message d'accueil à cet utilisateur.)
name = "John"
print("Hello, %s!" % name)
# This prints out "Hello, John!"
name = "John"
age = 23
print("%s is %d years old." % (name, age))
# This prints out "John is 23 years old."
6. Concaténation de chaînes
5
Python prend en charge la jointure (concaténation) de chaînes à l'aide de l'opérateur +.

L'opérateur + est également utilisé pour les opérations d'addition mathématique. Si les
paramètres passés à l'opérateur + sont des chaînes, alors la concaténation sera effectuée. Si le
paramètre passé à + a des types différents, Python signalera une condition d'erreur. Plusieurs
variables ou chaînes littérales peuvent être réunies à l'aide de l'opérateur +.
# String concatenation
first = "Hello "
second = "World"
result = first + second
print(result)
long_result = first + second + "!"
print(long_result)
7. Entiers
Un entier est un nombre qui peut être écrit sans partie décimale (pas de décimale). Un nombre
entier peut être un nombre positif, un nombre négatif ou le nombre 0 tant qu'il n'y a pas de partie
décimale.
Le nombre 0 représente une valeur entière mais le même nombre écrit que 0.0 représenterait un
nombre à virgule flottante.
# Example integer numbers

chairs = 4
tables = 1
broken_chairs = -2
sofas = 0
# Non-integer numbers
lights = 2.5
left_overs = 0.0
8. Variables
Le langage Python est un langage fortement typé, ce qui signifie que chaque variable, à chaque
instant, ne peut être que d'un type. Par contre, ce typage est dynamique, ce qui signifie qu'à la
déclaration d'une variable, il n'est pas nécessaire de déclarer son type : c'est la valeur qu'on
6
affectera à la variable qui déterminera son type. La déclaration d'une variable est donc une
instruction du type :
ma_variable = 12
Il est possible de connaître le type d’une variable en utilisant la fonction type :
print(type(ma_variable))
Déclarez une variable ma_variable et affectez-lui la valeur 2 . Quel est le type de cette variable
? Répétez l’opération avec les valeurs suivantes :
 2.5
 2. (notez le caractère . final)
 2 + 2.5
 'a'
 10 / 3
 10 / 2
9. Opérations arithmétiques
Python prend en charge différents types d'opérations arithmétiques qui peuvent être effectuées
sur des nombres littéraux, des variables ou une combinaison. Les principaux opérateurs
arithmétiques sont :
 + pour l'ajout
 - pour la soustraction
 * pour multiplier
 / pour la division
 % pour le module (renvoie le reste)
 ** pour l'exponentiation
print(573 - 74 + 1)
print(25 * 2)
print(10 / 5)
7
10. Opérateur Plus-Égal à +=
# Plus-Equal Operator
counter = 0
counter += 10
# This is equivalent to
counter = 0
counter = counter + 10
L'opérateur plus-égal += fournit un moyen pratique d'ajouter une valeur à une variable existante
et de réaffecter la nouvelle valeur à la même variable. Dans le cas où la variable et la valeur
sont des chaînes, cet opérateur effectue une concaténation de chaînes au lieu d'une addition.
L'opération est effectuée sur place, ce qui signifie que toute autre variable qui pointe vers la
variable en cours de mise à jour sera également mise à jour.
11. Exposants
Python peut également effectuer une exponentiation. En mathématiques écrites, vous pouvez
voir un exposant comme un nombre en exposant, mais taper des nombres en exposant n'est pas
toujours facile sur les claviers modernes. Puisque cette opération est tellement liée à la
multiplication, nous utilisons la notation **.
# 2 to the 10th power, or 1024

print(2 ** 10)
# 8 squared, or 64
print(8 ** 2)
# 9 * 9 * 9, 9 cubed, or 729
print(9 ** 3)
# We can even perform fractional exponents
# 4 to the half power, or 2
print(4 ** 0.5)
Ici, nous calculons quelques exposants simples. Nous calculons 2 à la puissance 10, 8 à la
puissance 2, 9 à la puissance 3 et 4 à la puissance 0,5.
12. Les listes
Les listes sont très similaires aux tableaux. Ils peuvent contenir n'importe quel type de variable,
et ils peuvent contenir autant de variables que vous le souhaitez. Les listes peuvent également
8
être itérées de manière très simple. Le premier index est zéro, le deuxième index est un, et ainsi
de suite. Voici un exemple de la façon de créer une liste.
mylist = [1,2,3,4,5]
print(mylist[0])
print(mylist[4])
even_numbers = [2,4,6,8]
odd_numbers = [1,3,5,7]
all_numbers = odd_numbers + even_numbers
print(all_numbers)
# prints out [1, 3, 5, 7, 2, 4, 6, 8]
13. Conditions
Python utilise la logique booléenne pour évaluer les conditions. Les valeurs booléennes True et
False sont retournés lorsqu'une expression est comparée ou évaluée. Par exemple :
x=2
print(x == 2) # prints out True
print(x == 3) # prints out False
print(x < 3) # prints out True
print(x > 3) # prints out False
14. Boucle "for"
Les boucles for itèrent sur une séquence donnée. Voici un exemple :
primes = [2, 3, 5, 7]
for prime in primes:
print(prime)
# prints out 2, 3, 5, 7
15. Boucles "while"
9
Les boucles While se répètent tant qu'une certaine condition booléenne est remplie. Par exemple
:
count = 0
while count < 5:
print(count)
count += 1 # This is the same as count = count + 1
# prints out 0, 1, 2, 3, 4
16. Instructions IF, ELIF et ELSE
Lorsque vous écrivez du code dans n'importe quel langage, vous devrez contrôler le flux de
votre programme. C'est généralement le cas lorsqu'une prise de décision est impliquée- vous
voudrez exécuter une certaine ligne de codes si une condition est satisfaite, et un autre ensemble
de codes dans le cas contraire. En Python, vous avez les instructions if, elif et else à cet effet.
Dans ce didacticiel, vous allez travailler avec un exemple pour en savoir plus sur l'instruction
if simple et passer progressivement aux instructions if-else, puis aux instructions if-elif-else.
Instruction if simple
Il s'agit de l'exemple le plus simple d'une instruction conditionnelle. La syntaxe est la suivante
if(condition) :
Bloc d'instructions en retrait
Le bloc de lignes indenté de la même manière après les deux points (:) sera exécuté lorsque la
condition est VRAIE.
Par exemple, disons que vous enregistrez le score d'un certain cours. Le score total est de 100,
dont 50 points pour le travail théorique et 50 pour le travail pratique. Vous souhaitez afficher
un message d'erreur ou un avertissement si la note dépasse 100.
score_theory = 40
score_practical = 45
if(score_theory + score_practical > 100):
10
print("Invalid score. Please check the input.")
Instruction if-else
L'instruction if-else est utilisée pour coder de la même manière que vous l'utiliseriez dans le
code précédent. La syntaxe de l'instruction if-else est la suivante :
score_theory = 40
if(score_theory + score_practical > 100):
print("Please check the input. Score exceeds total possible score.")
else:
print("Score validated. Your total is: ", score_theory + score_practical)
Instruction if-elif-else
score_theory = 60
if(score_theory > 50):
print("Please check the input score for 'Theory'.")
elif(score_practical > 50):
print("Please check the input score for 'Practical'.")
else:
print("Score validated. Your total is: ",score_theory + score_practical)
17. Fonctions
Les fonctions sont un moyen pratique de diviser votre code en blocs utiles, ce qui nous permet
d'ordonner notre code, de le rendre plus lisible, de le réutiliser et de gagner du temps. Les
fonctions sont également un moyen essentiel de définir des interfaces afin que les
programmeurs puissent partager leur code.
def my_function():
print("Hello From My Function!")
11
def sum_two_numbers(a, b):

return a + b
III. Application
Exercice 1 :
Création du premier programme : Utilisez la fonction "print" pour imprimer la ligne "Hello,
World!".
Étape 1) Ouvrez l'éditeur PyCharm. Vous pouvez voir l'écran d'introduction de PyCharm.
Pour créer un nouveau projet, cliquez sur « Créer un nouveau projet ».
Étape 2) Vous devrez sélectionner un emplacement.
Vous pouvez sélectionner l'emplacement où vous souhaitez que le projet soit créé. Si vous ne
voulez pas changer d'emplacement, gardez-le tel quel, mais changez au moins le nom de "sans
titre" en quelque chose de plus significatif, comme "FirstProject".
PyCharm devrait avoir trouvé l'interpréteur Python que vous avez installé précédemment.
Cliquez ensuite sur le bouton « Créer ».
12
Étape 3) Maintenant, allez dans le menu "Fichier" et sélectionnez "Nouveau". Ensuite,

sélectionnez "Fichier Python".
Étape 4) Une nouvelle fenêtre contextuelle apparaîtra. Tapez maintenant le nom du fichier
que vous voulez (Ici, nous donnons "HelloWorld") et appuyez sur "OK".
Étape 5) Tapez maintenant un programme simple – print (« Hello World ! »).
13
Étape 6) Maintenant, allez dans le menu « Exécuter » et sélectionnez « Exécuter » pour

exécuter votre programme.
Étape 7) Vous pouvez voir la sortie de votre programme en bas de l'écran.
Exercice 2 :
Vous devrez écrire les instructions qui permettent d’afficher les données suivantes :
Bonjour John Doe. Votre solde actuel est de 5,44 $.
Exercice 3 :
Ecrivez les instructions suivantes et commentez les résultats obtenus:
astring = "Hello world!"

print(len(astring))
print(astring.index("o"))
14
print(astring[3:7])
print(astring[::-1])
print(astring.upper())
print(astring.lower())
print(astring.startswith("Hello"))
print(astring.endswith("asdfasdfasdf"))
Exercice 4 :
Demandez à l'utilisateur un numéro. Tester si le nombre est pair ou impair et imprimer un

message approprié à l'utilisateur.
Exercice 5 :
Étant donné un fichier .txt contenant une liste de noms. La base de la lecture d'un fichier est
que vous devez lire chaque ligne une par une, en ne lisant la ligne suivante que si elle existe.
Lire le contenu du fichier, et imprimez les résultats à l'écran.
15
AYADI Wadhah TP2 : Introduction aux réseaux de neurones
Intelligence Artificielle TP 2 : Introduction aux AU : 2021/2022

réseaux de neurones Filière : LSE3
I. Objectif
1. Comprendre quelques notions de réseaux de neurones.
2. Implémenter un algorithme simple de Perceptron mono couche à une seule entrée dans le but
de représenter la porte logique : ‘NOT’.
3. Implémenter quelques algorithmes simples de Perceptron mono couche à deux entrées dans
le but de représenter les portes logiques : ‘AND’ et ‘OR’.
4. Appliquer les ports implémentés précédemment pour réaliser le port ‘XOR’.
II. Qu'est-ce qu'un perceptron ?
Le perceptron est un modèle simple de neurone. La formulation du perceptron a été la première

étape vers la modélisation du cerveau humain et du réseau neuronal biologique. Les perceptrons
sont des structures de données simples et ils sont très faciles à apprendre. Un perceptron est un
nœud d'un grand réseau interconnecté, tout comme les neurones du cerveau humain. Les liens
entre ces nœuds montrent la relation entre les nœuds ainsi que la transmission des données et
des informations.
Un perceptron possède un certain nombre de liens d'entrée externes, une entrée interne (appelée
biais), un seuil et une sortie. Habituellement, les valeurs d'entrée sont booléennes (c'est-à-dire
qu'elles ne peuvent avoir que deux valeurs possibles : 1 ou 0), mais elles peuvent aussi être
n'importe quel nombre réel. La sortie du perceptron, cependant, est toujours booléenne. Lorsque
la sortie est activée (à la valeur 1), on dit que le perceptron fonctionne.
Le réseau neuronal le plus simple est le "perceptron", qui, dans sa forme la plus simple, consiste
en un seul neurone. À l'instar des neurones biologiques, qui possèdent des dendrites et des
axones, le neurone artificiel unique est une structure arborescente simple comportant des nœuds
d'entrée et un nœud de sortie unique, qui est connecté à chaque nœud d'entrée. Voici une
comparaison visuelle des deux :
16
Un perceptron est une unité de réseau neuronal qui effectue un calcul précis pour détecter des
caractéristiques dans les données d'entrée. Le perceptron est principalement utilisé pour classer
les données en deux parties. C'est pourquoi il est également connu sous le nom de classificateur
binaire linéaire. Un réseau neuronal classique ressemble à ceci :
Le perceptron se compose de 4 parties.
La valeur d'entrée ou une couche d'entrée : La couche d'entrée du perceptron est constituée
de neurones d'entrée artificiels et prend les données initiales dans le système pour un traitement
ultérieur.
Poids et biais :
Poids : Il représente la dimension ou la force de la connexion entre les unités. Si le poids du

nœud 1 est plus élevée qu'au nœud 2, alors le neurone 1 a une influence plus considérable sur
le neurone.
17
Biais : il est identique à l'ordonnée à l'origine ajoutée dans une équation linéaire. Il s'agit d'un
paramètre supplémentaire dont la tâche est de modifier la sortie avec la somme pondérée de
l'entrée de l'autre neurone.
Somme: Elle calcule la somme totale.
Fonction d'activation : Un neurone peut être activé ou non, ce qui est déterminé par une
fonction d'activation. La fonction d'activation calcule une somme pondérée à laquelle elle ajoute
un biais pour donner le résultat.
III. Comment fonctionne-t-il ?

Le perceptron fonctionne selon les étapes simples suivantes :
a. Dans la première étape, toutes les entrées x sont multipliées par leurs poids w.
b. Dans cette étape, on additionne toutes les valeurs augmentées et on les appelle la somme
pondérée.
c. Dans la dernière étape, appliquez la somme pondérée à une fonction d'activation correcte.
18
Par exemple :
Une fonction d'activation d'étape unitaire.
IV. Type de perceptron
Il existe deux types d'architecture de perceptron. Ces types se concentrent sur la fonctionnalité
des réseaux neuronaux artificiels comme suit :
- Perceptron mono couche

- Perceptron multicouche
1. Perceptron mono couche
Le type de réseau neuronal le plus simple est le réseau perceptron à couche unique. Il se
compose d'une seule couche de nœuds de sortie. Les entrées sont directement transmises aux
sorties par une série de poids. De cette façon, il peut être considéré comme le type le plus simple
de réseau à action directe. La somme des produits des poids et des entrées est calculée dans
chaque nœud. Si cette valeur est supérieure à un certain seuil, le neurone se déclenche et prend
la valeur activée. Sinon, il prend la valeur désactivée. Les perceptrons à une unité ne sont
capables d'apprendre que des modèles linéairement séparables.
2. Perceptron multicouche
Un perceptron à une seule couche est un modèle très simple. Dans le monde réel, les choses
sont beaucoup plus complexes. Pour se rapprocher de ce qui se passe réellement dans le cerveau,
nous devons étendre le perceptron monocouche. D'où l'idée du perceptron multicouche. Un
perceptron multicouche est un réseau interconnecté de perceptrons conçu pour apprendre et
prendre automatiquement des décisions intelligentes. Pour les perceptrons multicouches, nous
utilisons à nouveau une règle d'apprentissage supervisé connue sous le nom de "règle de
rétropropagation". Cette catégorie de réseaux se compose de plusieurs couches d'unités de
calcul, généralement interconnectées de manière à ce que les neurones soient dirigés vers
19
l'avant. Chaque neurone d'une couche a des connexions dirigées vers les neurones de la couche
suivante.
Lorsque nous montrons un modèle d'entrée à un réseau non entraîné, il produit une sortie
aléatoire. Comment va-t-il savoir comment se modifier pour produire les sorties correctes ?
Nous devons définir une fonction d'erreur qui représente la différence entre la sortie produite
par le réseau et la sortie que nous souhaitons. Cette fonction d'erreur doit être continuellement
réduite pour que notre sortie atteigne celle de la sortie souhaitée.
Pour y parvenir, nous ajustons les poids des liens entre les couches. Pour ce faire, nous calculons
l'erreur pour une entrée particulière et la propageons en retour dans la couche précédente. Ainsi,
chaque unité du réseau voit ses poids ajustés de manière à réduire la valeur de la fonction
d'erreur et le réseau apprend.
V. Application
Perceptron mono couche à une entrée
Exercice 1 : Porte NON (NOT)
Dans notre prochain exemple, nous allons programmer un réseau de neurones en Python qui
implémente la fonction logique " NOT ". Il est défini pour une seule entrée comme montre la
figure suivante :
Pour commencer, suivre les étapes suivantes :
- Réaliser un appel aux bibliothèques nécessaires pour l’exécution de code.

- Taper la fonction unitStep qui assure la comparaison de résultat à la valeur seuil.
- Taper la fonction perceptronModel qui assure le calcul de résultat.
20
- Taper la fonction NOT_logicFunction qui assure de fournir le résultat final.

- Essayez de changer les valeurs de w et b et vérifiez la sortie !.
Perceptron mono couche à deux entrées
Exercice 2 : Porte ET (AND)
On peut dire que tout ce que fait un perceptron, c'est appliquer des transformations (fonctions
mathématiques) à un ensemble d'entrée pour les représenter de manière significative dans
l'espace. Outre les transformations, nous avons besoin d'une étape supplémentaire pour que les
choses fonctionnent : l'étape d'apprentissage. L'étape d'apprentissage vérifie si notre
transformation fonctionne bien. Pour cela, nous avons besoin de la réponse à notre problème
pour comparer si notre sortie actuelle est correcte (ou proche de la bonne réponse). Pour illustrer
cela, regardez la table de vérité de la porte ET.
Nous avons un ensemble d'entrée ([0,0], [0,1], [1,0], [1,1]) et leurs sorties respectives ([0, 0, 0,
1]) que nous pouvons considérer comme leurs étiquettes dans un problème d'apprentissage
automatique. Nous pouvons représenter la porte ET de manière géométrique, en utilisant les
entrées comme coordonnées et les sorties comme caractéristiques de ces points (comme des
couleurs) :
21
Pour chaque entrée, nous avons un point dans l'espace avec des coordonnées (x, y), et les
couleurs des points représentent la sortie de la porte ET (bleu si sortie = 0, rouge si entrée = 1).
Cela nous donne donc un problème de classification (nous avons deux classes de points, bleu
et rouge (ou sortie ET 0 et 1), et nous voulons séparer l'espace en conséquence avec ces classes,
comme ça :
En suivant les étapes de l'exercice 1, essayé d’implémenter un réseau de neurones compatible

avec les données de la fonction AND.
Exercice 3 : Porte OU (OR)
Maintenant, nous allons programmer un réseau de neurones en Python qui implémente la

fonction logique " OR ". En se basant sur les étapes de l'exercice 1 et les données fournies par
la figure suivante, essayé de taper le code.
22
Exercice 4 : Porte XOR
En se basant sur les ports implémentés précédemment, essayé d’implémenter un réseau de

neurones compatible avec les données de la fonction ‘XOR’.
23
AYADI Wadhah TP 3 : Régression linéaire simple
Intelligence Artificielle TP 3 : Régression linéaire AU : 2021/2022

simple Filière : LSE3
I. Objectif
- Comprendre la notion de régression linéaire simple.
- Implémentation d’un exemple de régression linéaire simple en utilisant Python.
II. Qu'est-ce qu'une régression linéaire simple ?
La régression linéaire simple est une approche statistique qui permet d'étudier et de résumer la
relation entre deux variables quantitatives continues. La régression linéaire simple est utilisée
dans les modèles d'apprentissage automatique, les mathématiques, la modélisation statistique,
la prévision des épidémies et d'autres domaines quantitatifs.
Parmi les deux variables, l'une est appelée variable dépendante, et l'autre variable indépendante.
Notre objectif est de prédire la valeur de la variable dépendante en fonction de la valeur de la
variable indépendante. Une régression linéaire simple vise à trouver la meilleure relation entre
les deux.
Il existe trois types de relations. La relation où nous pouvons prédire la variable de sortie à l'aide
de sa fonction s'appelle une relation déterministe (Diamètre = 2*pi*radius, Fahrenheit =
1,8*celsius+32). Dans les relations aléatoires, il n'existe aucune relation entre les variables.
Dans notre monde statistique, il est peu probable d'avoir une relation déterministe. En
statistique, nous avons généralement une relation qui n'est pas si parfaite, que l'on appelle une
relation statistique, qui est un mélange de relations déterministes et aléatoires (Nombre de
chocolats par rapport au coût, Revenu vs. Dépense).
24
Cas d'utilisation de la régression linéaire :
1. Taille et poids.
2. Consommation d'alcool et taux d'alcoolémie.
3. La capacité pulmonaire vitale et les paquets-années de tabagisme.
4. La vitesse de conduite et la consommation d'essence.
III. Comprendre la régression linéaire simple :
Le type de modèle de régression le plus simple en apprentissage automatique est une régression
linéaire simple. Tout d'abord, nous allons étudier le plus simple exemple.
À partir des données collectées, on a pu tracer les données sur un diagramme de dispersion :
Si nous observons attentivement le graphique ci-dessus, nous pouvons remarquer que nous
pouvons relier nos deux points de données par une ligne, et comme nous le savons, chaque ligne
a son équation. À partir de la figure, nous pouvons rapidement obtenir le prix de la maison si
nous connaissons la surface de la maison. Il sera plus facile pour nous d'obtenir le prix de la
maison en utilisant une formule.
A partir de notre graphe, nous pouvons déduire que:

( X 1, Y1)  (1500,150000)
25
( X 2, Y 2)  (2500,300000)
Ensuite, nous pouvons facilement trouver la pente des deux points.

300000  150000 150000
m   150
2500  1500 1000
Si l'on prend notre exemple, dans notre équation, Y représente le prix de la maison, et X la
surface de la maison.
Maintenant que nous avons toutes les autres valeurs, nous pouvons calculer la valeur de la
pente b.
Y  mX  b
b  Y  mX
( X , Y )  (1500,150000)
b  150000  150*1500  75000
( X , Y )  (2500,300000)
b  300000  150*2500  75000
Remarquez que nous pouvons utiliser n'importe lequel des points pour calculer la valeur de la
pente. La réponse à la pente sera toujours la même pour une même ligne droite.
Ensuite, puisque nous avons tous nos paramètres, nous pouvons écrire l'équation de la droite
comme suit :
Y  mX  b
Y  150 X  75000
Pour trouver le prix de la maison, nous devons introduire X=1800 dans l'équation ci-dessus.
Y  mX  b
Y  150 X  75000  150*1800  75000  195000
Maintenant, on peut dire que Patrick devrait vendre sa maison pour 195 000 $.
Notez que nous n'avions que deux points de données pour tracer rapidement une seule ligne
droite à travers eux et obtenir notre équation d'une ligne. Dans ce cas, la chose essentielle à
noter ici est que notre prédiction dépendra de la valeur de deux points de données. Si nous
changeons la valeur de l'un des deux points de données disponibles, notre prédiction changera
26
probablement aussi. Pour faire face à ce problème, nous disposons d'ensembles de données en
plus grande quantité. Les ensembles de données du monde réel peuvent contenir des millions
de points de données.
Revenons maintenant à notre exemple. Lorsque nous avons plus de deux points de données
dans notre ensemble de données (le cas habituel), nous ne pouvons pas tracer une seule ligne
droite qui passe par tous les points. C'est pourquoi nous allons utiliser une ligne qui correspond
le mieux à notre ensemble de données. Cette ligne est appelée ligne de meilleur ajustement ou
ligne de régression. En utilisant l'équation de cette ligne, nous pourrons faire des prédictions
sur notre ensemble de données.
Veuillez noter que le concept central reste le même. Nous allons trouver l'équation de la droite
et y insérer la valeur de X (variable indépendante) pour trouver la valeur de Y (variable
dépendante). Nous devons trouver la ligne de meilleur ajustement pour notre ensemble de
données.
IV. Calcul de la meilleure adéquation linéaire
Comme nous pouvons le voir dans la figure suivante, nous ne pouvons pas tracer une seule
ligne droite qui passe par tous les points. Ce que nous pouvons faire ici est donc de minimiser
l'erreur. Cela signifie que nous trouvons une droite, puis l'erreur de prédiction. Puisque nous
avons la valeur réelle ici, nous pouvons facilement trouver l'erreur de prédiction. Notre objectif
final sera de trouver la ligne qui a l'erreur minimale. Cette ligne est appelée la meilleure
adaptation linéaire.
27
Comme nous l'avons vu plus haut, notre objectif est de trouver le meilleur ajustement linéaire
pour notre ensemble de données, ou en d'autres termes, nous pouvons dire que notre objectif
devrait être de réduire l'erreur de prédiction. La question est maintenant de savoir comment
calculer l'erreur. Une manière de mesurer la distance entre les points dispersés et la ligne est de
trouver la distance entre leurs valeurs Y.
Pour mieux comprendre, revenons à notre exemple de prédiction du prix réel d'une maison.
Nous savons que le prix de vente réel d'une maison d'une surface de 1800 pieds carrés est de
220 000 $. Si nous prédisons le prix de la maison sur la base de l'équation linéaire, qui est Y =
150X-75000, nous obtiendrons le prix de la maison à 195 000 $. Nous voyons ici qu'il y a une
erreur de prédiction.
Par conséquent, nous pouvons utiliser la technique de calcul de la somme des erreurs au carré
pour trouver l'erreur de prédiction pour chacun des points de données. Nous choisissons au
hasard les paramètres de notre ligne puis nous calculons l'erreur. Ensuite, nous ajustons à
nouveau le paramètre, puis nous calculons l'erreur.
Nous répétons cette opération jusqu'à ce que nous obtenions l'erreur la plus faible possible. Ce
processus fait partie de l'algorithme de descente de gradient.
V. Implémentation Python de la régression linéaire simple:

1. Importez les bibliothèques requises :
numpy : Numpy est la bibliothèque de base pour le calcul scientifique en Python. Elle est utilisée
pour travailler avec des tableaux et des matrices.
pandas : Utilisé pour la manipulation et l'analyse des données.
matplotlib : C'est une bibliothèque de traçage, et nous allons l'utiliser pour la visualisation des
données.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
2. Ensemble de Données
La première étape de tout problème d'apprentissage automatique consiste à obtenir des données.
Il n'y a pas d'apprentissage automatique s'il n'y a rien à "apprendre". Nous allons donc utiliser
28
un ensemble de données très courant pour la régression linéaire, à savoir l'ensemble de données
de prédiction du prix des maisons.
Il s'agit d'un ensemble de données simple contenant les prix des maisons. La première colonne
est la surface de la maison (en pieds carrés) et la deuxième colonne est le prix de la maison.
Vous avez peut-être remarqué que nous avons qu'une caractéristique dans notre ensemble de
données (c'est-à-dire la surface de la maison). Nous allons donc utiliser la régression linéaire
simple et l'étiquette (y) sera le prix de la maison car c'est ce que nous allons prédire.
Définissons la fonction de chargement de l'ensemble de données :
def load_data(filename):
df = pd.read_csv(filename, sep=",", index_col=False)
df.columns = ["surface", "prix"]
data = np.array(df, dtype=float)
plot_data(data[:,:1], data[:, -1])
normalize(data)
return data[:,:1], data[:, -1]
3. Normalisation des données
Le code ci-dessus ne se contente pas de charger les données, il les normalise également et trace
les points de données. Nous allons examiner le tracé des données dans un instant, mais avant
de comprendre ce que fait la ligne normalize(data) ci-dessus. Notre modèle n'évalue pas les
données en tant que la surface de la maison. Pour le modèle, ce ne sont que des chiffres. Cela
peut créer un biais indésirable dans votre modèle d'apprentissage automatique vers les colonnes
(ou caractéristiques) qui ont des valeurs numériques plus élevées que les autres. Cela peut
également créer un déséquilibre dans la variance et la moyenne mathématique. Pour ces raisons
et aussi pour faciliter le travail, il est toujours conseillé de mettre à l'échelle ou de normaliser
vos caractéristiques afin qu'elles se situent toutes dans la même plage (par exemple [0 à 1]).
Cela facilite grandement l'apprentissage. Ainsi, pour notre objectif ici, nous utiliserons la
normalisation des caractéristiques qui, dans le sens mathématique, signifie :
Z = (x — μ) / σ
μ : la moyenne
σ : l'écart type
Dans la formule ci-dessus, z est notre caractéristique normalisée et x est la caractéristique non
normalisée.
29
def normalize(data):
for i in range(0, data.shape[1] - 1):
mu.append(np.mean(data[:, i]))
std.append(np.std(data[:, i]))
data[:, i] = ((data[:, i] - np.mean(data[:, i])) / np.std(data[:, i]))
4. Tracez les données
L'une des façons de prouver que l'utilisation de la régression linéaire fonctionnera pour notre
ensemble de données actuel est de le tracer. À cette fin, nous avons appelé la fonction plot_data
dans load_data ci-dessus.
def plot_data(x, y):

plt.xlabel(‘surface de la maison’)
plt.ylabel('prix')
plt.plot(x[:,0], y, 'bo')
plt.show()
Cette fonction, lorsqu'elle est appelée, génère le graphique suivant :
Vous pouvez voir qu'il est possible d'ajuster grossièrement une ligne à travers le graphique ci-
dessus. Cela signifie qu'une approximation linéaire nous permettra de faire des prédictions assez
précises, d'où l'utilisation de la régression linéaire.
Maintenant les données sont prêtes, passons à la deuxième partie de l'algorithme.
5. Hypothèse
Tout d'abord, nous devons définir à quoi ressemble notre fonction d'hypothèse car nous
utiliserons pour calculer le coût. Nous savons que pour une régression linéaire, notre hypothèse
est :
30
h  x    0  1x1   2 x2   3x3 ..   nxn

Notre ensemble de données ne comporte cependant que une seule caractéristique, donc pour
notre problème actuel l'hypothèse est : h  x    0  1x1
où x1 est la caractéristique (c'est-à-dire la surface de la maison). Mettons cela dans une simple
fonction python qui renvoie l'hypothèse :
def h(x,theta):
return np.matmul(x, theta)
6. Fonction de coût
Pour évaluer la qualité de notre modèle, nous utilisons la fonction de coût. L'équation de la
fonction de coût est la suivante :
 
2
1 m
J 1   
2m i 1
h ( xi  )  yi 
Et le code pour notre fonction de coût est :
def cost_function(x, y, theta):

return ((h(x, theta)-y).T@(h(x, theta)-y))/(2*y.shape[0])
Maintenant que nous avons le coût, nous devons le minimiser et pour cela nous utilisons la
descente de gradient.
7. Descente par gradient
Dans notre contexte, la descente par gradient est un algorithme d'optimisation qui vise à ajuster
les paramètres afin de minimiser la fonction de coût.
L'étape principale de mise à jour pour la descente de gradient est :

 j :  j   J (0 ,1 ) ( pour j  0 et j  1)
 j
Nous multiplions donc la dérivée de la fonction de coût avec le taux d'apprentissage(α) et la

soustrayons de la valeur actuelle des paramètres(θ) pour obtenir les nouveaux paramètres mis
à jour(θ).
def gradient_descent(x, y, theta, learning_rate=0.1, num_epochs=50):

m = x.shape[0]
J_all = []
31
for _ in range(num_epochs):
h_x = h(x, theta)
cost_ = (1/m)*(x.T@(h_x - y))
theta = theta - (learning_rate)*cost_
J_all.append(cost_function(x, y, theta))
return theta, J_all
La fonction gradient_descent renvoie theta et J_all. theta est évidemment notre vecteur de
paramètres qui contient les valeurs de θs pour l'hypothèse et J_all est une liste contenant la
fonction de coût après chaque époque. La variable J_all n'est pas exactement essentielle mais
elle aide à mieux analyser le modèle.
8. Organiser les fonctions
Il ne reste plus qu'appeler nos fonctions dans le bon ordre :
x,y = load_data("house_price_data.txt")
y = np.reshape(y, (45,1))
x = np.hstack((np.ones((x.shape[0],1)), x))
theta = np.zeros((x.shape[1], 1))
learning_rate = 0.1
num_epochs = 50
theta, J_all = gradient_descent(x, y, theta, learning_rate, num_epochs)
J = cost_function(x, y, theta)
print("Cost: ", J)
print("Parameters: ", theta)
Rappelez-vous que lorsque nous exécutons notre code pour implémenter cette fonction, nous
ne retournons pas l'expression comme pour hθ(x), mais la valeur mathématique à laquelle cette
expression est évaluée.
La fonction de coût diminue progressivement pour chaque époque de descente de gradient.
Ce graphique peut être tracé en définissant et en appelant une fonction plot_cost comme suit :
def plot_cost(J_all, num_epochs):

plt.xlabel('Epochs')
plt.ylabel('Cost')
plt.plot(num_epochs, J_all, 'm', linewidth = "5")
plt.show()
32
Nous pouvons maintenant utiliser ces paramètres pour trouver le prix d'une maison en utilisons
la surface de la maison.
9. Test
Vous pouvez maintenant tester votre code en appelant une fonction de test qui prendra en entrée
la surface de la maison et le vecteur thêta final qui a été renvoyé par notre modèle de régression
linéaire et nous donnera le prix de la maison.
def test(theta, x):

x[0] = (x[0] - mu[0])/std[0]
y = theta[0] + theta[1]*x[0]
print("Le prix de la maison est: ", y)
33
AYADI Wadhah TP 4 : Classification des images à l'aide d'un réseau de neurones
Intelligence Artificielle TP 4 : Classification des AU : 2021/2022

images à l'aide d'un Filière : LSE3
réseau de neurones
I. Objectif
- Apprendre à mettre en œuvre un réseau de neurones simple.
- Implémentation d’un exemple d’un réseau de neurones en utilisant Python.
- Repérer et surmonter l'Overfitting pendant l’apprentissage.
II. Chargement des données
MNIST est un ensemble de données de chiffres couramment utilisé, composé de 60 000 images
dans l'ensemble d’apprentissage et de 10 000 images dans l'ensemble de test. Ainsi, chaque
chiffre a 6000 images dans l'ensemble d'apprentissage. Les chiffres sont normalisés en taille et
centrés dans une image de taille fixe (28×28). La tâche consiste à entraîner un algorithme
d'apprentissage automatique à reconnaître correctement un nouvel échantillon de l'ensemble de
test.
Keras est livré avec le chargeur de données MNIST. Il possède une fonction mnist.load_data()
qui télécharge les données depuis ses serveurs si elles ne sont pas présentes sur votre ordinateur.
Les données chargées à l'aide de cette fonction sont divisées en ensembles d’apprentissage et
de test. Ceci est fait par la fonction suivante :
from tensorflow.keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
III. Vérification de données
Voyons à quoi ressemblent les données. Les données consistent en des nombres écrits à la main
allant de 0 à 9, ainsi que leur vérité de base. Il y a 60 000 échantillons d’apprentissage et 10 000
échantillons de test. Chaque échantillon est une image en niveaux de gris de 28×28.
import numpy as np
from matplotlib import pyplot as plt
from tensorflow.keras.utils import to_categorical
print('Training data shape : ', train_images.shape, train_labels.shape)
print('Testing data shape : ', test_images.shape, test_labels.shape)
# Find the unique numbers from the train labels
34
classes = np.unique(train_labels)
classes_num = len(classes)
print('Total number of outputs : ', classes_num)
print('Output classes : ', classes)
plt.figure(figsize=[10,5])
# Display the first image in training data
plt.subplot(121)
plt.imshow(train_images[0,:,:], cmap='gray')
plt.title("Ground Truth : {}".format(train_labels[0]))
# Display the first image in testing data
plt.subplot(122)
plt.imshow(test_images[0,:,:], cmap='gray')
plt.title("Ground Truth : {}".format(test_labels[0]))
plt.show()
Output:
IV. Traiter les données
Les images sont en niveaux de gris et les valeurs des pixels vont de 0 à 255. Nous allons
appliquer les pré-traitements suivants aux données avant de les envoyer au réseau.
1. Convertir chaque matrice d'image (28×28) en un tableau (28*28 = 784 dimensions) qui
sera introduit dans le réseau comme une seule caractéristique.
# Change from matrix to array of dimension 28x28 to array of dimension 784

dim_data = np.prod(train_images.shape[1:])
35
train_data = train_images.reshape(train_images.shape[0], dim_data)

test_data = test_images.reshape(test_images.shape[0], dim_data)
2. Convertissez les données en valeurs flottantes et mettez les valeurs à l'échelle entre 0 et 1.
# Change to float datatype

train_data = train_data.astype('float32')
test_data = test_data.astype('float32')
3. Convertissez les étiquettes des entiers en encodage catégorique (one-hot), car c'est le
format requis par Keras pour effectuer une classification multi-classe. L'encodage à 1 est un
type de représentation booléenne de données entières. Il convertit le nombre entier en un tableau
de tous les zéros, à l'exception d'un 1 à l'index du nombre entier.
Par exemple, en utilisant un encodage à 1 pour 10 classes, l'entier 5 sera encodé sous la forme
0000010000.
# Change the labels from integer to categorical data

train_labels_one_hot = to_categorical(train_labels)
test_labels_one_hot = to_categorical(test_labels)
Output:
V. Formation du réseau
Une fois que vous avez les données d’apprentissage et de test, vous pouvez suivre ces étapes
pour former un réseau neuronal. Le schéma fonctionnel est donné ici à titre de référence.
36
Nous allons utiliser les valeurs brutes des pixels comme entrée du réseau. Les images sont des
matrices de taille 28×28. Nous remodelons donc la matrice d'image en un tableau de taille 784
(28*28) et alimentons ce tableau au réseau. Nous utiliserons un réseau avec 2 couches cachées
de 512 neurones chacune. La couche de sortie aura 10 couches pour les 10 chiffres. Un
diagramme schématique est présenté ci-dessous.
1. Création du réseau
Nous avions mentionné que nous utiliserions un réseau avec 2 couches cachées et une couche
de sortie de 10 unités. Le nombre d'unités dans les couches cachées est maintenu à 512. L'entrée
du réseau est le tableau à 784 dimensions converti à partir de l'image 28×28.
Nous allons utiliser le modèle séquentiel pour construire le réseau. Dans le modèle séquentiel,
nous pouvons simplement empiler les couches en ajoutant la couche souhaitée une par une.
Nous utilisons la couche dense, également appelée couche entièrement connectée, car nous
construisons un réseau à action directe dans lequel tous les neurones d'une couche sont
connectés aux neurones de la couche précédente. Outre la couche dense, nous ajoutons la
fonction d'activation ReLU, qui est nécessaire pour introduire la non-linéarité dans le modèle.
Cela aidera le réseau à apprendre des limites de décision non linéaires. La dernière couche est
une couche softmax car il s'agit d'un problème de classification multi-classes.
from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense
model = Sequential()
model.add (Dense(512, activation='relu', input_shape=(dim_data,)))
model.add (Dense(512, activation='relu'))
model.add (Dense(classes_num, activation='softmax'))
37
2. Configuration du réseau
Dans cette étape, nous configurons l'optimiseur comme étant rmsprop. Nous spécifions
également le type de perte qui est l'entropie croisée catégorielle, utilisée pour la classification
multi_classe. Nous spécifions également la métrique (exactitude dans ce cas) que nous voulons
suivre pendant le processus d’apprentissage. Vous pouvez également essayer d'utiliser un autre
optimiseur tel que ‘adam’ ou ‘SGD’.
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])

3. Apprentissage du modèle
Le réseau est prêt à être entraîné. Cela se fait à l'aide de la fonction fit() de Keras. Nous
spécifions que le nombre d'époques est de 20. Cela signifie que l'ensemble des données sera
transmis au réseau 20 fois. Nous utiliserons les données de test pour la validation.
history = model.fit(train_data, train_labels_one_hot, batch_size=256, epochs=20, verbose=1,

validation_data=(test_data, test_labels_one_hot))
4. Évaluation du modèle
Nous vérifions la performance sur l'ensemble des données de test en utilisant la méthode
evaluate().
[test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot)

print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format(test_loss, test_acc))
Output:
Les résultats semblent bons. Cependant, nous voudrions avoir un autre regard sur les résultats.
VI. Vérification de l'Overfitting
La fonction fit() renvoie un objet historique qui contient un dictionnaire de toutes les mesures
qui devaient être suivies pendant l’apprentissage. Nous pouvons utiliser les données de l'objet
history pour tracer les courbes de perte et d’exactitude afin de vérifier le déroulement du
processus d’apprentissage.
Vous pouvez utiliser la fonction history.history.keys() pour vérifier quelles métriques sont
présentes dans l'historique. Cela devrait ressembler à ce qui suit :
38
['accuracy', 'loss', 'val_accuracy', 'val_loss']
Traçons les courbes de perte et d’exactitude.
#Plot the Loss Curves

plt.plot(history.history['loss'],'r',linewidth=3.0)
plt.plot(history.history['val_loss'],'b',linewidth=3.0)
plt.legend(['Training loss', 'Validation Loss'],fontsize=18)
plt.xlabel('Epochs ',fontsize=16)
plt.ylabel('Loss',fontsize=16)
plt.title('Loss Curves',fontsize=16)
#Plot the Accuracy Curves

plt.plot(history.history['accuracy'],'r',linewidth=3.0)
plt.plot(history.history['val_accuracy'],'b',linewidth=3.0)
plt.legend(['Training Accuracy', 'Validation Accuracy'],fontsize=18)
plt.xlabel('Epochs ',fontsize=16)
plt.ylabel('Accuracy',fontsize=16)
plt.title('Accuracy Curves',fontsize=16)
plt.show()
Bien que l’exactitude obtenue ci-dessus soit très bonne, si vous observez les courbes de perte
et de précision dans les figures ci-dessus, vous remarquerez que la perte de validation diminue
initialement, mais qu'elle commence ensuite à augmenter progressivement. De plus, il y a une
différence substantielle entre l’exactitude de l’apprentissage et celle du test. Il s'agit d'un signe
clair de sur-adaptation, ce qui signifie que le réseau a très bien mémorisé les données
d'apprentissage, mais qu'il n'est pas assuré de fonctionner sur des données non vues. D'où la
différence entre la précision de l'apprentissage et celle du test.
39
VII. Ajoutez une régularisation au modèle
L'ajustement excessif se produit principalement parce que les paramètres du réseau sont trop
biaisés par rapport aux données d'apprentissage. Nous pouvons ajouter une couche d'exclusion
pour surmonter ce problème dans une certaine mesure. Dans ce cas, une fraction des neurones
est désactivée de manière aléatoire pendant le processus d’apprentissage, ce qui réduit la
dépendance à l'égard de l'ensemble d’apprentissage dans une certaine mesure.
from tensorflow.keras.layers import Dropout

model = Sequential()
model.add (Dense(512, activation='relu', input_shape=(dim_data,)))
model.add(Dropout(0.5))
model.add (Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add (Dense(classes_num, activation='softmax'))
VIII. Vérifier les performances après régularisation

Nous allons entraîner à nouveau le réseau de la même manière que précédemment et vérifier
les courbes de perte et de précision.
A partir des courbes de perte et de précision ci-dessus, nous pouvons observer que la perte de
validation n'augmente pas. La différence entre l’exactitude de l’apprentissage et de la validation
n'est pas très élevée. Ainsi, nous pouvons dire que le modèle a une meilleure capacité de
généralisation car la performance ne diminue pas radicalement dans le cas de données non vues.
IX. Classification d’une seule image
La classification d'une seule image peut se réaliser comme suit :
# Predict the most likely class

pred = model.predict(test_data[[1], :])[0]
40
print(pred)
y_classes = pred.argmax(axis=-1)
print(y_classes)
# Display the predicted image
plt.imshow(test_images[1], cmap='gray')
plt.title("Ground Truth : {}".format(test_labels[1]))
plt.show()
Output:
41
42

Fascicule IA

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Fascicule IA

Transféré par

Droits d'auteur :

Formats disponibles

République Tunisienne

Ministère de l’Enseignement Supérieur et de la Recherche

Enseignant : Ayadi Wadhah

TP 1 : Prise en main de Python.

Intelligence Artificielle TP 1 : Prise en main de AU : 2021/2022

II. Prise en main de Python

user = "User Full Name"

Python prend en charge la jointure (concaténation) de chaînes à l'aide de l'opérateur +.

# Example integer numbers

Il est possible de connaître le type d’une variable en utilisant la fonction type :

10. Opérateur Plus-Égal à +=

# 2 to the 10th power, or 1024

12. Les listes

14. Boucle "for"

15. Boucles "while"

16. Instructions IF, ELIF et ELSE

print("Invalid score. Please check the input.")

def sum_two_numbers(a, b):

Étape 2) Vous devrez sélectionner un emplacement.

Cliquez ensuite sur le bouton « Créer ».

Étape 3) Maintenant, allez dans le menu "Fichier" et sélectionnez "Nouveau". Ensuite,

Étape 5) Tapez maintenant un programme simple – print (« Hello World ! »).

Étape 6) Maintenant, allez dans le menu « Exécuter » et sélectionnez « Exécuter » pour

Étape 7) Vous pouvez voir la sortie de votre programme en bas de l'écran.

Bonjour John Doe. Votre solde actuel est de 5,44 $.

Ecrivez les instructions suivantes et commentez les résultats obtenus:

astring = "Hello world!"

Demandez à l'utilisateur un numéro. Tester si le nombre est pair ou impair et imprimer un

Intelligence Artificielle TP 2 : Introduction aux AU : 2021/2022

II. Qu'est-ce qu'un perceptron ?

Le perceptron est un modèle simple de neurone. La formulation du perceptron a été la première

Le perceptron se compose de 4 parties.

Poids : Il représente la dimension ou la force de la connexion entre les unités. Si le poids du

Somme: Elle calcule la somme totale.

III. Comment fonctionne-t-il ?

Une fonction d'activation d'étape unitaire.

IV. Type de perceptron

- Perceptron mono couche

Perceptron mono couche à une entrée

Exercice 1 : Porte NON (NOT)

Pour commencer, suivre les étapes suivantes :

- Réaliser un appel aux bibliothèques nécessaires pour l’exécution de code.

- Taper la fonction NOT_logicFunction qui assure de fournir le résultat final.

Perceptron mono couche à deux entrées

Exercice 2 : Porte ET (AND)

En suivant les étapes de l'exercice 1, essayé d’implémenter un réseau de neurones compatible

Exercice 3 : Porte OU (OR)

Maintenant, nous allons programmer un réseau de neurones en Python qui implémente la

Exercice 4 : Porte XOR

En se basant sur les ports implémentés précédemment, essayé d’implémenter un réseau de

Intelligence Artificielle TP 3 : Régression linéaire AU : 2021/2022

Cas d'utilisation de la régression linéaire :

A partir de notre graphe, nous pouvons déduire que:

Ensuite, nous pouvons facilement trouver la pente des deux points.

b  150000  150*1500  75000

b  300000  150*2500  75000

IV. Calcul de la meilleure adéquation linéaire

V. Implémentation Python de la régression linéaire simple:

pandas : Utilisé pour la manipulation et l'analyse des données.

Définissons la fonction de chargement de l'ensemble de données :

def plot_data(x, y):

Maintenant les données sont prêtes, passons à la deuxième partie de l'algorithme.

h  x    0  1x1   2 x2   3x3 ..   nxn

Et le code pour notre fonction de coût est :