Przetwarzanie danych niestandardowych dla aplikacji sztucznej inteligencji

Z tego przewodnika Szybki start dowiesz się, jak utworzyć potok pozyskiwania danych w celu przetwarzania i przygotowywania niestandardowych danych dla aplikacji sztucznej inteligencji. Aplikacja używa Microsoft.Extensions.DataIngestion biblioteki do odczytywania dokumentów, wzbogacania zawartości za pomocą sztucznej inteligencji, fragmentowania tekstu semantycznie i przechowywania osadzania w bazie danych wektorowej na potrzeby wyszukiwania semantycznego.

Pozyskiwanie danych jest niezbędne w przypadku scenariuszy generowania wspomaganego wyszukiwaniem (RAG), w których należy przetwarzać duże ilości danych bez struktury i uczynić je możliwymi do wyszukiwania przez aplikacje sztucznej inteligencji.

Wymagania wstępne

Zestaw .NET 8.0 SDK lub nowszy — Zainstaluj zestaw .NET 8 SDK.
Subskrypcja Azure — Utwórz ją bezpłatnie.
Interfejs wiersza polecenia dla deweloperów Azure (opcjonalnie) — Zainstaluj lub zaktualizuj interfejs wiersza polecenia dla deweloperów Azure.

Tworzenie aplikacji

Wykonaj poniższe kroki, aby utworzyć aplikację konsolową platformy .NET.

W pustym katalogu na komputerze użyj polecenia dotnet new, aby utworzyć nową aplikację konsolową:
```
dotnet new console -o ProcessDataAI
```
Zmień katalog na folder aplikacji:
```
cd ProcessDataAI
```

Zainstaluj wymagane pakiety:

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

Tworzenie usługi sztucznej inteligencji

Aby aprowizować usługę Azure OpenAI i model, wykonaj kroki opisane w artykule Tworzenie i wdrażanie zasobu usługi Azure OpenAI Service . W tym przewodniku szybkiego startu musisz udostępnić dwa modele: gpt-5 i text-embedding-3-small.
W terminalu lub wierszu polecenia przejdź do głównego katalogu projektu.

Uruchom następujące polecenia, aby skonfigurować punkt końcowy i klucz interfejsu API usługi Azure OpenAI dla przykładowej aplikacji:

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>

Otwieranie aplikacji w edytorze

Otwórz aplikację w programie Visual Studio Code (lub edytorze).

code .

Tworzenie przykładowych danych

Skopiuj plik sample.md do folderu o nazwie data w katalogu projektu.
Skonfiguruj projekt, aby skopiować ten plik do katalogu wyjściowego. Jeśli używasz programu Visual Studio, kliknij prawym przyciskiem myszy plik w Eksploratorze rozwiązań, wybierz pozycję Właściwości, a następnie ustaw Kopiuj do katalogu wyjściowego na Kopiuj, jeśli nowszy.

Dodawanie kodu aplikacji

Potok pozyskiwania danych składa się z kilku składników, które współpracują ze sobą w celu przetwarzania dokumentów:

Czytnik dokumentów: odczytuje pliki Markdown z katalogu.
Procesor dokumentów: wzbogaca obrazy przy użyciu tekstu alternatywnego generowanego przez sztuczną inteligencję.
Fragmenter: dzieli dokumenty na fragmenty semantyczne przy użyciu osadzania.
Procesor fragmentów: generuje podsumowania sztucznej inteligencji dla każdego fragmentu.
Moduł zapisu magazynu wektorowego: przechowuje fragmenty z osadzeniami w bazie danych SQLite.

Program.cs W pliku usuń dowolny istniejący kod i dodaj następujący kod, aby skonfigurować czytnik dokumentów:
```
// Configure document reader.
IngestionDocumentReader reader = new MarkdownReader();
```
Klasa MarkdownReader odczytuje dokumenty markdown i konwertuje je na ujednolicony format, który dobrze współdziała z dużymi modelami językowymi.

Dodaj kod, aby skonfigurować rejestrowanie dla potoku:

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

Dodaj kod, aby skonfigurować klienta sztucznej inteligencji na potrzeby wzbogacania i czatu:

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

Dodaj kod, aby skonfigurować procesor dokumentów, który wzbogaca obrazy za pomocą opisów generowanych przez sztuczną inteligencję:

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

Model ImageAlternativeTextEnricher używa dużych modeli językowych do generowania opisowego tekstu alternatywnego dla obrazów w dokumentach. Ten tekst sprawia, że są one bardziej dostępne i poprawia ich semantyczne znaczenie.

Dodaj kod, aby skonfigurować generator osadzania na potrzeby tworzenia reprezentacji wektorów:
```
// Configure embedding generator.
IEmbeddingGenerator<string, Embedding<float>> embeddingGenerator =
    azureClient.GetEmbeddingClient(embeddingModel).AsIEmbeddingGenerator();
```
Osadzanie to liczbowe reprezentacje semantycznego znaczenia tekstu, co umożliwia wyszukiwanie podobieństwa wektorów.
Dodaj kod, aby skonfigurować fragmenter dzielący dokumenty na fragmenty semantyczne:
```
// 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);
```
Inteligentnie SemanticSimilarityChunker dzieli dokumenty, analizując semantyczne podobieństwo między zdaniami, zapewniając, że powiązana zawartość zostaje razem. Ten proces tworzy fragmenty, które zachowują znaczenie i kontekst lepiej niż prosty znak lub fragment oparty na tokenach.
Dodaj kod, aby skonfigurować procesor fragmentów, który generuje podsumowania:
```
// Configure chunk processor to generate summaries for each chunk.
IngestionChunkProcessor<string> summaryEnricher = new SummaryEnricher(enricherOptions);
```
Narzędzie SummaryEnricher automatycznie generuje zwięzłe podsumowania dla każdego fragmentu, co może poprawić dokładność pobierania, zapewniając ogólny przegląd zawartości.

Dodaj kod, aby skonfigurować magazyn wektorów SQLite na potrzeby przechowywania osadzania:

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

Magazyn wektorów przechowuje fragmenty wraz z ich osadzaniem, umożliwiając szybkie funkcje wyszukiwania semantycznego.

Dodaj kod, aby utworzyć wszystkie składniki do kompletnego potoku:

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

Element IngestionPipeline<T> łączy wszystkie składniki w spójny przepływ pracy, który przetwarza dokumenty od początku do końca.

Dodaj kod do przetwarzania dokumentów z katalogu:

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

Potok przetwarza wszystkie pliki Markdown i raportuje stan każdego dokumentu w katalogu ./data.

Dodaj kod umożliwiający interaktywne wyszukiwanie przetworzonych dokumentów:

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

Funkcja wyszukiwania konwertuje zapytania użytkowników na osadzanie i znajduje najbardziej semantycznie podobne fragmenty w magazynie wektorów.

Uruchom aplikację

Uruchom aplikację za pomocą polecenia dotnet run:
```
dotnet run
```
Aplikacja przetwarza wszystkie pliki markdown w ./data katalogu i wyświetla stan przetwarzania dla każdego dokumentu. Po zakończeniu przetwarzania możesz wprowadzić pytania dotyczące języka naturalnego, aby wyszukać przetworzoną zawartość.
Wprowadź pytanie w wierszu polecenia, aby wyszukać dane:
```
Enter your question (or 'exit' to quit): What is data ingestion?
```
Aplikacja zwraca najbardziej istotne fragmenty z dokumentów wraz z wynikami podobieństwa.
Wpisz , exit aby zamknąć aplikację.

Uprzątnij zasoby

Jeśli nie potrzebujesz ich już, usuń zasób Azure OpenAI i wdrożenie modelu.

W witrynie Azure Portalprzejdź do zasobu Azure OpenAI.
Wybierz zasób Azure OpenAI, a następnie wybierz pozycję Usuń.

Następne kroki

Opinia

Czy ta strona była pomocna?

Last updated on 2026-03-11