import matplotlib.pyplot as pltimport numpy as np
# simple functiondef func(x):    return np.sin(x)
# derivate of func(x)def d_func(x):    return np.cos(x)
X = np.arange(-5, 5, 0.4) # sample x valuesY = func(X) # y valuesZ = d_func(X) # derivates/gradient value
plt.plot(X, Y, c="blue", marker='o', label="(X, func(X))")plt.plot(X, Z, c='red', marker='o', label="(X, d_func(X))")plt.xlabel('X')plt.ylabel('Y/Z')plt.legend()plt.grid(True)print("(X, func(X)) = ", list(zip(X[:2], Y[:2])))print("(X, d_func(X)) = ", list(zip(X[:2], Z[:2])))

import matplotlib.pyplot as pltimport numpy as np
# simple functiondef func(x):    return 2*(x**2)
# derivate of func(x)def d_func(x):    h = 0.00001    return (func(x+h)-func(x))/h
X = np.arange(-25, 25, 1) #Y = func(X)Z = d_func(X)
plt.plot(X, Y, c="blue",  label="(X, func(X))")plt.plot(X, Z, c='red', label="(X, d_func(X))")plt.xlabel('X')plt.ylabel('Y')plt.legend()plt.grid(True)

# approach using Finite Difference Approximation.# Import necessary librariesimport


    
 matplotlib.pyplot as pltimport numpy as np
# an array ranging from -0.5 to 0.5 with a step of 0.01inputX = np.arange(-0.5, 0.5, 0.01) # random values with a normal distribution to add noise to the input.noise = np.random.normal(0, 0.2, inputX.shape)# output values with noise.outputY = inputX+noiseprint("Input Values : ", inputX[:2], " Output Values : ", outputY[:2])# so input dataset is ready inputX, outputYplt.scatter(inputX, outputY, c="blue", label="Dataset")
# initial weights and biasweight = 0.1 # any valuebias = 1 # any value
# calculates the predicted values based on the input, weight, and bias.def linear_regression_equation(input_value, weight, bias):    # X = independent value    # Y = Dependent Value    # M = SLOPE    # B = INTERCEPT/BIAS    # = y=mx+b    predicted_value = (weight * input_value) + bias    return predicted_value
# calculates the mean squared error (MSE)def cost_function(input_value, weight, bias, target_value):    predicted_value = linear_regression_equation(input_value, weight, bias)    difference = (target_value - predicted_value)**2    return sum(difference)/len(difference)
# calculates gradients using finite difference approximation.def gradient_value_using_approx(inputX, outputY, weight, bias):    # this approach is easy to implement but,     # it takes more computation power and time.    f = cost_function    h = 0.001    w_grad_val = (f(inputX, weight+h, bias, outputY)-f(inputX, weight, bias, outputY))/h    b_grad_val = (f(inputX, weight, bias+h, outputY)-f(inputX, weight, bias, outputY))/h    return (w_grad_val, b_grad_val)
# the loss (MSE) before any learningbefore_loss_value = cost_function(inputX, weight, bias, outputY)plt.plot(inputX, linear_regression_equation(inputX, weight, bias), c="orange", label="Before Learning")
# training parametersepochs = 300learning_rate = 0.08# Weights and bias are updated using the learning rate # and gradients to minimize the loss.for _ in range(epochs):    (w_grad_val, b_grad_val) = gradient_value_using_approx(inputX, outputY, weight, bias)    weight = weight - (learning_rate*w_grad_val)    bias = bias - (learning_rate*b_grad_val)
# the loss (MSE) after the specified number of epochs.after_loss_value = cost_function(inputX, weight, bias, outputY)print(f"Loss Value (Before Learning) : {before_loss_value}, Loss Value (After Learning) :  {after_loss_value}")# plot the linear regression line in greenplt.plot(inputX, linear_regression_equation(inputX, weight, bias), c="green", label=f"After {epochs} epochs learning")plt.legend()plt.grid(True)

#.... Same Code as given in previous example .... def gradient_value_using_rules(inputX, outputY, weight, bias):    # recommended way    # using chain rule to get derivate of     # cost_function(linear_regression_equation(input))    #    w_grad_val = sum((-2 *inputX)*(outputY - ((weight*inputX)+bias)))/len(inputX)    b_grad_val = sum(-2*(outputY - ((weight*inputX)+bias)))/len(inputX)    return (w_grad_val, b_grad_val)
#.... Just replace gradient_value_using_approx to gradient_value_using_rules ....

class TensorValue:    def __init__(self, num, ops= None, left=None, right=None):        self.num = num        self.ops = ops        self.left = left        self.right = right        self.grad = 0.0        self.leaf = True                if self.left or self.right:            self.leaf = False        def __add__(self, y):        return self.__class__(self.num + getattr(y, "num", y), ops="+", left=self, right=y)        def __radd__(self,  y):        return self.__add__(y)        def __sub__(self, y):   


    
        return self.__add__(-y)        def __rsub__(self,  y):        return self.__add__(-y)        def __mul__(self, y):             return self.__class__(self.num * getattr(y,"num", y), ops="*", left=self, right=y)        def __rmul__(self,  y):        return self.__mul__(y)        def relu(self):        return self.__class__(max(0, self.num), ops="rl", left=self)
    def __neg__(self):        return self.__mul__(-1)        def __truediv__(self, y):                return self.__mul__(y**-1)        def __rtruediv__(self,  y):        return self.__mul__(y**-1)        def __pow__(self, y):        return self.__class__(self.num ** getattr(y, "num", y), ops="pow", left=self, right=y)        def __repr__(self):        return f"{self.__class__.__name__}({self.num})"            def flush_gradient(self):        if not self.leaf:            self.grad = 0        if isinstance(self.left, self.__class__):            self.left.flush_gradient()         if isinstance(self.right, self.__class__):            self.right.flush_gradient()        def backward(self):        self.grad = 1        return self.calculate_gradient_backward()            def calculate_gradient_backward(self,):        r = getattr(self.right, "num", self.right)        l = getattr(self.left, "num", self.left)            # the derivative of f(x, y) = x + y with respect to x is simply 1        if self.ops=="+":            self.left.grad += (self.grad * 1)            if isinstance(self


    
.right, self.__class__):                self.right.grad += (self.grad * 1)                        # the derivative of f(a, b) = a * b with respect to 'a' is 'b'.        elif self.ops=="*":            self.left.grad += (r * self.grad)                            if isinstance(self.right, self.__class__):                self.right.grad += (l * self.grad)                elif self.ops=="rl":            self.left.grad += (int(self.num > 0) * self.grad)                                        # the derivative of f(a, b) = a^b with respect to 'a' is 'b * a^(b-1)'        elif self.ops=="pow":            self.left.grad += ((r * (l ** (r - 1))) * self.grad)                            if isinstance(self.right, self.__class__):                self.right.grad += ((l * (r ** (l -1))) * self.grad)                    if isinstance(self.left, self.__class__):            self.left.calculate_gradient_backward()            self.left.flush_gradient()                    if isinstance(self.right, self.__class__):            self.right.calculate_gradient_backward()            self.right.flush_gradient()