refactor code

Author: minhqngo

minitorch/__init__.py

@@ -1,6 +1,6 @@
 # MODULE 0
 # MODULE 1
-import minitorch.scalar_functions as scalar_functions  # noqa: F401,F403
+import minitorch.scalar.functions as scalar_functions  # noqa: F401,F403
 
 from .autodiff import *  # noqa: F401,F403
 from .cuda_ops import *  # noqa: F401,F403
@@ -15,7 +15,7 @@
 from .nn import *  # noqa: F401,F403
 from .optim import *  # noqa: F401,F403
 from .scalar import Scalar, ScalarHistory, derivative_check  # noqa: F401,F403
-from .scalar_functions import ScalarFunction  # noqa: F401,F403
+from minitorch.scalar.functions import ScalarFunction  # noqa: F401,F403
 
 # MODULE 2
 from .tensor import *  # noqa: F401,F403

minitorch/autodiff.py

@@ -3,9 +3,6 @@
 
 from typing_extensions import Protocol
 
-# ## Task 1.1
-# Central Difference calculation
-
 
 def central_difference(f: Any, *vals: Any, arg: int = 0, epsilon: float = 1e-6) -> Any:
     r"""

minitorch/scalar_modules.py renamed to minitorch/backends/__init__.py

@@ -4,8 +4,8 @@
 
 import minitorch
 
-from . import operators
-from .autodiff import Context
+from .. import common_operators
+from ..autodiff import Context
 
 if TYPE_CHECKING:
     from typing import Tuple
@@ -86,12 +86,12 @@ class Log(ScalarFunction):
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
         ctx.save_for_backward(a)
-        return operators.log(a)
+        return common_operators.log(a)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> float:
         (a,) = ctx.saved_values
-        return operators.log_back(a, d_output)
+        return common_operators.log_back(a, d_output)
 
 
 class Mul(ScalarFunction):
@@ -100,7 +100,7 @@ class Mul(ScalarFunction):
     @staticmethod
     def forward(ctx: Context, a: float, b: float) -> float:
         ctx.save_for_backward(a, b)
-        return operators.mul(a, b)
+        return common_operators.mul(a, b)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> Tuple[float, float]:
@@ -114,20 +114,20 @@ class Inv(ScalarFunction):
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
         ctx.save_for_backward(a)
-        return operators.inv(a)
+        return common_operators.inv(a)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> float:
         (a,) = ctx.saved_values
-        return operators.inv_back(a, d_output)
+        return common_operators.inv_back(a, d_output)
 
 
 class Neg(ScalarFunction):
     "Negation function"
 
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
-        return operators.neg(a)
+        return common_operators.neg(a)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> float:
@@ -139,7 +139,7 @@ class Sigmoid(ScalarFunction):
 
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
-        s = operators.sigmoid(a)
+        s = common_operators.sigmoid(a)
         ctx.save_for_backward(s)
         return s
 
@@ -155,20 +155,20 @@ class ReLU(ScalarFunction):
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
         ctx.save_for_backward(a)
-        return operators.relu(a)
+        return common_operators.relu(a)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> float:
         (a,) = ctx.saved_values
-        return operators.relu_back(a, d_output)
+        return common_operators.relu_back(a, d_output)
 
 
 class Exp(ScalarFunction):
     "Exp function"
 
     @staticmethod
     def forward(ctx: Context, a: float) -> float:
-        e = operators.exp(a)
+        e = common_operators.exp(a)
         ctx.save_for_backward(e)
         return e
 
@@ -183,7 +183,7 @@ class LT(ScalarFunction):
 
     @staticmethod
     def forward(ctx: Context, a: float, b: float) -> float:
-        return operators.lt(a, b)
+        return common_operators.lt(a, b)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> Tuple[float, float]:
@@ -195,7 +195,7 @@ class EQ(ScalarFunction):
 
     @staticmethod
     def forward(ctx: Context, a: float, b: float) -> float:
-        return operators.eq(a, b)
+        return common_operators.eq(a, b)
 
     @staticmethod
     def backward(ctx: Context, d_output: float) -> Tuple[float, float]:

minitorch/operators.py renamed to minitorch/common_operators.py

@@ -5,8 +5,8 @@
 
 import numpy as np
 
-from .autodiff import Context, Variable, backpropagate, central_difference
-from .scalar_functions import (
+from ..autodiff import Context, Variable, backpropagate, central_difference
+from .functions import (
     EQ,
     LT,
     Add,

minitorch/modules.py

@@ -9,7 +9,7 @@
 from numpy import array, float64
 from typing_extensions import TypeAlias
 
-from .operators import prod
+from ..common_operators import prod
 
 MAX_DIMS = 32