Självstudie: använda .NET och AI för att generera sökbart innehåll från Azure-blobbarTutorial: Use .NET and AI to generate searchable content from Azure blobs

Om du har ostrukturerad text eller avbildningar i Azure Blob Storage kan en AI-pipeline utvinna information och skapa nytt innehåll för full texts ökning eller kunskaps utvinnings scenarier.If you have unstructured text or images in Azure Blob storage, an AI enrichment pipeline can extract information and create new content for full-text search or knowledge mining scenarios.

I den här självstudien får du lära dig hur man:In this tutorial, you will learn how to:

  • Konfigurera en utvecklings miljöSet up a development environment
  • Definiera en pipeline som använder OCR, språk identifiering och enhets-och nyckel fras igenkänning.Define a pipeline that uses OCR, language detection, and entity and key phrase recognition.
  • Kör pipelinen för att anropa transformationer och för att skapa och läsa in ett sökindex.Execute the pipeline to invoke transformations, and to create and load a search index.
  • Utforska resultat med fullständig texts ökning och en omfattande frågesyntax.Explore results using full text search and a rich query syntax.

Om du inte har någon Azure-prenumeration kan du öppna ett kostnads fritt konto innan du börjar.If you don't have an Azure subscription, open a free account before you begin.

ÖversiktOverview

I den här självstudien används C# och Azure.Search.Documents -klient biblioteket för att skapa en data källa, index, indexerare och färdigheter.This tutorial uses C# and the Azure.Search.Documents client library to create a data source, index, indexer, and skillset.

Indexeraren ansluter till en BLOB-behållare som anges i objektet data källa och skickar allt indexerat innehåll till ett befintligt sökindex.The indexer connects to a blob container that's specified in the data source object, and sends all indexed content to an existing search index.

Färdigheter är kopplad till indexeraren.The skillset is attached to the indexer. Den använder inbyggda kunskaper från Microsoft för att hitta och extrahera information.It uses built-in skills from Microsoft to find and extract information. Stegen i pipelinen inkluderar optisk tecken läsning (OCR) på bilder, språk identifiering på text, extrahering av nyckel fraser och enhets igenkänning (organisationer).Steps in the pipeline include Optical Character Recognition (OCR) on images, language detection on text, key phrase extraction, and entity recognition (organizations). Ny information som skapas av pipelinen lagras i nya fält i ett index.New information created by the pipeline is stored in new fields in an index. När indexet har fyllts kan du använda fälten i frågor, ansikts och filter.Once the index is populated, you can use the fields in queries, facets, and filters.

FörutsättningarPrerequisites

Anteckning

Du kan använda den kostnads fria Sök tjänsten för den här självstudien.You can use the free search service for this tutorial. En kostnads fri Sök tjänst begränsar dig till tre index, tre indexerare och tre data källor.A free search service limits you to three indexes, three indexers, and three data sources. I den här kursen skapar du en av varje.This tutorial creates one of each. Innan du börjar bör du kontrol lera att du har utrymme på tjänsten för att godkänna de nya resurserna.Before starting, make sure you have room on your service to accept the new resources.

Hämta exempeldataDownload sample data

Exempel data består av 14 filer av blandad innehålls typ som du kommer att överföra till Azure Blob Storage i ett senare steg.The sample data consists of 14 files of mixed content type that you will upload to Azure Blob storage in a later step.

  1. Öppna den här OneDrive-mappen och klicka på Ladda ned i det övre vänstra hörnet för att kopiera filerna till datorn.Open this OneDrive folder and on the top-left corner, click Download to copy the files to your computer.

  2. Högerklicka på zip-filen och välj extrahera alla.Right-click the zip file and select Extract All. Det finns 14 filer av olika typer.There are 14 files of various types. Du använder 7 för den här övningen.You'll use 7 for this exercise.

Du kan också ladda ned käll koden för den här självstudien.You can also download the source code for this tutorial. Käll koden finns i självstudien – AI-anrikning/V11 -mappen i Azure-Search-dotNet-samples -lagringsplatsen.Source code is in the tutorial-ai-enrichment/v11 folder in the azure-search-dotnet-samples repository.

1 – skapa tjänster1 - Create services

I den här självstudien används Azure Kognitiv sökning för indexering och frågor, Cognitive Services på Server delen för AI-anrikning och Azure Blob Storage för att tillhandahålla data.This tutorial uses Azure Cognitive Search for indexing and queries, Cognitive Services on the backend for AI enrichment, and Azure Blob storage to provide the data. Den här självstudien finns kvar under den kostnads fria allokeringen av 20 transaktioner per indexerare per dag på Cognitive Services, så de enda tjänsterna du behöver skapa är Sök och lagring.This tutorial stays under the free allocation of 20 transactions per indexer per day on Cognitive Services, so the only services you need to create are search and storage.

Skapa om möjligt både i samma region och resurs grupp för närhet och hanterbarhet.If possible, create both in the same region and resource group for proximity and manageability. I praktiken kan ditt Azure Storage-konto finnas i vilken region som helst.In practice, your Azure Storage account can be in any region.

Börja med Azure StorageStart with Azure Storage

  1. Logga in på Azure Portal och klicka på + skapa resurs.Sign in to the Azure portal and click + Create Resource.

  2. Sök efter lagrings konto och välj Microsofts erbjudande för lagrings konto.Search for storage account and select Microsoft's Storage Account offering.

    Skapa lagrings kontoCreate Storage account

  3. På fliken grundläggande måste följande objekt vara obligatoriska.In the Basics tab, the following items are required. Acceptera standardvärdena för allt annat.Accept the defaults for everything else.

    • Resursgrupp.Resource group. Välj en befintlig eller skapa en ny, men Använd samma grupp för alla tjänster så att du kan hantera dem tillsammans.Select an existing one or create a new one, but use the same group for all services so that you can manage them collectively.

    • Namn på lagringskonto.Storage account name. Om du tror att du kan ha flera resurser av samma typ, använder du namnet på disambiguate efter typ och region, till exempel blobstoragewestus.If you think you might have multiple resources of the same type, use the name to disambiguate by type and region, for example blobstoragewestus.

    • Plats.Location. Om möjligt väljer du samma plats som används för Azure Kognitiv sökning och Cognitive Services.If possible, choose the same location used for Azure Cognitive Search and Cognitive Services. Med en enda plats annulleras bandbredds avgifter.A single location voids bandwidth charges.

    • Typ av konto.Account Kind. Välj standard, StorageV2 (generell användning v2).Choose the default, StorageV2 (general purpose v2).

  4. Klicka på Granska + skapa för att skapa tjänsten.Click Review + Create to create the service.

  5. När den har skapats klickar du på gå till resursen för att öppna översikts sidan.Once it's created, click Go to the resource to open the Overview page.

  6. Klicka på blobs -tjänsten.Click Blobs service.

  7. Klicka på + container för att skapa en behållare och ge den namnet kugg hjuls-search-demo.Click + Container to create a container and name it cog-search-demo.

  8. Välj kugg hjuls-search-demo och klicka sedan på Ladda upp för att öppna mappen där du sparade nedladdnings filerna.Select cog-search-demo and then click Upload to open the folder where you saved the download files. Välj alla fjorton filer och klicka på OK för att ladda upp.Select all fourteen files and click OK to upload.

    Ladda upp exempelfilerUpload sample files

  9. Innan du lämnar Azure Storage får du en anslutnings sträng så att du kan formulera en anslutning i Azure Kognitiv sökning.Before you leave Azure Storage, get a connection string so that you can formulate a connection in Azure Cognitive Search.

    1. Gå tillbaka till sidan Översikt för ditt lagrings konto (vi använde blobstoragewestus som exempel).Browse back to the Overview page of your storage account (we used blobstoragewestus as an example).

    2. I det vänstra navigerings fönstret väljer du åtkomst nycklar och kopierar en av anslutnings strängarna.In the left navigation pane, select Access keys and copy one of the connection strings.

    Anslutnings strängen är en URL som liknar följande exempel:The connection string is a URL similar to the following example:

    DefaultEndpointsProtocol=https;AccountName=blobstoragewestus;AccountKey=<your account key>;EndpointSuffix=core.windows.net
    
  10. Spara anslutnings strängen i anteckningar.Save the connection string to Notepad. Du behöver det senare när du konfigurerar anslutningen till data källan.You'll need it later when setting up the data source connection.

Cognitive ServicesCognitive Services

AI-berikning backas upp av Cognitive Services, inklusive Textanalys och Visuellt innehåll för naturligt språk och bild bearbetning.AI enrichment is backed by Cognitive Services, including Text Analytics and Computer Vision for natural language and image processing. Om målet var att slutföra en faktisk prototyp eller ett projekt, skulle du i den här punkten etablera Cognitive Services (i samma region som Azure Kognitiv sökning) så att du kan koppla den till indexerings åtgärder.If your objective was to complete an actual prototype or project, you would at this point provision Cognitive Services (in the same region as Azure Cognitive Search) so that you can attach it to indexing operations.

I den här övningen kan du hoppa över resurs etableringen eftersom Azure Kognitiv sökning kan ansluta till Cognitive Services bakom kulisserna och ge dig 20 kostnads fria transaktioner per indexerare.For this exercise, however, you can skip resource provisioning because Azure Cognitive Search can connect to Cognitive Services behind the scenes and give you 20 free transactions per indexer run. Eftersom den här självstudien använder 14 transaktioner är den kostnads fria fördelningen tillräckligt.Since this tutorial uses 14 transactions, the free allocation is sufficient. För större projekt bör du planera för etablering Cognitive Services på S0-nivån betala per användning.For larger projects, plan on provisioning Cognitive Services at the pay-as-you-go S0 tier. Mer information finns i bifoga Cognitive Services.For more information, see Attach Cognitive Services.

Den tredje komponenten är Azure Kognitiv sökning, som du kan skapa i portalen eller hitta en befintlig Sök tjänst i din prenumeration.The third component is Azure Cognitive Search, which you can create in the portal or find an existing search service in your subscription.

Du kan använda den kostnads fria nivån för att slutföra den här genom gången.You can use the Free tier to complete this walkthrough.

Om du vill interagera med din Azure Kognitiv sökning-tjänst behöver du tjänst-URL: en och en åtkomst nyckel.To interact with your Azure Cognitive Search service you will need the service URL and an access key. En Sök tjänst skapas med båda, så om du har lagt till Azure-Kognitiv sökning till din prenumeration följer du dessa steg för att få den information som krävs:A search service is created with both, so if you added Azure Cognitive Search to your subscription, follow these steps to get the necessary information:

  1. Loggain på Azure Portal och hämta URL: en på sidan Översikt över Sök tjänsten.Sign in to the Azure portal, and in your search service Overview page, get the URL. Här följer ett exempel på hur en slutpunkt kan se ut: https://mydemo.search.windows.net.An example endpoint might look like https://mydemo.search.windows.net.

  2. I Inställningar > nycklar, kopierar du en administratörs nyckel för fullständiga rättigheter till tjänsten.In Settings > Keys, copy an admin key for full rights on the service. Det finns två utbytbara administratörs nycklar, som tillhandahålls för affärs kontinuitet om du behöver rulla en över.There are two interchangeable admin keys, provided for business continuity in case you need to roll one over. Du kan använda antingen den primära eller sekundära nyckeln på begär Anden för att lägga till, ändra och ta bort objekt.You can use either the primary or secondary key on requests for adding, modifying, and deleting objects.

    Hämta även frågans nyckel.Get the query key as well. Det är en bra idé att utfärda förfrågningar med skrivskyddad åtkomst.It's a best practice to issue query requests with read-only access.

    Hämta tjänstens namn och administratör och fråge nycklar

En giltig nyckel upprättar förtroende, i varje begäran, mellan programmet som skickar begäran och tjänsten som hanterar den.Having a valid key establishes trust, on a per request basis, between the application sending the request and the service that handles it.

2 – Konfigurera din miljö2 - Set up your environment

Börja med att öppna Visual Studio och skapa ett nytt konsol program som kan köras på .NET Core.Begin by opening Visual Studio and creating a new Console App project that can run on .NET Core.

Installera Azure.Search.DocumentsInstall Azure.Search.Documents

Azure kognitiv sökning .NET SDK består av ett klient bibliotek som gör att du kan hantera dina index, data källor, indexerare och färdighetsuppsättningar, samt överföra och hantera dokument och köra frågor, allt utan att du behöver hantera informationen om http och JSON.The Azure Cognitive Search .NET SDK consists of a client library that enables you to manage your indexes, data sources, indexers, and skillsets, as well as upload and manage documents and execute queries, all without having to deal with the details of HTTP and JSON. Det här klient biblioteket distribueras som ett NuGet-paket.This client library is distributed as a NuGet package.

För det här projektet installerar du version 11 eller senare av Azure.Search.Documents och den senaste versionen av Microsoft.Extensions.Configuration .For this project, install version 11 or later of the Azure.Search.Documents and the latest version of Microsoft.Extensions.Configuration.

  1. I Visual Studio väljer du verktyg > NuGet Package Manager > Hantera NuGet-paket för lösning...In Visual Studio, select Tools > NuGet Package Manager > Manage NuGet Packages for Solution...

  2. Bläddra efter Azure.Search.Document.Browse for Azure.Search.Document.

  3. Välj den senaste versionen och klicka sedan på Installera.Select the latest version and then click Install.

  4. Upprepa föregående steg för att installera Microsoft.Extensions.Configuration och Microsoft.Extensions.Configuration.Jspå.Repeat the previous steps to install Microsoft.Extensions.Configuration and Microsoft.Extensions.Configuration.Json.

Lägg till information om tjänst anslutningAdd service connection information

  1. Högerklicka på ditt projekt i Solution Explorer och välj Lägg till > nytt objekt. ...Right-click on your project in the Solution Explorer and select Add > New Item... .

  2. Ge filen ett namn appsettings.json och välj Lägg till.Name the file appsettings.json and select Add.

  3. Ta med den här filen i din utmatnings katalog.Include this file in your output directory.

    1. Högerklicka på appsettings.json och välj Egenskaper.Right-click on appsettings.json and select Properties.
    2. Ändra värdet för Kopiera till utdatakatalogen för att Kopiera om det är nyare.Change the value of Copy to Output Directory to Copy if newer.
  4. Kopiera nedanstående JSON till din nya JSON-fil.Copy the below JSON into your new JSON file.

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

Lägg till din Sök tjänst och information om Blob Storage-kontot.Add your search service and blob storage account information. Kom ihåg att du kan hämta den här informationen från tjänst etablerings stegen som anges i föregående avsnitt.Recall that you can get this information from the service provisioning steps indicated in the previous section.

Ange den fullständiga URL: en för SearchServiceUri.For SearchServiceUri, enter the full URL.

Lägg till namn områdenAdd namespaces

I Program.cs lägger du till följande namn rymder.In Program.cs, add the following namespaces.

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

Skapa en klientCreate a client

Skapa en instans av en SearchIndexClient och en SearchIndexerClient under Main .Create an instance of a SearchIndexClient and a SearchIndexerClient under Main.

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

Anteckning

Klienterna ansluter till din Sök tjänst.The clients connect to your search service. För att undvika att öppna för många anslutningar bör du försöka att dela en enda instans i programmet om det är möjligt.In order to avoid opening too many connections, you should try to share a single instance in your application if possible. Metoderna är tråd säkra för att aktivera sådan delning.The methods are thread-safe to enable such sharing.

Lägg till funktion för att avsluta programmet under ett haveri lägeAdd function to exit the program during failure

Den här självstudien är avsedd att hjälpa dig att förstå varje steg i indexerings pipelinen.This tutorial is meant to help you understand each step of the indexing pipeline. Om det finns ett allvarligt problem som hindrar programmet från att skapa data källan, färdigheter, index eller indexerare, kommer programmet att generera fel meddelandet och avsluta så att problemet kan tolkas och åtgärdas.If there is a critical issue that prevents the program from creating the data source, skillset, index, or indexer the program will output the error message and exit so that the issue can be understood and addressed.

Lägg till i ExitProgram Main för att hantera scenarier som kräver att programmet avslutas.Add ExitProgram to Main to handle scenarios that require the program to exit.

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 – skapa pipelinen3 - Create the pipeline

I Azure Kognitiv sökning sker AI-bearbetning under indexering (eller data inmatning).In Azure Cognitive Search, AI processing occurs during indexing (or data ingestion). I den här delen av genom gången skapas fyra objekt: data källa, index definition, färdigheter, indexerare.This part of the walkthrough creates four objects: data source, index definition, skillset, indexer.

Steg 1: Skapa en datakällaStep 1: Create a data source

SearchIndexerClient har en DataSourceName egenskap som du kan ange till ett SearchIndexerDataSourceConnection objekt.SearchIndexerClient has a DataSourceName property that you can set to a SearchIndexerDataSourceConnection object. Det här objektet innehåller alla metoder som du behöver för att skapa, Visa, uppdatera eller ta bort Azure Kognitiv sökning data källor.This object provides all the methods you need to create, list, update, or delete Azure Cognitive Search data sources.

Skapa en ny SearchIndexerDataSourceConnection instans genom att anropa indexerClient.CreateOrUpdateDataSourceConnection(dataSource) .Create a new SearchIndexerDataSourceConnection instance by calling indexerClient.CreateOrUpdateDataSourceConnection(dataSource). Följande kod skapar en data källa av typen AzureBlob .The following code creates a data source of type AzureBlob.

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;
}

För att begäran ska lyckas returnerar metoden den data källa som skapades.For a successful request, the method will return the data source that was created. Om det uppstår ett problem med begäran, till exempel en ogiltig parameter, kommer metoden att utlösa ett undantag.If there is a problem with the request, such as an invalid parameter, the method will throw an exception.

Nu kan du lägga till en rad i Main för att anropa den CreateOrUpdateDataSource funktion som du just har lagt till.Now add a line in Main to call the CreateOrUpdateDataSource function that you've just added.

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

Skapa och kör lösningen.Build and run the solution. Eftersom det här är din första förfrågan kontrollerar du Azure Portal för att bekräfta att data källan har skapats i Azure Kognitiv sökning.Since this is your first request, check the Azure portal to confirm the data source was created in Azure Cognitive Search. På sidan Search Service-Översikt kontrollerar du att listan med data källor har ett nytt objekt.On the search service overview page, verify the Data Sources list has a new item. Du kan behöva vänta några minuter medan portalsidan uppdateras.You might need to wait a few minutes for the portal page to refresh.

Panelen data källor i portalenData sources tile in the portal

Steg 2: skapa en färdigheterStep 2: Create a skillset

I det här avsnittet definierar du en uppsättning med anriknings steg som du vill använda för dina data.In this section, you define a set of enrichment steps that you want to apply to your data. Varje anriknings steg kallas en färdighet och en uppsättning av anriknings steg, en färdigheter.Each enrichment step is called a skill and the set of enrichment steps, a skillset. I den här självstudien används inbyggda kognitiva kunskaper för färdigheter:This tutorial uses built-in cognitive skills for the skillset:

  • Optisk tecken läsning för att identifiera skriven och handskriven text i bildfiler.Optical Character Recognition to recognize printed and handwritten text in image files.

  • Text sammanslagning för att konsolidera text från en samling fält till ett enda fält.Text Merger to consolidate text from a collection of fields into a single field.

  • Språkidentifiering för att identifiera innehållets språk.Language Detection to identify the content's language.

  • Text delning för att dela upp stor mängd innehåll i mindre segment innan du anropar nyckel frasens extraherings kunskap och enhets igenkännings kompetensen.Text Split to break large content into smaller chunks before calling the key phrase extraction skill and the entity recognition skill. Extrahering av nyckel fraser och entitets igenkänning accepterar indata på högst 50 000 tecken.Key phrase extraction and entity recognition accept inputs of 50,000 characters or less. Några av exempelfilerna måste delas upp för att rymmas inom gränsen.A few of the sample files need splitting up to fit within this limit.

  • Enhets igenkänning för extrahering av namn på organisationer från innehåll i BLOB-behållaren.Entity Recognition for extracting the names of organizations from content in the blob container.

  • Extrahering av nyckelfraser för att hämta viktigaste nyckelfraserna.Key Phrase Extraction to pull out the top key phrases.

Under den inledande bearbetningen knäcker Azure Kognitiv sökning varje dokument för att extrahera innehåll från olika fil format.During initial processing, Azure Cognitive Search cracks each document to extract content from different file formats. Text som kommer från käll filen placeras i ett genererat content fält, en för varje dokument.Text originating in the source file is placed into a generated content field, one for each document. Därför måste du ange inmatade värden som "/document/content" Använd den här texten.As such, set the input as "/document/content" to use this text. Bild innehåll placeras i ett genererat normalized_images fält som anges i en färdigheter som /document/normalized_images/* .Image content is placed into a generated normalized_images field, specified in a skillset as /document/normalized_images/*.

Utdata kan mappas till ett index som används som indata till en underordnad kunskap, eller både, vilket är fallet med språkkod.Outputs can be mapped to an index, used as input to a downstream skill, or both as is the case with language code. I indexet kan en språkkod användas för filtrering.In the index, a language code is useful for filtering. Som indata används språkkoden av textanalyskunskaper för att informera om de språkliga reglerna kring ordnedbrytning.As an input, language code is used by text analysis skills to inform the linguistic rules around word breaking.

Mer information om grunderna i kunskapsuppsättningar finns i Definiera en kunskapsuppsättning.For more information about skillset fundamentals, see How to define a skillset.

OCR-kunskaperOCR skill

OCR -kompetensen extraherar text från bilder.The OCR skill extracts text from images. Den här kunskapen förutsätter att det finns ett normalized_images fält.This skill assumes that a normalized_images field exists. Om du vill generera det här fältet senare i självstudien ställer vi in "imageAction" konfigurationen i indexerings definitionen till "generateNormalizedImages" .To generate this field, later in the tutorial we'll set the "imageAction" configuration in the indexer definition to "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;
}

Sammanfoga kunskaperMerge skill

I det här avsnittet ska du skapa en sammanfogad färdighet som sammanfogar dokumentets innehålls fält med den text som har producerats av OCR-kunskaper.In this section, you'll create a Merge skill that merges the document content field with the text that was produced by the OCR skill.

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;
}

Kunskap om språk identifieringLanguage detection skill

Språkidentifiering -kunskapen identifierar språket i inmatad text och rapporterar en enda språkkod för varje dokument som skickas på begäran.The Language Detection skill detects the language of the input text and reports a single language code for every document submitted on the request. Vi ska använda utdata från språkidentifiering -kompetensen som en del av indata för text delnings färdigheten.We'll use the output of the Language Detection skill as part of the input to the Text Split skill.

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;
}

Text delnings kunskaperText split skill

Den delade kunskapen nedan delar upp text efter sidor och begränsar sid längden till 4 000 tecken som mäts av String.Length .The below Split skill will split text by pages and limit the page length to 4,000 characters as measured by String.Length. Algoritmen försöker dela upp texten i segment som har störst maximumPageLength storlek.The algorithm will try to split the text into chunks that are at most maximumPageLength in size. I det här fallet gör algoritmen det bästa sättet att dela upp meningen på en mening, så storleken på segmentet kan vara något mindre än maximumPageLength .In this case, the algorithm will do its best to break the sentence on a sentence boundary, so the size of the chunk may be slightly less than 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;
}

Kompetens för enhets igenkänningEntity recognition skill

Den här EntityRecognitionSkill instansen är inställd på att identifiera kategori typ organization .This EntityRecognitionSkill instance is set to recognize category type organization. Entitetens igenkännings förmåga kan också identifiera kategori typer person och location .The Entity Recognition skill can also recognize category types person and location.

Observera att fältet "context" är inställt på "/document/pages/*" med en asterisk, vilket innebär att ett anriknings steg anropas för varje sida under "/document/pages" .Notice that the "context" field is set to "/document/pages/*" with an asterisk, meaning the enrichment step is called for each page under "/document/pages".

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;
}

Extraherings färdighet för nyckel fraserKey phrase extraction skill

Precis som den EntityRecognitionSkill instans som precis skapades, anropas extrahering av diskussionsämne -kompetens för varje sida i dokumentet.Like the EntityRecognitionSkill instance that was just created, the Key Phrase Extraction skill is called for each page of the document.

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;
}

Skapa och skapa färdigheterBuild and create the skillset

Skapa Skillset med hjälp av de kunskaper du har skapat.Build the Skillset using the skills you created.

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;
}

Lägg till följande rader i Main .Add the following lines to Main.

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

Steg 3: skapa ett indexStep 3: Create an index

I det här avsnittet definierar du indexschemat genom att ange vilka fält som ska ingå i det sökbara indexet och sökattributen för varje fält.In this section, you define the index schema by specifying which fields to include in the searchable index, and the search attributes for each field. Fält har en typ och kan ta attribut som bestämmer hur fältet ska användas (sökbart, sorteringsbart och så vidare).Fields have a type and can take attributes that determine how the field is used (searchable, sortable, and so forth). Fältnamn i ett index krävs inte för att matcha fältnamn identiskt i källan.Field names in an index are not required to identically match the field names in the source. I ett senare steg lägger du till fältmappningar i en indexerare för att ansluta källa-mål-fält.In a later step, you add field mappings in an indexer to connect source-destination fields. För det här steget definiera indexet med fältnamnkonventioner som är relevanta för ditt sökprogram.For this step, define the index using field naming conventions pertinent to your search application.

Den här övningen använder följande fält och fälttyp:This exercise uses the following fields and field types:

Fält namnField names FälttyperField types
id Edm.StringEdm.String
content Edm.StringEdm.String
languageCode Edm.StringEdm.String
keyPhrases List<Edm.String>List<Edm.String>
organizations List<Edm.String>List<Edm.String>

Skapa DemoIndex-klassCreate DemoIndex Class

Fält för det här indexet definieras med en modell klass.The fields for this index are defined using a model class. Varje egenskap i modellklassen har attribut som avgör motsvarande indexfälts sökrelaterade beteende.Each property of the model class has attributes which determine the search-related behaviors of the corresponding index field.

Vi ska lägga till modell klassen i en ny C#-fil.We'll add the model class to a new C# file. Högerklicka på projektet och välj Lägg till > nytt objekt..., välj "klass" och ge filen ett namn och DemoIndex.cs Välj sedan Lägg till.Right click on your project and select Add > New Item..., select "Class" and name the file DemoIndex.cs, then select Add.

Se till att ange att du vill använda typer från Azure.Search.Documents.Indexes System.Text.Json.Serialization namn områdena och.Make sure to indicate that you want to use types from the Azure.Search.Documents.Indexes and System.Text.Json.Serialization namespaces.

Lägg till modell klass definitionen nedan DemoIndex.cs och inkludera den i samma namn område där du skapar indexet.Add the below model class definition to DemoIndex.cs and include it in the same namespace where you'll create the index.

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; }
    }
}

Nu när du har definierat en modell klass Program.cs kan du skapa en index definition på ett ganska enkelt sätt i igen.Now that you've defined a model class, back in Program.cs you can create an index definition fairly easily. Namnet på det här indexet kommer att vara demoindex .The name for this index will be demoindex. Om det redan finns ett index med det namnet tas det bort.If an index already exists with that name, it will be deleted.

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;
}

Under testningen kanske du upptäcker att du försöker skapa indexet mer än en gång.During testing, you may find that you're attempting to create the index more than once. Därför bör du kontrol lera om det index som du håller på att skapa redan finns innan du försöker skapa det.Because of this, check to see if the index that you're about to create already exists before attempting to create it.

Lägg till följande rader i Main .Add the following lines to Main.

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

Lägg till följande using-instruktion för att lösa disambiguate-referensen.Add the following using statement to resolve the disambiguate reference.

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

Mer information om index koncept finns i skapa index (REST API).To learn more about index concepts, see Create Index (REST API).

Steg 4: skapa och köra en indexerareStep 4: Create and run an indexer

Hittills har du skapat en datakälla, en kunskapsuppsättning och ett index.So far you have created a data source, a skillset, and an index. De här tre komponenterna blir en del av en indexerare som sammanför varje del till en enda åtgärd i flera faser.These three components become part of an indexer that pulls each piece together into a single multi-phased operation. Om du vill sammanfoga dem i en indexerare måste du definiera fältmappningar.To tie these together in an indexer, you must define field mappings.

  • FieldMappings bearbetas före färdigheter och mappar käll fälten från data källan till mål fälten i ett index.The fieldMappings are processed before the skillset, mapping source fields from the data source to target fields in an index. Om fält namn och typer är desamma i båda ändar, krävs ingen mappning.If field names and types are the same at both ends, no mapping is required.

  • OutputFieldMappings bearbetas efter färdigheter, refererar till sourceFieldNames som inte finns förrän dokument sprickor eller berikning skapar dem.The outputFieldMappings are processed after the skillset, referencing sourceFieldNames that don't exist until document cracking or enrichment creates them. TargetFieldName är ett fält i ett index.The targetFieldName is a field in an index.

Förutom att koppla upp indata till utdata kan du också använda fält mappningar för att förenkla data strukturer.In addition to hooking up inputs to outputs, you can also use field mappings to flatten data structures. Mer information finns i så här mappar du berikade fält till ett sökbart index.For more information, see How to map enriched fields to a searchable index.

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;
}

Lägg till följande rader i Main .Add the following lines to Main.

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

Det kan ta lite tid att slutföra indexerings bearbetningen.Expect indexer processing to take some time to complete. Trots att datauppsättningen är liten är analytiska kunskaper beräkningsintensiva.Even though the data set is small, analytical skills are computation-intensive. Vissa kunskaper, som bildanalys, är tidskrävande.Some skills, such as image analysis, are long-running.

Tips

När en indexerare skapas anropas pipelinen.Creating an indexer invokes the pipeline. Om det uppstår problem med att ansluta till data, mappningsindata eller -utdata eller ordningen på åtgärder visas dem i det här stadiet.If there are problems reaching the data, mapping inputs and outputs, or order of operations, they appear at this stage.

Utforska hur du skapar indexerarenExplore creating the indexer

Kod uppsättningen "maxFailedItems" till-1, som instruerar indexerings motorn att ignorera fel vid data import.The code sets "maxFailedItems" to -1, which instructs the indexing engine to ignore errors during data import. Detta är användbart eftersom det finns det så få dokument i demo-datakällan.This is useful because there are so few documents in the demo data source. För en större datakälla skulle du ställa in värdet på större än 0.For a larger data source, you would set the value to greater than 0.

Observera också "dataToExtract" att är inställt på "contentAndMetadata" .Also notice the "dataToExtract" is set to "contentAndMetadata". Den här instruktionen anger att indexeraren automatiskt ska extrahera innehållet från olika filformat samt metadata som är relaterade till varje fil.This statement tells the indexer to automatically extract the content from different file formats as well as metadata related to each file.

När innehållet har extraherats kan du ställa in imageAction på att extrahera text från avbildningar som hittades i datakällan.When content is extracted, you can set imageAction to extract text from images found in the data source. "imageAction" "generateNormalizedImages" Konfigurationen är inställd på konfiguration, kombinerat med OCR-kunskaper och text kopplings kunskap, och anger att indexeraren ska extrahera text från bilderna (till exempel ordet "Stop" från ett trafik stopp) och bädda in det som en del av innehålls fältet.The "imageAction" set to "generateNormalizedImages" configuration, combined with the OCR Skill and Text Merge Skill, tells the indexer to extract text from the images (for example, the word "stop" from a traffic Stop sign), and embed it as part of the content field. Det här beteendet gäller både avbildningarna som är inbäddade i dokumenten (tänk på en avbildning i en PDF) samt avbildningar som hittas i datakällan, till exempel en JPG-fil.This behavior applies to both the images embedded in the documents (think of an image inside a PDF), as well as images found in the data source, for instance a JPG file.

4 – övervaka indexering4 - Monitor indexing

När du har definierat indexeraren körs den automatiskt när du skickar din begäran.Once the indexer is defined, it runs automatically when you submit the request. Beroende på vilka kognitiva kunskaper du har definierat kan indexeringen ta längre tid än väntat.Depending on which cognitive skills you defined, indexing can take longer than you expect. Använd metoden för att ta reda på om indexeraren fortfarande körs GetStatus .To find out whether the indexer is still running, use the GetStatus method.

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 visar aktuell status och körnings historik för en indexerare.demoIndexerExecutionInfo represents the current status and execution history of an indexer.

Varningar är vanliga med vissa källfils- och kunskapskombinationer och är inte alltid tecken på problem.Warnings are common with some source file and skill combinations and do not always indicate a problem. I den här självstudien är varningarna ofarliga (till exempel inga textindata från JPEG-filerna).In this tutorial, the warnings are benign (for example, no text inputs from the JPEG files).

Lägg till följande rader i Main .Add the following lines to Main.

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

I Azure Kognitiv sökning själv studie konsol appar lägger vi vanligt vis till en fördröjning på 2 sekunder innan du kör frågor som returnerar resultat, men eftersom det tar flera minuter att slutföra den här processen, stängs konsolen och en annan metod används i stället.In Azure Cognitive Search tutorial console apps, we typically add a 2-second delay before running queries that return results, but because enrichment takes several minutes to complete, we'll close the console app and use another approach instead.

Det enklaste alternativet är Sök Utforskaren i portalen.The easiest option is Search explorer in the portal. Du kan först köra en tom fråga som returnerar alla dokument eller en mer riktad sökning som returnerar nytt fält innehåll som skapats av pipelinen.You can first run an empty query that returns all documents, or a more targeted search that returns new field content created by the pipeline.

  1. I Azure Portal går du till sidan Sök översikt och väljer index.In Azure portal, in the search Overview page, select Indexes.

  2. Sök demoindex i listan.Find demoindex in the list. Den bör ha 14 dokument.It should have 14 documents. Om antalet dokument är noll körs inte indexeraren eller så har sidan ännu inte uppdaterats.If the document count is zero, the indexer is either still running or the page hasn't been refreshed yet.

  3. Välj demoindex.Select demoindex. Sök Utforskaren är den första fliken.Search explorer is the first tab.

  4. Innehållet är sökbart så snart det första dokumentet har lästs in.Content is searchable as soon as the first document is loaded. Om du vill kontrol lera att innehållet finns kör du en ospecificerad fråga genom att klicka på Sök.To verify content exists, run an unspecified query by clicking Search. Den här frågan returnerar alla för tillfället indexerade dokument, vilket ger dig en uppfattning om vad indexet innehåller.This query returns all currently indexed documents, giving you an idea of what the index contains.

  5. Klistra sedan in följande sträng för mer hanterbara resultat: search=*&$select=id, languageCode, organizationsNext, paste in the following string for more manageable results: search=*&$select=id, languageCode, organizations

Återställa och köra igenReset and rerun

I de tidiga experiment stegen i utvecklingen är den mest praktiska metoden för design upprepning att ta bort objekten från Azure Kognitiv sökning och tillåta att koden återskapas.In the early experimental stages of development, the most practical approach for design iteration is to delete the objects from Azure Cognitive Search and allow your code to rebuild them. Resursnamn är unika.Resource names are unique. Om du tar bort ett objekt kan du återskapa det med samma namn.Deleting an object lets you recreate it using the same name.

Exempel koden för den här självstudien kontrollerar om det finns befintliga objekt och tar bort dem så att du kan köra koden igen.The sample code for this tutorial checks for existing objects and deletes them so that you can rerun your code. Du kan också använda portalen för att ta bort index, indexerare, data källor och färdighetsuppsättningar.You can also use the portal to delete indexes, indexers, data sources, and skillsets.

LärdomarTakeaways

Den här självstudien demonstrerade de grundläggande stegen för att skapa en omfattande indexerings pipeline genom att skapa komponent delar: en data källa, färdigheter, index och indexerare.This tutorial demonstrated the basic steps for building an enriched indexing pipeline through the creation of component parts: a data source, skillset, index, and indexer.

Inbyggda kunskaper introducerades, tillsammans med färdigheter-definitionen och Mechanics för länkning av färdigheter tillsammans genom indata och utdata.Built-in skills were introduced, along with skillset definition and the mechanics of chaining skills together through inputs and outputs. Du har också lärt dig att outputFieldMappings i index definitions definitionen krävs för att dirigera berikade värden från pipelinen till ett sökbart index i en Azure kognitiv sökning-tjänst.You also learned that outputFieldMappings in the indexer definition is required for routing enriched values from the pipeline into a searchable index on an Azure Cognitive Search service.

Slutligen lärde du dig att testa resultat och återställa systemet för ytterligare iterationer.Finally, you learned how to test results and reset the system for further iterations. Du har lärt dig att när du utfärdar frågor mot indexet returneras utdata som skapades av pipelinen för berikande indexering.You learned that issuing queries against the index returns the output created by the enriched indexing pipeline. Du har också lärt dig att kontrollera indexerarstatus, och vilka objekt du ska ta bort innan du kör en pipeline igen.You also learned how to check indexer status, and which objects to delete before rerunning a pipeline.

Rensa resurserClean up resources

När du arbetar i din egen prenumeration är det en bra idé att ta bort de resurser som du inte längre behöver i slutet av projektet.When you're working in your own subscription, at the end of a project, it's a good idea to remove the resources that you no longer need. Resurser som fortsätter att köras kostar pengar.Resources left running can cost you money. Du kan ta bort resurser individuellt eller ta bort resursgruppen om du vill ta bort hela uppsättningen resurser.You can delete resources individually or delete the resource group to delete the entire set of resources.

Du kan hitta och hantera resurser i portalen med hjälp av länken alla resurser eller resurs grupper i det vänstra navigerings fönstret.You can find and manage resources in the portal, using the All resources or Resource groups link in the left-navigation pane.

Nästa stegNext steps

Nu när du är bekant med alla objekt i en pipeline för AI-anrikning, tar vi en närmare titt på färdigheter-definitioner och enskilda kunskaper.Now that you're familiar with all of the objects in an AI enrichment pipeline, let's take a closer look at skillset definitions and individual skills.