Oktatóanyag: Kereshető tartalom létrehozása Azure-blobok alapján a .NET és az AI használatával

Ha az Azure Blob Storage-ban strukturálatlan szövegekkel vagy képekkel rendelkezik, az AI-bővítő folyamat információkat tud kinyerni és új tartalmat létrehozni teljes szöveges kereséshez vagy tudásbányászati forgatókönyvekhez.

Az oktatóanyag során a következőket fogja elsajátítani:

  • Fejlesztési környezet beállítása
  • Definiálhat egy olyan folyamatot, amely OCR-t, nyelvfelismerést, valamint entitás- és kulcskifejezés-felismerést használ.
  • Hajtsa végre a folyamatot átalakítások meghívása, valamint egy keresési index létrehozásához és betöltéséhez.
  • Az eredményeket teljes szöveges kereséssel és gazdag lekérdezési szintaxissal tárja fel.

Ha nem rendelkezik Azure-előfizetéssel, kezdés előtt nyisson meg egy ingyenes fiókot.

Áttekintés

Ez az oktatóanyag a C# és a Azure.Search.Documents ügyféloldali kódtár segítségével hoz létre adatforrást, indexet, indexelőt és képességkészletet.

Az indexelő az adatforrás-objektumban megadott blobtárolóhoz csatlakozik, és minden indexelt tartalmat egy meglévő keresési indexnek küld.

A képességkészlet az indexelőhöz van csatolva. A Microsoft beépített készségeit használja az információk kereséshez és kinyerhez. A folyamat lépései közé tartozik a képek optikai karakterfelismerése (OCR), a szöveg nyelvfelismerése, a kulcskifejezések kinyerése és az entitásfelismerés (szervezetek). A folyamat által létrehozott új információk egy index új mezőiben tárolódnak. Az index feltöltése után használhatja a mezőket a lekérdezésekben, a facets és a szűrőkben.

Előfeltételek

Megjegyzés

Ehhez az oktatóanyaghoz használhatja az ingyenes keresési szolgáltatást. Az ingyenes keresési szolgáltatás három indexre, három indexelőre és három adatforrásra korlátozza. Az oktatóanyagban mindegyikből egyet hozhat majd létre. A kezdés előtt győződjön meg arról, hogy van hely a szolgáltatásban az új erőforrások elfogadásához.

Töltse le a mintaadatokat

A mintaadatok 14 vegyes tartalomtípusú fájlt tartalmaznak, amelyek egy későbbi lépésben Storage Azure Blob-tárolóba lesznek feltöltve.

  1. Nyissa meg OneDrive mappát, és a bal felső sarokban kattintson a Letöltés gombra a fájlok számítógépre másoláshoz.

  2. Kattintson a jobb gombbal a zip-fájlra, és válassza az Összes kibonta lehetőséget. 14 fájltípus létezik. Ehhez a gyakorlathoz a 7-et fogja használni.

Az oktatóanyag forráskódját is letöltheti. A forráskód az azure-search-dotnet-samples adattár tutorial-ai-enrichment/v11 mappájában található.

1 – Szolgáltatások létrehozása

Ez az oktatóanyag Azure Cognitive Search indexeléshez és lekérdezésekhez, Cognitive Services a háttérbeli AI-gazdagításhoz, az Azure Blob Storage pedig az adatokhoz. Ez az oktatóanyag az indexelőnként napi 20 tranzakció ingyenes kiosztása alatt marad Cognitive Services-ben, így csak a keresést és a tárolást kell létrehoznia.

Ha lehetséges, hozzon létre mindkettőt ugyanabban a régióban és erőforráscsoportban a közelség és a kezelhetőség érdekében. A gyakorlatban az Azure Storage-fiókja bármely régióban lehet.

Az Azure Storage

  1. Jelentkezzen be a Azure Portal és kattintson az + Erőforrás létrehozása elemre.

  2. Keressen rá a tárfiók kifejezésre, és válassza ki a Microsoft Storage-ajánlatát.

    Új Storage létrehozása

  3. Az Alapvető beállítások lapon a következő elemekre van szükség. Minden más esetén fogadja el az alapértelmezett értékeket.

    • Erőforráscsoport. Válasszon ki egy meglévőt, vagy hozzon létre egy újat, de használja ugyanazt a csoportot az összes szolgáltatáshoz, hogy együttesen kezelheti őket.

    • Tárfiók neve. Ha úgy gondolja, hogy több azonos típusú erőforrással rendelkezik, használja a nevet a típus és a régió , például blobstoragewestus alapján történő eloszláshoz.

    • Hely. Ha lehetséges, válassza ugyanazt a helyet, mint a Azure Cognitive Search és Cognitive Services. Egyetlen hely nem igényel sávszélesség-díjakat.

    • Fiók fajtája. Válassza az alapértelmezett StorageV2 (általános célú v2) értéket.

  4. A szolgáltatás létrehozásához kattintson az Áttekintés + létrehozás gombra.

  5. A létrehozás után kattintson az Ugrás az erőforrásra elemre az Áttekintés lap megnyitásához.

  6. Kattintson a Blobok szolgáltatás elemre.

  7. Kattintson a + Tároló elemre egy tároló létrehozásához, és nevezze el cog-search-demo néven.

  8. Válassza a cog-search-demo lehetőséget, majd kattintson a Feltöltés gombra a letöltött fájlokat tartalmazó mappa megnyitásához. Válassza ki az összes saját fájlt, majd kattintson az OK gombra a feltöltéshez.

    Mintafájlok feltöltése

  9. Mielőtt elhagyja az Azure Storage, szerezze be a kapcsolati sztringet, hogy kapcsolatot hoz létre a Azure Cognitive Search.

    1. Lépjen vissza a tárfiók Áttekintés lapjára (példaként a blobstoragewestust használtjuk).

    2. A bal oldali navigációs panelen válassza a Hozzáférési kulcsok lehetőséget, és másolja ki az egyik kapcsolati sztringet.

    A kapcsolati sztring az alábbi példához hasonló URL-cím:

    DefaultEndpointsProtocol=https;AccountName=blobstoragewestus;AccountKey=<your account key>;EndpointSuffix=core.windows.net
    
  10. Mentse a kapcsolati sztringet a Jegyzettömb. Később szüksége lesz rá az adatforrás-kapcsolat beállításakor.

Cognitive Services

Az AI-gazdagítást a Cognitive Services, beleértve a Text Analytics és Computer Vision természetes nyelvi és képfeldolgozási Computer Vision is. Ha a cél egy tényleges prototípus vagy projekt befejezése volt, akkor ezen a ponton üzembe kell Cognitive Services -t (ugyanabban a régióban, mint az Azure Cognitive Search), hogy indexelési műveletekhez csatolja.

Ebben a gyakorlatban azonban kihagyhatja az erőforrás-kiépítést, mert a Azure Cognitive Search a színfalak mögött Cognitive Services, és indexelő-futtatásonként 20 ingyenes tranzakciót tud adni. Mivel ez az oktatóanyag 14 tranzakciót használ, az ingyenes kiosztás elegendő. Nagyobb projektek esetén a Cognitive Services S0 szinten tervezze meg a kiépítést. További információ: Attach Cognitive Services.

A harmadik összetevő Azure Cognitive Search, amelyet létrehozhat a portálon, vagy megkereshet egy meglévő keresési szolgáltatást az előfizetésében.

Az útmutató befejezéséhez használhatja az Ingyenes szintet.

A szolgáltatás Azure Cognitive Search szüksége lesz a szolgáltatás URL-címére és egy hozzáférési kulcsra. Mindkettővel létrejön egy keresési szolgáltatás, így ha hozzáadott Azure Cognitive Search az előfizetéshez, kövesse az alábbi lépéseket a szükséges információk lekért adatokat:

  1. Jelentkezzen be a Azure Portal,majd a keresési szolgáltatás Áttekintés oldalán szerezze be az URL-címet. A végpontok például a következőképpen nézhetnek ki: https://mydemo.search.windows.net.

  2. A Gépház > kulcsok között másolja ki a rendszergazdai kulcsot a szolgáltatásra vonatkozó teljes jogosultságokért. Az üzletmenet folytonossága érdekében két felcserélhető rendszergazdai kulcs áll rendelkezésre arra az esetre, ha át kellene adni egyet. Az objektumok hozzáadására, módosítására és törlésére vonatkozó kérések esetén az elsődleges vagy a másodlagos kulcsot is használhatja.

    Szerezze be a lekérdezési kulcsot is. Ajánlott eljárás csak olvasási hozzáféréssel lekérdezési kéréseket kikérdezni.

    Szolgáltatásnév, rendszergazdai és lekérdezési kulcsok lekérdezve

Érvényes kulcs birtokában kérelmenként létesíthető megbízhatósági kapcsolat a kérést küldő alkalmazás és az azt kezelő szolgáltatás között.

2 – A környezet beállítása

Először is Visual Studio egy .NET Core-on futtatható új konzolalkalmazás-projektet.

A Azure.Search.Doctelepítése

A Azure Cognitive Search .NET SDK egy ügyféloldali kódtárból áll, amely lehetővé teszi az indexek, adatforrások, indexelők és képességkészletek kezelését, valamint dokumentumok feltöltését és kezelését, valamint lekérdezések végrehajtását anélkül, hogy a HTTP és a JSON adatait kezelné. Ez az ügyféloldali kódtár NuGet-csomagként van terjesztve.

Ehhez a projekthez telepítse a 11-es vagy újabb verzióját és Azure.Search.Documents a legújabb Microsoft.Extensions.Configuration verzióját.

  1. A Visual Studio válassza a Tools > NuGet Csomagkezelő Manage NuGet Packages for Solution... (NuGet-csomagok kezelése a > megoldáshoz) lehetőséget.

  2. Keresse meg aAzure.Search.Docet.

  3. Válassza ki a legújabb verziót, majd kattintson a Telepítés gombra.

  4. Ismételje meg az előző lépéseket aMicrosoft.Extensions.Configés aMicrosoft.Extensions.Configuration.Jstelepítéséhez.

Szolgáltatáskapcsolati adatok hozzáadása

  1. Kattintson a jobb gombbal a projektre a Megoldáskezelő, és válassza az Add > New Item... (Új elem hozzáadása... ) lehetőséget.

  2. Nevezze el a fájlt, appsettings.json és válassza a Hozzáadás lehetőséget.

  3. Ezt a fájlt foglalja bele a kimeneti könyvtárba.

    1. Kattintson a jobb gombbal a appsettings.json elemre, és válassza a Tulajdonságok lehetőséget.
    2. Módosítsa a Copy to Output Directory (Másolás a kimeneti könyvtárba) értékét Copy if newer (Másolás, ha újabb) értékre.
  4. Másolja az alábbi JSON-t az új JSON-fájlba.

    {
      "SearchServiceUri": "Put your search service URI here",
      "SearchServiceAdminApiKey": "Put your primary or secondary API key here",
      "SearchServiceQueryApiKey": "Put your query API key here",
      "AzureBlobConnectionString": "Put your Azure Blob connection string here",
    }
    

Adja meg a keresési szolgáltatás és a Blob Storage-fiók adatait. Ne feledheti, hogy ezeket az információkat az előző szakaszban jelzett szolgáltatás-kiépítési lépésekből kaphatja meg.

A SearchServiceUri mezőben adja meg a teljes URL-címet.

Névterek hozzáadása

A Program.cs fájlban adja hozzá a következő névtereket.

using Azure;
using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;
using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Linq;

namespace EnrichwithAI

Ügyfél létrehozása

Hozzon létre egy és SearchIndexClient egy példányt a SearchIndexerClient Main alatt.

public static void Main(string[] args)
{
    // Create service client
    IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
    IConfigurationRoot configuration = builder.Build();

    string searchServiceUri = configuration["SearchServiceUri"];
    string adminApiKey = configuration["SearchServiceAdminApiKey"];
    string cognitiveServicesKey = configuration["CognitiveServicesKey"];

    SearchIndexClient indexClient = new SearchIndexClient(new Uri(searchServiceUri), new AzureKeyCredential(adminApiKey));
    SearchIndexerClient indexerClient = new SearchIndexerClient(new Uri(searchServiceUri), new AzureKeyCredential(adminApiKey));
}

Megjegyzés

Az ügyfelek a keresési szolgáltatáshoz csatlakoznak. A túl sok kapcsolat megnyitásának elkerülése érdekében lehetőség szerint próbáljon meg egyetlen példányt megosztani az alkalmazásban. A metódusok szál számára biztonságosak az ilyen megosztás engedélyezéséhez.

Függvény hozzáadása a programból való kilépéshez hiba esetén

Ez az oktatóanyag segít megérteni az indexelési folyamat egyes lépését. Ha kritikus probléma van, amely megakadályozza, hogy a program létrehozza az adatforrást, képességkészletet, indexet vagy indexelőt, a program ki fogja küldeni a hibaüzenetet, és kilép, hogy a probléma érthető és elhárítható legyen.

Adja ExitProgram hozzá Main a következőhöz: , ha olyan forgatókönyveket szeretne kezelni, amelyeknél a programnak ki kell lépnie.

private static void ExitProgram(string message)
{
    Console.WriteLine("{0}", message);
    Console.WriteLine("Press any key to exit the program...");
    Console.ReadKey();
    Environment.Exit(0);
}

3 – A folyamat létrehozása

A Azure Cognitive Search AI-feldolgozás az indexelés (vagy adatbe feldolgozása) során történik. Az útmutató ezen része négy objektumot hoz létre: adatforrást, indexdefiníciót, képességcsoportot, indexelőt.

1. lépés: Adatforrás létrehozása

SearchIndexerClient A DataSourceName rendelkezik egy tulajdonságmal, amely beállítható egy SearchIndexerDataSourceConnection objektumra. Ez az objektum biztosítja az adatforrások létrehozásához, listához, frissítéséhez vagy Azure Cognitive Search szükséges összes metódust.

Hozzon létre egy új példányt a SearchIndexerDataSourceConnection hívása indexerClient.CreateOrUpdateDataSourceConnection(dataSource) segítségével. Az alábbi kód egy típusú adatforrást hoz AzureBlob létre.

private static SearchIndexerDataSourceConnection CreateOrUpdateDataSource(SearchIndexerClient indexerClient, IConfigurationRoot configuration)
{
    SearchIndexerDataSourceConnection dataSource = new SearchIndexerDataSourceConnection(
        name: "demodata",
        type: SearchIndexerDataSourceType.AzureBlob,
        connectionString: configuration["AzureBlobConnectionString"],
        container: new SearchIndexerDataContainer("cog-search-demo"))
    {
        Description = "Demo files to demonstrate cognitive search capabilities."
    };

    // The data source does not need to be deleted if it was already created
    // since we are using the CreateOrUpdate method
    try
    {
        indexerClient.CreateOrUpdateDataSourceConnection(dataSource);
    }
    catch (Exception ex)
    {
        Console.WriteLine("Failed to create or update the data source\n Exception message: {0}\n", ex.Message);
        ExitProgram("Cannot continue without a data source");
    }

    return dataSource;
}

Sikeres kérés esetén a metódus visszaadja a létrehozott adatforrást. Ha probléma van a kéréssel, például érvénytelen paraméterrel, a metódus kivételt ad vissza.

Most adjon hozzá egy sort Main a-hoz, amely az előbb CreateOrUpdateDataSource hozzáadott függvényt hívja meg.

// Create or Update the data source
Console.WriteLine("Creating or updating the data source...");
SearchIndexerDataSourceConnection dataSource = CreateOrUpdateDataSource(indexerClient, configuration);

Fordítsa le és futtassa a megoldást. Mivel ez az első kérése, ellenőrizze a Azure Portal, hogy az adatforrás létrejött-e a Azure Cognitive Search. A keresési szolgáltatás áttekintő oldalán ellenőrizze, hogy az Adatforrások listában új elem található-e. Lehet, hogy várnia kell néhány percet, amíg a portáloldal frissül.

Adatforrások csempe a portálon

2. lépés: Képességkészlet létrehozása

Ebben a szakaszban definiálhatja az adatokra alkalmazni kívánt bővítő lépések készletét. Minden egyes gazdagítási lépés neve képesség, a további lépések készlete pedig egy képességkészlet. Ez az oktatóanyag beépített kognitív képességeket használ a képességkészlethez:

  • Optikai karakterfelismerés a nyomtatott és kézzel írt szöveg felismerésére képfájlokban.

  • Szöveg egyesíteni egy mezőgyűjtemény szövegét egyetlen mezőben.

  • Nyelvfelismeréssel azonosítja a tartalom nyelvét.

  • Szöveg felosztása, hogy a nagy tartalmat kisebb adattömbökre bontsa a kulcskifejezés-kinyerési képesség és az entitásfelismerési képesség hívása előtt. A kulcskifejezések kinyerése és az entitások felismerése 50 000 karakternél rövidebb bemeneteket fogad el. A mintafájlok közül néhányat fel kell osztani ahhoz, hogy beleférjen a korlátozásba.

  • Entitásfelismerés a szervezetek nevének a blobtárolóban lévő tartalomból való kinyeréséhez.

  • A Kulcskifejezések kinyerése lehívja a leggyakoribb kulcskifejezéseket.

A kezdeti feldolgozás során a Azure Cognitive Search feltöri az egyes dokumentumokat, hogy különböző fájlformátumból származó tartalmakat bontsa ki. A forrásfájlból származó szöveg egy generált mezőbe kerül, minden content dokumentumhoz egyet. Ezért állítsa be a bemenetet úgy, "/document/content" hogy ezt a szöveget használja. A kép tartalma egy generált mezőbe kerül, amely normalized_images egy képességkészletben a következőként van megadva: /document/normalized_images/* .

A kimenetek hozzárendelhetők egy indexhez, bemenetként használhatók egy alsóbb rétegbeli képességhez, vagy a fentiek mindegyike lehetséges, akárcsak a nyelvkód esetében. Az indexben a nyelvkód a szűréskor lehet hasznos. A nyelvkódot bemenetként a szövegelemzési képességek használják, a szótördeléssel kapcsolatos nyelvi szabályok megadásához.

A képességcsoportok alapvető tudnivalóval kapcsolatos bővebb információkért lásd: Képességcsoport megadása.

OCR-képesség

A OcrSkill kinyeri a szöveget képekből. Ez a képesség feltételezi, hogy normalized_images mező létezik. A mező létrehozásához az oktatóanyag későbbi oktatóanyagában az indexelő definíciójában a konfigurációt a következőre "imageAction" állítjuk: "generateNormalizedImages" .

private static OcrSkill CreateOcrSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("image")
    {
        Source = "/document/normalized_images/*"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("text")
    {
        TargetName = "text"
    });

    OcrSkill ocrSkill = new OcrSkill(inputMappings, outputMappings)
    {
        Description = "Extract text (plain and structured) from image",
        Context = "/document/normalized_images/*",
        DefaultLanguageCode = OcrSkillLanguage.En,
        ShouldDetectOrientation = true
    };

    return ocrSkill;
}

Képesség egyesítése

Ebben a szakaszban létre fog hozni egy et, amely egyesíti a dokumentum tartalmának mezőjét az MergeSkill OCR-képesség által előállított szöveggel.

private static MergeSkill CreateMergeSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("text")
    {
        Source = "/document/content"
    });
    inputMappings.Add(new InputFieldMappingEntry("itemsToInsert")
    {
        Source = "/document/normalized_images/*/text"
    });
    inputMappings.Add(new InputFieldMappingEntry("offsets")
    {
        Source = "/document/normalized_images/*/contentOffset"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("mergedText")
    {
        TargetName = "merged_text"
    });

    MergeSkill mergeSkill = new MergeSkill(inputMappings, outputMappings)
    {
        Description = "Create merged_text which includes all the textual representation of each image inserted at the right location in the content field.",
        Context = "/document",
        InsertPreTag = " ",
        InsertPostTag = " "
    };

    return mergeSkill;
}

Nyelvfelismerési képesség

A észleli a bemeneti szöveg nyelvét, és egyetlen nyelvi kódot küld a kéréshez beküldött LanguageDetectionSkill minden dokumentumhoz. A szövegfelosztó képesség bemenetének Nyelvfelismerés a képesség kimenetét fogjuk használni.

private static LanguageDetectionSkill CreateLanguageDetectionSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("text")
    {
        Source = "/document/merged_text"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("languageCode")
    {
        TargetName = "languageCode"
    });

    LanguageDetectionSkill languageDetectionSkill = new LanguageDetectionSkill(inputMappings, outputMappings)
    {
        Description = "Detect the language used in the document",
        Context = "/document"
    };

    return languageDetectionSkill;
}

Szövegfelosztó képesség

Az alábbi táblázat oldalak szerint osztja fel a szöveget, és a által mért SplitSkill oldalhosszt 4000 karakterre String.Length korlátozza. Az algoritmus megpróbálja felosztani a szöveget a legnagyobb méretű maximumPageLength adattömbökre. Ebben az esetben az algoritmus mindent meg fog tenni a mondat mondathatáron való lebontásán, így az adattömb mérete valamivel kisebb lehet, mint maximumPageLength .

private static SplitSkill CreateSplitSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("text")
    {
        Source = "/document/merged_text"
    });
    inputMappings.Add(new InputFieldMappingEntry("languageCode")
    {
        Source = "/document/languageCode"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("textItems")
    {
        TargetName = "pages",
    });

    SplitSkill splitSkill = new SplitSkill(inputMappings, outputMappings)
    {
        Description = "Split content into pages",
        Context = "/document",
        TextSplitMode = TextSplitMode.Pages,
        MaximumPageLength = 4000,
        DefaultLanguageCode = SplitSkillLanguage.En
    };

    return splitSkill;
}

Entitásfelismerési képesség

Ez EntityRecognitionSkill a példány úgy van beállítva, hogy felismerje a kategóriatípust. organization A EntityRecognitionSkill a és kategóriatípusokat is person képes location felismerni.

Figyelje meg, hogy a "környezet" mező egy csillaggal van beállítva, ami azt jelenti, hogy a gazdagítási lépés minden oldalhoz meg lesz "/document/pages/*" hívva a "/document/pages" alatt.

private static EntityRecognitionSkill CreateEntityRecognitionSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("text")
    {
        Source = "/document/pages/*"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("organizations")
    {
        TargetName = "organizations"
    });

    EntityRecognitionSkill entityRecognitionSkill = new EntityRecognitionSkill(inputMappings, outputMappings)
    {
        Description = "Recognize organizations",
        Context = "/document/pages/*",
        DefaultLanguageCode = EntityRecognitionSkillLanguage.En
    };
    entityRecognitionSkill.Categories.Add(EntityCategory.Organization);

    return entityRecognitionSkill;
}

Kulcskifejezés-kinyerési képesség

Az újonnan létrehozott példányhoz hasonló a EntityRecognitionSkill KeyPhraseExtractionSkill a lesz hívva a dokumentum minden oldalára.

private static KeyPhraseExtractionSkill CreateKeyPhraseExtractionSkill()
{
    List<InputFieldMappingEntry> inputMappings = new List<InputFieldMappingEntry>();
    inputMappings.Add(new InputFieldMappingEntry("text")
    {
        Source = "/document/pages/*"
    });
    inputMappings.Add(new InputFieldMappingEntry("languageCode")
    {
        Source = "/document/languageCode"
    });

    List<OutputFieldMappingEntry> outputMappings = new List<OutputFieldMappingEntry>();
    outputMappings.Add(new OutputFieldMappingEntry("keyPhrases")
    {
        TargetName = "keyPhrases"
    });

    KeyPhraseExtractionSkill keyPhraseExtractionSkill = new KeyPhraseExtractionSkill(inputMappings, outputMappings)
    {
        Description = "Extract the key phrases",
        Context = "/document/pages/*",
        DefaultLanguageCode = KeyPhraseExtractionSkillLanguage.En
    };

    return keyPhraseExtractionSkill;
}

A képességkészlet létrehozása és létrehozása

A létrehozott SearchIndexerSkillset készségek használatával építse ki a et.

private static SearchIndexerSkillset CreateOrUpdateDemoSkillSet(SearchIndexerClient indexerClient, IList<SearchIndexerSkill> skills,string cognitiveServicesKey)
{
    SearchIndexerSkillset skillset = new SearchIndexerSkillset("demoskillset", skills)
    {
        Description = "Demo skillset",
        CognitiveServicesAccount = new CognitiveServicesAccountKey(cognitiveServicesKey)
    };

    // Create the skillset in your search service.
    // The skillset does not need to be deleted if it was already created
    // since we are using the CreateOrUpdate method
    try
    {
        indexerClient.CreateOrUpdateSkillset(skillset);
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine("Failed to create the skillset\n Exception message: {0}\n", ex.Message);
        ExitProgram("Cannot continue without a skillset");
    }

    return skillset;
}

Adja hozzá a következő sorokat a következő Main hez.

// Create the skills
Console.WriteLine("Creating the skills...");
OcrSkill ocrSkill = CreateOcrSkill();
MergeSkill mergeSkill = CreateMergeSkill();
EntityRecognitionSkill entityRecognitionSkill = CreateEntityRecognitionSkill();
LanguageDetectionSkill languageDetectionSkill = CreateLanguageDetectionSkill();
SplitSkill splitSkill = CreateSplitSkill();
KeyPhraseExtractionSkill keyPhraseExtractionSkill = CreateKeyPhraseExtractionSkill();

// Create the skillset
Console.WriteLine("Creating or updating the skillset...");
List<SearchIndexerSkill> skills = new List<SearchIndexerSkill>();
skills.Add(ocrSkill);
skills.Add(mergeSkill);
skills.Add(languageDetectionSkill);
skills.Add(splitSkill);
skills.Add(entityRecognitionSkill);
skills.Add(keyPhraseExtractionSkill);

SearchIndexerSkillset skillset = CreateOrUpdateDemoSkillSet(indexerClient, skills, cognitiveServicesKey);

3. lépés: Index létrehozása

Ebben a szakaszban egy indexsémát határoz meg a kereshető indexben szereplő mezők és az egyes mezők keresési attribútumainak megadásával. A mezők típussal is rendelkeznek, emellett olyan attribútumokat tartalmazhatnak, amelyek meghatározzák a mező használatának módját (kereshető, rendezhető stb.). Az indexben szereplő mezőneveknek nem kell pontosan megegyezniük a forrásban szereplő mezők nevével. Egy későbbi lépésben mezőleképezéseket fog hozzáadni egy indexelőhöz a forrás-cél mezőkhöz való csatlakozás céljából. Ebben a lépésben a keresőalkalmazásra vonatkozó mezőelnevezési konvenciók használatával határozza meg az indexet.

A gyakorlat során az alábbi mezőket és mezőtípusokat használjuk:

Mezőnevek Mezőtípusok
id Edm.String
content Edm.String
languageCode Edm.String
keyPhrases List<Edm.String>
organizations List<Edm.String>

DemoIndex osztály létrehozása

Az index mezői egy modellosztály használatával vannak definiálva. A modellosztály minden tulajdonsága olyan attribútumokkal rendelkezik, amelyek meghatározzák a vonatkozó indexmező kereséssel kapcsolatos viselkedéseit.

Hozzáadjuk a modellosztályt egy új C#-fájlhoz. Kattintson a jobb gombbal a projektre, és válassza az Új elem hozzáadása... lehetőséget, válassza az "Osztály" lehetőséget, adja a fájlnak a > DemoIndex.cs nevet, majd válassza a Hozzáadás lehetőséget.

Ügyeljen arra, hogy jelezze, hogy a és a névtér típusait Azure.Search.Documents.Indexes System.Text.Json.Serialization szeretné használni.

Adja hozzá az alábbi modellosztály-definíciót a fájlhoz, és adja hozzá ugyanoda a névtérbe, ahol DemoIndex.cs az indexet létre fogja hozni.

using Azure.Search.Documents.Indexes;
using System.Text.Json.Serialization;

namespace EnrichwithAI
{
    // The SerializePropertyNamesAsCamelCase is currently unsupported as of this writing. 
    // Replace it with JsonPropertyName
    public class DemoIndex
    {
        [SearchableField(IsSortable = true, IsKey = true)]
        [JsonPropertyName("id")]
        public string Id { get; set; }

        [SearchableField]
        [JsonPropertyName("content")]
        public string Content { get; set; }

        [SearchableField]
        [JsonPropertyName("languageCode")]
        public string LanguageCode { get; set; }

        [SearchableField]
        [JsonPropertyName("keyPhrases")]
        public string[] KeyPhrases { get; set; }

        [SearchableField]
        [JsonPropertyName("organizations")]
        public string[] Organizations { get; set; }
    }
}

Most, hogy definiált egy modellosztályt, elég egyszerűen létrehozhat Program.cs egy indexdefiníciót. Az index neve demoindex lesz. Ha már létezik ilyen nevű index, az törlődik.

private static SearchIndex CreateDemoIndex(SearchIndexClient indexClient)
{
    FieldBuilder builder = new FieldBuilder();
    var index = new SearchIndex("demoindex")
    {
        Fields = builder.Build(typeof(DemoIndex))
    };

    try
    {
        indexClient.GetIndex(index.Name);
        indexClient.DeleteIndex(index.Name);
    }
    catch (RequestFailedException ex) when (ex.Status == 404)
    {
        //if the specified index not exist, 404 will be thrown.
    }

    try
    {
        indexClient.CreateIndex(index);
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine("Failed to create the index\n Exception message: {0}\n", ex.Message);
        ExitProgram("Cannot continue without an index");
    }

    return index;
}

A tesztelés során előfordulhat, hogy egynél több alkalommal próbálja létrehozni az indexet. Ezért a létrehozási kísérlet előtt ellenőrizze, hogy létezik-e már a létrehozni kívánt index.

Adja hozzá a következő sorokat a következő Main hez.

// Create the index
Console.WriteLine("Creating the index...");
SearchIndex demoIndex = CreateDemoIndex(indexClient);

Adja hozzá a következő using utasítást a kétértelmű hivatkozás feloldásához.

using Index = Azure.Search.Documents.Indexes.Models;

További információ az indexekkel kapcsolatos fogalmakról: Index létrehozása (REST API).

4. lépés: Indexelő létrehozása és futtatása

Eddig létrehozott egy adatforrást, egy képességcsoportot és egy indexet. Ez a három összetevő egy olyan indexelő része lesz, amely az egyes részeket egyetlen többszakaszos műveletben egyesíti. A három rész egy indexelőben való egyesítéséhez mezőleképezéseket kell meghatároznia.

  • A fieldMappings a képességcsoport előtt lesz feldolgozva, és leképezi a forrásmezőket az adatforrásból egy index célmezőire. Ha a mezőnevek és -típusok azonosak mindkét végén, nincs szükség leképezésre.

  • Az outputFieldMappings a képességkészlet után lesz feldolgozva, és a nem létező sourceFieldNames kifejezésre hivatkozik, amíg létre nem hozza azokat a dokumentum feltörte vagy bővítette. A targetFieldName egy index egyik mezője.

A bemenetek kimenetekhez való összekötése mellett mezőleképezések is használhatók az adatstruktúrák el simítására. További információ: Bővített mezők leképezés kereshető indexre.

private static SearchIndexer CreateDemoIndexer(SearchIndexerClient indexerClient, SearchIndexerDataSourceConnection dataSource, SearchIndexerSkillset skillSet, SearchIndex index)
{
    IndexingParameters indexingParameters = new IndexingParameters()
    {
        MaxFailedItems = -1,
        MaxFailedItemsPerBatch = -1,
    };
    indexingParameters.Configuration.Add("dataToExtract", "contentAndMetadata");
    indexingParameters.Configuration.Add("imageAction", "generateNormalizedImages");

    SearchIndexer indexer = new SearchIndexer("demoindexer", dataSource.Name, index.Name)
    {
        Description = "Demo Indexer",
        SkillsetName = skillSet.Name,
        Parameters = indexingParameters
    };

    FieldMappingFunction mappingFunction = new FieldMappingFunction("base64Encode");
    mappingFunction.Parameters.Add("useHttpServerUtilityUrlTokenEncode", true);

    indexer.FieldMappings.Add(new FieldMapping("metadata_storage_path")
    {
        TargetFieldName = "id",
        MappingFunction = mappingFunction

    });
    indexer.FieldMappings.Add(new FieldMapping("content")
    {
        TargetFieldName = "content"
    });

    indexer.OutputFieldMappings.Add(new FieldMapping("/document/pages/*/organizations/*")
    {
        TargetFieldName = "organizations"
    });
    indexer.OutputFieldMappings.Add(new FieldMapping("/document/pages/*/keyPhrases/*")
    {
        TargetFieldName = "keyPhrases"
    });
    indexer.OutputFieldMappings.Add(new FieldMapping("/document/languageCode")
    {
        TargetFieldName = "languageCode"
    });

    try
    {
        indexerClient.GetIndexer(indexer.Name);
        indexerClient.DeleteIndexer(indexer.Name);
    }
    catch (RequestFailedException ex) when (ex.Status == 404)
    {
        //if the specified indexer not exist, 404 will be thrown.
    }

    try
    {
        indexerClient.CreateIndexer(indexer);
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine("Failed to create the indexer\n Exception message: {0}\n", ex.Message);
        ExitProgram("Cannot continue without creating an indexer");
    }

    return indexer;
}

Adja hozzá a következő sorokat a következő Main hez.

// Create the indexer, map fields, and execute transformations
Console.WriteLine("Creating the indexer and executing the pipeline...");
SearchIndexer demoIndexer = CreateDemoIndexer(indexerClient, dataSource, skillset, demoIndex);

Az indexelő feldolgozása némi időt vehet igénybe. Annak ellenére, hogy az adatkészlet kis méretű, az analitikai képességek számítási igénye nagy. Néhány képesség, például a képelemzés futásideje hosszú.

Tipp

Az indexelő létrehozása elindítja a folyamatot. Ha probléma lép fel az adatok elérésével, a bemenetek és kimenetek leképezésével vagy a műveletek sorrendjével kapcsolatban, az ebben a szakaszban jelenik meg.

Ismerkedés az indexelő létrehozásával

A kód -1-re állítja az értékeket, amely arra utasítja az indexelőmotort, hogy hagyja figyelmen kívül az "maxFailedItems" adatimportálás során előforduló hibákat. Ez azért hasznos, mert az adatforrás kevés dokumentumot tartalmaz. Nagyobb méretű adatforrás esetén 0-nál nagyobb értéket kell megadnia.

Azt is figyelje "dataToExtract" meg, hogy a beállítása "contentAndMetadata" . Ez az utasítást meghatározza, hogy az indexelő automatikusan kinyerje a tartalmat a különböző fájlformátumokból, beleértve az egyes fájlokra vonatkozó metaadatokat is.

Tartalom kinyerésekor az imageAction beállításával kinyerheti a szöveget az adatforrásban talált képekből. Az OCR-készséggel és a Szövegegyesítési képességgel kombinálva a beállítás arra utasítja az indexelőt, hogy kinyerje a szöveget a képekből (például a "stop" szót egy forgalmi "imageAction" stop táblából), és a tartalommező részeként ágyazza "generateNormalizedImages" be. Ez a működés mind a dokumentumokban beágyazott képekre (például egy PDF-fájlban található képre), mind az adatforrásban talált képekre (például egy JPG-fájlra) vonatkozik.

4 – Indexelés monitorozása

Az indexelő meghatározását követően az indexelő a kérés elküldésekor automatikusan lefut. Az indexelés a vártnál tovább is eltarthat attól függően, hogy mely kognitív képességeket adta meg. Annak kiderítése, hogy az indexelő még fut-e, használja a GetStatus metódust.

private static void CheckIndexerOverallStatus(SearchIndexerClient indexerClient, SearchIndexer indexer)
{
    try
    {
        var demoIndexerExecutionInfo = indexerClient.GetIndexerStatus(indexer.Name);

        switch (demoIndexerExecutionInfo.Value.Status)
        {
            case IndexerStatus.Error:
                ExitProgram("Indexer has error status. Check the Azure Portal to further understand the error.");
                break;
            case IndexerStatus.Running:
                Console.WriteLine("Indexer is running");
                break;
            case IndexerStatus.Unknown:
                Console.WriteLine("Indexer status is unknown");
                break;
            default:
                Console.WriteLine("No indexer information");
                break;
        }
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine("Failed to get indexer overall status\n Exception message: {0}\n", ex.Message);
    }
}

demoIndexerExecutionInfo az indexelő aktuális állapotát és végrehajtási előzményeit jelöli.

A figyelmeztetések bizonyos forrásfájl- és képességkombinációk esetében gyakoriak, és nem mindig utalnak hibára. Ebben az oktatóanyagban a figyelmeztetések jóindulatúak (például nincs szöveges bemenet a JPEG-fájlokból).

Adja hozzá a következő sorokat a következő Main hez.

// Check indexer overall status
Console.WriteLine("Check the indexer overall status...");
CheckIndexerOverallStatus(indexerClient, demoIndexer);

Az Azure Cognitive Search oktatóanyagban általában 2 másodperces késleltetést alkalmazunk az eredményeket visszaadó lekérdezések futtatása előtt, de mivel a bővítés több percig is eltarthat, bezárjuk a konzolalkalmazást, és helyette egy másik módszert alkalmazunk.

A legegyszerűbb lehetőség a Keresési ablak a portálon. Először futtathat egy üres lekérdezést, amely visszaadja az összes dokumentumot, vagy egy célzottabb keresést, amely a folyamat által létrehozott új mezőtartalmat ad vissza.

  1. A Azure Portal keresés Áttekintés lapján válassza az Indexek lehetőséget.

  2. Keresse demoindex meg a listában. 14 dokumentumnak kell lennie. Ha a dokumentumszám nulla, az indexelő még mindig fut, vagy az oldal még nem lett frissítve.

  3. Válassza az demoindex lehetőséget. A Keresési ablak az első lap.

  4. A tartalom az első dokumentum betöltése után kereshető. A tartalom létezésének ellenőrzéséhez futtason egy nem meghatározott lekérdezést a Keresés gombra kattintva. Ez a lekérdezés visszaadja az összes jelenleg indexelt dokumentumot, így átlássa, mit tartalmaz az index.

  5. Ezután illessze be a következő sztringet a kezelhetőbb eredmények érdekében: search=*&$select=id, languageCode, organizations

Alaphelyzetbe állítás és ismételt futtatás

A fejlesztés korai kísérleti szakaszaiban a tervezési iteráció legpraktikusabb megközelítése az objektumok törlése a Azure Cognitive Search hogy a kód újraépítse őket. Az erőforrásnevek egyediek. Egy objektum törlése révén újból létrehozhatja azt ugyanazzal a névvel.

Az oktatóanyag mintakódja ellenőrzi a meglévő objektumokat, és törli őket, hogy újrafuttathatja a kódot. A portálon indexeket, indexelőket, adatforrásokat és képességkészleteket is törölhet.

Legfontosabb ismeretek

Ez az oktatóanyag bemutatta a bővített indexelési folyamat létrehozásának alapvető lépéseit az összetevők ( adatforrás, képességkészlet, index és indexelő) létrehozásával.

Bevezettük a beépített képességeket, a képességcsoport definícióját, valamint a képességek bemenetekkel és kimenetekkel való összefűzásának mechanizmusát. Azt is megtanulta, hogy az indexelő definíciójában szükség van a bővített értékek folyamatból egy kereshető indexbe való átirányításához egy Azure Cognitive Search outputFieldMappings szolgáltatásban.

Végül megismerte, hogyan tesztelheti az eredményeket, és hogyan állíthatja alaphelyzetbe a rendszert a későbbi futtatásokhoz. Megtanulta, hogy ha lekérdezéseket futtat az indexen, az a bővített indexelési folyamat által létrehozott kimenetet adja vissza. Emellett azt is megtanulta, hogyan ellenőrizheti az indexelő állapotát, illetve hogy melyik objektumokat kell törölnie a folyamat újrafuttatása előtt.

Az erőforrások eltávolítása

Amikor a saját előfizetésében dolgozik, a projekt végén jó ötlet eltávolítani azokat az erőforrásokat, amelyekre már nincs szüksége. A továbbra is futó erőforrások költségekkel járhatnak. Az erőforrásokat törölheti egyesével, vagy az erőforráscsoport törlésével eltávolíthatja a benne lévő összes erőforrást is.

Az erőforrásokat a portálon a bal oldali navigációs panel Minden erőforrás vagy Erőforráscsoport hivatkozásával találhatja meg és kezelheti.

Következő lépések

Most, hogy megismerkedett az AI-bővítő folyamat összes objektumával, közelebbről is megvizsgáljuk a képességcsoport-definíciókat és az egyéni képességeket.