Zdefiniuj projekcję indeksu dla indeksowania nadrzędno-podrzędnego

Jeśli fragmentujesz zawartość dla wzorca RAG lub wektoryzacji, możesz określić projekcję indeksu, aby kontrolować indeksowanie jeden do wielu, gdzie zawartość źródłowa (jedna) jest przewidywana do jednego lub więcej indeksów (wiele). Intencją projekcji indeksu jest kontrolowanie, czy elementy dokumentu nadrzędnego, takie jak nazwa pliku lub data utworzenia:

• Powtórz dla każdego dziecka (fragmentu) w obrębie pojedynczego indeksu
• Są indeksowane jako autonomiczne dokumenty wyszukiwania w tym samym indeksie
• Lub są pozyskiwane do oddzielnych indeksów

Zalecamy powtarzanie pól nadrzędnych w jednym indeksie, ponieważ różne kształty dokumentu lub dzielenie zawartości na dwa indeksy mogą być trudne do wykonywania zapytań, szczególnie w przypadku wyszukiwania klasycznego, w którym sprzężenia indeksu nie są obsługiwane.

W Wyszukiwanie AI platformy Azure fragmentacja jest realizowana za pomocą umiejętności i w związku z tym zależy od indeksatorów. Aby zdefiniować projekcję indeksu, określ ją w zestawie umiejętności.

Wymagania wstępne

• Wyszukiwanie AI platformy Azure, dowolną warstwę lub region.

• Potok indeksowania oparty na indeksatorze.

• Obsługiwane źródło danych zawierające zawartość, którą chcesz fragmentować.

• Indeks (jeden lub wiele), który przyjmuje dane wyjściowe potoku indeksatora.

• Umiejętność, która fragmentuje zawartość, taką jak umiejętność dzielenia tekstu.

Zestaw umiejętności zawiera projekcję indeksatora, która kształtuje dane dla indeksowania jeden do wielu. Zestaw umiejętności może również mieć inne umiejętności, takie jak umiejętność osadzania, taka jak AzureOpenAIEmbedding , jeśli twój scenariusz obejmuje wektoryzację zintegrowaną.

Wybieranie podejścia

Projekcje indeksu generują dokumenty podrzędne (fragmenty) dla każdego dokumentu nadrzędnego. Wybierz sposób obsługi zawartości nadrzędnej:

W przypadku większości scenariuszy RAG należy użyć pierwszego podejścia. Zobacz przykład klasycznego RAG.

Kroki implementacji zalecanego podejścia

1. Utwórz indeks przeznaczony dla fragmentów z dołączonymi polami nadrzędnymi.
2. Utwórz zestaw umiejętności z umiejętnością fragmentowania i indexProjections.
3. Utwórz indeksator wskazujący obsługiwane źródło danych.

Jeśli źródło danych obsługuje śledzenie zmian, indeksator automatycznie synchronizuje zmiany.

Tworzenie indeksu dla indeksowania jeden do wielu

Niezależnie od tego, czy tworzysz jeden indeks dla fragmentów, które powtarzają wartości pól nadrzędnych, czy oddzielne indeksy umiejscowienia pól nadrzędnych i podrzędnych, indeks podstawowy używany do wyszukiwania jest opracowany z myślą o fragmentach danych. Schemat indeksu musi zawierać następujące pola:

• Pole klucza dokumentu unikatowo identyfikujące każdy dokument. Należy go zdefiniować jako typ Edm.String z analizatorem keyword .

• Pole kojarzące każdy fragment z elementem nadrzędnym. Musi być typu Edm.String. Nie może to być pole klucza dokumentu i musi mieć filterable ustawioną wartość true. Jest on określany jako parent_id w przykładach i jako projekcyjny klucz wartości w tym artykule.

• Inne pola zawartości, takie jak pola tekstowe lub wektoryzowane fragmenty.

Indeks musi istnieć w usłudze wyszukiwania przed utworzeniem zestawu umiejętności lub uruchomieniem indeksatora. Zdefiniowane selectors w zestawie umiejętności powinny zawierać te pola.

Schemat pojedynczego indeksu obejmujący pola nadrzędne i podrzędne

Pojedynczy indeks, oparty na fragmentach, gdzie zawartość nadrzędna powtarza się dla każdego fragmentu, jest przeważającym wzorcem dla scenariuszy wyszukiwania RAG i wektora. Możliwość skojarzenia właściwej zawartości nadrzędnej z każdym fragmentem można osiągnąć dzięki projekcjom indeksu.

Poniższy schemat jest przykładem spełniającym wymagania projekcji indeksu. W tym przykładzie:

• Polami nadrzędnymi są parent_id i tytuł i powtarzają się dla każdego fragmentu.
• Pola podrzędne są fragmentami wektorów i wektorów niewektorowych. Chunk_id jest identyfikatorem dokumentu tego indeksu.

Możesz użyć portalu Azure, interfejsów API REST lub Azure SDK, aby utworzyć indeks.

{
    "name": "my_consolidated_index",
    "fields": [
        {"name": "chunk_id", "type": "Edm.String", "key": true, "filterable": true, "analyzer": "keyword"},
        {"name": "parent_id", "type": "Edm.String", "filterable": true},
        {"name": "title", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true, "retrievable": true},
        {"name": "chunk", "type": "Edm.String","searchable": true,"retrievable": true},
        {"name": "chunk_vector", "type": "Collection(Edm.Single)", "searchable": true, "retrievable": false, "stored": false, "dimensions": 1536, "vectorSearchProfile": "hnsw"}
    ],
    "vectorSearch": {
        "algorithms": [{"name": "hnsw", "kind": "hnsw", "hnswParameters": {}}],
        "profiles": [{"name": "hnsw", "algorithm": "hnsw"}]
    }
}

 # Create a search index  
 index_name = "my_consolidated_index"
 index_client = SearchIndexClient(endpoint=AZURE_SEARCH_SERVICE, credential=credential)  
 fields = [
     SearchField(name="document_id", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True, analyzer_name="keyword"),  
     SearchField(name="parent_id", type=SearchFieldDataType.String, filterable=True),  
     SearchField(name="title", type=SearchFieldDataType.String, searchable=True, sortable=False, filterable=True, facetable=False, retrievable=True), 
     SearchField(name="chunk", type=SearchFieldDataType.String, sortable=False, filterable=False, facetable=False, retrievable=True),  
     SearchField(name="chunk_vector", type=SearchFieldDataType.Collection(SearchFieldDataType.Single, searchable=True, retrievable=False), vector_search_dimensions=1024, vector_search_profile_name="myHnswProfile")
     ]  

 # Configure the vector search configuration  
 vector_search = VectorSearch(  
     algorithms=[  
         HnswAlgorithmConfiguration(name="myHnsw"),
     ],  
     profiles=[  
         VectorSearchProfile(  
             name="myHnswProfile",  
             algorithm_configuration_name="myHnsw",  
             vectorizer_name="myOpenAI",  
         )
     ],  
     vectorizers=[  
         AzureOpenAIVectorizer(  
             vectorizer_name="myOpenAI",  
             kind="azureOpenAI",  
             parameters=AzureOpenAIVectorizerParameters(  
                 resource_url=AZURE_OPENAI_ACCOUNT,  
                 deployment_name="text-embedding-3-large",
                 model_name="text-embedding-3-large"
             ),
         ),  
     ], 
 )  

 # Create the search index
 index = SearchIndex(name=index_name, fields=fields, vector_search=vector_search)  
 result = index_client.create_or_update_index(index)  
 print(f"{result.name} created")  

Dodawanie projekcji indeksu do zestawu umiejętności

Projekcje indeksów są definiowane w ramach definicji zestawu umiejętności i są głównie zdefiniowane jako tablica selectors, gdzie każdy selektor odpowiada innemu indeksowi docelowemu w usłudze wyszukiwania. Ta sekcja rozpoczyna się od składni i przykładów kontekstu, a następnie odwołania do parametrów.

"indexProjections": {
    "selectors": [
        {
            "targetIndexName": "my_consolidated_index",
            "parentKeyFieldName": "parent_id",
            "sourceContext": "/document/pages/*",
            "mappings": [
                {
                    "name": "chunk",
                    "source": "/document/pages/*",
                    "sourceContext": null,
                    "inputs": []
                },
                {
                    "name": "chunk_vector",
                    "source": "/document/pages/*/chunk_vector",
                    "sourceContext": null,
                    "inputs": []
                },
                {
                    "name": "title",
                    "source": "/document/title",
                    "sourceContext": null,
                    "inputs": []
                }
            ]
        }
    ],
    "parameters": {
        "projectionMode": "skipIndexingParentDocuments"
    }
}

index_projections = SearchIndexerIndexProjection(  
    selectors=[  
        SearchIndexerIndexProjectionSelector(  
            target_index_name=index_name,  
            parent_key_field_name="parent_id",  
            source_context="/document/pages/*",  
            mappings=[  
                InputFieldMappingEntry(name="chunk", source="/document/pages/*"),  
                InputFieldMappingEntry(name="chunk_vector", source="/document/pages/*/chunk_vector"),
                InputFieldMappingEntry(name="title", source="/document/title")
            ],  
        ),  
    ],  
    parameters=SearchIndexerIndexProjectionsParameters(  
        projection_mode=IndexProjectionMode.SKIP_INDEXING_PARENT_DOCUMENTS  
    ),  
) 

Referencja parametrów

Parametry mają następujące elementy w ramach ich definicji.

Selektory mają następujące elementy w ramach ich definicji.

Parametr mappings jest ważny. Należy jawnie mapować każde pole w indeksie podrzędnym, z wyjątkiem pól identyfikatora, takich jak klucz dokumentu i identyfikator nadrzędny.

To wymaganie jest w przeciwieństwie do innych konwencji mapowania pól w Wyszukiwanie AI platformy Azure. W przypadku niektórych typów źródeł danych indeksator może niejawnie mapować pola na podstawie podobnych nazw lub znanych cech (na przykład indeksatory obiektów blob używają unikatowej ścieżki magazynu metadanych jako domyślnego klucza dokumentu). Jednak w przypadku projekcji indeksatora po stronie "wiele" relacji należy wyraźnie określić każde mapowanie pól.

Przeglądanie mapowań pól

Indeksatory są powiązane z trzema różnymi typami mapowań pól. Przed uruchomieniem indeksatora sprawdź mapowania pól i dowiedz się, kiedy należy używać każdego typu.

Mapowania pól są definiowane w indeksatorze i używane do mapowania pola źródłowego na pole indeksu. Mapowania pól są używane do ścieżek danych, które przenoszą dane ze źródła i przekazują je do indeksowania bez pośredniego etapu przetwarzania danych. Zazwyczaj indeksator może automatycznie mapować pola o tej samej nazwie i typie. Jawne mapowania pól są wymagane tylko wtedy, gdy występują rozbieżności. W indeksowaniu "jeden do wielu" i omówionych do tej pory wzorcach może nie być konieczne mapowanie pól.

Mapowania pól wyjściowych, które są zdefiniowane w indeksatorze, są używane do odwzorowywania wzbogaconej treści wygenerowanej przez zestaw umiejętności do pola w głównym indeksie. Fragmenty są uznawane za wzbogaconą zawartość dzięki tworzeniu przez umiejętności (Podział Tekstu), ale nie potrzebujesz mapowania pól wyjściowych dla fragmentów ani projekcji indeksu zdefiniowanych przez mapowanie selektora.

Selectors.mappings są definiowane w zestawie funkcji i przypisywane do pól w indeksie podrzędnym. W przypadkach, gdy indeks podrzędny zawiera również pola nadrzędne (podobnie jak w rozwiązaniu skonsolidowanego indeksu), należy skonfigurować mapowania pól dla każdego pola zawierającego zawartość, w tym pola tytułu na poziomie nadrzędnym, przy założeniu, że tytuł ma być wyświetlany w każdym fragmentowanym dokumencie. Jeśli używasz oddzielnych indeksów nadrzędnych i podrzędnych, selektor powinien mieć mapowania pól tylko dla pól na poziomie podrzędnym.

Uruchamianie indeksatora

Po utworzeniu źródła danych, indeksów i zestawu umiejętności możesz utworzyć i uruchomić indeksator. Ten krok uruchamia pipeline do wykonania.

Możesz wykonać zapytanie względem indeksu wyszukiwania po zakończeniu przetwarzania w celu przetestowania rozwiązania.

Cykl życia zawartości

W zależności od bazowego źródła danych indeksator zwykle zapewnia ciągłe śledzenie zmian i wykrywanie usuwania. W tej sekcji wyjaśniono cykl życia treści dla indeksowania jeden-do-wielu w kontekście odświeżania danych.

W przypadku źródeł danych, które zapewniają śledzenie zmian i wykrywanie usuwania, proces indeksatora może pobierać zmiany w danych źródłowych. Za każdym razem, gdy uruchamiasz indeksator i zestaw umiejętności, projekcje indeksu są aktualizowane, jeśli zestaw umiejętności lub bazowe dane źródłowe uległy zmianie. Wszelkie zmiany pobierane przez indeksator są propagowane przez proces wzbogacania do projekcji w indeksie, zapewniając, że przewidywane dane są bieżącą reprezentacją zawartości w źródle danych źródłowych. Działanie odświeżania danych jest rejestrowane w prognozowanej wartości klucza dla każdego fragmentu. Ta wartość jest aktualizowana po zmianie danych bazowych.

Zaktualizowana zawartość

Jeśli dodasz nową zawartość do źródła danych, nowe fragmenty lub dokumenty podrzędne zostaną dodane do indeksu podczas następnego uruchomienia indeksatora.

Jeśli zmodyfikujesz istniejącą zawartość w źródle danych, fragmenty są aktualizowane przyrostowo w indeksie wyszukiwania, jeśli używane źródło danych obsługuje wykrywanie śledzenia zmian i usuwania. Jeśli na przykład wyraz lub zdanie zmieni się w dokumencie, fragment w indeksie docelowym zawierającym ten wyraz lub zdanie zostanie zaktualizowany podczas następnego uruchomienia indeksatora. Inne typy aktualizacji, takie jak zmiana typu pola i niektóre przypisania, nie są obsługiwane dla istniejących pól. Aby uzyskać więcej informacji na temat dozwolonych aktualizacji, zobacz Aktualizowanie schematu indeksu.

Niektóre źródła danych, takie jak Azure Storage obsługują domyślnie śledzenie zmian i usuwania na podstawie znacznika czasu. Inne źródła danych, takie jak Microsoft OneLake, Azure SQL lub Azure Cosmos DB muszą być skonfigurowane do śledzenia zmian.

Usunięta zawartość

Jeśli zawartość źródłowa już nie istnieje (na przykład jeśli tekst zostanie skrócony, aby mieć mniej fragmentów), odpowiedni dokument podrzędny w indeksie wyszukiwania zostanie usunięty. Pozostałe dokumenty podrzędne również otrzymują aktualizację klucza w celu uwzględnienia nowej wartości skrótu, nawet jeśli ich zawartość nie zmieniła się w inny sposób.

Jeśli dokument nadrzędny zostanie całkowicie usunięty ze źródła danych, odpowiednie dokumenty podrzędne zostaną usunięte tylko wtedy, gdy usunięcie zostanie wykryte przez definicję dataDeletionDetectionPolicy źródła danych. Jeśli nie masz skonfigurowanego dokumentu nadrzędnego dataDeletionDetectionPolicy i musisz usunąć go ze źródła danych, należy ręcznie usunąć dokumenty podrzędne , jeśli nie są już potrzebne.

Prognozowana wartość klucza

Aby zapewnić integralność danych dla zaktualizowanej i usuniętej zawartości, odświeżanie danych w indeksowaniu "jeden do wielu" opiera się na przewidywanej wartości klucza po stronie "wiele". Jeśli używasz zintegrowanej wektoryzacji lub kreatora importu danych, prognozowana wartość klucza jest parent_id polem po stronie fragmentowanej lub "wiele" indeksu.

Przewidywana wartość klucza jest unikatowym identyfikatorem generowanym przez indeksator dla każdego dokumentu. Zapewnia unikatowość i umożliwia prawidłowe działanie śledzenia zmian i usuwania. Ten klucz zawiera następujące segmenty:

• Losowy skrót gwarantujący unikatowość. Ten skrót zmienia się, jeśli dokument nadrzędny jest aktualizowany w kolejnych uruchomieniach indeksatora.
• Klucz dokumentu nadrzędnego.
• Ścieżka adnotacji wzbogacania identyfikująca kontekst wygenerowanego dokumentu.

Jeśli na przykład podzielisz dokument nadrzędny z wartością klucza "aa1b22c33" na cztery strony, a następnie każda z tych stron będzie projektowana jako osobny dokument za pomocą projekcji indeksowych:

• aa1b22c33
• aa1b22c33_pages_0
• aa1b22c33_pages_1
• aa1b22c33_pages_2

Jeśli dokument nadrzędny jest aktualizowany w danych źródłowych, na przykład w wyniku większej liczby fragmentowanych stron, losowy skrót zmienia się, dodawane są kolejne strony, a zawartość każdego fragmentu jest aktualizowana tak, aby pasowała do tego, co znajduje się w dokumencie źródłowym.

Przykład oddzielnych indeksów nadrzędnych i podrzędnych

W tej sekcji przedstawiono przykład oddzielnych indeksów nadrzędnych i podrzędnych. Jest to nietypowy wzorzec, ale możliwe, że mogą istnieć wymagania aplikacji, które najlepiej spełniają przy użyciu tego podejścia. W tym scenariuszu projektujesz zawartość relacyjną między rodzicem a dzieckiem na dwa oddzielne indeksy.

1. Utwórz dwa schematy indeksu.

   Każdy schemat zawiera pola dla swojego poziomu szczegółowości, z polem identyfikatora nadrzędnego wspólnym dla obu indeksów do użycia w zapycie wyszukiwania. Podstawowym korpusem wyszukiwania jest indeks podrzędny, jednak można wydać zapytanie wyszukiwawcze, aby pobrać pola nadrzędne dla każdego dopasowania w rezultacie. Wyszukiwanie AI platformy Azure nie obsługuje sprzężeń w czasie wykonywania zapytań, więc kod aplikacji lub warstwa aranżacji musi scalić lub sortować wyniki, które mogą być przekazywane do aplikacji lub procesu.

   Indeks nadrzędny ma pole parent_id i tytuł. Parent_id jest kluczem dokumentu. Nie potrzebujesz konfiguracji wyszukiwania wektorowego, chyba że chcesz wektorować pola na poziomie dokumentu nadrzędnego.

   {
       "name": "my-parent-index",
       "fields": [
   
           {"name": "parent_id", "type": "Edm.String", "key":true, "filterable": true},
           {"name": "title", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true, "retrievable": true}
       ]
   }
   

   Indeks podrzędny zawiera pola fragmentowane oraz pole parent_id. Jeśli używasz zintegrowanej wektoryzacji, profilów scoringu, rankera semantycznego lub analizatorów, powinieneś ustawić je w indeksie podrzędnym.

   {
       "name": "my-child-index",
       "fields": [
           {"name": "chunk_id", "type": "Edm.String", "key": true, "filterable": true, "analyzer": "keyword"},
           {"name": "parent_id", "type": "Edm.String", "filterable": true},
            {"name": "chunk", "type": "Edm.String","searchable": true,"retrievable": true},
           {"name": "chunk_vector", "type": "Collection(Edm.Single)", "searchable": true, "retrievable": false, "stored": false, "dimensions": 1536, "vectorSearchProfile": "hnsw"}
       ],
       "vectorSearch": {
           "algorithms": [{"name": "hsnw", "kind": "hnsw", "hnswParameters": {}}],
           "profiles": [{"name": "hsnw", "algorithm": "hnsw"}]
       },
       "scoringProfiles": [],
       "semanticConfiguration": [],
       "analyzers": []
   }
   

2. Zaktualizuj indeksator, aby określić indeks nadrzędny jako docelowy.

   Definicja indeksatora określa składniki zestawu. W definicji indeksatora nazwa indeksu, która ma być podana, jest indeksem nadrzędnym. Jeśli potrzebujesz mapowań dla pól na poziomie nadrzędnym, zdefiniuj je w sekcji outputFieldMappings. W przypadku indeksowania "jeden do wielu", które używa oddzielnych indeksów, definicja indeksatora może wyglądać podobnie do poniższego przykładu.

   {
     "name": "my-indexer",
     "dataSourceName": "my-ds",
     "targetIndexName": "my-parent-index",
     "skillsetName" : "my-skillset",
     "parameters": { },
     "fieldMappings": (optional) Maps fields in the underlying data source to fields in an index,
     "outputFieldMappings" : (required) Maps skill outputs to fields in an index,
   }
   

3. Dodaj indexProjections do zestawu umiejętności.

   Oto przykład definicji projekcji indeksu, która określa ścieżkę danych, która indeksator powinien używać do indeksowania zawartości. Określa nazwę indeksu podrzędnego w definicji projekcji indeksu. Specyfikuje również mapowania każdego pola podrzędnego lub na poziomie fragmentu. Jest to jedyne miejsce, w którym określono nazwę indeksu dziecięcego.

   Zwróć uwagę, że parameters parametr ma wartość null i używa wartości domyślnej includeIndexingParentDocuments. Indeksator wypełnia indeks nadrzędny. Tablica selectors służy do projekcji dokumentów fragmentów do indeksu podrzędnego.

   "indexProjections": {
       "selectors": [
           {
               "targetIndexName": "my-child-index",
               "parentKeyFieldName": "parent_id",
               "sourceContext": "/document/pages/*",
               "mappings": [
                   {
                       "name": "chunk",
                       "source": "/document/pages/*",
                       "sourceContext": null,
                       "inputs": []
                   },
                   {
                       "name": "chunk_vector",
                       "source": "/document/pages/*/chunk_vector",
                       "sourceContext": null,
                       "inputs": []
                   }
               ]
           }
       ],
       "parameters": {}
   }
   

4. Uruchom indeksator. Jeśli wcześniej uruchomiono indeksator, pamiętaj, aby najpierw go zresetować.

   Powinny istnieć dwa indeksy wypełnione odpowiednią zawartością. Wykonaj zapytanie dotyczące indeksów w Eksploratorze wyszukiwania, aby sprawdzić, czy każda z nich ma poprawną zawartość.

Następny krok

Fragmentowanie danych i indeksowanie jeden-do-wielu są częścią klasycznego wzorca RAG w Wyszukiwanie AI platformy Azure. Przejdź do poniższego samouczka i przykładowego kodu, aby dowiedzieć się więcej na ten temat.