- Add tensor slicing

- Implement RNN layer
- Fix github CI/CD

Author: minhqngo

.github/workflows/minitorch.yml

@@ -8,12 +8,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.8]
+        python-version: ['3.10']
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies

minitorch/nn/layers.py

@@ -9,6 +9,25 @@
     cuda_conv = None
 
 
+__all__ = ['Linear', 'Conv1d', 'Conv2d', 'RNN', 'tanh']
+
+
+def tanh(x):
+    """
+    Hyperbolic tangent activation function.
+
+    tanh(x) = (exp(2x) - 1) / (exp(2x) + 1) = 2*sigmoid(2x) - 1
+
+    Args:
+        x: Input tensor
+
+    Returns:
+        Tensor with tanh applied element-wise
+    """
+    # Using the sigmoid-based formula for numerical stability
+    return 2.0 * (2.0 * x).sigmoid() - 1.0
+
+
 class Linear(Module):
     def __init__(self, in_size, out_size, backend, initializer=init.kaiming_uniform):
         super().__init__()
@@ -46,17 +65,17 @@ def forward(self, input):
 class Conv2d(Module):
     def __init__(self, in_channels, out_channels, kernel, backend, stride=1, initializer=init.kaiming_uniform):
         super().__init__()
-        
+
         self.stride = stride if isinstance(stride, tuple) else (stride, stride)
         kernel = kernel if isinstance(kernel, tuple) else (kernel, kernel)
         kh, kw = kernel
-        
+
         self.weights = Parameter(rand((out_channels, in_channels, kh, kw), backend=backend))
         fan_in = in_channels * kh * kw
         initializer(self.weights.value, fan_in)
-        
+
         self.bias = Parameter(zeros((out_channels, 1, 1), backend=backend))
-        
+
         self.backend = backend
 
     def forward(self, input):
@@ -65,3 +84,59 @@ def forward(self, input):
         else:
             out = fast_conv.conv2d(input, self.weights.value, self.stride) + self.bias.value
         return out
+
+
+class RNN(Module):
+    def __init__(self, input_size, hidden_size, backend, initializer=init.glorot_uniform):
+        super().__init__()
+
+        # Input-to-hidden weights
+        self.W_ih = Parameter(rand((input_size, hidden_size), backend=backend))
+        initializer(self.W_ih.value, input_size, hidden_size)
+
+        # Hidden-to-hidden weights
+        self.W_hh = Parameter(rand((hidden_size, hidden_size), backend=backend))
+        initializer(self.W_hh.value, hidden_size, hidden_size)
+
+        # Bias
+        self.bias = Parameter(zeros((hidden_size,), backend=backend))
+
+        self.hidden_size = hidden_size
+        self.input_size = input_size
+        self.backend = backend
+
+    def forward(self, x, h=None):
+        batch_size, seq_len, input_size = x.shape
+        assert input_size == self.input_size, f"Expected input size {self.input_size}, got {input_size}"
+
+        if h is None:
+            h = zeros((batch_size, self.hidden_size), backend=self.backend)
+
+        outputs = []
+
+        for t in range(seq_len):
+            x_t = x[:, t, :]
+            h = tanh(
+                x_t.view(batch_size, self.input_size) @ self.W_ih.value.view(self.input_size, self.hidden_size)
+                + h.view(batch_size, self.hidden_size) @ self.W_hh.value.view(self.hidden_size, self.hidden_size)
+                + self.bias.value.view(1, self.hidden_size)
+            )
+            outputs.append(h)
+        
+        output_tensors = []
+        for i, out in enumerate(outputs):
+            output_tensors.append(out.view(batch_size, 1, self.hidden_size))
+
+        if seq_len == 1:
+            output = output_tensors[0]
+        else:
+            output_list = []
+            for b in range(batch_size):
+                for t in range(seq_len):
+                    for h_idx in range(self.hidden_size):
+                        output_list.append(outputs[t][b, h_idx])
+
+            from ..tensor.functions import tensor
+            output = tensor(output_list, backend=self.backend).view(batch_size, seq_len, self.hidden_size)
+
+        return output, h

minitorch/tensor/data.py

@@ -143,6 +143,41 @@ def strides_from_shape(shape: UserShape) -> UserStrides:
     return tuple(reversed(layout[:-1]))
 
 
+def normalize_slice(s: slice, dim_size: int) -> Tuple[int, int, int]:
+    """
+    Normalize a slice object to (start, stop, step) with proper bounds.
+
+    Args:
+        s: slice object
+        dim_size: size of the dimension being sliced
+
+    Returns:
+        (start, stop, step) tuple with normalized values
+    """
+    step = s.step if s.step is not None else 1
+    if step == 0:
+        raise IndexingError("slice step cannot be zero")
+
+    if step < 0:
+        start = s.start if s.start is not None else dim_size - 1
+        stop = s.stop if s.stop is not None else -dim_size - 1
+    else:
+        start = s.start if s.start is not None else 0
+        stop = s.stop if s.stop is not None else dim_size
+
+    if start < 0:
+        start = max(0, dim_size + start)
+    else:
+        start = min(start, dim_size)
+
+    if stop < 0:
+        stop = max(-1 if step < 0 else 0, dim_size + stop)
+    else:
+        stop = min(stop, dim_size)
+
+    return start, stop, step
+
+
 class TensorData:
     _storage: Storage
     _strides: Strides
@@ -175,7 +210,8 @@ def __init__(
         self.dims = len(strides)
         self.size = int(prod(shape))
         self.shape = shape
-        assert len(self._storage) == self.size
+        # Note: Storage can be larger than size for non-contiguous views
+        # assert len(self._storage) == self.size
 
     def to_cuda_(self) -> None:  # pragma: no cover
         if not numba.cuda.is_cuda_array(self._storage):
@@ -260,6 +296,55 @@ def permute(self, *order: int) -> TensorData:
         new_strides = tuple(self.strides[i] for i in order)
         return TensorData(self._storage, new_shape, new_strides)
 
+    def slice(self, key: Union[int, slice, Sequence[Union[int, slice]]]) -> TensorData:
+        """
+        Create a sliced view of the tensor.
+
+        Args:
+            key: int, slice, or tuple of ints/slices for indexing
+
+        Returns:
+            New TensorData representing the sliced view
+        """
+        if isinstance(key, (int, slice)):
+            key = (key,)
+
+        if len(key) > len(self.shape):
+            raise IndexingError(f"Too many indices {len(key)} for tensor of dimension {len(self.shape)}")
+
+        key = tuple(key) + (slice(None),) * (len(self.shape) - len(key))
+
+        new_shape = []
+        new_strides = []
+        offset = 0
+
+        for dim, (k, dim_size, stride) in enumerate(zip(key, self.shape, self.strides)):
+            if isinstance(k, int):
+                idx = k
+                if idx < 0:
+                    idx = dim_size + idx
+                if idx < 0 or idx >= dim_size:
+                    raise IndexingError(f"Index {k} out of range for dimension {dim} with size {dim_size}")
+                offset += idx * stride
+            elif isinstance(k, slice):
+                start, stop, step = normalize_slice(k, dim_size)
+                if step > 0:
+                    size = max(0, (stop - start + step - 1) // step)
+                else:
+                    size = max(0, (stop - start + step + 1) // step)
+
+                new_shape.append(size)
+                new_strides.append(stride * step)
+                offset += start * stride
+            else:
+                raise IndexingError(f"Unsupported index type: {type(k)}")
+
+        if len(new_shape) == 0:
+            scalar_val = self._storage[offset]
+            return TensorData([scalar_val], (1,), (1,))
+
+        return _make_tensor_data_view(self._storage, tuple(new_shape), tuple(new_strides), offset)
+
     def to_string(self) -> str:
         s = ""
         for index in self.indices():
@@ -283,3 +368,30 @@ def to_string(self) -> str:
             else:
                 s += " "
         return s
+
+
+def _make_tensor_data_view(
+    storage: Storage, shape: UserShape, strides: UserStrides, offset: int
+) -> TensorData:
+    """
+    Create a TensorData view with an offset into the storage.
+
+    Args:
+        storage: The underlying storage array
+        shape: Shape of the view
+        strides: Strides for the view
+        offset: Offset into the storage where the view starts
+
+    Returns:
+        TensorData representing the view
+    """
+    if len(shape) == 0 or prod(shape) == 0:
+        # Empty tensor
+        return TensorData([], shape, strides)
+
+    if offset > 0:
+        view_storage = storage[offset:]
+    else:
+        view_storage = storage
+
+    return TensorData(view_storage, shape, strides)

minitorch/tensor/tensor.py

@@ -285,9 +285,27 @@ def contiguous(self) -> Tensor:
     def __repr__(self) -> str:
         return self._tensor.to_string()
 
-    def __getitem__(self, key: Union[int, UserIndex]) -> float:
-        key2 = (key,) if isinstance(key, int) else key
-        return self._tensor.get(key2)
+    def __getitem__(self, key: Union[int, slice, UserIndex]) -> Union[float, Tensor]:
+        if isinstance(key, slice):
+            sliced_data = self._tensor.slice(key)
+            return Tensor(sliced_data, backend=self.backend)
+        elif isinstance(key, tuple):
+            has_slice = any(isinstance(k, slice) for k in key)
+            if has_slice:
+                sliced_data = self._tensor.slice(key)
+                if sliced_data.shape == (1,) and sliced_data.size == 1:
+                    return float(sliced_data._storage[0])
+                return Tensor(sliced_data, backend=self.backend)
+            else:
+                return self._tensor.get(key)
+        elif isinstance(key, int):
+            if len(self.shape) == 1:
+                return self._tensor.get((key,))
+            else:
+                sliced_data = self._tensor.slice(key)
+                return Tensor(sliced_data, backend=self.backend)
+        else:
+            raise TypeError(f"Unsupported index type: {type(key)}")
 
     def __setitem__(self, key: Union[int, UserIndex], val: float) -> None:
         key2 = (key,) if isinstance(key, int) else key

requirements.txt

@@ -1,12 +1,12 @@
-colorama==0.4.3
-hypothesis == 6.54
-mypy == 0.971
-numba==0.62
-numpy==2.2.6
-pre-commit==2.20.0
-pytest==7.1.2
-pytest-env
-pytest-runner==5.2
+colorama==0.4.6
+hypothesis==6.54
+mypy==1.7.0
+numba==0.60.0
+numpy==1.26.4
+pre-commit==3.5.0
+pytest==7.4.3
+pytest-env==1.1.3
+pytest-runner==6.0.1
 tensorboardX==2.6.4
-tensorboard==2.20.0
-typing_extensions
+tensorboard==2.15.1
+typing_extensions==4.9.0