Összetett adattípusok modellezése Azure AI Keresés

Az Azure AI Keresés index feltöltéséhez használt külső adatkészletek számos alakzatban lehetnek. Néha hierarchikus vagy beágyazott alstruktúrákat is tartalmaznak. Ilyen lehet például egy ügyfél több címe, egy termék több színe és mérete, egy könyv több szerzője stb. Modellezési szempontból ezeket a struktúrákat összetett, összetett, összetett vagy összesítő adattípusoknak nevezik. Az Azure AI Keresés az komplex típus kifejezést használja erre a fogalomra. A Azure AI Keresés az összetett típusokat komplex mezők használatával modellezi. Az összetett mező olyan mező, amely gyermekeket (almezőket) tartalmaz, amelyek bármilyen típusúak lehetnek, beleértve az egyéb összetett típusokat is. Ez a programozási nyelv strukturált adattípusaihoz hasonlóan működik.

Az összetett mezők a dokumentum egyetlen objektumát vagy egy objektumtömböt jelölnek az adattípustól függően. A típusmezők Edm.ComplexType egyetlen objektumot, míg a típusmezők Collection(Edm.ComplexType) objektumtömböket jelölnek.

Azure AI Keresés natív módon támogatja az összetett típusokat és gyűjteményeket. Ezek a típusok lehetővé teszik, hogy szinte bármilyen JSON-struktúrát modellezhet egy Azure AI Keresés indexben. A Azure AI Keresés API-k korábbi verzióiban csak az egybesimított sorkészletek importálhatók. A legújabb verzióban az index mostantól jobban megfelelhet a forrásadatoknak. Más szóval, ha a forrásadatok összetett típusok, akkor az index összetett típusokkal is rendelkezhet.

Kezdésként a hotels adatkészletet javasoljuk, amelyet egy importáló varázslóval tölthet be az Azure portálon. A varázsló összetett típusokat észlel a forrásban, és javaslatot tesz egy indexsémára az észlelt struktúrák alapján.

Példa egy összetett struktúrára

A következő JSON-dokumentum egyszerű mezőkből és összetett mezőkből áll. Az összetett mezők( például Address és Rooms) almezőkkel rendelkeznek. Address egyetlen értékkészlettel rendelkezik ezekhez az almezőkhöz, mivel ez egy objektum a dokumentumban. Ezzel szemben Rooms az almezőkhöz több értékkészlet tartozik, egy a gyűjtemény minden objektumához.

{
  "HotelId": "1",
  "HotelName": "Stay-Kay City Hotel",
  "Description": "Ideally located on the main commercial artery of the city in the heart of New York.",
  "Tags": ["Free wifi", "on-site parking", "indoor pool", "continental breakfast"],
  "Address": {
    "StreetAddress": "677 5th Ave",
    "City": "New York",
    "StateProvince": "NY"
  },
  "Rooms": [
    {
      "Description": "Budget Room, 1 Queen Bed (Cityside)",
      "RoomNumber": 1105,
      "BaseRate": 96.99,
    },
    {
      "Description": "Deluxe Room, 2 Double Beds (City View)",
      "Type": "Deluxe Room",
      "BaseRate": 150.99,
    }
    . . .
  ]
}

Összetett mezők létrehozása

Az indexdefiníciókhoz hasonlóan a Azure portal, a REST API vagy a .NET SDK használatával is létrehozhat összetett típusokat tartalmazó sémát.

Az egyéb Azure SDK-k példákat biztosítanak Python, Java és JavaScript nyelveken.

{
  "name": "hotels",
  "fields": [
    { "name": "HotelId", "type": "Edm.String", "key": true, "filterable": true },
    { "name": "HotelName", "type": "Edm.String", "searchable": true, "filterable": false },
    { "name": "Description", "type": "Edm.String", "searchable": true, "analyzer": "en.lucene" },
    { "name": "Address", "type": "Edm.ComplexType",
      "fields": [
        { "name": "StreetAddress", "type": "Edm.String", "filterable": false, "sortable": false, "facetable": false, "searchable": true },
        { "name": "City", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true, "facetable": true },
        { "name": "StateProvince", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true, "facetable": true }
      ]
    },
    { "name": "Rooms", "type": "Collection(Edm.ComplexType)",
      "fields": [
        { "name": "Description", "type": "Edm.String", "searchable": true, "analyzer": "en.lucene" },
        { "name": "Type", "type": "Edm.String", "searchable": true },
        { "name": "BaseRate", "type": "Edm.Double", "filterable": true, "facetable": true }
      ]
    }
  ]
}

using Azure.Search.Documents.Indexes;

namespace AzureSearch.SDKHowTo
{
    public partial class Address
    {
        [SearchableField(IsFilterable = true)]
        public string StreetAddress { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string City { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string StateProvince { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string PostalCode { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string Country { get; set; }
    }
}

using System;
using Microsoft.Spatial;
using System.Text.Json.Serialization;
using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;

namespace AzureSearch.SDKHowTo
{
    public partial class Hotel
    {
        [SimpleField(IsKey = true, IsFilterable = true)]
        public string HotelId { get; set; }

        [SearchableField(IsSortable = true)]
        public string HotelName { get; set; }

        // Removed multiple fields for brevity

        // Address is declared as type Address
        [SearchableField]
        public Address Address { get; set; }

        // Room array is declared as type Room
        public Room[] Rooms { get; set; }
    }
}

Összetett gyűjteménykorlátok

Az indexelés során legfeljebb 3000 elem lehet egyetlen dokumentum összes összetett gyűjteményében. Az összetett gyűjtemény egyik eleme ennek a gyűjteménynek a tagja. A Szobák (a szállodai példa egyetlen összetett gyűjteménye) esetében minden szoba elem. A fenti példában, ha a "Stay-Kay City Hotel" 500 szobával rendelkezne, a szálloda dokumentuma 500 szobaelemből állna. Beágyazott összetett gyűjtemények esetén a külső (szülő) elem mellett az egyes beágyazott elemek is megszámlálhatók.

Ez a korlát csak összetett gyűjteményekre vonatkozik, és nem összetett típusokra (például Cím) vagy sztringgyűjteményekre (például Címkék).

Összetett mezők frissítése

A mezőkre általában érvényes összes újraindexelési szabály továbbra is az összetett mezőkre vonatkozik. Egy új mező összetett típushoz való hozzáadása nem igényel index-újraépítést, de a legtöbb más módosításhoz újra kell építeni.

A definíció szerkezeti frissítései

Új almezőket bármikor hozzáadhat egy összetett mezőhöz anélkül, hogy index-újraépítésre van szükség. Például a "ZipCode" Address vagy a "Amenities" Rooms hozzáadása engedélyezett, ugyanúgy, mint egy felső szintű mező hozzáadása egy indexhez. A meglévő dokumentumok null értékkel rendelkeznek az új mezőkhöz, amíg az adatok frissítésével explicit módon nem tölti ki ezeket a mezőket.

Egy összetett típuson belül minden almező típussal rendelkezik, és attribútumokkal rendelkezhet, ugyanúgy, mint a legfelső szintű mezők.

Adatfrissítések

Az index meglévő dokumentumainak frissítése a upload művelettel ugyanúgy működik, mint az összetett és egyszerű mezők esetében: minden mező lecserélődik. Azonban merge (vagy mergeOrUpload ha egy meglévő dokumentumra alkalmazva) nem működik minden mezőnél. merge Pontosabban nem támogatja a gyűjtemény elemeinek egyesítését. Ez a korlátozás primitív típusú és összetett gyűjteményekre vonatkozik. A gyűjtemény frissítéséhez le kell kérnie a teljes gyűjteményi értéket, módosítania kell, majd be kell foglalnia az új gyűjteményt az Index API-kérelembe.

Összetett mezők keresése szöveges lekérdezésekben

A szabad formátumú keresési kifejezések a várt módon működnek az összetett típusok esetében. Ha egy dokumentum bármely kereshető mezője vagy almezője megegyezik, akkor maga a dokumentum egyezés.

A lekérdezések árnyaltabbak lesznek, ha több kifejezéssel és operátorral rendelkezik, és egyes kifejezésekben mezőnevek vannak megadva, ahogyan az a Lucene szintaxisban lehetséges. Például ez a lekérdezés a "Portland" és "OR" kifejezéseket próbálja illeszteni a Cím mező két almezőjéhez.

search=Address/City:Portland AND Address/State:OR

Az ilyen lekérdezések a teljes szöveges keresés során nem korrelálnak, ellentétben a szűrőkkel. A szűrőkben az összetett gyűjtemény almezőire vonatkozó lekérdezések a tartományváltozók használatával vannak korrelálva.anyall A fenti Lucene-lekérdezés "Portland, Maine" és "Portland, Oregon" dokumentumokat, valamint Oregon többi városát is visszaadja. Ez azért történik, mert az egyes záradékok a teljes dokumentumban a mező összes értékére vonatkoznak, így az "aktuális aldokumentum" fogalma nem létezik. Erről további információt a Az OData-gyűjteményszűrők az Azure AI Keresés-ban című témakörben talál.

Összetett mezők keresése RAG-lekérdezésekben

A RAG-minta továbbítja a keresési eredményeket egy csevegőmodellnek a generatív AI és a beszélgetési keresés érdekében. Alapértelmezés szerint az LLM-nek átadott keresési eredmények egy lapított sorkészlet. Ha azonban az index összetett típusokból áll, a lekérdezés ezeket a mezőket is megadhatja, ha először JSON-ra konvertálja a keresési eredményeket, majd átadja a JSON-t az LLM-nek.

Egy részleges példa a technikát szemlélteti:

• Adja meg a kívánt mezőket a parancssorban vagy a lekérdezésben.
• Győződjön meg arról, hogy a mezők kereshetők és lekérdezhetők az indexben.
• Jelölje ki a keresési eredmények mezőit.
• Formázza az eredményeket JSON-ként.
• Küldje el a csevegés befejezésére vonatkozó kérelmet a modellszolgáltatónak.

import json

# Query is the question being asked. It's sent to the search engine and the LLM.
query="Can you recommend a few hotels that offer complimentary breakfast? Tell me their description, address, tags, and the rate for one room they have which sleep 4 people."

# Set up the search results and the chat thread.
# Retrieve the selected fields from the search index related to the question.
selected_fields = ["HotelName","Description","Address","Rooms","Tags"]
search_results = search_client.search(
    search_text=query,
    top=5,
    select=selected_fields,
    query_type="semantic"
)
sources_filtered = [{field: result[field] for field in selected_fields} for result in search_results]
sources_formatted = "\n".join([json.dumps(source) for source in sources_filtered])

response = openai_client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": GROUNDED_PROMPT.format(query=query, sources=sources_formatted)
        }
    ],
    model=AZURE_DEPLOYMENT_MODEL
)

print(response.choices[0].message.content)

A végponttól végpontig használt példáért lásd: klasszikus RAG az Azure AI Keresés-ben.

Összetett mezők kijelölése

A $select paraméter a keresési eredményekben visszaadott mezők kiválasztására szolgál. Ha ezt a paramétert egy összetett mező adott almezőinek kiválasztásához szeretné használni, adja meg a szülőmezőt és az almezőt perjellel (/perjellel) elválasztva.

$select=HotelName, Address/City, Rooms/BaseRate

A mezőket lekérdezhetőként kell megjelölni az indexben, ha azt szeretné, hogy a keresési eredményekben szerepeljenek. Csak azok a mezők használhatók egy $select utasításban, amelyek lekérhetők.

Összetett mezők szűrése, fácetálása és rendezése

A szűréshez és a mezőalapú keresésekhez használt OData-elérési út szintaxisa a keresési kérelmek mezőinek szűrésére, rendezésére és kijelölésére is használható. Összetett típusok esetén olyan szabályok érvényesek, amelyek meghatározzák, hogy mely almezők jelölhetők rendezhetőként vagy facétálhatóként. Ezekről a szabályokról további információt az Index API létrehozása referenciában talál.

Arculati almezők

Bármely almező megjelölhető facettálhatóként, kivéve, ha a típusa Edm.GeographyPoint vagy Collection(Edm.GeographyPoint).

A szemantikai eredményekben visszaadott dokumentumszámokat a szülődokumentum (szálloda) számolják ki, nem pedig egy összetett gyűjtemény (szobák) aldokumentumaira. Tegyük fel például, hogy egy szálloda 20 "suite" típusú szobával rendelkezik. Tekintettel erre a szempontra facet=Rooms/Type, a aspektusok száma a szálloda számára egy, nem pedig a szobák esetében 20.

Összetett mezők rendezése

A rendezési műveletek a dokumentumokra (szállodákra) és nem aldokumentumokra (Szobákra) vonatkoznak. Ha összetett típusú gyűjteménnyel rendelkezik, például a Szobákkal, lényeges tudatosítani, hogy a Szobákat egyáltalán nem lehet rendezni. Valójában nem rendezhet semmilyen gyűjteményt.

A rendezési műveletek akkor működnek, ha a mezők dokumentumonként egyetlen értékkel rendelkeznek, legyen szó egyszerű mezőről vagy összetett típusú almezőről. Például Address/City rendezhető, mert szállodánként csak egy cím van, így $orderby=Address/City ezek a szállodákat város szerint rendezi.

Szűrés összetett mezőkön

Egy szűrőkifejezésben egy összetett mező almezőire hivatkozhat. Csak használja ugyanazt az OData-elérési út szintaxist, amelyet a mezők facettázásához, rendezéséhez és kijelöléséhez használnak. Az alábbi szűrő például az összes kanadai szállodát visszaadja:

$filter=Address/Country eq 'Canada'

Összetett gyűjteménymezőkre való szűréshez használhat lambda kifejezést és anyall operátorokat. Ebben az esetben a lambda kifejezés tartományváltozója egy almezőkkel rendelkező objektum. Ezekre az almezőkre a standard OData-elérési út szintaxisával hivatkozhat. Például az alábbi szűrő visszaadja az összes olyan szállodát, amelynek van legalább egy deluxe szobája, és az összes nemdohányzó szobát.

$filter=Rooms/any(room: room/Type eq 'Deluxe Room') and Rooms/all(room: not room/SmokingAllowed)

A legfelső szintű egyszerű mezőkhöz hasonlóan az összetett mezők egyszerű almezői csak akkor vehetők fel a szűrőkbe, ha az indexdefinícióban a szűrhető attribútum van beállítva true . További információkért tekintse meg az Index API létrehozása referenciát.

Áthidaló megoldás a bonyolult gyűjteménykorlátra

Ne feledje, hogy Azure AI Keresés a gyűjtemény összetett objektumait dokumentumonként 3000 objektumra korlátozza. Ha túllépi ezt a korlátot, a következő üzenet jelenik meg:

A collection in your document exceeds the maximum elements across all complex collections limit.
The document with key '1052' has '4303' objects in collections (JSON arrays).
At most '3000' objects are allowed to be in collections across the entire document.
Remove objects from collections and try indexing the document again."

Ha több mint 3000 elemre van szüksége, az értékeket elválasztó csövet (|) vagy bármilyen típusú elválasztót használhat az értékek elválasztásához, összefűzéséhez és elválasztott sztringként való tárolásához. A tömbben tárolt sztringek száma nincs korlátozva. Az összetett értékek sztringként való tárolása meghaladja az összetett gyűjtemény korlátozását.

A szemléltetés érdekében tegyük fel, hogy több mint 3000 elemből áll egy "searchScope" tömb:

"searchScope": [
  {
     "countryCode": "FRA",
     "productCode": 1234,
     "categoryCode": "C100"
  },
  {
     "countryCode": "USA",
     "productCode": 1235,
     "categoryCode": "C200"
  }
  . . .
]

Az értékek tagolt sztringként való tárolásának kerülő megoldása a következőképpen nézhet ki:

"searchScope": [
        "|FRA|1234|C100|",
        "|FRA|*|*|",
        "|*|1234|*|",
        "|*|*|C100|",
        "|FRA|*|C100|",
        "|*|1234|C100|"
]

Az összes keresési változat tárolása a tagolt sztringben hasznos lehet olyan keresési forgatókönyvekben, ahol olyan elemeket szeretne keresni, amelyek csak "FRA" vagy "1234" vagy más kombinációval rendelkeznek a tömbön belül.

Az alábbiakban egy C# szűrőformázási kódrészletet talál, amely kereshető sztringekké alakítja a bemeneteket:

foreach (var filterItem in filterCombinations)
        {
            var formattedCondition = $"searchScope/any(s: s eq '{filterItem}')";
            combFilter.Append(combFilter.Length > 0 ? " or (" + formattedCondition + ")" : "(" + formattedCondition + ")");
        }

Az alábbi lista bemeneteket és keresési sztringeket (kimeneteket) tartalmaz egymás mellett:

• A "FRA" megyei kód és az "1234" termékkód esetében a formázott kimenet a |FRA|1234|*|.

• Az "1234" termékkód esetében a formázott kimenet a következő |*|1234|*|.

• A "C100" kategóriakód esetén a formázott kimenet a következő |*|*|C100|.

Csak akkor adja meg a helyettesítő karaktert (*), ha a sztringtömb megkerülését implementálja. Ellenkező esetben, ha összetett típust használ, a szűrő az alábbi példához hasonlóan nézhet ki:

var countryFilter = $"searchScope/any(ss: search.in(countryCode ,'FRA'))";
var catgFilter = $"searchScope/any(ss: search.in(categoryCode ,'C100'))";
var combinedCountryCategoryFilter = "(" + countryFilter + " and " + catgFilter + ")";

Ha implementálja a kerülő megoldást, mindenképpen tesztelje alaposan.

Következő lépés

Az importálási varázsló mintaadatokkal való használatával végigvezetheti az indexek létrehozásán, betöltésén és lekérdezésén: