## 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:

#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's Next?

We've now entered the finance section on this platform, where you can enhance your financial literacy.