Elaborare dati personalizzati per le applicazioni di intelligenza artificiale

In questa guida introduttiva si apprenderà come creare una pipeline di inserimento dati per elaborare e preparare i dati personalizzati per le applicazioni di intelligenza artificiale. L'app utilizza la Microsoft.Extensions.DataIngestion libreria per leggere i documenti, arricchire il contenuto con l'intelligenza artificiale, segmentare il testo semanticamente e archiviare le incorporazioni in un database vettoriale per la ricerca semantica.

L'inserimento dei dati è essenziale per gli scenari di generazione avanzata (RAG) di recupero in cui è necessario elaborare grandi quantità di dati non strutturati e renderli ricercabili per le applicazioni di intelligenza artificiale.

Prerequisiti

Creare l'app

Completare i passaggi seguenti per creare un'app console .NET.

  1. In una directory vuota nel computer usare il comando dotnet new per creare una nuova app console:

    dotnet new console -o ProcessDataAI

  2. Modificare la directory nella cartella dell'app:

    cd ProcessDataAI

  3. Installare i pacchetti necessari:

    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

Creare il servizio di intelligenza artificiale

  1. Per effettuare il provisioning di un servizio e un modello OpenAI di Azure, completare la procedura descritta nell'articolo Creare e distribuire una risorsa del servizio OpenAI di Azure . Per questa guida introduttiva, è necessario effettuare il provisioning di due modelli: gpt-5 e text-embedding-3-small.

  2. Dal terminale o dal prompt dei comandi, vai alla cartella principale della directory del progetto.

  3. Eseguire i comandi seguenti per configurare l'endpoint e la chiave API openAI di Azure per l'app di esempio:

    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>

Aprire l'app in un editor

Aprire l'app in Visual Studio Code (o nell'editor preferito).

code .

Creare i dati di esempio

  1. Copiare il file sample.md in una cartella denominata data nella directory del progetto.
  2. Configurare il progetto per copiare il file nella directory di output. Se si usa Visual Studio, fare clic con il pulsante destro del mouse sul file in Esplora soluzioni, selezionare Proprietà e quindi impostare Copia nella directory di output su Copia se più recente.

Aggiungere il codice dell'app

La pipeline di inserimento dati è costituita da diversi componenti che interagiscono per elaborare i documenti:

  • Lettore di documenti: legge i file Markdown da una directory.
  • Processore di documenti: arricchisce le immagini con testo alternativo generato dall'intelligenza artificiale.
  • Chunker: suddivide i documenti in blocchi semantici usando incorporamenti.
  • Processore blocchi: genera riepiloghi di intelligenza artificiale per ogni blocco.
  • Writer dell'archivio vettoriale: archivia blocchi con incorporamenti in un database SQLite.

  1. Program.cs Nel file eliminare qualsiasi codice esistente e aggiungere il codice seguente per configurare il lettore di documenti:

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

    La MarkdownReader classe legge i documenti Markdown e li converte in un formato unificato che funziona bene con modelli linguistici di grandi dimensioni.

  2. Aggiungere codice per configurare la registrazione per la pipeline:

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

  3. Aggiungere il codice per configurare il client di intelligenza artificiale per l'arricchimento e la chat:

    // 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. Aggiungere codice per configurare il processore di documenti che arricchisce le immagini con descrizioni generate dall'intelligenza artificiale:

    // 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);

    ImageAlternativeTextEnricher usa modelli linguistici di grandi dimensioni per generare testo alternativo descrittivo per le immagini all'interno dei documenti. Questo testo li rende più accessibili e migliora il loro significato semantico.

  5. Aggiungere codice per configurare il generatore di incorporamento per la creazione di rappresentazioni vettoriali:

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

    Gli incorporamenti sono rappresentazioni numeriche del significato semantico del testo, che abilita la ricerca di somiglianza vettoriale.

  6. Aggiungere il codice per configurare la suddivisione dei documenti in blocchi semantici:

    // 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);

    Suddivide SemanticSimilarityChunker in modo intelligente i documenti analizzando la somiglianza semantica tra frasi, assicurandosi che il contenuto correlato rimanga insieme. Questo processo produce blocchi che mantengono il significato e il contesto migliori rispetto al carattere semplice o alla suddivisione in blocchi basata su token.

  7. Aggiungere il codice per configurare il processore di blocchi che genera riepiloghi:

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

    Genera SummaryEnricher automaticamente riepiloghi concisi per ogni blocco, che possono migliorare l'accuratezza del recupero fornendo una panoramica generale del contenuto.

  8. Aggiungere codice per configurare l'archivio vettoriale SQLite per l'archiviazione degli incorporamenti:

    // 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" });

    L'archivio vettoriale archivia blocchi insieme ai relativi incorporamenti, consentendo funzionalità di ricerca semantica rapida.

  9. Aggiungere codice per comporre tutti i componenti in una pipeline completa:

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

    IngestionPipeline<T> combina tutti i componenti in un flusso di lavoro coesivo che elabora i documenti dall'inizio alla fine.

  10. Aggiungere codice per elaborare i documenti da una directory:

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

    La pipeline elabora tutti i file Markdown nella ./data directory e segnala lo stato di ogni documento.

  11. Aggiungere codice per abilitare la ricerca interattiva dei documenti elaborati:

    // 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 funzionalità di ricerca converte le query utente in incorporamenti e trova i blocchi più semanticamente simili nell'archivio vettoriale.

Eseguire l'app

  1. Usare il comando dotnet run per eseguire l'app:

    dotnet run

    L'app elabora tutti i file Markdown nella ./data directory e visualizza lo stato di elaborazione per ogni documento. Una volta completata l'elaborazione, è possibile immettere domande in linguaggio naturale per cercare il contenuto elaborato.

  2. Immettere una domanda al prompt per cercare i dati:

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

    L'app restituisce i blocchi più rilevanti dai documenti insieme ai punteggi di somiglianza.

  3. Digitare exit per chiudere l'applicazione.

Pulire le risorse

Se non sono più necessari, eliminare la risorsa e la distribuzione del modello OpenAI di Azure.

  1. Nel portale di Azure passare alla risorsa OpenAI di Azure.
  2. Selezionare la risorsa OpenAI di Azure e quindi selezionare Elimina.

Passaggi successivi

  • Last updated on