Forem: Olalekan Oladiran

Build a Fruit Detection AI with Azure Custom Vision: A Step-by-Step Guide

Olalekan Oladiran — Mon, 04 Aug 2025 15:54:37 +0000

Introduction

The Azure AI Custom Vision service enables you to create computer vision models that are trained on your own images. You can use it to train image classification and object detection models; which you can then publish and consume from applications.

In this exercise, you will use the Custom Vision service to train an object detection model that can detect and locate three classes of fruit (apple, banana, and orange) in an image.

Create Custom Vision resources

Open the Azure portal at https://portal.azure.com, and sign in using your Azure credentials. Close any welcome messages or tips that are displayed.
Select Create a resource.
In the search bar, search for Custom Vision, select Custom Vision, and create the resource with the following settings:
- Create options: Both
- Subscription: Your Azure subscription
- Resource group: Create or select a resource group
- Region: Choose any available region
- Name: A valid name for your Custom Vision resource
- Training pricing tier: F0
- Prediction pricing tier: F0
Create the resource and wait for deployment to complete, and then view the deployment details. Note that two Custom Vision resources are provisioned; one for training, and another for prediction.

Note: Each resource has its own endpoint and keys, which are used to manage access from your code. To train an image classification model, your code must use the training resource (with its endpoint and key); and to use the trained model to predict image classes, your code must use the prediction resource (with its endpoint and key).

When the resources have been deployed, go to the resource group to view them. You should see two custom vision resources, one with the suffix -Prediction.

Create a Custom Vision project in the Custom Vision portal

To train an object detection model, you need to create a Custom Vision project based on your training resource. To do this, you’ll use the Custom Vision portal.

Open a new browser tab (keeping the Azure portal tab open - you’ll return to it later).
In the new browser tab, open the Custom Vision portal at https://customvision.ai. If prompted, sign in using your Azure credentials and agree to the terms of service.
Create a new project with the following settings:
- Name: Detect Fruit
- Description: Object detection for fruit.
- Resource: Your Custom Vision resource
- Project Types: Object Detection
- Domains: General
Wait for the project to be created and opened in the browser.

Upload and tag images

Now that you have an object detection project, you can upload and tag images to train a model.

The Custom Vision portal includes visual tools that you can use to upload images and tag regions within them that contain multiple types of object.
In a new browser tab, download the training images from https://github.com/MicrosoftLearning/mslearn-ai-vision/raw/main/Labfiles/object-detection/training-images.zip and extract the zip folder to view its contents. This folder contains images of fruit. - In the Custom Vision portal, in your object detection project, select Add images and upload all of the images in the extracted folder. - After the images have been uploaded, select the first one to open it. - Hold the mouse over any object in the image until an automatically detected region is displayed like the image below. Then select the object, and if necessary resize the region to surround it. Alternatively, you can simply drag around the object to create a region. - When the region surrounds the object, add a new tag with the appropriate object type (apple, banana, or orange) as shown here: - Select and tag each other object in the image, resizing the regions and adding new tags as required. - Use the > link on the right to go to the next image, and tag its objects. Then just keep working through the entire image collection, tagging each apple, banana, and orange. - When you have finished tagging the last image, close the Image Detail editor. On the Training Images page, under Tags, select Tagged to see all of your tagged images:

Use the Custom Vision SDK to upload images

You can use the UI in the Custom Vision portal to tag your images, but many AI development teams use other tools that generate files containing information about tags and object regions in images. In scenarios like this, you can use the Custom Vision training API to upload tagged images to the project.

Click the settings (⚙) icon at the top right of the Training Images page in the Custom Vision portal to view the project settings.
Under General (on the left), note the Project Id that uniquely identifies this project.
On the right, under Resources note that the Key and Endpoint are shown. These are the details for the training resource (you can also obtain this information by viewing the resource in the Azure portal).
Return to the browser tab containing the Azure portal (keeping the Custom Vision portal tab open - you’ll return to it later).
- Open VS Code
Enter the following commands to clone the GitHub repo containing the code files for this exercise git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

After the repo has been cloned, use the following command to navigate to the application code files:

cd mslearn-ai-vision/Labfiles/object-detection/python/train-detector

The folder contains application configuration and code files for your app. It also contains a tagged-images.json file which contains bounding box coordinates for objects in multiple images, and an /images subfolder, which contains the images.
Install the Azure AI Custom Vision SDK package for training and any other required packages by running the following commands:

pip install -r requirements.txt azure-cognitiveservices-vision-customvision

Open env file in VS Code, update the configuration values it contains to reflect the Endpoint and an authentication Key for your Custom Vision training resource, and the Project ID for the custom vision project you created previously.
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command to save your changes and then use the CTRL+Q command to close the code editor while keeping the cloud shell command line open.
Open the tagged-images.json file to see the tagging information for the image files in the /images subfolder: JSON defines a list of images, each containing one or more tagged regions. Each tagged region includes a tag name, and the top and left coordinates and width and height dimensions of the bounding box containing the tagged object.
Open add-tagged-images.py
Note the following details in the code file:
- The namespaces for the Azure AI Custom Vision SDK are imported.
- The Main function retrieves the configuration settings, and uses the key and endpoint to create an authenticated
- CustomVisionTrainingClient, which is then used with the project ID to create a Project reference to your project.
- The Upload_Images function extracts the tagged region information from the JSON file and uses it to create a batch of images with regions, which it then uploads to the project.
Enter the following command to run the program:

python3 add-tagged-images.py

Wait for the program to end.
Switch back to the browser tab containing the Custom Vision portal (keeping the Azure portal cloud shell tab open), and view the Training Images page for your project (refreshing the browser if necessary).
Verify that some new tagged images have been added to the project.

Train and test a model

Now that you’ve tagged the images in your project, you’re ready to train a model.

In the Custom Vision project, click Train (⚙⚙) to train an object detection model using the tagged images. Select the Quick Training option.
Wait for training to complete (it might take ten minutes or so).
In the Custom Vision portal, when training has finished, review the Precision, Recall, and mAP performance metrics - these measure the prediction accuracy of the object detection model, and should all be high.
At the top right of the page, click Quick Test, and then in the Image URL box, type https://aka.ms/test-fruit and click the quick test image (➔) button.
View the prediction that is generated.
Close the Quick Test window.

Use the object detector in a client application

Now you’re ready to publish your trained model and use it in a client application.

In the Custom Vision portal, on the Performance page, click 🗸 Publish to publish the trained model with the following settings:
- Model name: fruit-detector
- Prediction Resource: The prediction resource you created previously which ends with “-Prediction” (not the training resource).
At the top left of the Project Settings page, click the Projects Gallery (👁) icon to return to the Custom Vision portal home page, where your project is now listed.
On the Custom Vision portal home page, at the top right, click the settings (⚙) icon to view the settings for your Custom Vision service. Then, under Resources, find your prediction resource which ends with “-Prediction” (not the training resource) to determine its Key and Endpoint values (you can also obtain this information by viewing the resource in the Azure portal).

Use the image classifier from a client application

Return to VS Code
Run the following commands to switch to the folder for you client application cd ../test-detector

The folder contains application configuration and code files for your app. It also contains the following produce.jpg image file, which you’ll use to test your model.
Open .env file
Update the configuration values to reflect the Endpoint and Key for your Custom Vision prediction resource, the Project ID for the object detection project, and the name of your published model (which should be fruit-detector). Save your changes (CTRL+S)
Open test-detector.py
Review the code, noting the following details:
- The namespaces for the Azure AI Custom Vision SDK are imported.
- The Main function retrieves the configuration settings, and uses the key and endpoint to create an authenticated CustomVisionPredictionClient.
- The prediction client object is used to get object detection predictions for the produce.jpg image, specifying the project ID and model name in the request. The predicted tagged regions are then drawn on the image, and the result is saved as output.jpg.
Enter the following command to run the program:

python3 test-detector.py

Review the program output, which lists each object detected in the image.
Note that an image file named output.jpg is generated.

You’ve just transformed raw images into an intelligent fruit-detection system—proving how accessible computer vision has become with Azure Custom Vision. Whether you're building a smart grocery scanner, industrial quality checker, or just exploring AI, the pattern remains the same: tag, train, and deploy.

Project guide link: https://microsoftlearning.github.io/mslearn-ai-vision/Instructions/Labs/05-custom-vision-object-detection.html

No ML Expertise Needed: Build a Computer Vision Model in Azure (Fruit Classification Example)

Olalekan Oladiran — Wed, 30 Jul 2025 17:13:32 +0000

Introduction

In this exercise, you will use the Custom Vision service to train an image classification model that can identify three classes of fruit (apple, banana, and orange).

Create Custom Vision resources

Open the Azure portal at https://portal.azure.com, and sign in using your Azure credentials. Close any welcome messages or tips that are displayed.
Select Create a resource.
In the search bar, search for Custom Vision, select Custom Vision, and create the resource with the following settings:
- Create options: Both
- Subscription: Your Azure subscription
- Resource group: Create or select a resource group
- Region: Choose any available region
- Name: A valid name for your Custom Vision resource
- Training pricing tier: F0
- Prediction pricing tier: F0
Create the resource and wait for deployment to complete, and then view the deployment details. Note that two Custom Vision resources are provisioned; one for training, and another for prediction.

Note: Each resource has its own endpoint and keys, which are used to manage access from your code. To train an image classification model, your code must use the training resource (with its endpoint and key); and to use the trained model to predict image classes, your code must use the prediction resource (with its endpoint and key).

When the resources have been deployed, go to the resource group to view them. You should see two custom vision resources, one with the suffix -Prediction.

Create a Custom Vision project in the Custom Vision portal

To train an image classification model, you need to create a Custom Vision project based on your training resource. To do this, you’ll use the Custom Vision portal.

Open a new browser tab (keeping the Azure portal tab open - you’ll return to it later).
In the new browser tab, open the Custom Vision portal at https://customvision.ai. If prompted, sign in using your Azure credentials and agree to the terms of service.
In the Custom Vision portal, create a new project with the following settings:
- Name: Classify Fruit
- Description: Image classification for fruit
- Resource: Your Custom Vision resource
- Project Types: Classification
- Classification Types: Multiclass (single tag per image)
- Domains: Food

Upload and tag images

In a new browser tab, download the training images from https://github.com/MicrosoftLearning/mslearn-ai-vision/raw/main/Labfiles/image-classification/training-images.zip and extract the zip folder to view its contents. This folder contains subfolders of apple, banana, and orange images.

In the Custom Vision portal, in your image classification project, click Add images, and select all of the files in the training-images/apple folder you downloaded and extracted previously. Then upload the image files, specifying the tag apple.

Use the Add Images ([+]) toolbar icon to repeat the previous step to upload the images in the banana folder with the tag banana, and the images in the orange folder with the tag orange.
Explore the images you have uploaded in the Custom Vision project - there should be 15 images of each class.

Train a model

In the Custom Vision project, above the images, click Train (⚙⚙) to train a classification model using the tagged images. Select the Quick Training option, and then wait for the training iteration to complete (this may take a minute or so).
When the model iteration has been trained, review the Precision, Recall, and AP performance metrics - these measure the prediction accuracy of the classification model, and should all be high.

Test the model

Above the performance metrics, click Quick Test.
In the Image URL box, type https://aka.ms/test-apple and click the quick test image (➔) button.
View the predictions returned by your model - the probability score for apple should be the highest
Try testing the following images:
- https://aka.ms/test-banana
- https://aka.ms/test-orange
Close the Quick Test window.

View the project settings

The project you have created has been assigned a unique identifier, which you will need to specify in any code that interacts with it.

Click the settings (⚙) icon at the top right of the Performance page to view the project settings.
Under General (on the left), note the Project Id that uniquely identifies this project.
On the right, under Resources note that the key and endpoint are shown. These are the details for the training resource (you can also obtain this information by viewing the resource in the Azure portal).

Use the training API

The Custom Vision portal provides a convenient user interface that you can use to upload and tag images, and train models. However, in some scenarios you may want to automate model training by using the Custom Vision training API.

Open VS Code
Enter the following commands to clone the GitHub repo containing the code files for this exercise git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

After the repo has been cloned, use the following command to navigate to the application code files: cd mslearn-ai-vision/Labfiles/image-classification/python/train-classifier

The folder contains application configuration and code files for your app. It also contains an /more-training-images subfolder, which contains some image files you’ll use to perform additional training of your model.

Install the Azure AI Custom Vision SDK package for training and any other required packages by running the following commands: pip install -r requirements.txt azure-cognitiveservices-vision-customvision

Open env file in VS Code, update the configuration values it contains to reflect the Endpoint and an authentication Key for your Custom Vision training resource, and the Project ID for the custom vision project you created previously.
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command to save your changes and then use the CTRL+Q command to close the code editor while keeping the cloud shell command line open.

Write code to perform model training

Open train-classifier.py
Note the following details in the code file:
- The namespaces for the Azure AI Custom Vision SDK are imported.
- The Main function retrieves the configuration settings, and uses the key and endpoint to create an authenticated.
- CustomVisionTrainingClient, which is then used with the project ID to create a Project reference to your project.
- The Upload_Images function retrieves the tags that are defined in the Custom Vision project and then uploads image files from correspondingly named folders to the project, assigning the appropriate tag ID.
- The Train_Model function creates a new training iteration for the project and waits for training to complete.
Enter the following command to run the program:
python3 train-classifier.py

Wait for the program to end. Then return to the browser tab containing the Custom Vision portal, and view the Training Images page for your project (refreshing the browser if necessary).
Verify that some new tagged images have been added to the project. Then view the Performance page and verify that a new iteration has been created.

Use the image classifier in a client application.

Now you’re ready to publish your trained model and use it in a client application.

Publish the image classification model

In the Custom Vision portal, on the Performance page, click 🗸 Publish to publish the trained model with the following settings:
- Model name: fruit-classifier
- Prediction Resource: The prediction resource you created previously which ends with “-Prediction” (not the training resource).
At the top left of the Project Settings page, click the Projects Gallery (👁) icon to return to the Custom Vision portal home page, where your project is now listed.
On the Custom Vision portal home page, at the top right, click the settings (⚙) icon to view the settings for your Custom Vision service. Then, under Resources, find your prediction resource which ends with “-Prediction” (not the training resource) to determine its Key and Endpoint values (you can also obtain this information by viewing the resource in the Azure portal).

Use the image classifier from a client application

Return to VS Code and run cd ../test-classifier

The folder contains application configuration and code files for your app. It also contains a /test-images subfolder, which contains some image files you’ll use to test your model.

Install the Azure AI Custom Vision SDK package for prediction and any other required packages by running the following commands: pip install -r requirements.txt azure-cognitiveservices-vision-customvision

Open .env file in VS Code and update the configuration values to reflect the Endpoint and Key for your Custom Vision prediction resource, the Project ID for the classification project, and the name of your published model (which should be fruit-classifier). Save your changes (CTRL+S) and close the code editor (CTRL+Q).
Open test-classifier.py in VS Code
Review the code, noting the following details:
- The namespaces for the Azure AI Custom Vision SDK are imported.
- The Main function retrieves the configuration settings, and uses the key and endpoint to create an authenticated CustomVisionPredictionClient.
- The prediction client object is used to predict a class for each image in the test-images folder, specifying the project ID and model name for each request. Each prediction includes a probability for each possible class, and only predicted tags with a probability greater than 50% are displayed.
Close the code editor and enter the following command to run the program:
python3 test-classifier.py

You’ve just trained an AI to see and classify fruit—transforming raw images into intelligent predictions with Azure Custom Vision. This is the magic of computer vision: turning pixels into actionable insights with just a few lines of code and a handful of tagged images.
But why stop at fruit? Imagine applying these same techniques to:
• Quality control in manufacturing (defect detection)
• Retail inventory management (product categorization)
• Medical imaging (preliminary diagnostics)

Project guide link: https://microsoftlearning.github.io/mslearn-ai-vision/Instructions/Labs/04-image-classification.html

Unlocking Facial Recognition with Azure AI: A Step-by-Step Developer Guide

Olalekan Oladiran — Tue, 29 Jul 2025 22:40:47 +0000

Introduction

The ability to detect and analyze human faces is a core AI capability. In this exercise, you’ll explore the Face service to work with faces.

Provision an Azure AI Face API resource

Open the Azure portal at https://portal.azure.com, and sign in using your Azure credentials. Close any welcome messages or tips that are displayed.

Select Create a resource.
In the search bar, search for Face, select Face, and create the resource with the following settings:
- Subscription: Your Azure subscription
- Resource group: Create or select a resource group
- Region: Choose any available region
- Name: A valid name for your Face resource
- Pricing tier: Free F0

Create the resource and wait for deployment to complete, and then view the deployment details.
When the resource has been deployed, go to it and under the Resource management node in the navigation pane, view its Keys and Endpoint page. You will need the endpoint and one of the keys from this page in the next procedure.

Develop a facial analysis app with the Face SDK

Open VS Code
Enter the following commands to clone the GitHub repo containing the code files for this exercise git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

After the repo has been cloned, use the following command to navigate to the application code files: cd mslearn-ai-vision/Labfiles/face/python/face-api

The folder contains application configuration and code files for your app. It also contains an /images subfolder, which contains some image files for your app to analyze.

Install the Azure AI Vision SDK package and other required packages by running the following commands: pip install -r requirements.txt azure-ai-vision-face==1.0.0b2

Open env file in VS Code, update the configuration values it contains to reflect the endpoint and an authentication key for your Computer Vision resource (copied from its Keys and Endpoint page in the Azure portal).
After you’ve replaced the placeholders, use the CTRL+S command to save your changes and then use the CTRL+Q command to close the code editor while keeping the cloud shell command line open.

Add code to create a Face API client

Open analyze-faces.py in VS Code.
In the code file, find the comment Import namespaces, and add the following code to import the namespaces you will need to use the Azure AI Vision SDK:

# Import namespaces
from azure.ai.vision.face import FaceClient
from azure.ai.vision.face.models import FaceDetectionModel, FaceRecognitionModel, FaceAttributeTypeDetection01
from azure.core.credentials import AzureKeyCredential

In the Main function, note that the code to load the configuration settings and determine the image to be analyzed has been provided. Then find the comment Authenticate Face client and add the following code to create and authenticate a FaceClient object:

# Authenticate Face client
face_client = FaceClient(
     endpoint=cog_endpoint,
     credential=AzureKeyCredential(cog_key))

Add code to detect and analyze faces

In the code file for your application, in the Main function, find the comment Specify facial features to be retrieved and add the following code:

# Specify facial features to be retrieved
features = [FaceAttributeTypeDetection01.HEAD_POSE,
             FaceAttributeTypeDetection01.OCCLUSION,
             FaceAttributeTypeDetection01.ACCESSORIES]

In the Main function, under the code you just added, find the comment Get faces and add the following code to print the facial feature information and call a function that annotates the image with the bounding box for each detected face (based on the face_rectangle property of each face):

# Get faces
with open(image_file, mode="rb") as image_data:
     detected_faces = face_client.detect(
         image_content=image_data.read(),
         detection_model=FaceDetectionModel.DETECTION01,
         recognition_model=FaceRecognitionModel.RECOGNITION01,
         return_face_id=False,
         return_face_attributes=features,
     )

face_count = 0
if len(detected_faces) > 0:
     print(len(detected_faces), 'faces detected.')
     for face in detected_faces:

         # Get face properties
         face_count += 1
         print('\nFace number {}'.format(face_count))
         print(' - Head Pose (Yaw): {}'.format(face.face_attributes.head_pose.yaw))
         print(' - Head Pose (Pitch): {}'.format(face.face_attributes.head_pose.pitch))
         print(' - Head Pose (Roll): {}'.format(face.face_attributes.head_pose.roll))
         print(' - Forehead occluded?: {}'.format(face.face_attributes.occlusion["foreheadOccluded"]))
         print(' - Eye occluded?: {}'.format(face.face_attributes.occlusion["eyeOccluded"]))
         print(' - Mouth occluded?: {}'.format(face.face_attributes.occlusion["mouthOccluded"]))
         print(' - Accessories:')
         for accessory in face.face_attributes.accessories:
             print('   - {}'.format(accessory.type))
         # Annotate faces in the image
         annotate_faces(image_file, detected_faces)

Examine the code you added to the Main function. It analyzes an image file and detects any faces it contains, including attributes for head pose, occlusion, and the presence of accessories such as glasses. Additionally, a function is called to annotate the original image with a bounding box for each detected face.
Save your changes (CTRL+S) but keep the code editor open in case you need to fix any typo’s.
Resize the panes so you can see more of the console, then enter the following command to run the program with the argument images/face1.jpg: python3 analyze-faces.py images/face1.jpg

The app runs and analyzes the following image:

Observe the output, which should include the ID and attributes of each face detected.
Note that an image file named detected_faces.jpg is also generated. Open detected_faces.jpg:
Run the program again, this time specifying the parameter images/face2.jpg to extract text from the following image:
Run the program one more time, this time specifying the parameter images/faces.jpg to extract text from this image:

You’ve just harnessed the power of Azure’s Face API to detect and analyze human faces with remarkable precision—from identifying accessories to measuring head pose. This technology opens doors to transformative applications: smarter security systems, personalized retail experiences, and accessible UI design that adapts to users’ expressions and focus.

Project guide link: https://microsoftlearning.github.io/mslearn-ai-vision/Instructions/Labs/03-face-service.html

Extract Text Like Magic: Build an OCR App with Azure AI Vision in Python

Olalekan Oladiran — Tue, 29 Jul 2025 21:13:52 +0000

Introduction

Optical character recognition (OCR) is a subset of computer vision that deals with reading text in images and documents. The Azure AI Vision Image Analysis service provides an API for reading text, which you’ll explore in this exercise.

Provision an Azure AI Vision resource

Open the Azure portal at https://portal.azure.com, and sign in using your Azure credentials. Close any welcome messages or tips that are displayed.
Select Create a resource.
In the search bar, search for Computer Vision, select Computer Vision, and create the resource with the following settings:
- Subscription: Your Azure subscription
- Resource group: Create or select a resource group
- Region: Choose from East US, West US, France Central, Korea Central, North Europe, Southeast Asia, West Europe, or East Asia*
- Name: A valid name for your Computer Vision resource
- Pricing tier: Free F0 *Azure AI Vision 4.0 full feature sets are currently only available in these regions.
Select the required checkboxes and create the resource.
Wait for deployment to complete, and then view the deployment details.
When the resource has been deployed, go to it and under the Resource management node in the navigation pane, view its Keys and Endpoint page. You will need the endpoint and one of the keys from this page in the next procedure.

Develop a text extraction app with the Azure AI Vision SDK

Open VS Code
Enter the following commands to clone the GitHub repo containing the code files for this exercise git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

After the repo has been cloned, use the following command to navigate to and view the folder containing the application code files: cd mslearn-ai-vision/Labfiles/ocr/python/read-text

The folder contains application configuration and code files for your app. It also contains an /images subfolder, which contains some image files for your app to analyze.

Install the Azure AI Vision SDK package and other required packages by running the following commands:

pip install -r requirements.txt azure-ai-vision-imageanalysis==1.0.0

Open env file in VS Code, update the configuration values it contains to reflect the endpoint and an authentication key for your Computer Vision resource (copied from its Keys and Endpoint page in the Azure portal).
After you’ve replaced the placeholders, use the CTRL+S command to save your changes and then use the CTRL+Q command to close the code editor while keeping the cloud shell command line open.

Add code to read text from an image

Open read-text.py in VS Code.
In the code file, find the comment Import namespaces, and add the following code to import the namespaces you will need to use the Azure AI Vision SDK:

# import namespaces
from azure.ai.vision.imageanalysis import ImageAnalysisClient
from azure.ai.vision.imageanalysis.models import VisualFeatures
from azure.core.credentials import AzureKeyCredential

In the Main function, the code to load the configuration settings and determine the file to be analyzed has been provided. Then find the comment Authenticate Azure AI Vision client and add the following language-specific code to create and authenticate an Azure AI Vision Image Analysis client object:

# Authenticate Azure AI Vision client
cv_client = ImageAnalysisClient(
     endpoint=ai_endpoint,
     credential=AzureKeyCredential(ai_key))

In the Main function, under the code you just added, find the comment Read text in image and add the following code to use the Image Analysis client to read the text in the image:

# Read text in image
with open(image_file, "rb") as f:
     image_data = f.read()
print (f"\nReading text in {image_file}")

result = cv_client.analyze(
     image_data=image_data,
     visual_features=[VisualFeatures.READ])

Find the comment Print the text and add the following code (including the final comment) to print the lines of text that were found and call a function to annotate them in the image (using the bounding_polygon returned for each line of text):

# Print the text
if result.read is not None:
     print("\nText:")

     for line in result.read.blocks[0].lines:
         print(f" {line.text}")        
     # Annotate the text in the image
     annotate_lines(image_file, result.read)

     # Find individual words in each line

Save your changes (CTRL+S) but keep the code editor open in case you need to fix any typo’s.
Resize the panes so you can see more of the console, then enter the following command to run the program:

python3 read-text.py images/Lincoln.jpg
The program reads the text in the specified image file (images/Lincoln.jpg), which looks like this:
Open lines.jpg
Run the program again, this time specifying the parameter images/Business-card.jpg to extract text from the following image:

python read-text.py images/Business-card.jpg

Run the program one more time, this time specifying the parameter images/Note.jpg to extract text from this image:

python read-text.py images/Note.jpg

Add code to return the position of individual words

Resize the panes so you can see more of the code file. Then find the comment Find individual words in each line and add the following code (being careful to maintain the correct indentation level):

# Find individual words in each line
print ("\nIndividual words:")
for line in result.read.blocks[0].lines:
     for word in line.words:
         print(f"  {word.text} (Confidence: {word.confidence:.2f}%)")
# Annotate the words in the image
annotate_words(image_file, result.read)

Save your changes (CTRL+S). Then, in the command line pane, rerun the program to extract text from images/Lincoln.jpg.
Observe the output, which should include each individual word in the image, and the confidence associated with their prediction.
In the read-text folder, a words.jpg image has been created. Open words.jpg
Rerun the program for images/Business-card.jpg and images/Note.jpg; viewing the words.jpg file generated for each image.

You’ve just unlocked the power to transform images into actionable text data—whether it’s digitizing documents, processing receipts, or extracting text from photos. With Azure AI Vision, what once required manual effort now takes just a few lines of Python code.

Project guide link: https://microsoftlearning.github.io/mslearn-ai-vision/Instructions/Labs/02-ocr.html

Teaching Computers to Understand Images: Hands-On with Azure AI Vision

Olalekan Oladiran — Tue, 29 Jul 2025 14:41:46 +0000

Introduction

Azure AI Vision is an artificial intelligence capability that enables software systems to interpret visual input by analyzing images. In Microsoft Azure, the Vision Azure AI service provides pre-built models for common computer vision tasks, including analysis of images to suggest captions and tags, detection of common objects and people. You can also use the Azure AI Vision service to remove the background or create a foreground matting of images.

Provision an Azure AI Vision resource

Open the Azure portal at https://portal.azure.com, and sign in using your Azure credentials. Close any welcome messages or tips that are displayed.
Select Create a resource.
In the search bar, search for Computer Vision, select Computer Vision, and create the resource with the following settings:
- Subscription: Your Azure subscription
- Resource group: Create or select a resource group
- Region: Choose from East US, West US, France Central, Korea Central, North Europe, Southeast Asia, West Europe, or East Asia*
- Name: A valid name for your Computer Vision resource
- Pricing tier: Free F0 *Azure AI Vision 4.0 full feature sets are currently only available in these regions.
Select the required checkboxes and create the resource.
Wait for deployment to complete, and then view the deployment details.
When the resource has been deployed, go to it and under the Resource management node in the navigation pane, view its Keys and Endpoint page. You will need the endpoint and one of the keys from this page in the next procedure.

Develop an image analysis app with the Azure AI Vision SDK

Open VS Code
Enter the following commands to clone the GitHub repo containing the code files for this exercise git clone https://github.com/MicrosoftLearning/mslearn-ai-vision

After the repo has been cloned, use the following command to navigate to and view the folder containing the application code files: cd mslearn-ai-vision/Labfiles/analyze-images/python/image-analysis

The folder contains application configuration and code files for your app. It also contains a /images subfolder, which contains some image files for your app to analyze.

Install the Azure AI Vision SDK package and other required packages by running the following commands:

pip install -r requirements.txt azure-ai-vision-imageanalysis==1.0.0

Open env file in VS Code, update the configuration values it contains to reflect the endpoint and an authentication key for your Computer Vision resource (copied from its Keys and Endpoint page in the Azure portal).
After you’ve replaced the placeholders, use the CTRL+S command to save your changes and then use the CTRL+Q command to close the code editor while keeping the cloud shell command line open.

Add code to suggest a caption

Open image-analysis.py in VS Code.
In the code file, find the comment Import namespaces, and add the following code to import the namespaces you will need to use the Azure AI Vision SDK:

# import namespaces
from azure.ai.vision.imageanalysis import ImageAnalysisClient
from azure.ai.vision.imageanalysis.models import VisualFeatures
from azure.core.credentials import AzureKeyCredential

In the Main function, note that the code to load the configuration settings and determine the image file to be analyzed has been provided. Then find the comment Authenticate Azure AI Vision client and add the following code to create and authenticate a Azure AI Vision client object (be sure to maintain the correct indentation levels):

# Authenticate Azure AI Vision client
cv_client = ImageAnalysisClient(
     endpoint=ai_endpoint,
     credential=AzureKeyCredential(ai_key))

In the Main function, under the code you just added, find the comment Analyze image and add the following code:

# Analyze image
with open(image_file, "rb") as f:
     image_data = f.read()
print(f'\nAnalyzing {image_file}\n')

result = cv_client.analyze(
     image_data=image_data,
     visual_features=[
         VisualFeatures.CAPTION,
         VisualFeatures.DENSE_CAPTIONS,
         VisualFeatures.TAGS,
         VisualFeatures.OBJECTS,
         VisualFeatures.PEOPLE],
)

Find the comment Get image captions, add the following code to display image captions and dense captions:

# Get image captions
if result.caption is not None:
     print("\nCaption:")
     print(" Caption: '{}' (confidence: {:.2f}%)".format(result.caption.text, result.caption.confidence * 100))

if result.dense_captions is not None:
     print("\nDense Captions:")
     for caption in result.dense_captions.list:
         print(" Caption: '{}' (confidence: {:.2f}%)".format(caption.text, caption.confidence * 100))

Save your changes (CTRL+S) and resize the panes so you can clearly see the command line console while keeping the code editor open. Then enter the following command to run the program with the argument images/street.jpg: python3 image-analysis.py images/street.jpg

Observe the output, which should include a suggested caption for the street.jpg image, which looks like this:
Run the program again, this time with the argument images/building.jpg to see the caption that gets generated for the building.jpg image, which looks like this:
Repeat the previous step to generate a caption for the images/person.jpg file, which looks like this:

Add code to generate suggested tags

It can sometimes be useful to identify relevant tags that provide clues about the contents of an image.

In VS Code, ind the comment Get image tags and add the following code:

# Get image tags
if result.tags is not None:
     print("\nTags:")
     for tag in result.tags.list:
         print(" Tag: '{}' (confidence: {:.2f}%)".format(tag.name, tag.confidence * 100))

Save your changes (CTRL+S) and run the program with the argument images/street.jpg, observing that in addition to the image caption, a list of suggested tags is displayed.
Rerun the program for the images/building.jpg and images/person.jpg files.

Add code to detect and locate objects

In the code editor, in the AnalyzeImage function, find the comment Get objects in the image and add the following code to list the objects detected in the image, and call the provided function to annotate an image with the detected objects:

# Get objects in the image
if result.objects is not None:
     print("\nObjects in image:")
     for detected_object in result.objects.list:
         # Print object tag and confidence
         print(" {} (confidence: {:.2f}%)".format(detected_object.tags[0].name, detected_object.tags[0].confidence * 100))
     # Annotate objects in the image
     show_objects(image_file, result.objects.list)

Save your changes (CTRL+S) and run the program with the argument images/street.jpg, observing that in addition to the image caption and suggested tags; a file named objects.jpg is generated.
Check the object file
Rerun the program for the images/building.jpg and images/person.jpg files, downloading the generated objects.jpg file after each run.

Add code to detect and locate people

In the code editor, in the AnalyzeImage function, find the comment Get people in the image and add the following code to list any detected people with a confidence level of 20% or more, and call a provided function to annotate them in an image:

# Get people in the image
if result.people is not None:
     print("\nPeople in image:")

     for detected_person in result.people.list:
         if detected_person.confidence > 0.2:
             # Print location and confidence of each person detected
             print(" {} (confidence: {:.2f}%)".format(detected_person.bounding_box, detected_person.confidence * 100))
     # Annotate people in the image
     show_people(image_file, result.people.list)

Save your changes (CTRL+S) and run the program with the argument images/street.jpg, observing that in addition to the image caption, suggested tags, and objects.jpg file; a list of person locations and file named people.jpg is generated.
Open people.jpg file
Rerun the program for the images/building.jpg and images/person.jpg files, downloading the generated people.jpg file after each run.

You’ve just unlocked the power of computer vision—transforming raw pixels into intelligent insights with Azure AI. From auto-generating captions to detecting objects and people, you now have the tools to build applications that truly see and understand visual data.

Project guide link: https://microsoftlearning.github.io/mslearn-ai-vision/Instructions/Labs/01-analyze-images.html

Build a Talking Clock with Azure AI Speech: A Step-by-Step Guide to Speech Synthesis & Recognition

Olalekan Oladiran — Sun, 13 Jul 2025 17:52:45 +0000

Introduction

Azure AI Speech is a service that provides speech-related functionality, including:

A speech-to-text API that enables you to implement speech recognition (converting audible spoken words into text).
A text-to-speech API that enables you to implement speech synthesis (converting text into audible speech). In this exercise, you’ll use both of these APIs to implement a speaking clock application.

Create an Azure AI Speech resource

Go to your Azure portal and click create a resource
In the top search field, search for Speech service. Select it from the list, then select Create. Provision the resource using the following settings:
- Subscription: Your Azure subscription.
- Resource group: Choose or create a resource group.
- Region:Choose any available region
- Name: Enter a unique name.
- Pricing tier: Select F0 (free), or S (standard) if F is not available.
Select Review + create, then select Create to provision the resource.
Wait for deployment to complete, and then go to the deployed resource.
View the Keys and Endpoint page in the Resource Management section. You will need the information on this page later in the exercise.

Prepare and configure the speaking clock app

Open your VS Code and enter the following commands to clone the GitHub repo for this exercise: git clone https://github.com/microsoftlearning/mslearn-ai-language mslearn-ai-language

After the repo has been cloned, navigate to the folder containing the speaking clock application code files: cd mslearn-ai-language/Labfiles/07-speech/C-sharp/speaking-clock

Enter the following command to install the libraries you’ll use:

dotnet add package Azure.Identity
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Microsoft.CognitiveServices.Speech --version 1.42.0

Edit the appsettings.json by expanding speaking-clock
In the code file, replace the your_project_api_key and your_project_location placeholders with the API key and location for your project (copied from the portal page you left open).
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command or Right-click > Save to save your changes

Add code to use the Azure AI Speech SDK

Open Programs.cs file and at the top of the code file, under the existing namespace references, find the comment Import namespaces. Then, under this comment, add the following language-specific code to import the namespaces you will need to use the Azure AI Speech SDK:

// Import namespaces
using Azure.Identity;
using Azure.AI.Projects;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

In the main function, under the comment Get config settings, note that the code loads the project key and location you defined in the configuration file.
Under the comment Configure speech service, add the following code to use the AI Services key and your project’s region to configure your connection to the Azure AI Services Speech endpoint

// Configure speech service
speechConfig = SpeechConfig.FromSubscription(projectKey, location);
Console.WriteLine("Ready to use speech service in " + speechConfig.Region);

Save your changes (CTRL+S), but leave the code editor open.

Run the app

So far, the app doesn’t do anything other than connect to your Azure AI Speech service, but it’s useful to run it and check that it works before adding speech functionality.

In the command line, enter the following language-specific command to run the speaking clock app:

dotnet run
If you are using C#, you can ignore any warnings about using the await operator in asynchronous methods - we’ll fix that later. The code should display the region of the speech service resource the application will use. A successful run indicates that the app has connected to your Azure AI Speech resource.

NOTE: I encountered this error

OLAMOBILEs-MacBook-Pro:speaking-clock olamobile$ dotnet run
/Users/olamobile/AI-pract/mslearn-ai-language/Labfiles/07-speech/C-Sharp/speaking-clock/Program.cs(6,13): error CS0234: The type or namespace name 'Identity' does not exist in the namespace 'Azure' (are you missing an assembly reference?)
/Users/olamobile/AI-pract/mslearn-ai-language/Labfiles/07-speech/C-Sharp/speaking-clock/Program.cs(7,16): error CS0234: The type or namespace name 'Projects' does not exist in the namespace 'Azure.AI' (are you missing an assembly reference?)

The build failed. Fix the build errors and run again.

To fix this, I comment the first two lines under // Import namespaces.

Add code to recognize speech

Now that you have a SpeechConfig for the speech service in your project’s Azure AI Services resource, you can use the Speech-to-text API to recognize speech and transcribe it to text.
In this procedure, the speech input is captured from an audio file.

In the Main function, note that the code uses the TranscribeCommand function to accept spoken input. Then in the TranscribeCommand function, under the comment Configure speech recognition, add the appropriate code below to create a SpeechRecognizer client that can be used to recognize and transcribe speech from an audio file:

// Configure speech recognition
string audioFile = "time.wav";
using AudioConfig audioConfig = AudioConfig.FromWavFileInput(audioFile);
using SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

In the TranscribeCommand function, under the comment Process speech input, add the following code to listen for spoken input, being careful not to replace the code at the end of the function that returns the command:

// Process speech input
Console.WriteLine("Listening...");
SpeechRecognitionResult speech = await speechRecognizer.RecognizeOnceAsync();
if (speech.Reason == ResultReason.RecognizedSpeech)
{
    command = speech.Text;
    Console.WriteLine(command);
}
else
{
    Console.WriteLine(speech.Reason);
    if (speech.Reason == ResultReason.Canceled)
    {
        var cancellation = CancellationDetails.FromResult(speech);
        Console.WriteLine(cancellation.Reason);
        Console.WriteLine(cancellation.ErrorDetails);
    }
}

Save your changes (CTRL+S), and then in the command line below the code editor, enter the following command to run the program: dotnet run

Synthesize speech

Your speaking clock application accepts spoken input, but it doesn’t actually speak! Let’s fix that by adding code to synthesize speech.
Once again, due to the hardware limitations of the cloud shell we’ll direct the synthesized speech output to a file.

In the Main function for your program, note that the code uses the TellTime function to tell the user the current time.
In the TellTime function, under the comment Configure speech synthesis, add the following code to create a SpeechSynthesizer client that can be used to generate spoken output:

// Configure speech synthesis
var outputFile = "output.wav";
speechConfig.SpeechSynthesisVoiceName = "en-GB-RyanNeural";
using var audioConfig = AudioConfig.FromWavFileOutput(outputFile);
using SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

In the TellTime function, under the comment Synthesize spoken output, add the following code to generate spoken output, being careful not to replace the code at the end of the function that prints the response:

// Synthesize spoken output
SpeechSynthesisResult speak = await speechSynthesizer.SpeakTextAsync(responseText);
if (speak.Reason != ResultReason.SynthesizingAudioCompleted)
{
    Console.WriteLine(speak.Reason);
}
else
{
    Console.WriteLine("Spoken output saved in " + outputFile);
}

Save your changes (CTRL+S), and then in the command line below the code editor, enter the following command to run the program:

dotnet run
Review the output from the application, which should indicate that the spoken output was saved in a file.
If you have a media player capable of playing .wav audio files, in the toolbar for the cloud shell pane, use the Upload/Download files button to download the audio file from your app folder, and then play it:

/home/user/mslearn-ai-language/Labfiles/07-speech/C-Sharp/speaking-clock/output.wav

Use Speech Synthesis Markup Language

Speech Synthesis Markup Language (SSML) enables you to customize the way your speech is synthesized using an XML-based format.

In the TellTime function, replace all of the current code under the comment Synthesize spoken output with the following code (leave the code under the comment Print the response):

// Synthesize spoken output
string responseSsml = $@"
    <speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'>
        <voice name='en-GB-LibbyNeural'>
            {responseText}
            <break strength='weak'/>
            Time to end this lab!
        </voice>
    </speak>";
SpeechSynthesisResult speak = await speechSynthesizer.SpeakSsmlAsync(responseSsml);
if (speak.Reason != ResultReason.SynthesizingAudioCompleted)
{
    Console.WriteLine(speak.Reason);
}
else
{
     Console.WriteLine("Spoken output saved in " + outputFile);
}

Save your changes and return to the integrated terminal for the speaking-clock folder, and enter the following command to run the program:

dotnet run
Review the output from the application, which should indicate that the spoken output was saved in a file.
Once again, if you have a media player capable of playing .wav audio files, in the toolbar for the cloud shell pane, use the Upload/Download files button to download the audio file from your app folder, and then play it:

/home/user/mslearn-ai-language/Labfiles/07-speech/C-Sharp/speaking-clock/output.wav

What if you have a mic and speaker?

In this exercise, you used audio files for the speech input and output. Let’s see how the code can be modified to use audio hardware.

Using speech recognition with a microphone

If you have a mic, you can use the following code to capture spoken input for speech recognition:

// Configure speech recognition
using AudioConfig audioConfig = AudioConfig.FromDefaultMicrophoneInput();
using SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
Console.WriteLine("Speak now...");

SpeechRecognitionResult speech = await speechRecognizer.RecognizeOnceAsync();
if (speech.Reason == ResultReason.RecognizedSpeech)
{
    command = speech.Text;
    Console.WriteLine(command);
}
else
{
    Console.WriteLine(speech.Reason);
    if (speech.Reason == ResultReason.Canceled)
    {
        var cancellation = CancellationDetails.FromResult(speech);
        Console.WriteLine(cancellation.Reason);
        Console.WriteLine(cancellation.ErrorDetails);
    }
}

Using speech synthesis with a speaker

If you have a speaker, you can use the following code to synthesize speech.

var now = DateTime.Now;
string responseText = "The time is " + now.Hour.ToString() + ":" + now.Minute.ToString("D2");

// Configure speech synthesis
speechConfig.SpeechSynthesisVoiceName = "en-GB-RyanNeural";
using var audioConfig = AudioConfig.FromDefaultSpeakerOutput();
using SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer(speechConfig, audioConfig);

// Synthesize spoken output
SpeechSynthesisResult speak = await speechSynthesizer.SpeakTextAsync(responseText);
if (speak.Reason != ResultReason.SynthesizingAudioCompleted)
{
    Console.WriteLine(speak.Reason);
}

You’ve just transformed text into speech and speech into understanding—turning Azure AI’s capabilities into a functional talking clock. But this is just the beginning. Imagine applying these same techniques to build voice assistants, interactive IVR systems, or even accessibility tools that give your applications a voice.

Thanks for staying till the end

How I Built a Smart Translation App Using Azure AI (And You Can Too)

Olalekan Oladiran — Sun, 13 Jul 2025 00:45:42 +0000

Introduction

Azure AI Translator is a service that enables you to translate text between languages. In this exercise, you’ll use it to create a simple app that translates input in any supported language to the target language of your choice.

Provision an Azure AI Translator resource

Go to your Azure portal and click create a resource
In the search field at the top, search for Translators then select Translators in the results.
Create a resource with the following settings:
- Subscription: Your Azure subscription
- Resource group: Choose or create a resource group
- Region: Choose any available region
- Name: Enter a unique name
- Pricing tier: Select F0 (free), or S (standard) if F is not available.
Select Review + create, then select Create to provision the resource.
Wait for deployment to complete, and then go to the deployed resource.
View the Keys and Endpoint page. You will need the information on this page later in the exercise.

Prepare to develop an app in Cloud Shell

Enter the following commands to clone the GitHub repo for this exercise: git clone https://github.com/microsoftlearning/mslearn-ai-language mslearn-ai-language

After the repo has been cloned, navigate to the folder containing the application code files: cd mslearn-ai-language/Labfiles/06-translator-sdk

Configure your application

Applications for both C# and Python have been provided, as well as a sample text file you’ll use to test the summarization. Both apps feature the same functionality. We will be using C# for this project. First, you’ll complete some key parts of the application to enable it to use your Azure AI Translator resource.

Run the command cd C-Sharp/translate-text or on your language preference. Each folder contains the language-specific code files for an app into which you’re you’re going to integrate Azure AI Translator functionality.
Install the Azure AI Translator SDK package by running the appropriate command for your language preference: dotnet add package Azure.AI.Translation.Text --version 1.0.0

Edit the appsettings.json by expanding translate-text.
Update the configuration values to include the region and a key from the Azure AI Translator resource you created (available on the Keys and Endpoint page for your Azure AI Translator resource in the Azure portal).
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command or Right-click > Save to save your changes.

Add code to translate text

Now you’re ready to use Azure AI Translator to translate text.

Open Programs.cs file and at the top, under the existing namespace references, find the comment Import namespaces. Then, under this comment, add the following language-specific code to import the namespaces you will need to use the Text Analytics SDK:

 // import namespaces
 using Azure;
 using Azure.AI.Translation.Text;

Find the comment Create client using endpoint and key and add the following code:

 // Create client using endpoint and key
 AzureKeyCredential credential = new(translatorKey);
 TextTranslationClient client = new(credential, translatorRegion);

Find the comment Choose target language and add the following code, which uses the Text Translator service to return list of supported languages for translation, and prompts the user to select a language code for the target language.

 // Choose target language
 Response<GetSupportedLanguagesResult> languagesResponse = await client.GetSupportedLanguagesAsync(scope:"translation").ConfigureAwait(false);
 GetSupportedLanguagesResult languages = languagesResponse.Value;
 Console.WriteLine($"{languages.Translation.Count} languages available.\n(See https://learn.microsoft.com/azure/ai-services/translator/language-support#translation)");
 Console.WriteLine("Enter a target language code for translation (for example, 'en'):");
 string targetLanguage = "xx";
 bool languageSupported = false;
 while (!languageSupported)
 {
     targetLanguage = Console.ReadLine();
     if (languages.Translation.ContainsKey(targetLanguage))
     {
         languageSupported = true;
     }
     else
     {
         Console.WriteLine($"{targetLanguage} is not a supported language.");
     }

 }

Find the comment Translate text and add the following code, which repeatedly prompts the user for text to be translated, uses the Azure AI Translator service to translate it to the target language (detecting the source language automatically), and displays the results until the user enters quit.

 // Translate text
 string inputText = "";
 while (inputText.ToLower() != "quit")
 {
     Console.WriteLine("Enter text to translate ('quit' to exit)");
     inputText = Console.ReadLine();
     if (inputText.ToLower() != "quit")
     {
         Response<IReadOnlyList<TranslatedTextItem>> translationResponse = await client.TranslateAsync(targetLanguage, inputText).ConfigureAwait(false);
         IReadOnlyList<TranslatedTextItem> translations = translationResponse.Value;
         TranslatedTextItem translation = translations[0];
         string sourceLanguage = translation?.DetectedLanguage?.Language;
         Console.WriteLine($"'{inputText}' translated from {sourceLanguage} to {translation?.Translations[0].TargetLanguage} as '{translation?.Translations?[0]?.Text}'.");
     }
 }

Save the changes to your code file and close the code editor.

Test your application

Now your application is ready to test.

Enter the following command to run the program (you maximize the console panel to see more text):

dotnet run
When prompted, enter a valid target language from the list displayed e.g. en for English
Enter a phrase to be translated (for example This is a test or C'est un test) and view the results, which should detect the source language and translate the text to the target language.
When you’re done, enter quit. You can run the application again and choose a different target language.

You've just unlocked the power of Azure AI Translator – transforming any text into multiple languages with just a few lines of code. Whether you're building multilingual apps, global customer support, or breaking down language barriers in your projects, this technology opens doors to truly borderless communication.

Thanks for staying till the end

How to Train an AI Model to Understand Time, Date & Location Requests

Olalekan Oladiran — Tue, 08 Jul 2025 11:59:41 +0000

Introduction

The Azure AI Language service enables you to define a conversational language understanding model that applications can use to interpret natural language input from users, predict the users intent (what they want to achieve), and identify any entities to which the intent should be applied.

For example, a conversational language model for a clock application might be expected to process input such as:

What is the time in London?

This kind of input is an example of an utterance (something a user might say or type), for which the desired intent is to get the time in a specific location (an entity); in this case, London.

Provision an Azure AI Language resource

Click Build Your First Text Analytics App with Azure AI in Under 30 Minutes

Create a conversational language understanding project

Now that you have created an authoring resource, you can use it to create a conversational language understanding project.

In a new browser tab, open the Azure AI Language Studio portal at https://language.cognitive.azure.com/ and sign in using the Microsoft account associated with your Azure subscription.
In a new browser tab, go to the Language Studio portal at https://language.cognitive.azure.com/ and sign in using the Microsoft account associated with your Azure subscription.
If you’re prompted to choose a Language resource, select the following settings:
- Azure Directory: The Azure directory containing your subscription.
- Azure subscription: Your Azure subscription.
- Resource type: Language
- Resource name: The Azure AI Language resource you created previously. If you are not prompted to choose a language resource, it may be because you have multiple Language resources in your subscription; in which case:
- On the bar at the top if the page, select the Settings (⚙) button.
- On the Settings page, view the Resources tab.
- Select the language resource you just created, and click Switch resource.
- At the top of the page, click Language Studio to return to the Language Studio home page.
At the top of the portal, in the Create new menu, select Conversational language understanding.

In the Create a project dialog box, on the Enter basic information page, enter the following details and then select Next:
- Name: Clock
- Utterances primary language: English
- Enable multiple languages in project?: Unselected
- Description: Natural language clock On the Review and finish page, select Create.

Create intents

The first thing we’ll do in the new project is to define some intents. The model will ultimately predict which of these intents a user is requesting when submitting a natural language utterance.

On the Schema definition page, on the Intents tab, select ＋ Add to add a new intent named GetTime.
Verify that the GetTime intent is listed (along with the default None intent). Then add the following additional intents:
- GetDay
- GetDate
Select the new GetTime intent and enter the utterance what is the time?. This adds the utterance as sample input for the intent. Add the following additional utterances for the GetTime intent:
- what's the time?
- what time is it?
- tell me the time
Select the GetDay intent and add the following utterances as example input for that intent:
- what day is it?
- what's the day?
- what is the day today?
- what day of the week is it?
Select the GetDate intent and add the following utterances for it:
- what date is it?
- what's the date?
- what is the date today?
- what's today's date?

Train and test the model

Now that you’ve added some intents, let’s train the language model and see if it can correctly predict them from user input.

In the pane on the left, select Training jobs. Then select + Start a training job.
On the Start a training job dialog, select the option to train a new model, name it Clock. Select Standard training mode and the default Data splitting options.
To begin the process of training your model, select Train.
When training is complete (which may take several minutes) the job Status will change to Training succeeded.
Select the Model performance page, and then select the Clock model. Review the overall and per-intent evaluation metrics (precision, recall, and F1 score) and the confusion matrix generated by the evaluation that was performed when training (note that due to the small number of sample utterances, not all intents may be included in the results).
Go to the Deploying a model page, then select Add deployment.
On the Add deployment dialog, select Create a new deployment name, and then enter production.
Select the Clock model in the Model field then select Deploy. The deployment may take some time.
When the model has been deployed, select the Testing deployments page, then select the production deployment in the Deployment name field.
Enter the following text in the empty textbox, and then select Run the test: what's the time now?
Review the result that is returned, noting that it includes the predicted intent (which should be GetTime) and a confidence score that indicates the probability the model calculated for the predicted intent. The JSON tab shows the comparative confidence for each potential intent (the one with the highest confidence score is the predicted intent)
Clear the text box, and then run another test with the following text: tell me the time
Again, review the predicted intent and confidence score.
Try the following text: what's the day today?
Hopefully the model predicts the GetDay intent.

Add entities

So far you’ve defined some simple utterances that map to intents. Most real applications include more complex utterances from which specific data entities must be extracted to get more context for the intent.
The most common kind of entity is a learned entity, in which the model learns to identify entity values based on examples.

In Language Studio, return to the Schema definition page and then on the Entities tab, select ＋ Add to add a new entity.
In the Add an entity dialog box, enter the entity name Location and ensure that the Learned tab is selected. Then select Add entity.
After the Location entity has been created, return to the Data labeling page.
Select the GetTime intent and enter the following new example utterance: what time is it in London?
When the utterance has been added, select the word London, and in the drop-down list that appears, select Location to indicate that “London” is an example of a location.
Add another example utterance for the GetTime intent: Tell me the time in Paris?
When the utterance has been added, select the word Paris, and map it to the Location entity.
Add another example utterance for the GetTime intent: what's the time in New York?
When the utterance has been added, select the words New York, and map them to the Location entity.
Select Save changes to save the new utterances.

Add a list entity

In some cases, valid values for an entity can be restricted to a list of specific terms and synonyms; which can help the app identify instances of the entity in utterances.

In Language Studio, return to the Schema definition page and then on the Entities tab, select ＋ Add to add a new entity.
In the Add an entity dialog box, enter the entity name Weekday and select the List entity tab. Then select Add entity.
On the page for the Weekday entity, in the Learned section, ensure Not required is selected. Then, in the List section, select ＋ Add new list. Then enter the following value and synonym and select Save:

List key	Synonyms
Sunday	Sun
Monday	Mon
Tuesday	Tue, Tues
Wednesday	Wed, Weds
Thursday	Thur, Thurs
Friday	Fri
Saturday	Sat

After adding and saving the list values, return to the Data labeling page.
Select the GetDate intent and enter the following new example utterance: what date was it on Saturday?
When the utterance has been added, select the word Saturday, and in the drop-down list that appears, select Weekday.
Add another example utterance for the GetDate intent: what date will it be on Friday?
When the utterance has been added, map Friday to the Weekday entity.
Add another example utterance for the GetDate intent: what will the date be on Thurs?
When the utterance has been added, map Thurs to the Weekday entity. select Save changes to save the new utterances.

Add a prebuilt entity

The Azure AI Language service provides a set of prebuilt entities that are commonly used in conversational applications.

In Language Studio, return to the Schema definition page and then on the Entities tab, select ＋ Add to add a new entity.
In the Add an entity dialog box, enter the entity name Date and select the Prebuilt entity tab. Then select Add entity.
On the page for the Date entity, in the Learned section, ensure Not required is selected. Then, in the Prebuilt section, select ＋ Add new prebuilt.
In the Select prebuilt list, select DateTime and then select Save.
After adding the prebuilt entity, return to the Data labeling page
Select the GetDay intent and enter the following new example utterance: what day was 01/01/1901?
When the utterance has been added, select 01/01/1901, and in the drop-down list that appears, select Date.
Add another example utterance for the GetDay intent: what day will it be on Dec 31st 2099?
When the utterance has been added, map Dec 31st 2099 to the Date entity.
Select Save changes to save the new utterances.

Retrain the model

Now that you’ve modified the schema, you need to retrain and retest the model.

On the Training jobs page, select Start a training job.
On the Start a training job dialog, select overwrite an existing model and specify the Clock model. Select Train to train the model. If prompted, confirm you want to overwrite the existing model.
When training is complete the job Status will update to Training succeeded.
Select the Model performance page and then select the Clock model. Review the evaluation metrics (precision, recall, and F1 score) and the confusion matrix generated by the evaluation that was performed when training (note that due to the small number of sample utterances, not all intents may be included in the results).
On the Deploying a model page, select Add deployment.
On the Add deployment dialog, select Override an existing deployment name, and then select production.
Select the Clock model in the Model field and then select Deploy to deploy it. This may take some time.
When the model is deployed, on the Testing deployments page, select the production deployment under the Deployment name field, and then test it with the following text: what's the time in Edinburgh?
Review the result that is returned, which should hopefully predict the GetTime intent and a Location entity with the text value “Edinburgh”.
Try testing the following utterances:
- what time is it in Tokyo?
- what date is it on Friday?
- what's the date on Weds?
- what day was 01/01/2020?
- what day will Mar 7th 2030 be?

Use the model from a client app

In a real project, you’d iteratively refine intents and entities, retrain, and retest until you are satisfied with the predictive performance. Then, when you’ve tested it and are satisfied with its predictive performance, you can use it in a client app by calling its REST interface or a runtime-specific SDK.

Prepare to develop an app in VS Code

Open VS Code and enter the following commands to clone the GitHub repo for this exercise: git clone https://github.com/microsoftlearning/mslearn-ai-language mslearn-ai-language

After the repo has been cloned, navigate to the folder containing the application code files:

cd mslearn-ai-language/Labfiles/03-language

Configure your application

Run the command cd C-Sharp/clock-client on your language preference. Each folder contains the language-specific files for an app into which you’re going to integrate Azure AI Language question answering functionality.
Install the Azure AI Language conversational language understanding SDK package by running the appropriate command for your language preference: dotnet add package Azure.AI.Language.Conversations --version 1.1.0

Open appsettings.json file.
Update the configuration values to include the endpoint and a key from the Azure Language resource you created (available on the Keys and Endpoint page for your Azure AI Language resource in the Azure portal).
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command or Right-click > Save to save your changes.

Add code to the application

Now you’re ready to add the code necessary to import the required SDK libraries, establish an authenticated connection to your deployed project, and submit questions.

Note that the clock-client folder contains a code file for the client application: Program.cs
Open the code file and at the top, under the existing namespace references, find the comment Import namespaces. Then, under this comment, add the following language-specific code to import the namespaces you will need to use the Text Analytics SDK:

 // import namespaces
 using Azure;
 using Azure.AI.Language.Conversations;

In the Main function, note that code to load the prediction endpoint and key from the configuration file has already been provided. Then find the comment Create a client for the Language service model and add the following code to create a prediction client for your Language Service app:

 // Create a client for the Language service model
 Uri endpoint = new Uri(predictionEndpoint);
 AzureKeyCredential credential = new AzureKeyCredential(predictionKey);

 ConversationAnalysisClient client = new ConversationAnalysisClient(endpoint, credential);

Note that the code in the Main function prompts for user input until the user enters “quit”. Within this loop, find the comment Call the Language service model to get intent and entities and add the following code:

 // Call the Language service model to get intent and entities
 var projectName = "Clock";
 var deploymentName = "production";
 var data = new
 {
     analysisInput = new
     {
         conversationItem = new
         {
             text = userText,
             id = "1",
             participantId = "1",
         }
     },
     parameters = new
     {
         projectName,
         deploymentName,
         // Use Utf16CodeUnit for strings in .NET.
         stringIndexType = "Utf16CodeUnit",
     },
     kind = "Conversation",
 };
 // Send request
 Response response = await client.AnalyzeConversationAsync(RequestContent.Create(data));
 dynamic conversationalTaskResult = response.Content.ToDynamicFromJson(JsonPropertyNames.CamelCase);
 dynamic conversationPrediction = conversationalTaskResult.Result.Prediction;   
 var options = new JsonSerializerOptions { WriteIndented = true };
 Console.WriteLine(JsonSerializer.Serialize(conversationalTaskResult, options));
 Console.WriteLine("--------------------\n");
 Console.WriteLine(userText);
 var topIntent = "";
 if (conversationPrediction.Intents[0].ConfidenceScore > 0.5)
 {
     topIntent = conversationPrediction.TopIntent;
 }

The call to the Language service model returns a prediction/result, which includes the top (most likely) intent as well as any entities that were detected in the input utterance. Your client application must now use that prediction to determine and perform the appropriate action.

Find the comment Apply the appropriate action, and add the following code, which checks for intents supported by the application (GetTime, GetDate, and GetDay) and determines if any relevant entities have been detected, before calling an existing function to produce an appropriate response.

 // Apply the appropriate action
 switch (topIntent)
 {
     case "GetTime":
         var location = "local";           
         // Check for a location entity
         foreach (dynamic entity in conversationPrediction.Entities)
         {
             if (entity.Category == "Location")
             {
                 //Console.WriteLine($"Location Confidence: {entity.ConfidenceScore}");
                 location = entity.Text;
             }
         }
         // Get the time for the specified location
         string timeResponse = GetTime(location);
         Console.WriteLine(timeResponse);
         break;
     case "GetDay":
         var date = DateTime.Today.ToShortDateString();            
         // Check for a Date entity
         foreach (dynamic entity in conversationPrediction.Entities)
         {
             if (entity.Category == "Date")
             {
                 //Console.WriteLine($"Location Confidence: {entity.ConfidenceScore}");
                 date = entity.Text;
             }
         }            
         // Get the day for the specified date
         string dayResponse = GetDay(date);
         Console.WriteLine(dayResponse);
         break;
     case "GetDate":
         var day = DateTime.Today.DayOfWeek.ToString();
         // Check for entities            
         // Check for a Weekday entity
         foreach (dynamic entity in conversationPrediction.Entities)
         {
             if (entity.Category == "Weekday")
             {
                 //Console.WriteLine($"Location Confidence: {entity.ConfidenceScore}");
                 day = entity.Text;
             }
         }          
         // Get the date for the specified day
         string dateResponse = GetDate(day);
         Console.WriteLine(dateResponse);
         break;
     default:
         // Some other intent (for example, "None") was predicted
         Console.WriteLine("Try asking me for the time, the day, or the date.");
         break;
 }

Save your changes and close the code editor, then enter the following command to run the program (you maximize the console panel to see more text): dotnet run
When prompted, enter utterances to test the application. For example, try:
- Hello
- What time is it?
- What’s the time in London?
- What’s the date?
- What date is Sunday?
- What day is it?
- What day is 01/01/2025?
When you have finished testing, enter quit.

You’ve just transformed raw text into an intelligent conversational experience—teaching Azure AI to understand time queries, extract locations, and even handle date math. This is the power of modern NLP: turning ambiguous human phrases into precise actions with a trained language model.

But don’t stop at clocks! Imagine applying these techniques to customer support bots, smart home controls, or workflow automation. The patterns are the same; only the intents change.

Thanks for staying till the end

Build a Smarter FAQ Bot with Azure AI: A Step-by-Step Guide to Question Answering

Olalekan Oladiran — Sun, 06 Jul 2025 12:02:14 +0000

Introduction

One of the most common conversational scenarios is providing support through a knowledge base of frequently asked questions (FAQs). Many organizations publish FAQs as documents or web pages, which works well for a small set of question and answer pairs, but large documents can be difficult and time-consuming to search.

Azure AI Language includes a question answering capability that enables you to create a knowledge base of question and answer pairs that can be queried using natural language input, and is most commonly used as a resource that a bot can use to look up answers to questions submitted by users.

Provision an Azure AI Language resource

Click Build Your First Text Analytics App with Azure AI in Under 30 Minutes

Create a question answering project

To create a knowledge base for question answering in your Azure AI Language resource, you can use the Language Studio portal to create a question answering project. In this case, you’ll create a knowledge base containing questions and answers about Microsoft Learn.

In a new browser tab, go to the Language Studio portal at https://language.cognitive.azure.com/ and sign in using the Microsoft account associated with your Azure subscription.
If you’re prompted to choose a Language resource, select the following settings:
- Azure Directory: The Azure directory containing your subscription.
- Azure subscription: Your Azure subscription.
- Resource type: Language
- Resource name: The Azure AI Language resource you created previously. If you are not prompted to choose a language resource, it may be because you have multiple Language resources in your subscription; in which case:
- On the bar at the top if the page, select the Settings (⚙) button.
- On the Settings page, view the Resources tab.
- Select the language resource you just created, and click Switch resource.
- At the top of the page, click Language Studio to return to the Language Studio home page.
Click create new and select Custom question answering.
In the Create a project wizard, on the Choose language setting page, select the option to Select the language for all projects, and select English as the language. Then select Next.
On the Enter basic information page, enter the following details:
- Name LearnFAQ
- Description: FAQ for Microsoft Learn
- Default answer when no answer is returned: Sorry, I don't understand the question
Select Next.
On the Review and finish page, select Create project.

Add sources to the knowledge base

You can create a knowledge base from scratch, but it’s common to start by importing questions and answers from an existing FAQ page or document. In this case, you’ll import data from an existing FAQ web page for Microsoft Learn, and you’ll also import some pre-defined “chit chat” questions and answers to support common conversational exchanges.

On the Manage sources page for your question answering project, in the + Add source list, select URLs. Then in the Add URLs dialog box, select + Add url and set the following name and URL before you select Add all to add it to the knowledge base:
- Name: Learn FAQ Page
- URL: https://docs.microsoft.com/en-us/learn/support/faq

On the Manage sources page for your question answering project, in the + Add source list, select Chitchat. The in the Add chit chat dialog box, select Friendly and select Add chit chat.

Edit the knowledge base

Your knowledge base has been populated with question and answer pairs from the Microsoft Learn FAQ, supplemented with a set of conversational chit-chat question and answer pairs. You can extend the knowledge base by adding additional question and answer pairs.

In your LearnFAQ project in Language Studio, select the Edit knowledge base page to see the existing question and answer pairs (if some tips are displayed, read them and choose Got it to dismiss them, or select Skip all)
In the knowledge base, on the Question answer pairs tab, select ＋, and create a new question answer pair with the following settings:
- Source: https://docs.microsoft.com/en-us/learn/support/faq
- Question: What are Microsoft credentials?
- Answer: Microsoft credentials enable you to validate and prove your skills with Microsoft technologies.
Select Done.
In the page for the What are Microsoft credentials? question that is created, expand Alternate questions. Then add the alternate question How can I demonstrate my Microsoft technology skills?.
Under the answer you entered for the certification question, expand Follow-up prompts and add the following follow-up prompt:
- Text displayed in the prompt to the user: Learn more about credentials.
- Select the Create link to new pair tab, and enter this text: You can learn more about credentials on the Microsoft credentials page.
- Select Show in contextual flow only. This option ensures that the answer is only ever returned in the context of a follow-up question from the original certification question.
Select Add prompt.

Train and test the knowledge base

Now that you have a knowledge base, you can test it in Language Studio.

Save the changes to your knowledge base by selecting the Save button under the Question answer pairs tab on the left.
After the changes have been saved, select the Test button to open the test pane.
In the test pane, at the top, deselect Include short answer response (if not already unselected). Then at the bottom enter the message Hello. A suitable response should be returned.
In the test pane, at the bottom enter the message What is Microsoft Learn?. An appropriate response from the FAQ should be returned.
Enter the message Thanks! An appropriate chit-chat response should be returned.
Enter the message Tell me about Microsoft credentials. The answer you created should be returned along with a follow-up prompt link.
Select the Learn more about credentials follow-up link. The follow-up answer with a link to the certification page should be returned.
When you’re done testing the knowledge base, close the test pane.

Deploy the knowledge base

The knowledge base provides a back-end service that client applications can use to answer questions. Now you are ready to publish your knowledge base and access its REST interface from a client.

In the LearnFAQ project in Language Studio, select the Deploy knowledge base page from the navigation menu on the left.
At the top of the page, select Deploy. Then select Deploy to confirm you want to deploy the knowledge base.
When deployment is complete, select Get prediction URL to view the REST endpoint for your knowledge base and note that the sample request includes parameters for:
- projectName: The name of your project (which should be LearnFAQ)
- deploymentName: The name of your deployment (which should be production)
Close the prediction URL dialog box.

Prepare to develop an app in VS Code

Open VS Code and enter the following commands to clone the GitHub repo for this exercise: git clone https://github.com/microsoftlearning/mslearn-ai-language mslearn-ai-language

After the repo has been cloned, navigate to the folder containing the application code files:

cd mslearn-ai-language/Labfiles/02-qna

Configure your application

Run the command cd C-Sharp/qna-app on your language preference. Each folder contains the language-specific files for an app into which you’re going to integrate Azure AI Language question answering functionality.

dotnet add package Azure.AI.Language.QuestionAnswering

Open appsettings.json file.
In the code file, update the configuration values it contains to reflect the endpoint and an authentication key for the Azure Language resource you created (available on the Keys and Endpoint page for your Azure AI Language resource in the Azure portal). The project name and deployment name for your deployed knowledge base should also be in this file.
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command or Right-click > Save to save your changes.

Add code to the application

Now you’re ready to add the code necessary to import the required SDK libraries, establish an authenticated connection to your deployed project, and submit questions.

Note that the qna-app folder contains a code file for the client application: C#: Program.cs
Open the code file and at the top, under the existing namespace references, find the comment Import namespaces. Then, under this comment, add the following language-specific code to import the namespaces you will need to use the Text Analytics SDK:

 // import namespaces
 using Azure;
 using Azure.AI.Language.QuestionAnswering;

In the Main function, note that code to load the Azure AI Language service endpoint and key from the configuration file has already been provided. Then find the comment Create client using endpoint and key, and add the following code to create a client for the Text Analysis API:

// Create client using endpoint and key
AzureKeyCredential credentials = new AzureKeyCredential(aiSvcKey);
Uri endpoint = new Uri(aiSvcEndpoint);
QuestionAnsweringClient aiClient = new    QuestionAnsweringClient(endpoint, credentials);

In the Main function, find the comment Submit a question and display the answer, and add the following code to repeatedly read questions from the command line, submit them to the service, and display details of the answers:

 // Submit a question and display the answer
 string user_question = "";
 while (true)
     {
         Console.Write("Question: ");
         user_question = Console.ReadLine();
         if (user_question.ToLower() == "quit")
             break;
         QuestionAnsweringProject project = new QuestionAnsweringProject(projectName, deploymentName);
         Response<AnswersResult> response = aiClient.GetAnswers(user_question, project);
         foreach (KnowledgeBaseAnswer answer in response.Value.Answers)
         {
             Console.WriteLine(answer.Answer);
             Console.WriteLine($"Confidence: {answer.Confidence:P2}");
             Console.WriteLine($"Source: {answer.Source}");
             Console.WriteLine();
         }
     }

Save your changes, then enter the following command to run the program:

dotnet run
When prompted, enter a question to be submitted to your question answering project; for example What is a learning path?.
Review the answer that is returned.
Ask more questions. When you’re done, enter quit.

You’ve just transformed static FAQ documents into an intelligent, AI-powered question-answering system with Azure AI Language. By leveraging natural language understanding, your knowledge base can now deliver instant, accurate responses—freeing up time for more complex support tasks and improving user experiences.

But don’t stop here! Experiment with adding more data sources, fine-tuning answers, or integrating your knowledge base into a chatbot for seamless customer interactions. The future of automated support starts with tools like these, and you’re already ahead of the curve.

Ready to take the next step? Dive deeper into Azure AI documentation or try connecting your Q&A system to Microsoft Bot Framework. Happy building!

Thanks for staying till the end

Build Your First Text Analytics App with Azure AI in Under 30 Minutes

Olalekan Oladiran — Sat, 05 Jul 2025 13:37:05 +0000

Introduction

Azure Language supports analysis of text, including language detection, sentiment analysis, key phrase extraction, and entity recognition.

Requirements

Microsoft Azure subscription
VS code

Provision an Azure AI Language resource

If you don’t already have one in your subscription, you’ll need to provision an Azure AI Language service resource in your Azure subscription.

Go to your Azure portal and click create a resource
Search for language service and select create under language service.
Select continue to create your resource
Provision your resource using the following settings:
- Subscription: Your Azure subscription.
- Resource group: Choose or create a resource group.
- Region:Choose any available region
- Name: Enter a unique name.
- Pricing tier: Select F0 (free), or S (standard) if F is not available.
- Responsible AI Notice: Agree.
Select Review+create
Wait for validation to complete and click create.
Wait for deployment to complete, and then go to the deployed resource.
View the Keys and Endpoint page in the Resource Management section. You will need the information on this page later in the exercise.

Clone the repository for this course

Open your VS Code and login to your Azure subscription by running the command:

az login
Follow the command to sign into your Azure account.
Enter the following commands to clone the GitHub repo for this exercise:

git clone https://github.com/microsoftlearning/mslearn-ai-language mslearn-ai-language

After the repo has been cloned, navigate to the folder containing the application code files: cd mslearn-ai-language/Labfiles/01-analyze-text

Configure your application

Run the command cd C-Sharp/text-analysis depending on your language preference. Each folder contains the language-specific files for an app into which you’re going to integrate Azure AI Language text analytics functionality.
Install the Azure AI Language Text Analytics SDK package by running the appropriate command for your language preference:

For C#: 
dotnet add package Azure.AI.TextAnalytics --version 5.3.0

Edit the appsettings.json by expanding text-analysis.
Update the configuration values to include the endpoint and a key from the Azure Language resource you created (available on the Keys and Endpoint page for your Azure AI Language resource in the Azure portal)
After you’ve replaced the placeholders, within the code editor, use the CTRL+S command or Right-click > Save to save your changes
Open Programs.cs file and at the top, under the existing namespace references, find the comment Import namespaces. Then, under this comment, add the following language-specific code to import the namespaces you will need to use the Text Analytics SDK:

 // import namespaces
 using Azure;
 using Azure.AI.TextAnalytics;

In the Main function, note that code to load the Azure AI Language service endpoint and key from the configuration file has already been provided. Then find the comment Create client using endpoint and key, and add the following code to create a client for the Text Analysis API:

 // Create client using endpoint and key
 AzureKeyCredential credentials = new AzureKeyCredential(aiSvcKey);
 Uri endpoint = new Uri(aiSvcEndpoint);
 TextAnalyticsClient aiClient = new TextAnalyticsClient(endpoint, credentials);

Save your changes, then enter the following command to run the program:

dotnet run
Observe the output as the code should run without error, displaying the contents of each review text file in the reviews folder. The application successfully creates a client for the Text Analytics API but doesn’t make use of it. We’ll fix that in the next section.

Add code to detect language

Now that you have created a client for the API, let’s use it to detect the language in which each review is written.

With Programs.cs file opened, find the comment Get language in the Main function for your program. Then, under this comment, add the code necessary to detect the language in each review document:

 // Get language
 DetectedLanguage detectedLanguage = aiClient.DetectLanguage(text);
 Console.WriteLine($"\nLanguage: {detectedLanguage.Name}");

Save your changes and re-run the program.
Observe the output, noting that this time the language for each review is identified.

Add code to evaluate sentiment

Sentiment analysis is a commonly used technique to classify text as positive or negative (or possible neutral or mixed). It’s commonly used to analyze social media posts, product reviews, and other items where the sentiment of the text may provide useful insights.

Still with Programs.cs file opened, find the comment Get sentiment. Then, under this comment, add the code necessary to detect the sentiment of each review document:

 // Get sentiment
 DocumentSentiment sentimentAnalysis = aiClient.AnalyzeSentiment(text);
 Console.WriteLine($"\nSentiment: {sentimentAnalysis.Sentiment}");

Save your changes and re-run the program.
Observe the output, noting that the sentiment of the reviews is detected.

Add code to identify key phrases

It can be useful to identify key phrases in a body of text to help determine the main topics that it discusses.

Still with Programs.cs file opened, find the comment Get key phrases. Then, under this comment, add the code necessary to detect the key phrases of each review document:

 // Get key phrases
 KeyPhraseCollection phrases = aiClient.ExtractKeyPhrases(text);
 if (phrases.Count > 0)
 {
     Console.WriteLine("\nKey Phrases:");
     foreach(string phrase in phrases)
     {
         Console.WriteLine($"\t{phrase}");
     }
 }

Save your changes and re-run the program.
Observe the output, noting that each document contains key phrases that give some insights into what the review is about.

Add code to extract entities

Often, documents or other bodies of text mention people, places, time periods, or other entities. The text Analytics API can detect multiple categories (and subcategories) of entity in your text.

Still with Programs.cs file opened, find the comment Get entities phrases. Then, under this comment, add the code necessary to identify entities that are mentioned in each review:

 // Get entities
 CategorizedEntityCollection entities = aiClient.RecognizeEntities(text);
 if (entities.Count > 0)
 {
     Console.WriteLine("\nEntities:");
     foreach(CategorizedEntity entity in entities)
     {
         Console.WriteLine($"\t{entity.Text} ({entity.Category})");
     }
 }

Save your changes and re-run the program.
Observe the output, noting the entities that have been detected in the text.

Add code to extract linked entities

In addition to categorized entities, the Text Analytics API can detect entities for which there are known links to data sources, such as Wikipedia.

Still with Programs.cs file opened, find the comment Get linked entities. Then, under this comment, add the code necessary to identify linked entities that are mentioned in each review:

 // Get linked entities
 LinkedEntityCollection linkedEntities = aiClient.RecognizeLinkedEntities(text);
 if (linkedEntities.Count > 0)
 {
     Console.WriteLine("\nLinks:");
     foreach(LinkedEntity linkedEntity in linkedEntities)
     {
         Console.WriteLine($"\t{linkedEntity.Name} ({linkedEntity.Url})");
     }
 }

Save your changes and re-run the program.
Observe the output, noting the linked entities that are identified.

Azure AI Language opens up a world of possibilities for analyzing text—whether you're assessing customer sentiment, extracting key insights, or identifying important entities. With just a few lines of code, you can integrate powerful NLP capabilities into your applications and unlock deeper understanding from unstructured data.

Now that you've seen how easy it is to get started, why not experiment further? Try analyzing your own datasets, fine-tuning results, or even combining these features with other Azure AI services to build even smarter solutions.

The future of intelligent applications starts here—happy coding!
credits: Analyze text with Azure AI Language

Thanks for staying till the end

From Local to Cloud: Building & Deploying C# Azure Functions in VS Code

Olalekan Oladiran — Sun, 08 Jun 2025 16:07:55 +0000

Introduction

Azure Functions let you run event-driven code without managing infrastructure—perfect for APIs, file processing, and automation. In this step-by-step guide, you’ll learn how to:

Develop locally in C# with VS Code
Test thoroughly using the Azure Functions Core Tools emulator
Deploy seamlessly to the cloud with built-in CI/CD
Validate execution in both local and Azure environments Whether you’re building microservices or backend APIs, this tutorial equips you with a production-ready workflow using .NET 8’s isolated process model.

Requirements

An Azure subscription. If you don't already have one, you can sign up for one.
Visual Studio Code on one of the supported platforms.
.NET 8 is the target framework.
C# Dev Kit for Visual Studio Code.
Azure Functions extension for Visual Studio Code.
Azure Functions Core Tools version 4.x. Run the following commands in a terminal to install Azure Functions Core Tools on your system. Visit Azure Function Core Tools on GitHub for installation instructions on other platforms.

Setting Up Your Local Project

Purpose: Create a foundation for your serverless function before deploying to Azure.

In Visual Studio Code, press F1 to open the command palette and search for and run the command Azure Functions: Create New Project....
Select the directory location for your project workspace and choose Select. You should either create a new folder or choose an empty folder for the project workspace. Don't choose a project folder that is already part of a workspace.
Provide the following information at the prompts: Prompt Action
- Select the folder that will contain your function projects Select Browse... to select a folder for you app.
- Select a language Select C#.
- Select a .NET runtime Select .NET 8.0 Isolated
- Select a template for your project's first function Select HTTP trigger.1
- Provide a function name Enter HttpExample.
- Provide a namespace Enter My.Function.
- Authorization level Select Anonymous, which enables anyone to call your function endpoint. Depending on your VS Code settings, you might need to use the Change template filter option to see the full list of templates.
Visual Studio Code uses the provided information and generates an Azure Functions project with an HTTP trigger. You can view the local project files in the Explorer.

Local Testing

Make sure the terminal is open in Visual Studio Code. You can open the terminal by selecting Terminal and then New Terminal in the menu bar.
Switch to Run and Debug, click on start debugging.
Output from Core Tools is displayed in the Terminal panel. Your app starts in the Terminal panel. You can see the URL endpoint of your HTTP-triggered function running locally.
With Core Tools running, go to the Azure: Functions area. Under Functions, expand Local Project > Functions. Right-click the HttpExample function and select Execute Function Now....
In Enter request body type the request message body value of { "name": "Azure" }. Press Enter to send this request message to your function. When the function executes locally and returns a response, a notification is raised in Visual Studio Code.
select the notification bell icon to view the notification. Information about the function execution is shown in Terminal panel.
Press control + C to stop Core Tools and disconnect the debugger. After verifying that the function runs correctly on your local computer, it's time to use Visual Studio Code to publish the project directly to Azure.

Deploy and execute the function in Azure

In this section you create an Azure Function App resource and deploy the function to the resource.

Sign in to Azure

Before you can publish your app, you must sign in to Azure. If you already signed in, go to the next section.

If you aren't already signed in, choose the Azure icon in the Activity bar, then in the Azure: Functions area, choose Sign in to Azure....
When prompted in the browser, choose your Azure account and sign in using your Azure account credentials.
After successfully signing in, you can close the new browser window. The subscriptions that belong to your Azure account are displayed in the Side bar.

Create resources in Azure

In this section, you create the Azure resources you need to deploy your local function app.

Choose the Azure icon in the Activity bar, then in the Resources area select the Create resource... button.
Provide the following information at the prompts:
Prompt Action
Select a resource to create Select Create Function App in Azure...

Select subscription Select the subscription to use. You won't see this if you only have one subscription.

Enter a globally unique name for the function app Type a name that is valid in a URL path, for example myfunctionappola. The name you type is validated to make sure that it's unique.

Select a location for new resources For better performance, select a region near you.

Select a runtime stack Select .NET 8.0 Isolated.

Select resource authentication type Select Secrets

The extension shows the status of individual resources as they're being created in the AZURE area of the terminal window.
When completed, the following Azure resources are created in your subscription, using names based on your function app name:
- A resource group, which is a logical container for related resources.
- A standard Azure Storage account, which maintains state and other information about your projects.
- A Flex consumption plan, which defines the underlying host for your serverless function app.
- A function app, which provides the environment for executing your function code. A function app lets you group functions as a logical unit for easier management, deployment, and sharing of resources within the same hosting plan.
- An Application Insights instance connected to the function app, which tracks usage of your serverless function.

Deploy the project to Azure

In the command palette, search for and run the command Azure Functions: Deploy to Function App....
Select the subscription you used when creating the resources.
Select the function app you created. When prompted about overwriting previous deployments, select Deploy to deploy your function code to the new function app resource.
After deployment completes, select View Output to view the details of the deployment results. If you miss the notification, select the notification bell icon in the lower right corner to see it again.

Run the function in Azure

Back in the Resources area in the side bar, expand your subscription, your new function app, and Functions. Right-click the HttpExample function and choose Execute Function Now....
In Enter request body you see the request message body value of { "name": "Azure" }. Press Enter to send this request message to your function.
When the function executes in Azure and returns a response, a notification is raised in Visual Studio Code. select the notification bell icon to view the notification.

Thanks for staying till the end

How to Use Deployment Slots in Azure App Service for Zero-Downtime Updates

Olalekan Oladiran — Fri, 06 Jun 2025 11:21:48 +0000

Introduction

Deployment slots in Azure App Service enable zero-downtime updates and risk-free testing by providing isolated staging environments that mirror your production app. In this guide, you’ll learn how to:

Create deployment slots (and upgrade your App Service plan when needed)
Deploy changes to a staging slot for validation
Swap slots seamlessly to promote tested code to production
Verify the swap while maintaining rollback capability
Perfect for CI/CD pipelines or manual deployments, this approach minimizes downtime and ensures smoother releases. Let’s dive in!

Requirements

You must have completed Getting Started with Azure App Service: Deploy a Web App in Minutes

Configure Deployment Slot

Open your Azure App services and select Deployment Slot under Deployment section.
Since deployment slot is not supported by shared service plan, it will ask you to upgrade to standard or premium.
Click upgrade, choose standard S1 and click on Select
Click Upgrade
Go back to deployment and click Add slot
Choose a name for your slot which will serve as a unique url for your slot. Click Add after
Confirm that the slot is created
Open the slot by clicking on it. Click the Default Domain of the staging slot to check if it is running.
You need to push your development code to this staging slot and see how you can swap it with the production after testing.
Head over to VS Code and make some changes to the index.html file. I added version 2.0 to distinguish it from the production slot
Next is to deploy it to slot by clicking view and select command pallete. Repeat the steps used to deploy the production slot
Search and select Deploy to slot
After deployment is succeeded, go back to the browser and click on refresh.

Swap deployment Slot

This allow seamless transition between production and staging environment

Go back to your production slot and click on swap.
Leave the settings as default and click start swap and wait for the swap to finish.
To check if the swap works, go to your production Default Domain and it should display app with version 2.0
Staging will display app without version 2.0

Thanks for staying till the end