DEV Community: Sabah Shariq

No Brainer Machine Learning model in Azure

Sabah Shariq — Mon, 31 Mar 2025 15:39:10 +0000

Introduction:

Azure ML has a process called "Designer" which creates machine learning workflows then makes it accessible to both beginners and experienced user. Azure Machine Learning Designer is a drag-and-drop interface within Microsoft's Azure Machine Learning platform that allows users to build, test and deploy machine learning models without requiring extensive coding knowledge.

Here we will train a linear regression model that predicts car prices. Following are the steps for that need to follow.

Create a workspace

Sign in to Azure Machine Learning studio
Select Create workspace
Provide the following information to configure your new workspace:
Workspace name
Friendly name
Hub
- If you did not select a hub provide the advanced information
- If you selected a hub these values are taken from the hub.
Subscription
Resource group
Region
Select Create to create the workspace

Create a new pipeline

Pipeline is a visual workflow where sequence of steps connected together to process data, train a model and produce an output. These are designed using the drag-and-drop interface.

Sign in to ml.azure.com
select the workspace you want to work with. If no workspace available then create one
Select Create a new pipeline using classic prebuilt components.
Click the pencil icon beside the automatically generated pipeline draft name, rename it to Automobile price prediction. The name doesn't need to be unique.

Import data

The designer comes with prebuilt sample dataset for user to do experiment. Here we will be using Automobile price data (Raw). Use the following steps to select the data set.

On the left hand side you will see options like datasets and components.
- Select components
- Expand sample data
Select the dataset Automobile price data (Raw) and drag it onto the canvas.

Visualize the data

It's better to visualize the data for better understanding of the dataset. To do this follow the following steps:

Right click the Automobile price data (Raw) and select Preview Data.
Select the different columns in the data window to view information about each one.

Each row represents an automobile, and the variables associated with each automobile appear as columns. There are 205 rows and 26 columns in this dataset.

Setup Data

Before doing an analysis on a data set it requires some processing. Like there might be some missing values which might create an issue for model to analyze correctly.
For our dataset we can see that the normalized-losses column is missing many values so, this need to exclude. Use the following steps:

In the datasets and component palette to the left of the canvas, click Component and search for the Select Columns in Dataset component.
Drag the Select Columns in Dataset component onto the canvas. Drop the component below the dataset component.
Connect the Automobile price data (Raw) dataset to the Select Columns in Dataset component. Drag from the dataset's output port which is the small circle at the bottom of the dataset on the canvas to the input port of Select Columns in Dataset which is the small circle at the top of the component.

Select the "Select Columns in Dataset component."
Click on the arrow icon under Settings to the right of the canvas to open the component details pane. Alternatively, you can double click the "Select Columns" in Dataset component to open the details pane.
Select Edit column to the right of the pane.
Expand the Column names drop down next to Include and select All columns.
Select the + to add a new rule.
From the drop-down menus, select Exclude and Column names.
Enter normalized-losses in the text box.
In the lower right, select Save to close the column selector.
In the Select Columns in Dataset component details pane expand Node info.
Select the Comment text box and enter Exclude normalized losses.

Comments will appear on the graph to help you organize your pipeline.

Clean missing data

After removing normalized-losses column the still might be missing value remaining. "Clean Missing Data" component can be used to remove this.

In the datasets and component palette to the left of the canvas, click Component and search for the Clean Missing Data component.
Drag the Clean Missing Data component to the pipeline canvas. Connect it to the Select Columns in Dataset component.
Select the Clean Missing Data component.
Click on the arrow icon under Settings to the right of the canvas to open the component details pane.
Select Edit column to the right of the pane.
In the Columns to be cleaned window that appears, expand the drop-down menu next to Include. Select All columns
Select Save
In the Clean Missing Data component details pane -> under Cleaning mode -> select Remove entire row.
In the Clean Missing Data component details pane -> expand Node info.
Select the Comment text box and enter Remove missing value rows.

Setup a machine learning model

As we want to predict the price we can use a regression algorithm like linear regression model.

Split the data

We will split the data into two separate datasets. One dataset trains the model and the other will test how well the model performed.

In the datasets and component palette to the left of the canvas, click Component and search for the Split Data component.
Drag the Split Data component to the pipeline canvas.
Connect the left port of the Clean Missing Data component to the Split Data component.
Select the Split Data component.
Click on the arrow icon under Settings to the right of the canvas to open the component details pane. Alternatively, you can double-click the Split Data component to open the details pane.
In the Split Data details pane set the Fraction of rows in the first output dataset to 0.7.
This option splits 70 percent of the data to train the model and 30 percent for testing it. The 70 percent dataset will be accessible through the left output port. The remaining data is available through the right output port.
In the Split Data details pane, expand Node info.
Select the Comment text box and enter Split the dataset into training set (0.7) and test set (0.3).

Train the model:

Train the model by giving it a dataset that includes the price. The algorithm constructs a model that explains the relationship between the features and the price as presented by the training data.

In the datasets and component palette to the left of the canvas click Component and search for the Linear Regression component.
Drag the Linear Regression component to the pipeline canvas.
In the datasets and component palette to the left of the canvas click Component and search for the Train Model component.
Drag the Train Model component to the pipeline canvas.
Connect the output of the Linear Regression component to the left input of the Train Model component.
Connect the training data output (left port) of the Split Data component to the right input of the Train Model component.
Select the Train Model component.
Click on the arrow icon under Settings to the right of the canvas to open the component details pane. Alternatively, you can double-click the Train Model component to open the details pane.
Select Edit column to the right of the pane.
In the Label column window that appears, expand the drop-down menu and select Column names.
In the text box enter price to specify the value that your model is going to predict.

Add the Score Model component

After training the model by using 70 percent of the data, we can use it to score the other 30 percent to see how well your model functions.

In the datasets and component palette to the left of the canvas, click Component and search for the Score Model component.
Drag the Score Model component to the pipeline canvas.
Connect the output of the Train Model component to the left input port of Score Model. Connect the test data output (right port) of the Split Data component to the right input port of Score Model.

Add the Evaluate Model component

Use the Evaluate Model component to evaluate how well your model scored the test dataset.

In the datasets and component palette to the left of the canvas, click Component and search for the Evaluate Model component.
Drag the Evaluate Model component to the pipeline canvas.
Connect the output of the Score Model component to the left input of Evaluate Model.

The final pipeline should look something like this:

Submit pipeline

Select Configure & Submit on the right top corner to submit the pipeline.
Then you'll see a step-by-step wizard follow the wizard to submit the pipeline job.
In Basics step, you can configure the experiment, job display name, job description etc.
After submitting the pipeline job, there will be a message on the top with a link to the job detail. You can select this link to review the job details.

View scored labels

In the job detail page, you can check the pipeline job status, results and logs.

After the job completes we can view the results of the pipeline job. First, look at the predictions generated by the regression model.

Right-click the Score Model component, and select Preview data -> Scored dataset to view its output.

Here we can see the predicted prices and the actual prices from the testing data.

Model Evaluation

Use the Evaluate Model to see how well the trained model performed on the test dataset.

Right-click the Evaluate Model component and select Preview data > Evaluation results to view its output.

The following statistics are shown for your model:

Mean Absolute Error (MAE): The average of absolute errors. An error is the difference between the predicted value and the actual value.
Root Mean Squared Error (RMSE): The square root of the average of squared errors of predictions made on the test dataset.
Relative Absolute Error: The average of absolute errors relative to the absolute difference between actual values and the average of all actual values.
Relative Squared Error: The average of squared errors relative to the squared difference between the actual values and the average of all actual values.
Coefficient of Determination: Also known as the R squared value, this statistical metric indicates how well a model fits the data.

For each of the error statistics, smaller is better. A smaller value indicates that the predictions are closer to the actual values. For the coefficient of determination, the closer its value is to one (1.0), the better the predictions.

Training a Machine Learning model in Azure

Sabah Shariq — Mon, 31 Mar 2025 10:17:22 +0000

Introduction

We will use a credit card dataset to understand how to use Machine Learning for a classification problem in Azure. Here our goal is to identify customers who are at risk of not paying their credit card bills. To get started with Azure Machine Learning following two prerequisites first we need to setup:

Workspace

In order to use Machine Learning in Azure we need to create a workspace. A workspace is a centralized environment where all the machine learning resource get stored.

Compute Instance

A compute instance is a cloud-based virtual machine (VM) used for developing and running ML models. Here we will run Jupyter notebooks and Python scripts and test AI algorithms.

Create a workspace

Sign in to Azure Machine Learning studio
Select Create workspace
Provide the following information to configure your new workspace:
Workspace name
Friendly name
Hub
- If you did not select a hub, provide the advanced information
- If you selected a hub, these values are taken from the hub.
Subscription
Resource group
Region
Select Create to create the workspace

Create a compute instance

Create compute instance following steps:

Select your workspace
On the top right, select New
Select Compute instance in the list
Supply a name
Keep the default values for the rest of the page, unless your organization policy requires you to change other settings
Select Review + Create
Select Create

Create handle to workspace

We need a way to reference our workspace. That is Azure Machine Learning workspace is where all your ML resources live (models, datasets, compute, etc.). In order to work in the workspace "Python code" needs to connect to it and creating an "ml_client" does this.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

#authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION="<SUBSCRIPTION_ID>"
RESOURCE_GROUP="<RESOURCE_GROUP>"
WS_NAME="<AML_WORKSPACE_NAME>"

#Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

Here, we need to import required library

Import Libraries
MLClient → Used to interact with Azure Machine Learning.
DefaultAzureCredential → Handles authentication using Azure credentials
Authenticate
This automatically retrieves credentials from the user's Azure environment.
Define Azure Subscription & Resource Details
Connect to the Azure ML Workspace
Verify Connection

ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

ml_client.workspaces.get(WS_NAME) → Fetches the workspace details from Azure.
ws.location → Prints the region where the workspace is deployed (e.g. "eastus").
ws.resource_group → Prints the resource group name.

If this prints the correct location and resource group, the connection is successful!

Enviroment Setup

To run machine learning jobs in Azure, we need to define an environment. To make sure the job runs correctly, need to tell Azure what software and libraries are required.

Create an environment in Azure ML to tell Azure what tools, packages and Python version the code needs to run correctly and reliably.

In this example, we create a custom conda environment for your jobs, using a conda yaml file. The reference this yaml file to create and register this custom environment in your workspace:

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

This registers the environment to your Azure ML workspace using ml_client.

print(
    f"Environment with name {custom_job_env.name} is registered to workspace, the environment version is {custom_job_env.version}"
)

Confirms that the environment has been successfully created or updated.

Configure a command job to run training script

Now we're setting up a command job in Azure to run a Python script that trains a credit default prediction model using GradientBoostingClassifier. This training script will do the following:

Prepares the data
Trains the model
Splits the data using train_test_split (training and testing sets)
Registers the trained model so it can be reused or deployed later

Here we will use Azure ML Studio to create and run the command job.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    #Split train and test datasets
    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))

    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################

    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Above code explanation

Set Up the Script: Uses "argparse" to get inputs (like data path, model name, and training settings).

Prepare the Data

credit_df = pd.read_csv(args.data)
train_df, test_df = train_test_split(credit_df)
Reads the CSV file.

Splits the data into training and test sets using train_test_split.

Train the Model

clf = GradientBoostingClassifier()
clf.fit(X_train, y_train)

Trains a Gradient Boosting Classifier a tree-based ML model. Then uses the model to make predictions.

Log Metrics and Results with MLflow

mlflow.sklearn.autolog()
mlflow.log_metric("num_samples", ...)

Automatically logs model metrics like accuracy, training time, etc. This helps track and compare different model runs.

Register the Trained Model

mlflow.sklearn.log_model(...)
mlflow.sklearn.save_model(...)

The model is saved and registered Azure ML Workspace. This allows to keep track of your trained models.

Configure a training job using "Command"

Now we need to configure a training job in Azure Machine Learning using the command function which will run the main.py training script in Azure with the right data, parameters and environment.

Create a variable called "inputs" that will use for:

data: The CSV file with credit card data.
test_train_ratio: How much of the data should be used for testing (20%).
learning_rate: A parameter for the model training.
registered_model_name: The name to register your trained model under.

Submit the job

Submit the job to run in Azure Machine Learning studio. This time will use create_or_update on ml_client. ml_client is a client class that allows you to connect to your Azure subscription using Python and interact with Azure Machine Learning services. "ml_client" allows to submit the jobs using Python.

ml_client.create_or_update(job)

Conclusion

After run the cell, the notebook output shows a link to the job's details page on Machine Learning studio. Following the link will show you result statics.

Artificial Intelligence: A Breakdown of Must-Know Buzzwords

Sabah Shariq — Mon, 17 Mar 2025 20:46:10 +0000

Introduction

In the field of artificial intelligence now a days we are hearing various buzzwords. In this blog post we will familiar ourselves with AI subfields and how utilizing their set of techniques and theories solve particular types of problems.

Here we will familiarize ourselves with Machine Learning (ML), Deep Learning, Neural Network (NN), Natural Language Processing (NLP), Computer Vision (CV), AI Agent/ Agentic, RAG AI AI, CAG AI and Multi Model.

Artificial Intelligence

AI is making computers think and act like humans. Basically, it's about designing algorithms and systems so that machines can learn from data, adapt to new inputs and execute functions that mimic human cognitive abilities like language understanding, image interpretation and logical reasoning. In the other word AI learns from examples to help humans solve problems.

          .----------------.
          |   [  AI  ]     |
          |  Neural Net    |
          |  Connections   |
           '------||------'
                  ||
        .---------||---------.
        |        ||         |
        |  Data  ||  Learning|
        | Stream ||   Flow   |
        '---------||---------'
                  ||
           .------||------.
          |   Adaptive   |
          |    Systems   |
           '------------'

Following is some of the classic subfields.

Machine Learning

Focuses on algorithms that allow computers to learn patterns from data to make predictions or decisions. It has many branches such as supervised learning, unsupervised learning and reinforcement learning.

        .---------||---------.
        |        ||         |
        |  Data  || Features |
        | Input  || Extraction |
        '---------||---------'
                  ||
           .------||------.
          |  Model Selection |
          |  & Evaluation    |
           '------||------'
                  ||      
           .------------------.
          |[ Machine Learning ]|
          |  Model Training    |
          |  & Optimization    |
           '------||------'
                  ||        
           .------||------.
          |   Predictions   |
          |  & Deployment   |
           '------------'

Deep Learning

Deep Learning focuses on training neural networks with multiple layers to learn patterns and make decisions without human intervention. The "deep" in deep learning refers to the multiple layers in these neural networks.


        Input Layer
    .----------------.
    | Feature Input  |
    '----------------'
            ||
  .------------------.
  | Hidden Layer 1   |   <-- Extracts basic patterns
  '------------------'
            ||
  .------------------.
  | Hidden Layer 2   |   <-- Learns deeper features
  '------------------'
            ||
  .------------------.
  | Hidden Layer 3   |   <-- Identifies complex relationships
  '------------------'
            ||
  .------------------.
  | Output Layer     |   <-- Makes final decision/prediction
  '------------------'

Deep Learning: Multiple hidden layers allow the network to learn complex patterns

Neural Network

Neural Network is a computational system inspired by the structure and function of the human brain also the foundation of Deep Learning. It consists of interconnected neurons/nodes that process and learn from data.

        Input Layer
    .----------------.
    | Feature Input  |
    '----------------'
            ||
  .------------------.
  | Hidden Layer 1   |   <-- Extracts basic patterns
  '------------------'
            ||
  .------------------.
  | Hidden Layer 2   |   <-- Learns deeper features
  '------------------'
            ||
  .------------------.
  | Output Layer     |   <-- Makes final decision/prediction
  '------------------'

Neural Networks are the core of Deep Learning allowing AI to learn from data and improve over time.

Natural Language Processing (NLP)

Focuses on enabling communication between humans and machines. NLP combines linguistics and machine learning to help AI process human language in a way that is meaningful and useful.

        User Input
    .----------------.
    | "Hello, AI!"   |
    '----------------'
            ||
  .------------------.
  |  Tokenization    |   <-- Splitting text
  '------------------'
            ||
  .------------------.
  |  POS Tagging     |   <-- Identifying grammar
  '------------------'
            ||
  .------------------.
  |  Sentiment Analysis |   <-- Understanding emotion
  '------------------'
            ||
  .------------------.
  |  AI Response      |   <-- Generating reply
  '------------------'

Computer Vision (CV)

Enables computers to "see" and interpret visual information from the world, much like humans do i.e. helps machines interpret the world visually.

        Image Input
    .----------------.
    |  Captured Image |
    '----------------'
            ||
  .------------------.
  |  Preprocessing   |   <-- Noise reduction, resizing
  '------------------'
            ||
  .------------------.
  |  Feature Extraction  |   <-- Identifying edges, textures
  '------------------'
            ||
  .------------------.
  |  Object Detection  |   <-- Locating objects in image
  '------------------'
            ||
  .------------------.
  |  Classification  |   <-- Labeling objects
  '------------------'
            ||
  .------------------.
  |  AI Decision Making  |   <-- AI response (e.g., stop sign detected)
  '------------------'

AI Agent/ Agentic AI

An AI agent is a computer program that can sense its surroundings, think and take actions to achieve specific goals. Similar to human making choices based on what they see and hear.

      User or Environment
    .--------------------.
    |   Input Data       |  <-- AI gets information (text, images, sound)
    '--------------------'
              ||
    .--------------------.
    |   AI Thinking      |  <-- AI processes & decides what to do
    '--------------------'
              ||
    .--------------------.
    |   AI Takes Action  |  <-- AI responds or does a task
    '--------------------'
              ||
    .--------------------.
    |   AI Learns        |  <-- AI improves over time
    '--------------------'

On the other hand, Agentic AI is a type of artificial intelligence that is designed to act as an agent i.e. performing tasks or making decisions to solve problems and achieve goals.


      User Gives a Goal
    .----------------------.
    |   "Plan my trip"     |  <-- AI gets the goal
    '----------------------'
              ||
    .----------------------.
    |   AI Plans Steps     |  <-- AI figures out what needs to be done
    '----------------------'
              ||
    .----------------------.
    |   AI Takes Action    |  <-- AI books tickets, suggests hotels
    '----------------------'
              ||
    .----------------------.
    | AI Learns & Improves |  <-- AI remembers and refines future plans
    '----------------------'

RAG AI

It is an AI technique where instead of relying on what it was trained on, it searches for new relevant facts from external knowledge sources (e.g. databases, documents, or the web) and then generates a more accurate answer.

      User Asks a Question
    .----------------------.
    |  "Latest AI trends?" |  <-- User Input
    '----------------------'
              ||
    .----------------------.
    | AI Searches Sources  |  <-- Retrieves updated info
    '----------------------'
              ||
    .----------------------.
    | AI Generates Answer  |  <-- Uses retrieved data
    '----------------------'
              ||
    .----------------------.
    | AI Gives Response    |  <-- Provides accurate answer
    '----------------------'

CAG AI

Unlike RAG AI which is performing real-time retrieval of documents instead CAG preloads all relevant knowledge into the model's context. This preloaded data is stored in a key-value (KV) cache, allowing the AI to generate responses instantly without the latency or potential errors introduced by retrieval processes.

+-----------------+
|  Start          |
+-----------------+
         |
         v
+-----------------+
|  Define Dataset |  (e.g., HR policies, manuals)
+-----------------+
         |
         v
+-----------------+
|  Process Data   |  (Encode/compress data into cache)
+-----------------+
         |
         v
+-----------------+
|  Preload Cache  |  (Store in model’s context/memory)
+-----------------+
         |
         v
+-----------------+
|  User Asks      |  (e.g., “What’s the vacation policy?”)
|  Question       |
+-----------------+
         |
         v
+-----------------+
|  Generate       |  (Use preloaded cache, no retrieval)
|  Response       |
+-----------------+
         |
         v
+-----------------+
|  End            |
+-----------------+

Multi-Modal AI

Multimodal AI refers to artificial intelligence systems that can process, understand, and generate outputs using multiple types of data—called "modalities"—such as text, images, audio, video, or even numerical data. Here,

"Multi" means multiple (more than one).
"Modal" refers to modes of data (text, images, audio, video).
So, Multi-Modal AI can process and combine different types of information.

      User Provides Input
    .----------------------.
    |  Text + Image + Audio |  <-- Different data types
    '----------------------'
              ||
    .----------------------.
    |  AI Processes Data    |  <-- Combines all input types
    '----------------------'
              ||
    .----------------------.
    |  AI Links Information |  <-- Connects text, image, or sound
    '----------------------'
              ||
    .----------------------.
    |  AI Generates Response|  <-- Intelligent answer using all inputs
    '----------------------'

Microsoft Azure provides various AI solution which can be use to build various intelligent applications. Some of Azure AI solutions are:

Azure AI Services
Azure Cognitive Services
Azure Machine Learning
Azure OpenAI Service
AI-Powered Analytics with Azure Synapse
AI Ethics and Responsible AI on Azure

Conclusion

AI holds immense potential to drive innovation and solve complex problems, but its success will depend on our ability to navigate its ethical implications and integrate it responsibly into society. And we can start with Microsoft Azure to get start.

Generative AI: Novice Guide to Transformers

Sabah Shariq — Fri, 29 Mar 2024 20:55:02 +0000

Introduction

Transformer model brings a revolutionary change in Natural Language Processing by overcoming the limitations of Recurrent Neural Network (RNN) and Convolutional Neural Network (CNN). It was first introduced in 2017 on a paper titled "Attention Is All You Need" by Vaswani et al. It is a type of neural network capable of understanding the context of sequential data, such as sentences, by analyzing the relationships between the words.

Transformers Structure

The transformer architecture consists of two main parts: an encoder and a decoder. The encoder takes a sequence of input tokens and produces a sequence of hidden states. The decoder then takes these hidden states and produces a sequence of output tokens. The encoder and decoder are both made up of a stack of self-attention layers.

Self-Attention

Let us start with revisiting what attention is in the NLP universe?

Attention allowed us to focus on parts of our input sequence while we predicted our output sequence. In simpler terms, self-attention helps us create similar connections but within the same sentence. Look at the following example:

“I poured water from the bottle into the cup until it was full.” it => cup
“I poured water from the bottle into the cup until it was empty.” it=> bottle

By changing one word “full” to “empty” the reference object for “it” changed. If we are translating such a sentence, we will want to know what the word “it” refers to.

Transformers Model:

In transformers "token" and "vector" are fundamental concepts of how data is represented and processed within the model.

Token

In natural language processing, a token refers to a unit of text that has been segmented for processing. For example:

At the word level: Each word in a sentence is treated as a separate token.
At the subword level: Words are broken down into smaller subword units, such as prefixes, suffixes, or stems. This approach is particularly useful for handling morphologically rich languages or dealing with out-of-vocabulary words.
At the character level: Each character in a word is treated as a separate token.

Tokens serve as the basic building blocks of input sequences in transformers. Before processing input data, it is tokenized into these units to represent the textual information in a format suitable for the model.

Vector

A vector refers to a mathematical representation of a token in a high-dimensional space. Each token is associated with a vector which captures its semantic and syntactic properties learned from the training data.

During the training process, the model learns to map tokens to vectors in such a way that tokens with similar meanings or contexts are represented by similar vectors, facilitating the model's ability to understand and process language effectively.

These token embeddings are the input to the transformer model. The model processes these embeddings through multiple layers of attention mechanisms and feedforward neural networks to generate contextualized representations of the tokens, capturing the relationships between them within the input sequence.

How Transformres works:

Word embeddings

Word embeddings in transformers are a way to represent words in a numerical form that a machine learning model can understand. Think of it like translating words into a language that computers speak.

Position embeddings

Position embeddings in transformers are a crucial component that helps the model understand the sequential order of tokens within an input sequence. In natural language processing tasks, such as text generation or language translation, the order of words or tokens in a sentence carries important semantic and syntactic information.

Encoder

The encoder is like a smart detective that reads and understands the input sequence. Its job is to take in a sequence of tokens (words or subwords) and convert each token into a rich representation called a context vector. The encoder does this by processing the tokens through multiple layers of attention mechanisms and feedforward neural networks. These context vectors capture the meaning and context of each token in the input sequence.

Decoder

The decoder is like a creative storyteller that uses the context vectors provided by the encoder to generate an output sequence. It takes the context vectors and produces tokens one by one, using them to guide its generation process. At each step, the decoder pays attention to the context vectors produced by the encoder to ensure that the generated tokens are relevant and coherent with the input sequence. This allows the decoder to generate meaningful output sequences based on the understanding provided by the encoder.

Attention

Attention helps the model to understand the context of a word by considering words that go before and after it.

Training

Transformer models are trained using supervised learning, where they learn to minimize a loss function that quantifies the difference between the model's predictions and the ground truth for the given task.

Where are transformers used?

Earlier we looked that transformers are used for natural language processing tasks. However now it is using in the fields like computer vision and speech recognition. Some examples are:

Computer vision
Speech recognition
Question answering
Text classification

Conclusion:

The Transformers architecture is poised to significantly advance the capabilities and applications of Generative AI, pushing the boundaries of what machines can create and how they assist in the creative process.

A Novice Guide to Azure AI Search

Sabah Shariq — Thu, 28 Mar 2024 22:30:47 +0000

Introduction

Azure AI Search provides an information retrieval service on a large amount of searchable data. For example document search, data exploration etc. You can use this service to enable powerful search capabilities within applications and solutions. Like Personalization, Insight Discovery, E-commerce Search, Healthcare Information Retrieval etc.

In Azure AI Search two term you need to know

Indexing
Querying

Indexing:

The purpose of this process is to loads the dataset into Azure AI Search that you created and make it searchable. The data format of an Index is in JSON. So, you need to format your data into JSON format or use and indexer to retrieve and serialize your data into JSON. Index is like a table which contains fields and their data. And each row in Index contains a new sets of records which is called document.

Querying:

You use query to search data based on a search criteria. Like retrieving a searchable content and associated document with the search terms.

Azure AI Search provides you the capability of full text search, keyword search. Also, you can use both to get most relevant results. Let's create our first search index and test some query to gain knowledge how Azure AI Search works.

Create a search index:

In order to create a search, we to follow these steps. We will be using free tier for creating a service and data source connection to sample data hosted by Microsoft on Azure Cosmos DB.

Step 01

Go to Azure AI Search and create a resource and name it for example: FirstAISearch
Create a search service and name it for example: firstaisearchservice. Please not that service name should be all lowercase.

Once service created successfully you will see the following successful message.

Step 02

Now go to overview menu from left hand side and select "Usage" tab to get the status of the service like indexes, indexers, and data sources you already have. Since we are using "free tier" it is limited to three indexes, three data sources, and three indexers.

Step 03

On the "Overview" page in the top menu there is option call "Import Data"

On Connect to your data, select the data source "Samples" from dropdown list.
In the list of built-in samples, select hotels-sample.
Select Next: Add cognitive skills (Optional) to continue.
For now, select Skip to: Customize target index to continue.

Step 04

Search service refers to a schema for the built-in hotels-sample index. Follow these steps to configure the index:

Keep as it is the Index name "hotels-sample-index" and Key field "HotelId".
Keep values for all field attributes as it is.
Select Next: Create an indexer to continue.

For creating the index it requires an Index name and a collection of Fields. One field must be marked as the document key to uniquely identify each document and the value is always a string.

Each field has a name, data type, and attributes that control how to use the field in the search index. Checkboxes enable or disable the following attributes:

Retrievable: Fields returned in a query response.
Filterable: Fields that accept a filter expression.
Sortable: Fields that accept an orderby expression.
Facetable: Fields used in a faceted navigation structure.
Searchable: Fields used in full text search. Strings are searchable. Numeric fields and Boolean fields are often marked as not searchable.

Step 05

Now we will configure the executable process and indexer name. Since we are getting started keep the default settings and select "Submit"

Step 06

Go to "Indexers" from the left hand side menu and you will see that index cration status with document count in it.

Step 07:

Go to "Indexes" from the left hand side menu and you will see that index document count and storage size.

Querying with Search explorer

Step 01:

On the Search explorer tab, enter text to search on example: new york hotel near to Time's Square and in Chelsea neighborhood. And select "Search". You will see the result.

Query output in JSON be like below. You will see that output contains search terms in it.

{
  "@odata.context": "https://firstaisearchservice.search.windows.net/indexes('hotels-sample-index')/$metadata#docs(*)",
  "value": [
    {
      "@search.score": 39.42806,
      "HotelId": "15",
      "HotelName": "Peaceful Market Hotel & Spa",
      "Description": "Book now and Save up to 30%.  Central location. Steps from Empire State Building & Times Square, in Chelsea neighborhood. Brand new rooms. Impeccable service.",
      "Description_fr": "Réservez dès maintenant et économisez jusqu'à 30%.  Emplacement central. A quelques pas de l'Empire State Building & Times Square, dans le quartier de Chelsea. Chambres flambant neuves. Service impeccable.",
      "Category": "Resort and Spa",
      "Tags": [
        "continental breakfast",
        "restaurant",
        "view"
      ]
}

Clean up resources

It's a good idea at the end of a project to identify whether you still need the resources you created. Resources left running can cost you money. You can delete resources individually or delete the resource group to delete the entire set of resources.

Conclusion

Overall, the purpose of using Azure AI Search is to deliver intelligent, relevant, and efficient search experiences that drive user engagement, unlock insights, and add value to applications and solutions across various industries and domains.

Sample Dataset

Azure AI Search Sample Data

A Novice Guide to Large Language Model (LLM)

Sabah Shariq — Mon, 25 Mar 2024 20:54:49 +0000

What is Large Language Model?

A large language model is an artificial intelligence (AI) model that is trained to understand and generate human language text. For example, as a human if we want to express something we use sentence to express it. This sentence is a collection of words that putted together one after another. But for a computer it is just a string of characters arranged in a particular order.

In LLM the term “Large” here refers to the number of parameters that were used to train the model. Based on the data it is fed and trained on it posesses the capability to provide answers and solutions to any questions and problems. The larger the model, the more data it can process and the more complex patterns it can learn. This Large Language Model is built on Transformer architecture.

Example:

An AI system using large language models can learn from a database of short stories and then use that knowledge to generate new short stories like "Once upon a time".

Pre-trained Transformers:

This means that the model’s wealth of knowledge is limited to the vast amount of data it has been trained with. If some data was not fed to the model, then it is not known to the model and therefore it cannot generate content around it or answer the question.

Transformers:

Transformers are a type of neural network capable of understanding the context of sequential data, such as sentences, by analyzing the relationships between the words.

The Transformer in NLP is a novel architecture (ANN) that aims to solve sequence-to-sequence tasks while handling long-range dependencies with ease. It relies entirely on "self-attention" to compute representations of its input and output WITHOUT using sequence-aligned RNNs or convolution.

Self-Attention:

Let us start with revisiting what attention is in the NLP universe?

“I poured water from the bottle into the cup until it was full.” it => cup
“I poured water from the bottle into the cup until it was empty.” it=> bottle

By changing one word “full” to “empty” the reference object for “it” changed. If we are translating such a sentence, we will want to know what the word “it” refers to.

Using the above that we discussed LLM provide answers and solutions to any questions and problems. How? by using "Prompts"?

Prompts

Prompts are a set instructions that is given to the LLM by human in order to obtain a solution, to guide its behavior or to generate desired outputs.

Conclusion

Large language models are deep learning models that can be used to generating creative content to aiding in language translation, summarization, and much more, LLMs showcase the incredible potential of machine learning and deep neural networks.

Image Reference:

Transformers

A Novice Guide to Generative AI

Sabah Shariq — Sun, 03 Sep 2023 13:19:49 +0000

What is Generative AI?

Generative AI is a subfield of artificial intelligence (AI) that involves creating algorithms that can generate new contents like:

An email response
A short story
A simple image

Example:

Google search has auto completion feature. Think of it as a very basic implementation of Generative AI where query suggestions were generated by the model based on the terms you type on the search bar. This model was trained against the zillions of queries searched by users across the world and generated suggestions or queries.

Generative AI in details:

Generative AI is supported by GPT or Generative Pre-trained Transformers takes this “generate” capability further by several levels. GPT are a family of "large-language models" trained using "artificial neural networks" using "transformer architecture" on "massive un-labelled text data" to generate human-like text responses.

Now that we have a very basic understanding of the different jargons let us dig a bit deeper.

Large Language Model:

What are Large Language Models and how are they defined?
How large is a Large Language Model?

The term “Large” here refers to the number of parameters that were used to train the model. Here’s a summary of the versions of GPT models released so far along with the parameter count.

Pre-trained Transformers:

Transformers:

Transformers are a type of neural network capable of understanding the context of sequential data, such as sentences, by analyzing the relationships between the words.

Self-Attention:

Let us start with revisiting what attention is in the NLP universe?

“I poured water from the bottle into the cup until it was full.” it => cup
“I poured water from the bottle into the cup until it was empty.” it=> bottle

By changing one word “full” to “empty” the reference object for “it” changed. If we are translating such a sentence, we will want to know what the word “it” refers to.

How does generative AI work?

The most common way to train a generative AI model is to use supervised learning - here the model is given a set of human-created content and corresponding labels. It then learns to generate content that is similar to the human-created content and labeled with the same labels.

Applications of Generative AI?

Language: Marketing Content, Code Development, Essay Writing
Visual: Image/Video Generation, Design, 3D Modelling
Music: Music/Voice Generation

Traditional AI vs. Generative AI:

Traditional AI is focused on detecting patterns, generating insights, automation, and prediction.
Generative AI starts with a prompt that lets a user submit a question along with any relevant data to guide content generation.
Traditional AI algorithms process data and return expected results, such as analyses or predictions
Generative AI algorithms produce newly synthesized content, like text or images, based on training from existing data

Model Setup:

A reason that Generative AI became so popular so quickly, is because it empowers the end user. Right now, anyone can log on to ChatGPT and start using it, which is a first for an AI application. Zero barrier to entry.
whereas Traditional AI necessitates rigorous data preparation and processes to develop and test a model designed to produce a good outcome.

So, with generative AI, you can just start talking to it, and it will understand what you want to do and offer a response.

Example:

ChatGPT, DALL-E, and Bard are examples of generative AI applications that produce text or images based on user-given prompts or dialogue.

Applications by Industry:

Automotive Industry: Synthetic data produced by AI can run simulations and train autonomous vehicles.
Media and Entertainment: AI can be used to quickly, easily, and more cheaply generate content, or (as a tool) to enhance the work of creatives like writers and designers.

Image Reference:

Visual Studio: .pdb File

Sabah Shariq — Sun, 12 Mar 2023 17:48:12 +0000

A file with the .pdb file extension is a program database file that's used to hold debugging information about a program, like a (dll or .exe) file. These are also called symbol files.

When we compile our code in Visual Studio, it creates a .pdb file alongside the executable file, which contains information about the location of each function and variable in the source code, as well as information about the compiled code, such as instructions and memory layout.

During debugging, the debugger uses the .pdb file to map the compiled code to the original source code, enabling us to step through code, set breakpoints, inspect variables, and view call stacks. Without a .pdb file, the debugger cannot provide detailed information about our code during debugging.

Remember, .pdb files are as important as source code. Because a build we do on our development machine is a private build. A build done on a build machine is a public build. And without the correct PDB files debugging is nearly impossible as debugger will not find the information to look for.

For more information: Specify symbol (.pdb) and source files in the Visual Studio debugger (C#, C++, Visual Basic, F#)

Visual Studio: Build, Rebuild, Clean and Batch Build

Sabah Shariq — Sun, 12 Mar 2023 16:45:55 +0000

Introduction

In this blog post we will look into the build configuration of our project or solution in Visual Studio application.

Build Configuration

The build solution will always perform an incremental build i.e. it will only build those files (dll and .exe) which have changed.

When we develop our .NET application in Visual Studio we see following build configuration:

Debug
Release Now, if we look into more details...

Debug

Debug mode allows developer to break the execution of program and step through the code. Compiled code dll in debug is not optimized. Therefore, size of dll file in debug mode is comparatively larger than release mode. Some additional instructions are added to enable the developer to set a breakpoint on every source code line like "symbolic information". For example, adding following code block will only execute in debug and in release mode this code block will get ignored.

#if DEBUG  
Console.WriteLine("Hello! This is Debug Mode");  
#endif

Release

This mode is for final deployment of the source code on production server. Release mode dll file contains optimized code, and it is generated for end user. Debugging symbol information is also gets omitted from the dll file in this mode.

Rebuild Solution

Rebuild solution will delete all the files (dll and .exe) or "bin and obj" and perform build from scratch irrespective of whether the files are modified or not. Please note that "Rebuild" will clean then build each project, one at a time, rather than cleaning all and then building all projects.

Clean Solution

The clean solution will delete all the compiled files (dll and .exe) from "bin and obj" directories. You may notice that not all of the files are actually removed from the project folder. This might happen because clean only removes files that are associated with a build and not everything else.

Build vs. Rebuild vs. Clean

The difference lies in what happens in each build configuration
for every projects.

For example, if the solution has two projects: Project A & Project B and you perform rebuild operation, it will take Project A, clean the compiled files for Project A, and build it. After that, it will take Project B, clean the files for Project B, and build it.

On the other hand, if you do a clean and then build separately, it will first clean all compiled files (dlls and .exe) for both the projects – Project A & Project B and then it will build Project A first then Project B.

Batch Build

When we build our project our project in visual studio we can only build it into one configuration mode at a time like Debug or Release etc. So, if we want to build our project into multiple configuration i.e. Debug and Release or build the project for multiple platforms, such as x86 and x64, all at once at the same time then we can do that with Batch Build operation. Batch build allows you to build multiple configurations with a single command instead of building them individually.

To perform a batch build, you can go to the "Build" menu, select "Batch Build," and then select the configurations and platforms that you want to build.

Concluiton

In summary, it is important to keep in mind that what happens in each build configuration in Visual Studio and based on our requirement we can select how our project or solution can be build.

ASP.NET Core Identity: Registration, Login and Logout

Sabah Shariq — Sat, 08 Oct 2022 20:42:42 +0000

Introduction

In this blog post we will look into how to implement ASP.NET Core Identity in a web app for adding authentication and authorization feature. Users can create an account and login with a username and password. This article is especially focusing on newcomers and anyone new wants to learn or thinking of using Identity in their .NET program. This is a series of blog post so please look into other for more information.

What is ASP.NET Core Identity?

When we build an application one of the key factors is that "how to handle the user management?", that means manages users, login, logout, passwords, profile data, roles, claims, tokens, email confirmation and more. So, to help ease these user management process we can use ASP.NET Core Identity a membership system.

Development Setup

For this example, we will be creating a ASP.NET Core MVC Web App using Visual Studio 2022 and .NET 6.0

Step 01: When creating an ASP.NET Core Web App (MVC) we will not select the Authentication type and set it as "None" as we will be looking from scratch how to set up the Identity feature in the application. For simplicity we will uncheck the "Configure for HTTPS" and "Enable Docker"

After creating we will have a basing MVC web application without any authentication feature.

And running the project will show the following webpage:

Step 02: Now we will add Identity feature by Scaffolding. So, right click on the project and go to "ADD" and select "New Scaffolded Item". In the following window select "Identity" and press "Add". In order to scaffolded to run a nuget package "Microsoft.VisualStudio.Web.CodeGeneration.Design" need to install. This will get automatically install when adding scaffolded item.

From the following select the Identity features that we would like to add in our web app. For this example, we will be selecting "Login", "Logout", "Register". We also need to specify the following:

Layout page: a layout page for the identity files so, we will be selecting our existing shared "_Layout.cshtml" page that got created by default with the project.
Data Context Class: By selecting + button it will generate the context class name and we will rename it to "AspNetCoreIdentityDbContext"
User class: By selecting + button we are setting the user model class name to "AspNetCoreIdentityUser"

Click on "Add" now our identity scaffolded. And we have the following structure changes in the project

Here we have "AspNetCoreIdentityDbContext" for our database. By which we will access our SQL Server. Then we have "AspNetCoreIdentityUser" which inherits from "IdentityUser" which implements the code for Login, Logout, Register and more. Now run the app and we need to add "Register" "Login"

To add this go to the header section in "_Layout.cshtml" under "Views" -> "Shared" and made the following changes.

But wait clicking "Register" and "Login" link does not work. This is because Identity is implemented in ASP.Net Core MVC is with "Razor" pages. So, we have an MVC application which needs Ragpr page supports and for this we have to inject our program with razor page support by adding "app.MapRazorPages();" in the Program.cs

Now clicking Register and Login button redirects to the respective pages.

Step 03: By default in Register page Identity adds only Email, Password and confirm passowrd fields. But we will add "First Name" and "Last Name" field. To do this we first need to a "First Name" and "Last Name" property in the "AspNetCoreIdentityUser" model class.

Once we have the entity properties set we can create our database. For this go to appsettings.json for our connection string. Here we have a default connection added by scafollded. Here we have our server "mssqllocaldb" which is a local db and database "AspNetCoreIdentity".

![connection string(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7exjayqgmnwrlbtzip6v.png)

Step 04: Let's create the database. First we will add a migration then we will import the migration and update the database. This is a EF Core concept.

Add-Migration InitialCreate
Update-Database

After adding the migration we will see the following "Migration" folder added with the file structure.

And in the "InitialCreate" file we can see the our "First Name" and "Last Name" added to the "AspNetUsers" table.

Step 05: Now our database is ready. We will now work on our Register page and two new field "First Name" and "Last Name". First we need to change our input model and add definition for "First Name" and "Last Name". As Register is a razor page we will go to the backend code and make the following changes.

Now goto the HTML page and add these two fields.

Let's build the application goto Register page and we now see the new fields.

Step 06: Before creating a new user we need to modify our backend as we need to configure our firstname and lastname. Goto "OnPostAsync" in Register.csghtml.cs page and add the following code.

Now create a new user:

Our user is successfully registered and this is temporary confirmation page. Click confirm account. Later we will disable this email confirmation option.

Now goto Login page and put our user credential and click Login and we successfully login to our user.

Step 07: Now we will look into how to disable Email confirmation. First logout from your application and goto Program.cs. Here we will see that in AddDefaultIdentity section we will set RequireConfirmedAccount to false.

Now build the application and goto Register page and create another new user.

After registering we directly redirect to main page.

And our data looks like below in our database:

Step 08: Now lets look into our identity features. Click on username which will take you to the manage profile page. Here you will see vairous option to manage our credentials like Profile, Email, Password, Two-factor authentication, personal data

Fix Anonymous Authentication:

As we can see user can login successfully but our identity is still anonymous as we can see from the following watcher windows for user identity value from base class.

For this we need to create a cookie and server will look into this cookie to authenticate. Goto Login.cshtml.cs page and add the following Claim, Identity and Claims principle in "OnPosyAsync". Then use HttpContext.SignInAsync() which will serialize the claims principles into string and encrypt that string and save that as a cookie into httpcontext object.

Now when you try to login you will get the following exception page.

To fix this goto to Program.cs

Now run the app again and login you now can see that you are not anymore logged in as anonymous

Concluiton:

Here we implemented user verification process. Then we injected the cookie authentication handlers so user do not logged in as anonymous. ASP.NET Core provides many tools and libraries to secure ASP.NET Core apps such as built-in identity providers and third-party identity services such as Facebook, Twitter, and LinkedIn.

A Quick Glimpse Into: Nuget Package Manager

Sabah Shariq — Wed, 01 Jun 2022 06:40:29 +0000

NuGet packages contain reusable code that other developers make available to us for use in our .NET projects. Often such code is bundled into packages that contain compiled code (as DLLs) along with other content needed in the projects that consume these packages.

Because of these features it cut down production costs, and means developers don’t have to reinvent the wheel when encountering a problem that’s been solved once before.

In simple word, a NuGet package is a single ZIP file with the .nupkg extension that contains compiled code (DLLs), other files related to that code, and includes information like the package's version number.

Because NuGet supports private hosts alongside the public nuget.org host, you can use NuGet packages to share code that's exclusive to an organization or a work group. You can also use NuGet packages as a convenient way to factor your own code for use in nothing but your own projects.

Also, if some (DLLs) are missing in windows that require you project to run you can also package in NuGet packages and deploy with your projects.

Visual Studio 2022 is 64-bit. What does it mean?

Sabah Shariq — Tue, 31 May 2022 20:21:52 +0000

Overview:

Before we look into what Visual Studio 2022 now 64-bit application first lets look into what does 32-bit or 64-bit means?

When we consider the various Windows versions, we might first think of the Home or Pro editions. While these are indeed different, there's another factor that separates Windows versions which is whether is system 32-bit or 64-bit?

Information in computers is normally represented in bits, a binary sequence of 1 and 0. The more bits you have, the more information you can represent. Specifically, a sequence of n bits can represent 2^n different pieces of information.

Why bits matter?

In computing, there are two types of processors existing, i.e., 32-bit and 64-bit processors. Where the CPU register stores memory addresses, which is how the processor accesses data from RAM. One bit in the register can reference an individual byte in memory. So, this 32-bit and 64-bit processors tell us how much memory a processor can access from a CPU register. For instance,

A 32-bit system can address a maximum of 4GB (2^32 possible addresses, or 4,294,967,296 bytes) of RAM
A 64-bit system can theoretically reference 16 exabytes (2^64 possible addresses or 18,446,744,073,709,551,616 bytes, about 18 billion gigabytes) of RAM.

This is several million times more than an average workstation would need to access. Meaning that a computer can calculate more, faster. And with 64-bit computer, a processor can hold 16 exabytes of memory addresses. (An exabyte is 1,000 petabytes, a petabyte is 1,000 terabytes, and a terabyte is 1,000 gigabytes.)

Advantages of 64-bit over 32-bit:

Using 64-bit user can do a lot in multi-tasking
Easily switch between various applications without any windows hanging problems.
Allows you to access virtual memory per process.

Visual Studio 2022 is 64-bit application:

Visual Studio 2022 is 64-bit application i.e. it is no longer limited to 4GB of memory in the main devenv.exe process. With a 64-bit Visual Studio on Windows, one can open, edit, run, and debug even the biggest and most complex solutions without running out of memory.

Earlier what happen is that even though you downloaded the 64-bit version of Visual Studio and able to create 64-bit application on computer but Visual Studio it self remains 32-bit application. Now, long into the 64-bit computing era, that has finally changed. Till Visual Studio 2019 the application is 32-bit however few of internal components such as diagnostics/debuggers, MSBuild, compilers, designers will take advantage of 64-bit processors if available.

So at the end the main core devenv.exe process is now a 64-bit. It will have much more advantages of using more CPU registers, and taking advantage of more than 4GB of memory.

How to check how if your application running on 64bit or 32 bit?

The devenv.exe file installation location for Visual Studio 2019 Enterprise vs. Visual Studio 2022 Enterprise preview clearly highlights this:

C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\Common7\IDE
C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\IDE

Another way to check is via “Task Manager”. In windows 11 Open the “Task Manager” . Move to the “Details” tab. In architecture column you can find on which architecture the process is running. There you should see the 64bit / 32bit as platform for the devenv.exe