Delen via


Azure AI-services

Azure AI-services helpen ontwikkelaars en organisaties snel intelligente, geavanceerde, marktklare en verantwoordelijke toepassingen te maken met kant-en-klare en vooraf gebouwde en aanpasbare API's en modellen.

Met SynapseML kunt u krachtige en zeer schaalbare voorspellende en analytische modellen bouwen uit verschillende Spark-gegevensbronnen. Synapse Spark biedt ingebouwde SynapseML-bibliotheken, waaronder synapse.ml.services.

Belangrijk

Vanaf 20 september 2023 kunt u geen nieuwe Anomaly Detector-resources maken. De Anomaly Detector-service wordt op 1 oktober 2026 buiten gebruik gesteld.

Vereisten voor Azure Synapse Analytics

De zelfstudie, vereisten voor het gebruik van Azure AI-services in Azure Synapse, begeleidt u door een aantal stappen die u moet uitvoeren voordat u Azure AI-services in Synapse Analytics gebruikt.

Azure AI-services is een suite met API's, SDK's en services die ontwikkelaars kunnen gebruiken om intelligente functies toe te voegen aan hun toepassingen. AI-services bieden ontwikkelaars zelfs als ze geen directe AI- of data science-vaardigheden of kennis hebben. Met Azure AI-services kunnen ontwikkelaars toepassingen maken die toepassingen kunnen zien, horen, spreken, begrijpen en zelfs beginnen te redeneren. De catalogus met services in Azure AI-services kan worden onderverdeeld in vijf hoofdpijlers: Vision, Speech, Language, Web search en Decision.

Gebruik

Vision

Computer Vision

  • Beschrijven: biedt een beschrijving van een afbeelding in een leesbare taal (Scala, Python)
  • Analyseren (kleur, afbeeldingstype, gezicht, volwassen/ongepaste inhoud): analyseert visuele kenmerken van een afbeelding (Scala, Python)
  • OCR: leest tekst uit een afbeelding (Scala, Python)
  • Tekst herkennen: leest tekst uit een afbeelding (Scala, Python)
  • Miniatuur: genereert een miniatuur van de door de gebruiker opgegeven grootte op basis van de afbeelding (Scala, Python)
  • Domeinspecifieke inhoud herkennen: domeinspecifieke inhoud (beroemdheid, oriëntatiepunt) (Scala, Python)
  • Tag: identificeert een lijst met woorden die relevant zijn voor de invoerafbeelding (Scala, Python)

Face

  • Detecteren: menselijke gezichten in een afbeelding detecteren (Scala, Python)
  • Controleer: controleert of twee gezichten tot dezelfde persoon behoren, of een gezicht behoort tot een persoon (Scala, Python)
  • Identificeren: zoekt de dichtstbijzijnde overeenkomsten van het specifieke gezicht van de querypersoon uit een persoonsgroep (Scala, Python)
  • Vergelijkbare zoeken: zoekt vergelijkbare gezichten naar het query-gezicht in een gezichtslijst (Scala, Python)
  • Groep: verdeelt een groep gezichten in niet-aaneengesloten groepen op basis van gelijkenis (Scala, Python)

Spraak

Spraakservices

  • Spraak-naar-tekst: audiostreams transcriberen (Scala, Python)
  • Gesprektranscriptie: transcribeert audiostreams in livetranscripties met geïdentificeerde sprekers. (Scala, Python)
  • Tekst naar spraak: converteert tekst naar realistische audio (Scala, Python)

Taal

AI-taal

  • Taaldetectie: detecteert de taal van de invoertekst (Scala, Python)
  • Sleuteltermextractie: identificeert de belangrijkste gesprekspunten in de invoertekst (Scala, Python)
  • Herkenning van benoemde entiteiten: identificeert bekende entiteiten en algemene benoemde entiteiten in de invoertekst (Scala, Python)
  • Sentimentanalyse: retourneert een score tussen 0 en 1 die het gevoel in de invoertekst aangeeft (Scala, Python)
  • Extractie van gezondheidszorgentiteiten: extraheert medische entiteiten en relaties uit tekst. (Scala, Python)

Vertaling

Translator

  • Vertalen: vertaalt tekst. (Scala, Python)
  • Transliteratie: converteert tekst in één taal van het ene script naar een ander script. (Scala, Python)
  • Detecteren: Identificeert de taal van een stuk tekst. (Scala, Python)
  • BreakSentence: Identificeert de positie van zinsgrenzen in een stuk tekst. (Scala, Python)
  • Opzoeken in woordenlijst: biedt alternatieve vertalingen voor een woord en een klein aantal idiomatische zinnen. (Scala, Python)
  • Voorbeelden van woordenlijst: bevat voorbeelden die laten zien hoe termen in de woordenlijst worden gebruikt in context. (Scala, Python)
  • Documentomzetting: vertaalt documenten in alle ondersteunde talen en dialecten en behoudt documentstructuur en gegevensindeling. (Scala, Python)

Documentinformatie

Documentinformatie

  • Indeling analyseren: tekst- en indelingsgegevens extraheren uit een bepaald document. (Scala, Python)
  • Ontvangstbewijzen analyseren: detecteert en extraheert gegevens uit ontvangstbevestigingen met behulp van OCR (optische tekenherkenning) en ons ontvangstmodel, zodat u eenvoudig gestructureerde gegevens kunt extraheren uit ontvangstbewijzen, zoals de naam van de verkoper, het telefoonnummer van de verkoper, transactiedatum, het transactietotaal en meer. (Scala, Python)
  • Visitekaartjes analyseren: detecteert en extraheert gegevens uit visitekaartjes met behulp van ocr (optische tekenherkenning) en ons visitekaartjesmodel, zodat u eenvoudig gestructureerde gegevens kunt extraheren uit visitekaartjes, zoals namen van contactpersonen, bedrijfsnamen, telefoonnummers, e-mailberichten en meer. (Scala, Python)
  • Facturen analyseren: detecteert en extraheert gegevens uit facturen met behulp van OCR (Optical Character Recognition) en onze deep learning-modellen voor factuurbegrip, zodat u eenvoudig gestructureerde gegevens kunt extraheren uit facturen zoals klant, leverancier, factuur-id, factuurdatum, totaal, verschuldigd factuurbedrag, belastingbedrag, verzenden naar, factureren naar, regelitems en meer. (Scala, Python)
  • Id-documenten analyseren: detecteert en extraheert gegevens uit identificatiedocumenten met behulp van OCR (Optical Character Recognition) en ons ID-documentmodel, zodat u eenvoudig gestructureerde gegevens kunt extraheren uit id-documenten, zoals voornaam, achternaam, geboortedatum, documentnummer en meer. (Scala, Python)
  • Aangepast formulier analyseren: extraheert informatie uit formulieren (PDF's en afbeeldingen) in gestructureerde gegevens op basis van een model dat is gemaakt op basis van een set representatieve trainingsformulieren. (Scala, Python)
  • Aangepast model ophalen: gedetailleerde informatie over een aangepast model ophalen. (Scala, Python)
  • Aangepaste modellen weergeven: informatie ophalen over alle aangepaste modellen. (Scala, Python)

Beslissing

Anomaliedetectie

  • Anomaliestatus van het laatste punt: genereert een model met behulp van voorgaande punten en bepaalt of het laatste punt afwijkend is (Scala, Python)
  • Afwijkingen zoeken: genereert een model met behulp van een hele reeks en zoekt afwijkingen in de reeks (Scala, Python)

Uw systeem voorbereiden

Importeer eerst de vereiste bibliotheken en initialiseer uw Spark-sessie.

from pyspark.sql.functions import udf, col
from synapse.ml.io.http import HTTPTransformer, http_udf
from requests import Request
from pyspark.sql.functions import lit
from pyspark.ml import PipelineModel
from pyspark.sql.functions import col

Importeer Azure AI-servicesbibliotheken en vervang de sleutels en locaties in het volgende codefragment door uw Azure AI-servicessleutel en -locatie.

from synapse.ml.services import *
from synapse.ml.core.platform import *

# A general AI services key for AI Language, Computer Vision and Document Intelligence (or use separate keys that belong to each service)
service_key = find_secret(
    secret_name="ai-services-api-key", keyvault="mmlspark-build-keys"
)  # Replace the call to find_secret with your key as a python string. e.g. service_key="27snaiw..."
service_loc = "eastus"

# A Bing Search v7 subscription key
bing_search_key = find_secret(
    secret_name="bing-search-key", keyvault="mmlspark-build-keys"
)  # Replace the call to find_secret with your key as a python string.

# An Anomaly Detector subscription key
anomaly_key = find_secret(
    secret_name="anomaly-api-key", keyvault="mmlspark-build-keys"
)  # Replace the call to find_secret with your key as a python string. If you don't have an anomaly detection resource created before Sep 20th 2023, you won't be able to create one.
anomaly_loc = "westus2"

# A Translator subscription key
translator_key = find_secret(
    secret_name="translator-key", keyvault="mmlspark-build-keys"
)  # Replace the call to find_secret with your key as a python string.
translator_loc = "eastus"

# An Azure search key
search_key = find_secret(
    secret_name="azure-search-key", keyvault="mmlspark-build-keys"
)  # Replace the call to find_secret with your key as a python string.

Sentimentanalyse uitvoeren op tekst

De AI Language-service biedt verschillende algoritmen voor het extraheren van intelligente inzichten uit tekst. We kunnen bijvoorbeeld het gevoel van een bepaald stuk ingevoerde tekst vinden. De service retourneert een score tussen 0,0 en 1,0, waarbij een lage score een negatief gevoel aangeeft en een hoge score een positief gevoel. In dit voorbeeld worden drie eenvoudige zinnen gebruikt en wordt het gevoel van elk ervan geretourneerd.

# Create a dataframe that's tied to it's column names
df = spark.createDataFrame(
    [
        ("I am so happy today, its sunny!", "en-US"),
        ("I am frustrated by this rush hour traffic", "en-US"),
        ("The AI services on spark aint bad", "en-US"),
    ],
    ["text", "language"],
)

# Run the Text Analytics service with options
sentiment = (
    AnalyzeText()
    .setKind("SentimentAnalysis")
    .setTextCol("text")
    .setLocation(service_loc)
    .setSubscriptionKey(service_key)
    .setOutputCol("sentiment")
    .setErrorCol("error")
    .setLanguageCol("language")
)

# Show the results of your text query in a table format
display(
    sentiment.transform(df).select(
        "text", col("sentiment.documents.sentiment").alias("sentiment")
    )
)

Tekstanalyse uitvoeren voor statusgegevens

De Text Analytics for Health Service extraheert en labelt relevante medische informatie uit ongestructureerde tekst, zoals doktersnotities, kwijtingsoverzichten, klinische documenten en elektronische gezondheidsdossiers.

Het volgende codevoorbeeld analyseert en transformeert tekst van artsennotities in gestructureerde gegevens.

df = spark.createDataFrame(
    [
        ("20mg of ibuprofen twice a day",),
        ("1tsp of Tylenol every 4 hours",),
        ("6-drops of Vitamin B-12 every evening",),
    ],
    ["text"],
)

healthcare = (
    AnalyzeHealthText()
    .setSubscriptionKey(service_key)
    .setLocation(service_loc)
    .setLanguage("en")
    .setOutputCol("response")
)

display(healthcare.transform(df))

Tekst in een andere taal vertalen

Translator is een cloudservice voor machinevertaling en maakt deel uit van de Azure AI-servicesfamilie van AI-API's die worden gebruikt om intelligente apps te bouwen. Translator is eenvoudig in uw toepassingen, websites, hulpprogramma's en oplossingen te integreren. Hiermee kunt u meertalige gebruikerservaringen toevoegen in 90 talen en dialecten en kan worden gebruikt om tekst te vertalen zonder uw eigen algoritme te hosten.

In het volgende codevoorbeeld wordt een eenvoudige tekstomzetting uitgevoerd door de zinnen op te geven waarnaar u de zinnen wilt vertalen en de doeltalen waarnaar u ze wilt vertalen.

from pyspark.sql.functions import col, flatten

# Create a dataframe including sentences you want to translate
df = spark.createDataFrame(
    [(["Hello, what is your name?", "Bye"],)],
    [
        "text",
    ],
)

# Run the Translator service with options
translate = (
    Translate()
    .setSubscriptionKey(translator_key)
    .setLocation(translator_loc)
    .setTextCol("text")
    .setToLanguage(["zh-Hans"])
    .setOutputCol("translation")
)

# Show the results of the translation.
display(
    translate.transform(df)
    .withColumn("translation", flatten(col("translation.translations")))
    .withColumn("translation", col("translation.text"))
    .select("translation")
)

Informatie uit een document extraheren in gestructureerde gegevens

Azure AI Document Intelligence maakt deel uit van Azure-app lied AI Services waarmee u geautomatiseerde gegevensverwerkingssoftware kunt bouwen met behulp van machine learning-technologie. Met Azure AI Document Intelligence kunt u tekst, sleutel-waardeparen, selectiemarkeringen, tabellen en structuur uit uw documenten identificeren en extraheren. De service voert gestructureerde gegevens uit die de relaties in het oorspronkelijke bestand, begrenzingsvakken, betrouwbaarheid en meer bevatten.

In het volgende codevoorbeeld wordt een afbeelding van een visitekaartje geanalyseerd en worden de bijbehorende gegevens geëxtraheerd in gestructureerde gegevens.

from pyspark.sql.functions import col, explode

# Create a dataframe containing the source files
imageDf = spark.createDataFrame(
    [
        (
            "https://mmlspark.blob.core.windows.net/datasets/FormRecognizer/business_card.jpg",
        )
    ],
    [
        "source",
    ],
)

# Run the Form Recognizer service
analyzeBusinessCards = (
    AnalyzeBusinessCards()
    .setSubscriptionKey(service_key)
    .setLocation(service_loc)
    .setImageUrlCol("source")
    .setOutputCol("businessCards")
)

# Show the results of recognition.
display(
    analyzeBusinessCards.transform(imageDf)
    .withColumn(
        "documents", explode(col("businessCards.analyzeResult.documentResults.fields"))
    )
    .select("source", "documents")
)

Voorbeeld in Computer Vision

Azure AI Vision analyseert afbeeldingen om structuur zoals gezichten, objecten en beschrijvingen in natuurlijke taal te identificeren.

In het volgende codevoorbeeld worden afbeeldingen geanalyseerd en gelabeld met tags. Tags zijn beschrijvingen van één woord van dingen in de afbeelding, zoals herkenbare objecten, personen, landschappen en acties.

# Create a dataframe with the image URLs
base_url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/"
df = spark.createDataFrame(
    [
        (base_url + "objects.jpg",),
        (base_url + "dog.jpg",),
        (base_url + "house.jpg",),
    ],
    [
        "image",
    ],
)

# Run the Computer Vision service. Analyze Image extracts information from/about the images.
analysis = (
    AnalyzeImage()
    .setLocation(service_loc)
    .setSubscriptionKey(service_key)
    .setVisualFeatures(
        ["Categories", "Color", "Description", "Faces", "Objects", "Tags"]
    )
    .setOutputCol("analysis_results")
    .setImageUrlCol("image")
    .setErrorCol("error")
)

# Show the results of what you wanted to pull out of the images.
display(analysis.transform(df).select("image", "analysis_results.description.tags"))

Bing Image Search doorzoekt het web om afbeeldingen op te halen die zijn gerelateerd aan de query in natuurlijke taal van een gebruiker.

In het volgende codevoorbeeld wordt een tekstquery gebruikt die zoekt naar afbeeldingen met aanhalingstekens. De uitvoer van de code is een lijst met afbeeldings-URL's die foto's bevatten die betrekking hebben op de query.

# Number of images Bing will return per query
imgsPerBatch = 10
# A list of offsets, used to page into the search results
offsets = [(i * imgsPerBatch,) for i in range(100)]
# Since web content is our data, we create a dataframe with options on that data: offsets
bingParameters = spark.createDataFrame(offsets, ["offset"])

# Run the Bing Image Search service with our text query
bingSearch = (
    BingImageSearch()
    .setSubscriptionKey(bing_search_key)
    .setOffsetCol("offset")
    .setQuery("Martin Luther King Jr. quotes")
    .setCount(imgsPerBatch)
    .setOutputCol("images")
)

# Transformer that extracts and flattens the richly structured output of Bing Image Search into a simple URL column
getUrls = BingImageSearch.getUrlTransformer("images", "url")

# This displays the full results returned, uncomment to use
# display(bingSearch.transform(bingParameters))

# Since we have two services, they are put into a pipeline
pipeline = PipelineModel(stages=[bingSearch, getUrls])

# Show the results of your search: image URLs
display(pipeline.transform(bingParameters))

Spraak naar tekst transformeren

Met de service Spraak-naar-tekst worden streams of bestanden met gesproken tekst naar leesbare tekst geconverteerd. In het volgende codevoorbeeld wordt één audiobestand getranscribeerd naar tekst.

# Create a dataframe with our audio URLs, tied to the column called "url"
df = spark.createDataFrame(
    [("https://mmlspark.blob.core.windows.net/datasets/Speech/audio2.wav",)], ["url"]
)

# Run the Speech-to-text service to translate the audio into text
speech_to_text = (
    SpeechToTextSDK()
    .setSubscriptionKey(service_key)
    .setLocation(service_loc)
    .setOutputCol("text")
    .setAudioDataCol("url")
    .setLanguage("en-US")
    .setProfanity("Masked")
)

# Show the results of the translation
display(speech_to_text.transform(df).select("url", "text.DisplayText"))

Tekst naar spraak transformeren

Tekst-naar-spraak is een service waarmee u apps en services kunt bouwen die natuurlijk spreken en kiezen uit meer dan 270 neurale stemmen in 119 talen en varianten.

In het volgende codevoorbeeld wordt tekst omgezet in een audiobestand dat de inhoud van de tekst bevat.

from synapse.ml.services.speech import TextToSpeech

fs = ""
if running_on_databricks():
    fs = "dbfs:"
elif running_on_synapse_internal():
    fs = "Files"

# Create a dataframe with text and an output file location
df = spark.createDataFrame(
    [
        (
            "Reading out loud is fun! Check out aka.ms/spark for more information",
            fs + "/output.mp3",
        )
    ],
    ["text", "output_file"],
)

tts = (
    TextToSpeech()
    .setSubscriptionKey(service_key)
    .setTextCol("text")
    .setLocation(service_loc)
    .setVoiceName("en-US-JennyNeural")
    .setOutputFileCol("output_file")
)

# Check to make sure there were no errors during audio creation
display(tts.transform(df))

Afwijkingen in tijdreeksgegevens detecteren

Als u vóór 20 september 2023 geen anomaliedetectieresource hebt gemaakt, kunt u er geen maken. U kunt dit gedeelte overslaan.

Anomaly Detector is geschikt voor het detecteren van onregelmatigheden in uw tijdreeksen. In het volgende codevoorbeeld wordt de Anomaly Detector-service gebruikt om afwijkingen in een tijdreeks te vinden.

# Create a dataframe with the point data that Anomaly Detector requires
df = spark.createDataFrame(
    [
        ("1972-01-01T00:00:00Z", 826.0),
        ("1972-02-01T00:00:00Z", 799.0),
        ("1972-03-01T00:00:00Z", 890.0),
        ("1972-04-01T00:00:00Z", 900.0),
        ("1972-05-01T00:00:00Z", 766.0),
        ("1972-06-01T00:00:00Z", 805.0),
        ("1972-07-01T00:00:00Z", 821.0),
        ("1972-08-01T00:00:00Z", 20000.0),
        ("1972-09-01T00:00:00Z", 883.0),
        ("1972-10-01T00:00:00Z", 898.0),
        ("1972-11-01T00:00:00Z", 957.0),
        ("1972-12-01T00:00:00Z", 924.0),
        ("1973-01-01T00:00:00Z", 881.0),
        ("1973-02-01T00:00:00Z", 837.0),
        ("1973-03-01T00:00:00Z", 9000.0),
    ],
    ["timestamp", "value"],
).withColumn("group", lit("series1"))

# Run the Anomaly Detector service to look for irregular data
anomaly_detector = (
    SimpleDetectAnomalies()
    .setSubscriptionKey(anomaly_key)
    .setLocation(anomaly_loc)
    .setTimestampCol("timestamp")
    .setValueCol("value")
    .setOutputCol("anomalies")
    .setGroupbyCol("group")
    .setGranularity("monthly")
)

# Show the full results of the analysis with the anomalies marked as "True"
display(
    anomaly_detector.transform(df).select("timestamp", "value", "anomalies.isAnomaly")
)

Informatie ophalen uit willekeurige web-API's

Met HTTP in Spark kan elke webservice in uw pijplijn voor big data worden gebruikt. In dit voorbeeld gebruiken we de API van de Wereldbank om informatie over verschillende landen/regio's over de hele wereld op te halen.

# Use any requests from the python requests library

def world_bank_request(country):
    return Request(
        "GET", "http://api.worldbank.org/v2/country/{}?format=json".format(country)
    )

# Create a dataframe with specifies which countries/regions we want data on
df = spark.createDataFrame([("br",), ("usa",)], ["country"]).withColumn(
    "request", http_udf(world_bank_request)(col("country"))
)

# Much faster for big data because of the concurrency :)
client = (
    HTTPTransformer().setConcurrency(3).setInputCol("request").setOutputCol("response")
)

# Get the body of the response

def get_response_body(resp):
    return resp.entity.content.decode()

# Show the details of the country/region data returned
display(
    client.transform(df).select(
        "country", udf(get_response_body)(col("response")).alias("response")
    )
)

Azure AI Search-voorbeeld

In dit voorbeeld laten we zien hoe u gegevens kunt verrijken met behulp van Cognitieve vaardigheden en schrijven naar een Azure Search-index met behulp van SynapseML.

search_service = "mmlspark-azure-search"
search_index = "test-33467690"

df = spark.createDataFrame(
    [
        (
            "upload",
            "0",
            "https://mmlspark.blob.core.windows.net/datasets/DSIR/test1.jpg",
        ),
        (
            "upload",
            "1",
            "https://mmlspark.blob.core.windows.net/datasets/DSIR/test2.jpg",
        ),
    ],
    ["searchAction", "id", "url"],
)

tdf = (
    AnalyzeImage()
    .setSubscriptionKey(service_key)
    .setLocation(service_loc)
    .setImageUrlCol("url")
    .setOutputCol("analyzed")
    .setErrorCol("errors")
    .setVisualFeatures(
        ["Categories", "Tags", "Description", "Faces", "ImageType", "Color", "Adult"]
    )
    .transform(df)
    .select("*", "analyzed.*")
    .drop("errors", "analyzed")
)

tdf.writeToAzureSearch(
    subscriptionKey=search_key,
    actionCol="searchAction",
    serviceName=search_service,
    indexName=search_index,
    keyCol="id",
)