lucid-dl 2.11.0__py3-none-any.whl → 2.11.2__py3-none-any.whl

lucid/nn/functional/_norm.py

@@ -1,9 +1,15 @@
 import lucid
 import lucid.nn as nn
-from lucid._tensor import Tensor
 
 from lucid.types import _ShapeLike
 
+from lucid._tensor import Tensor
+from lucid.nn._kernel.norm import (
+    layer_norm_kernel,
+    batch_norm_kernel,
+    group_norm_kernel,
+)
+
 
 def normalize(
     input_: Tensor, ord: int = 2, axis: int = 1, eps: float = 1e-12
@@ -25,44 +31,34 @@ def batch_norm(
     eps: float = 1e-5,
 ) -> Tensor:
     C = input_.shape[1]
-    spatial_dim = input_.ndim - 2
-    use_batch_stats = training or running_mean is None or running_var is None
-
-    if use_batch_stats:
-        batch_mean = input_.mean(axis=(0, *range(2, input_.ndim)), keepdims=True)
-        batch_var = input_.var(axis=(0, *range(2, input_.ndim)), keepdims=True)
-
-        if running_mean is not None and running_var is not None:
-            running_stats_ = (
-                momentum * batch_mean.flatten() + (1 - momentum) * running_mean,
-                momentum * batch_var.flatten() + (1 - momentum) * running_var,
-            )
-
-            if isinstance(running_mean, nn.Buffer) and isinstance(
-                running_var, nn.Buffer
-            ):
-                running_mean.data = running_stats_[0].data
-                running_var.data = running_stats_[1].data
-            else:
-                running_mean, running_var = running_stats_
-
-        mean = batch_mean
-        var = batch_var
+    if running_mean is None or running_var is None:
+        running_mean = lucid.zeros((C,), device=input_.device)
+        running_var = lucid.ones((C,), device=input_.device)
+        has_running = False
     else:
-        mean = running_mean.reshape(1, C, *(1,) * spatial_dim)
-        var = running_var.reshape(1, C, *(1,) * spatial_dim)
-
-    normalized = (input_ - mean) / lucid.sqrt(var + eps)
+        has_running = True
 
-    if weight is not None:
-        weight = weight.reshape((1, C) + (1,) * spatial_dim)
-        normalized *= weight
+    if weight is None:
+        weight = lucid.ones((C,), device=input_.device)
+        has_weight = False
+    else:
+        has_weight = True
 
-    if bias is not None:
-        bias = bias.reshape((1, C) + (1,) * spatial_dim)
-        normalized += bias
+    if bias is None:
+        bias = lucid.zeros((C,), device=input_.device)
+        has_bias = False
+    else:
+        has_bias = True
 
-    return normalized
+    op = batch_norm_kernel(
+        eps=eps,
+        momentum=momentum,
+        training=training,
+        has_running=has_running,
+        has_weight=has_weight,
+        has_bias=has_bias,
+    )
+    return op(input_, running_mean, running_var, weight, bias)
 
 
 def layer_norm(
@@ -77,21 +73,22 @@ def layer_norm(
             "Input tensor's normalized shape must match "
             + "the provided `normalized_shape`."
         )
+    if weight is None:
+        weight = lucid.ones(normalized_shape, device=input_.device)
+        has_weight = False
+    else:
+        has_weight = True
 
-    mean = input_.mean(axis=tuple(range(-len(normalized_shape), 0)), keepdims=True)
-    var = input_.var(axis=tuple(range(-len(normalized_shape), 0)), keepdims=True)
-
-    normalized = (input_ - mean) / lucid.sqrt(var + eps)
-    if weight is not None:
-        normalized *= weight.reshape(
-            (1,) * (input_.ndim - len(normalized_shape)) + normalized_shape
-        )
-    if bias is not None:
-        normalized += bias.reshape(
-            (1,) * (input_.ndim - len(normalized_shape)) + normalized_shape
-        )
+    if bias is None:
+        bias = lucid.zeros(normalized_shape, device=input_.device)
+        has_bias = False
+    else:
+        has_bias = True
 
-    return normalized
+    op = layer_norm_kernel(
+        normalized_shape, eps=eps, has_weight=has_weight, has_bias=has_bias
+    )
+    return op(input_, weight, bias)
 
 
 def instance_norm(
@@ -155,29 +152,23 @@ def group_norm(
     bias: Tensor | None,
     eps: float = 1e-5,
 ) -> Tensor:
-    N, C, *spatial_dims = input_.shape
-    assert C % num_groups == 0, "Number of channels must be divisible by num_groups"
-
-    group_size = C // num_groups
-    new_shape = (N, num_groups, group_size, *spatial_dims)
-    reshaped = input_.reshape(*new_shape)
-
-    axes = (2,) + tuple(range(3, reshaped.ndim))
-    mean = reshaped.mean(axis=axes, keepdims=True)
-    var = reshaped.var(axis=axes, keepdims=True)
-
-    normalized = (reshaped - mean) / lucid.sqrt(var + eps)
-    normalized = normalized.reshape(N, C, *spatial_dims)
-
-    if weight is not None:
-        weight = weight.reshape(1, C, *(1,) * len(spatial_dims))
-        normalized *= weight
+    C = input_.shape[1]
+    if weight is None:
+        weight = lucid.ones((C,), device=input_.device)
+        has_weight = False
+    else:
+        has_weight = True
 
-    if bias is not None:
-        bias = bias.reshape(1, C, *(1,) * len(spatial_dims))
-        normalized += bias
+    if bias is None:
+        bias = lucid.zeros((C,), device=input_.device)
+        has_bias = False
+    else:
+        has_bias = True
 
-    return normalized
+    op = group_norm_kernel(
+        num_groups=num_groups, eps=eps, has_weight=has_weight, has_bias=has_bias
+    )
+    return op(input_, weight, bias)
 
 
 def global_response_norm(

lucid/nn/functional/_pool.py

@@ -2,7 +2,7 @@ import math
 from typing import Literal
 
 from lucid._tensor import Tensor
-from lucid._backend.pool import avg_pool_nd_op, max_pool_nd_op
+from lucid.nn._kernel.pool import pool_nd_kernel
 
 
 def avg_pool1d(
@@ -11,7 +11,7 @@ def avg_pool1d(
     stride: int | tuple[int] = 1,
     padding: int | tuple[int] = 0,
 ) -> Tensor:
-    return avg_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="avg")(input_)
 
 
 def avg_pool2d(
@@ -20,7 +20,7 @@ def avg_pool2d(
     stride: int | tuple[int, int] = 1,
     padding: int | tuple[int, int] = 0,
 ) -> Tensor:
-    return avg_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="avg")(input_)
 
 
 def avg_pool3d(
@@ -29,7 +29,7 @@ def avg_pool3d(
     stride: int | tuple[int, int, int] = 1,
     padding: int | tuple[int, int, int] = 0,
 ) -> Tensor:
-    return avg_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="avg")(input_)
 
 
 def max_pool1d(
@@ -38,7 +38,7 @@ def max_pool1d(
     stride: int | tuple[int] = 1,
     padding: int | tuple[int] = 0,
 ) -> Tensor:
-    return max_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="max")(input_)
 
 
 def max_pool2d(
@@ -47,7 +47,7 @@ def max_pool2d(
     stride: int | tuple[int, int] = 1,
     padding: int | tuple[int, int] = 0,
 ) -> Tensor:
-    return max_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="max")(input_)
 
 
 def max_pool3d(
@@ -56,7 +56,7 @@ def max_pool3d(
     stride: int | tuple[int, int, int] = 1,
     padding: int | tuple[int, int, int] = 0,
 ) -> Tensor:
-    return max_pool_nd_op(kernel_size, stride, padding)(input_)
+    return pool_nd_kernel(kernel_size, stride, padding, mode="max")(input_)
 
 
 def adaptive_pool1d(

lucid/nn/functional/_util.py

@@ -4,6 +4,8 @@ import lucid.nn.functional
 from lucid._tensor import Tensor
 from lucid.types import _Scalar, Numeric
 
+from lucid.nn._kernel.embedding import embedding_kernel
+
 
 def _interpolate_bilinear(
     input_: Tensor, size: tuple[int, int], align_corners: bool = False
@@ -129,7 +131,9 @@ def embedding(
     max_norm: float | None = None,
     norm_type: float = 2.0,
 ) -> Tensor:
-    output = weight[input_.astype(lucid.Int)]
+    indices = input_.astype(lucid.Int)
+    op = embedding_kernel()
+    output = op(indices, weight)
     if padding_idx is not None:
         mask = input_.data == padding_idx
         output *= 1 - mask[..., None]

lucid/nn/init/_dist.py

@@ -26,6 +26,7 @@ def _calculate_fan_in_and_fan_out(tensor: Tensor) -> tuple[int, int]:
 
 
 def _assign_like(tensor: Tensor, data: np.ndarray) -> None:
+    tensor._version += 1
     if tensor.is_cpu():
         tensor.data = np.asarray(data, dtype=tensor.data.dtype)
     else:

lucid/types.py

@@ -2,6 +2,7 @@ from typing import (
     Any,
     Callable,
     Protocol,
+    Self,
     Sequence,
     Literal,
     TypeAlias,
@@ -9,7 +10,6 @@ from typing import (
 )
 import re
 
-# NOTE: This module retains module independency.
 import numpy as np
 import mlx.core as mx
 
@@ -20,6 +20,8 @@ _Scalar = int | float | complex
 _NumPyArray: TypeAlias = np.ndarray
 _MLXArray: TypeAlias = mx.array
 
+_TensorData = _NumPyArray | _MLXArray
+
 _Gradient = _NumPyArray | _MLXArray | None
 
 _ArrayOrScalar = _Scalar | list[_Scalar] | _NumPyArray | _MLXArray
@@ -55,11 +57,14 @@ class _TensorLike(Protocol):
     _prev: list[_TensorLike]
     _backward_op: Any
     _backward_hooks: Any
+    _version: int
 
     def to(self, device: _DeviceType) -> None: ...
 
     def free(self) -> None: ...
 
+    def new_tensor(self) -> _TensorLike: ...
+
     def is_cpu(self) -> bool: ...
 
     def is_gpu(self) -> bool: ...
@@ -132,8 +137,18 @@ class Numeric:
 
         raise TypeError(f"Unsupported dtype: {dtype}")
 
+    def __eq__(self, other: Self) -> bool:
+        if self.base_dtype is not other.base_dtype:
+            return False
+        if self.is_bit_free:
+            return True if other.is_bit_free else False
+        return True if other.is_bit_free or self.bits == other.bits else False
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
     def __str__(self) -> str:
-        return self.base_dtype.__name__ + str(self.bits)
+        return self.base_dtype.__name__ + (str(self.bits) if self.bits else "")
 
     def __repr__(self) -> str:
         return (
@@ -148,11 +163,18 @@ Int16 = Numeric(int, bits=16)
 Int32 = Numeric(int, bits=32)
 Int64 = Numeric(int, bits=64)
 
+Char = Int8
+Short = Int16
+Long = Int64
+
 Float = Numeric(float, None)
 Float16 = Numeric(float, bits=16)
 Float32 = Numeric(float, bits=32)
 Float64 = Numeric(float, bits=64)
 
+Half = Float16
+Double = Float64
+
 Complex = Numeric(complex, None)
 Complex64 = Numeric(complex, bits=64)
 

{lucid_dl-2.11.0.dist-info → lucid_dl-2.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lucid-dl
-Version: 2.11.0
+Version: 2.11.2
 Summary: Lumerico's Comprehensive Interface for Deep Learning
 Home-page: https://github.com/ChanLumerico/lucid
 Author: ChanLumerico
@@ -8,7 +8,7 @@ Author-email: greensox284@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.12
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -33,7 +33,7 @@ Dynamic: summary
 [![PyPI Total Downloads](https://static.pepy.tech/personalized-badge/lucid-dl?period=total&units=NONE&left_color=GRAY&right_color=yellow&left_text=total%20downloads)](https://pepy.tech/projects/lucid-dl)
 ![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/badge/lines%20of%20code-27.7k-purple.svg)
+![Lines of Code](https://img.shields.io/badge/dynamic/json?label=Lines%20of%20Code&color=purple&url=https%3A%2F%2Fraw.githubusercontent.com%2FChanLumerico%2Flucid%2Fmain%2Floc%2Floc_badge.json&query=%24.linesOfCode&cacheSeconds=3600)
 
 **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.
 
@@ -48,9 +48,11 @@ Whether you're a student, educator, or an advanced researcher seeking to demysti
 
 ### 🔥 What's New
 
-- Now supports [**`Safetensors`**](https://github.com/huggingface/safetensors) for Lucid neural module porting along with the legacy `.lcd` format
+- Added various inplace tensor operations (e.g. `a.add_(b)`, `a.mul_(b)`)
 
-- Branched a Stand-alone Autograd Engine as `lucid.autograd`
+- Added **Noise Conditional Score Network(NCSN)** to `lucid.models.NCSN`
+
+- Branched a Stand-Alone Autograd Engine as `lucid.autograd`
 
   - Provides a generalized API of computing gradients:
     

{lucid_dl-2.11.0.dist-info → lucid_dl-2.11.2.dist-info}/RECORD

@@ -1,13 +1,11 @@
-lucid/__init__.py,sha256=Rd4OF5hgSNFuSzeB4--gfkRrrQpSEhYJ10-vV93YShk,9089
+lucid/__init__.py,sha256=EwNZkKALNS54RQw_D_1BtqbBo3kFMi4uSveSs6i-bdM,9161
 lucid/error.py,sha256=qnTiVuZm3c5-DIt-OOyobZ7RUm7E1K4NR0j998LG1ug,709
 lucid/port.py,sha256=Kt1YaSWef_eKF4KRj-UFhirvFC5urEESfYQ_BSlBZGE,3811
-lucid/types.py,sha256=7mkE4_kAn6I8bToqoNb4E5IKwVOjYMQ_kMXZB7O_KeA,4310
+lucid/types.py,sha256=XFeLUXhtMXGh9liRPB3X49PbJSK3bcOA6KN1gvCjksA,4818
 lucid/_backend/__init__.py,sha256=n1bnYdeb_bNDBKASWGywTRa0Ne9hMAkal3AuVZJgovI,5
-lucid/_backend/conv.py,sha256=EkU_AbNcSFJWwLzk7tY4OBaA5RUh44CgDcVGviH_AZA,16641
-lucid/_backend/core.py,sha256=TYuLbv5V-H3sxhgTjwUO2iPxJ6TIJjsYx8EugpUGJ2g,8531
-lucid/_backend/metal.py,sha256=I5EsTbb1Oc1qjr7YvPv1W92O5XNRmbTz0fiD5358Zhk,4158
-lucid/_backend/pool.py,sha256=SRmw9ZShpu9g7_SiZ-o1oLvIbf093ruCfdNCaLYLm3M,11207
-lucid/_func/__init__.py,sha256=fGd4Vv--Kuwrwc4w9ZSYEz3Bqb-O-kY5KSBKM6u0ndE,13705
+lucid/_backend/core.py,sha256=neZF9uQlwNp-yHeyi0IbKlN556O-lsqThsIFExsf8-Y,11791
+lucid/_backend/metal.py,sha256=vQegTENuPjeAM_EIXfuOpnIXZBeMbGVxCFvm4s-_NNo,4215
+lucid/_func/__init__.py,sha256=ZOA1hnnDwwXbAUoLInwsA_0sMet89bw3XlOlft7UqnA,17062
 lucid/_func/bfunc.py,sha256=HtU6T_SV6VdMFTKZ__EqWXP9UKGVPT5XkRdgGRtV2MA,20479
 lucid/_func/gfunc.py,sha256=_gEJnYnAYhcN6aV1Z6ArIOGTgd0NEB2_eM86tE6uq-Q,4866
 lucid/_func/ufunc.py,sha256=AnCSykuYC0fNNoZso-TM60Rlq_4c54uMYOG3BHdvy20,30261
@@ -15,18 +13,18 @@ lucid/_fusion/__init__.py,sha256=SVzLiFzs4m1mMOpefKDLFkYqV0zV5FGwFd9hEbUZtSo,68
 lucid/_fusion/base.py,sha256=d6nWuPjYxkie9Xrtbj3JVusnIN61PIoSFFSthJNm9os,3821
 lucid/_fusion/func.py,sha256=9tXzB-QNrx_AvNJiPto807faXKlzjuMG4o9gRgI5usc,1659
 lucid/_tensor/__init__.py,sha256=wFWAMhTnQwThNiBEIT4fcw4ryIm8A4AoR-m9KDhklOQ,40
-lucid/_tensor/tensor.py,sha256=kccMHLPi2aGpkjwzEb7SBpp3Hhbe1TZv3VUDUSOv2ik,13570
-lucid/_tensor/tensor_ops.py,sha256=5XtqcPbrkOb87pVTSOMNaje9K78tgLpsNdV8XXnbpHc,3991
+lucid/_tensor/base.py,sha256=pEeL4O-R_xFbugdBG8mWipP_pEhtIhWPSgAgHc51ZcQ,5262
+lucid/_tensor/tensor.py,sha256=BLqpVqxP657W8j-oq7la9IVzH5RZnvQDKEMsU1s5rjM,14821
 lucid/_util/__init__.py,sha256=NgOleItHJGVLdJlKHKfpzuSl3vofzJpNsZByHAYJmKs,6838
 lucid/_util/func.py,sha256=ZODVlGdAejMTJnwEls7yMCI5WJ9Thkb3RIq1WwQCS4E,44239
-lucid/autograd/__init__.py,sha256=uKuGXUUSF8rBx7iEuVA6a_AhY9wfkC82TPmc1AKbay4,6675
+lucid/autograd/__init__.py,sha256=hDoK_B2chRFVhoxsT4vxRKangzBEMWqF8gj2hdoTenk,6775
 lucid/data/__init__.py,sha256=qrDIQsnix5ZUEa0yrtomaaWbNJyJ3xEr2gdhRvg70_8,118
 lucid/data/_base.py,sha256=RM8xpBl8qFhm19n7eER_jOsRaxkL3rbOkwUvn6VetSE,5921
 lucid/data/_util.py,sha256=UsbliOrGmM0f1vqppoBPn3RSx53PIqcVx_yVOlHZB6A,1985
 lucid/datasets/__init__.py,sha256=vFlNOP38SSYG75_Yf0Jbyw3okSO7sY4wIjSxIzzIgWg,103
 lucid/datasets/_base.py,sha256=yeXPm3La3Beel7U_yPrxjXgGtjndJ3T6NYaQ2_H_Fak,1325
 lucid/datasets/cifar.py,sha256=Wf9r6PSgwFuuYsnZDEQOFNB-06AkqW4DrVsVPRyxEF0,3704
-lucid/datasets/mnist.py,sha256=mLjcp8Jx8987F21J13snH7cdG75qZRSHMuKYXV7QFt4,3739
+lucid/datasets/mnist.py,sha256=PUXW2UwmlXJFVJiNkI9Jm58Qe4qWHGA63znkk-y9INM,8603
 lucid/einops/__init__.py,sha256=9Dlmfw6PsIU9b_a89Zre4yV2rztRHPCL4QpsUnXJwjM,802
 lucid/einops/_func.py,sha256=XXsX9lse_0turKoFnOTtLdY6hBUi0gq_8K81G7nr80I,21026
 lucid/linalg/__init__.py,sha256=N-LrlC3qSsOMt6Ad1-PP3Qc3QH6EWNf5P50GBvwb9aQ,1118
@@ -60,8 +58,9 @@ lucid/models/imgclf/vgg.py,sha256=fWy78AAHJre3Msy4DK5nhQwThI-7frsdqRS-JYtFiXM,24
 lucid/models/imgclf/vit.py,sha256=NXzPIiyXxcE1-g25m36-_YwKnJZ0gl1-jf7G3V12jS0,3594
 lucid/models/imgclf/xception.py,sha256=Y7YKCzF_y4r864hLouW0eE7M-kxA59SiI3-iIFsXVhQ,3728
 lucid/models/imgclf/zfnet.py,sha256=brH5tHLVWTUfCqu-BwfFb0yZV9p5DmXN4O6cyP3U26U,1469
-lucid/models/imggen/__init__.py,sha256=bEKRZdPj4YNlyHJYAT1kNmyz0ezk7EAju8tCkDaPhWU,39
+lucid/models/imggen/__init__.py,sha256=J6MlEHqXxAYINbeQmyb85ev_IEOvQDTxTQjPgX6hdpY,59
 lucid/models/imggen/ddpm.py,sha256=Nyi5bp7WMzqZ8Xl2AXuLsMmdz9QSZifbbmMPMeY1YfQ,10752
+lucid/models/imggen/ncsn.py,sha256=TF_kqnXcPZx4C_eIBqwyeRf3jp7KtiHy3SxQDnbeCj4,13555
 lucid/models/imggen/vae.py,sha256=avR8W0rzIsUyJF6veJCIEHavRsPjJsSuTDqzO2wj6sU,4084
 lucid/models/objdet/__init__.py,sha256=y8_3gjSKlD8Pu0HYburcJ1FAOb4SG5eza_lg9SdFjy8,140
 lucid/models/objdet/detr.py,sha256=i-KbNoPA9nUuUVBAKRHER-NB6z_sFF5r3Y3oplRaJkI,30336
@@ -82,19 +81,27 @@ lucid/nn/fused.py,sha256=75fcXuo6fHSO-JtjuKhowhHSDr4qc5871WR63sUzH0g,5492
 lucid/nn/module.py,sha256=XvFWJ8NqXeZpr3RmKBQBz5eqT535Oi_7DaPN1Zi9gJc,21971
 lucid/nn/parameter.py,sha256=NQS65YKn2B59wZbZIoT1mpDsU_F08y3yLi7hmV1B6yo,1232
 lucid/nn/util.py,sha256=Yw1iBSPrGV_r_F51qpqLYdafNE_hyaA0DPWYP-rjaig,1699
-lucid/nn/functional/__init__.py,sha256=90Zi7jClPOiiSYx-Qkg0QTideKD6GigbWON9eFCoxzg,13869
-lucid/nn/functional/_activation.py,sha256=nQVwArvPuwkUpLMLCNABTw96Zgw9VsPB8SyXCL6t2LM,1331
-lucid/nn/functional/_attention.py,sha256=nrZF3-2AR03kNo1PGNszujhWlAVcab_FNQwOCWZT47I,946
-lucid/nn/functional/_conv.py,sha256=dbbnkZp88VYOhqJgklkREnfAknZyc19qF1rC46aLsRs,5798
+lucid/nn/_kernel/__init__.py,sha256=n1bnYdeb_bNDBKASWGywTRa0Ne9hMAkal3AuVZJgovI,5
+lucid/nn/_kernel/activation.py,sha256=mfe48Aw3_Hv0hZEVC7DxDw19XK9XSLfdCOvo2JcZz_o,5662
+lucid/nn/_kernel/attention.py,sha256=1k0gboLObMNVow2v3TwliXC_2v8uKf2o8jHYFuyQqcg,3699
+lucid/nn/_kernel/conv.py,sha256=TiY3EkUAmwFCI1aA8YVMoZJHIRrqmJAXZEPh1C7lons,16412
+lucid/nn/_kernel/embedding.py,sha256=uf_G0aKphxBEOtfR9DHXmSyqkDCwc6tJEBNMKt4CNOU,2390
+lucid/nn/_kernel/loss.py,sha256=UD0B5DZ3R98OPZUigHsctL0eAJch2rKQpn1uaI3fzGg,13935
+lucid/nn/_kernel/norm.py,sha256=261WtixerLxFISIroQw8l_zZ3X0b4c_eDy8QHHA-i4M,11992
+lucid/nn/_kernel/pool.py,sha256=IQh5hfKU4PUvnGS1ayorUmytB_vCSxcbAwBYlFKw0iI,10697
+lucid/nn/functional/__init__.py,sha256=NDxjFCqXJ0SZ9ehuK8VbNDPdObegx_YflCIHN6eo1L8,13943
+lucid/nn/functional/_activation.py,sha256=tLkFqAD2HRkuZqLu1qXRhN0EZtkXgeitt-VXD0ztqx4,1266
+lucid/nn/functional/_attention.py,sha256=B4-Ock4_yYds0WVpRHlJnBR8kw9sYCyVFWNIdX25wwA,1212
+lucid/nn/functional/_conv.py,sha256=Vx8K_eGa-yNxqOrudvyuLgPRYeT003UzNv8eCiLZQhM,5555
 lucid/nn/functional/_drop.py,sha256=99zcj-06BGHaAPEFHeXJWlfxa-jinZrKc5pteXYtxL0,2351
 lucid/nn/functional/_linear.py,sha256=0KPs14tdjTqJDhLaHTQp_OAOpDP0i-Pd4kJes2BTR9I,663
-lucid/nn/functional/_loss.py,sha256=H_IB08O-7XTBXVZwLgsgNA32zmUspOS0Hl5TqOkjlRk,3871
-lucid/nn/functional/_norm.py,sha256=vjPfSh0vRSE-nR3-CJPSm66ZYQycNd8mxm5Oz2DLwKw,5961
-lucid/nn/functional/_pool.py,sha256=ftzRSFCZB3LRQwN5HkNJSUyZJonYQhfOH4lwKa0cR9Y,4027
+lucid/nn/functional/_loss.py,sha256=b6KT8SrKe5lgAqlAmQnT00Hk7tvd-UcBPNryGYtTPWQ,3834
+lucid/nn/functional/_norm.py,sha256=yunKJttd3WTxXvzKuugL2LgHLmp-9dMxhHgQ9myLUzA,5041
+lucid/nn/functional/_pool.py,sha256=u6ykwqTZ38b9QPwUqFXpnPhOx2cc_9x9AfH0k26Y9pQ,4085
 lucid/nn/functional/_spatial.py,sha256=lazoSvVMFcauBWRbMOqmkgixA5bDes6scGHVWCgVmHE,3911
-lucid/nn/functional/_util.py,sha256=oaMbR76XuFrFtEjLCUEQBPgfFObP98WGnkGQLtFz2uk,4949
+lucid/nn/functional/_util.py,sha256=I2MvzuqPqZBC7Xo_rOq5d1R-f1Hqf7CtTKE06nudY60,5060
 lucid/nn/init/__init__.py,sha256=YFi-HD2TEglweJ-gyX3n4UVZYzd70gcUi1dBu6hnOAY,1533
-lucid/nn/init/_dist.py,sha256=ju3nayB2Mo2-VfngONn51ABnOsVxH-Vfnu_n-NkWFA4,2437
+lucid/nn/init/_dist.py,sha256=Tj9SKl43ZrJdv99X5qXUowdcts4f4D3tUk7RBmX5uCg,2462
 lucid/nn/modules/__init__.py,sha256=mol5Gfy-3ab5hBYZRxX0vjiI0w5VyKtBxVwj_vrOAZs,285
 lucid/nn/modules/activation.py,sha256=CpiKpzgZHoCp8UO5taCJ9BuwFz5mYUs0o1_TQcEwQbQ,2823
 lucid/nn/modules/attention.py,sha256=pZi7IGsNFu2xCmeLMuyWgveMyi2QXtaKRKQ70yAeE0c,4407
@@ -127,8 +134,8 @@ lucid/visual/__init__.py,sha256=6TuFDfmXTwpLyHl7_KqBfdzW6zqHjGzIFvymjFPlvjI,21
 lucid/visual/graph.py,sha256=YjpIDM_lloZARw3sCBiXPl_hT5A2gTk2fEHvwvJWXTk,4599
 lucid/weights/__init__.py,sha256=z1AikA3rOEeckWGkYWlcZkxNlJo9Xwa39PL6ly3hWnc,8801
 lucid/weights/__init__.pyi,sha256=lFonYC3cUx2Idolf3AEPnjFcyqcn3UDU84oJlZafqLY,3013
-lucid_dl-2.11.0.dist-info/licenses/LICENSE,sha256=vxRFYnVD1IeYtsvw-KmoElfqrjxKHv1h9YTvsG54loQ,1065
-lucid_dl-2.11.0.dist-info/METADATA,sha256=_wOx1Pjq_HgSvzL_4eMHGMsHz8cOwpvU9EpiFhYglco,12159
-lucid_dl-2.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lucid_dl-2.11.0.dist-info/top_level.txt,sha256=uzP_qBx9iNWIHKJRlElYcBLYVqMpdm9Q1Ma63QPYbFc,6
-lucid_dl-2.11.0.dist-info/RECORD,,
+lucid_dl-2.11.2.dist-info/licenses/LICENSE,sha256=vxRFYnVD1IeYtsvw-KmoElfqrjxKHv1h9YTvsG54loQ,1065
+lucid_dl-2.11.2.dist-info/METADATA,sha256=udbwTB1UUVhJNWAWTGG_aqKNovOu-Qb_iLTi_HVb13I,12312
+lucid_dl-2.11.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+lucid_dl-2.11.2.dist-info/top_level.txt,sha256=uzP_qBx9iNWIHKJRlElYcBLYVqMpdm9Q1Ma63QPYbFc,6
+lucid_dl-2.11.2.dist-info/RECORD,,

{lucid_dl-2.11.0.dist-info → lucid_dl-2.11.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any