Freigeben über

Azure KI Services

  • 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.

SynapseML ermöglicht die Erstellung leistungsstarker und hochgradig skalierbarer Vorhersage- und Analysemodelle auf der Grundlage verschiedener Spark-Datenquellen. Synapse Spark bietet integrierte SynapseML-Bibliotheken, einschließlich synapse.ml.services.

Wichtig

Ab dem 20. September 2023 können Sie keine neuen Ressourcen für die Anomalieerkennung mehr erstellen. Der Dienst für die Anomalieerkennung wird am 1. Oktober 2026 eingestellt.

Voraussetzungen für Azure Synapse Analytics

Das Tutorial Voraussetzungen für die Verwendung von Azure KI Services in Azure Synapse Analytics führt Sie durch einige Schritte, die Sie ausführen müssen, bevor Sie Azure KI Services in Synapse Analytics verwenden können.

Azure KI Services ist eine Suite von APIs, SDKs und Diensten, die Entwickler verwenden können, um ihren Anwendungen intelligente Features hinzuzufügen. KI Services unterstützt Entwickler auch dann, wenn sie nicht über direkte KI- oder Data Science-Fähigkeiten oder -Kenntnisse verfügen. Azure KI-Dienste helfen Entwicklern, 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.

Verbrauch

Bildanalyse

Maschinelles Sehen

  • Beschreiben: Stellt eine Beschreibung eines Bilds in lesbarer Sprache bereit. (Scala, Python)
  • Analysieren (Farbe, Bildtyp, Gesicht, nicht jugendfreie/gewagte Inhalte): Analysiert visuelle Merkmale eines Bilds. (Scala, Python)
  • OCR: Liest Text aus einem Bild. (Scala, Python)
  • Texterkennung: Liest Text aus einem Bild. (Scala, Python)
  • Miniaturansicht: Generiert eine Miniaturansicht mit benutzerdefinierter Größe aus dem Bild. (Scala, Python)
  • Domänenspezifischer Inhalte erkennen: Erkennt domänenspezifische Inhalte (Prominente, Sehenswürdigkeiten). (Scala, Python)
  • Tag: Identifiziert die Liste der Wörter, die für das Eingabebild relevant sind. (Scala, Python)

Gesicht

  • Erkennen: Erkennt menschliche Gesichter in einem Bild. (Scala, Python)
  • Überprüfen: Überprüft, ob zwei Gesichter zu derselben Person gehören oder ob ein Gesicht zu einer bestimmten Person gehört. (Scala, Python)
  • Identifizieren: Findet die besten Übereinstimmungen des Gesichts der spezifischen Person in der Abfrage aus einer Personengruppe heraus. (Scala, Python)
  • Ähnliche suchen: Findet ähnliche Gesichter wie das in der Abfrage angegebene Gesicht in einer Liste von Gesichtern. (Scala, Python)
  • Gruppieren: Unterteilt eine Gruppe von Gesichtern basierend auf Ähnlichkeit in getrennte Gruppen. (Scala, Python)

Spracheingabe/-ausgabe

Speech-Dienste

  • Spracherkennung: Transkribiert Audiodatenströme. (Scala, Python)
  • Unterhaltungstranskription: Transkribiert Audiodatenströme in Livetranskripte mit identifizierten Sprechern. (Scala, Python)
  • Sprachsynthese: Konvertiert Text in realistische Audiodaten. (Scala, Python)

Sprache

KI Language

  • Sprachenerkennung: Erkennt die Sprache des Eingabetexts. (Scala, Python)
  • Schlüsselbegriffsextraktion: Identifiziert die wichtigsten Gesprächspunkte im Eingabetext. (Scala, Python)
  • Erkennung benannter Entitäten: Identifiziert bekannte Entitäten und allgemeine benannte Entitäten im Eingabetext. (Scala, Python)
  • Stimmungsanalyse: Gibt einen Wert zwischen 0 und 1 zurück, der die Stimmung im Eingabetext angibt. (Scala, Python)
  • Extraktion von Entitäten im Gesundheitswesen: Extrahiert medizinische Entitäten und Beziehungen aus Text. (Scala, Python)

Sprachübersetzung

Translator

  • Übersetzen: Übersetzt Text. (Scala, Python)
  • Transkribieren: Konvertiert Text in einer Sprache aus einem Skript in ein anderes Skript. (Scala, Python)
  • Erkennen: Identifiziert die Sprache eines Textabschnitts. (Scala, Python)
  • BreakSentence: Erkennt die Positionierung von Satzgrenzen in einem Textabschnitt. (Scala, Python)
  • Wörterbuchsuche: Stellt alternative Übersetzungen für ein Wort und eine kleine Anzahl von idiomatischen Ausdrücken bereit. (Scala, Python)
  • Wörterbuchbeispiele: Stellt Kontextbeispiele für die Verwendung von Begriffen im Wörterbuch bereit. (Scala, Python)
  • Dokumentübersetzung: Übersetzt Dokumente in alle und aus allen unterstützten Sprachen und Dialekten, wobei Dokumentstruktur und Datenformat beibehalten werden. (Scala, Python)

Dokument Intelligenz

Dokument Intelligenz

  • Layout analysieren: Extrahiert Text- und Layoutinformationen aus einem bestimmten Dokument. (Scala, Python)
  • Belege analysieren: Erkennt und extrahiert Daten aus Belegen mithilfe der optischen Zeichenerkennung (Optical Character Recognition, OCR) und unseres Belegmodells, sodass Sie problemlos strukturierte Daten aus Belegen wie Händlername- und telefonnummer, Transaktionsdatum und -summe und noch weitere Informationen extrahieren können. (Scala, Python)
  • Visitenkarten analysieren: Erkennt und extrahiert Daten aus Visitenkarten mithilfe der optischen Zeichenerkennung (Optical Character Recognition, OCR) und unseres Visitenkartenmodells, sodass Sie aus Visitenkarten problemlos strukturierte Daten wie Kontakt- und Firmenname, Telefonnummern, E-Mail-Adressen und vieles mehr extrahieren können. (Scala, Python)
  • Rechnungen analysieren: Erkennt und extrahiert Daten aus Rechnungen mithilfe der optischen Zeichenerkennung (Optical Character Recognition, OCR) und unserer Deep Learning-Modelle, sodass Sie aus Rechnungen problemlos strukturierte Daten extrahieren können, z. B. Kunde, Lieferant, Rechnungs-ID, Fälligkeitsdatum der Rechnung, Gesamtsumme, fälliger Rechnungsbetrag, Steuerbetrag, Lieferadresse, Rechnungsadresse, Posten und mehr. (Scala, Python)
  • Ausweisdokumente analysieren: Erkennt und extrahiert Daten aus Ausweisdokumenten mithilfe der optischen Zeichenerkennung (Optical Character Recognition, OCR) und unseres Ausweisdokumentmodells, sodass Sie aus Ausweisdokumenten strukturierte Daten problemlos extrahieren können, z. B. Vorname, Nachname, Geburtsdatum, Ausweisnummer usw. (Scala, Python)
  • Benutzerdefiniertes Formular analysieren: Extrahiert Informationen aus Formularen (PDFs und Bildern) in strukturierte Daten basierend auf einem Modell, das aus einer Reihe repräsentativer Trainingsformulare erstellt wurde. (Scala, Python)
  • Benutzerdefiniertes Modell abrufen: Dieser Vorgang ruft ausführliche Informationen zu einem benutzerdefinierten Modell ab. (Scala, Python)
  • Benutzerdefinierte Modelle auflisten: Ruft Informationen zu allen benutzerdefinierten Modellen ab. (Scala, Python)

Entscheidung

Anomalieerkennung

  • Anomaliestatus des letzten Punkts: Generiert ein Modell anhand vorheriger Punkte und ermittelt, ob der letzte Punkt anomal ist. (Scala, Python)
  • Anomalien suchen: Generiert ein Modell anhand einer ganzen Reihe und findet Anomalien in der Reihe. (Scala, Python)

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

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

Ausführen von Standpunktanalysen für Text

Der KI Language-Dienst bietet mehrere Algorithmen zum Extrahieren intelligenter Erkenntnisse aus Texten. Beispielsweise können wir die Stimmung eines Eingabetexts ermitteln. Der Dienst gibt eine Bewertung zwischen 0,0 und 1,0 zurück, wobei niedrige Scores auf eine negative Stimmung und hohe Scores auf eine positive Stimmung hindeuten. In diesem Beispiel werden drei einfache Sätze verwendet, und es wird jeweils die Stimmung 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 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")
    )
)

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

Translator ist ein Clouddienst für maschinelle Übersetzung und gehört zur Azure KI Services-Familie von KI-APIs für die Erstellung intelligenter Apps. Translator lässt sich einfach in Ihre Anwendungen, Websites, Tools und Lösungen integrieren. Er ermöglicht Ihnen, mehrsprachige Benutzeroberflächen in 90 Sprachen und Dialekten hinzufügen. Darüber hinaus kann er verwendet werden, um Text zu übersetzen, ohne Ihren eigenen Algorithmus zu hosten.

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 Teil der Azure Applied 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")
)

Beispiel für maschinelles Sehen

Azure KI Vision 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.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))

Erkennen von Anomalien in Zeitreihendaten

Wenn Sie keine Ressource für die Anomalieerkennung vor dem 20. September 2023 erstellt haben, können Sie keine erstellen. Sie können diesen Teil überspringen.

Die Anomalieerkennung eignet sich hervorragend zum Erkennen von Unregelmäßigkeiten in ihren Zeitreihendaten Im folgenden Codebeispiel wird der Dienst für die Anomalieerkennung verwendet, um Anomalien in einer 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 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 alle Webdienste in Ihrer Big Data-Pipeline verwendet werden. In diesem Beispiel verwenden wir die World Bank-API, 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")
    )
)

Azure KI-Suchbeispiel

In diesem Beispiel wird gezeigt, wie Sie Daten mithilfe von kognitiven Skills anreichern und mithilfe von SynapseML in einen Azure Search-Index schreiben können.

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