L'intelligence artificielle pour les développeurs : concepts et implémentations en Java

Auteur(s) :

Mathivet, Virginie Découvrir l'auteur

Résumé

Une présentation des principales techniques d'intelligence artificielle et leur application sous Java 8 : les systèmes experts, la logique floue, les systèmes multiagents ou encore les réseaux de neurones. Sept projets Java sont disponibles en téléchargement. ©Electre 2019

Éditeur(s)
- Éditions ENI
Date
- cop. 2019
Notes
- La couv. porte en plus : "Fichiers complémentaires à télécharger" ; "Version numériques offerte ! www.editions-eni.fr"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
- La 4e de couv. porte en plus : "Surwww-editions-eni.fr : un projet Java Netbeans par chapitre, illustrant l'exemple proposé dans le chapitre"
Langues
- Français
Description matérielle
- 1 vol. (500 p.) : ill. ; 22 cm
Collections
- Datapro
Sujet(s)
- Intelligence artificielle
- Java (langage de programmation)
ISBN
- 978-2-409-01709-4
Indice
- 681.7 Intelligence artificielle, systèmes experts
Quatrième de couverture
- L'Intelligence Artificielle pour les développeurs
  Concepts et implémentations en Java
  Ce livre sur L'Intelligence Artificielle s'adresse particulièrement aux développeurs et ne nécessite pas de connaissances mathématiques approfondies. Au fil des chapitres, l'auteur présente les principales techniques d'Intelligence Artificielle et, pour chacune d'elles, les inspirations biologiques, physiques voire mathématiques, puis les différents concepts et principes (sans entrer dans les détails mathématiques), avec des exemples et figures pour chacun de ceux-ci. Les domaines d'application sont illustrés par des applications réelles et actuelles. Chaque chapitre contient un exemple d'implémentation générique, complété par une application pratique, développée en Java. Ces exemples de code étant génériques, ils sont facilement adaptables à de nombreuses applications Java 10, sans plugin extérieur. Les techniques d'Intelligence Artificielle décrites sont :
  
  Les systèmes experts, permettant d'appliquer des règles pour prendre des décisions ou découvrir de nouvelles connaissances.
  
  La logique floue, permettant de contrôler des systèmes informatiques ou mécaniques de manière beaucoup plus souple que les programmes traditionnels.
  
  Les algorithmes de recherche de chemin, dont le A* très utilisé dans les jeux vidéo pour trouver les meilleurs itinéraires.
  
  Les algorithmes génétiques, utilisant la puissance de l'évolution pour apporter des solutions à des problèmes complexes.
  
  Les principales métaheuristiques, dont la recherche tabou, trouvant des optimums à des problèmes d'optimisation, avec ou sans contraintes.
  
  Les systèmes multi-agents, simulant des foules ou permettant des comportements émergents à partir de plusieurs agents très simples.
  
  Les réseaux de neurones (et le deep learning), capables de découvrir et de reconnaître des modèles, dans des suites historiques, des images ou encore des données.
  
  Pour aider le lecteur à passer de la théorie à la pratique, l'auteur propose en téléchargement, sur le site www.editions-eni.fr, sept projets Java (réalisés avec NetBeans), un par technique d'Intelligence Artificielle. Chaque projet contient un package générique et un ou plusieurs packages spécifiques à l'application proposée.
  Le livre se termine par une bibliographie, permettant au lecteur de trouver plus d'informations sur ces différentes techniques, une sitographie listant quelques articles présentant des applications réelles, une annexe et un index.
Tables des matières
- - L'Intelligence Artificielle pour les développeurs
  - Concepts et implémentations en Java
  - Avant-propos
  - 1. Objectifs du livre15
  - 2. Public et prérequis15
  - 3. Structure du livre16
  - 4. Code en téléchargement18
  - Introduction
  - 1. Présentation du chapitre19
  - 2. Définir l'intelligence19
  - 3. L'intelligence du vivant22
  - 4. L'intelligence artificielle23
  - 5. Domaines d'application25
  - 6. Synthèse28
  - Chapitre 1
    Systèmes experts
  - 1. Présentation du chapitre29
  - 2. Exemple : un système expert en polygones30
  - 2.1 Triangles30
  - 2.2 Quadrilatères32
  - 2.3 Autres polygones34
  - 3. Contenu d'un système expert34
  - 3.1 Base de règles35
  - 3.2 Base de faits36
  - 3.3 Moteur d'inférences37
  - 3.4 Interface utilisateur39
  - 4. Types d'inférences39
  - 4.1 Chaînage avant40
  - 4.1.1 Principe40
  - 4.1.2 Application à un exemple40
  - 4.2 Chaînage arrière41
  - 4.2.1 Principe41
  - 4.2.2 Application à un exemple42
  - 4.3 Chaînage mixte43
  - 5. Étapes de construction d'un système44
  - 5.1 Extraction des connaissances45
  - 5.2 Création du moteur d'inférences45
  - 5.3 Écriture des règles46
  - 5.4 Création de l'interface utilisateur46
  - 6. Performance et améliorations47
  - 6.1 Critères de performance47
  - 6.2 Amélioration des performances par l'écriture des règles48
  - 6.3 Importance de la représentation du problème49
  - 7. Ajout d'incertitudes et de probabilités51
  - 7.1 Apport des incertitudes51
  - 7.2 Faits incertains52
  - 7.3 Règles incertaines52
  - 8. Domaines d'application53
  - 8.1 Aide au diagnostic54
  - 8.2 Estimation de risques55
  - 8.3 Planification et logistique55
  - 8.4 Transfert de compétences et connaissances56
  - 8.5 Autres applications56
  - 9. Création d'un système expert en Java57
  - 9.1 Détermination des besoins58
  - 9.2 Implémentation des faits59
  - 9.3 Base de faits63
  - 9.4 Règles et base de règles64
  - 9.5 Interface67
  - 9.6 Moteur d'inférences69
  - 9.7 Saisie des règles et utilisation76
  - 10. Utilisation de Prolog78
  - 10.1 Présentation du langage78
  - 10.2 Syntaxe du langage79
  - 10.2.1 Généralités79
  - 10.2.2 Prédicats80
  - 10.2.3 Poser des questions80
  - 10.2.4 Écriture des règles81
  - 10.2.5 Autres prédicats utiles82
  - 10.3 Codage du problème des formes géométriques83
  - 10.4 Codage du problème des huit reines87
  - 10.4.1 Intérêt du chaînage arrière87
  - 10.4.2 Étude du problème88
  - 10.4.3 Règles à appliquer88
  - 10.4.4 Règles de conflits entre reines89
  - 10.4.5 But du programme91
  - 10.4.6 Exemples d'utilisation91
  - 11. Synthèse92
  - Chapitre 2
    Logique floue
  - 1. Présentation du chapitre95
  - 2. Incertitude et imprécision96
  - 2.1 Incertitude et probabilités96
  - 2.2 Imprécision et subjectivité96
  - 2.3 Nécessité de traiter l'imprécision97
  - 3. Ensembles flous et degrés d'appartenance98
  - 3.1 Logique booléenne et logique floue98
  - 3.2 Fonctions d'appartenance99
  - 3.3 Caractéristiques d'une fonction d'appartenance102
  - 3.4 Valeurs et variables linguistiques103
  - 4. Opérateurs sur les ensembles flous104
  - 4.1 Opérateurs booléens104
  - 4.2 Opérateurs flous106
  - 4.2.1 Négation106
  - 4.2.2 Union et intersection108
  - 5. Création de règles110
  - 5.1 Règles en logique booléenne110
  - 5.2 Règles floues110
  - 6. Fuzzification et défuzzification113
  - 6.1 Valeur de vérité113
  - 6.2 Fuzzification et application des règles115
  - 6.3 Défuzzification119
  - 7. Domaines d'application121
  - 7.1 Premières utilisations121
  - 7.2 Dans les produits électroniques122
  - 7.3 En automobile122
  - 7.4 Autres domaines123
  - 8. Implémentation d'un moteur de logique floue123
  - 8.1 Le coeur du code : les ensembles flous124
  - 8.1.1 Point2D : un point d'une fonction d'appartenance124
  - 8.1.2 EnsembleFlou : un ensemble flou125
  - 8.1.3 Opérateurs de comparaison et de multiplication126
  - 8.1.4 Opérateurs ensemblistes127
  - 8.1.5 Calcul du barycentre136
  - 8.2 Ensembles flous particuliers138
  - 8.3 Variables et valeurs linguistiques141
  - 8.3.1 Valeur linguistique141
  - 8.3.2 Variable linguistique142
  - 8.4 Règles floues143
  - 8.4.1 Expression floue144
  - 8.4.2 Valeur numérique144
  - 8.4.3 Règle floue145
  - 8.5 Système de contrôle flou146
  - 8.6 Synthèse du code créé150
  - 9. Implémentation d'un cas pratique151
  - 10. Synthèse157
  - Chapitre 3
    Recherche de chemins
  - 1. Présentation du chapitre159
  - 2. Chemins et graphes160
  - 2.1 Définition et concepts160
  - 2.2 Représentations161
  - 2.2.1 Représentation graphique161
  - 2.2.2 Matrice d'adjacence161
  - 2.3 Coût d'un chemin et matrice des longueurs164
  - 3. Exemple en cartographie166
  - 4. Algorithmes naïfs de recherche de chemins168
  - 4.1 Parcours en profondeur168
  - 4.1.1 Principe et pseudo-code168
  - 4.1.2 Application à la carte170
  - 4.2 Parcours en largeur172
  - 4.2.1 Principe et pseudo-code173
  - 4.2.2 Application à la carte174
  - 5. Algorithmes « intelligents »177
  - 5.1 Algorithme de Bellman-Ford178
  - 5.1.1 Principe et pseudo-code178
  - 5.1.2 Application à la carte180
  - 5.2 Algorithme de Dijkstra183
  - 5.2.1 Principe et pseudo-code184
  - 5.2.2 Application à la carte185
  - 5.3 Algorithme A*188
  - 5.3.1 Principe et pseudo-code188
  - 5.3.2 Application à la carte189
  - 6. Domaines d'application196
  - 7. Implémentation198
  - 7.1 Noeuds, arcs et graphes198
  - 7.1.1 Implémentation des noeuds198
  - 7.1.2 Classe représentant les arcs199
  - 7.1.3 Graphes199
  - 7.2 Fin du programme générique200
  - 7.2.1 IHM200
  - 7.2.2 Algorithme générique201
  - 7.3 Implémentation des différents algorithmes202
  - 7.3.1 Recherche en profondeur202
  - 7.3.2 Recherche en largeur204
  - 7.3.3 Algorithme de Bellman-Ford205
  - 7.3.4 Algorithme de Dijkstra206
  - 7.3.5 Algorithme A*208
  - 7.4 Application à la carte209
  - 7.4.1 Gestion des tuiles209
  - 7.4.2 Implémentation de la carte211
  - 7.4.3 Programme principal218
  - 7.5 Comparaison des performances221
  - 8. Synthèse223
  - Chapitre 4
    Algorithmes génétiques
  - 1. Présentation du chapitre225
  - 2. Évolution biologique226
  - 2.1 Le concept d'évolution226
  - 2.2 Les causes des mutations227
  - 2.3 Le support de cette information : les facteurs228
  - 2.4 Des facteurs au code génétique230
  - 2.5 Le « cycle de la vie »232
  - 3. Évolution artificielle233
  - 3.1 Principes233
  - 3.2 Convergence234
  - 3.3 Exemple235
  - 3.3.1 Jeu du Mastermind235
  - 3.3.2 Création de la population initiale236
  - 3.3.3 Fonction d'évaluation237
  - 3.3.4 Phase de reproduction237
  - 3.3.5 Survie et enchaînement des générations239
  - 3.3.6 Terminaison de l'algorithme239
  - 4. Premières phases de l'algorithme240
  - 4.1 Choix des représentations240
  - 4.1.1 Population et individus240
  - 4.1.2 Gènes241
  - 4.1.3 Cas complexes241
  - 4.2 Initialisation de la population initiale243
  - 4.3 Évaluation des individus244
  - 5. Création des générations suivantes245
  - 5.1 Sélection des parents245
  - 5.2 Reproduction247
  - 5.2.1 Crossover247
  - 5.2.2 Mutation249
  - 5.3 Survie251
  - 5.4 Terminaison251
  - 6. Coévolution252
  - 7. Domaines d'application253
  - 8. Implémentation255
  - 8.1 Implémentation générique d'un algorithme255
  - 8.1.1 Spécifications255
  - 8.1.2 Paramètres256
  - 8.1.3 Individus et gènes258
  - 8.1.4 IHM260
  - 8.1.5 Processus évolutionnaire260
  - 8.2 Utilisation pour le voyageur de commerce264
  - 8.2.1 Présentation du problème264
  - 8.2.2 Environnement265
  - 8.2.3 Gènes267
  - 8.2.4 Individus268
  - 8.2.5 Programme principal271
  - 8.2.6 Résultats273
  - 8.3 Utilisation pour la résolution d'un labyrinthe274
  - 8.3.1 Présentation du problème274
  - 8.3.2 Environnement275
  - 8.3.3 Gènes280
  - 8.3.4 Individus281
  - 8.3.5 Modification de la fabrique284
  - 8.3.6 Programme principal286
  - 8.3.7 Résultats287
  - 9. Synthèse289
  - Chapitre 5
    Métaheuristiques d'optimisation
  - 1. Présentation du chapitre291
  - 2. Optimisation et minimums292
  - 2.1 Exemples292
  - 2.2 Le problème du sac à dos292
  - 2.3 Formulation des problèmes293
  - 2.4 Résolution mathématique294
  - 2.5 Recherche exhaustive296
  - 2.6 Métaheuristiques296
  - 3. Algorithmes gloutons297
  - 4. Descente de gradient300
  - 5. Recherche tabou302
  - 6. Recuit simulé305
  - 7. Optimisation par essaims particulaires307
  - 8. Méta-optimisation308
  - 9. Domaines d'application309
  - 10. Implémentation310
  - 10.1 Classes génériques311
  - 10.2 Implémentation des différents algorithmes312
  - 10.2.1 Algorithme glouton312
  - 10.2.2 Descente de gradient313
  - 10.2.3 Recherche tabou314
  - 10.2.4 Recuit simulé315
  - 10.2.5 Optimisation par essaims particulaires316
  - 10.3 Résolution du problème du sac à dos317
  - 10.3.1 Implémentation du problème318
  - 10.3.2 Algorithme glouton324
  - 10.3.3 Descente de gradient326
  - 10.3.4 Recherche Tabou327
  - 10.3.5 Recuit simulé329
  - 10.3.6 Optimisation par essaims particulaires331
  - 10.3.7 Programme principal335
  - 10.4 Résultats obtenus336
  - 11. Synthèse340
  - Chapitre 6
    Systèmes multi-agents
  - 1. Présentation du chapitre343
  - 2. Origine biologique344
  - 2.1 Les abeilles et la danse344
  - 2.2 Les termites et le génie civil346
  - 2.3 Les fourmis et l'optimisation de chemins347
  - 2.4 Intelligence sociale348
  - 3. Systèmes multi-agents348
  - 3.1 L'environnement348
  - 3.2 Les objets349
  - 3.3 Les agents349
  - 4. Classification des agents350
  - 4.1 Perception du monde350
  - 4.2 Prise des décisions350
  - 4.3 Coopération et communication351
  - 4.4 Capacités de l'agent352
  - 5. Principaux algorithmes353
  - 5.1 Algorithmes de meutes353
  - 5.2 Optimisation par colonie de fourmis354
  - 5.3 Systèmes immunitaires artificiels356
  - 5.4 Automates cellulaires357
  - 6. Domaines d'application359
  - 6.1 Simulation de foules359
  - 6.2 Planification360
  - 6.3 Phénomènes complexes360
  - 6.4 Autres domaines361
  - 7. Implémentation361
  - 7.1 Banc de poissons 2D362
  - 7.1.1 Les objets du monde et les zones à éviter362
  - 7.1.2 Les agents-poissons364
  - 7.1.3 L'océan372
  - 7.1.4 L'application graphique375
  - 7.1.5 Résultats obtenus379
  - 7.2 Tri sélectif381
  - 7.2.1 Les déchets381
  - 7.2.2 Les agents nettoyeurs383
  - 7.2.3 L'environnement388
  - 7.2.4 L'application graphique391
  - 7.2.5 Résultats obtenus396
  - 7.3 Le jeu de la vie397
  - 7.3.1 La grille398
  - 7.3.2 L'application graphique401
  - 7.3.3 Résultats obtenus404
  - 8. Synthèse406
  - Chapitre 7
    Réseau de neurones
  - 1. Présentation du chapitre407
  - 2. Origine biologique408
  - 3. Machine Learning410
  - 3.1 Formes d'apprentissage et exemples410
  - 3.1.1 Apprentissage non supervisé411
  - 3.1.2 Apprentissage supervisé412
  - 3.1.3 Apprentissage par renforcement414
  - 3.2 Régression et algorithme de régression linéaire415
  - 3.3 Classification et algorithme de séparation418
  - 4. Neurone formel et perceptron420
  - 4.1 Principe420
  - 4.2 Réseaux de type « perceptron »421
  - 4.3 Fonctions d'agrégation et d'activation423
  - 4.3.1 Fonction d'agrégation423
  - 4.3.2 Fonction d'activation424
  - 4.4 Exemple de réseau428
  - 4.5 Apprentissage429
  - 5. Réseaux feed-forward431
  - 5.1 Réseaux avec couche cachée431
  - 5.2 Apprentissage par rétropropagation du gradient433
  - 5.3 Surapprentissage435
  - 5.4 Améliorations de l'algorithme438
  - 5.4.1 Batch, mini-batch et gradient stochastique438
  - 5.4.2 Régularisation439
  - 5.4.3 Dropout439
  - 5.4.4 Variation de l'algorithme de descente de gradient440
  - 5.4.5 Création de nouvelles données : data augmentation440
  - 6. Autres architectures441
  - 6.1 Réseaux de neurones à convolution441
  - 6.2 Cartes de Kohonen442
  - 6.3 Réseaux de neurones récurrents442
  - 6.4 Réseaux de Hopfield443
  - 7. Domaines d'application443
  - 7.1 Reconnaissance de patterns444
  - 7.2 Estimation de fonctions444
  - 7.3 Création de comportements444
  - 7.4 Applications actuelles445
  - 8. Implémentation446
  - 8.1 Points et ensembles de points446
  - 8.2 Neurone449
  - 8.3 Réseau de neurones451
  - 8.4 Interface homme-machine455
  - 8.5 Système complet455
  - 8.6 Programme principal459
  - 8.7 Applications460
  - 8.7.1 Application au XOR460
  - 8.7.2 Application à Abalone462
  - 8.7.3 Améliorations possibles464
  - 9. Synthèse465
  - Bibliographie467
  - Sitographie
  - 1. Pourquoi une sitographie ?471
  - 2. Systèmes experts471
  - 3. Logique floue474
  - 4. Recherche de chemins477
  - 5. Algorithmes génétiques478
  - 6. Métaheuristiques480
  - 7. Systèmes multi-agents481
  - 8. Réseaux de neurones483
  - Annexe
  - 1. Installation de SWI-Prolog487
  - 2. Utilisation de SWI-Prolog sous Windows488
  - Index491
Origine de la notice:
- Electre