Servizi di Azure AI

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

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 consentono agli 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 dei servizi di intelligenza artificiale di Azure può essere suddiviso in cinque pilastri principali: Visione, Riconoscimento vocale, Lingua, Ricerca Web e Decisione.

Utilizzo

Visione

Visione artificiale

  • Descrivere: fornisce una descrizione di un'immagine in un linguaggio leggibile (Scala, Python)
  • Analizza (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)
  • Riconoscere il contenuto specifico del dominio: riconosce il contenuto specifico del dominio (celebrità, punto di riferimento) (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 a una stessa persona o se un viso appartiene a una persona (Scala, Python)
  • Identificare: trova le corrispondenze più vicine del viso della persona della query da un gruppo di persone (Scala, Python)
  • Trovare un aspetto simile: trova visi simili al viso della query in un elenco di visi (Scala, Python)
  • Gruppo: 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 parlanti 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 che indica 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 parte del testo. (Scala, Python)
  • Spaziatura del testo: Identifica il posizionamento dei delimitatori di frase in una porzione di testo. (Scala, Python)
  • Ricerca nel dizionario: Specifica le traduzioni alternative per una parola e un numero ridotto di frasi idiomatiche. (Scala, Python)
  • Esempi dal dizionario: Fornisce esempi che illustrano come vengono usati nel contesto i termini nel dizionario. (Scala, Python)
  • Traduzione di documenti: Traduce più file in 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 layout: Estrarre informazioni di testo e layout da un documento specificato. (Scala, Python)
  • Analisi ricevute: Rileva ed estrae dati dalle ricevute usando il riconoscimento ottico dei caratteri (OCR) e il nostro modello di ricevuta, consentendo di estrarre facilmente dati strutturati dalle ricevute, ad esempio il nome del fornitore, il numero di telefono del fornitore, la data della transazione, il 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 nostro 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 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 ID, ad esempio nome, cognome, data di nascita, numero di documento e altro ancora. (Scala, Python)
  • Analizza 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: ottenere informazioni dettagliate su un modello personalizzato. (Scala, Python)
  • Elenca modelli personalizzati: ottenere 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)

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à

Il Analisi del testo per Servizio integrità estrae ed etichetta le informazioni mediche rilevanti da testo non strutturato, ad esempio note del medico, riepiloghi di scarico, documenti clinici e record sanitari elettronici.

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

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

L'esempio di codice seguente esegue una semplice traduzione testuale specificando le frasi in cui si vogliono tradurre e le lingue di destinazione in cui si vogliono 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.

L'esempio di codice seguente analizza un'immagine di biglietto da visita ed estrae 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 di parole di elementi nell'immagine, ad esempio oggetti riconoscibili, persone, paesaggi e azioni.

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

Nell'esempio di codice seguente 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 il riconoscimento vocale 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

Il riconoscimento vocale è un servizio che consente di creare app e servizi che parlano naturalmente, 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
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 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")
    )
)

Esempio di ricerca di intelligenza artificiale di Azure

In questo esempio viene illustrato 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",
)