Servizi di Azure AI

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.

SynapseML consente di creare modelli predittivi e analitici potenti e altamente scalabili da varie origini dati Spark. Synapse Spark offre librerie SynapseML predefinite, tra cui synapse.ml.services.

Importante

A partire dal 20 settembre 2023 non sarà possibile creare nuove risorse Rilevamento anomalie. Il servizio Rilevamento anomalie viene ritirato il 1° ottobre 2026.

Prerequisiti in Azure Synapse Analytics

L'esercitazione, Prerequisiti per l'uso dei Servizi di Azure AI in Azure Synapse, illustra alcuni passaggi da eseguire prima di usare i Servizi di Azure AI in Synapse Analytics.

I servizi di intelligenza artificiale di Azure sono una suite di API, SDK e servizi che gli sviluppatori possono usare per aggiungere funzionalità intelligenti alle applicazioni. I servizi di intelligenza artificiale supportano gli sviluppatori anche quando non hanno competenze o conoscenze dirette di intelligenza artificiale o data science. I servizi di intelligenza artificiale di Azure aiutano gli sviluppatori a creare applicazioni in grado di vedere, ascoltare, 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.

Utilizzo

Visione

Visione artificiale

• Descrizione: fornisce una descrizione di un'immagine in un linguaggio leggibile (Scala, Python)
• Analisi (colore, tipo di immagine, viso, contenuto per adulti/spinto): analizza le funzionalità visive di un'immagine (Scala, Python)
• Riconoscimento ottico dei caratteri (OCR): legge il testo da un'immagine (Scala, Python)
• Riconoscimento del testo: legge il testo da un'immagine (Scala, Python)
• Anteprima: genera un'anteprima delle dimensioni specificate dall'utente dall'immagine (Scala, Python)
• Riconoscimento del contenuto specifico del dominio: riconosce il contenuto specifico del dominio (celebrità, luogo di interesse) (Scala, Python)
• Tag: identifica l'elenco di parole rilevanti per l'immagine di input (Scala, Python)

Viso

• Rilevamento: rileva i visi umani in un'immagine (Scala, Python)
• Verifica: verifica se due visi appartengono alla stessa persona o se un viso appartiene a una persona (Scala, Python)
• Identificazione: trova le corrispondenze migliori del viso della persona specificata nella query da un gruppo di persone (Scala, Python)
• Ricerca di simili: trova visi simili al viso della query in un elenco di visi (Scala, Python)
• Gruppi: divide un gruppo di visi in gruppi non contigui in base alla somiglianza (Scala, Python)

Voce

Servizi Voce

• Riconoscimento vocale: trascrive flussi audio (Scala, Python)
• Trascrizione conversazione: trascrive i flussi audio in trascrizioni in tempo reale con altoparlanti identificati. (Scala, Python)
• Sintesi vocale: converte il testo in audio realistico (Scala, Python)

Lingua

Linguaggio di intelligenza artificiale

• Rilevamento della lingua: rileva la lingua del testo di input (Scala, Python)
• Estrazione di frasi chiave: identifica i punti di discussione chiave nel testo di input (Scala, Python)
• Riconoscimento di entità denominate: identifica le entità note e le entità denominate generali nel testo di input (Scala, Python)
• Analisi valutazione: restituisce un punteggio compreso tra 0 e 1 per indicare la valutazione nel testo di input (Scala, Python)
• Estrazione di entità sanitarie: estrae entità mediche e relazioni dal testo. (Scala, Python)

Traduzione

Translator

• Traduzione: traduce il testo. (Scala, Python)
• Traslitterazione: converte il testo in una lingua da uno script in un altro script. (Scala, Python)
• Rilevamento: identifica la lingua di una porzione di testo. (Scala, Python)
• Spaziatura del testo: identifica il posizionamento dei delimitatori di frase in una porzione di testo. (Scala, Python)
• Ricerca nel dizionario: fornisce le traduzioni alternative di una parola e un numero ridotto di frasi idiomatiche. (Scala, Python)
• Esempi dal dizionario: fornisce esempi che mostrano come vengono usati i termini nel dizionario nel contesto. (Scala, Python)
• Traduzione di documenti: traduce documenti tutte le lingue e i dialetti supportati mantenendo al tempo stesso la struttura del documento e il formato dei dati. (Scala, Python)

Document Intelligence

Intelligence per i documenti

• Analisi del layout: estrare informazioni sul testo e sul layout da un documento specificato. (Scala, Python)
• Analisi ricevute: rileva ed estrae dati dalle ricevute usando il riconoscimento ottico dei caratteri (OCR) e il modello di ricevuta, consentendo di estrarre facilmente dati strutturati dalle ricevute, ad esempio, nome del fornitore, numero di telefono del fornitore, data della transazione, totale delle transazioni e altro ancora. (Scala, Python)
• Analisi biglietti da visita: rileva ed estrae dati da biglietti da visita usando il riconoscimento ottico dei caratteri (OCR) e il modello di biglietti da visita, consentendo di estrarre facilmente dati strutturati da biglietti da visita, ad esempio, nomi di contatto, nomi di società, numeri di telefono, e-mail e altro ancora. (Scala, Python)
• Analisi fatture: rileva ed estrae dati dalle fatture usando il riconoscimento ottico dei caratteri (OCR) e i modelli di Deep Learning per la comprensione delle fatture, consentendo di estrarre facilmente dati strutturati dalle fatture, ad esempio cliente, fornitore, ID fattura, data di scadenza della fattura, totale, importo della fattura dovuto, importo iva, importo fiscale, spedizione, fatturazione, voci e altro ancora. (Scala, Python)
• Analisi documenti di identità: rileva ed estrae dati dai documenti di identificazione usando il riconoscimento ottico dei caratteri (OCR) e il modello di documento di identità, consentendo di estrarre facilmente dati strutturati da documenti di identità, ad esempio, nome, cognome, data di nascita, numero di documento e altro ancora. (Scala, Python)
• Analisi modulo personalizzato: estrae informazioni dai moduli (PDF e immagini) in dati strutturati basati su un modello creato da un set di moduli di training rappresentativi. (Scala, Python)
• Ottenere un modello personalizzato: ottiene informazioni dettagliate su un modello personalizzato. (Scala, Python)
• Elenco di modelli personalizzati: ottiene informazioni su tutti i modelli personalizzati. (Scala, Python)

Decision

Rilevamento anomalie

• Stato anomalie del punto più recente: genera un modello usando i punti precedenti e determina se il punto più recente è anomalo (Scala, Python)
• Trovare anomalie: genera un modello usando un'intera serie e trova anomalie nella serie (Scala, Python)

Ricerca

• Ricerca immagini Bing (Scala, Python)
• Ricerca cognitiva di Azure (Scala, Python)

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

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

Eseguire l'analisi del sentiment sul testo

Il servizio di linguaggio di intelligenza artificiale offre diversi algoritmi per estrarre informazioni dettagliate intelligenti dal testo. Ad esempio, è possibile trovare la valutazione del testo di input specificato. 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. In questo esempio vengono usate tre frasi semplici e viene restituita la valutazione per ognuna di esse.

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

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 API di intelligenza artificiale di Azure usate per creare 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 tradurre testo senza ospitare il proprio algoritmo.

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

Intelligence sui documenti di Intelligenza artificiale di Azure fa parte di servizi di intelligenza artificiale app Azure lied che consente di creare software di elaborazione dati automatizzato usando 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")
)

Esempio di Visione artificiale

Visione artificiale di Azure 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"))

Cercare immagini correlate a una query in linguaggio naturale

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

Rilevare anomalie nei dati delle serie temporali

Se non si dispone di una risorsa di rilevamento anomalie creata prima del 20 settembre 2023, non sarà possibile crearne una. È possibile ignorare questa parte.

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 una serie temporale.

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

Ottenere informazioni dalle API Web arbitrarie

Con HTTP in Spark è possibile usare qualsiasi servizio Web nella pipeline Big Data. In questo esempio si usa l'API World Bank per ottenere informazioni su diversi paesi/regioni 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/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")
    )
)

Esempio di ricerca di intelligenza artificiale di Azure

In questo campione viene mostrato come arricchire i dati usando competenze cognitive e scrivere in un indice di Ricerca di Azure usando 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",
)