Index-előrejelzés definiálása szülő-gyermek indexeléshez

Ha tartalmat darabol ragmintához vagy vektorizáláshoz, megadhat egy indexprojekciót az egy-a-többekhez indexelés irányítására, ahol a forrástartalom (egy) egy vagy több indexre (többre) van kivetítve. Az indexvetítés célja arra irányul, hogy szabályozza a szülődokumentum elemeként szereplő elemeket, például a fájlnevet vagy a létrehozás dátumát.

• Ismételje meg minden gyermek (chunk) esetén egyetlen indexben
• Önálló keresési dokumentumként van indexelve ugyanabban az indexben
• Vagy külön indexekbe töltődnek be

Javasoljuk, hogy egyetlen indexben ismételje meg a szülőmezőket, mert a különböző dokumentumalakzatok vagy a tartalom két indexre való felosztása nehéz lehet, különösen olyan klasszikus keresésekben, ahol az indexek összekapcsolása nem támogatott.

Az Azure AI Keresés-ben a tömbösítést képességek hajtják végre, és ezért függ az indexelőktől. Index-előrejelzés definiálásához adja meg egy készségkészletben.

Előfeltételek

• Azure AI Keresés, bármilyen szinten vagy régióban.

• Indexelőalapú indexelési folyamat.

• Olyan támogatott adatforrás , amely tartalmaz egy adattömbbe beszúrni kívánt tartalmat.

• Az indexelő folyamat kimenetét elfogadó index (egy vagy több).

• Olyan képesség, amely feloszt tartalmat, például a Szövegfelosztási készség.

A képességhalmaz tartalmazza az indexelő vetületét, amely az adatokat egy-többhöz adatindexelés céljából formálja. A készségkészletek más készségekkel is rendelkezhetnek, például beágyazási képességekkel, például az AzureOpenAIEmbedding szolgáltatással , ha a forgatókönyv integrált vektorizálást is tartalmaz.

Megközelítés kiválasztása

Az index projekciók "gyermek" dokumentumokat (tömböket) hoznak létre a "szülő" dokumentumokhoz. A szülőtartalom kezelésének kiválasztása:

A legtöbb RAG-forgatókönyv esetében használja az első megközelítést. Lásd a klasszikus RAG példát.

Az ajánlott megközelítés implementálási lépései

1. Hozzon létre egy adattömbökhöz tervezett indexet , amely tartalmazza a szülőmezőket.
2. Hozzon létre egy készségkészletet egy adattömb-készítési képességgel és indexProjections.
3. Hozzon létre egy indexelőt , amely a támogatott adatforrásra mutat.

Ha az adatforrás támogatja a változáskövetést, az indexelő automatikusan szinkronizálja a módosításokat.

Egy-több közötti indexeléshez index létrehozása

Akár a szülőértékeket ismétlő adattömbökhöz hoz létre egy indexet, akár külön indexeket a szülő-gyermek mező elhelyezéséhez, a kereséshez használt elsődleges index adattömbök köré van tervezve. Az indexsémának a következő mezőkkel kell rendelkeznie:

• Egy dokumentumkulcsmező, amely egyedileg azonosítja az egyes dokumentumokat. Típusként Edm.String kell definiálni az keyword elemzővel.

• Az egyes darabokat a szülőjükkel társító mező. Típusnak Edm.Stringkell lennie. Nem lehet a dokumentumkulcs mezője, és igaz értékre kell filterable állítania. A példákban parent_id néven hivatkozunk rá, és a jelen cikkben előrevetített kulcsértékként említjük.

• Egyéb tartalommezők, például szöveg- vagy vektorizált adattömbmezők.

A képességkészlet létrehozása vagy az indexelő futtatása előtt indexnek kell léteznie a keresési szolgáltatásban. A selectors készségkészletben definiált mezőknek tartalmazniuk kell ezeket a mezőket.

Szülő- és gyermekmezőket tartalmazó egyetlen indexséma

A RAG- és vektorkeresési forgatókönyvek elsődleges mintája az egyes adattömbökhöz ismétlődő szülőtartalommal rendelkező adattömbök köré tervezett egyetlen index. A megfelelő szülőtartalom és az egyes adattömbök társításának lehetősége indexprojekciókon keresztül engedélyezve van.

Az alábbi séma egy példa, amely megfelel az index-előrejelzések követelményeinek. Ebben a példában:

• A szülőmezők a parent_id és a cím, és minden egyes adattömbhöz ismétlődnek
• A gyermekmezők a vektorok és a nem vektoros adattömbök. A chunk_id az index dokumentumazonosítója.

A Azure portál, REST API-k vagy Azure SDK segítségével indexet hozhat létre.

{
    "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")  

Index-előrejelzések hozzáadása egy készségkészlethez

Az index-előrejelzések egy képességkészlet-definícióban vannak definiálva, és elsősorban tömbként selectorsvannak definiálva, ahol minden választó egy másik célindexnek felel meg a keresési szolgáltatásban. Ez a szakasz a környezet szintaxisával és példáival kezdődik, majd paraméterhivatkozással.

"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  
    ),  
) 

Paraméterhivatkozás

A paraméterek definíciójuk részeként a következő elemekkel rendelkeznek.

A választók definíciójuk részeként a következő elemekkel rendelkeznek.

A mappings paraméter fontos. Minden mezőt a gyermekindexben explicit módon kell feltérképezni, kivéve az ID mezőket, mint például a dokumentumkulcsot és a szülőazonosítót.

Ez a követelmény ellentétben áll a Azure AI Keresés más mezőleképezési konvencióival. Egyes adatforrástípusok esetében az indexelő implicit módon megfeleltethet mezőket hasonló nevek vagy ismert jellemzők alapján (például a blobindexelők alapértelmezett dokumentumkulcsként az egyedi metaadat-tárolási útvonalat használják). Az indexelővetítések esetében azonban explicit módon meg kell adnia a kapcsolat "több" oldalán lévő összes mezőleképezést.

Mezőleképezések áttekintése

Az indexelők három különböző típusú mezőleképezéssel vannak társítva. Az indexelő futtatása előtt ellenőrizze a mezőleképezéseket, és tudja, mikor érdemes használni az egyes típusokat.

A mezőleképezések egy indexelőben vannak definiálva, és egy forrásmező indexmezőhöz való leképezésére szolgálnak. A mezőleképezések olyan adatútvonalakhoz használhatók, amelyek adatokat emelnek ki a forrásból, és indexelés céljából adják át azokat, köztes képességfeldolgozási lépés nélkül. Az indexelők általában automatikusan leképezhetik az azonos nevű és típusú mezőket. Explicit mezőleképezésekre csak akkor van szükség, ha eltérések vannak. Az egy-a-többhöz indexelés és az eddig tárgyalt minták esetén előfordulhat, hogy nincs szükség mezőtérképezésekre.

A kimeneti mezőleképezések egy indexelőben vannak definiálva, és a képességkészlet által létrehozott gazdagított tartalomnak a fő indexbe való leképezésére szolgálnak. Az adattömbök gazdagított tartalomnak minősülnek egy képesség (Szöveg felosztása) létrehozása miatt, de nincs szükség kimeneti mezőleképezésre az adattömbökhöz vagy a választóleképezés által definiált index-leképezésekhez.

Selectors.mappings egy készségkészletben van definiálva, és a gyermekindex mezőire van kivetítve. Azokban az esetekben, amikor a gyermekindex szülőmezőket is tartalmaz (az összevont indexmegoldáshoz hasonlóan), minden tartalommal rendelkező mezőhöz be kell állítania a mezőleképezéseket, beleértve a szülőszintű címmezőt is, feltéve, hogy azt szeretné, hogy a cím megjelenjen az egyes darabolt dokumentumokban. Ha külön szülő- és gyermekindexeket használ, a választónak csak a gyermekszintű mezők mezőleképezésével kell rendelkeznie.

Az indexelő futtatása

Miután létrehozott egy adatforrást, indexet és képességkészletet, készen áll az indexelő létrehozására és futtatására. Ez a lépés végrehajtja a folyamatot.

A keresési index lekérdezhető, miután a feldolgozás befejeződött a megoldás teszteléséhez.

Tartalom életciklusa

Az alapul szolgáló adatforrástól függően az indexelők általában folyamatos változáskövetést és törlésészlelést biztosítanak. Ez a szakasz az egy-a-többhöz indexelés tartaloméletciklusát ismerteti az adatfrissítés vonatkozásában.

A változáskövetést és törlésészlelést biztosító adatforrások esetében az indexelő folyamat képes a forrásadatok változásainak felvételére. Minden alkalommal, amikor az indexelőt és a készségkészletet futtatja, az index-előrejelzések frissülnek, ha a képességkészlet vagy a mögöttes forrásadatok megváltoztak. Az indexelő által észlelt módosítások a bővítési folyamaton keresztül kerülnek propagálásra az indexben lévő előrejelzésekre, biztosítva, hogy a tervezett adatok a forrásból származó adatforrás tartalmának aktuális ábrázolása legyen. Az adatfrissítési tevékenység minden adattömbhöz egy előre jelzett kulcsértékben lesz rögzítve. Ez az érték frissül a mögöttes adatok változásakor.

Frissített tartalom

Ha új tartalmat ad hozzá az adatforráshoz, a rendszer új adattömböket vagy gyermekdokumentumokat ad hozzá az indexhez a következő indexelő futtatásakor.

Ha módosítja az adatforrás meglévő tartalmát, az adattömbök növekményesen frissülnek a keresési indexben, ha a használt adatforrás támogatja a változáskövetést és a törlés észlelését. Ha például egy szó vagy mondat megváltozik egy dokumentumban, az adott szót vagy mondatot tartalmazó célindex adattömbje frissül a következő indexelő futtatásakor. A meglévő mezők nem támogatnak más típusú frissítéseket, például egy mezőtípust és néhány hozzárendelést. Az engedélyezett frissítésekről további információt az indexséma frissítése című témakörben talál.

Egyes adatforrások, például a Azure Storage alapértelmezés szerint támogatják a változás- és törléskövetést az időbélyeg alapján. A változáskövetéshez más adatforrásokat, például Microsoft OneLake, Azure SQL vagy Azure Cosmos DB kell konfigurálni.

Törölt tartalom

Ha a forrástartalom már nem létezik (például ha a szöveg kevesebb adattömbhöz van lerövidítve), a keresési index megfelelő gyermekdokumentuma törlődik. A fennmaradó gyermekdokumentumok a kulcsukat is frissítik, hogy új kivonatértéket tartalmazzanak, még akkor is, ha a tartalmuk egyébként nem változott.

Ha egy szülődokumentumot teljesen törölnek az adatforrásból, a megfelelő gyermekdokumentumok csak akkor törlődnek, ha az adatforrás-definícióban meghatározott dataDeletionDetectionPolicy érzékeli a törlést. Ha nincs dataDeletionDetectionPolicy konfigurálva, és törölnie kell egy szülődokumentumot az adatforrásból, akkor manuálisan kell törölnie a gyermekdokumentumokat , ha már nem szeretné őket.

Előre jelzett kulcsérték

A frissített és törölt tartalmak adatintegritásának biztosítása érdekében az egy-a-többhöz indexelés adatfrissítése a "több" oldalon előrejelzett kulcsértékre támaszkodik. Ha integrált vektorizálást vagy adatimportálási varázslót használ, a tervezett kulcs értéke az parent_id index egy darabolt vagy "több" oldalán lévő mező.

A tervezett kulcsérték egy egyedi azonosító, amelyet az indexelő minden dokumentumhoz létrehoz. Biztosítja az egyediséget, és lehetővé teszi a módosítások és törlések nyomon követését a megfelelő működéshez. Ez a kulcs a következő szegmenseket tartalmazza:

• Véletlenszerű kivonat az egyediség garantálásához. Ez a kivonat akkor változik, ha a szülődokumentum frissül az indexelő későbbi futtatásakor.
• A szülődokumentum kulcsa.
• A létrehozott dokumentum kontextusát azonosító bővítési annotáció útvonala.

Ha például feloszt egy szülődokumentumot az "aa1b22c33" kulcsértékkel négy lapra, majd az egyes oldalakat saját dokumentumként veti ki az indexprojekciók segítségével:

• aa1b22c33
• aa1b22c33_pages_0
• aa1b22c33_pages_1
• aa1b22c33_pages_2

Ha a szülődokumentum frissül a forrásadatokban, esetleg több adattömbbe ágyazott lapot eredményez, a véletlenszerű kivonat megváltozik, több oldal lesz hozzáadva, és az egyes adattömbek tartalma a forrásdokumentum tartalmával megegyező módon frissül.

Példa külön szülő-gyermek indexekre

Ez a szakasz egy példát mutat be a külön szülő- és gyermekindexekre. Ez nem gyakori minta, de lehetséges, hogy olyan alkalmazáskövetelményekkel rendelkezik, amelyek a legjobban megfelelnek ennek a megközelítésnek. Ebben a forgatókönyvben szülő-gyermek tartalmakat helyez két különböző indexbe.

1. Hozzon létre két indexsémát.

   Minden séma rendelkezik az adott részletesség mezőivel, és a szülő ID mező közös mindkét indexben a lekérdezés való használathoz. Az elsődleges keresési korpusz a gyermekindex, de kibocsáthat egy keresési lekérdezést a szülőmezők lekéréséhez az eredmény minden egyes egyezéséhez. Azure AI Keresés nem támogatja az illesztéseket a lekérdezési időpontban, ezért az alkalmazás kódjának vagy vezénylési rétegének egyesítenie vagy össze kellválogatnia azokat az eredményeket, amelyek átadhatók egy alkalmazásnak vagy folyamatnak.

   A szülőindex parent_id mezővel és címmel rendelkezik. A parent_id a dokumentumkulcs. Nincs szükség vektorkeresési konfigurációra, hacsak nem szeretné vektorizálni a mezőket a szülődokumentum szintjén.

   {
       "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}
       ]
   }
   

   A gyermekindexben vannak az adattömbmezők, valamint a parent_id mező. Ha integrált vektorizálást, pontozási profilokat, szemantikai rangsorolókat vagy elemzőket használ, ezeket a gyermekindexben állíthatja be.

   {
       "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. Frissítse az indexelőt, hogy a szülőindexet adja meg célként.

   Az indexelő definíciója a folyamat összetevőit határozza meg. Az indexelő definíciójában a megadható indexnév a szülőindex. Ha mezőleképezésekre van szüksége a szülőszintű mezőkhöz, definiálja őket az outputFieldMappings fájlban. A különálló indexeket használó egy-a-többhöz indexelés esetén az indexelő definíciója az alábbi példához hasonlóan nézhet ki.

   {
     "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. Adja hozzá indexProjections a készségkészlethez.

   Íme egy példa egy indexprojektálási definícióra, amely meghatározza, hogy az indexelőnek mely adatelérési utat kell használnia a tartalom indexeléséhez. Megadja a gyermekindex nevét az indexprojekció definíciójában, és minden gyermek- vagy adattömbszintű mező megfeleltetését adja meg. Ez az egyetlen hely, ahol a gyermekindex neve meg van adva.

   Figyelje meg, hogy parameters null értékű, és az alapértelmezett includeIndexingParentDocumentsértéket használja. Az indexelő feltölti a szülőindexet. A selectors tömb az adattömb-dokumentumok gyermekindexre való kivetítésére szolgál.

   "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. Indexálót futtat. Ha korábban futtatta az indexelőt, ne felejtse el alaphelyzetbe állítani.

   Két indexet kell feltöltenie a megfelelő tartalommal. Az indexek lekérdezése a Search Explorerben annak ellenőrzéséhez, hogy mindegyik rendelkezik-e a megfelelő tartalommal.

Következő lépés

Az adatdarabolás és az egy-a-többhöz indexelés az Azure AI Keresés klasszikus RAG-mintájának része. További információért folytassa az alábbi oktatóanyag és kódminta használatával.