La Table de matière
1. Introduction .............................................................................................................................................. 2
1.1 Présentation des cinq volets de l'IA ................................................................................................ 2
2. Réseau de neurones.................................................................................................................................. 3
2.1 Projet concret.................................................................................................................................. 3
2.2 explications du résultat ................................................................................................................... 8
2.3 défaillance majeure des réseaux de neurones ............................................................................... 9
3. Logique floue........................................................................................................................................... 11
3.3 Projet concret................................................................................................................................ 11
3.3.1 Fuzzification ............................................................................................................................... 11
3.3.2 Rule Evaluation .......................................................................................................................... 14
3.3.3 Aggregation & Defuzzification ................................................................................................... 18
3.3.4 Creating the Tipping Controller ................................................................................................. 20
3.3.5 Fuzzy Rules ................................................................................................................................. 22
3.3.6 Résumons ce qu’on a fait ........................................................................................................... 24
4. Raisonnement à partir de cas ................................................................................................................. 24
4.3 Projet concret................................................................................................................................ 24
4.3.1 Trouver les valeurs manquantes ................................................................................................ 25
5. Systèmes multi-agents ............................................................................................................................ 29
5.4 Projet concret................................................................................................................................ 29
6. Traitement du langage naturel ............................................................................................................... 29
6.3 Projet concret................................................................................................................................ 29
8. Conclusion ............................................................................................................................................... 29
8. Références .............................................................................................................................................. 30
1. Introduction
1.1 Présentation des cinq volets de l'IA
Dans ce rapport, nous nous concentrerons sur l'étude de cinq volets clés de
l'intelligence artificielle, chacun offrant une approche unique pour résoudre des
problèmes complexes et offrant des perspectives intéressantes pour l'avenir de l'IA. Voici
une brève présentation de ces cinq volets :
Réseaux de neurones : Inspirés par le fonctionnement du cerveau humain, les
réseaux de neurones sont des modèles puissants d'IA. Ils sont utilisés pour la
reconnaissance de motifs, la classification, la prédiction et bien d'autres tâches. Nous
explorerons les concepts fondamentaux des réseaux de neurones, tels que les neurones
artificiels, les couches de neurones et les fonctions d'activation. Un projet concret sera
présenté, mettant en œuvre un réseau de neurones pour la classification d'images.
Logique floue : Contrairement à la logique traditionnelle qui se base sur des valeurs
binaires (vrai ou faux), la logique floue permet de prendre en compte l'incertitude et les
nuances dans le raisonnement. Nous discuterons des principes fondamentaux de la
logique floue et de son utilisation dans le processus de prise de décision. Un projet concret
sera présenté, mettant en œuvre un système de contrôle basé sur la logique floue.
Raisonnement à partir de cas : Cette approche consiste à résoudre de nouveaux
problèmes en s'appuyant sur des expériences passées similaires. Nous explorerons le
fonctionnement du raisonnement à partir de cas, son utilisation dans des domaines tels
que la médecine et l'ingénierie, et nous présenterons un projet concret de création d'un
système de recommandation basé sur le raisonnement à partir de cas.
Systèmes multi-agents : Les systèmes multi-agents mettent l'accent sur la
collaboration et la communication entre plusieurs entités autonomes pour atteindre des
objectifs communs. Nous discuterons de l'organisation des agents, de leurs interactions
et de leurs avantages dans des domaines tels que la logistique et la robotique. Un projet
concret sera présenté, illustrant le développement d'un système multi-agents pour la
planification de trajets.
Traitement du langage naturel : Le traitement du langage naturel vise à permettre
aux machines de comprendre, d'interpréter et de générer du langage humain. Cette
approche est essentielle pour les chatbots, les assistants virtuels, la traduction
automatique, etc. Nous explorerons les concepts fondamentaux du traitement du
langage naturel et présenterons un projet concret de création d'un système de traduction
automatique basé sur cette approche.
2. Réseau de neurones
2.1 Projet concret
Le principe du projet est d'utiliser les réseaux de neurones convolutionnels (CNN)
pour entraîner une machine à distinguer entre les images de CIN et l'acte de naissance.
Les CNN sont particulièrement adaptés à la tâche de classification d'images en raison de
leur capacité à extraire des caractéristiques visuelles à différents niveaux d'abstraction.
On Charge et affiche les deux images : une image de Pikachu et une image de
Rondoudou. Les images sont obtenues à partir de liens URL spécifiques. Le code utilise les
bibliothèques OpenCV, NumPy, Requests et Matplotlib pour télécharger et afficher les
images.
Résultats obtenus
2.3.2 prétraitements
On effectue plusieurs étapes de prétraitement sur l'image de Pikachu chargée
précédemment :
 La fonction cv2.resize est utilisée pour redimensionner l'image de Pikachu
à une taille de 40x40 pixels avec une interpolation cubique. Cela permet
d'ajuster la taille de l'image pour correspondre aux exigences du modèle.
 La fonction cv2.cvtColor est utilisée pour convertir l'image redimensionnée
en niveaux de gris. Cela réduit la dimension de l'image de 3D à 2D, ce qui
simplifie le traitement ultérieur.
 La fonction cv2.threshold est utilisée pour appliquer un seuillage binaire à
l'image en niveaux de gris. Tous les pixels ayant une valeur supérieure à
127 sont définis sur 255 (blanc) et les autres pixels sont définis sur 0 (noir).
 Les boucles for sont utilisées pour afficher les valeurs de chaque pixel de
l'image après l'application du seuillage binaire.
 Enfin, l'image seuillée est affichée à l'aide de la fonction plt.imshow de
Matplotlib, en convertissant l'image du format de couleur BGR à RGB.
Ce code crée et entraîne un modèle de réseau de neurones convolutionnels (CNN)
pour la classification d'images.
1. `num_classes = 2` définit le nombre de classes dans le problème de classification.
2. Le modèle est créé en utilisant la classe `Sequential` de Keras. Les différentes
couches du modèle sont ajoutées séquentiellement :
 `layers.experimental.preprocessing.Rescaling(1./255)`
normalise
les
valeurs des pixels des images entre 0 et 1.
 `layers.Conv2D` crée une couche de convolution avec le nombre spécifié de
filtres, la taille du noyau et la fonction d'activation relu.
 `layers.MaxPooling2D` ajoute une couche de pooling pour réduire la
dimensionnalité des caractéristiques.
 `layers.Flatten` aplatit les caractéristiques en un vecteur.
 `layers.Dense` ajoute des couches denses avec la fonction d'activation relu.
 `layers.Dense` ajoute la couche de sortie avec la fonction d'activation
softmax pour la classification multiclasse.
3. Le modèle est compilé avec l'optimiseur 'adam', la fonction de perte
`SparseCategoricalCrossentropy` et la métrique d'exactitude ('accuracy').
4. Un rappel `TensorBoard` est configuré pour enregistrer les métriques et les
visualisations pendant l'entraînement. Les journaux seront enregistrés dans le répertoire
"logs".
5. Le modèle est entraîné en utilisant la méthode `fit()` avec les ensembles de
données d'entraînement et de validation, le nombre d'époques et le rappel
`TensorBoard`.
Ainsi, ce code crée un modèle CNN, le compile et l'entraîne sur les ensembles de
données d'entraînement et de validation.
1. `from google.colab import files`: Cette ligne importe la bibliothèque `files` de
Google Colab, qui permet de télécharger des fichiers depuis votre ordinateur vers
l'environnement de Colab.
2. `file_to_predict = files.upload()`: Cette ligne permet de télécharger un fichier
depuis votre ordinateur vers l'environnement de Colab. Elle ouvre une fenêtre de
sélection de fichier où vous pouvez choisir le fichier que vous souhaitez prédire.
3. `for file_ in file_to_predict:`: Cette boucle parcourt tous les fichiers téléchargés.
4. `image_to_predict = cv2.imread(file_,cv2.IMREAD_COLOR)`: Cette ligne utilise
la bibliothèque OpenCV (`cv2`) pour lire l'image téléchargée en couleur.
5. `plt.imshow(cv2.cvtColor(image_to_predict, cv2.COLOR_BGR2RGB))`: Cette
ligne affiche l'image téléchargée en utilisant la fonction `imshow` de Matplotlib. La
conversion `cv2.COLOR_BGR2RGB` est effectuée pour s'assurer que les couleurs de
l'image sont affichées correctement.
6. `img_to_predict = np.expand_dims(cv2.resize(image_to_predict,(200,200)),
axis=0)`: Cette ligne redimensionne l'image téléchargée à une taille de 200x200 pixels à
l'aide de la fonction `cv2.resize`. Ensuite, la fonction `np.expand_dims` est utilisée pour
ajouter une dimension supplémentaire à l'image afin de correspondre à la forme d'entrée
attendue par le modèle.
7. `res = model.predict_classes(img_to_predict)`: Cette ligne utilise le modèle
entraîné pour prédire la classe de l'image redimensionnée. La méthode `predict_classes`
retourne la classe prédite.
8. `print(model.predict_classes(img_to_predict))`: Cette ligne affiche la classe
prédite par le modèle.
9. `print(model.predict(img_to_predict))`: Cette ligne affiche les scores de
prédiction pour chaque classe. Les scores sont obtenus à l'aide de la méthode `predict`
du modèle.
10. Les instructions conditionnelles suivantes utilisent la classe prédite pour
afficher l'image correspondante (Pikachu ou Rondoudou) à l'aide de la fonction `imshow`.
Un message est également affiché pour indiquer la classe prédite.
2.2 explications du résultat
En utilisant un ensemble de 150 photos de cartes d'identité nationale (CIN) et 150
photos d'actes de naissance, nous avons entraîné un modèle de réseau de neurones
convolutif (CNN) afin de développer une compétence permettant de distinguer ces deux
types de documents. Le CNN a été conçu pour extraire des caractéristiques spécifiques à
partir des images et les utiliser pour prendre des décisions de classification. En exposant
le modèle à un grand nombre d'exemples, il a appris à identifier les différences visuelles
entre les CIN et les actes de naissance, et il est désormais capable de prédire avec une
certaine précision à quelle catégorie appartient une nouvelle image donnée. Cette
approche offre une solution automatisée et efficace pour la distinction entre les CIN et
les actes de naissance, ce qui peut être utile dans divers contextes, tels que la vérification
d'identité et la gestion des documents officiels.
2.3 défaillance majeure des réseaux de neurones
Le code fourni est un exemple pratique de surapprentissage utilisant la régression
polynomiale. Il génère un ensemble de données synthétiques avec une relation non
linéaire, divise les données en trois ensembles avec différents degrés de polynômes (1, 4
et 15), et effectue la régression polynomiale suivie d'une régression linéaire.
Le code utilise également la validation croisée pour évaluer les performances de
chaque modèle, en enregistrant les scores de l'erreur quadratique moyenne (MSE). Les
résultats sont ensuite tracés, montrant les prédictions du modèle, la véritable fonction et
les échantillons de données.
Le but de cet exemple est de mettre en évidence le surapprentissage, où les
modèles de degré plus élevé (15) s'adaptent trop étroitement aux données
d'entraînement, mais ne généralisent pas bien aux nouvelles données.
En exécutant le code, vous pourrez visualiser les résultats graphiques et observer
l'effet du surapprentissage. Assurez-vous d'avoir les bibliothèques nécessaires installées
(numpy, matplotlib, sklearn) pour exécuter le code avec succès.
3. Logique floue
3.3 Projet concret
3.3.1 Fuzzification
On commence par importer les bibliothèques nécessaires, notamment numpy pour les
opérations mathématiques, skfuzzy pour la logique floue et matplotlib.pyplot pour la
visualisation des résultats.
Ensuite, des variables d'univers sont générées pour les entrées et les sorties du système
de logique floue. Dans cet exemple, les variables x_MAP, x_HUO et x_IFR représentent
les valeurs possibles des variables "MAP" (Mesure de l'activité du radar météorologique),
"HUO" (Humidité de l'air) et "IFR" (Indice de vol aux instruments), respectivement.
Ensuite, des fonctions d'appartenance floues sont définies pour chaque variable à l'aide
de la fonction trapmf de skfuzzy. Dans cet exemple, des fonctions d'appartenance
trapézoïdales sont utilisées, ce qui permet de représenter différentes catégories
linguistiques comme "low", "normal", "high", etc. pour chaque variable.
Une fois que les fonctions d'appartenance sont définies, on peut les utiliser dans des
règles d'inférence floue pour prendre des décisions ou effectuer des opérations de
raisonnement flou.
Ce code est utilisé pour visualiser les univers et les fonctions d'appartenance floues
définies précédemment.
Le code crée une figure avec trois sous-graphiques (ax0, ax1, ax2) correspondant aux
variables "Mean Arterial Blood Pressure" (Pression artérielle moyenne), "Hourly Urine
Output" (Production d'urine horaire) et "Intravenous Fluid Rate" (Débit de fluide
intraveineux), respectivement.
L'ensemble du code permet de visualiser les univers et les fonctions
d'appartenance floues, ce qui facilite la compréhension des relations entre les variables
et les catégories linguistiques associées.
3.3.2 Rule Evaluation
Ce code calcule les degrés d'appartenance flous pour les valeurs spécifiques de la pression
artérielle moyenne (Mean Arterial Blood Pressure - MAP) et du débit urinaire horaire
(Hourly Urine Output - HUO).
Les lignes suivantes extraient les degrés d'appartenance pour une valeur spécifique :
 `MAP_lo = fuzz.interp_membership(x_MAP, low_MAP, 90.0)`: Cela calcule le degré
d'appartenance de 90.0 à la fonction d'appartenance floue "LOW" de la pression
artérielle moyenne (MAP).
 `MAP_norm = fuzz.interp_membership(x_MAP, normal_MAP, 90.0)`: Cela calcule
le degré d'appartenance de 90.0 à la fonction d'appartenance floue "NORMAL" de
la pression artérielle moyenne (MAP).
 `MAP_hi = fuzz.interp_membership(x_MAP, high_MAP, 90.0)`: Cela calcule le
degré d'appartenance de 90.0 à la fonction d'appartenance floue "HIGH" de la
pression artérielle moyenne (MAP).
De même, les lignes suivantes calculent les degrés d'appartenance pour le débit urinaire
horaire (HUO) pour une valeur de 110.0.
Ensuite, les degrés d'appartenance sont affichés à l'aide de la fonction `print()`. Les degrés
d'appartenance donnent une indication de l'intensité de l'appartenance d'une valeur
donnée à chaque ensemble flou ("LOW", "NORMAL" et "HIGH") pour les variables MAP
et HUO respectivement.
Ce code applique des règles floues pour déterminer l'activation des ensembles flous d'IFR
(Intravenous Fluid Rate) en fonction des valeurs d'appartenance floue de MAP (Mean
Arterial Blood Pressure) et HUO (Hourly Urine Output).
Les variables `active_rule1` à `active_rule9` représentent les parties actives des règles
floues individuelles. Par exemple, `active_rule1` correspond à la règle 1, qui est "si MAP
est faible et HUO est faible, alors IFR est très élevé".
Enfin, la variable `IFR0` est initialisée avec des valeurs nulles pour représenter l'ensemble
flou IFR vide.
L'application de ces règles permet de déterminer l'activation des ensembles flous d'IFR
en fonction des conditions floues définies par les ensembles flous de MAP et HUO.
Ce code permet de visualiser les ensembles flous d'IFR (Intravenous Fluid Rate) résultants
après l'application des règles floues. Les ensembles flous sont représentés par des
courbes de membres flous et des zones de remplissage colorées pour indiquer l'activation
des ensembles flous correspondants.
Les trois sous-graphiques représentent les ensembles flous d'IFR pour les différentes
combinaisons de règles floues activées.
Ces visualisations permettent de comprendre l'activation des ensembles flous d'IFR en
fonction des conditions floues définies par les ensembles flous de MAP et HUO, et de
faciliter l'interprétation des résultats du système de logique floue.
3.3.3 Aggregation & Defuzzification
Dans cette partie du code, nous agrégeons les fonctions d'appartenance de sortie en une
seule fonction agrégée. La fonction agrégée est obtenue en prenant le maximum des
degrés d'appartenance des différentes fonctions d'appartenance de sortie.
Dans cette partie du code, nous visualisons le résultat agrégé et le résultat défuzzifié. Le
graphique affiche les fonctions d'appartenance de sortie pour les catégories "very high",
"high", "moderate", "maintain" et "low" sous forme de lignes en pointillés. La fonction
d'appartenance agrégée est remplie en rose.
Ensuite, une ligne verticale est tracée à la position du résultat défuzzifié (`output_IFR`).
La longueur de cette ligne est déterminée par le degré d'appartenance du résultat
défuzzifié à la fonction d'appartenance agrégée (`output_IFR_activation`).
3.3.4 Creating the Tipping Controller
Dans cette partie du code, nous créons de nouveaux objets `Antecedent` et `Consequent`
pour les variables d'univers et les fonctions d'appartenance.
Pour l'antécédent "Mean Arterial Pressure" (MAP), nous utilisons la méthode `.automf()`
pour générer automatiquement trois fonctions d'appartenance : "poor", "average" et
"good". Ensuite, nous définissons une fonction d'appartenance personnalisée pour
chaque étiquette en utilisant la méthode `.trapmf()`.
De même, pour l'antécédent "Hourly Urine Output" (HUO), nous utilisons `.automf()` pour
générer trois fonctions d'appartenance, puis nous définissons des fonctions
d'appartenance personnalisées pour chaque étiquette.
Pour le conséquent "Intravenous Fluid Rate" (IFR), nous définissons cinq fonctions
d'appartenance personnalisées : "low", "mantain", "moderate", "high" et "veryhigh".
Chaque fonction est définie en utilisant `.trapmf()` avec des valeurs appropriées pour
décrire la forme trapézoïdale.
3.3.5 Fuzzy Rules
Dans cette partie du code, nous créons des règles de contrôle pour relier les antécédents
aux conséquents.
Les règles sont définies en utilisant la classe `Rule` du module `ctrl`. Chaque règle est
créée en spécifiant les antécédents et le conséquent correspondant à l'aide de leurs
fonctions d'appartenance respectives.
Voici les règles définies :
- Rule 1 : Si MAP est "poor" et HUO est "poor", alors IFR est "veryhigh".
- Rule 2 : Si MAP est "poor" et HUO est "average", alors IFR est "high".
- Rule 3 : Si MAP est "poor" et HUO est "good", alors IFR est "moderate".
- Rule 4 : Si MAP est "average" et HUO est "poor", alors IFR est "moderate".
- Rule 5 : Si MAP est "average" et HUO est "average", alors IFR est "mantain".
- Rule 6 : Si MAP est "average" et HUO est "good", alors IFR est "mantain".
- Rule 7 : Si MAP est "good" et HUO est "poor", alors IFR est "low".
- Rule 8 : Si MAP est "good" et HUO est "average", alors IFR est "low".
- Rule 9 : Si MAP est "good" et HUO est "good", alors IFR est "low".
Chaque règle est ensuite visualisée à l'aide de la méthode `.view()` pour afficher les
graphiques correspondants.
3.3.6 Résumons ce qu’on a fait
En conclusion, ce projet a utilisé la logique floue pour modéliser et contrôler le taux
d'administration de liquide intraveineux en fonction de la pression artérielle moyenne et
du débit urinaire horaire. Nous avons défini des univers de discours, des fonctions
d'appartenance floues et des règles linguistiques pour représenter la relation entre les
variables d'entrée et la sortie. En agrégeant les règles et en effectuant des simulations,
nous avons pu recommander un niveau d'IFR approprié en fonction des valeurs d'entrée
données. La logique floue offre une approche flexible pour prendre des décisions basées
sur des variables incertaines, permettant ainsi une régulation efficace du taux
d'administration de liquide intraveineux dans un contexte médical.
4. Raisonnement à partir de cas
4.3 Projet concret
Le projet utilise le principe de Raisonnement à partir de cas (CBR) pour résoudre
des problèmes en se basant sur des solutions de problèmes similaires rencontrés par le
passé. En particulier, il se concentre sur la recherche des valeurs manquantes dans un
ensemble de données en utilisant des caractéristiques similaires présentes dans d'autres
variables. Pour cela, on utilise la distance euclidienne pour trouver les variables similaires
et prédire les caractéristiques manquantes.
Le projet comprend deux scripts Python. Le premier script permet de trouver les
valeurs manquantes dans un ensemble de données, tandis que le deuxième script calcule
les caractéristiques (colonnes) qui influencent ou définissent le plus les valeurs
manquantes. Les données utilisées dans ce projet sont issues des statistiques collectées
auprès des utilisateurs d'une entreprise de télécommunications.
En utilisant ces données, il est possible de former un modèle et de vérifier
l'exactitude des résultats obtenus. Ce projet permet donc de résoudre le problème des
valeurs manquantes dans un ensemble de données en se basant sur des caractéristiques
similaires, offrant ainsi une approche pratique pour compléter les données manquantes
dans un contexte de télécommunications.
4.3.1 Trouver les valeurs manquantes
Le code fourni définit la classe `ScriptSetting`, qui contient les paramètres de
configuration du script. Ces paramètres sont utilisés pour charger un fichier CSV
contenant des données.
La fonction `load_data_frame_from_csv` charge les données à partir du fichier CSV
spécifié en utilisant les paramètres de configuration de la classe `ScriptSetting`. Elle
renvoie un objet DataFrame contenant les données chargées à partir du fichier CSV. De
plus, la fonction affiche le nombre de lignes et de colonnes dans le DataFrame chargé.
En résumé, ce code permet de charger les données à partir d'un fichier CSV en utilisant
les paramètres de configuration spécifiés dans la classe `ScriptSetting`.
Le code fournit trois fonctions utilitaires pour manipuler un DataFrame :
1. `get_missing_columns` : Cette fonction renvoie une liste des noms des colonnes
qui contiennent des valeurs manquantes dans le DataFrame donné.
2. `subset_columns` : Cette fonction renvoie une liste des noms des colonnes qui
ne font pas partie d'une liste spécifiée de colonnes. Elle permet de sélectionner
uniquement certaines colonnes à partir du DataFrame.
3. `columns_to_number` : Cette fonction convertit les colonnes de type chaîne de
caractères du DataFrame en colonnes numériques en ajoutant des catégories
numériques. Elle modifie le DataFrame en place.
En résumé, le code fournit des fonctionnalités pour identifier les colonnes avec des
valeurs manquantes, sélectionner des colonnes spécifiques et convertir les colonnes en
types numériques.
La fonction `normalize_data` permet de normaliser les colonnes numériques du
DataFrame en utilisant la méthode de la mise à l'échelle Z (Z-scaling). Les colonnes qui
contiennent des valeurs manquantes ou qui sont spécifiées comme étant en dehors de la
prédiction sont exclues de la normalisation. La normalisation est effectuée en soustrayant
la moyenne de chaque colonne et en divisant par l'écart-type.
La fonction `get_predict_columns` renvoie une liste des noms de colonnes à partir
desquelles nous allons calculer la distance Euclidienne. Cette liste est obtenue en excluant
la colonne manquante spécifiée et les colonnes spécifiées comme étant en dehors de la
prédiction.
La fonction `euclid_distance` permet de calculer la distance euclidienne entre les lignes
qui contiennent des valeurs manquantes pour une colonne spécifiée (`missing_column`)
et les lignes qui ne contiennent pas de valeurs manquantes pour cette colonne. Elle utilise
la méthode de comparaison des valeurs des colonnes spécifiées dans la liste `columns` à
partir du DataFrame.
Pour chaque ligne contenant une valeur manquante, la fonction parcourt toutes les lignes
sans valeur manquante et calcule la distance euclidienne en comparant les valeurs des
colonnes. La valeur la plus proche est déterminée en trouvant la distance minimale. Les
valeurs trouvées sont stockées dans un dictionnaire, où la clé est l'identifiant de la ligne
correspondante et la valeur est la valeur trouvée.
La fonction `start` est la fonction principale du script. Elle charge le DataFrame à partir du fichier CSV
spécifié dans les paramètres, puis effectue les étapes suivantes :
1. Normalisation (mise à l'échelle Z) de toutes les colonnes numériques, à l'exception des colonnes
contenant des valeurs manquantes.
2. Transformation des colonnes alpha en nombres.
3. Recherche des valeurs manquantes en utilisant la distance euclidienne.
4. Affichage des valeurs trouvées.
5. Systèmes multi-agents
5.4 Projet concret
6. Traitement du langage naturel
6.3 Projet concret
8. Conclusion
En résumé, les outils tels que les réseaux de neurones, la logique floue, le
raisonnement basé sur des cas, les systèmes multi-agents et le traitement du langage
naturel offrent différentes approches pour résoudre des problèmes complexes. Chacun
de ces outils a ses avantages et ses utilisations spécifiques. Cependant, les réseaux de
neurones se distinguent souvent comme étant particulièrement performants et
polyvalents dans de nombreux domaines, notamment en matière d'apprentissage à partir
de données et de modélisation complexe. Par conséquent, les réseaux de neurones sont
généralement considérés comme l'un des outils les plus puissants parmi ceux
mentionnés.
8. Références
https://github.com/andirian98/Medical-Decision-Making-using-Fuzzy-Logic-Project
https://github.com/anisayari/Youtube-apprendre-le-deeplearning-avec-tensorflow