Serviços de IA do Azure
Os serviços de IA do Azure ajudam desenvolvedores e organizações a criar rapidamente aplicativos inteligentes, de ponta, prontos para o mercado e responsáveis com APIs e modelos prontos para uso e predefinidos e personalizáveis.
O SynapseML permite que você crie modelos preditivos e analíticos eficientes e altamente escalonáveis de várias fontes de dados do Spark. O Synapse Spark fornece bibliotecas SynapseML internas, incluindo synapse.ml.services.
Importante
A partir de 20 de setembro de 2023, você não poderá criar novos recursos do Detector de Anomalias. O serviço Detector de Anomalias será desativado em 01º de outubro de 2026.
Pré-requisitos no Azure Synapse Analytics
O tutorial Pré-requisitos para usar serviços de IA do Azure no Azure Synapse, orienta pelas duas etapas que devem ser executadas antes de usar os serviços de IA do Azure no Synapse Analytics.
Os serviços de IA do Azure são um conjunto de APIs, SDKs e serviços que os desenvolvedores podem usar para adicionar recursos inteligentes aos seus aplicativos. Os serviços de IA capacitam os desenvolvedores mesmo quando eles não têm habilidades ou conhecimentos diretos de IA ou ciência de dados. Os serviços de IA do Azure ajudam os desenvolvedores a criar aplicativos que podem ver, ouvir, falar, reconhecer e até começar a raciocinar. O catálogo dos serviços de IA do Azure pode ser categorizado em cinco pilares principais: Visão, Fala, Linguagem, Pesquisa na Web e Decisão.
Uso
Visão
- Descrever: fornece a descrição de uma imagem em linguagem legível humana (Scala, Python)
- Analisar (cor, tipo de imagem, rosto, conteúdo adulto/picante): analisa recursos visuais de uma imagem (Scala, Python)
- OCR: lê o texto de uma imagem (Scala, Python)
- Reconhecimento de texto: lê o texto de uma imagem (Scala, Python)
- Miniatura: gera uma miniatura de tamanho especificado pelo usuário da imagem (Scala, Python)
- Reconhecimento de conteúdo específico do domínio: reconhece conteúdo específico do domínio (celebridade, ponto de referência) (Scala, Python)
- Marca: identifica a lista de palavras relevantes para a imagem de entrada (Scala, Python)
- Detectar: detecta rostos humanos em uma imagem (Scala, Python)
- Verificar: verifica se dois rostos pertencem a uma mesma pessoa ou se um rosto pertence a uma pessoa (Scala, Python)
- Identificar: encontra as correspondências mais próximas do rosto de uma pessoa em um grupo de pessoas, em uma consulta específica (Scala, Python)
- Localizar semelhante: localiza rostos semelhantes ao rosto da consulta em uma lista de rostos (Scala, Python)
- Grupo: divide um grupo de rostos em grupos desarticulados com base na similaridade (Scala, Python)
Fala
- Reconhecimento de fala: transcreve fluxos de áudio (Scala, Python)
- Transcrição de conversas: transcreve fluxos de áudio em transcrições em tempo real com oradores identificados. (Scala, Python)
- Conversão de texto em fala: converte texto em áudio realista (Scala, Python)
Idioma
- Detecção de idioma: detecta o idioma do texto de entrada (Scala, Python)
- Extração de frase-chave: identifica os principais pontos da conversa no texto de entrada (Scala, Python)
- Reconhecimento de entidade nomeada: identifica entidades conhecidas e entidades nomeadas gerais no texto de entrada (Scala, Python)
- Análise de sentimento: retorna uma pontuação entre 0 e 1 indicando o sentimento no texto de entrada (Scala, Python)
- Extração de entidades de saúde: extrai entidades médicas e relacionamentos do texto. (Scala, Python)
Tradução
- Traduzir: traduz o texto. (Scala, Python)
- Transliterar: converte o texto de uma linguagem de script em outro script. (Scala, Python)
- Detectar: identifica o idioma de uma parte do texto. (Scala, Python)
- Sentença de quebra: identifica o posicionamento dos limites da frase em uma parte do texto. (Scala, Python)
- Pesquisa em dicionário: fornece as traduções alternativas para uma palavra e um pequeno número de frases idiomáticas. (Scala, Python)
- Exemplos de dicionário: fornece exemplos que mostram como os termos no dicionário são usados no contexto. (Scala, Python)
- Tradução de documentos: traduz documentos entre todos os idiomas e dialetos com suporte e, ao mesmo tempo, preserva a estrutura do documento e o formato dos dados. (Scala, Python)
Document Intelligence
- Analisar layout: extrai informações de texto e layout de um determinado documento. (Scala, Python)
- Analisar recibos: detecta e extrai dados de recibos usando OCR (reconhecimento óptico de caracteres) e nosso modelo de recibo, permitindo que você extraia facilmente dados estruturados de recibos, como nome e número de telefone do comerciante, data da transação, total da transação e muito mais. (Scala, Python)
- Analisar cartões de visita: detecta e extrai dados de cartões de visita usando OCR (reconhecimento óptico de caracteres) e nosso modelo de cartão de visita, permitindo que você extraia facilmente dados estruturados de cartões de visita, como nomes de contato, nomes de empresa, números de telefone, emails e muito mais. (Scala, Python)
- Analisar faturas: detecta e extrai dados de faturas usando OCR (reconhecimento óptico de caracteres) e nossos modelos de aprendizado profundo com reconhecimento de faturas, permitindo que você extraia facilmente dados estruturados de faturas, como cliente, fornecedor, ID, data de vencimento, total, valor devido da fatura, valor do imposto, enviar para, faturar para, itens de linha e muito mais. (Scala, Python)
- Analisar documentos de identificação: detecta e extrai dados de documentos de identificação usando OCR (reconhecimento óptico de caracteres) e nosso modelo de documento de identificação, permitindo que você extraia facilmente dados estruturados de documentos de identificação, como nome, sobrenome, data de nascimento, número do documento e muito mais. (Scala, Python)
- Analisar formulário personalizado: extrai informações de formulários (PDFs e imagens) em dados estruturados com base em um modelo criado a partir de um conjunto de formulários de treinamento representativos. (Scala, Python)
- Obter modelo personalizado: obtenha informações detalhadas sobre um modelo personalizado. (Scala, Python)
- Listar modelos personalizados: obtenha informações sobre todos os modelos personalizados. (Scala, Python)
Decisão
- Status da anomalia do ponto mais recente: gera um modelo usando pontos anteriores e determina se o ponto mais recente é anormal (Scala, Python)
- Localizar anomalias: gera um modelo usando uma série inteira e localiza anomalias na série (Scala, Python)
Pesquisar
Preparar seu sistema
Para começar, importe as bibliotecas necessárias e inicialize a sessão do 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 bibliotecas de serviços de IA do Azure e substitua as chaves e os locais no trecho de código a seguir pela chave e localização dos serviços de IA do 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.
Executar análise de sentimento no texto
O serviço Linguagem de IA fornece vários algoritmos para extrair insights inteligentes do texto. Por exemplo, podemos encontrar a sentimentos do texto de entrada fornecido. O serviço retornará uma pontuação entre 0,0 e 1,0 em que as pontuações baixas indicam um sentimento negativo e pontuações altas indicam um sentimento positivo. Este exemplo usa três frases simples e retorna o sentimento para cada uma.
# 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")
)
)
Executar análise de texto para dados de integridade
A Análise de Texto para Serviço de Integridade extrai e etiqueta informações médicas relevantes de textos não estruturados, como observações do médico, resumos de alta, documentos clínicos e registros eletrônicos de saúde.
O exemplo de código a seguir analisa e transforma texto de anotações médicas em dados estruturados.
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))
Traduzir texto para um idioma diferente
O Tradutor é um serviço de tradução automática baseado em nuvem e faz parte da família de serviços de IA do Azure das APIs de IA usadas para a criação de aplicativos inteligentes. O Tradutor é fácil de integrar em seus aplicativos, sites, ferramentas e soluções. Ele permite que você adicione experiências de usuário em vários idiomas em 90 idiomas e dialetos e pode ser usado para traduzir texto sem hospedar seu próprio algoritmo.
Neste exemplo, fazemos uma tradução de texto simples, fornecendo as frases que você quer traduzir e idiomas de destino para os quais você quer traduzir.
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")
)
Extrair informações de um documento em dados estruturados
A IA do Azure para Informação de Documentos faz parte dos Serviços de IA Aplicada do Azure que permite criar software de processamento de dados automatizado usando a tecnologia de aprendizado de máquina. Com o IA do Azure para Informação de Documentos, você pode identificar e extrair texto, pares chave/valor, marcas de seleção, tabelas e estrutura de seus documentos. O serviço gera dados estruturados que incluem as relações no arquivo original, caixas delimitadoras, confiança e muito mais.
O exemplo de código a seguir analisa uma imagem de cartão de negócios e extrai suas informações em dados estruturados.
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")
)
Exemplo de Pesquisa Visual Computacional
A Visão de IA do Azure analisa imagens para identificar estruturas como rostos, objetos e descrições de linguagem natural.
O exemplo de código a seguir analisa imagens e as rotula com marcas. Marcas são descrições de uma palavra de coisas na imagem, como objetos reconhecíveis, pessoas, cenários e ações.
# 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"))
Pesquisar imagens relacionadas a uma consulta de linguagem natural
A Pesquisa de Imagem do Bing pesquisa na Web para recuperar imagens relacionadas à consulta de idioma natural de um usuário.
O exemplo de código a seguir usa uma consulta de texto que procura imagens com aspas. A saída do código é uma lista de URLs de imagem que contêm fotos relacionadas à 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))
Transformar fala em texto
O serviço de Conversão de fala em texto converte fluxos ou arquivos de áudio falado em texto. O exemplo de código a seguir transcreve um arquivo de áudio em 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 em fala
A conversão de texto em fala é um serviço que permite criar aplicativos e serviços que falam naturalmente, escolhendo entre mais de 270 vozes neurais em 119 idiomas e variantes.
O exemplo de código a seguir transforma o texto em um arquivo de áudio que contém o conteúdo do 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 anomalias em dados de série temporal
Se você não tiver um recurso de detecção de anomalias criado antes de 20 de setembro de 2023, não poderá criar um. Talvez você queira ignorar essa parte.
O Detector de Anomalias é ótimo para detectar irregularidades em seus dados de série temporal. O exemplo de código a seguir usa o serviço Detector de Anomalias para encontrar anomalias em uma série 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
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")
)
Obter informações de APIs Web arbitrárias
Com HTTP no Spark, qualquer serviço Web pode ser usado em seu pipeline de Big Data. Neste exemplo, usamos a API World Bank para obter informações sobre vários países/regiões em todo o 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 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")
)
)
Amostra de pesquisa de IA do Azure
Neste exemplo, mostramos como você pode enriquecer dados usando habilidades cognitivas e gravar em um índice do Azure Search 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",
)
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de