# Find the minimum of cost function using Gradient Descent Algorithm

Understand Gradient Descent Algorithm and find minimum of cost function using this algorithm.

### Introduction:

Gradient Descent is a simple and powerful optimization algorithm used to find the minimum (or maximum) of a function. Imagine you are standing on a hilly terrain, and your goal is to reach the lowest point (the valley) as quickly as possible.

In Gradient Descent, you take small steps downhill in the steepest direction to approach the lowest point. At each step, you calculate the slope (gradient) of the terrain in the direction you're heading. If the slope is positive, it means you are going uphill, so you need to take a step in the opposite direction to go downhill.

By repeating this process iteratively, you gradually get closer to the valley. The size of the steps you take is controlled by a parameter called the learning rate. A higher learning rate means bigger steps, which can lead to quicker convergence but may overshoot the minimum. On the other hand, a smaller learning rate takes smaller, more cautious steps, but it may take longer to reach the minimum.

The algorithm continues to update your position until you reach a point where taking a step doesn't significantly change your position (convergence). At this point, you have found an approximate minimum of the function.

Gradient Descent is widely used in various fields, including machine learning, where it is used to optimize parameters of models to make predictions more accurate. It's like finding the best fit line for a set of data points or adjusting the weights of a neural network to improve its performance.

Overall, Gradient Descent is a simple yet effective method to find the minimum of a function and has numerous applications in optimization and machine learning tasks.

### Steps to find the minimum of Cost Function using Gradient Descent Algorithm:

**Step 1: Define the Cost Function **

Start by defining the cost function you want to minimize. The cost function represents the objective you want to optimize. For example, in machine learning, the cost function measures the error between the predicted output and the actual output.

**Step 2: Initialize Parameters **

Choose initial values for the parameters of the cost function. These parameters are the variables that the cost function depends on and whose values you want to find to minimize the cost function.

**Step 3: Calculate the Gradient **

Compute the gradient of the cost function with respect to each parameter. The gradient indicates the direction and magnitude of the steepest increase in the cost function. It guides the algorithm towards the minimum.

**Step 4: Update Parameters **

Use the gradients calculated in the previous step to update the values of the parameters. The update rule involves subtracting a fraction of the gradient from the current parameter value, controlled by a learning rate. This step is where the actual movement towards the minimum takes place.

**Step 5: Repeat Until Convergence **

Repeat steps 3 and 4 iteratively until the cost function converges to a minimum. Convergence occurs when the cost function stops significantly changing, or the parameter values don't change beyond a specified tolerance.

**Step 6: Output the Minimized Parameters **

Once the algorithm converges, the parameter values at this point represent the minimum of the cost function. These optimized parameter values can be used for making predictions or further analysis, depending on the specific problem.

**Step 7: Fine-Tuning (Optional) **

In practice, you might need to experiment with different learning rates and convergence criteria to achieve the best results. Choosing an appropriate learning rate is crucial for the algorithm to converge efficiently without overshooting the minimum.

**Step 8: Test the Model (for Machine Learning) **

If you are using the Gradient Descent Algorithm for machine learning tasks, it's essential to test the model's performance using a validation set or cross-validation to ensure the minimum found is indeed optimal for the problem.

### Example code in C to find the minimum of cost function using Gradient Descent Algorithm:

```
#include <stdio.h>
#include <math.h>
// Define the cost function
double costFunction(double x) {
// For example, let's use a simple quadratic cost function: f(x) = (x - 3)^2
return pow(x - 3, 2);
}
// Define the derivative of the cost function
double costFunctionDerivative(double x) {
// The derivative of the cost function f'(x) = 2 * (x - 3)
return 2 * (x - 3);
}
// Gradient Descent Function to find the minimum of the cost function
double gradientDescent(double learningRate, int iterations) {
double x = 0.0; // Initial value of x (can be any value)
// Perform gradient descent iterations
for (int i = 0; i < iterations; ++i) {
double gradient = costFunctionDerivative(x);
x -= learningRate * gradient;
}
return x;
}
int main() {
double learningRate = 0.1; // Learning rate for gradient descent
int iterations = 1000; // Number of iterations for gradient descent
double minimum = gradientDescent(learningRate, iterations);
printf("Minimum of the cost function: %lf\n", minimum);
return 0;
}
```

In this code, we define a simple quadratic cost function `costFunction(x) = (x - 3)^2`

and its derivative `costFunctionDerivative(x) = 2 * (x - 3)`

. We then use the gradient descent algorithm to find the minimum of this cost function. The `gradientDescent`

function iteratively updates the value of `x`

using the gradient of the cost function with respect to `x`

and the learning rate.

Note: In practical applications, the cost function and its derivative may be more complex, and gradient descent may require additional optimization techniques, such as adaptive learning rates or momentum, to ensure convergence to the global minimum. The example provided is a simple illustration to demonstrate the gradient descent algorithm in C.