Compartir a través de


Servicios de Azure AI

Los servicios de Azure AI ayudan a los desarrolladores y a las organizaciones a crear rápidamente aplicaciones inteligentes, vanguardistas, listas para el mercado y responsables con API y modelos listos para usar y preconstruidos y personalizables.

SynapseML permite crear modelos analíticos y predictivos eficaces y altamente escalables a partir de diversos orígenes de datos de Spark. Synapse Spark proporciona bibliotecas de SynapseML incorporadas, incluyendo synapse.ml.services.

Importante

A partir del 20 de septiembre de 2023, no podrá crear nuevos recursos de Anomaly Detector. El servicio Anomaly Detector se retira el 1 de octubre de 2026.

Requisitos previos en Azure Synapse Analytics

Tutorial: Requisitos previos para el uso de servicios de Azure AI en Azure Synapse le puede servir de guía siguiendo un par de pasos que debe realizar antes de utilizar servicios de Azure AI en Synapse Analytics.

Servicios de Azure AI es un conjunto de API, SDK y servicios que los desarrolladores pueden usar para agregar características inteligentes a sus aplicaciones. Los servicios de IA capacitan a los desarrolladores incluso cuando no tienen conocimientos o conocimientos directos de inteligencia artificial o ciencia de datos. Servicios de Azure AI ayuda a los desarrolladores a crear aplicaciones que puedan ver, oír, hablar, comprender e incluso empezar a razonar. El catálogo de servicios de servicios de Azure AI se puede dividir en cinco pilares principales: Vision, Voz, Lenguaje, Web Search y Decision.

Uso

Visión

Computer Vision

  • Describir: proporciona una descripción de una imagen en lenguaje legible (Scala, Python)
  • Analizar (color, tipo de imagen, cara, contenido para adultos/subido de tono): analiza las características visuales de una imagen (Scala, Python)
  • OCR: lee texto de una imagen (Scala, Python)
  • Reconocer texto: lee texto de una imagen (Scala, Python)
  • Miniatura: genera una miniatura del tamaño especificado por el usuario a partir de la imagen (Scala, Python)
  • Reconocimiento de contenido específico del dominio: reconoce contenido específico del dominio (celebridad, punto de referencia) (Scala, Python)
  • Etiqueta: identifica la lista de palabras que son pertinentes para la imagen de entrada (Scala, Python)

Face

  • Detectar: detecta caras humanas en una imagen (Scala, Python)
  • Comprobar: comprueba si dos caras pertenecen a una misma persona o si una cara pertenece a una persona (Scala, Python)
  • Identificar: busca las coincidencias más cercanas de la cara de una persona de una consulta específica de un grupo de personas (Scala, Python)
  • Buscar similar: busca caras similares a la cara de la consulta en una lista de caras (Scala, Python)
  • Agrupar: divide un grupo de caras en grupos separados en función de la similitud (Scala, Python)

Voz

Servicios de voz

  • Conversión de voz en texto: transcribe secuencias de audio (Scala, Python)
  • Transcripción de conversaciones: transcribe secuencias de audio en transcripciones en directo con hablantes identificados. (Scala, Python)
  • Text to Speech: convierte texto en audio realista (Scala, Python)

Lenguaje

Lenguaje de Azure AI

  • Detección de idioma: detecta el idioma del texto de entrada (Scala, Python)
  • Extracción de frases clave: identifica los puntos clave de la conversación en el texto de entrada (Scala, Python)
  • Reconocimiento de entidades con nombre: identifica entidades conocidas y entidades con nombre generales en el texto de entrada (Scala, Python)
  • Análisis de sentimiento: devuelve una puntuación entre 0 y 1 que indica la opinión del texto de entrada (Scala, Python)
  • Extracción de entidades sanitarias: extrae entidades y relaciones médicas del texto. (Scala, Python)

Traducción

Translator

  • Traducir: traduce texto. (Scala, Python)
  • Transliterar: convierte texto en un idioma de un script a otro script. (Scala, Python)
  • Detectar: identifica el idioma de un fragmento de texto. (Scala, Python)
  • BreakSentence: identifica el posicionamiento de los límites de las frases en un fragmento de texto. (Scala, Python)
  • Búsqueda de diccionario: proporciona traducciones alternativas para una palabra y un pequeño número de frases hechas. (Scala, Python)
  • Ejemplos de diccionario: proporciona ejemplos que muestran cómo se usan los términos del diccionario en el contexto. (Scala, Python)
  • Traducción de documentos: traduce documentos entre todos los idiomas y dialectos admitidos manteniendo la estructura del documento y el formato de los datos. (Scala, Python)

Document Intelligence

Documento de inteligencia

  • Analizar diseño: extrae texto e información del diseño de un documento determinado. (Scala, Python)
  • Analizar recibos: detecta y extrae datos de los recibos mediante el reconocimiento óptico de caracteres (OCR) y nuestro modelo de recibo, lo que le permite extraer fácilmente datos estructurados de los recibos, como el nombre del comerciante, el número de teléfono del comerciante, la fecha de la transacción, el total de transacciones, etc. (Scala, Python)
  • Analizar tarjetas de presentación: detecta y extrae datos de tarjetas de presentación mediante el reconocimiento óptico de caracteres (OCR) y nuestro modelo de tarjeta de presentación, lo que le permite extraer fácilmente datos estructurados de las tarjetas de presentación, como nombres de contacto, nombres de empresa, números de teléfono, correos electrónicos, etc. (Scala, Python)
  • Analizar facturas: detecta y extrae datos de facturas mediante el reconocimiento óptico de caracteres (OCR) y nuestros modelos de aprendizaje profundo de la comprensión de facturas, lo que le permite extraer fácilmente datos estructurados de las facturas como cliente, proveedor, identificador de factura, fecha de vencimiento de la factura, total, importe de factura debido, importe de impuestos, dirección de envío, dirección de facturación, elementos de línea, etc. (Scala, Python)
  • Analizar documentos de identificación: detecta y extrae datos de documentos de identificación mediante el reconocimiento óptico de caracteres (OCR) y nuestro modelo de documento de identificación, lo que le permite extraer fácilmente datos estructurados de los documentos de identificación, como el nombre, el apellido, la fecha de nacimiento, el número de documento, etc. (Scala, Python)
  • Analizar formulario personalizado: extrae información de formularios (archivos PDF e imágenes) en datos estructurados basados en un modelo creado a partir de un conjunto de formularios de entrenamiento representativos. (Scala, Python)
  • Obtener modelo personalizado: obtiene información detallada sobre un modelo personalizado. (Scala, Python)
  • Enumerar modelos personalizados: obtiene información sobre todos los modelos personalizados. (Scala, Python)

Decisión

Anomaly Detector

  • Estado de anomalía del punto más reciente: genera un modelo mediante puntos anteriores y determina si el punto más reciente es anómalo (Scala, Python)
  • Búsqueda de anomalías: genera un modelo mediante una serie completa y busca anomalías en la serie (Scala, Python)

Preparación del sistema

Para empezar, importe las bibliotecas necesarias e inicialice su sesión 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

Importe las bibliotecas de servicios de Azure AI y sustituya las claves y ubicaciones del siguiente fragmento de código por su clave y ubicación de servicios de 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.

Realizar análisis de sentimientos en el texto

El servicio Lenguaje de Azure AI ofrece varios algoritmos para extraer conclusiones inteligentes de los textos. Por ejemplo, podemos encontrar la opinión de un texto de entrada determinado. El servicio devolverá una puntuación entre 0,0 y 1,0, donde las puntuaciones bajas indican una opinión negativa y una puntuación alta indica una opinión positiva. Este ejemplo utiliza tres frases simples y devuelve la opinión de cada una.

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

Análisis de texto de datos de estado

El servicio Text Analytics for Health extrae y etiqueta información médica relevante de textos no estructurados como notas del médico, resúmenes de altas, documentos clínicos e historias clínicas electrónicas.

El siguiente ejemplo de código analiza y transforma el texto de las notas de los médicos en datos estructurados.

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

Traducir texto a otro idioma

Traductor es un servicio de traducción automática basado en la nube que forma parte de la familia de API de IA de servicios de Azure AI utilizadas para crear aplicaciones inteligentes. Translator se integra con facilidad en cualquier aplicación, sitio web, herramienta y solución. Le permite agregar experiencias de usuario multilingües en 90 idiomas y dialectos y puede usarse para traducir texto sin hospedar su propio algoritmo.

El siguiente ejemplo de código realiza una traducción de texto sencilla proporcionando las frases que desea traducir y los idiomas de destino a los que desea traducirlas.

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

Extraer información de un documento en datos estructurados

Documento de inteligencia de Azure AI es una parte de Azure Applied AI Services que le permite compilar software de procesamiento de datos automatizado utilizando tecnología de aprendizaje automático. Con el Documento de inteligencia de Azure AI, puede identificar y extraer texto, pares clave-valor, marcas de selección, tablas y estructura de los documentos. El servicio obtiene datos estructurados que incluyen las relaciones del archivo original, rectángulos delimitadores, confianza y más.

El siguiente ejemplo de código analiza una imagen de tarjeta de visita y extrae su información en datos estructurados.

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

Ejemplo de Computer Vision

Visión de Azure AI analiza imágenes para identificar estructuras como caras, objetos y descripciones en lenguaje natural.

El siguiente ejemplo de código analiza imágenes y las etiqueta con etiquetas. Las etiquetas son descripciones de una palabra de los elementos de la imagen, como objetos reconocibles, personas, paisajes y acciones.

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

Bing Image Search busca en la Web para recuperar las imágenes relacionadas con una consulta en lenguaje natural del usuario.

El siguiente ejemplo de código utiliza una consulta de texto que busca imágenes con comillas. La salida del código es una lista de URL de imágenes que contienen fotos relacionadas con la consulta.

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

Conversión de voz en texto

El servicio Speech to Text convierte secuencias o archivos de audio hablado en texto. El siguiente ejemplo de código transcribe un archivo de audio a texto.

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

Transformar texto en voz

La conversión de texto en voz es un servicio que permite crear aplicaciones y servicios que hablan con naturalidad, eligiendo entre más de 270 voces neuronales en 119 idiomas y variantes.

El siguiente ejemplo de código transforma un texto en un archivo de audio que contiene el contenido del texto.

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

Detectar anomalías en los datos de series temporales

Si no tiene un recurso de detección de anomalías creado antes del 20 de septiembre de 2023, no podrá crearlo. Es posible que quiera omitir esta parte.

Anomaly Detector es ideal para detectar irregularidades en los datos de series temporales. El siguiente ejemplo de código utiliza el servicio Anomaly Detector para encontrar anomalías en datos una serie temporal.

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

Obtener información de API web arbitrarias

Con HTTP en Spark, se puede usar cualquier servicio web en la canalización de macrodatos. En este ejemplo, usamos la API de World Bank para obtener información sobre varios países y regiones de todo el mundo.

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

Ejemplo de Búsqueda de Azure AI

En este ejemplo, se muestra cómo puede enriquecer los datos mediante aptitudes cognitivas y escribir en un índice de Azure Search mediante 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",
)