Refactor gradient_descent.py with full type hints and documentation

This PR modernizes machine_learning/gradient_descent.py while preserving the original algorithm behavior.

Changes include:
- Added full type hints 
- Improved docstrings and readability

No functional or algorithmic behavior was modified.

Author: anandvenugopal-tech

machine_learning/gradient_descent.py

@@ -3,24 +3,29 @@
 function.
 """
 
+from __future__ import annotations
+
 import numpy as np
+from typing import Literal, Sequence
 
 # List of input, output pairs
-train_data = (
+train_data: tuple[tuple[tuple[int, ...], int], ...] = (
     ((5, 2, 3), 15),
     ((6, 5, 9), 25),
     ((11, 12, 13), 41),
     ((1, 1, 1), 8),
     ((11, 12, 13), 41),
 )
-test_data = (((515, 22, 13), 555), ((61, 35, 49), 150))
-parameter_vector = [2, 4, 1, 5]
-m = len(train_data)
-LEARNING_RATE = 0.009
+test_data: tuple[tuple[tuple[int, ...], int], ...] = (((515, 22, 13), 555), ((61, 35, 49), 150))
+parameter_vector: list[float] = [2.0, 4.0, 1.0, 5.0]
+m: int = len(train_data)
+LEARNING_RATE: float = 0.009
 
 
-def _error(example_no, data_set="train"):
+def _error(example_no: int, data_set: Literal["train", "test"]="train") -> float:
     """
+    Compute prediction error for a given example.
+    
     :param data_set: train data or test data
     :param example_no: example number whose error has to be checked
     :return: error in example pointed by example number.
@@ -30,9 +35,10 @@ def _error(example_no, data_set="train"):
     )
 
 
-def _hypothesis_value(data_input_tuple):
+def _hypothesis_value(data_input_tuple: Sequence[int]) -> float:
     """
-    Calculates hypothesis function value for a given input
+    Calculates hypothesis value for a given input tuple.
+    
     :param data_input_tuple: Input tuple of a particular example
     :return: Value of hypothesis function at that point.
     Note that there is an 'biased input' whose value is fixed as 1.
@@ -46,8 +52,10 @@ def _hypothesis_value(data_input_tuple):
     return hyp_val
 
 
-def output(example_no, data_set):
+def output(example_no: int, data_set: Literal["train", "test"]) -> float:
     """
+    Get the true output value of an example.
+    
     :param data_set: test data or train data
     :param example_no: example whose output is to be fetched
     :return: output for that example
@@ -59,9 +67,10 @@ def output(example_no, data_set):
     return None
 
 
-def calculate_hypothesis_value(example_no, data_set):
+def calculate_hypothesis_value(example_no: int, data_set: Literal["train", "test"]) -> float:
     """
-    Calculates hypothesis value for a given example
+    Calculates hypothesis value for a given example.
+    
     :param data_set: test data or train_data
     :param example_no: example whose hypothesis value is to be calculated
     :return: hypothesis value for that example
@@ -73,9 +82,10 @@ def calculate_hypothesis_value(example_no, data_set):
     return None
 
 
-def summation_of_cost_derivative(index, end=m):
+def summation_of_cost_derivative(index: int, end: int = m) -> float:
     """
-    Calculates the sum of cost function derivative
+    Calculates the summation term of the cost derivative.
+    
     :param index: index wrt derivative is being calculated
     :param end: value where summation ends, default is m, number of examples
     :return: Returns the summation of cost derivative
@@ -91,8 +101,10 @@ def summation_of_cost_derivative(index, end=m):
     return summation_value
 
 
-def get_cost_derivative(index):
+def get_cost_derivative(index: int) -> float:
     """
+    Compute ∂J/∂θᵢ for a given parameter index.
+    
     :param index: index of the parameter vector wrt to derivative is to be calculated
     :return: derivative wrt to that index
     Note: If index is -1, this means we are calculating summation wrt to biased
@@ -102,7 +114,10 @@ def get_cost_derivative(index):
     return cost_derivative_value
 
 
-def run_gradient_descent():
+def run_gradient_descent() -> None:
+    """
+    Perform gradient descent to optimize the parameter vector.
+    """
     global parameter_vector
     # Tune these values to set a tolerance value for predicted output
     absolute_error_limit = 0.000002
@@ -127,7 +142,7 @@ def run_gradient_descent():
     print(("Number of iterations:", j))
 
 
-def test_gradient_descent():
+def test_gradient_descent() -> None:
     for i in range(len(test_data)):
         print(("Actual output value:", output(i, "test")))
         print(("Hypothesis output:", calculate_hypothesis_value(i, "test")))