[Partie 1] Établir le cadre fondamental du LLM

Chapitre 1 Carte LLM

1.1 Apprentissage profond et modélisation du langage
1.1.1 Apprentissage profond qui extrait lui-même les caractéristiques des données
1.1.2 Intégration : Comment les modèles d’apprentissage profond représentent les données
1.1.3 Modélisation du langage : Comment les modèles d’apprentissage profond apprennent le langage
1.2 Comment le modèle de langage est devenu ChatGPT
1.2.1 De l'architecture RNN à l'architecture Transformer
1.2.2 La relation entre la taille du modèle et ses performances, telle qu'observée dans la série GPT
__1.2.3 L'émergence de ChatGPT
1.3 L'ère des demandes de LLM commence
__1.3.1 LLM qui a révolutionné notre façon d'utiliser les connaissances
__1.3.2 sLLM : Construction de modèles plus petits et plus efficaces
1.3.3 Techniques pour un apprentissage et une inférence plus efficaces
1.3.4 Technologie de génération de recherche augmentée (RAG) pour traiter le phénomène d'hallucination lié au LLM
1.4 L'avenir du LLM : élargir la perception et l'action
1.5 Résumé

Chapitre 2 : Aperçu de l’architecture du transformateur, au cœur du LLM

2.1 Qu'est-ce que l'architecture Transformer ?
2.2 Conversion de texte en éléments intégrés
__2.2.1 Tokenisation
__2.2.2 Conversion en plongements lexicaux
2.2.3 Encodage positionnel
2.3 Comprendre l'attention
2.3.1 Comment les gens lisent et l'attention
2.3.2 Comprendre les requêtes, les clés et les valeurs
__2.3.3 Attention dans le code
__2.3.4 Attention multi-têtes
2.4 Couches de normalisation et de propagation directe
__2.4.1 Comprendre la normalisation des couches
__2.4.2 Couche de propagation directe
Encodeur 2.5
Décodeur 2.6
2.7 Architectures utilisant des transformateurs tels que BERT, GPT et T5
BERT utilisant l'encodeur __2.7.1
__2.7.2 GPT utilisant un décodeur
__2.7.3 BART, T5 utilisant à la fois l'encodeur et le décodeur
2.8 Principaux mécanismes de préapprentissage
__2.8.1 Modélisation causale du langage
__2.8.2 Modélisation du langage masqué
2.9 Résumé

Chapitre 3 : Bibliothèque de transformateurs Hugging Face pour la gestion des modèles de transformateurs

3.1 Qu'est-ce qu'un Hugging Face Transformer ?
3.2 Exploration du hub Hugging Face
__3.2.1 Centre de modélisation
__3.2.2 Centre de données
3.2.3 Un espace où les démonstrations de modèles peuvent être rendues publiques et mises à disposition pour utilisation
3.3 Apprendre à utiliser la bibliothèque Hugging Face
3.3.1 Utilisation du modèle
3.3.2 Utilisation du tokenizer
3.3.3 Utilisation de l'ensemble de données
3.4 Entraînement du modèle
3.4.1 Préparation des données
3.4.2 Formation à l'aide de l'API Trainer
3.4.3 Entraînement sans utiliser l'API de l'entraîneur
3.4.4 Téléchargement du modèle entraîné
3.5 Inférence du modèle
3.5.1 Inférence à l'aide de pipelines
3.5.2 Inférence directe
3.6 Résumé

Chapitre 4 : Construire un modèle qui obéit

4.1 Réussir le test de codage : pré-entraînement et mise au point de la carte
4.1.1 Maîtriser les concepts de programmation : Prérequis pour le LLM
__4.1.2 Exercice pratique : Ajustement précis de la carte
4.1.3 Conditions pour un bon jeu de données d'instructions
4.2 Amélioration de la lisibilité du code grâce à un modèle de notation
4.2.1 Création d'un modèle de notation à l'aide d'un jeu de données privilégié
4.2.2 Apprentissage par renforcement : vers des scores de lisibilité du code élevés
4.2.3 PPO : Éviter les astuces en matière de rémunération
__4.2.4 RLHF : Sympa, mais si vous pouvez l’éviter…
4.3 L’apprentissage par renforcement est-il vraiment nécessaire ?
__4.3.1 Échantillonnage par rejet : que se passe-t-il si nous utilisons simplement les données ayant obtenu le score le plus élevé ?
4.3.2 DPO : Entraînement direct sur les jeux de données préférés
4.3.3 Modèles entraînés à l'aide de DPO
4.4 Résumé

[Partie 2 : Apprivoiser le LLM]

Chapitre 5 : Apprentissage efficace sur GPU

5.1 Analyse des données chargées sur le GPU
5.1.1 Types de données des modèles d'apprentissage profond
5.1.2 Réduction de la taille du modèle par quantification
5.1.3 Démontage de la mémoire GPU
5.2 Utilisation efficace d'un seul GPU
__5.2.1 Accumulation du gradient
__5.2.2 Point de contrôle du gradient
5.3 Apprentissage distribué et ZeRO
5.3.1 Apprentissage distribué
__5.3.2 Réduction du stockage redondant dans le parallélisme des données (ZeRO)
5.4 Méthode d'apprentissage efficace (PEFT) : LoRA
5.4.1 Apprentissage LoRA par reconfiguration d'une partie seulement des paramètres du modèle
__5.4.2 Affichage des paramètres LoRa
5.4.3 Utilisation de LoRa Learning avec du code
5.5 Méthode d'apprentissage efficace (PEFT) : QLoRA
__5.5.1 Quantification sur 4 bits et quantification du second ordre
__5.5.2 Optimiseur de page
5.5.3 Utilisation des modèles QLoRA avec du code
5.6 Résumé

Chapitre 6 : Étudier le LLM

6.1 Ensemble de données Text2SQL
__6.1.1 Exemples de jeux de données Text2SQL
__6.1.2 Ensemble de données coréen
6.1.3 Utilisation de données synthétiques
6.2 Préparation du processus d'évaluation des performances
__6.2.1 Méthode d'évaluation Text2SQL
6.2.2 Constitution d'un ensemble de données d'évaluation
__6.2.3 Invite de génération SQL
__6.2.4 Préparation de l'invite d'évaluation et du code GPT-4
6.3 Travaux pratiques : Réaliser des réglages fins
6.3.1 Évaluation du modèle de base
6.3.2 Réalisation des réglages fins
6.3.3 Nettoyage et ajustement fin des données d'entraînement
6.3.4 Modifier le modèle de base
__6.3.5 Comparaison des performances des modèles
6.4 Résumé

Chapitre 7 : Alléger le modèle

7.1 Comprendre l'inférence du modèle de langage
7.1.1 Comment les modèles de langage génèrent le langage
__7.1.2 Cache KV pour réduire les opérations redondantes
7.1.3 Architecture GPU et taille optimale des lots
7.1.4 Réduction de la mémoire cache KV
7.2 Réduction de la taille du modèle par quantification
__7.2.1 Morceaux et Morceaux
__7.2.2 GPTQ
__7.2.3 AWQ
7.3 Utilisation de la distillation des connaissances
7.4 Résumé

Chapitre 8 Servir sLLM

8.1 Stratégies de déploiement efficaces
__8.1.1 Disposition générale (disposition statique)
8.1.2 Déploiement dynamique
8.1.3 Traitement par lots continu
8.2 Fonctionnement efficace des transformateurs
__8.2.1 Attention flash
__8.2.2 Flash Attention 2
8.2.3 Encodage de position relative
8.3 Stratégies d'inférence efficaces
__8.3.1 Fusion du noyau
__8.3.2 Page Attention
8.3.3 Décodage spéculatif
8.4 Mise en pratique : Cadre de service LLM
8.4.1 Service hors ligne
8.4.2 Service en ligne
8.5 Résumé

[Partie 3] Développement d'applications pratiques avec LLM

Chapitre 9 : Élaboration des demandes de maîtrise en droit

9.1 Génération de recherche augmentée (RAG)
9.1.1 Stockage des données
__9.1.2 Intégration des résultats de recherche dans les invites
__9.1.3 Exercice pratique : Mise en œuvre de RAG avec RamaIndex
Cache LLM 9.2
__9.2.1 Fonctionnement du cache LLM
__9.2.2 Exercice pratique : Implémentation du cache de l’API OpenAI
9.3 Vérification des données
9.3.1 Méthode de vérification des données
__9.3.2 Pratique de validation des données
9.4 Enregistrement des données
__9.4.1 Journalisation de l'API OpenAI
__9.4.2 Journalisation de l'index Rama
9.5 Résumé

Chapitre 10 : Compression du sens des données grâce aux modèles d’intégration

10.1 Comprendre les plongements lexicaux
10.1.1 Avantages de l'enchâssement de phrases
__10.1.2 Codage One-Hot
__10.1.3 Dos des guerres
__10.1.4 TF-IDF
__10.1.5 Mot au verso
10.2 Méthode d'intégration de phrases
10.2.1 Deux façons de calculer les relations entre les phrases
__10.2.2 Structure du modèle de bi-encodeur
__10.2.3 Génération d'embeddings de texte et d'image avec des transformateurs de phrases
__10.2.4 Comparaison des modèles d'intégration open source et commerciaux
10.3 Exercice pratique : Mise en œuvre de la recherche sémantique
10.3.1 Mise en œuvre de la recherche sémantique
__10.3.2 Utilisation du modèle de transformateurs de phrases dans RamaIndex
10.4 Combinaison de méthodes de recherche pour améliorer les performances
__10.4.1 Méthode de recherche par mots clés : BM25
__10.4.2 Comprendre les combinaisons de rangs mutuels
10.5 Exercices pratiques : Mise en œuvre de la recherche hybride
__10.5.1 Mise en œuvre de BM25
__10.5.2 Mise en œuvre des combinaisons de rangs mutuels
10.5.3 Mise en œuvre de la recherche hybride
10.6 Résumé

Chapitre 11 : Création de modèles d’intégration adaptés à vos données : Amélioration du RAG

11.1 Deux façons d'améliorer les performances de recherche
11.2 Création d'un modèle de langage en tant que modèle d'intégration
__11.2.1 Apprentissage contrastif
11.2.2 Pratique : Préparation à l'apprentissage
__11.2.3 Exercice : Entraînement d’un modèle d’intégration avec des données de phrases similaires
11.3 Ajustement du modèle d'intégration
11.3.1 Pratique : Préparation à l'apprentissage
__11.3.2 Réglage fin à l'aide de la perte MNR
11.4 Réorganisation des classements pour améliorer la qualité de la recherche
11.5 Implémentation d'un RAG amélioré avec bi-encodeur et encodeur croisé
__11.5.1 Recherche avec le modèle d'intégration par défaut
11.5.2 Recherche avec un modèle d'intégration affiné
__11.5.3 Combinaison d'un modèle d'intégration finement ajusté avec un encodeur croisé
11.6 Résumé

Chapitre 12 : Extension aux bases de données vectorielles : Implémentation de RAG

12.1 Qu'est-ce qu'une base de données vectorielles ?
__12.1.1 Apprentissage profond et bases de données vectorielles
12.1.2 Comprendre le terrain de la base de données vectorielles
12.2 Fonctionnement des bases de données vectorielles
__12.2.1 Recherche KNN et ses limitations
__12.2.2 Qu'est-ce que la recherche ANN ?
__12.2.3 Explorable Small World (NSW)
12.2.4 Structure hiérarchique
12.3 Exercice : Comprendre les paramètres clés de l'indice HNSW
__12.3.1 Comprendre le paramètre m
__12.3.2 Comprendre le paramètre ef_construction
__12.3.3 Comprendre le paramètre ef_search
12.4 Exercice pratique : Mise en œuvre de la recherche vectorielle avec Pinecone
__12.4.1 Comment utiliser le client Pinecone
__12.4.2 Modification de la base de données vectorielles dans RamaIndex
12.5 Exercice pratique : Mise en œuvre de la recherche multimodale avec Pinecone
__12.5.1 Ensemble de données
__12.5.2 Déroulement de la pratique
__12.5.3 Génération de descriptions d'images avec GPT-4o
__12.5.4 Invite d'enregistrement
__12.5.5 Recherche d'intégration d'images
__12.5.6 Création d'une image avec DALL-E 3
12.6 Résumé

Chapitre 13 : Suivre un LLM

13,1 MLOps
13.1.1 Gestion des données
13.1.2 Gestion expérimentale
__13.1.3 Référentiel de modèles
__13.1.4 Surveillance du modèle
13.2 Qu'est-ce qui différencie LLMOps ?
13.2.1 Choisir entre un modèle commercial et un modèle open source
13.2.2 Modifications des méthodes d'optimisation des modèles
13.2.3 Difficultés liées à l'évaluation du LLM
13.3 Évaluation du LLM
13.3.1 Indicateurs quantitatifs
__13.3.2 Évaluation à l'aide d'ensembles de données de référence
13.3.3 Comment les gens évaluent directement
13.3.4 Évaluation par le biais du LLM
__13.3.4 Évaluation RAG
13.4 Résumé

[Partie 4] Multimodalité, agents et avenir du LLM

Chapitre 14 Multimodal

LLM 14.1 Qu'est-ce qu'un LLM multimodal ?
14.1.1 Composantes d'un LLM multimodal
__14.1.2 Cours d'apprentissage multimodal LLM
14.2 Modèle de liaison entre images et texte : CLIP
__14.2.1 Qu'est-ce que le modèle CLIP ?
__14.2.2 Méthode d'apprentissage du modèle CLIP
14.2.3 Utilisation du modèle CLIP et excellentes performances
14.2.4 Utilisation directe du modèle CLIP
14.3 Un modèle de génération d'images à partir de texte : DALL-E
14.3.1 Principe du modèle de diffusion
Modèle DALL-E __14.3.2
14.4 LLaVA
__14.4.1 Données d'entraînement de LLaVA
__14.4.2 Structure du modèle LLaVA
__14.4.3 LLaVA 1.5
__14.4.4 LLaVA NeXT
14.5 Résumé

Chapitre 15 Agent LLM

15.1 Qu'est-ce qu'un agent ?
__15.1.1 Composants de l'agent
__15.1.2 Le cerveau de l'agent
__15.1.3 Les sens de l'agent
__15.1.4 Comportement de l'agent
15.2 Types de systèmes d'agents
15.2.1 Agent unique
__15.2.2 Interaction agent utilisateur
__15.2.3 Multi-agent
15.3 Évaluation des agents
15.4 Exercice pratique : Mise en œuvre d’un agent
__15.4.1 Utilisation de base d'AutoGen
__15.4.2 Agent RAG
__15.4.3 Agent multimodal
15.5 Résumé

Chapitre 16 : Nouvelle architecture

16.1 Avantages et inconvénients des architectures existantes
16.2 SSM
__16.2.1 S4
16.3 Mécanisme de sélection
16.4 Mamba
__16.4.1 Performance de Mamba
16.4.2 Comparaison avec l'architecture existante
Mamba dans le code 16.5

Annexe | Préparation à l'exercice

A.1 Comment utiliser Google Colab
A.2 Jeton Visage Câlin
A.3 Jeton OpenAI

| Ce que ce livre aborde |

- Architecture Transformer, au cœur du LLM
- Comment créer un ChatGPT : Optimisation de la carte et RLHF
- Apprenez-en davantage sur le LLM open source avec vos propres données
- Modèle léger pour l'application LLM
- Mise en œuvre et amélioration du RAG à l'aide de l'indice de Rama
- LLM multimodal qui traite à la fois les images et les voix
- Architecture d'agent combinant mémoire à long terme et outils dans LLM

| Public cible de ce livre |

- Développeurs souhaitant créer des applications d'IA à l'aide de LLM
- Les développeurs curieux de connaître les principes et les technologies sous-jacentes du modèle plutôt que de simplement utiliser l'API LLM.
- Étudiants et demandeurs d'emploi souhaitant devenir ingénieurs en IA
- Les étudiants diplômés qui souhaitent organiser rapidement des articles et des technologies liés au LLM

| Télécharger le code d'entraînement GitHub |

Le code d'exercice se trouve dans le dépôt GitHub du livre (https://github.com/onlybooks/llm).
Le code provenant de GitHub peut être utilisé dans Google Colab de deux manières :

1.
Téléchargement depuis le local : Clonez le code depuis GitHub vers votre environnement local ou téléchargez-le sous forme de fichier compressé, puis ouvrez le fichier notebook (ipynb) dans le dossier d'exercices que vous souhaitez utiliser dans Google Colab.
Vous pouvez procéder avec la partie humide.
2.
Ouvrir avec une URL GitHub : lorsque vous sélectionnez Ouvrir le notebook dans Google Colab (Ctrl+O), vous pouvez ouvrir le notebook d’exercice via l’URL du code dans l’onglet GitHub parmi les différentes façons d’ouvrir le notebook.

| Environnement d'exécution du code pour ce livre |

Les exercices de ce livre sont réalisés sur Google Colab.
Google Colab est un environnement d'exécution de notebooks fourni par Google, qui peut être exécuté dans un navigateur avec une interface utilisateur similaire à celle de Jupyter Notebook de Python.
Google Colab fournit également un GPU T4 (16 Go) pour une utilisation gratuite.
La version gratuite de Google Colab a une durée d'exécution limitée à 12 heures et peut se déconnecter si elle reste inutilisée pendant une période prolongée.

[Note de l'auteur]

En juillet 2024, date de rédaction de cet article, les mots-clés du marché de l'IA et du LLM pouvaient être définis comme étant « multimodale, agent et IA embarquée ».
Le terme « multimodal » désigne un modèle d'IA qui traite différents types de données, comme du texte, des images, de la voix et de la vidéo, tandis qu'un agent désigne un système plus avancé dans lequel un modèle d'IA possède une mémoire à long terme et utilise divers outils, comme les recherches sur Internet et l'exécution de code, pour résoudre les problèmes des utilisateurs.
L'IA embarquée désigne les modèles d'IA fonctionnant directement sur l'appareil de l'utilisateur, plutôt que dans le cloud ou sur des serveurs haute performance.
L'avantage est que les utilisateurs peuvent utiliser des modèles d'IA sans craindre que leurs informations personnelles ne soient divulguées, car leurs informations ne quittent pas l'appareil.
Cette tendance majeure du marché des LLM peut être confirmée par les modèles et projets récemment publiés par les principales entreprises d'IA.

En mai 2024, OpenAI a dévoilé GPT-4o, un nouveau modèle de langage capable de voir, d'entendre et de parler.
Le lendemain, Google DeepMind a dévoilé le projet Astra, un agent multimodal qui fait quasiment la même chose.
En juin 2024, Anthropic a publié son modèle Claude 3.5 Sonnet, qui a surpassé le GPT-40 d'OpenAI.
Sonnet est le nom du modèle de milieu de gamme d'Anthropic.
Cela nous laisse présager d'excellentes performances pour le prochain modèle haut de gamme, le Claude 3.5 Opus.

En juin 2024, Apple a annoncé un nouveau nom pour les capacités d'IA exécutées sur ses appareils : Apple Intelligence.
Depuis la sortie de ChatGPT, Apple n'a montré aucun progrès significatif dans la recherche et le développement en IA, ce qui amène beaucoup à penser qu'Apple est en train de perdre son leadership à l'ère de l'IA.
Cependant, Apple a fait preuve de confiance en utilisant un nom provocateur qui signifie IA, pouvant également se lire Apple Intelligence, et le marché affiche également de grandes attentes.

Pour comprendre les mots-clés mentionnés jusqu'à présent, il est nécessaire de comprendre les modèles d'IA les plus récents, notamment les grands modèles de langage, et comment les utiliser.

Ce livre aborde à la fois les modèles eux-mêmes et leur application, aidant ainsi les lecteurs à se tenir au courant des tendances récentes du marché de l'IA.
Les deux premières parties du livre (chapitres 1 à 8) présentent les principes du LLM et le modèle lui-même, y compris comment apprendre le modèle et comment faire des inférences, pour vous aider à le comprendre en profondeur.
La partie 3 du livre (chapitres 9 à 13) explore les composants nécessaires au développement d'applications utilisant LLM et la génération augmentée par récupération (RAG).
Enfin, la partie 4 (chapitres 14 à 16) introduit la multimodalité, les agents et les architectures LLM nouvellement étudiées, offrant un aperçu du futur proche du LLM.

[Note de l'éditeur]

Avant d'aborder le développement d'applications LLM, il est nécessaire de se demander pourquoi ces applications sont si attrayantes pour les gens.
De nombreuses technologies ont émergé puis disparu au fil des ans, mais les principales technologies encore utilisées aujourd'hui se distinguent par des paradigmes de développement ou d'utilisation considérablement avancés.
Pour déterminer si les applications LLM vont se généraliser et devenir un outil essentiel pour les développeurs, il est préférable d'examiner d'abord les changements en cours.


Commençons par les changements côté utilisateur.
Même aujourd'hui, il est nécessaire de garder à l'esprit la recherche pour acquérir des connaissances.
Lorsqu'un utilisateur saisit un mot-clé ou une combinaison de mots dans un moteur de recherche, une liste de documents correspondants apparaît comme par magie.
Au départ, les listes étaient compilées méticuleusement, élément par élément, comme un annuaire téléphonique, afin d'en améliorer la qualité. Mais l'avènement de la surcharge informationnelle a rapidement entraîné l'automatisation. Le moteur de recherche le plus emblématique, la série AltaVista, ne disposait pas d'un algorithme performant pour le classement des résultats ; il fallait donc parcourir manuellement de nombreuses listes.
Puis, Google, sur lequel nous nous appuyons encore aujourd'hui, est arrivé et a considérablement amélioré la qualité de la recherche, permettant de trouver ce que l'on cherchait dès la première page.


Mais récemment, l'accent s'est déplacé de la recherche vers la formulation de questions.
Dans notre société actuelle, où tout va très vite, même l'ouverture d'une liste élément par élément est devenue fastidieuse, et la qualité des résultats de recherche ne cesse de se dégrader par rapport au passé, notamment à cause de pratiques abusives sous couvert d'optimisation pour les moteurs de recherche. On peut donc y voir la réponse au désir de poser une question et d'obtenir la réponse souhaitée.
Dans le cas de ChatGPT ou de Google Gemini, la multimodalité est prise en charge, vous pouvez donc poser et recevoir des questions en combinant images et texte.

Ensuite, nous devons examiner les changements survenus dans l'apprentissage automatique et l'apprentissage profond.
Avant l’avènement de l’IA générative et des grands modèles de langage (LLM), la plupart des modèles d’apprentissage automatique et d’apprentissage profond étaient spécifiques à un domaine.
En d'autres termes, des travaux de recherche et de développement ont été menés pour résoudre efficacement des problèmes de portée limitée, afin que des prédictions et des analyses puissent être réalisées en utilisant les données accumulées dans le domaine concerné.
Bien sûr, lorsque le monde de l'apprentissage profond a commencé, les infrastructures de big data, de cloud et de GPU existaient déjà, mais il n'y avait pas de percée technologique ou économique permettant de les étendre à des fins générales.
Par exemple, dans le domaine des images, divers modèles d'apprentissage profond ont émergé, à commencer par le jugement de chiffres à l'aide de l'ensemble de données MNIST et divers jugements de classe à l'aide de l'ensemble de données CIFAR-10, et même YOLO, qui peut identifier l'emplacement des objets et juger les classes en temps réel, mais ils sont tous limités à la classification d'images.


Cependant, avec l'émergence de l'IA générative, elle évolue vers un modèle à usage général capable d'effectuer diverses tâches.
Par exemple, ChatGPT est très performant pour répondre non seulement aux questions générales, mais aussi aux questions spécialisées telles que les questions médicales ou juridiques, et les modèles avancés tels que GPT-4V ou 4o qui prennent en charge la multimodalité peuvent également répondre aux questions concernant les tableaux ou les images.
Il est également considéré comme un outil polyvalent car il peut générer du code Python à l'exécution et afficher les résultats de l'exécution dans un environnement isolé lorsque des calculs complexes ou des sorties graphiques sont nécessaires.
L'IA générative démontre des cas d'utilisation diversifiés, notamment les questions-réponses, la traduction, la classification, le résumé, l'analyse, la modification stylistique et l'analyse des sentiments, et évolue au-delà de l'information et du soutien à la décision pour atteindre le niveau du raisonnement autonome.


Enfin, il ne faut pas oublier les changements survenus dans le développement lui-même, qui sont susceptibles d'intéresser le plus les développeurs.
Les premiers langages de programmation étaient axés sur la logique. Les langages fonctionnels comme LISP mettaient à l'épreuve les capacités de calcul humaines en s'appuyant sur la théorie mathématique. Les méthodes procédurales ont été introduites par Fortran, Pascal et le langage C. Les techniques orientées objet ont été introduites par C++ et Java.
Parallèlement, les progrès se sont concentrés sur les données. SQL a facilité la manipulation de données structurées sous forme de tableaux, et avec l'avènement du Big Data, il est devenu possible de traiter non seulement des données structurées, mais aussi des données semi-structurées et non structurées.


Parallèlement, avec l'émergence récente de l'IA générative, une autre vague de changement se fait sentir.
Une nouvelle méthode a vu le jour : utiliser un langage plus proche des humains que des ordinateurs pour implémenter la logique métier ! Cette technique, également appelée ingénierie des prompts, orchestre les entrées du langage pour obtenir les résultats souhaités et ajuste la sortie afin d’atteindre le résultat escompté.
Comme les invites sont plus proches du langage utilisé par les humains, il est difficile de garantir leur exactitude, mais en contrepartie, on gagne en flexibilité et en extensibilité, ce qui a permis de mettre en œuvre facilement une logique métier qui était auparavant assez difficile à implémenter.

L'émergence de l'IA générative s'accompagne de nombreux changements, et les développeurs doivent se préparer à s'adapter.
Si vous développez une application avec la structure existante navigateur web (ou application) - WAS (serveur d'applications web) - base de données (relationnelle ou NoSQL), vous devez identifier les cas d'utilisation de LLM en fonction des exigences de l'entreprise et modifier l'architecture en conséquence.
Une technologie particulièrement intéressante est la génération de recherche augmentée (RAG), qui a récemment suscité un vif intérêt dans le monde de l'entreprise. RAG est une application qui utilise une technologie d'intégration de documents et de données au sein de l'entreprise pour construire une base de connaissances sous forme de base de données vectorielle. Elle extrait ensuite de cette base les fragments de documents les plus pertinents pour la question de l'utilisateur et les fait synthétiser par un assistant logiciel.


Alors que les méthodes de recherche traditionnelles, basées sur des algorithmes tels que TF/IDF ou BM25, encodent les mots (mots-clés) d'une phrase à l'aide de vecteurs creux, la recherche sémantique utilisée dans RAG emploie des vecteurs denses pour encoder le sens abstrait et les relations entre les mots. Elle s'avère ainsi parfaitement compatible avec LLM, qui excelle dans le traitement automatique du langage naturel. RAG illustre parfaitement la mise en œuvre concrète du concept d'entropie de l'information, défendu par Claude Shannon dans les années 1950. Elle combine judicieusement les deux technologies majeures que sont l'intégration et LLM pour optimiser le traitement d'informations aux significations multiples. Les développeurs pourront ainsi puiser une riche source d'inspiration dans cet écosystème technologique.


Ce livre commence par présenter l'architecture de base de LLM, l'adapte aux exigences des applications, le rend léger pour une utilisation dans des environnements informatiques limités et jette les bases d'une prestation de services fluide. Il explique ensuite étape par étape comment créer une application LLM représentative appelée RAG.
Cela ne s'arrête pas là, mais couvre également la manière de surmonter les difficultés rencontrées lors de l'exploitation réelle, ainsi que des sujets avancés tels que la multimodalité et les agents.
En d'autres termes, il explique les connaissances en matière de développement essentielles à l'ère du LLM d'un point de vue à la fois théorique et pratique, ce qui constituera un soulagement bienvenu pour les développeurs cherchant à s'adapter au nouveau paradigme.
Je recommande vivement ce produit à tous les développeurs qui travaillent constamment dans le domaine de la recherche et du développement.

- Jaeho Park / Responsable du blog « Computer vs. Book » et traducteur de « Clean Code: Now Python » (Bookman, 2022)