[Partie 1] Noyau de PyTorch

Chapitre 1 : Introduction à l'apprentissage profond et à la bibliothèque PyTorch
__1.1 La révolution de l'apprentissage profond
__1.2 PyTorch pour l'apprentissage profond
__1.3 Pourquoi PyTorch ?
____1.3.1 Paysage concurrentiel de l'apprentissage profond
__1.4 Présentation du projet d'apprentissage profond PyTorch
1.5 Configuration matérielle et logicielle requise
____1.5.1 Carnet Jupyter
__1.6 Exercices pratiques
1.7 Résumé des points clés

Chapitre 2 Réseaux de neurones pré-entraînés
2.1 Réseau neuronal pré-entraîné pour la reconnaissance d'images
____2.1.1 Importation d'un réseau neuronal pré-entraîné pour la reconnaissance d'images
____2.1.2 Alexnet
____2.1.3 ResNet
____2.1.4 Préparation, avant de commencer… un instant
____2.1.5 Courez !
____2.2 Modèle pré-entraîné pour créer de fausses images
____2.2.1 Jeu GAN
____2.2.2 CycleGAN
____2.2.3 Réseau neuronal qui transforme les chevaux en zèbres
2.3 Réseau neuronal pré-entraîné pour décrire les scènes
____2.3.1 Communication neuronale 2
__2.4 Moyeu de torche
__2.5 Conclusion
__2.6 Exercices pratiques
__2.7 Résumé des points clés

Chapitre 3 Structure tensorielle
__3.1 Le monde des nombres à virgule flottante
3.2 Tenseur : Tableaux multidimensionnels
3.2.1 Conversion des listes Python en tenseurs PyTorch
____3.2.2 Création de votre premier tenseur
____3.2.3 Le noyau des tenseurs
__3.3 Indexation des tenseurs
3.4 Tenseurs nommés
3.5 Types d'éléments tenseurs
____3.5.1 Spécification des types numériques avec dtype
____3.5.2 dtype utilisé dans tous les cas
____3.5.3 Gestion des attributs dtype des tenseurs
__3.6 API Tensor
3.7 Visualisation des tenseurs du point de vue du stockage
____3.7.1 Indexation de l'espace de stockage
3.7.2 Modification des valeurs stockées : opérations internes sur les tenseurs
3.8 Métadonnées du tenseur : taille, décalage, pas
____3.8.1 Création d'une vue sur le stockage d'un autre tenseur
____3.8.2 Transposition d'un tenseur sans copie
____3.8.3 Opérations de transposition dans des dimensions supérieures
____3.8.4 Tenseurs adjacents
3.9 Transfert des tenseurs vers le GPU
____3.9.1 Gestion des propriétés du périphérique Tensor
Compatible avec NumPy __3.10
__3.11 Les tenseurs généralisés sont également des tenseurs
__3.12 Sérialisation des tenseurs
____3.12.1 Parallélisation de HDF5 avec h5py
__3.13 Conclusion
__3.14 Exercices pratiques
__3.15 Résumé des points clés

Chapitre 4 : Représentation des données réelles sous forme de tenseurs
4.1 Gestion des images
____4.1.1 Ajout de canaux de couleur
____4.1.2 Chargement des fichiers image
____4.1.3 Modification de la mise en page
____4.1.4 Normalisation des données
4.2 Images 3D : Données volumiques
____4.2.1 Chargement des formats spéciaux
4.3 Représentation des données tabulaires
____4.3.1 Utilisation d'ensembles de données réelles
____4.3.2 Lecture des données sur le vin sous forme de tenseur
____4.3.3 Expression des scores
____4.3.4 Encodage One-Hot
____4.3.5 Quand catégoriser
____4.3.6 Détermination par seuil
4.4 Traitement des données de séries chronologiques
____4.4.1 Ajout d'une dimension temporelle
____4.4.2 Création de données par heure
____4.4.3 Préparation à la formation
4.5 Représentation du texte
____4.5.1 Conversion de texte en nombres
____4.5.2 Encodage one-hot des caractères
____4.5.3 Encodage one-hot de tous les mots
____4.5.4 Intégration de texte
____4.5.5 Intégration de texte comme modèle
4.6 Conclusion
__4.7 Exercices pratiques
4.8 Résumé des points clés

Chapitre 5 Techniques d'apprentissage
5.1 Apprentissage par modélisation intemporelle
5.2 L'apprentissage se résume à l'estimation des paramètres
____5.2.1 Problèmes liés à la température
5.2.2 Collecte des données
____5.2.3 Visualisation des données
____5.2.4 Commencez par essayer de choisir un modèle linéaire.
5.3 Mesures visant à réduire les pertes
____5.3.1 Résolution d'un problème avec PyTorch
5.4 Descente de la pente
____5.4.1 Réduction des pertes
____5.4.2 Analyse
____5.4.3 Itérations pour l'ajustement du modèle
____5.4.4 Normalisation des entrées
____5.4.5 (Réexamen) Visualisation
__5.5 Différentiation automatique dans PyTorch : Rétropropagation de toutes les informations
____5.5.1 Calcul automatique de la pente
____5.5.2 Optimiseur sélectif
____5.5.3 Entraînement, validation et surapprentissage
____5.5.4 Remarques sur la différentiation automatique et la désactivation de la différentiation automatique
5.6 Conclusion
__5.7 Exercices pratiques
5.8 Résumé des points clés

Chapitre 6 : Ajustement des données à l’aide de réseaux neuronaux
6.1 Neurone artificiel
____6.1.1 Synthèse de réseaux neuronaux multicouches
____6.1.2 Fonction d'erreur
____6.1.3 Ce dont nous avons besoin, c'est d'une fonction d'activation
____6.1.4 Autres fonctions actives
6.1.5 Choix de la fonction d'activation optimale
____6.1.6 La signification de l'apprentissage dans les réseaux neuronaux
__6.2 Module nn PyTorch
6.2.1 Utiliser __call__ au lieu de forward
____6.2.2 Retour au modèle linéaire
6.3 Enfin, le réseau neuronal
____6.3.1 Remplacement des modèles linéaires
____6.3.2 Examen des paramètres
6.3.3 Comparaison avec les modèles linéaires
6.4 Conclusion
__6.5 Exercices pratiques
__6.6 Résumé des points clés

Chapitre 7 : Distinguer les oiseaux des avions : l’apprentissage par l’image
7.1 Un ensemble de données de petites images
____7.1.1 Téléchargement CIFAR-10
____7.1.2 Classe de jeu de données
____7.1.3 Conversion des données
____7.1.4 Normalisation des données
7.2 Distinguer les oiseaux des avions
____7.2.1 Constitution de l'ensemble de données
____7.2.2 Modèle entièrement connecté
____7.2.3 Sortie du classificateur
____7.2.4 Exprimer la production sous forme de probabilité
____7.2.5 Valeurs de perte pour la classification
____7.2.6 Formation des classificateurs
____7.2.7 Limites de la connectivité complète
7.3 Conclusion
__7.4 Exercices pratiques
__7.5 Résumé des points clés

Chapitre 8 Généralisation par convolution
8.1 Convolution
____8.1.1 Le rôle de la convolution
8.2 Essai de convolution
____8.2.1 Marge intérieure
____8.2.2 Recherche de caractéristiques par convolution
____8.2.3 Approfondir la reconnaissance grâce à la profondeur et à la mise en commun
____8.2.4 Application à notre réseau neuronal
8.3 Sous-classement de nn.Module
____8.3.1 Notre réseau neuronal défini avec nn.Module
____8.3.2 Comment PyTorch gère les paramètres et les sous-modules
____8.3.3 API fonctionnelle
8.4 Entraînement du réseau neuronal convolutif que nous avons créé
____8.4.1 Mesure de précision
____8.4.2 Sauvegarde et chargement des modèles
____8.4.3 Entraînement sur GPU
8.5 Conception du modèle
8.5.1 Augmentation de la capacité de mémoire : largeur
8.5.2 Comment aider les modèles à converger et à généraliser : la régularisation
8.5.3 Approfondir l'étude pour apprendre des structures plus complexes : Profondeur
____8.5.4 Comparaison des performances des modèles
____8.5.5 Déjà une vieille méthode
8.6 Conclusion
__8.7 Exercices pratiques
8.8 Résumé des points clés

[Partie 2] Apprentissage pratique par l'image : Diagnostic précoce du cancer du poumon

Chapitre 9 : Utiliser PyTorch pour combattre et vaincre le cancer
__9.1 Introduction aux cas d'utilisation
__9.2 Préparation d'un projet de grande envergure
__9.3 Qu'est-ce qu'un scanner CT ?
Projet 9.4 : Dispositif de diagnostic complet du cancer du poumon
____9.4.1 Pourquoi on ne peut pas simplement inonder un réseau neuronal de données jusqu'à ce qu'il se mette à fonctionner
____9.4.2 Qu'est-ce qu'un nodule ?
____9.4.3 Source des données : LUNA Grand Challenge
____9.4.4 Téléchargement des données LUNA
__9.5 Conclusion
__9.6 Résumé des points clés

Chapitre 10 : Combiner plusieurs sources de données en un ensemble de données unifié
__10.1 Fichier de données CT original
10.2 Analyse des données d'annotation LUNA
10.2.1 Ensembles d'entraînement et de validation
____10.2.2 Fusion des données d'annotation et des données candidates
__10.3 Chargement des tomodensitométries individuelles
____10.3.1 Unités Hounsfield
10.4 Détermination de la localisation du nodule à l'aide du système de coordonnées du patient
____10.4.1 Système de coordonnées du patient
10.4.2 Morphologie et taille des voxels du scanner CT
____10.4.3 Conversion des millimètres en adresses de voxels
____10.4.4 Extraction des nodules à partir de tomodensitométries
__10.5 Mise en œuvre d'un jeu de données simple
____10.5.1 Mise en cache des tableaux candidats avec la fonction getCtRawCandidate
____10.5.2 Création d'un jeu de données avec LunaDataset.__init__
____10.5.3 Séparation formation/validation
____10.5.4 Rendu des données
__10.6 Conclusion
__10.7 Exercices pratiques
__10.8 Résumé des points clés

Chapitre 11 : Entraînement d’un modèle de classification pour la détection des tumeurs
__11.1 Modèle de base et boucle d'apprentissage
11.2 Le point d'entrée principal de l'application
__11.3 Configuration et initialisation avant l'entraînement
____11.3.1 Initialisation du modèle et de l'optimiseur
____11.3.2 Gestion du chargeur de données et approvisionnement en données
__11.4 Conception du premier réseau neuronal
____11.4.1 Convolution de base
____11.4.2 Modèle complet
__11.5 Entraînement et validation du modèle
____11.5.1 Fonction computeBatchLoss
____11.5.2 Boucle de validation similaire à l'entraînement
__11.6 Résultats des indicateurs de performance
____11.6.1 Fonction logMetrics
__11.7 Exécution du script d'entraînement
____11.7.1 Données requises pour la formation
____11.7.2 Apprendre la fonction enumerateWithEstimate en utilisant l'intermission
__11.8 Évaluation du modèle : Une précision de 99,7 % est-elle bonne ?
__11.9 Représentation graphique des métriques liées à l'entraînement avec TensorBoard
____11.9.1 Exécution de TensorBoard
____11.9.2 Rendre la fonction d'enregistrement des métriques compatible avec TensorBoard
__11.10 Pourquoi le modèle ne peut pas apprendre à détecter les nodules
__11.11 Conclusion
__11.12 Exercices pratiques
__11.13 Résumé des points clés

Chapitre 12 : Améliorer la formation grâce aux métriques et à l’augmentation des données
__12.1 Plan d'amélioration de haut niveau
__12.2 Bons chiens et méchants : faux positifs et faux négatifs
12.3 Représentation schématique des cas positifs et négatifs
____12.3.1 L’avantage de Roxy, qui aboie sur n’importe qui, est sa reproductibilité.
____12.3.2 Preston, qui dort beaucoup mais attrape bien les voleurs, a pour spécialité la précision.
____12.3.3 Obtention de la précision et du rappel avec logMetrics
____12.3.4 L'indicateur ultime : le score F1
____12.3.5 Vérification du bon fonctionnement du modèle avec la nouvelle métrique
__12.4 À quoi ressemble un jeu de données idéal
12.4.1 Rapprocher les données de l'« idéal » plutôt que de la réalité
____12.4.2 Différences dans les résultats obtenus avec l'ensemble de données Luna équilibré
____12.4.3 Reconnaître les symptômes de surapprentissage
__12.5 Retour sur le problème du surapprentissage
____12.5.1 Surapprentissage du modèle de prédiction de l'âge du visage
12.6 Prévenir le surapprentissage grâce à l'augmentation des données
____12.6.1 Technologie spéciale d'augmentation des données
____12.6.2 Vérification de l'effet d'augmentation des données
__12.7 Conclusion
__12.8 Exercices pratiques
__12.9 Résumé des points clés

Chapitre 13 : Détection des nodules suspects par segmentation
__13.1 Ajout d'un deuxième modèle au projet
__13.2 Différents types de segmentation
13.3 Segmentation sémantique : classification au niveau du pixel
____13.3.1 Architecture UNET
13.4 Mise à jour du modèle de segmentation
____13.4.1 Application d'un modèle prêt à l'emploi à un projet
__13.5 Mise à jour de l'ensemble de données pour la segmentation
____13.5.1 UNET avec une taille d'entrée très limitée
13.5.2 Avantages et inconvénients de l'utilisation d'UNET pour les données 2D par rapport aux données 3D
____13.5.3 Création de données du monde réel
____13.5.4 Implémentation de Luna2dSegmentationDataset
____13.5.5 Conception des données d'entraînement et de validation
____13.5.6 Implémentation du jeu de données de segmentation Luna2D
____13.5.7 Augmenté fonctionnant sur GPU
__13.6 Script de formation mis à jour pour la segmentation
____13.6.1 Segmentation et initialisation du modèle d'augmentation
____13.6.2 Utilisation de l'optimiseur Adam
____13.6.3 Perte aux dés
____13.6.4 Importer une image dans TensorBoard
____13.6.5 Mise à jour de la journalisation des métriques
____13.6.6 Sauvegarde du modèle
__13.7 Résultats
__13.8 Conclusion
__13.9 Exercices pratiques
__13.10 Résumé des points clés

Chapitre 14 : Analyse de bout en bout des nœuds et défis restants
__14.1 Vers la ligne d'arrivée
14.2 Indépendance de l'ensemble de vérification
14.3 Liaison entre la segmentation tomodensitométrique et la classification des nodules candidats
____14.3.1 Segmentation
____14.3.2 Regroupement des voxels pour créer des candidats nodules
____14.3.3 Avez-vous trouvé un nodule ? Classification pour réduire les faux positifs
__14.4 Vérification quantitative
__14.5 Prédiction malveillante
____14.5.1 Acquisition d'informations malveillantes
____14.5.2 Valeur de référence de l'AUC : Classification par diamètre
____14.5.3 Réutilisation des poids précédents : ajustement fin
____14.5.4 Affichage supplémentaire dans TensorBoard
14.6 Ce que vous voyez grâce au diagnostic
14.6.1 Ensemble d'entraînement, ensemble de validation et ensemble de test
__14.7 Et ensuite ? Nous avons besoin de plus de données et d'inspiration.
____14.7.1 Prévenir le surapprentissage : une meilleure régularisation
____14.7.2 Données d'entraînement affinées
____14.7.3 Comparaison des résultats et des articles de recherche
__14.8 Conclusion
____14.8.1 Dans les coulisses
__14.9 Exercices pratiques
__14.10 Résumé des points clés

[Partie 3] Enfin, la distribution

Chapitre 15 La distribution en tant que produit
__15.1 Service de modèles PyTorch
____15.1.1 Modèle dans un flacon
____15.1.2 Ce que je souhaite lors du déploiement
____15.1.3 Demande par lots
15.2 Exportation du modèle
____15.2.1 Assurer la compatibilité au-delà de PyTorch avec ONNX
____15.2.2 Exportation vers PyTorch : Traçage
____15.2.3 Serveur construit avec des modèles suivis
__15.3 Opération JIT PyTorch
____15.3.1 Aller au-delà de Python/PyTorch traditionnel
____15.3.2 PyTorch du point de vue de l'interface et du backend
____15.3.3 TorchScript
____15.3.4 Rendre le code traçable avec TorchScript
__15.4 LibTorch : C++ PyTorch
____15.4.1 Exécution d'un modèle traité JIT en C++
____15.4.2 C++ pour débuter : L’API C++
__15.5 Mobile
____15.5.1 Amélioration de l'efficacité : conception et quantification des modèles
15.6 Technologies récentes : Modèle PyTorch pour les services d'entreprise
__15.7 Conclusion
__15.8 Exercices pratiques
__15.9 Résumé des points clés

| Ce que ce livre aborde |

- Entraînement des réseaux neuronaux profonds
- Implémentation des modules et des fonctions de perte
- Utilisez les modèles pré-entraînés de PyTorch Hub
- Exploration d'exemples de code Jupyter Notebook
- Analyse, évaluation et amélioration des performances des modèles d'apprentissage profond
Un projet de diagnostic du cancer simulé de bout en bout, de l'analyse du modèle à la mise en service, utilisant des données d'imagerie CT de tumeurs pulmonaires.

| Structure de ce livre |

La première partie, « PyTorch Core », couvre les compétences de base nécessaires pour comprendre les projets PyTorch et vous initie à la création de vos propres projets.
Nous explorerons ensuite certaines des fonctionnalités cachées qui font de PyTorch une bibliothèque, ainsi que l'API PyTorch, et nous entraînerons notre modèle de classification initial.
Après la première partie, vous serez prêt à vous attaquer à un véritable projet.
Le chapitre 1, « Introduction à l'apprentissage profond et à la bibliothèque PyTorch », présente PyTorch en tant que bibliothèque et son rôle dans la révolution de l'apprentissage profond, et explique ce qui la différencie des autres frameworks d'apprentissage profond.
Le chapitre 2, « Réseaux neuronaux pré-entraînés », illustre PyTorch en action en exécutant un exemple de réseau neuronal pré-entraîné.
Ce tutoriel explique comment télécharger et exécuter un modèle depuis PyTorch Hub.
Le chapitre 3, « Structures tensorielles », présente les tenseurs, les éléments constitutifs de base de PyTorch, et montre les parties cachées de l'API tensorielle ainsi que l'implémentation détaillée.
Le chapitre 4, « Exprimer des données du monde réel sous forme de tenseurs », explore comment des données diverses peuvent être exprimées avec des tenseurs et explique comment créer des tenseurs pour les modèles d’apprentissage profond.
Le chapitre 5, « Techniques d'apprentissage », décrit le mécanisme d'apprentissage par descente de gradient et explore comment PyTorch permet la descente de gradient avec différentiation automatique.
Le chapitre 6, « Ajustement des données avec des réseaux neuronaux », démontre le processus de création et d'entraînement d'un modèle de réseau neuronal pour la régression dans PyTorch en utilisant les modules nn et optim.
Le chapitre 7, « Distinguer les oiseaux des avions : apprentissage d'images », s'appuie sur ce que vous avez appris dans les chapitres précédents en construisant un modèle entièrement connecté pour la classification d'images et en élargissant vos connaissances de l'API PyTorch.
Le chapitre 8, « Généralisation avec convolution », présente les réseaux neuronaux convolutifs et couvre les concepts avancés pour la mise en œuvre de modèles de réseaux neuronaux dans PyTorch.

La deuxième partie, « Apprentissage pratique des images : diagnostic précoce du cancer du poumon », nous rapproche d'une solution complète pour le diagnostic automatisé du cancer du poumon.
Ces problèmes complexes servent de catalyseur pour démontrer des approches concrètes de résolution de problèmes de grande envergure tels que le dépistage du cancer.
Il s'agit d'un projet de grande envergure axé sur l'ingénierie propre, le dépannage et la résolution de problèmes.
Le chapitre 9, « Utiliser PyTorch pour combattre et vaincre le cancer », décrit une stratégie de bout en bout pour classifier les tumeurs pulmonaires à partir d'images CT.
Le chapitre 10, « Combinaison de plusieurs sources de données en un ensemble de données unifié », utilise les API PyTorch standard pour lire les données d'annotation étiquetées par des humains à partir d'images de tomodensitométrie, les transformer au format requis et les convertir en un tenseur.
Le chapitre 11, « Entraînement d'un modèle de classification pour la détection des tumeurs », présente le premier modèle de classification utilisant les données d'entraînement présentées au chapitre 10.
Entraînez le modèle et collectez les indicateurs de performance de base.
Dans le même temps, nous introduisons TensorBoard pour le suivi de l'entraînement.
Le chapitre 12, « Améliorer la formation grâce aux métriques et à l'augmentation », explore et met en œuvre des métriques de performance standard et les utilise pour identifier les faiblesses de la formation précédente.
Pour pallier ces faiblesses, nous utilisons ensuite l'équilibrage et l'augmentation des données afin de créer un ensemble d'entraînement amélioré.
Le chapitre 13, « Détection des nodules suspects à l'aide de la segmentation », décrit la segmentation et une architecture de modèle pixel à pixel pour créer une carte thermique qui identifie les emplacements des tumeurs sur l'ensemble du scanner CT.
Cette carte thermique peut être utilisée pour détecter les nodules pulmonaires sur les scanners CT en l'absence de données d'annotation manuelles.
Le chapitre 14, « Analyse des nœuds de bout en bout et défis restants », met en œuvre le projet final de bout en bout.
Diagnostiquer les patients atteints de cancer à l'aide d'un nouveau modèle de segmentation créé sur la base de la classification.

La troisième partie, intitulée « Enfin, la distribution », comprend un chapitre consacré à la distribution.

Le chapitre 15, « Déploiement en production », explore comment déployer des modèles PyTorch sous forme de simples serveurs Web, intégrés dans des programmes C++ ou intégrés sur des smartphones.

| Public cible de ce livre |

Ce livre s'adresse aux développeurs qui souhaitent appliquer l'apprentissage profond en pratique ou devenir compétents en PyTorch.
Nous supposons que nos lecteurs sont probablement des étudiants en informatique, des data scientists, des ingénieurs logiciels ou des étudiants de premier cycle dans des domaines connexes.
Puisque nous supposons que le lecteur n'a aucune connaissance préalable de l'apprentissage profond, nous allons réitérer des concepts que même les praticiens expérimentés connaissent déjà.
J'espère que les lecteurs qui ont un niveau plus avancé trouveront utiles les passages qui expliquent le sujet sous un angle légèrement différent, même s'il s'agit d'un sujet qu'ils connaissent déjà.
Les lecteurs de ce livre sont supposés posséder déjà des connaissances de base en programmation impérative et en programmation orientée objet.
Ce livre utilise Python ; les lecteurs doivent donc être familiarisés avec sa syntaxe de base et son environnement d'exécution.
Vous devez posséder des connaissances préalables sur la manière d'installer des packages Python ou d'exécuter des scripts sur votre plateforme.
Si vous avez de l'expérience avec des langages comme C++, Java, JavaScript ou Ruby, vous n'aurez pas beaucoup de difficultés, mais si vous n'y connaissez pas grand-chose, vous devrez investir un peu plus de temps pour acquérir des connaissances.
La connaissance de NumPy est utile, mais pas obligatoire.
Il serait également utile d'avoir quelques connaissances de base en algèbre linéaire, comme savoir ce qu'est une matrice, un vecteur ou un produit scalaire.

| Configuration matérielle et logicielle requise |

- Carte graphique avec 8 Go de RAM
- Au moins 200 Go d'espace disque
- Python 3.6 ou supérieur

[Note de l'auteur]

En 1980, alors que nous étions tous enfants, Ellie a fait ses premiers pas dans le monde de l'informatique avec un Commodore VIC 20, Luca avec un Sinclair Spectrum 48K et Thomas avec un Commodore C16.
Nous avons assisté à l'avènement de l'ordinateur personnel, appris à écrire du code et des algorithmes sur des ordinateurs de plus en plus rapides, et rêvé de l'avenir que nous réservaient les ordinateurs.
À ce moment-là, nous avons tous levé les yeux au ciel en regardant la scène où le protagoniste d'un film d'espionnage disait : « Ordinateur, zoomez », mais nous avons aussi constaté avec amertume le fossé entre l'ordinateur du film et le fonctionnement réel d'un ordinateur.
Plus tard dans leur carrière professionnelle, Ellie et Luca ont tous deux eu du mal à analyser des images d'imagerie médicale et ont dû relever le défi d'écrire des algorithmes pour tenir compte de la diversité du corps humain.
Diverses heuristiques ont été proposées sur la manière de combiner de façon optimale plusieurs algorithmes afin de raccourcir la période et de parvenir à un résultat satisfaisant.
Au tournant du XXIe siècle, Thomas avait obtenu un doctorat en mathématiques, où il avait étudié les réseaux neuronaux et la reconnaissance de formes, ainsi que la modélisation.

L'apprentissage profond, apparu dans le domaine de la vision par ordinateur au début des années 2010, a commencé à être utilisé dans l'analyse d'images médicales pour reconnaître les lésions et les structures dans les images médicales.
Ce n'est qu'au milieu des années 2010 que l'apprentissage profond a commencé à apparaître sur nos écrans de surveillance individuels.
Il a fallu un certain temps pour réaliser que l'apprentissage profond offrait une approche totalement nouvelle de la programmation logicielle.
Un nouveau système, appelé algorithme à usage général, apprend de lui-même à gérer des tâches complexes simplement en observant des données.
Du point de vue des nomades des années 1980, ce fut un moment où, du jour au lendemain, les possibilités des ordinateurs se sont étendues au-delà du cerveau des programmeurs qualifiés pour englober les données, les architectures de réseaux neuronaux et les processus d'apprentissage.
Immédiatement après cette prise de conscience, nous avons décidé de l'essayer nous-mêmes.
Luca a choisi le vénérable Torch 7 (http://torch.ch).
Torch7 était rapide, léger et facilement accessible grâce à son code source écrit en Lua et en C, et bénéficiait également du soutien d'une communauté établie de longue date.
Luca est tombé amoureux de Torch7 au premier regard.
Cependant, Torch 7 présentait un inconvénient : il s’éloignait de l’écosystème de science des données Python, en pleine croissance.
À l'inverse, à cette époque, d'autres frameworks étaient dérivés de Python.
Ellie s'intéresse à l'IA depuis ses années universitaires.
Mais sa carrière prenait une autre direction, et les premiers frameworks d'apprentissage profond représentaient trop de travail pour qu'il puisse les poursuivre comme un simple passe-temps.

C’est pourquoi nous étions tous très enthousiastes lors de la sortie de la première version de PyTorch le 18 janvier 2017.
Luca a contribué en tant que développeur principal, tandis qu'Ellie a été l'une des premières membres de la communauté, corrigeant des bugs étranges, ajoutant des fonctionnalités et mettant à jour la documentation.
Thomas a contribué à de nombreuses fonctionnalités et corrections de bugs, devenant finalement l'un des principaux contributeurs.
Quelque chose d'important était en train de se produire, nécessitant juste le bon niveau de complexité et une charge cognitive minimale.
Il hérite des leçons de conception allégée tirées de Torch 7 et ajoute des fonctionnalités de pointe telles que la différenciation automatique, les graphes de calcul dynamiques et l'intégration de NumPy.

Après avoir travaillé avec enthousiasme sur des projets et animé plusieurs ateliers PyTorch, écrire un livre m'a semblé une suite logique.
Nos auteurs se sont fixé pour objectif d'écrire un livre qui soit captivant pour ceux d'entre nous qui ont commencé à utiliser PyTorch il y a quelques années.
Comme prévu, nous avons commencé avec une idée ambitieuse.
J'ai essayé d'expliquer les meilleurs et les plus récents modèles de PyTorch en enseignant les bases et en suivant le projet de bout en bout.
Mais j'ai rapidement compris qu'un seul livre ne suffirait pas à couvrir tout cela.
J'ai donc décidé de me concentrer sur mes objectifs initiaux et de consacrer du temps et une analyse approfondie des concepts fondamentaux de PyTorch.
Il est rédigé de manière à ce que les lecteurs puissent suivre l'intégralité du projet même avec peu de connaissances préalables en apprentissage profond.
Pour notre projet pratique, nous avons choisi l'analyse d'images médicales, qui est notre spécialité.

[Note du traducteur]

Si j'avais l'occasion de poser une question à l'intelligence artificielle générale (IAG), je lui demanderais : Auriez-vous appris l'apprentissage basé sur les GPU, détecté des objets à partir d'images et existeriez-vous aujourd'hui si Andrew Ng n'avait pas rencontré Jeff Dean par hasard dans la cuisine de l'entreprise une dizaine d'années avant la publication de ce livre ?
Comme l'auteur le mentionne lui-même à plusieurs reprises dans le livre, les progrès réalisés dans le domaine de l'apprentissage profond au cours de la dernière décennie ont été formidables et se sont produits très rapidement.
Pour ceux d'entre nous qui avons fait des études d'ingénierie informatique et qui en vivons, avoir tant à étudier était un fardeau, mais d'un autre côté, c'était une joie de vivre l'excitation de voir l'imagination que nous ne voyions que dans les films devenir une réalité tout près de chez nous.
C'était en 2015.
L'apprentissage profond ayant émergé il y a quelques années, je pensais qu'il devrait exister des ouvrages bien structurés sur le sujet. J'ai donc parcouru quelques livres, y compris les versions originales sur les sites de librairies en ligne, mais il restait difficile de trouver du contenu utile. À de nombreuses reprises, j'ai acheté des livres parce qu'ils étaient minces, mais je les ai si mal parcourus que l'expression « les lire en un clin d'œil » est loin d'être suffisante.
Quand on me demande « Par où commencer pour étudier l'apprentissage profond ? », je recommande toujours les cours de Stanford et Coursera.
Quant aux livres, je n'en connais aucun que je puisse recommander. Le livre d'Ian Goodfellow sur l'apprentissage profond a été à la hauteur de sa réputation et regorgeait d'informations précieuses, mais pour être honnête, pour moi, c'était plus un recueil qu'un livre à lire, comme « L'Art de la programmation informatique » de Knuth.


Entre-temps, les frameworks d'apprentissage profond ont traversé la période des États combattants et sont désormais divisés en TensorFlow et PyTorch. Comme il se doit, ils ont évolué, passant de la simple présentation de modèles et de résultats d'entraînement performants à des démonstrations, à l'étape de la commercialisation où ils sont utilisés dans des services et des entreprises réels.
À peu près à la même époque, j'ai également suivi le mouvement et construit une plateforme complète pour l'application pratique et la commercialisation, mais il était difficile de trouver des livres ou des documents sur PyTorch, qui est apparu un peu plus tard que TensorFlow, en dehors du site web officiel.
À cette époque, un éditeur m'a demandé de traduire ce livre, comment aurais-je pu refuser ?
Je suis très fière que ce livre, qui a fait couler beaucoup d'encre parmi les groupes d'experts nationaux, ait enfin été publié en coréen, et que je participe à son processus de publication en tant que traductrice.


Contrairement à d'autres livres sur l'apprentissage profond que j'ai regrettés d'avoir achetés, car j'avais été trompé par le titre ou tenté par la minceur du livre, je n'ai aucun doute que celui-ci étanchera la soif des lecteurs avides de développement en intelligence artificielle, grâce à ses auteurs, membres fondateurs de PyTorch, et au contenu détaillé qu'il aborde.
Cet ouvrage est le fruit des efforts de l'auteur pour transmettre des connaissances durables sur le domaine en constante évolution de l'apprentissage profond. Il aborde tous les aspects, depuis les principes fondamentaux de l'apprentissage profond jusqu'aux explications des différents termes, techniques et outils pour une application pratique, en passant par l'évaluation.
Même si vous devrez peut-être étudier certains termes techniques séparément, n'abandonnez pas et lisez jusqu'au bout pour acquérir de nombreuses connaissances et une aide précieuse dans vos recherches en intelligence artificielle.

- Hyun Dong-seok