Usar serviços de IA do Azure com SynapseML no Microsoft Fabric
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, predefinidos e personalizáveis. Neste artigo, você usará os vários serviços disponíveis nos serviços de IA do Azure para executar tarefas que incluem: análise de texto, tradução, inteligência de documento, visão, pesquisa de imagem, conversão de fala em texto e texto em fala, detecção de anomalias e extração de dados de APIs Web.
O objetivo dos serviços de IA do Azure é ajudar os desenvolvedores a criar aplicativos que possam ver, ouvir, falar, entender e até começar a raciocinar. O catálogo de serviços nos serviços de IA do Azure pode ser categorizado em cinco pilares principais: Vision, Speech, Language, Web searche Decision.
Pré-requisitos
Obtenha uma assinatura do Microsoft Fabric. Ou inscreva-se para uma avaliação gratuita do Microsoft Fabric.
Entre no Microsoft Fabric.
Use o alternador de experiência no canto inferior esquerdo da sua página inicial para alternar para o Fabric.
- Criar um notebook.
- Anexe seu notebook a um lakehouse. No lado esquerdo, selecione Adicionar para adicionar um lakehouse existente ou criar um.
- Obtenha uma chave de serviços de IA do Azure seguindo o Início Rápido: criar um recurso multisserviço para os serviços de IA do Azure. Copie o valor da chave a ser usada nos exemplos de código abaixo.
Prepare seu sistema
Para começar, importe as bibliotecas necessárias e inicialize sua 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
import os
from pyspark.sql import SparkSession
from synapse.ml.core.platform import *
# Bootstrap Spark Session
spark = SparkSession.builder.getOrCreate()
Importe as bibliotecas de serviços de IA do Azure e substitua as chaves e os locais no snippet de código a seguir por sua chave e localização dos serviços de IA do 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
Executar análise de sentimento no texto
O serviço de Análise de Texto fornece vários algoritmos para extrair insights inteligentes do texto. Por exemplo, você pode usar o serviço para encontrar o sentimento de algum texto de entrada. O serviço retornará uma pontuação entre 0,0 e 1,0, em que pontuações baixas indicam sentimento negativo e pontuações altas indicam sentimento positivo.
O exemplo de código a seguir retorna o sentimento de três frases simples.
# 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")
)
)
Executar análise de texto para dados de saúde
O Análise de Texto para Serviço de Saúde extrai e rotula informações médicas relevantes de texto não estruturado, como anotações médicas, 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 em um idioma diferente
Translator é um serviço de tradução automática baseado em nuvem e faz parte da família de serviços de IA do Azure de APIs cognitivas usadas para criar 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 de vários idiomas em 90 idiomas e dialetos e pode ser usado para tradução de texto com qualquer sistema operacional.
O exemplo de código a seguir realiza uma tradução de texto simples fornecendo as frases a serem traduzidas e os idiomas-alvo aos quais você deseja traduzi-las.
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
do Azure AI Document Intelligence faz parte dos serviços de IA do Azure que permitem criar software de processamento de dados automatizado usando a tecnologia de machine learning. Com o Azure AI Document Intelligence, 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 visita 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")
)
Analisar e marcar imagens
Pesquisa Visual Computacional 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 itens 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
Bing Pesquisa de Imagens pesquisa na internet para recuperar imagens relacionadas à consulta de linguagem 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 para texto converte fluxos ou arquivos de áudio falado em texto. O exemplo de código a seguir transcreve um arquivo de áudio para 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.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))
Detectar anomalias em dados de série temporal
Detector de Anomalias é ótimo para detectar irregularidades em seus dados de séries temporais. O exemplo de código a seguir usa o serviço Detector de Anomalias para encontrar anomalias em dados de série temporal inteiros.
# 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, você pode usar qualquer serviço Web em seu pipeline de Big Data. O exemplo de código a seguir usa a da API do Banco Mundial para obter informações sobre vários países ao redor do 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")
)
)