Dela via

Använda Azure AI-tjänster med SynapseML i Microsoft Fabric

  • Artikel

Azure AI-tjänster hjälper utvecklare och organisationer att snabbt skapa intelligenta, spjutspets, marknadsklara och ansvarsfulla program med färdiga och anpassningsbara API:er och modeller. I den här artikeln använder du de olika tjänster som är tillgängliga i Azure AI-tjänster för att utföra uppgifter som: textanalys, översättning, dokumentinformation, vision, bildsökning, tal till text och text till talkonvertering, avvikelseidentifiering och dataextrahering från webb-API:er.

Målet med Azure AI-tjänster är att hjälpa utvecklare att skapa program som kan se, höra, tala, förstå och till och med börja resonera. Katalogen med tjänster i Azure AI-tjänster kan kategoriseras i fem huvudpelare: Vision, Speech, Language, Web Searchoch Decision.

Förutsättningar

Förbereda systemet

Börja genom att importera nödvändiga bibliotek och initiera Spark-sessionen.

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
import os

from pyspark.sql import SparkSession
from synapse.ml.core.platform import *

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

Importera Azure AI-tjänstbibliotek och ersätt nycklarna och platserna i följande kodfragment med din Azure AI-tjänstnyckel och plats.

from synapse.ml.cognitive import *

# A general Azure AI services key for Text Analytics, Vision and Document Intelligence (or use separate keys that belong to each service)
service_key = "<YOUR-KEY-VALUE>" # Replace <YOUR-KEY-VALUE> with your Azure AI service key, check prerequisites for more details
service_loc = "eastus"

# A Bing Search v7 subscription key
bing_search_key =  "<YOUR-KEY-VALUE>" # Replace <YOUR-KEY-VALUE> with your Bing v7 subscription key, check prerequisites for more details

# An Anomaly Detector subscription key
anomaly_key = <"YOUR-KEY-VALUE"> # Replace <YOUR-KEY-VALUE> with your anomaly service key, check prerequisites for more details
anomaly_loc = "westus2"

# A Translator subscription key
translator_key = "<YOUR-KEY-VALUE>" # Replace <YOUR-KEY-VALUE> with your translator service key, check prerequisites for more details
translator_loc = "eastus"

# An Azure search key
search_key = "<YOUR-KEY-VALUE>" # Replace <YOUR-KEY-VALUE> with your search key, check prerequisites for more details

Utföra attitydanalys på text

Tjänsten TextAnalys innehåller flera algoritmer för att extrahera intelligenta insikter från text. Du kan till exempel använda tjänsten för att hitta attityden för viss indatatext. Tjänsten returnerar en poäng mellan 0,0 och 1,0, där låga poäng indikerar negativt sentiment och höga poäng indikerar positivt sentiment.

Följande kodexempel returnerar sentimentet för tre enkla meningar.

# 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 cognitive services on spark aint bad", "en-US"),
    ],
    ["text", "language"],
)

# Run the Text Analytics service with options
sentiment = (
    TextSentiment()
    .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.document.sentiment").alias("sentiment")
    )
)

Utföra textanalys för hälsodata

Textanalysverktyget för hälsotjänsten extraherar och etiketterar relevant medicinsk information från ostrukturerad text som läkaranteckningar, utskrivningssammanfattningar, kliniska dokument och elektroniska hälsojournaler.

Följande kodexempel analyserar och transformerar text från läkaranteckningar till strukturerade data.

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

Översätta text till ett annat språk

Translator är en molnbaserad maskinöversättningstjänst och ingår i Azure AI-tjänstefamiljen med kognitiva API:er som används för att skapa intelligenta appar. Translator är lätt att integrera i dina program, webbplatser, verktyg och lösningar. Det gör att du kan lägga till användarupplevelser på flera språk på 90 språk och dialekter och kan användas för textöversättning med valfritt operativsystem.

Följande kodexempel gör en enkel textöversättning genom att ange de meningar som du vill översätta och målspråk som du vill översätta dem till.

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")
)

Extrahera information från ett dokument till strukturerade data

Azure AI Document Intelligence är en del av Azure AI-tjänster som gör att du kan skapa automatiserad databehandlingsprogramvara med hjälp av maskininlärningsteknik. Med Azure AI Document Intelligence kan du identifiera och extrahera text, nyckel/värde-par, urvalsmarkeringar, tabeller och struktur från dina dokument. Tjänsten matar ut strukturerade data som innehåller relationerna i den ursprungliga filen, avgränsningsrutor, konfidens med mera.

Följande kodexempel analyserar en visitkortsbild och extraherar dess information till strukturerade data.

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")
)

Analysera och tagga bilder

Datorseende analyserar bilder för att identifiera strukturer som ansikten, objekt och naturspråkliga beskrivningar.

Följande kodexempel analyserar bilder och etiketterar dem med taggar. Taggar är enordsbeskrivningar av saker i bilden, till exempel igenkännliga objekt, personer, landskap och åtgärder.

# 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"))

bildsökning i Bing söker på webben för att hämta bilder relaterade till en användares fråga på naturligt språk.

I följande kodexempel används en textfråga som söker efter bilder med citattecken. Kodens utdata är en lista över bild-URL:er som innehåller foton relaterade till frågan.

# 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))

Transformera tal till text

Tjänsten Tal till text konverterar strömmar eller filer med talat ljud till text. Följande kodexempel transkriberar en ljudfil till text.

# 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"))

Transformera text till tal

Text till tal är en tjänst som gör att du kan skapa appar och tjänster som talar naturligt och välja mellan fler än 270 neurala röster på 119 språk och varianter.

Följande kodexempel omvandlar text till en ljudfil som innehåller textens innehåll.

from synapse.ml.cognitive 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))

Identifiera avvikelser i tidsseriedata

Avvikelseidentifiering är bra för att identifiera oegentligheter i dina tidsseriedata. I följande kodexempel används tjänsten Avvikelseidentifiering för att hitta avvikelser i hela tidsseriedata.

# 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
anamoly_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(
    anamoly_detector.transform(df).select("timestamp", "value", "anomalies.isAnomaly")
)

Hämta information från godtyckliga webb-API:er

Med HTTP på Spark kan du använda valfri webbtjänst i din stordatapipeline. Följande kodexempel använder World Bank API för att få information om olika länder runt om i världen.

# 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 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 data returned
display(
    client.transform(df).select(
        "country", udf(get_response_body)(col("response")).alias("response")
    )
)

Relaterat innehåll