Freigeben über

Verwenden von Azure KI Services mit SynapseML in Microsoft Fabric

  • Artikel

Azure KI Services unterstützen Entwickler und Unternehmen bei der schnellen Erstellung intelligenter, hochmoderner, marktreifer und verantwortungsbewusster Anwendungen mit sofort einsatzbereiten, vorgefertigten und anpassbaren APIs und Modellen. In diesem Artikel verwenden Sie die verschiedenen in Azure KI Services verfügbaren Dienste, um Aufgaben wie Textanalyse, Übersetzung, Dokument Intelligenz, maschinelles Sehen, Bildersuche, Spracherkennungs- und Sprachsynthesekonvertierung, Anomalieerkennung und Datenextraktion aus Web-APIs auszuführen.

Das Ziel von Azure KI Services ist es, Entwicklern zu helfen, Anwendungen zu entwickeln, die sehen, hören, sprechen, verstehen und sogar schlussfolgern können. Die in Azure KI Services verfügbaren Dienste können in fünf Hauptkategorien unterteilt werden: Sehen, Sprechen, Sprache, Websuche und Entscheidungsfindung.

Voraussetzungen

  • Erstellen Sie ein neues Notebook.
  • Fügen Sie Ihr Notebook an ein Lakehouse an. Wählen Sie auf der linken Seite Ihres Notebooks Hinzufügen aus, um ein vorhandenes Lakehouse hinzuzufügen oder ein neues zu erstellen.
  • Rufen Sie einen Azure KI Services-Schlüssel ab, indem Sie die Schritte unter Schnellstart: Erstellen einer Ressource für mehrere Dienste für Azure KI Services ausführen. Kopieren Sie den Wert des Schlüssels, der in den folgenden Codebeispielen verwendet werden soll.

Vorbereiten Ihres Systems

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

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

Importieren Sie Azure KI Services-Bibliotheken, und ersetzen Sie die Schlüssel im folgenden Codeschnipsel durch Ihren Azure KI Services-Schlüssel.

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

Ausführen von Standpunktanalysen für Text

Der Textanalyse-Dienst bietet mehrere Algorithmen zum Extrahieren intelligenter Erkenntnisse aus Text. Sie können den Dienst beispielsweise verwenden, um die Stimmung einiger Eingabetexte zu ermitteln. Der Dienst gibt eine Bewertung zwischen 0,0 und 1,0 zurück, wobei eine niedrigere Zahl auf eine negative Stimmung und eine hohe auf eine positive Stimmung hindeutet.

Im folgenden Codebeispiel wird die Stimmung für drei einfache Sätze zurückgegeben.

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

Ausführen einer Textanalyse für Gesundheitsdaten

Der DienstText Analytics for Health extrahiert und bezeichnet relevante medizinische Informationen aus unstrukturierten Texten wie Arztbriefen, Entlassungsberichten, klinischen Dokumenten und elektronischen Gesundheitsakten.

Im folgenden Codebeispiel wird Text aus Notizen von Ärzt*innen analysiert und in strukturierte Daten umgewandelt.

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

Textübersetzung ist ein cloudbasierter Dienst für die maschinelle Übersetzung und gehört zur Azure KI Services-Familie kognitiver APIs für die Erstellung intelligenter Apps. Translator lässt sich einfach in Ihre Anwendungen, Websites, Tools und Lösungen integrieren. Mit dieser App können mehrsprachige Benutzeroberflächen in mehr als 90 Sprachen und Dialekten bereitgestellt werden. Darüber hinaus kann sie unter jedem Betriebssystem für die Textübersetzung verwendet werden.

Im folgenden Codebeispiel wird eine einfache Textübersetzung ausgeführt, indem Sie die zu übersetzenden Sätze und die Zielsprachen angeben, in die Sie übersetzen möchten.

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

Extrahieren von Informationen aus einem Dokument in strukturierte Daten

Azure KI Dokument Intelligenz ist ein Dienst der Azure KI Services, der Ihnen ermöglicht, unter Verwendung von Technologien zum maschinellen Lernen Software für die automatisierte Datenverarbeitung zu entwickeln. Mit Azure KI Dokument Intelligenz können Sie Text, Schlüssel-Wert-Paare, Auswahlzeichen, Tabellen und die Struktur in Ihren Dokumenten identifizieren und daraus extrahieren. Der Dienst gibt strukturierte Daten aus, die die Beziehungen in der Originaldatei, Begrenzungsrahmen, Sicherheit und mehr enthalten.

Im folgenden Codebeispiel wird das Bild einer Visitenkarte analysiert und dessen Informationen in strukturierte Daten extrahiert.

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

Analysieren und Markieren von Bildern

Maschinelles Sehen analysiert Bilder, um die Struktur zu identifizieren, wie z. B. Gesichter, Objekte und Beschreibungen in natürlicher Sprache.

Im folgenden Codebeispiel werden Bilder analysiert und mit Tags beschriftet. Tags sind Einwortbeschreibungen der Dinge im Bild, wie z. B. erkennbare Objekte, Personen, Szenen und Aktionen.

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

Die Bing-Bildersuche durchsucht das Web nach Bildern im Zusammenhang mit einer Abfrage in natürlicher Sprache eines Benutzers.

Im folgenden Codebeispiel wird eine Textabfrage verwendet, die nach Bildern mit Zitaten sucht. Die Ausgabe des Codes ist eine Liste von Bild-URLs, die Fotos enthalten, die sich auf die Abfrage beziehen.

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

Transformieren von Sprache zu Text

Der Spracherkennungsdienst konvertiert Streams oder Dateien gesprochener Audiodaten in Text. Im folgenden Codebeispiel wird eine Audiodatei in Text transkribiert.

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

Transformieren von Text zu Sprache

Text-zu-Sprache ist ein Dienst, mit dem Apps und Dienste mit natürlicher Sprache erstellt werden können. Dabei können Sie aus mehr als 270 neuronalen Stimmen in 119 Sprachen und Varianten wählen.

Im folgenden Codebeispiel wird Text in eine Audiodatei umgewandelt, die den Inhalt des Texts enthält.

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

Erkennen von Anomalien in Zeitreihendaten

Die Anomalieerkennung eignet sich hervorragend zum Erkennen von Unregelmäßigkeiten in ihren Zeitreihendaten Im folgenden Codebeispiel wird der Anomalieerkennung-Dienst verwendet, um Anomalien in gesamten Zeitreihendaten 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 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")
)

Abrufen von Informationen von beliebigen Web-APIs

Mit HTTP in Spark können Sie beliebige Webdienste in Ihrer Big Data-Pipeline verwenden. Im folgenden Codebeispiel wird die World Bank-API verwendet, um Informationen zu verschiedenen Ländern auf der ganzen Welt zu erhalten.

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

Zugehöriger Inhalt