Freigeben über

Verwenden von Azure AI-Diensten mit SynapseML in Microsoft Fabric

Azure AI-Dienste helfen Entwicklern und Organisationen, verantwortungsvolle Anwendungen mit einsatzbereiten und anpassbaren APIs und Modellen zu erstellen. In diesem Artikel verwenden Sie Azure AI-Dienste, um Aufgaben auszuführen, die Folgendes umfassen: Textanalyse, Übersetzung, Dokumentintelligenz, Vision, Bildsuche, Sprache zu Text und Text zu Sprache, Anomalieerkennung und Datenextraktion aus Web-APIs.

Azure AI-Dienste helfen Entwicklern beim Erstellen von Anwendungen, die Anwendungen sehen, hören, sprechen, verstehen und mit dem Grund beginnen. Der Azure AI-Dienstkatalog umfasst fünf Säulen: Vision, Sprache, Sprache, Websuche und Entscheidung.

Voraussetzungen

Bereiten Sie Ihr System vor

Importieren Sie zunächst die erforderlichen Bibliotheken, und initialisieren Sie eine Spark-Sitzung.

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

from pyspark.sql import SparkSession

# Start a Spark session.
spark = SparkSession.builder.getOrCreate()

Importieren Sie die Azure AI-Dienstbibliotheken. Ersetzen Sie im folgenden Code den Platzhaltertext <YOUR-KEY-VALUE> durch Ihre eigenen Schlüssel, und legen Sie die Positionswerte für jeden Dienst fest.

from synapse.ml.cognitive import *

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

# A Bing Search v7 subscription key.
bing_search_key = "<YOUR-KEY-VALUE>"  # Replace `<YOUR-KEY-VALUE>` with your Bing Search v7 subscription key. See prerequisites for details.

# An Anomaly Detector subscription key.
anomaly_key = "<YOUR-KEY-VALUE>"  # Replace `<YOUR-KEY-VALUE>` with your Anomaly Detector key. See prerequisites for details.
anomaly_loc = "westus2"

# A Translator subscription key.
translator_key = "<YOUR-KEY-VALUE>"  # Replace `<YOUR-KEY-VALUE>` with your Translator key. See prerequisites for details.
translator_loc = "eastus"

# An Azure Search key.
search_key = "<YOUR-KEY-VALUE>"  # Replace `<YOUR-KEY-VALUE>` with your Azure Search key. See prerequisites for details.

Analysieren der Stimmung im Text

Der Text Analytics--Dienst bietet mehrere Algorithmen zum Extrahieren intelligenter Erkenntnisse aus Text. Verwenden Sie beispielsweise den Dienst, um die Stimmung im Eingabetext zu analysieren. Der Dienst gibt eine Bewertung zwischen 0,0 und 1,0 zurück: Niedrige Bewertungen deuten auf negative Stimmung hin, und hohe Bewertungen deuten auf positive Stimmung hin.

In diesem Codebeispiel wird die Stimmung für drei Sätze zurückgegeben.

# Create a DataFrame that's tied to its column names
df = spark.createDataFrame(
    [
        ("I am so happy today, it's sunny!", "en-US"),
        ("I am frustrated by this rush hour traffic", "en-US"),
        ("The cognitive services on Spark aren't 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 in a table.
display(
    sentiment.transform(df).select(
        "text", col("sentiment.document.sentiment").alias("sentiment")
    )
)

Durchführen von Textanalysen für Gesundheitsdaten

Text analytics for health extracts and labels medical information from unstrukturd text like doctor es notes, discharge summaryes, clinical documents, and electronic health records.

In diesem Codebeispiel werden Text aus Arztnotizen analysiert und strukturierte Daten zurückgegeben.

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

Übersetzen von Text in eine andere Sprache

Translator ist ein cloudbasierter maschineller Übersetzungsdienst, der Teil der Azure AI-Dienstfamilie von kognitiven APIs zum Erstellen intelligenter Apps ist. Übersetzer lässt sich problemlos in Ihre Apps, Websites, Tools und Lösungen integrieren. Es ermöglicht Ihnen, mehrsprachige Oberflächen in 90 Sprachen und Dialekten hinzuzufügen, und es funktioniert auf jedem Betriebssystem für die Textübersetzung.

Im folgenden Codebeispiel werden die Eingabesätze in die Zielsprachen übersetzt.

from pyspark.sql.functions import col, flatten

# Create a DataFrame with the sentences to translate
df = spark.createDataFrame(
    [(["Hello, what is your name?", "Bye"],)],
    [
        "text",
    ],
)

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

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

Extrahieren von Informationen aus einem Dokument in strukturierte Daten

Azure AI Document Intelligence ist Teil von Azure AI-Diensten und ermöglicht Ihnen das Erstellen automatisierter Datenverarbeitungssoftware mit maschinellem Lernen. Verwenden Sie Azure AI Document Intelligence, um Text, Schlüsselwertpaare, Auswahlmarkierungen, Tabellen und Struktur aus Ihren Dokumenten zu identifizieren und zu extrahieren. Der Dienst gibt strukturierte Daten aus, die Beziehungen aus der ursprünglichen Datei, begrenzungsfelder, Konfidenzergebnisse und vieles mehr enthalten.

Der folgende Code analysiert ein Visitenkartenbild und extrahiert seine Informationen als strukturierte Daten.

from pyspark.sql.functions import col, explode

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

# Run Azure AI Document Intelligence
analyzeBusinessCards = (
    AnalyzeBusinessCards()
    .setSubscriptionKey(service_key)
    .setLocation(service_loc)
    .setImageUrlCol("source")
    .setOutputCol("businessCards")
)

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

Analysieren und Kategorisieren von Bildern

Azure AI Vision analysiert Bilder, um Gesichter, Objekte und Beschreibungen natürlicher Sprachen zu identifizieren.

In diesem Codebeispiel werden Bilder analysiert und mit Tags beschriftet. Tags sind Einwortbeschreibungen von Objekten, Personen, Landschaften und Aktionen in einem Bild.

# Create a DataFrame with 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 Azure AI Vision to analyze images and extract information.
analysis = (
    AnalyzeImage()
    .setLocation(service_loc)
    .setSubscriptionKey(service_key)
    .setVisualFeatures(
        ["Categories", "Color", "Description", "Faces", "Objects", "Tags"]
    )
    .setOutputCol("analysis_results")
    .setImageUrlCol("image")
    .setErrorCol("error")
)

# Show the description tags.
display(analysis.transform(df).select("image", "analysis_results.description.tags"))

Bing-Bildsuche durchsucht das Web, um Bilder abzurufen, die sich auf die Abfrage natürlicher Sprache eines Benutzers beziehen.

In diesem Beispiel wird eine Textabfrage verwendet, um Bilder von Anführungszeichen zu finden. Sie gibt eine Liste von Bild-URLs aus, die mit der Abfrage zusammenhängen.

# Number of images Bing returns per query
imgsPerBatch = 10
# List of offsets to page through the search results
offsets = [(i * imgsPerBatch,) for i in range(100)]
# Create a DataFrame of offsets to page through results
bingParameters = spark.createDataFrame(offsets, ["offset"])

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

# Create a transformer that extracts and flattens the Bing Image Search output into a single URL column
getUrls = BingImageSearch.getUrlTransformer("images", "url")

# Display the full results. Uncomment to use
# display(bingSearch.transform(bingParameters))

# Put both services into a pipeline
pipeline = PipelineModel(stages=[bingSearch, getUrls])

# Show the image URLs returned by the search
display(pipeline.transform(bingParameters))

Konvertieren von Spracherkennung in Text

Der Azure AI Speech-Dienst konvertiert gesprochene Audiodatenströme oder Dateien in Text. Im folgenden Codebeispiel wird eine Audiodatei transkribiert.

# Create a DataFrame with the audio URL in the 'url' column
df = spark.createDataFrame(
    [("https://mmlspark.blob.core.windows.net/datasets/Speech/audio2.wav",)], ["url"]
)

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

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

Transformieren von Text in Sprache

Text-zu-Sprache ist ein Dienst, mit dem Sie Apps und Dienste erstellen können, die natürlich sprechen. Wählen Sie aus mehr als 270 neuralen Stimmen aus 119 Sprachen und Varianten.

Im folgenden Codebeispiel wird Text in eine Audiodatei konvertiert.

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 that there are no errors during audio creation
display(tts.transform(df))

Erkennen von Anomalien in Zeitreihendaten

Anomaliedetektor erkennt Unregelmäßigkeiten in Zeitreihendaten. In diesem Beispiel wird der Anomaly Detector-Dienst verwendet, um Anomalien in einer ganzen Zeitreihe zu finden.

# 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 Anomaly Detector to detect anomalies
anomaly_detector = (
    SimpleDetectAnomalies()
    .setSubscriptionKey(anomaly_key)
    .setLocation(anomaly_loc)
    .setTimestampCol("timestamp")
    .setValueCol("value")
    .setOutputCol("anomalies")
    .setGroupbyCol("group")
    .setGranularity("monthly")
)

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

Abrufen von Informationen aus beliebigen Web-APIs

Verwenden Sie einen beliebigen Webdienst in Ihrer großen Pipeline mit HTTP auf Spark. Im folgenden Codebeispiel wird die Weltbank-API verwendet, um Informationen zu verschiedenen Ländern und Regionen auf der ganzen Welt abzurufen.

# Use any request 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 that specifies the countries to get data for.
df = spark.createDataFrame([("br",), ("usa",)], ["country"]).withColumn(
    "request", http_udf(world_bank_request)(col("country"))
)

# Improve big data performance by using 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 country details from the response.
display(
    client.transform(df).select(
        "country", udf(get_response_body)(col("response")).alias("response")
    )
)

Verwandte Inhalte

  • Last updated on