Narzędzia odlewni

Narzędzia foundry ułatwiają deweloperom i organizacjom szybkie tworzenie inteligentnych, najnowocześniejszych, gotowych na rynek i odpowiedzialnych aplikacji za pomocą gotowych do użycia i wstępnie utworzonych i dostosowywalnych interfejsów API i modeli.

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 Detektora anomalii. Usługa Detekcji Anomalii zostanie wycofana 1 października 2026 r.

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

Samouczek , wymagania wstępne dotyczące korzystania z narzędzi Foundry Tools w usłudze Azure Synapse, przeprowadzi Cię przez kilka kroków, które należy wykonać przed użyciem narzędzi Foundry w usłudze Synapse Analytics.

Foundry Tools to zestaw interfejsów API, zestawów SDK i usług, których deweloperzy mogą używać do dodawania inteligentnych funkcji do swoich aplikacji. Narzędzia foundry dają deweloperom możliwości nawet w przypadku, gdy brakuje im bezpośrednich umiejętności w zakresie sztucznej inteligencji lub nauki o danych czy też ogólnej wiedzy na ten temat. Narzędzia Foundry pomagają deweloperom tworzyć aplikacje, które mogą widzieć, słyszeć, mówić, rozumieć, a nawet rozumować. Katalog usług w narzędziu Foundry Tools można podzielić na pięć głównych filarów: Vision, Speech, Language, Web search i Decision.

Użycie

Wizja

Wizja komputerowa

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

Twarz

• 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 twarzy osoby zapytania spośród grupy osób (Scala, Python)
• Znajdź podobne: wyszukuje twarze podobne do twarzy z 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 mówcami. (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 głębokiego uczenia do interpretacji faktur, umożliwiając łatwe wyodrębnianie danych ustrukturyzowanych z faktur, takich jak klient, dostawca, identyfikator faktury, termin płatności faktury, kwota do zapłaty, kwota podatku, adres wysyłki, adres rozliczeniowy, pozycje faktury 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)
• Pobierz model niestandardowy: uzyskaj szczegółowe informacje o modelu niestandardowym. (Scala, Python)
• Wyświetl listę modeli niestandardowych: Uzyskaj informacje 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 Narzędzi Foundry i zastąp klucze i lokalizacje w poniższym fragmencie kodu swoimi kluczami i lokalizacjami Narzędzi Foundry.

from synapse.ml.services import *
from synapse.ml.core.platform import *

# A general Foundry Tools key for Azure Language in Foundry Tools, Computer Vision and Azure Document Intelligence in Foundry Tools (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 sentymentu tekstu

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ę. Ten przykład używa trzech prostych zdań i zwraca sentiment 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 Foundry Tools 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ług Zdrowotnych wyodrębnia i oznacza odpowiednie informacje medyczne z tekstu niestrukturalizowanego, takie jak uwagi lekarza, podsumowania wypisu, dokumenty kliniczne i elektroniczne rekordy 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

Usługa Azure Translator w narzędziu Foundry Tools to oparta na chmurze usługa tłumaczenia maszynowego i jest częścią rodziny narzędzi Foundry Tools 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

Analiza dokumentów jest częścią usług Azure Applied AI Services, która umożliwia tworzenie zautomatyzowanego oprogramowania do przetwarzania danych przy użyciu technologii uczenia maszynowego. Za pomocą analizy dokumentów 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, ramki ograniczające, stopień pewności i inne.

Poniższy przykładowy kod analizuje obraz wizytówki i przekształca informacje w 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 wizji komputerowej

Usługa Azure Vision w narzędziu Foundry Tools analizuje obrazy w celu identyfikowania 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 przeszukuje Internet, aby znaleźć obrazy powiązane 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. Przykład kodu poniżej używa usługi wykrywania anomalii do znajdowania anomalii w szeregu czasowym.

# 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
anomaly_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(
    anomaly_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/regionach 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/regions 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/region 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",
)