app.py

app.py

@@ -1,16 +1,18 @@
+import torch
+
 # Input data
-x1 = [50, 60, 70, 80, 90]
-x2 = [20, 21, 22, 23, 24]
-y_actual = [30, 35, 40, 45, 50]
+x1 = torch.tensor([50, 60, 70, 80, 90])
+x2 = torch.tensor([20, 21, 22, 23, 24])
+y_actual = torch.tensor([30, 35, 40, 45, 50])
 
 # Learning rate and maximum number of iterations
 alpha = 0.01
 max_iters = 1000
 
 # Initial values for Theta0, Theta1, and Theta2
-Theta0 = 0
-Theta1 = 0
-Theta2 = 0
+Theta0 = torch.tensor(0.0, requires_grad=True)
+Theta1 = torch.tensor(0.0, requires_grad=True)
+Theta2 = torch.tensor(0.0, requires_grad=True)
 
 # Start the iteration counter
 iter_count = 0
@@ -18,34 +20,43 @@ iter_count = 0
 # Loop until convergence or maximum number of iterations
 while iter_count < max_iters:
     # Compute the predicted output
-    y_pred = [Theta0 + Theta1 * x1[i] + Theta2 * x2[i] for i in range(len(x1))]
+    y_pred = Theta0 + Theta1 * x1 + Theta2 * x2
 
     # Compute the errors
-    errors = [y_pred[i] - y_actual[i] for i in range(len(x1))]
-
-    # Update Theta0, Theta1, and Theta2
-    Theta0 -= alpha * sum(errors) / len(x1)
-    Theta1 -= alpha * sum([errors[i] * x1[i] for i in range(len(x1))]) / len(x1)
-    Theta2 -= alpha * sum([errors[i] * x2[i] for i in range(len(x2))]) / len(x2)
+    errors = y_pred - y_actual
 
     # Compute the cost function
-    cost = sum([(y_pred[i] - y_actual[i]) ** 2 for i in range(len(x1))]) / (2 * len(x1))
+    cost = torch.sum(errors ** 2) / (2 * len(x1))
 
     # Print the cost function every 100 iterations
     if iter_count % 100 == 0:
-        print("Iteration {}: Cost = {}, Theta0 = {}, Theta1 = {}, Theta2 = {}".format(iter_count, cost, Theta0, Theta1,
-                                                                                      Theta2))
+        print("Iteration {}: Cost = {}, Theta0 = {}, Theta1 = {}, Theta2 = {}".format(iter_count, cost, Theta0.item(), Theta1.item(),
+                                                                                      Theta2.item()))
 
     # Check for convergence (if the cost is decreasing by less than 0.0001)
-    if iter_count > 0 and abs(cost - prev_cost) < 0.0001:
+    if iter_count > 0 and torch.abs(cost - prev_cost) < 0.0001:
         print("Converged after {} iterations".format(iter_count))
         break
 
+    # Perform automatic differentiation to compute gradients
+    cost.backward()
+
+    # Update Theta0, Theta1, and Theta2 using gradient descent
+    with torch.no_grad():
+        Theta0 -= alpha * Theta0.grad
+        Theta1 -= alpha * Theta1.grad
+        Theta2 -= alpha * Theta2.grad
+
+        # Reset gradients for the next iteration
+        Theta0.grad.zero_()
+        Theta1.grad.zero_()
+        Theta2.grad.zero_()
+
     # Update the iteration counter and previous cost
     iter_count += 1
     prev_cost = cost
 
 # Print the final values of Theta0, Theta1, and Theta2
-print("Final values: Theta0 = {}, Theta1 = {}, Theta2 = {}".format(Theta0, Theta1, Theta2))
-print("Final Cost: Cost = {}".format(cost))
+print("Final values: Theta0 = {}, Theta1 = {}, Theta2 = {}".format(Theta0.item(), Theta1.item(), Theta2.item()))
+print("Final Cost: Cost = {}".format(cost.item()))
 print("Final values: y_pred = {}, y_actual = {}".format(y_pred, y_actual))