lucid-dl 2.5.5__tar.gz → 2.8.4__tar.gz

{lucid_dl-2.5.5/lucid_dl.egg-info → lucid_dl-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lucid-dl
-Version: 2.5.5
+Version: 2.8.4
 Summary: Lumerico's Comprehensive Interface for Deep Learning
 Home-page: https://github.com/ChanLumerico/lucid
 Author: ChanLumerico
@@ -29,27 +29,26 @@ Dynamic: summary
 # Lucid² 💎
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lucid-dl?color=red)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/lucid-dl)
-![PyPI - Total Downloads](https://img.shields.io/badge/total%20downloads-30.2k-yellow)
-![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ChanLumerico/lucid)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lucid-dl.svg)
+![PyPI - Total Downloads](https://img.shields.io/badge/total%20downloads-34.0k-yellow.svg)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ChanLumerico/lucid.svg)
 ![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)
-![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Floc-counter.onrender.com%2F%3Frepo%3DChanLumerico%2Flucid%26branch%3Dmain%26ignored%3Ddocs%26stat%3DlinesOfCode&label=Lines%20of%20Code&color=purple&cacheSeconds=5)
+![Lines of Code](https://img.shields.io/badge/lines%20of%20code-26.5k-purple.svg)
 
 **Lucid** is a minimalist deep learning framework built entirely from scratch in Python. It offers a pedagogically rich environment to explore the foundations of modern deep learning systems, including autodiff, neural network modules, and GPU acceleration — all while staying lightweight, readable, and free of complex dependencies.
 
 Whether you're a student, educator, or an advanced researcher seeking to demystify deep learning internals, Lucid provides a transparent and highly introspectable API that faithfully replicates key behaviors of major frameworks like PyTorch, yet in a form simple enough to study line by line.
 
-[📑 Lucid Documentation](https://chanlumerico.github.io/lucid/build/html/index.html)
-
+[📑 Lucid Documentation](https://chanlumerico.github.io/lucid/build/html/index.html) | 
 [🤗 Lucid Huggingface](https://huggingface.co/ChanLumerico/lucid)
 
 ### 🔥 What's New
 
-- Now supports [**`🤗 Safetensors`**](https://github.com/huggingface/safetensors) for Lucid neural module porting along with the legacy `.lcd` format
-- Implemented **YOLO-v2**: `lucid.models.YOLO_V2` with variants `yolo_v2`, `yolo_v2_tiny`
-- Implemented **YOLO-v1**: `lucid.models.YOLO_V1` with variants `yolo_v1`, `yolo_v1_tiny`
-- **DDPM** implemented: `lucid.models.DDPM`
-- Added `lucid.cumprod` and `lucid.cumsum`
+- Now supports [**`Safetensors`**](https://github.com/huggingface/safetensors) for Lucid neural module porting along with the legacy `.lcd` format
+
+- Added new neural module category `nn.rnn`, including:
+
+  `nn.RNNBase`, `nn.RNN`, `nn.LSTM`, `nn.GRU`, `nn.RNNCell`, `nn.LSTMCell`, `nn.GRUCell`
 
 ## 🔧 How to Install
 

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/README.md

@@ -1,27 +1,26 @@
 # Lucid² 💎
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lucid-dl?color=red)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/lucid-dl)
-![PyPI - Total Downloads](https://img.shields.io/badge/total%20downloads-30.2k-yellow)
-![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ChanLumerico/lucid)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/lucid-dl.svg)
+![PyPI - Total Downloads](https://img.shields.io/badge/total%20downloads-34.0k-yellow.svg)
+![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ChanLumerico/lucid.svg)
 ![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)
-![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Floc-counter.onrender.com%2F%3Frepo%3DChanLumerico%2Flucid%26branch%3Dmain%26ignored%3Ddocs%26stat%3DlinesOfCode&label=Lines%20of%20Code&color=purple&cacheSeconds=5)
+![Lines of Code](https://img.shields.io/badge/lines%20of%20code-26.5k-purple.svg)
 
 **Lucid** is a minimalist deep learning framework built entirely from scratch in Python. It offers a pedagogically rich environment to explore the foundations of modern deep learning systems, including autodiff, neural network modules, and GPU acceleration — all while staying lightweight, readable, and free of complex dependencies.
 
 Whether you're a student, educator, or an advanced researcher seeking to demystify deep learning internals, Lucid provides a transparent and highly introspectable API that faithfully replicates key behaviors of major frameworks like PyTorch, yet in a form simple enough to study line by line.
 
-[📑 Lucid Documentation](https://chanlumerico.github.io/lucid/build/html/index.html)
-
+[📑 Lucid Documentation](https://chanlumerico.github.io/lucid/build/html/index.html) | 
 [🤗 Lucid Huggingface](https://huggingface.co/ChanLumerico/lucid)
 
 ### 🔥 What's New
 
-- Now supports [**`🤗 Safetensors`**](https://github.com/huggingface/safetensors) for Lucid neural module porting along with the legacy `.lcd` format
-- Implemented **YOLO-v2**: `lucid.models.YOLO_V2` with variants `yolo_v2`, `yolo_v2_tiny`
-- Implemented **YOLO-v1**: `lucid.models.YOLO_V1` with variants `yolo_v1`, `yolo_v1_tiny`
-- **DDPM** implemented: `lucid.models.DDPM`
-- Added `lucid.cumprod` and `lucid.cumsum`
+- Now supports [**`Safetensors`**](https://github.com/huggingface/safetensors) for Lucid neural module porting along with the legacy `.lcd` format
+
+- Added new neural module category `nn.rnn`, including:
+
+  `nn.RNNBase`, `nn.RNN`, `nn.LSTM`, `nn.GRU`, `nn.RNNCell`, `nn.LSTMCell`, `nn.GRUCell`
 
 ## 🔧 How to Install
 

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_func/__init__.py

@@ -42,8 +42,8 @@ def multiply(a: Tensor, b: Tensor, /) -> Tensor:
     return bfunc.multiply()(a, b)
 
 
-def div(a: Tensor, b: Tensor, /) -> Tensor:
-    return bfunc.truediv()(a, b)
+def div(a: Tensor, b: Tensor, /, floor: bool = False) -> Tensor:
+    return bfunc.truediv()(a, b) if not floor else bfunc.floordiv()(a, b)
 
 
 def _equal(a: Tensor, b: Tensor, /) -> Tensor:
@@ -129,6 +129,8 @@ _radd: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: add(a, b)
 _rsub: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: sub(b, a)
 _rmul: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: multiply(a, b)
 _rtruediv: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: div(b, a)
+_floordiv: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: div(a, b, floor=True)
+_rfloordiv: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: div(b, a, floor=True)
 _rbitwise_and: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: _bitwise_and(b, a)
 _rbitwise_or: Callable[[Tensor, Tensor], Tensor] = lambda a, b, /: _bitwise_or(b, a)
 
@@ -137,10 +139,18 @@ def _pow(a: Tensor, /, exp: _Scalar) -> Tensor:
     return ufunc._pow(exp)(a)
 
 
+def _rpow(a: Tensor, /, base: _Scalar) -> Tensor:
+    return ufunc._rpow(base)(a)
+
+
 def _neg(a: Tensor, /) -> Tensor:
     return ufunc._neg()(a)
 
 
+def _invert(a: Tensor, /) -> Tensor:
+    return ufunc._invert()(a)
+
+
 def exp(a: Tensor, /) -> Tensor:
     return ufunc.exp()(a)
 
@@ -551,6 +561,8 @@ Tensor.__mul__ = multiply
 Tensor.__rmul__ = _rmul
 Tensor.__truediv__ = div
 Tensor.__rtruediv__ = _rtruediv
+Tensor.__floordiv__ = _floordiv
+Tensor.__rfloordiv__ = _rfloordiv
 Tensor.__matmul__ = matmul
 
 Tensor.__eq__ = _equal
@@ -561,7 +573,9 @@ Tensor.__lt__ = _less
 Tensor.__le__ = _less_or_equal
 
 Tensor.__pow__ = _pow
+Tensor.__rpow__ = _rpow
 Tensor.__neg__ = _neg
+Tensor.__invert__ = _invert
 
 Tensor.__and__ = _bitwise_and
 Tensor.__rand__ = _rbitwise_and

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_func/bfunc.py

@@ -108,6 +108,27 @@ class truediv(operation):
         return _broadcast_flops(a, b)
 
 
+class floordiv(operation):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @binary_func_op(has_gradient=False)
+    def cpu(self, a: Tensor, b: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(a.data // b.data).astype(lucid.Int)
+        return self.result, partial(self.__grad__, lib_=np)
+
+    @binary_func_op(has_gradient=False, device="gpu")
+    def gpu(self, a: Tensor, b: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(a.data // b.data).astype(lucid.Int)
+        return self.result, partial(self.__grad__, lib_=mx)
+
+    def __grad__(self, lib_: ModuleType) -> _GradFuncType:
+        return lib_.array(0.0), lib_.array(0.0)
+
+    def __flops__(self, a: Tensor, b: Tensor) -> int:
+        return _broadcast_flops(a, b)
+
+
 class _equal(operation):
     def __init__(self) -> None:
         super().__init__()

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_func/ufunc.py

@@ -38,6 +38,28 @@ class _pow(operation):
         return 11 * a.size
 
 
+class _rpow(operation):
+    def __init__(self, base: _Scalar) -> None:
+        super().__init__()
+        self.base = base
+
+    @unary_func_op()
+    def cpu(self, a: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(self.base**a.data)
+        return self.result, partial(self.__grad__, a=a)
+
+    @unary_func_op(device="gpu")
+    def gpu(self, a: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(self.base**a.data)
+        return self.result, partial(self.__grad__, a=a)
+
+    def __grad__(self, a: Tensor) -> _GradFuncType:
+        return (math.log(self.base) * self.base**a.data) * self.result.grad
+
+    def __flops__(self, a: Tensor) -> int:
+        return 11 * a.size
+
+
 class _neg(operation):
     def __init__(self) -> None:
         super().__init__()
@@ -59,6 +81,24 @@ class _neg(operation):
         return a.size
 
 
+class _invert(operation):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @unary_func_op(has_gradient=False)
+    def cpu(self, a: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(~a.data)
+        return self.result, partial(self.__grad__, lib_=np)
+
+    @unary_func_op(has_gradient=False, device="gpu")
+    def gpu(self, a: Tensor) -> _FuncOpReturnType:
+        self.result = Tensor(mx.bitwise_invert(a.data))
+        return self.result, partial(self.__grad__, lib_=mx)
+
+    def __grad__(self, lib_: ModuleType) -> _GradFuncType:
+        return lib_.array(0.0)
+
+
 class exp(operation):
     def __init__(self) -> None:
         super().__init__()

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_tensor/tensor.py

@@ -15,7 +15,7 @@ from lucid.types import (
     Numeric,
 )
 
-from lucid._tensor.tensor_ops import _TensorOps
+from lucid._tensor.tensor_ops import _TensorBase
 from lucid._backend.metal import mx, parse_mlx_indexing, check_metal_availability
 
 
@@ -27,7 +27,7 @@ _dtype_map = {int: types.Int64, float: types.Float64, complex: types.Complex64}
 def _noop() -> None: ...
 
 
-class Tensor(_TensorOps):
+class Tensor(_TensorBase):
     def __init__(
         self,
         data: _ArrayOrScalar | _MLXArray,
@@ -397,28 +397,33 @@ class Tensor(_TensorOps):
         return hash(id(self))
 
     def __deepcopy__(self, *args: Any) -> Self:
+        cls = self.__class__
         copied_data = Tensor.copy_data(self.data)
 
-        new_tensor = Tensor(
-            copied_data,
-            requires_grad=self.requires_grad,
-            keep_grad=self.keep_grad,
-            dtype=self.dtype,
-            device=self.device,
-        )
+        if cls is Tensor:
+            new = Tensor(
+                copied_data, self.requires_grad, self.keep_grad, self.dtype, self.device
+            )
+        else:
+            base = Tensor(copied_data, dtype=self.dtype, device=self.device)
+            new = cls(base)
 
-        if self.grad is not None:
-            new_tensor.grad = Tensor.copy_grad(self.grad)
+        if self.grad is not None and (
+            self.keep_grad or getattr(new, "keep_grad", False)
+        ):
+            new.grad = Tensor.copy_grad(self.grad)
+        else:
+            new.grad = None
 
-        new_tensor._op = self._op
-        new_tensor._backward_op = self._backward_op
-        new_tensor._prev = self._prev.copy()
-        new_tensor._backward_hooks = self._backward_hooks.copy()
+        new._op = None
+        new._backward_op = _noop
+        new._prev = []
+        new._backward_hooks = []
 
-        new_tensor._is_free = self._is_free
-        new_tensor._is_bool_tensor = self._is_bool_tensor
+        new._is_free = self._is_free
+        new._is_bool_tensor = self._is_bool_tensor
 
-        return new_tensor
+        return new
 
     def __bool__(self) -> bool:
         if self.data.size != 1:
@@ -428,16 +433,20 @@ class Tensor(_TensorOps):
             )
         return bool(self.data.item())
 
-    def any(self) -> bool:
+    def any(self, axis: int | None = None, keepdims: bool = False) -> bool | Self:
         if self.is_cpu():
-            return bool(np.any(self.data))
+            result = np.any(self.data, axis=axis, keepdims=keepdims)
+            return bool(result) if axis is None else Tensor(result, device="cpu")
         else:
             mx.eval(self.data)
-            return bool(mx.any(self.data).item())
+            result = mx.any(self.data, axis=axis, keepdims=keepdims)
+            return bool(result.item()) if axis is None else Tensor(result, device="gpu")
 
-    def all(self) -> bool:
+    def all(self, axis=None, keepdims=False) -> bool | Self:
         if self.is_cpu():
-            return bool(np.all(self.data))
+            result = np.all(self.data, axis=axis, keepdims=keepdims)
+            return bool(result) if axis is None else Tensor(result, device="cpu")
         else:
             mx.eval(self.data)
-            return bool(mx.all(self.data).item())
+            result = mx.all(self.data, axis=axis, keepdims=keepdims)
+            return bool(result.item()) if axis is None else Tensor(result, device="gpu")

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_tensor/tensor_ops.py

@@ -3,7 +3,7 @@ from typing import Self, Sequence
 from lucid.types import _Scalar, _ArrayOrScalar, _ShapeLike, _ArrayLikeInt
 
 
-class _TensorOps:
+class _TensorBase:
     def __add__(self, other: Self | _ArrayOrScalar) -> Self: ...
 
     def __radd__(self, other: Self | _ArrayOrScalar) -> Self: ...
@@ -20,6 +20,10 @@ class _TensorOps:
 
     def __rtruediv__(self, other: Self | _ArrayOrScalar) -> Self: ...
 
+    def __floordiv__(self, other: Self | _ArrayOrScalar) -> Self: ...
+
+    def __rfloordiv__(self, other: Self | _ArrayOrScalar) -> Self: ...
+
     def __matmul__(self, other: Self | _ArrayOrScalar) -> Self: ...
 
     def __eq__(self, other: Self | _ArrayOrScalar) -> Self: ...
@@ -36,8 +40,12 @@ class _TensorOps:
 
     def __pow__(self, _: _Scalar) -> Self: ...
 
+    def __rpow__(self, other: Self | _ArrayOrScalar) -> Self: ...
+
     def __neg__(self) -> Self: ...
 
+    def __invert__(self) -> Self: ...
+
     def __and__(self, other: Self | _ArrayOrScalar) -> Self: ...
 
     def __rand__(self, other: Self | _ArrayOrScalar) -> Self: ...

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/_util/func.py

@@ -919,7 +919,7 @@ class argmax(operation):
 
     @unary_func_op(has_gradient=False, device="gpu")
     def gpu(self, a: Tensor) -> _FuncOpReturnType:
-        axis = self.aixs if self.axis is not None else 0
+        axis = self.axis if self.axis is not None else 0
         indices = mx.argmax(a.data, axis=axis)
         if self.keepdims:
             indices = mx.expand_dims(indices, axis)

lucid_dl-2.8.4/lucid/data/__init__.py

@@ -0,0 +1,2 @@
+from lucid.data._base import Dataset, Subset, TensorDataset, ConcatDataset, DataLoader
+from lucid.data._util import *

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/data/_base.py

@@ -1,15 +1,16 @@
 from abc import ABC, abstractmethod
-from typing import Callable, Self, Any
+from typing import Callable, Iterator, Self, Any, override
 import random
 import math
 
 import lucid
 from lucid._tensor import Tensor
+from lucid.types import _ArrayLike, _IndexLike, _DeviceType
 
 
 class Dataset(ABC):
     @abstractmethod
-    def __getitem__(self, index: int) -> None:
+    def __getitem__(self, idx: _IndexLike) -> None:
         raise NotImplementedError("Subclasses must implement __getitem__.")
 
     @abstractmethod
@@ -19,6 +20,92 @@ class Dataset(ABC):
     def __add__(self, other: Self) -> Self:
         return ConcatDataset([self, other])
 
+    def __iter__(self) -> Iterator[Any]:
+        for i in range(len(self)):
+            yield self[i]
+
+    def __repr__(self) -> str:
+        return f"Dataset(n={len(self)})"
+
+
+class Subset(Dataset):
+    def __init__(self, dataset: Dataset, indices: list[int]) -> None:
+        super().__init__()
+        self.dataset = dataset
+        self.indices = indices
+
+    def __getitem__(self, idx: _IndexLike) -> Any:
+        return self.dataset[self.indices[idx]]
+
+    def __len__(self) -> int:
+        return len(self.indices)
+
+    @override
+    def __iter__(self) -> Iterator[Any]:
+        for i in self.indices:
+            yield self.dataset[i]
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.dataset, name)
+
+    def __repr__(self) -> str:
+        return f"Subset(n={len(self)})"
+
+
+class TensorDataset(Dataset):
+    def __init__(self, *tensors_or_arrays: Tensor | _ArrayLike) -> None:
+        super().__init__()
+        if len(tensors_or_arrays) == 0:
+            raise ValueError(
+                "TensorDataset requires at least one tensor/array-like object."
+            )
+        try:
+            self._tensors: tuple[Tensor, ...] = tuple(
+                lucid._check_is_tensor(t) for t in tensors_or_arrays
+            )
+        except Exception as e:
+            raise RuntimeError(
+                "Failed to convert array-like object(s) to tensor."
+            ) from e
+
+        n0 = len(self._tensors[0])
+        for i, t in enumerate(self._tensors):
+            if t.ndim == 0 or len(t) == 0:
+                raise RuntimeError(
+                    "All tensors must be at least 1D. "
+                    f"Tensor at index {i} has no length."
+                )
+            if len(t) != n0:
+                raise ValueError(
+                    "All tensors must have the same length along dim 0: "
+                    f"got {n0} and {len(t)} at index {i}."
+                )
+
+    def __len__(self) -> int:
+        return len(self._tensors[0])
+
+    @override
+    def __getitem__(self, idx: _IndexLike | Tensor) -> tuple[Tensor, ...]:
+        return tuple(t[idx] for t in self._tensors)
+
+    def to(self, device: _DeviceType) -> Self:
+        self._tensors = tuple(t.to(device) for t in self._tensors)
+        return self
+
+    @property
+    def tensors(self) -> tuple[Tensor, ...]:
+        return self._tensors
+
+    @override
+    def __iter__(self) -> Iterator[tuple[Tensor, ...]]:
+        return super().__iter__()
+
+    @override
+    def __repr__(self) -> str:
+        shapes = ", ".join(str(t.shape) for t in self._tensors)
+        devices = {t.device for t in self._tensors}
+        return f"TensorDataset(n={len(self)}, shapes=({shapes}), devices={devices})"
+
 
 class ConcatDataset(Dataset):
     def __init__(self, datasets: list[Dataset]) -> None:
@@ -38,7 +125,7 @@ class ConcatDataset(Dataset):
     def __len__(self) -> int:
         return self.cumulative_sizes[-1] if self.cumulative_sizes else 0
 
-    def __getitem__(self, idx: int) -> Any:
+    def __getitem__(self, idx: _IndexLike) -> Any:
         if idx < 0:
             if -idx > len(self):
                 raise IndexError("Index out of range.")
@@ -101,6 +188,7 @@ class DataLoader:
         if isinstance(batch[0], (tuple, list)):
             transposed = list(zip(*batch))
             return tuple(lucid.stack(tuple(x), axis=0) for x in transposed)
+
         elif isinstance(batch[0], Tensor):
             return lucid.stack(tuple(batch), axis=0)
         else:

lucid_dl-2.8.4/lucid/data/_util.py

@@ -0,0 +1,70 @@
+from typing import Sequence
+import random
+import math
+
+import lucid
+
+from ._base import Dataset, Subset
+
+
+__all__ = ["random_split"]
+
+
+def _resolve_lengths_from_fractions(fractions: Sequence[float], n: int) -> list[int]:
+    if not fractions:
+        raise ValueError("fractions must be non-empty.")
+    if any(f < 0 for f in fractions):
+        raise ValueError("Fractional lengths mus be non-negative.")
+
+    s = sum(fractions)
+    if not math.isclose(s, 1.0, rel_tol=1e-6, abs_tol=1e-6):
+        raise ValueError(f"When passing fractions, they must sum to 1.0 (got {s}).")
+
+    base = [int(math.floor(f * n)) for f in fractions]
+    remainder = n - sum(base)
+    for i in range(remainder):
+        base[i % len(base)] += 1
+
+    return base
+
+
+def random_split(
+    dataset: Dataset, lengths: Sequence[int | float], seed: int | None = None
+) -> tuple[Subset, ...]:
+    n = len(dataset)
+    if not lengths:
+        raise ValueError("lengths must be non-empty.")
+
+    all_int = all(isinstance(l, int) for l in lengths)
+    all_float = all(isinstance(l, float) for l in lengths)
+
+    if not (all_int or all_float):
+        return TypeError("lengths must be all integers or all floats.")
+
+    if all_float:
+        int_lengths = _resolve_lengths_from_fractions(lengths, n)
+    else:
+        int_lengths = list(lengths)
+        s = sum(int_lengths)
+        if s != n:
+            raise ValueError(
+                f"Sum of input lengths ({s}) does not equal dataset length ({n})."
+            )
+        if any(l < 0 for l in int_lengths):
+            raise ValueError("All split lengths must be non-negative.")
+
+    if seed is None:
+        seed = lucid.random.get_seed()
+    rng = random.Random(seed)
+
+    indices = list(range(n))
+    rng.shuffle(indices)
+
+    splits: list[Subset] = []
+    offset = 0
+    for length in int_lengths:
+        split_idx = indices[offset : offset + length]
+        splits.append(Subset(dataset, split_idx))
+        offset += length
+
+    return tuple(splits)

{lucid_dl-2.5.5 → lucid_dl-2.8.4}/lucid/models/imgclf/__init__.py

@@ -2,6 +2,7 @@ from .alex import *
 from .coatnet import *
 from .convnext import *
 from .crossvit import *
+from .cspnet import *
 from .cvt import *
 from .dense import *
 from .efficient import *