Utiliser des services Azure AI avec SynapseML dans Microsoft Fabric
Les services Azure AI aident les développeurs et les organisations à créer rapidement des applications intelligentes, innovantes, prêtes pour le marché et responsables, avec des API et des modèles prédéfinis et personnalisables. Dans cet article, vous allez utiliser les différents services disponibles dans les services Azure AI pour effectuer des tâches qui incluent l’analyse de texte, la traduction, l’intelligence de document, la vision, la recherche d’images, la reconnaissance vocale et la conversion de texte en synthèse vocale, la détection des anomalies et l’extraction de données à partir d’API web.
L’objectif des services Azure AI est d’aider les développeurs à créer des applications qui peuvent voir, entendre, parler, comprendre et même commencer à raisonner. Le catalogue de services au sein des services Azure AI peut être classé en cinq piliers principaux : Vision, Speech, Language, recherche webet Décision.
Conditions préalables
Souscrire à un abonnement Microsoft Fabric . Vous pouvez également vous inscrire à une version d’évaluation gratuite de Microsoft Fabric .
Connectez-vous à Microsoft Fabric.
Utilisez le sélecteur d’expérience en bas à gauche de votre page d’accueil pour basculer vers Fabric.
- Créez un nouveau bloc-notes.
- Attachez votre notebook à un lakehouse. Sur le côté gauche de votre bloc-notes, sélectionnez Ajouter pour ajouter un lakehouse existant ou en créer un.
- Obtenez une clé de services Azure AI en suivant Démarrage rapide : Créer une ressource multiservices pour les services Azure AI. Copiez la valeur de la clé à utiliser dans les exemples de code ci-dessous.
Préparer votre système
Pour commencer, importez les bibliothèques requises et initialisez votre session 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()
Importez les bibliothèques de services Azure AI et remplacez les clés et emplacements dans l’extrait de code suivant par votre clé et emplacement des services Azure AI.
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
Effectuer une analyse des sentiments sur le texte
Le service Analyse de texte fournit plusieurs algorithmes permettant d’extraire des insights intelligents à partir de texte. Par exemple, vous pouvez utiliser le service pour rechercher le sentiment d’un texte d’entrée. Le service retourne un score compris entre 0,0 et 1,0, où les scores faibles indiquent des sentiments négatifs et des scores élevés indiquent un sentiment positif.
L’exemple de code suivant renvoie le sentiment pour trois phrases 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")
)
)
Effectuer des analyses de texte pour les données de santé
Le Service d'analyse de texte pour la santé extrait et étiquette des informations médicales pertinentes à partir de textes non structurés tels que les notes de médecin, les comptes rendus de sortie, les documents cliniques et les dossiers de santé électroniques.
L’exemple de code suivant analyse et transforme le texte des notes des médecins en données structurées.
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))
Traduire du texte dans une autre langue
Translator est un service de traduction automatique basé sur le cloud et fait partie de la famille de services Ia Azure utilisées pour créer des applications intelligentes. Translator est facile à intégrer dans vos applications, sites web, outils et solutions. Il vous permet d’ajouter des expériences utilisateur multi-langues dans 90 langues et dialectes et peut être utilisé pour la traduction de texte avec n’importe quel système d’exploitation.
L’exemple de code suivant effectue une traduction de texte simple en fournissant les phrases à traduire et à cibler les langues vers lesquelles vous souhaitez les traduire.
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")
)
Extraire des informations d’un document dans des données structurées
Azure AI Document Intelligence fait partie des services Azure AI IA qui vous permettent de créer des logiciels de traitement automatisé des données à l’aide de la technologie Machine Learning. Avec Azure AI Document Intelligence, vous pouvez identifier et extraire du texte, des paires clé/valeur, des marques de sélection, des tables et de la structure à partir de vos documents. Le service génère des données structurées qui incluent les relations dans le fichier d’origine, les zones englobantes, la confiance et bien plus encore.
L’exemple de code suivant analyse une image de carte de visite et extrait ses informations dans des données structurées.
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")
)
Analyser et étiqueter des images
Vision par ordinateur analyse des images pour identifier la structure telle que les visages, les objets et les descriptions en langage naturel.
L'exemple de code suivant analyse les images et les marque avec les balises . Les balises sont des descriptions à un mot des éléments de l’image, tels que des objets reconnaissables, des personnes, des paysages et des actions.
# 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"))
Rechercher des images liées à une requête en langage naturel
Recherche d’images Bing recherche sur le web pour récupérer des images liées à la requête en langage naturel d’un utilisateur.
L’exemple de code suivant utilise une requête de texte qui recherche des images avec des guillemets. La sortie du code est une liste d’URL d’image qui contiennent des photos liées à la requête.
# 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))
Transformer la parole en texte
Le service Reconnaissance vocale convertit des flux ou des fichiers de contenu audio en texte. L’exemple de code suivant transcrit un fichier audio en texte.
# 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"))
Transformer du texte en synthèse vocale
Synthèse vocale est un service qui vous permet de créer des applications et des services qui parlent naturellement, en choisissant parmi plus de 270 voix neuronales en 119 langues et variantes.
L’exemple de code suivant transforme le texte en fichier audio qui contient le contenu du texte.
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))
Détecter les anomalies dans les données de série chronologique
détecteur d’anomalies est idéal pour détecter les irrégularités dans vos données de série chronologique. L’exemple de code suivant utilise le service Détecteur d’anomalies pour rechercher des anomalies dans des données de série chronologique entières.
# 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")
)
Obtenir des informations à partir d’API web arbitraires
Avec HTTP sur Spark, vous pouvez utiliser n’importe quel service web dans votre pipeline Big Data. L’exemple de code suivant utilise l’API Banque mondiale pour obtenir des informations sur différents pays du monde.
# 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")
)
)