Concept of: AI algorithms


Artificial Intelligence

AI stands for Artificial Intelligence. It refers to the development of computer systems that can perform tasks that typically require human intelligence. These tasks include learning, reasoning, problem-solving, perception, speech recognition, and language understanding.

There are two main types of AI:

Narrow or Weak AI: This type of AI is designed and trained for a specific task. It excels at that particular task but lacks the general cognitive abilities of a human. Examples include voice assistants, image recognition software, and chatbots.

General or Strong AI: This is a more advanced form of AI that possesses the ability to understand, learn, and apply knowledge across a broad range of tasks, similar to a human. Also, strong AI has the potential for self-awareness and consciousness.

AI technologies can be categorized into various subfields, including machine learning, natural language processing, computer vision, and robotics. Machine learning, in particular, is a key aspect of AI, where algorithms are designed to learn from data and make predictions or decisions without explicit programming.

Note: AI is used in a wide range of applications, including healthcare, finance, education, transportation, and many more, offering the potential to automate tasks, improve efficiency, and contribute to advancements in various fields.

How do Artificial intelligence (AI) algorithms work?

Artificial Intelligence (AI) algorithms work by using mathematical models and computational power to process data, learn patterns, and make decisions or predictions without explicit programming. There are various types of AI algorithms: supervised learning and unsupervised learning.

1. Supervised Learning:

Overview: In supervised learning, the algorithm is trained on a labeled dataset, where each input is associated with the corresponding correct output. The algorithm learns to map inputs to outputs based on the provided examples.

Example: Image classification is a common example of supervised learning. Suppose you have a dataset of images with labels indicating whether they contain a cat or a dog. The algorithm learns to identify patterns in the images that are associated with either a cat or a dog. Once trained, it can classify new, unseen images into the correct categories.

2. Unsupervised Learning:

Overview: In unsupervised learning, the algorithm is given unlabeled data and must find patterns or relationships within the data without explicit guidance. It discovers the inherent structure of the input data.

Example: Clustering is an unsupervised learning task. For instance, imagine a dataset of customer purchase history. The algorithm may identify natural groupings of customers who tend to buy similar products. This can help businesses in targeted marketing or personalized recommendations.

Let's take a simple example to illustrate how a supervised learning algorithm, specifically a linear regression algorithm, works.

Supervised Learning - Linear Regression:

Problem: Predicting the price of a house based on its size.

Dataset: You have a dataset with pairs of house sizes (input features) and their corresponding prices (output labels).

Size (sq. ft.) Price (INR )
1400 1,80,000
1600 2,00,000
1700 2,20,000
1875 2,40,000
1100 1,50,000

* Table data isn't connected with real-world data.

Linear Regression Model:

The goal is to find a linear relationship between the size of the house (x) and its price (y), represented by the equation: y = mx + b, where 'm' is the slope and 'b' is the intercept.

The linear regression algorithm will try to find the best values for 'm' and 'b' that minimize the difference between the predicted prices and the actual prices in the training data.

Mathematical Steps:

1. Initialize Parameters: Start with initial values for 'm' and 'b'.

2. Define a Prediction Function: The prediction for a house of size 'x' is given by y_pred = mx + b.

3. Calculate Loss: The loss measures the difference between the predicted prices and the actual prices. One common loss function is the Mean Squared Error (MSE): loss = (1/N) * Σ(y_actual - y_pred)^2, where 'N' is the number of data points.

4. Gradient Descent: Adjust the parameters ('m' and 'b') to minimize the loss. Update rules: m = m - learning_rate * ∂(loss)/∂m and b = b - learning_rate * ∂(loss)/∂b.

5. Repeat: Iteratively perform steps 2-4 until the loss is minimized.

Initial Parameters:

  • m = 0.5
  • b = 1,00,000

Iteration 1: Predicted prices after that calculate MSE loss and update parameters using gradient descent.

Iteration 2: Repeat the process with updated parameters and continue until convergence.

The algorithm iteratively refines its parameters to minimize the difference between predicted and actual prices. The final 'm' and 'b' values represent the learned relationship, and you can use them to predict house prices for new sizes.

Now, it's time to write a computer program to execute this algorithm using the C language. This example assumes a basic understanding of C and focuses on the core logic:

c Copy Code
#include <stdio.h>
#include <math.h>

// Function to calculate mean squared error (MSE) loss
double calculate_loss(int n, double *x, double *y, double m, double b) {
    double loss = 0.0;
    for (int i = 0; i < n; i++) {
        double y_pred = m * x[i] + b;
        loss += (y[i] - y_pred) * (y[i] - y_pred);
    return loss / n;

// Function to perform gradient descent and update parameters
void gradient_descent(int n, double *x, double *y, double *m, double *b, double learning_rate) {
    double dm = 0.0, db = 0.0;
    for (int i = 0; i < n; i++) {
        double y_pred = (*m) * x[i] + (*b);
        dm += -2 * x[i] * (y[i] - y_pred);
        db += -2 * (y[i] - y_pred);
    *m = *m - learning_rate * (dm / n);
    *b = *b - learning_rate * (db / n);

// Function to normalize the input features
void normalize(int n, double *x) {
    double max_x = x[0];
    for (int i = 1; i < n; i++) {
        if (x[i] > max_x) {
            max_x = x[i];
    for (int i = 0; i < n; i++) {
        x[i] /= max_x;

int main() {
    // Example dataset
    int n = 5;
    double x[] = {1400, 1600, 1700, 1875, 1100};
    double y[] = {180000, 200000, 220000, 240000, 150000};

    // Normalize the input features
    normalize(n, x);

    // Initial parameters
    double m = 0.5;
    double b = 100000;

    // Hyperparameter: learning rate
    double learning_rate = 0.000001;

    // Number of iterations
    int num_iterations = 1000;

    // Training loop
    for (int i = 0; i < num_iterations; i++) {
        // Calculate mean squared error loss
        double loss = calculate_loss(n, x, y, m, b);

        // Print loss for monitoring purposes
        if (i % 100 == 0) {
            printf("Iteration %d, Loss: %lf\n", i, loss);

        // Update parameters using gradient descent
        gradient_descent(n, x, y, &m, &b, learning_rate);

    // Print the final learned parameters
    printf("Final Parameters: m = %lf, b = %lf\n", m, b);

    // Example: Predict the price for a new house size (e.g., 1500 sq. ft.)
    double new_size = 1500;
    double predicted_price = m * new_size + b;
    printf("Predicted Price for %lf sq. ft.: %lf\n", new_size, predicted_price);

    return 0;
Iteration 0, Loss: 10579915360.172594  
Iteration 100, Loss: 10573210482.516537
Iteration 200, Loss: 10566510102.789234
Iteration 300, Loss: 10559814217.972036
Iteration 400, Loss: 10553122825.048319
Iteration 500, Loss: 10546435921.003483
Iteration 600, Loss: 10539753502.824955
Iteration 700, Loss: 10533075567.502178
Iteration 800, Loss: 10526402112.026602
Iteration 900, Loss: 10519733133.391729
Final Parameters: m = 169.502571, b = 100195.665306
Predicted Price for 1500.000000 sq. ft.: 354449.521177

This C program includes functions for calculating the mean squared error loss and performing gradient descent to update the parameters 'm' and 'b'. The main function initializes the dataset, hyperparameters, and runs the training loop. The learned parameters are printed at the end, and a prediction is made for a new house size.

Remember: Keep in mind that this is a simplified example, and in practice, libraries like math.h and additional error handling may be used.

This is a basic example, and real-world scenarios involve more complex algorithms and features, but the fundamental principles remain similar.

What is New?

We have just updated this website & still working on adding new content & updating existing features.