In dit bericht bespreken we een machine learning (ML)-oplossing voor complexe zoekopdrachten naar afbeeldingen met behulp van Amazon Kendra en Amazon Rekognition. We gebruiken met name het voorbeeld van architectuurdiagrammen voor complexe afbeeldingen vanwege de integratie van talloze verschillende visuele iconen en tekst.

Met internet is het zoeken en verkrijgen van een afbeelding nog nooit zo eenvoudig geweest. Meestal kunt u uw gewenste afbeeldingen nauwkeurig lokaliseren, zoals het zoeken naar uw volgende vakantiebestemming. Simpele zoekopdrachten zijn vaak succesvol, omdat ze niet geassocieerd worden met veel kenmerken. Afgezien van de gewenste afbeeldingskenmerken, vereisen de zoekcriteria doorgaans geen significante details om het vereiste resultaat te vinden. Als een gebruiker bijvoorbeeld probeert te zoeken naar een specifiek type blauwe fles, worden de resultaten van veel verschillende soorten blauwe flessen weergegeven. Het kan echter zijn dat de gewenste blauwe fles niet gemakkelijk gevonden kan worden vanwege generieke zoektermen.

Het interpreteren van zoekcontext draagt ​​ook bij aan vereenvoudiging van resultaten. Wanneer gebruikers een gewenst beeld in gedachten hebben, proberen ze dit om te zetten in een op tekst gebaseerde zoekopdracht. Het begrijpen van de nuances tussen zoekopdrachten voor vergelijkbare onderwerpen is belangrijk om relevante resultaten te bieden en de inspanning die de gebruiker nodig heeft om de resultaten handmatig te sorteren, te minimaliseren. De zoekopdracht 'Hondeneigenaar speelt apporteren' probeert bijvoorbeeld afbeeldingsresultaten te retourneren waarin een hondeneigenaar een spelletje apporteren speelt met een hond. De daadwerkelijk gegenereerde resultaten kunnen echter in plaats daarvan gericht zijn op een hond die een object apporteert zonder de betrokkenheid van een eigenaar te tonen. Gebruikers moeten mogelijk handmatig ongeschikte afbeeldingsresultaten filteren bij complexe zoekopdrachten.

Om de problemen in verband met complexe zoekopdrachten aan te pakken, beschrijft dit bericht in detail hoe u een zoekmachine kunt bereiken die in staat is om naar complexe afbeeldingen te zoeken door Amazon Kendra en Amazon Rekognition te integreren. Amazon Kendra is een intelligente zoekservice aangedreven door ML, en Amazon Rekognition is een ML-service die objecten, mensen, tekst, scènes en activiteiten uit afbeeldingen of video's kan identificeren.

Welke afbeeldingen kunnen te complex zijn om doorzoekbaar te zijn? Een voorbeeld zijn architectuurdiagrammen, waaraan veel zoekcriteria kunnen worden gekoppeld, afhankelijk van de complexiteit van de use case en het aantal vereiste technische services, wat resulteert in een aanzienlijke handmatige zoekinspanning voor de gebruiker. Als gebruikers bijvoorbeeld een architectuuroplossing willen vinden voor het gebruik van klantverificatie, gebruiken ze doorgaans een zoekopdracht die lijkt op 'Architectuurdiagrammen voor klantverificatie'. Generieke zoekopdrachten zouden echter een breed scala aan services en verschillende datums voor het maken van inhoud omvatten. Gebruikers zouden handmatig geschikte architectuurkandidaten moeten selecteren op basis van specifieke services en de relevantie van de architectuurontwerpkeuzes moeten overwegen op basis van de aanmaakdatum van de inhoud en de vraagdatum.

De volgende afbeelding toont een voorbeelddiagram dat een georkestreerde ETL-architectuuroplossing (Extract, Transform en Load) illustreert.

Voor gebruikers die niet bekend zijn met het serviceaanbod dat op het cloudplatform wordt aangeboden, kunnen ze verschillende generieke manieren en beschrijvingen geven bij het zoeken naar een dergelijk diagram. Hier volgen enkele voorbeelden van hoe er kan worden gezocht:

• "Orchestreer ETL-workflow"
• "Hoe de verwerking van bulkgegevens te automatiseren"
• "Methoden om een ​​pijplijn te creëren voor het transformeren van gegevens"

Overzicht oplossingen

We doorlopen de volgende stappen om de oplossing te implementeren:

1. trein een Aangepaste labels voor Amazon-herkenning model om symbolen in architectuurdiagrammen te herkennen.
2. Integreer Amazon Rekognition-tekstdetectie om architectuurdiagramsymbolen te valideren.
3. Gebruik Amazon Rekognition in een webcrawler om een ​​repository voor zoeken te bouwen
4. Gebruik Amazon Kendra om de repository te doorzoeken.

Om gebruikers gemakkelijk een grote opslagplaats van relevante resultaten te bieden, moet de oplossing een geautomatiseerde manier bieden om door betrouwbare bronnen te zoeken. Met behulp van architectuurdiagrammen als voorbeeld moet de oplossing referentielinks en technische documenten doorzoeken op architectuurdiagrammen en de aanwezige services identificeren. Door trefwoorden zoals use cases en branchebranches in deze bronnen te identificeren, kan de informatie ook worden vastgelegd en kunnen relevantere zoekresultaten aan de gebruiker worden weergegeven.

Gezien het doel van hoe relevante diagrammen moeten worden doorzocht, moet de oplossing voor het zoeken naar afbeeldingen aan drie criteria voldoen:

• Schakel eenvoudig zoeken op trefwoorden in
• Interpreteer zoekopdrachten op basis van use cases die gebruikers verstrekken
• Zoekresultaten sorteren en ordenen

Zoeken op trefwoorden is simpelweg zoeken naar "Amazon Rekognition" en architectuurdiagrammen te zien krijgen over hoe de service wordt gebruikt in verschillende gebruikssituaties. Als alternatief kunnen de zoektermen indirect aan het diagram worden gekoppeld via use cases en brancheverticalen die mogelijk verband houden met de architectuur. Als u bijvoorbeeld zoekt naar de termen 'Hoe ETL-pijplijn orkestreren', worden resultaten geretourneerd van architectuurdiagrammen waarmee is gebouwd AWS lijm en AWS Stap Functies. Het sorteren en ordenen van zoekresultaten op basis van attributen zoals aanmaakdatum zou ervoor zorgen dat de architectuurdiagrammen nog steeds relevant zijn, ondanks service-updates en releases. De volgende afbeelding toont het architectuurdiagram van de oplossing voor het zoeken naar afbeeldingen.

Zoals geïllustreerd in het voorgaande diagram en in het oplossingsoverzicht, zijn er twee hoofdaspecten van de oplossing. Het eerste aspect wordt uitgevoerd door Amazon Rekognition, dat objecten, mensen, tekst, scènes en activiteiten uit afbeeldingen of video's kan identificeren. Het bestaat uit vooraf getrainde modellen die kunnen worden toegepast om afbeeldingen en video's op schaal te analyseren. Met de functie voor aangepaste labels kunt u met Amazon Rekognition de ML-service afstemmen op uw specifieke zakelijke behoeften door afbeeldingen te labelen die zijn verzameld van sourcing via architectuurdiagrammen in vertrouwde referentielinks en technische documenten. Door een kleine set trainingsafbeeldingen te uploaden, laadt en inspecteert Amazon Rekognition automatisch de trainingsgegevens, selecteert het de juiste ML-algoritmen, traint een model en biedt modelprestatiestatistieken. Daarom kunnen gebruikers zonder ML-expertise profiteren van de voordelen van een aangepast labelmodel via een API-aanroep, omdat een aanzienlijke hoeveelheid overhead wordt verminderd. De oplossing past Amazon Rekognition Custom Labels toe om AWS-servicelogo's op architectuurdiagrammen te detecteren, zodat de architectuurdiagrammen doorzoekbaar kunnen zijn met servicenamen. Na modellering worden gedetecteerde services van elke architectuurdiagramafbeelding en de metadata, zoals URL-oorsprong en afbeeldingstitel, geïndexeerd voor toekomstige zoekdoeleinden en opgeslagen in Amazon DynamoDB, een volledig beheerde, serverloze NoSQL-database met sleutelwaarden die is ontworpen om krachtige toepassingen uit te voeren.

Het tweede aspect wordt ondersteund door Amazon Kendra, een intelligente zoekservice voor ondernemingen, mogelijk gemaakt door ML, waarmee u verschillende inhoudsbronnen kunt doorzoeken. Met Amazon Kendra kunt u zoeken naar resultaten, zoals afbeeldingen of documenten, die zijn geïndexeerd. Deze resultaten kunnen ook in verschillende repositories worden opgeslagen omdat de zoekservice ingebouwde connectoren gebruikt. Trefwoorden, zinsdelen en beschrijvingen kunnen worden gebruikt om te zoeken, waardoor u nauwkeurig kunt zoeken naar diagrammen die betrekking hebben op een bepaalde gebruikssituatie. Daarom kunt u eenvoudig een intelligente zoekservice bouwen met minimale ontwikkelingskosten.

Met een goed begrip van het probleem en de oplossing, gaan de volgende secties in op het automatiseren van data sourcing door het crawlen van architectuurdiagrammen uit geloofwaardige bronnen. Hierna doorlopen we het proces van het genereren van een aangepast label ML-model met een volledig beheerde service. Ten slotte behandelen we de gegevensopname door een intelligente zoekservice, mogelijk gemaakt door ML.

Maak een Amazon Recognition-model met aangepaste labels

Voordat we architectuurdiagrammen verkrijgen, hebben we een hulpmiddel nodig om te evalueren of een afbeelding kan worden geïdentificeerd als een architectuurdiagram. Amazon Rekognition Custom Labels biedt een gestroomlijnd proces om een ​​beeldherkenningsmodel te creëren dat objecten en scènes in afbeeldingen identificeert die specifiek zijn voor een zakelijke behoefte. In dit geval gebruiken we Amazon Rekognition Custom Labels om AWS-servicepictogrammen te identificeren, waarna de afbeeldingen worden geïndexeerd met de services voor een relevantere zoekopdracht met Amazon Kendra. Dit model maakt geen onderscheid of een afbeelding een architectuurdiagram is of niet; het identificeert eenvoudig servicepictogrammen, indien aanwezig. Als zodanig kunnen er gevallen zijn waarin afbeeldingen die geen architectuurdiagrammen zijn, in de zoekresultaten terechtkomen. Dergelijke resultaten zijn echter minimaal.

De volgende afbeelding toont de stappen die deze oplossing neemt om een ​​Amazon Rekognition Custom Labels-model te maken.

Dit proces omvat het uploaden van de datasets, het genereren van een manifestbestand dat verwijst naar de geüploade datasets, gevolgd door het uploaden van dit manifestbestand naar Amazon Rekognition. Er wordt een Python-script gebruikt om te helpen bij het uploaden van de datasets en het genereren van het manifestbestand. Nadat het manifestbestand met succes is gegenereerd, wordt het geüpload naar Amazon Rekognition om het modeltrainingsproces te starten. Voor meer informatie over het Python-script en hoe het moet worden uitgevoerd, raadpleegt u de GitHub repo.

Kies in het Amazon Rekognition-project om het model te trainen Trein model, selecteer het project dat je wilt trainen, voeg relevante tags toe en kies Trein model. Raadpleeg de beschikbare Video tutorials. Het trainen van het model met deze dataset kan tot 8 uur duren.

Wanneer de training is voltooid, kunt u het getrainde model kiezen om de evaluatieresultaten te bekijken. Raadpleeg voor meer informatie over de verschillende statistieken zoals precisie, terugroepen en F1 Statistieken voor het evalueren van uw model. Om het model te gebruiken, navigeert u naar de Gebruik Model tab, laat het aantal inferentie-eenheden op 1 staan ​​en start het model. Dan kunnen we een AWS Lambda functie om afbeeldingen naar het model in base64 te sturen, en het model retourneert een lijst met labels en betrouwbaarheidsscores.

Na het succesvol trainen van een Amazon Rekognition-model met Amazon Rekognition Custom Labels, kunnen we het gebruiken om servicepictogrammen te identificeren in de architectuurdiagrammen die zijn gecrawld. Om de nauwkeurigheid van het identificeren van services in het architectuurdiagram te vergroten, gebruiken we een andere Amazon Rekognition-functie genaamd tekst detectie. Om deze functie te gebruiken, geven we dezelfde afbeelding door in base64, en Amazon Rekognition retourneert de lijst met tekst die in de afbeelding wordt geïdentificeerd. In de volgende afbeeldingen vergelijken we de originele afbeelding en hoe deze eruitziet nadat de services in de afbeelding zijn geïdentificeerd. De eerste afbeelding toont de originele afbeelding.

De volgende afbeelding toont de originele afbeelding met gedetecteerde services.

Om schaalbaarheid te garanderen, gebruiken we een Lambda-functie, die wordt weergegeven via een API-eindpunt dat is gemaakt met behulp van Amazon API-gateway. Lambda is een serverloze, gebeurtenisgestuurde rekenservice waarmee u code kunt uitvoeren voor vrijwel elk type applicatie of backend-service zonder servers in te richten of te beheren. Het gebruik van een Lambda-functie elimineert een algemeen probleem met betrekking tot opschalen wanneer grote hoeveelheden verzoeken worden ingediend bij het API-eindpunt. Lambda voert automatisch de functie uit voor de specifieke API-aanroep, die stopt wanneer de aanroep is voltooid, waardoor de kosten voor de gebruiker worden verlaagd. Omdat het verzoek naar het Amazon Rekognition-eindpunt zou worden geleid, is het niet voldoende dat alleen de Lambda-functie schaalbaar is. Om ervoor te zorgen dat het Amazon Rekognition-eindpunt schaalbaar is, kunt u de inferentie-eenheid van het eindpunt vergroten. Raadpleeg voor meer informatie over het configureren van de inferentie-eenheid Inferentie-eenheden.

Het volgende is een codefragment van de Lambda-functie voor het beeldherkenningsproces:

const AWS = require("aws-sdk");
const axios = require("axios"); // API to retrieve information about individual services
const SERVICE_API = process.env.SERVICE_API;
// ARN of Amazon Rekognition model
const MODEL_ARN = process.env.MODEL_ARN; const rekognition = new AWS.Rekognition(); exports.handler = async (event) => { const body = JSON.parse(event["body"]); let base64Binary = ""; // Checks if the payload contains a url to the image or the image in base64 if (body.url) { const base64Res = await new Promise((resolve) => { axios .get(body.url, { responseType: "arraybuffer", }) .then((response) => { resolve(Buffer.from(response.data, "binary").toString("base64")); }); }); base64Binary = new Buffer.from(base64Res, "base64"); } else if (body.byte) { const base64Cleaned = body.byte.split("base64,")[1]; base64Binary = new Buffer.from(base64Cleaned, "base64"); } // Pass the contents through the trained Custom Labels model and text detection const [labels, text] = await Promise.all([ detectLabels(rekognition, base64Binary, MODEL_ARN), detectText(rekognition, base64Binary), ]); const texts = text.TextDetections.map((text) => ({ DetectedText: text.DetectedText, ParentId: text.ParentId, })); // Compare between overlapping labels and retain the label with the highest confidence let filteredLabels = removeOverlappingLabels(labels); // Sort all the labels from most to least confident filteredLabels = sortByConfidence(filteredLabels); // Remove duplicate services in the list const services = retrieveUniqueServices(filteredLabels, texts); // Pass each service into the reference document API to retrieve the URL to the documentation const refLinks = await getReferenceLinks(services); var responseBody = { labels: filteredLabels, text: texts, ref_links: refLinks, }; console.log("Response: ", response_body); const response = { statusCode: 200, headers: { "Access-Control-Allow-Origin": "*", // Required for CORS to work }, body: JSON.stringify(responseBody), }; return response;
}; // Code removed to truncate section

Nadat we de Lambda-functie hebben gemaakt, kunnen we doorgaan met het blootstellen ervan als een API met behulp van API Gateway. Raadpleeg voor instructies voor het maken van een API met Lambda-proxy-integratie Tutorial: Bouw een Hello World REST API met Lambda-proxy-integratie.

Kruip door de architectuurdiagrammen

Om de zoekfunctie goed te laten werken, hebben we een opslagplaats van architectuurdiagrammen nodig. Deze diagrammen moeten echter afkomstig zijn van geloofwaardige bronnen zoals AWS-blog en AWS Prescriptieve richtlijnen. Het vaststellen van de geloofwaardigheid van gegevensbronnen zorgt ervoor dat de onderliggende implementatie en het doel van de use cases nauwkeurig en goed doorgelicht zijn. De volgende stap is het opzetten van een crawler die kan helpen bij het verzamelen van veel architectuurdiagrammen die in onze repository kunnen worden ingevoerd. We hebben een webcrawler gemaakt om architectuurdiagrammen en informatie, zoals een beschrijving van de implementatie, uit de relevante bronnen te halen. Er zijn meerdere manieren waarop u een dergelijk mechanisme kunt bouwen; voor dit voorbeeld gebruiken we een programma dat draait op Amazon Elastic Compute-cloud (Amazone EC2). Het programma verkrijgt eerst links naar blogposts van een AWS Blog API. Het antwoord dat door de API wordt geretourneerd, bevat informatie over het bericht, zoals titel, URL, datum en de links naar afbeeldingen die in het bericht zijn gevonden.

Het volgende is een codefragment van de JavaScript-functie voor het webcrawlproces:

import axios from "axios";
import puppeteer from "puppeteer";
import { putItemDDB, identifyImageHighConfidence, getReferenceList,
} from "./utils.js"; /** Global variables */
const blogPostsApi = process.env.BLOG_POSTS_API;
const IMAGE_URL_PATTERN = "<pattern in the url that identified as link to image>";
const DDB_Table = process.env.DDB_Table; // Function that retrieves URLs of records from a public API
function getURLs(blogPostsApi) { // Return a list of URLs return axios .get(blogPostsApi) .then((response) => { var data = response.data.items; console.log("RESPONSE:"); const blogLists = data.map((blog) => [ blog.item.additionalFields.link, blog.item.dateUpdated, ]); return blogLists; }) .catch((error) => console.error(error));
} // Function that crawls content of individual URLs
async function crawlFromUrl(urls) { const browser = await puppeteer.launch({ executablePath: "/usr/bin/chromium-browser", }); // const browser = await puppeteer.launch(); const page = await browser.newPage(); let numOfValidArchUrls = 0; for (let index = 0; index < urls.length; index++) { console.log("index: ", index); let blogURL = urls[index][0]; let dateUpdated = urls[index][1]; await page.goto(blogURL); console.log("blogUrl:", blogURL); console.log("date:", dateUpdated); // Identify and get image from post based on URL pattern const images = await page.evaluate(() => Array.from(document.images, (e) => e.src) ); const filter1 = images.filter((img) => img.includes(IMAGE_URL_PATTERN)); console.log("all images:", filter1); // Validate if image is an architecture diagram for (let index_1 = 0; index_1 < filter1.length; index_1++) { const imageUrl = filter1[index_1]; const rekog = await identifyImageHighConfidence(imageUrl); if (rekog) { if (rekog.labels.size >= 2) { console.log("Rekog.labels.size = ", rekog.labels.size); console.log("Selected image url = ", imageUrl); let articleSection = []; let metadata = await page.$$('span[property="articleSection"]'); for (let i = 0; i < metadata.length; i++) { const element = metadata[i]; const value = await element.evaluate( (el) => el.textContent, element ); console.log("value: ", value); articleSection.push(value); } const title = await page.title(); const allRefLinks = await getReferenceList( rekog.labels, rekog.textServices ); numOfValidArchUrls = numOfValidArchUrls + 1; putItemDDB( blogURL, dateUpdated, imageUrl, articleSection.toString(), rekog, { L: allRefLinks }, title, DDB_Table ); console.log("numOfValidArchUrls = ", numOfValidArchUrls); } } if (rekog && rekog.labels.size >= 2) { break; } } } console.log("valid arch : ", numOfValidArchUrls); await browser.close();
} async function startCrawl() { // Get a list of URLs // Extract architecture image from those URLs const urls = await getURLs(blogPostsApi); if (urls) console.log("Crawling urls completed"); else { console.log("Unable to crawl images"); return; } await crawlFromUrl(urls);
} startCrawl();

Met dit mechanisme kunnen we gemakkelijk honderden en duizenden afbeeldingen van verschillende blogs crawlen. We hebben echter een filter nodig dat alleen afbeeldingen accepteert die inhoud van een architectuurdiagram bevatten, in ons geval iconen van AWS-services, om afbeeldingen die geen architectuurdiagrammen zijn eruit te filteren.

Dit is het doel van ons Amazon Rekognition-model. De diagrammen doorlopen het beeldherkenningsproces, dat servicepictogrammen identificeert en bepaalt of het kan worden beschouwd als een geldig architectuurdiagram.

Het volgende is een codefragment van de functie die afbeeldingen naar het Amazon Rekognition-model stuurt:

import axios from "axios";
import AWS from "aws-sdk"; // Configuration
AWS.config.update({ region: process.env.REGION }); /** Global variables */
// API to identify images
const LABEL_API = process.env.LABEL_API;
// API to get relevant documentations of individual services
const DOCUMENTATION_API = process.env.DOCUMENTATION_API;
// Create the DynamoDB service object
const dynamoDB = new AWS.DynamoDB({ apiVersion: "2012-08-10" }); // Function to identify image using an API that calls Amazon Rekognition model
function identifyImageHighConfidence(image_url) { return axios .post(LABEL_API, { url: image_url, }) .then((res) => { let data = res.data; let rekogLabels = new Set(); let rekogTextServices = new Set(); let rekogTextMetadata = new Set(); data.labels.forEach((element) => { if (element.Confidence >= 40) rekogLabels.add(element.Name); }); data.text.forEach((element) => { if ( element.DetectedText.includes("AWS") || element.DetectedText.includes("Amazon") ) { rekogTextServices.add(element.DetectedText); } else { rekogTextMetadata.add(element.DetectedText); } }); rekogTextServices.delete("AWS"); rekogTextServices.delete("Amazon"); return { labels: rekogLabels, textServices: rekogTextServices, textMetadata: Array.from(rekogTextMetadata).join(", "), }; }) .catch((error) => console.error(error));
}

Na het doorstaan ​​van de beeldherkenningscontrole worden de geretourneerde resultaten van het Amazon Rekognition-model en de daarvoor relevante informatie gebundeld in hun eigen metadata. De metadata worden vervolgens opgeslagen in een DynamoDB-tabel waar het record zou worden gebruikt om op te nemen in Amazon Kendra.

Het volgende is een codefragment van de functie die de metadata van het diagram opslaat in DynamoDB:

// Code removed to truncate section // Function that PUTS item into Amazon DynamoDB table
function putItemDDB( originUrl, publishDate, imageUrl, crawlerData, rekogData, referenceLinks, title, tableName
) { console.log("WRITE TO DDB"); console.log("originUrl : ", originUrl); console.log("publishDate: ", publishDate); console.log("imageUrl: ", imageUrl); let write_params = { TableName: tableName, Item: { OriginURL: { S: originUrl }, PublishDate: { S: formatDate(publishDate) }, ArchitectureURL: { S: imageUrl, }, Metadata: { M: { crawler: { S: crawlerData, }, Rekognition: { M: { labels: { S: Array.from(rekogData.labels).join(", "), }, textServices: { S: Array.from(rekogData.textServices).join(", "), }, textMetadata: { S: rekogData.textMetadata, }, }, }, }, }, Reference: referenceLinks, Title: { S: title, }, }, }; dynamoDB.putItem(write_params, function (err, data) { if (err) { console.log("*** DDB Error", err); } else { console.log("Successfuly inserted in DDB", data); } });
}

Neem metadata op in Amazon Kendra

Nadat de architectuurdiagrammen het beeldherkenningsproces hebben doorlopen en de metadata zijn opgeslagen in DynamoDB, hebben we een manier nodig waarop de diagrammen doorzoekbaar zijn terwijl wordt verwezen naar de inhoud in de metadata. De aanpak hiervoor is om een ​​zoekmachine te hebben die kan worden geïntegreerd met de applicatie en die een groot aantal zoekopdrachten aankan. Daarom gebruiken we Amazon Kendra, een intelligente zoekservice voor ondernemingen.

We gebruiken Amazon Kendra als interactief onderdeel van de oplossing vanwege de krachtige zoekmogelijkheden, vooral met het gebruik van natuurlijke taal. Dit voegt een extra laag van eenvoud toe wanneer gebruikers zoeken naar diagrammen die het dichtst in de buurt komen van wat ze zoeken. Amazon Kendra biedt een aantal connectoren voor gegevensbronnen voor het opnemen en verbinden van inhoud. Deze oplossing gebruikt een aangepaste connector om informatie over architectuurdiagrammen uit DynamoDB op te nemen. Om een ​​gegevensbron te configureren voor een Amazon Kendra-index, kunt u een bestaande index of gebruiken maak een nieuwe index.

De gecrawlde diagrammen moeten vervolgens worden opgenomen in de Amazon Kendra-index die is gemaakt. De volgende afbeelding toont de stroom van hoe de diagrammen worden geïndexeerd.

Eerst maken de diagrammen die in DynamoDB zijn ingevoegd een Put-gebeurtenis via Amazon DynamoDB-streams. De gebeurtenis activeert de Lambda-functie die fungeert als een aangepaste gegevensbron voor Amazon Kendra en laadt de diagrammen in de index. Raadpleeg voor instructies voor het maken van een DynamoDB Streams-trigger voor een Lambda-functie Tutorial: AWS Lambda gebruiken met Amazon DynamoDB Streams

Nadat we de Lambda-functie met DynamoDB hebben geïntegreerd, moeten we de records van de diagrammen die naar de functie zijn verzonden, opnemen in de Amazon Kendra-index. De index accepteert gegevens van verschillende soorten bronnen en het opnemen van items in de index vanuit de Lambda-functie betekent dat de aangepaste gegevensbronconfiguratie moet worden gebruikt. Raadpleeg voor instructies voor het maken van een aangepaste gegevensbron voor uw index Aangepaste gegevensbronconnector.

Het volgende is een codefragment van de Lambda-functie voor hoe een diagram op een aangepaste manier kan worden geïndexeerd:

import json
import os
import boto3 KENDRA = boto3.client("kendra")
INDEX_ID = os.environ["INDEX_ID"]
DS_ID = os.environ["DS_ID"] def lambda_handler(event, context): dbRecords = event["Records"] # Loop through items from Amazon DynamoDB for row in dbRecords: rowData = row["dynamodb"]["NewImage"] originUrl = rowData["OriginURL"]["S"] publishedDate = rowData["PublishDate"]["S"] architectureUrl = rowData["ArchitectureURL"]["S"] title = rowData["Title"]["S"] metadata = rowData["Metadata"]["M"] crawlerMetadata = metadata["crawler"]["S"] rekognitionMetadata = metadata["Rekognition"]["M"] rekognitionLabels = rekognitionMetadata["labels"]["S"] rekognitionServices = rekognitionMetadata["textServices"]["S"] concatenatedText = ( f"{crawlerMetadata} {rekognitionLabels} {rekognitionServices}" ) add_document( dsId=DS_ID, indexId=INDEX_ID, originUrl=originUrl, architectureUrl=architectureUrl, title=title, publishedDate=publishedDate, text=concatenatedText, ) return # Function to add the diagram into Kendra index
def add_document(dsId, indexId, originUrl, architectureUrl, title, publishedDate, text): document = get_document( dsId, indexId, originUrl, architectureUrl, title, publishedDate, text ) documents = [document] result = KENDRA.batch_put_document(IndexId=indexId, Documents=documents) print("result:" + json.dumps(result)) return True # Frame the diagram into a document that Kendra accepts
def get_document(dsId, originUrl, architectureUrl, title, publishedDate, text): document = { "Id": originUrl, "Title": title, "Attributes": [ {"Key": "_data_source_id", "Value": {"StringValue": dsId}}, {"Key": "_source_uri", "Value": {"StringValue": architectureUrl}}, {"Key": "_created_at", "Value": {"DateValue": publishedDate}}, {"Key": "publish_date", "Value": {"DateValue": publishedDate}}, ], "Blob": text, } return document

De belangrijke factor die ervoor zorgt dat diagrammen doorzoekbaar zijn, is de Blob-sleutel in een document. Dit is waar Amazon Kendra naar kijkt wanneer gebruikers hun zoekopdracht invoeren. In deze voorbeeldcode bevat de Blob-sleutel een samengevatte versie van de use case van het diagram, samengevoegd met de informatie die is gedetecteerd tijdens het beeldherkenningsproces. Hierdoor kunnen gebruikers zoeken naar architectuurdiagrammen op basis van use cases zoals "Fraud Detection" of op servicenamen zoals "Amazon Kendra".

Om een ​​voorbeeld te illustreren van hoe de Blob-sleutel eruitziet, verwijst het volgende fragment naar het eerste ETL-diagram dat we eerder in dit bericht hebben geïntroduceerd. Het bevat een beschrijving van het diagram dat werd verkregen toen het werd gecrawld, evenals de services die werden geïdentificeerd door het Amazon Rekognition-model.

{ ..., "Blob": "Build and orchestrate ETL pipelines using Amazon Athena and AWS Step Functions Amazon Athena, AWS Step Functions, Amazon S3, AWS Glue Data Catalog "
}

Zoeken met Amazon Kendra

Nadat we alle componenten hebben samengevoegd, zien de resultaten van een voorbeeldzoekopdracht van "real time analytics" eruit als de volgende schermafbeelding.

Door naar deze use case te zoeken, produceert het verschillende architectuurdiagrammen. Gebruikers krijgen deze verschillende methoden van de specifieke werk belasting die ze proberen te implementeren.

Opruimen

Voltooi de stappen in dit gedeelte om de bronnen op te schonen die u als onderdeel van dit bericht hebt gemaakt:

1. Verwijder de API:
   1. Selecteer op de API Gateway-console de API die moet worden verwijderd.
   2. Op de Acties menu, kies Verwijder.
   3. Kies Verwijder bevestigen.
2. Verwijder de DynamoDB-tabel:
   1. Kies op de DynamoDB-console Tafels in het navigatievenster.
   2. Selecteer de tabel die u hebt gemaakt en kies Verwijder.
   3. Voer delete in wanneer om bevestiging wordt gevraagd.
   4. Kies Tabel verwijderen bevestigen.
3. Verwijder de Amazon Kendra-index:
   1. Kies op de Amazon Kendra-console Indexen in het navigatievenster.
   2. Selecteer de index die u hebt gemaakt en kies Verwijder
   3. Voer een reden in wanneer om bevestiging wordt gevraagd.
   4. Kies Verwijder bevestigen.
4. Verwijder het Amazon Recognition-project:
   1. Kies op de Amazon Rekognition-console Gebruik aangepaste labels in het navigatievenster en kies vervolgens Projecten.
   2. Selecteer het project dat je hebt gemaakt en kies Verwijder.
   3. Voer Verwijderen in wanneer om bevestiging wordt gevraagd.
   4. Kies Bijbehorende datasets en modellen verwijderen bevestigen.
5. Verwijder de Lambda-functie:
   1. Selecteer op de Lambda-console de functie die moet worden verwijderd.
   2. Op de Acties menu, kies Verwijder.
   3. Voer Verwijderen in wanneer om bevestiging wordt gevraagd.
   4. Kies Verwijder bevestigen.

Samengevat

In dit bericht lieten we een voorbeeld zien van hoe je op een intelligente manier informatie uit afbeeldingen kunt zoeken. Dit omvat het proces van het trainen van een Amazon Rekognition ML-model dat fungeert als een filter voor afbeeldingen, de automatisering van het crawlen van afbeeldingen, wat zorgt voor geloofwaardigheid en efficiëntie, en het opvragen van diagrammen door een aangepaste gegevensbron te koppelen die een flexibelere manier mogelijk maakt om items te indexeren . Om dieper in te gaan op de implementatie van de codes, zie de GitHub repo.

Nu u begrijpt hoe u de ruggengraat van een gecentraliseerde zoekrepository voor complexe zoekopdrachten kunt leveren, kunt u proberen uw eigen beeldzoekmachine te maken. Raadpleeg voor meer informatie over de kernfuncties Aan de slag met aangepaste Amazon Rekognition-labels, Inhoud modererenEn Amazon Kendra-ontwikkelaarsgids. Als je nieuw bent bij Amazon Rekognition Custom Labels, probeer het dan uit met onze gratis laag, die 3 maanden duurt en 10 gratis trainingsuren per maand en 4 gratis inferentie-uren per maand omvat.

Over de auteurs

Ryan zie is een oplossingsarchitect bij AWS. Hij is gevestigd in Singapore en werkt samen met klanten om oplossingen te bouwen om hun zakelijke problemen op te lossen, en om een ​​technische visie op maat te maken om meer schaalbare en efficiëntere workloads in de cloud uit te voeren.

James Ong Jia Xiang is Customer Solutions Manager bij AWS. Hij is gespecialiseerd in het Migration Acceleration Program (MAP) waar hij klanten en partners helpt bij het succesvol implementeren van grootschalige migratieprogramma's naar AWS. Hij is gevestigd in Singapore en richt zich ook op het stimuleren van moderniserings- en bedrijfstransformatie-initiatieven in heel APJ door middel van schaalbare mechanismen. In zijn vrije tijd houdt hij van natuuractiviteiten zoals wandelen en surfen.

Hang Duong op is een oplossingsarchitect bij AWS. Ze is gevestigd in Hanoi, Vietnam, en richt zich op het stimuleren van de acceptatie van de cloud in haar hele land door haar klanten zeer beschikbare, veilige en schaalbare cloudoplossingen te bieden. Daarnaast houdt ze van bouwen en is ze betrokken bij verschillende prototyping-projecten. Ze is ook gepassioneerd door het gebied van machine learning.

Trin Vo is een Solutions Architect bij AWS, gevestigd in Ho Chi Minh City, Vietnam. Ze richt zich op het werken met klanten in verschillende industrieën en partners in Vietnam om architecturen en demonstraties van het AWS-platform te maken die terugwerken op de zakelijke behoeften van de klant en de acceptatie van geschikte AWS-technologie versnellen. Ze houdt van speleologie en wandelen in haar vrije tijd.

Wai Kin Tham is een Cloud Architect bij AWS. Hij is gevestigd in Singapore en zijn dagelijkse taak bestaat erin klanten te helpen migreren naar de cloud en hun technologiestapel in de cloud te moderniseren. In zijn vrije tijd volgt hij lessen Muay Thai en Braziliaans Jiu Jitsu.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoAiStream. Web3 gegevensintelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Koop en verkoop aandelen in PRE-IPO-bedrijven met PREIPO®. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/build-an-image-search-engine-with-amazon-kendra-and-amazon-rekognition/