Traiter des données personnalisées pour les applications IA

Dans ce guide de démarrage rapide, vous allez apprendre à créer un pipeline d’ingestion de données pour traiter et préparer des données personnalisées pour les applications IA. L’application utilise la bibliothèque Microsoft.Extensions.DataIngestion pour lire des documents, enrichir le contenu avec l’IA, segmenter le texte de manière sémantique et stocker des embeddings dans une base de données vectorielle pour la recherche sémantique.

L’ingestion de données est essentielle pour les scénarios de génération augmentée par récupération (RAG), où vous devez traiter de grandes quantités de données non structurées et les rendre accessibles aux applications d'IA pour la recherche.

Prerequisites

Créer l’application

Effectuez les étapes suivantes pour créer une application console .NET.

  1. Dans un répertoire vide sur votre ordinateur, utilisez la commande dotnet new pour créer une application console :

    dotnet new console -o ProcessDataAI

  2. Modifiez le répertoire dans le dossier de l’application :

    cd ProcessDataAI

  3. Installez les packages nécessaires :

    dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.DataIngestion --prerelease
dotnet add package Microsoft.Extensions.DataIngestion.Markdig --prerelease
dotnet add package Microsoft.Extensions.Logging.Console
dotnet add package Microsoft.ML.Tokenizers.Data.O200kBase
dotnet add package Microsoft.SemanticKernel.Connectors.SqliteVec --prerelease

Créer le service d’IA

  1. Pour provisionner un service et un modèle Azure OpenAI, suivez les étapes décrites dans l’article Créer et déployer une ressource Azure OpenAI Service . Pour ce guide de démarrage rapide, vous devez provisionner deux modèles : gpt-5 et text-embedding-3-small.

  2. À partir d’un terminal ou d’une invite de commandes, accédez à la racine de votre répertoire de projet.

  3. Exécutez les commandes suivantes pour configurer votre point de terminaison Azure OpenAI et votre clé API pour l’exemple d’application :

    dotnet user-secrets init
dotnet user-secrets set AZURE_OPENAI_ENDPOINT <your-Azure-OpenAI-endpoint>
dotnet user-secrets set AZURE_OPENAI_API_KEY <your-Azure-OpenAI-API-key>

Ouvrir l’application dans un éditeur

Ouvrez l’application dans Visual Studio Code (ou l’éditeur de votre choix).

code .

Créer les exemples de données

  1. Copiez le fichier sample.md dans un dossier nommé data dans le répertoire de votre projet.
  2. Configurez le projet pour copier ce fichier dans le répertoire de sortie. Si vous utilisez Visual Studio, cliquez avec le bouton droit sur le fichier dans l’Explorateur de solutions, sélectionnez Propriétés, puis définissez Copier dans le répertoire de sortie sur Copier si plus récent.

Ajouter le code de l’application

Le pipeline d’ingestion de données se compose de plusieurs composants qui fonctionnent ensemble pour traiter les documents :

  • Lecteur de document : lit les fichiers Markdown à partir d’un répertoire.
  • Processeur de documents : enrichit des images avec du texte de remplacement généré par l’IA.
  • Chunker : fractionne les documents en blocs sémantiques à l’aide d’incorporations.
  • Processeur de blocs : génère des résumés d’IA pour chaque bloc.
  • Écrivain de base de données vectorielle : stocke les blocs avec des embeddings dans une base de données SQLite.

  1. Dans le Program.cs fichier, supprimez tout code existant et ajoutez le code suivant pour configurer le lecteur de document :

    // Configure document reader.
IngestionDocumentReader reader = new MarkdownReader();

    La MarkdownReader classe lit les documents Markdown et les convertit dans un format unifié qui fonctionne bien avec les modèles de langage volumineux.

  2. Ajoutez du code pour configurer la journalisation pour le pipeline :

    using ILoggerFactory loggerFactory =
    LoggerFactory.Create(builder => builder.AddSimpleConsole());

  3. Ajoutez du code pour configurer le client IA pour l’enrichissement et la conversation :

    // Configure IChatClient to use Azure OpenAI.
IConfigurationRoot config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

string endpoint = config["AZURE_OPENAI_ENDPOINT"];
string apiKey = config["AZURE_OPENAI_API_KEY"];
string chatModel = "gpt-5";
string embeddingModel = "text-embedding-3-small";

AzureOpenAIClient azureClient = new(
    new Uri(endpoint),
    new AzureKeyCredential(apiKey));

IChatClient chatClient =
    azureClient.GetChatClient(chatModel).AsIChatClient();

  4. Ajoutez du code pour configurer le processeur de documents qui enrichit les images avec des descriptions générées par l’IA :

    // Configure document processor.
EnricherOptions enricherOptions = new(chatClient)
{
    // Enricher failures should not fail the whole ingestion pipeline,
    // as they are best-effort enhancements.
    // This logger factory can create loggers to log such failures.
    LoggerFactory = loggerFactory
};

IngestionDocumentProcessor imageAlternativeTextEnricher =
    new ImageAlternativeTextEnricher(enricherOptions);

    L’utilisation ImageAlternativeTextEnricher de modèles de langage volumineux permet de générer un texte de remplacement descriptif pour les images dans des documents. Ce texte les rend plus accessibles et améliore leur signification sémantique.

  5. Ajoutez du code pour configurer le générateur d’incorporation pour créer des représentations vectorielles :

    // Configure embedding generator.
IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator =
    azureClient.GetEmbeddingClient(embeddingModel).AsIEmbeddingGenerator();

    Les incorporations sont des représentations numériques de la signification sémantique du texte, ce qui permet la recherche de similarité vectorielle.

  6. Ajoutez du code pour configurer le chunker qui fractionne les documents en blocs sémantiques :

    // Configure chunker to split text into semantic chunks.
IngestionChunkerOptions chunkerOptions = new(TiktokenTokenizer.CreateForModel(chatModel))
{
    MaxTokensPerChunk = 2000,
    OverlapTokens = 0
};

IngestionChunker<string> chunker =
    new SemanticSimilarityChunker(embeddingGenerator, chunkerOptions);

    Le SemanticSimilarityChunker divise intelligemment les documents en analysant la similarité sémantique entre les phrases, pour garantir que le contenu associé reste groupé. Ce processus produit des blocs qui préservent la signification et le contexte mieux que des segments basés sur les caractères ou les jetons.

  7. Ajoutez du code pour configurer le processeur de blocs qui génère des résumés :

    // Configure chunk processor to generate summaries for each chunk.
IngestionChunkProcessor<string> summaryEnricher = new SummaryEnricher(enricherOptions);

    Les SummaryEnricher résumés concis sont générés automatiquement pour chaque bloc, ce qui peut améliorer la précision de la récupération en fournissant une vue d’ensemble générale du contenu.

  8. Ajoutez du code pour configurer le magasin de vecteurs SQLite pour le stockage des incorporations :

    // Configure SQLite Vector Store.
using SqliteVectorStore vectorStore = new(
    "Data Source=vectors.db;Pooling=false",
    new()
    {
        EmbeddingGenerator = embeddingGenerator
    });

// The writer requires the embedding dimension count to be specified.
using VectorStoreWriter<string> writer = new(
    vectorStore,
    dimensionCount: 1536,
    new VectorStoreWriterOptions { CollectionName = "data" });

    Le magasin de vecteurs stocke les blocs ainsi que leurs incorporations, ce qui permet des fonctionnalités de recherche sémantique rapide.

  9. Ajoutez du code pour composer tous les composants dans un pipeline complet :

    // Compose data ingestion pipeline
using IngestionPipeline<string> pipeline =
    new(reader, chunker, writer, loggerFactory: loggerFactory)
{
    DocumentProcessors = { imageAlternativeTextEnricher },
    ChunkProcessors = { summaryEnricher }
};

    Le IngestionPipeline<T> combine tous les composants en un flux de travail intégré et cohérent qui traite les documents du début à la fin.

  10. Ajoutez du code pour traiter des documents à partir d’un répertoire :

    await foreach (IngestionResult result in pipeline.ProcessAsync(
    new DirectoryInfo("./data"),
    searchPattern: "*.md"))
{
    Console.WriteLine($"Completed processing '{result.DocumentId}'. " +
        $"Succeeded: '{result.Succeeded}'.");
}

    Le pipeline traite tous les fichiers Markdown dans le ./data répertoire et signale l’état de chaque document.

  11. Ajoutez du code pour activer la recherche interactive des documents traités :

    // Search the vector store collection and display results
VectorStoreCollection<object, Dictionary<string, object?>> collection =
    writer.VectorStoreCollection;

while (true)
{
    Console.Write("Enter your question (or 'exit' to quit): ");
    string? searchValue = Console.ReadLine();
    if (string.IsNullOrEmpty(searchValue) || searchValue == "exit")
    {
        break;
    }

    Console.WriteLine("Searching...\n");
    await foreach (VectorSearchResult<Dictionary<string, object?>> result in
        collection.SearchAsync(searchValue, top: 3))
    {
        Console.WriteLine($"Score: {result.Score}\n\tContent: {result.Record["content"]}");
    }
}

    La fonctionnalité de recherche convertit les requêtes utilisateur en incorporations et recherche les segments les plus sémantiquement similaires dans le magasin vectoriel.

Exécuter l’application

  1. Utilisez la commande dotnet run pour exécuter l’application :

    dotnet run

    L’application traite tous les fichiers Markdown dans le ./data répertoire et affiche l’état de traitement de chaque document. Une fois le traitement terminé, vous pouvez entrer des questions en langage naturel pour rechercher le contenu traité.

  2. Entrez une question à l’invite pour rechercher les données :

    Enter your question (or 'exit' to quit): What is data ingestion?

    L’application retourne les blocs les plus pertinents de vos documents, ainsi que leurs scores de similarité.

  3. Tapez exit pour quitter l’application.

Nettoyer les ressources

Si vous n’en avez plus besoin, supprimez la ressource Azure OpenAI et le déploiement de modèle.

  1. Dans le portail Azure , accédez à la ressource Azure OpenAI.
  2. Sélectionnez la ressource Azure OpenAI, puis sélectionnez Supprimer.

Étapes suivantes

  • Last updated on