Condividi tramite

Usare Servizi di Azure AI con SynapseML in Microsoft Fabric

  • Articolo

I Servizi di Azure AI consentono a sviluppatori e organizzazioni di creare rapidamente applicazioni intelligenti, all'avanguardia, pronte per il mercato e responsabili con API e modelli predefiniti e personalizzabili. In questo articolo si useranno i vari servizi disponibili nei servizi di intelligenza artificiale di Azure per eseguire attività che includono analisi del testo, traduzione, intelligenza dei documenti, visione, ricerca di immagini, sintesi vocale e sintesi vocale, rilevamento anomalie ed estrazione dei dati dalle API Web.

L'obiettivo di Servizi di Azure AI è aiutare gli sviluppatori a creare applicazioni che possano vedere, sentire, parlare, comprendere e persino iniziare a ragionare. Il catalogo dei servizi all'interno di Servizi di Azure AI può essere suddiviso in cinque pilastri principali: visione, voce, lingua, ricerca Web e decisione.

Prerequisiti

Preparare il sistema

Per iniziare, importare le librerie necessarie e inizializzare la sessione 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
import os

from pyspark.sql import SparkSession
from synapse.ml.core.platform import *

# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()

Importare le librerie dei servizi di intelligenza artificiale di Azure e sostituire le chiavi e i percorsi nel frammento di codice seguente con la chiave e la posizione dei servizi di intelligenza artificiale di Azure.

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

Eseguire l'analisi del sentiment sul testo

Il servizio Analisi del testo fornisce diversi algoritmi per estrarre dati analitici intelligenti dal testo. Ad esempio, è possibile usare il servizio per trovare il sentiment di un testo di input. Il servizio restituirà un punteggio compreso tra 0.0 e 1.0 in cui punteggi bassi indicano una valutazione negativa e un punteggio alto indica una valutazione positiva.

L'esempio di codice seguente restituisce il sentiment per tre frasi semplici.

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

Eseguire analisi del testo per i dati di integrità

L’Analisi del testo per il Servizio integrità estrae ed etichetta informazioni mediche rilevanti da testi non strutturati, ad esempio referti medici, riepiloghi di dimissioni, documenti clinici e cartelle cliniche elettroniche.

L'esempio di codice seguente analizza e trasforma il testo dalle note dei medici in dati strutturati.

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

Tradurre il testo in una lingua diversa

Translator è un servizio di traduzione automatica basato sul cloud e fa parte della famiglia di Servizi di Azure AI di API cognitive usate per lo sviluppo di app intelligenti. Traduttore è facilmente integrabile in applicazioni, siti Web, strumenti e soluzioni. Consente di aggiungere esperienze utente multilingue in 90 lingue e dialetti e può essere usato per la traduzione testuale con qualsiasi sistema operativo.

In questo campione di codice viene eseguita una semplice traduzione testuale specificando le frasi da tradurre e le lingue di destinazione in cui li si vuole tradurre.

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

Estrarre informazioni da un documento in dati strutturati

Azure AI Document Intelligence è un servizio di Azure per intelligenza artificiale che consente di creare software di elaborazione dati automatica tramite la tecnologia di Machine Learning. Con Azure AI Document Intelligence, è possibile identificare ed estrarre testo, coppie chiave/valore, segni di selezione, tabelle e struttura dai documenti. Il servizio restituisce dati strutturati che includono le relazioni nel file originale, rettangoli delimitatori, attendibilità e altro ancora.

In questo campione di codice viene analizzata l'immagine di un biglietto da visita estraendo le informazioni in dati strutturati.

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

Analizzare e contrassegnare le immagini

Visione artificiale analizza le immagini per identificare la struttura, ad esempio visi, oggetti e descrizioni in linguaggio naturale.

Nell'esempio di codice seguente vengono analizzate le immagini e le etichette con tag. I tag sono descrizioni costituite da una sola parola di elementi presenti nell'immagine, come persone, scenari, azioni e oggetti riconoscibili.

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

Ricerca immagini Bing cerca nel Web e recupera immagini correlate a una query dell'utente in linguaggio naturale.

In questo esempio di codice viene usata una query di testo che cerca immagini con virgolette. L'output del codice è un elenco di URL di immagini che contengono foto correlate alla query.

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

Trasformare la voce in testo

Il servizio Riconoscimento vocale converte flussi o file di parlato audio in testo. L'esempio di codice seguente trascrive un file audio in testo.

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

Trasformare il testo in voce

Sintesi vocale è un servizio che consente di creare app e servizi che si esprimono in maniera naturale, scegliendo tra più di 270 voci neurali in 119 lingue e varianti.

L'esempio di codice seguente trasforma il testo in un file audio contenente il contenuto del testo.

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

Rilevare anomalie nei dati delle serie temporali:

Rilevamento anomalie è ideale per rilevare irregolarità nei dati della serie temporale. Nell'esempio di codice seguente viene usato il servizio Rilevamento anomalie per trovare anomalie in intere serie temporali.

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

Ottenere informazioni dalle API Web arbitrarie

Con HTTP in Spark è possibile usare qualsiasi servizio Web nella pipeline Big Data. In questo esempio di codice si usa l'API World Bank per ottenere informazioni su diversi paesi in tutto il mondo.

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

Contenuto correlato