Usługi platformy Azure AI

Usługi azure AI ułatwiają deweloperom i organizacjom szybkie tworzenie inteligentnych, najnowocześniejszych, gotowych na rynek i odpowiedzialnych aplikacji z wbudowanymi i wstępnie utworzonymi i dostosowywalnymi interfejsami API oraz modelami.

Usługa SynapseML umożliwia tworzenie zaawansowanych i wysoce skalowalnych modeli predykcyjnych i analitycznych z różnych źródeł danych platformy Spark. Usługa Synapse Spark udostępnia wbudowane biblioteki synapseML, w tym synapse.ml.services.

Ważne

Od 20 września 2023 r. nie będzie można utworzyć nowych zasobów Narzędzie do wykrywania anomalii. Usługa Narzędzie do wykrywania anomalii jest wycofywana 1 października 2026 r.

Wymagania wstępne dotyczące usługi Azure Synapse Analytics

Samouczek Wymagania wstępne dotyczące korzystania z usług azure AI w usłudze Azure Synapse zawiera kilka kroków, które należy wykonać przed rozpoczęciem korzystania z usług Azure AI w usłudze Synapse Analytics.

Usługi azure AI to zestaw interfejsów API, zestawów SDK i usług, których deweloperzy mogą używać do dodawania inteligentnych funkcji do swoich aplikacji. Usługi sztucznej inteligencji umożliwiają deweloperom nawet wtedy, gdy nie mają bezpośrednich umiejętności sztucznej inteligencji ani nauki o danych ani wiedzy. Usługi sztucznej inteligencji platformy Azure ułatwiają deweloperom tworzenie aplikacji, które mogą wyświetlać, słyszeć, mówić, rozumieć, a nawet zaczynać rozumować. Katalog usług w ramach usług azure AI można podzielić na pięć głównych filarów: Vision, Speech, Language, Web search i Decision.

Użycie

Obraz

Przetwarzanie obrazów

• Opis: zawiera opis obrazu w języku czytelnym dla człowieka (Scala, Python)
• Analizuj (kolor, typ obrazu, twarz, zawartość dla dorosłych/rasowa): analizuje funkcje wizualne obrazu (Scala, Python)
• OCR: odczytuje tekst z obrazu (Scala, Python)
• Rozpoznawanie tekstu: odczytuje tekst z obrazu (Scala, Python)
• Miniatura: generuje miniaturę rozmiaru określonego przez użytkownika na podstawie obrazu (Scala, Python)
• Rozpoznawanie zawartości specyficznej dla domeny: rozpoznaje zawartość specyficzną dla domeny (celebryta, punkt orientacyjny) (Scala, Python)
• Tag: identyfikuje listę wyrazów, które są istotne dla obrazu wejściowego (Scala, Python)

Rozpoznawanie twarzy

• Wykrywanie: wykrywa ludzkie twarze na obrazie (Scala, Python)
• Sprawdź: sprawdza, czy dwie twarze należą do tej samej osoby, czy twarz należy do osoby (Scala, Python)
• Zidentyfikuj: znajduje najbliższe dopasowania określonej osoby kwerendy z grupy osób (Scala, Python)
• Znajdź podobne: znajduje podobne twarze do twarzy zapytania na liście twarzy (Scala, Python)
• Grupa: dzieli grupę twarzy na rozłączne grupy na podstawie podobieństwa (Scala, Python)

Mowa

Usługi mowy

• Zamiana mowy na tekst: transkrypcja strumieni audio (Scala, Python)
• Transkrypcja konwersacji: transkrybuje strumienie audio do transkrypcji na żywo z zidentyfikowanymi głośnikami. (Scala, Python)
• Zamiana tekstu na mowę: konwertuje tekst na realistyczny dźwięk (Scala, Python)

Język

Język sztucznej inteligencji

• Wykrywanie języka: wykrywa język tekstu wejściowego (Scala, Python)
• Wyodrębnianie kluczowych fraz: identyfikuje kluczowe punkty rozmowy w tekście wejściowym (Scala, Python)
• Rozpoznawanie nazwanych jednostek: identyfikuje znane jednostki i ogólne nazwane jednostki w tekście wejściowym (Scala, Python)
• Analiza tonacji: zwraca wynik z zakresu od 0 do 1 wskazujący tonację w tekście wejściowym (Scala, Python)
• Wyodrębnianie jednostek opieki zdrowotnej: wyodrębnia jednostki medyczne i relacje z tekstu. (Scala, Python)

Tłumaczenie

Translator

• Tłumaczenie: tłumaczy tekst. (Scala, Python)
• Transliteracja: konwertuje tekst w jednym języku z jednego skryptu na inny skrypt. (Scala, Python)
• Wykryj: identyfikuje język tekstu. (Scala, Python)
• BreakSentence: określa położenie granic zdań w tekście. (Scala, Python)
• Wyszukiwanie słownika: udostępnia alternatywne tłumaczenia wyrazów i niewielką liczbę fraz idiomatycznych. (Scala, Python)
• Przykłady słowników: zawiera przykłady pokazujące, jak terminy w słowniku są używane w kontekście. (Scala, Python)
• Tłumaczenie dokumentów: tłumaczy dokumenty we wszystkich obsługiwanych językach i dialektach przy zachowaniu struktury dokumentów i formatu danych. (Scala, Python)

Analiza dokumentów

Analiza dokumentów

• Analizuj układ: wyodrębnianie informacji o tekście i układzie z danego dokumentu. (Scala, Python)
• Analizowanie paragonów: wykrywa i wyodrębnia dane z paragonów przy użyciu optycznego rozpoznawania znaków (OCR) i naszego modelu paragonu, umożliwiając łatwe wyodrębnianie ustrukturyzowanych danych z paragonów, takich jak nazwa sprzedawcy, numer telefonu kupca, data transakcji, suma transakcji i nie tylko. (Scala, Python)
• Analizowanie wizytówek: wykrywa i wyodrębnia dane z wizytówek przy użyciu optycznego rozpoznawania znaków (OCR) i naszego modelu wizytówek, co umożliwia łatwe wyodrębnianie ustrukturyzowanych danych z wizytówek, takich jak nazwy kontaktów, nazwy firm, numery telefonów, wiadomości e-mail i inne. (Scala, Python)
• Analizowanie faktur: wykrywa i wyodrębnia dane z faktur przy użyciu optycznego rozpoznawania znaków (OCR) i modeli uczenia głębokiego z interpretacją faktur, umożliwiając łatwe wyodrębnianie danych ustrukturyzowanych z faktur, takich jak klient, dostawca, identyfikator faktury, data ukończenia faktury, łączna kwota faktury, kwota podatku, wysyłka do, rozliczenia, elementy liniowe i inne. (Scala, Python)
• Analizowanie dokumentów identyfikatorów: wykrywa i wyodrębnia dane z dokumentów identyfikacyjnych przy użyciu optycznego rozpoznawania znaków (OCR) i modelu dokumentów identyfikatorów, co umożliwia łatwe wyodrębnianie danych strukturalnych z dokumentów identyfikatorów, takich jak imię, nazwisko, data urodzenia, numer dokumentu i inne. (Scala, Python)
• Analizuj formularz niestandardowy: wyodrębnia informacje z formularzy (plików PDF i obrazów) do danych strukturalnych na podstawie modelu utworzonego na podstawie zestawu reprezentatywnych formularzy szkoleniowych. (Scala, Python)
• Pobieranie modelu niestandardowego: uzyskiwanie szczegółowych informacji o modelu niestandardowym. (Scala, Python)
• Wyświetlanie listy modeli niestandardowych: uzyskiwanie informacji o wszystkich modelach niestandardowych. (Scala, Python)

Decyzja

Narzędzie do wykrywania anomalii

• Stan anomalii najnowszego punktu: generuje model przy użyciu poprzednich punktów i określa, czy najnowszy punkt jest nietypowy (Scala, Python)
• Znajdowanie anomalii: generuje model przy użyciu całej serii i znajduje anomalie w serii (Scala, Python)

Search

• Wyszukiwanie obrazów Bing (Scala, Python)
• Azure Cognitive Search (Scala, Python)

Przygotowywanie systemu

Aby rozpocząć, zaimportuj wymagane biblioteki i zainicjuj sesję platformy Spark.

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

Zaimportuj biblioteki usług Azure AI i zastąp klucze i lokalizacje w poniższym fragmencie kodu kluczem i lokalizacją usług azure AI.

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.

Przeprowadzanie analizy tonacji w tekście

Usługa języka sztucznej inteligencji udostępnia kilka algorytmów do wyodrębniania inteligentnych szczegółowych informacji z tekstu. Na przykład możemy znaleźć tonację danego tekstu wejściowego. Usługa zwróci ocenę z zakresu od 0,0 do 1,0, gdzie niskie wyniki wskazują negatywną tonację i wysoki wynik wskazuje pozytywną tonację. W tym przykładzie są używane trzy proste zdania i zwraca tonację dla każdego z nich.

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

Wykonywanie analizy tekstu na potrzeby danych dotyczących kondycji

Analiza tekstu dla Usługa kondycji wyodrębnia i oznacza odpowiednie informacje medyczne z tekstu bez struktury, takie jak uwagi lekarza, podsumowania wypisu, dokumenty kliniczne i elektroniczne dokumenty zdrowotne.

Poniższy przykładowy kod analizuje i przekształca tekst z notatek lekarzy w dane ustrukturyzowane.

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

Tłumaczenie tekstu w innym języku

Translator to oparta na chmurze usługa tłumaczenia maszynowego i jest częścią rodziny usług sztucznej inteligencji platformy Azure interfejsów API sztucznej inteligencji używanych do tworzenia inteligentnych aplikacji. Translator jest łatwy do zintegrowania z aplikacjami, witrynami internetowymi, narzędziami i rozwiązaniami. Umożliwia dodawanie środowisk użytkownika w wielu językach w 90 językach i dialektach i może służyć do tłumaczenia tekstu bez hostowania własnego algorytmu.

Poniższy przykładowy kod wykonuje proste tłumaczenie tekstu, podając zdania, na które chcesz przetłumaczyć, i języki docelowe, na które chcesz je przetłumaczyć.

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

Wyodrębnianie informacji z dokumentu do danych strukturalnych

Usługa Azure AI Document Intelligence jest częścią aplikacja systemu Azure lied usług sztucznej inteligencji, która umożliwia tworzenie zautomatyzowanego oprogramowania do przetwarzania danych przy użyciu technologii uczenia maszynowego. Dzięki usłudze Azure AI Document Intelligence można identyfikować i wyodrębniać tekst, pary klucz/wartość, znaczniki wyboru, tabele i strukturę z dokumentów. Usługa generuje dane ustrukturyzowane, które zawierają relacje w oryginalnym pliku, pola ograniczenia, pewność siebie i nie tylko.

Poniższy przykładowy kod analizuje obraz wizytówki i wyodrębnia informacje na dane ustrukturyzowane.

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

przykład przetwarzanie obrazów

Usługa Azure AI Vision analizuje obrazy w celu zidentyfikowania struktury, takiej jak twarze, obiekty i opisy języka naturalnego.

Poniższy przykładowy kod analizuje obrazy i oznacza je tagami. Tagi to jeden wyraz opis elementów na obrazie, takich jak rozpoznawalne obiekty, osoby, sceneria i akcje.

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

Wyszukiwanie obrazów powiązanych z zapytaniem w języku naturalnym

Wyszukiwanie obrazów Bing wyszukuje w Internecie w celu pobrania obrazów powiązanych z zapytaniem w języku naturalnym użytkownika.

Poniższy przykładowy kod używa zapytania tekstowego, które wyszukuje obrazy z cudzysłowami. Dane wyjściowe kodu to lista adresów URL obrazów zawierających zdjęcia związane z zapytaniem.

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

Przekształcanie mowy na tekst

Usługa zamiany mowy na tekst konwertuje strumienie lub pliki dźwięku mówionego na tekst. Poniższy przykładowy kod transkrybuje jeden plik audio do tekstu.

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

Przekształcanie tekstu na mowę

Zamiana tekstu na mowę to usługa, która umożliwia tworzenie aplikacji i usług, które mówią naturalnie, wybierając spośród ponad 270 neuronowych głosów w 119 językach i wariantach.

Poniższy przykładowy kod przekształca tekst w plik audio zawierający zawartość tekstu.

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

Wykrywanie anomalii w danych szeregów czasowych

Jeśli nie masz utworzonego zasobu wykrywania anomalii przed 20 września 2023 r., nie będzie można go utworzyć. Możesz pominąć tę część.

Narzędzie do wykrywania anomalii doskonale nadaje się do wykrywania nieprawidłowości w danych szeregów czasowych. Poniższy przykładowy kod używa usługi Narzędzie do wykrywania anomalii do znajdowania anomalii w szeregach czasowych.

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

Pobieranie informacji z dowolnych internetowych interfejsów API

Protokół HTTP na platformie Spark umożliwia użycie dowolnej usługi internetowej w potoku danych big data. W tym przykładzie użyjemy interfejsu API Banku Światowego, aby uzyskać informacje o różnych krajach na całym świecie.

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

Przykład wyszukiwania sztucznej inteligencji platformy Azure

W tym przykładzie pokazano, jak wzbogacić dane przy użyciu umiejętności poznawczych i zapisać w indeksie usługi Azure Search przy użyciu usługi 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",
)