broccoli-ml 9.5.1__py3-none-any.whl

broccoli/utils.py

@@ -0,0 +1,15 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class PadTensor(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self.args = args
+        self.kwargs = kwargs
+
+    def forward(self, x):
+        if sum(self.args[0]) == 0:
+            return x
+        else:
+            return F.pad(x, *self.args, **self.kwargs)

broccoli/vit.py

@@ -0,0 +1,600 @@
+import math
+from typing import Optional
+
+from .transformer import TransformerEncoder, FeedforwardBlock
+from .cnn import SpaceToDepth, calculate_output_spatial_size, spatial_tuple
+from .activation import ReLU, SquaredReLU, GELU, SwiGLU
+from .utils import PadTensor
+
+from einops import einsum
+from einops.layers.torch import Rearrange
+
+import torch
+import torch.nn as nn
+
+
+class GetCLSToken(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return x[:, 0, :]
+
+
+class SequencePool(nn.Module):
+    def __init__(self, d_model, linear_module=nn.Linear):
+        super().__init__()
+        self.attention = nn.Sequential(
+            *[
+                linear_module(d_model, 1),
+                Rearrange("batch seq 1 -> batch seq"),
+                nn.Softmax(dim=-1),
+            ]
+        )
+
+        self.reset_parameters()
+
+    def forward(self, x):
+        weights = self.attention(x)
+        return einsum(weights, x, "batch seq, batch seq d_model -> batch d_model")
+
+    def attention_scores(self, x):
+        return self.attention(x)
+
+    def reset_parameters(self):
+        # Iterate over modules in the sequential block
+        for module in self.attention:
+            if hasattr(module, "reset_parameters"):
+                module.reset_parameters()
+
+
+class ClassificationHead(nn.Module):
+    """
+    A general classification head for a ViT
+    """
+
+    def __init__(
+        self,
+        d_model,
+        n_classes,
+        logit_projection_layer=nn.Linear,
+        batch_norm_logits=True,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.summarize = GetCLSToken()
+
+        if d_model == n_classes:
+            # No need to project
+            self.projection = nn.Identity()
+        else:
+            self.projection = logit_projection_layer(d_model, n_classes)
+
+        if batch_norm_logits:
+            self.batch_norm = nn.BatchNorm1d(n_classes, affine=False)
+        else:
+            self.batch_norm = nn.Identity()
+
+        self.classification_process = nn.Sequential(
+            *[
+                self.summarize,
+                self.projection,
+                self.batch_norm,
+            ]
+        )
+
+        self.reset_parameters()
+
+    def forward(self, x):
+        return self.classification_process(x)
+
+    def reset_parameters(self):
+        for module in self.classification_process:
+            if hasattr(module, "reset_parameters"):
+                module.reset_parameters()
+
+
+class SequencePoolClassificationHead(ClassificationHead):
+    """
+    As described in [Hasani et al. (2021) *''Escaping the Big Data Paradigm with
+        Compact Transformers''*](https://arxiv.org/abs/2104.05704). It can be viewed
+        as a generalisation of average pooling.
+    """
+
+    def __init__(
+        self,
+        d_model,
+        n_classes,
+        logit_projection_layer=nn.Linear,
+        batch_norm_logits=True,
+    ):
+        super().__init__(
+            d_model,
+            n_classes,
+            logit_projection_layer=logit_projection_layer,
+            batch_norm_logits=batch_norm_logits,
+        )
+
+        self.summarize = SequencePool(d_model, logit_projection_layer)
+        # Rebuild the classification process with the correct summary module:
+        self.classification_process = nn.Sequential(
+            *[
+                self.summarize,
+                self.projection,
+                self.batch_norm,
+            ]
+        )
+
+        self.reset_parameters()
+
+
+class ViTEncoder(nn.Module):
+    """
+    Based on the Compact Convolutional Transformer (CCT) of [Hasani et al. (2021)
+        *''Escaping the Big Data Paradigm with Compact Transformers''*](
+        https://arxiv.org/abs/2104.05704). It's basically a convolutional neural
+        network leading into a transformer encoder. To make it like the full CCT
+        we would finish it of with a sequence pooling layer but we won't always
+        want to do that.
+    """
+
+    def __init__(
+        self,
+        input_size=(32, 32),
+        in_channels=3,
+        initial_batch_norm=True,
+        cnn=True,
+        cnn_out_channels=16,
+        cnn_kernel_size=3,
+        cnn_kernel_stride=1,
+        cnn_padding="same",
+        cnn_kernel_dilation=1,
+        cnn_kernel_groups=1,
+        cnn_activation: nn.Module = ReLU,
+        cnn_activation_kwargs: Optional[dict] = None,
+        cnn_dropout=0.0,
+        pooling_type="concat",  # max, average or concat
+        pooling_kernel_size=3,
+        pooling_kernel_stride=2,
+        pooling_padding=1,
+        transformer_feedforward_first=True,
+        transformer_initial_ff_residual_path=True,
+        transformer_initial_ff_linear_module_up=None,
+        transformer_initial_ff_linear_module_down=None,
+        transformer_initial_ff_dropout=None,
+        transformer_initial_ff_inner_dropout=None,
+        transformer_initial_ff_outer_dropout=None,
+        transformer_pre_norm=True,
+        transformer_normformer=False,
+        transformer_post_norm=False,
+        transformer_absolute_position_embedding=False,
+        transformer_relative_position_embedding=True,
+        transformer_embedding_size=256,
+        transformer_layers=7,
+        transformer_heads=4,
+        transformer_mlp_ratio=2,
+        transformer_utility_tokens=0,
+        transformer_return_utility_tokens=False,
+        transformer_activation: nn.Module = SquaredReLU,
+        transformer_activation_kwargs: Optional[dict] = None,
+        transformer_ff_linear_module_up=None,
+        transformer_ff_linear_module_down=None,
+        transformer_msa_scaling="d",
+        transformer_ff_dropout=0.0,
+        transformer_ff_inner_dropout=0.0,
+        transformer_ff_outer_dropout=0.0,
+        transformer_msa_dropout=0.1,
+        transformer_stochastic_depth=0.1,
+        transformer_checkpoint_ff=True,
+        linear_module=nn.Linear,
+    ):
+        super().__init__()
+
+        if cnn_activation_kwargs is not None:
+            self.cnn_activation = cnn_activation(**cnn_activation_kwargs)
+        else:
+            self.cnn_activation = cnn_activation()
+
+        if transformer_activation_kwargs is not None:
+            self.transformer_activation = transformer_activation(
+                **transformer_activation_kwargs
+            )
+        else:
+            self.transformer_activation = transformer_activation()
+
+        self.input_size = input_size
+        self.spatial_dimensions = len(self.input_size)
+
+        if self.spatial_dimensions == 1:
+            maxpoolxd = nn.MaxPool1d
+            avgpoolxd = nn.AvgPool1d
+            convxd = nn.Conv1d
+            batchnormxd = nn.BatchNorm1d
+            spatial_dim_names = "D1"
+        elif self.spatial_dimensions == 2:
+            maxpoolxd = nn.MaxPool2d
+            avgpoolxd = nn.AvgPool2d
+            convxd = nn.Conv2d
+            batchnormxd = nn.BatchNorm2d
+            spatial_dim_names = "D1 D2"
+        elif self.spatial_dimensions == 3:
+            maxpoolxd = nn.MaxPool3d
+            avgpoolxd = nn.AvgPool3d
+            convxd = nn.Conv3d
+            batchnormxd = nn.BatchNorm3d
+            spatial_dim_names = "D1 D2 D3"
+        else:
+            raise NotImplementedError(
+                "`input_size` must be a tuple of length 1, 2, or 3."
+            )
+
+        if cnn:
+            # This block rhymes:
+            if cnn_activation.__name__.endswith("GLU"):
+                cnn_out_channels *= 2
+            cnn_output_size = calculate_output_spatial_size(
+                input_size,
+                kernel_size=cnn_kernel_size,
+                stride=cnn_kernel_stride,
+                padding=cnn_padding,
+                dilation=cnn_kernel_dilation,
+            )
+            self.cnn = convxd(
+                in_channels,
+                cnn_out_channels,
+                cnn_kernel_size,
+                stride=cnn_kernel_stride,
+                padding=cnn_padding,
+                dilation=cnn_kernel_dilation,
+                groups=cnn_kernel_groups,
+                bias=True,
+                padding_mode="zeros",
+            )
+            cnn_activation_out_channels = cnn_out_channels
+            self.activate_and_dropout = nn.Sequential(
+                *[
+                    Rearrange(  # rearrange in case we're using XGLU activation
+                        f"N C {spatial_dim_names} -> N {spatial_dim_names} C"
+                    ),
+                    self.cnn_activation,
+                    Rearrange(f"N {spatial_dim_names} C -> N C {spatial_dim_names}"),
+                    nn.Dropout(cnn_dropout),
+                    batchnormxd(cnn_activation_out_channels),
+                ]
+            )
+        else:
+            self.cnn = nn.Identity()
+            self.activate_and_dropout = nn.Identity()
+            cnn_output_size = input_size
+            cnn_out_channels = in_channels
+            cnn_activation_out_channels = in_channels
+
+        pooling_kernel_voxels = math.prod(
+            spatial_tuple(pooling_kernel_size, self.spatial_dimensions)
+        )
+
+        pooling_output_size = (
+            cnn_output_size
+            if pooling_type is None
+            else calculate_output_spatial_size(
+                cnn_output_size,
+                kernel_size=pooling_kernel_size,
+                stride=pooling_kernel_stride,
+                padding=pooling_padding,
+                dilation=1,
+            )
+        )
+
+        if pooling_type is None:
+            pooling_out_channels = cnn_activation_out_channels
+            self.pool = nn.Identity()
+
+        elif pooling_type == "max":
+            pooling_out_channels = cnn_activation_out_channels
+            self.pool = maxpoolxd(
+                pooling_kernel_size,
+                stride=pooling_kernel_stride,
+                padding=pooling_padding,
+            )
+        elif pooling_type == "average":
+            pooling_out_channels = cnn_activation_out_channels
+            self.pool = avgpoolxd(
+                pooling_kernel_size,
+                stride=pooling_kernel_stride,
+                padding=pooling_padding,
+            )
+        elif pooling_type == "concat":
+            pooling_out_channels = pooling_kernel_voxels * cnn_activation_out_channels
+            self.pool = SpaceToDepth(
+                pooling_kernel_size,
+                stride=pooling_kernel_stride,
+                padding=pooling_padding,
+                spatial_dimensions=self.spatial_dimensions,
+            )
+        else:
+            raise NotImplementedError(
+                "Pooling type must be max, average, concat or None"
+            )
+
+        self.pooling_channels_padding = PadTensor(
+            (0, max(0, transformer_embedding_size - pooling_out_channels))
+        )
+
+        self.sequence_length = math.prod(pooling_output_size)  # One token per voxel
+
+        if transformer_layers > 0:
+            self.transformer = TransformerEncoder(
+                self.sequence_length,
+                transformer_embedding_size,
+                transformer_layers,
+                transformer_heads,
+                absolute_position_embedding=transformer_absolute_position_embedding,
+                relative_position_embedding=transformer_relative_position_embedding,
+                source_size=pooling_output_size,
+                mlp_ratio=transformer_mlp_ratio,
+                activation=transformer_activation,
+                activation_kwargs=transformer_activation_kwargs,
+                ff_linear_module_up=transformer_ff_linear_module_up,
+                ff_linear_module_down=transformer_ff_linear_module_down,
+                msa_scaling=transformer_msa_scaling,
+                ff_dropout=transformer_ff_dropout,
+                ff_inner_dropout=transformer_ff_inner_dropout,
+                ff_outer_dropout=transformer_ff_outer_dropout,
+                msa_dropout=transformer_msa_dropout,
+                stochastic_depth=transformer_stochastic_depth,
+                causal=False,
+                linear_module=linear_module,
+                utility_tokens=transformer_utility_tokens,
+                return_utility_tokens=transformer_return_utility_tokens,
+                pre_norm=transformer_pre_norm,
+                normformer=transformer_normformer,
+                post_norm=transformer_post_norm,
+                checkpoint_ff=transformer_checkpoint_ff,
+            )
+        else:
+            self.transformer = nn.Identity()
+
+        if transformer_feedforward_first:
+            self.initial_ff = FeedforwardBlock(
+                max(transformer_embedding_size, pooling_out_channels),
+                transformer_mlp_ratio,
+                transformer_embedding_size,
+                activation=transformer_activation,
+                activation_kwargs=transformer_activation_kwargs,
+                dropout=(
+                    # First truthy assigned value
+                    transformer_initial_ff_dropout
+                    if transformer_initial_ff_dropout is not None
+                    else transformer_ff_dropout
+                ),
+                inner_dropout=(
+                    # First truthy assigned value
+                    transformer_initial_ff_inner_dropout
+                    if transformer_initial_ff_inner_dropout is not None
+                    else transformer_ff_inner_dropout
+                ),
+                outer_dropout=(
+                    # First truthy assigned value
+                    transformer_initial_ff_outer_dropout
+                    if transformer_initial_ff_outer_dropout is not None
+                    else transformer_ff_outer_dropout
+                ),
+                linear_module_up=(
+                    # First truthy assigned value
+                    transformer_initial_ff_linear_module_up
+                    or transformer_ff_linear_module_up
+                    or linear_module
+                ),
+                linear_module_down=(
+                    # First truthy assigned value
+                    transformer_initial_ff_linear_module_down
+                    or transformer_ff_linear_module_down
+                    or linear_module
+                ),
+                pre_norm=transformer_pre_norm,
+                normformer=transformer_normformer,
+                post_norm=transformer_post_norm,
+                residual_path=transformer_initial_ff_residual_path,
+                checkpoint=transformer_checkpoint_ff,
+            )
+        else:
+            self.initial_ff = nn.Identity()
+
+        self.encoder = nn.Sequential(
+            *[
+                batchnormxd(in_channels) if initial_batch_norm else nn.Identity(),
+                self.cnn,
+                self.activate_and_dropout,
+                self.pool,
+                Rearrange(  # for transformer
+                    f"N C {spatial_dim_names} -> N ({spatial_dim_names}) C"
+                ),
+                self.pooling_channels_padding,
+                self.initial_ff,
+                self.transformer,
+            ]
+        )
+
+        self.reset_parameters()
+
+    def forward(self, x):
+        return self.encoder(x)
+
+    def attention_logits(self, x):
+        x = self.encoder[:-1](x)
+        return self.encoder[-1].attention_logits(x)
+
+    def reset_parameters(self):
+        for module in self.encoder:
+            if hasattr(module, "reset_parameters"):
+                module.reset_parameters()
+
+
+class ViT(nn.Module):
+    """
+    ...
+    """
+
+    def __init__(
+        self,
+        input_size=(32, 32),
+        image_classes=100,
+        in_channels=3,
+        initial_batch_norm=True,
+        cnn=True,
+        cnn_out_channels=16,
+        cnn_kernel_size=3,
+        cnn_kernel_stride=1,
+        cnn_padding="same",
+        cnn_kernel_dilation=1,
+        cnn_kernel_groups=1,
+        cnn_activation: nn.Module = ReLU,
+        cnn_activation_kwargs: Optional[dict] = None,
+        cnn_dropout=0.0,
+        pooling_type="concat",  # max, average or concat
+        pooling_kernel_size=3,
+        pooling_kernel_stride=2,
+        pooling_padding=1,
+        transformer_feedforward_first=True,
+        transformer_initial_ff_residual_path=True,
+        transformer_initial_ff_linear_module_up=None,
+        transformer_initial_ff_linear_module_down=None,
+        transformer_initial_ff_dropout=None,
+        transformer_initial_ff_inner_dropout=None,
+        transformer_initial_ff_outer_dropout=None,
+        transformer_pre_norm=True,
+        transformer_normformer=False,
+        transformer_post_norm=False,
+        transformer_absolute_position_embedding=False,
+        transformer_relative_position_embedding=True,
+        transformer_embedding_size=256,
+        transformer_layers=7,
+        transformer_heads=4,
+        transformer_mlp_ratio=2,
+        transformer_utility_tokens=0,
+        transformer_return_utility_tokens=False,
+        transformer_activation: nn.Module = SquaredReLU,
+        transformer_activation_kwargs: Optional[dict] = None,
+        transformer_ff_linear_module_up=None,
+        transformer_ff_linear_module_down=None,
+        transformer_msa_scaling="d",
+        transformer_ff_dropout=0.0,
+        transformer_ff_inner_dropout=0.0,
+        transformer_ff_outer_dropout=0.0,
+        transformer_msa_dropout=0.1,
+        transformer_stochastic_depth=0.1,
+        transformer_checkpoint_ff=True,
+        head=SequencePoolClassificationHead,
+        batch_norm_logits=True,
+        logit_projection_layer=nn.Linear,
+        linear_module=nn.Linear,
+    ):
+
+        super().__init__()
+
+        if isinstance(cnn_activation, str):
+            cnn_activation = {
+                "ReLU": ReLU,
+                "SquaredReLU": SquaredReLU,
+                "GELU": GELU,
+                "SwiGLU": SwiGLU,
+            }[cnn_activation]
+
+        if isinstance(transformer_activation, str):
+            transformer_activation = {
+                "ReLU": ReLU,
+                "SquaredReLU": SquaredReLU,
+                "GELU": GELU,
+                "SwiGLU": SwiGLU,
+            }[transformer_activation]
+
+        self.encoder = ViTEncoder(
+            input_size=input_size,
+            initial_batch_norm=initial_batch_norm,
+            in_channels=in_channels,
+            cnn=cnn,
+            cnn_out_channels=cnn_out_channels,
+            cnn_kernel_size=cnn_kernel_size,
+            cnn_kernel_stride=cnn_kernel_stride,
+            cnn_padding=cnn_padding,
+            cnn_kernel_dilation=cnn_kernel_dilation,
+            cnn_kernel_groups=cnn_kernel_groups,
+            cnn_activation=cnn_activation,
+            cnn_activation_kwargs=cnn_activation_kwargs,
+            cnn_dropout=cnn_dropout,
+            pooling_type=pooling_type,
+            pooling_kernel_size=pooling_kernel_size,
+            pooling_kernel_stride=pooling_kernel_stride,
+            pooling_padding=pooling_padding,
+            transformer_feedforward_first=transformer_feedforward_first,
+            transformer_initial_ff_residual_path=transformer_initial_ff_residual_path,
+            transformer_initial_ff_linear_module_up=transformer_initial_ff_linear_module_up,
+            transformer_initial_ff_linear_module_down=transformer_initial_ff_linear_module_down,
+            transformer_initial_ff_dropout=transformer_initial_ff_dropout,
+            transformer_initial_ff_inner_dropout=transformer_initial_ff_inner_dropout,
+            transformer_initial_ff_outer_dropout=transformer_initial_ff_outer_dropout,
+            transformer_pre_norm=transformer_pre_norm,
+            transformer_normformer=transformer_normformer,
+            transformer_post_norm=transformer_post_norm,
+            transformer_absolute_position_embedding=transformer_absolute_position_embedding,
+            transformer_relative_position_embedding=transformer_relative_position_embedding,
+            transformer_embedding_size=transformer_embedding_size,
+            transformer_layers=transformer_layers,
+            transformer_heads=transformer_heads,
+            transformer_mlp_ratio=transformer_mlp_ratio,
+            transformer_utility_tokens=transformer_utility_tokens,
+            transformer_return_utility_tokens=transformer_return_utility_tokens,
+            transformer_activation=transformer_activation,
+            transformer_activation_kwargs=transformer_activation_kwargs,
+            transformer_ff_linear_module_up=transformer_ff_linear_module_up,
+            transformer_ff_linear_module_down=transformer_ff_linear_module_down,
+            transformer_msa_scaling=transformer_msa_scaling,
+            transformer_ff_dropout=transformer_ff_dropout,
+            transformer_ff_inner_dropout=transformer_ff_inner_dropout,
+            transformer_ff_outer_dropout=transformer_ff_outer_dropout,
+            transformer_msa_dropout=transformer_msa_dropout,
+            transformer_stochastic_depth=transformer_stochastic_depth,
+            transformer_checkpoint_ff=transformer_checkpoint_ff,
+            linear_module=linear_module,
+        )
+
+        self.pool = head(
+            transformer_embedding_size,
+            image_classes,
+            logit_projection_layer=logit_projection_layer,
+            batch_norm_logits=batch_norm_logits,
+        )
+
+        self.reset_parameters()
+
+    @property
+    def sequence_length(self):
+        return self.encoder.sequence_length
+
+    def forward(self, x):
+        return self.pool(self.encoder(x))
+
+    def attention_logits(self, x):
+        return self.encoder.attention_logits(x)
+
+    def pool_attention(self, x):
+        if hasattr(self.pool.summarize, "attention"):
+            return self.pool.summarize.attention(self.encoder(x))
+        else:
+            raise NotImplementedError(
+                "`pool_attention` is currently only implemented where"
+                " head class is SequencePoolClassificationHead"
+            )
+
+    def head_to_utility_token_attention_logits(self, x):
+        all_attention = self.attention_logits(x)
+        batch_averages = torch.mean(all_attention, dim=0, keepdim=False)
+        sequence_averages = torch.mean(batch_averages, dim=-1, keepdim=False)
+        n_utility_tokens = self.encoder.encoder[-1]._utility_tokens
+        return sequence_averages[
+            :, :, :n_utility_tokens
+        ]  # (layer, head, utility_tokens)
+
+    def reset_parameters(self):
+        self.encoder.reset_parameters()
+        self.pool.reset_parameters()

broccoli_ml-9.5.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 nicholasbailey87
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

broccoli_ml-9.5.1.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.3
+Name: broccoli-ml
+Version: 9.5.1
+Summary: Some useful Pytorch models, circa 2025
+License: MIT
+Author: Nicholas Bailey
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: einops (>=0.8.1,<0.9.0)
+Description-Content-Type: text/markdown
+
+# broccoli
+
+Some useful PyTorch models, circa 2025.
+
+![broccoli](broccoli.png "Image of a rockstar made of broccoli")
+
+# Getting started
+
+You can install broccoli with
+
+```
+pip install broccoli-ml
+```
+
+PyTorch is a peer dependency of `broccoli`, which means
+  * You will need to make sure you have PyTorch installed in order to use `broccoli`
+  * PyTorch will **not** be installed automatically when you install `broccoli`
+
+We take this approach because PyTorch versioning is environment-specific and we don't know where you will want to use `broccoli`. If we automatically install PyTorch for you, there's a good chance we would get it wrong!
+
+Therefore, please also make sure you install PyTorch.
+
+# Usage examples
+
+...

broccoli_ml-9.5.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+broccoli/__init__.py,sha256=tmyspsVxqPZHRQCY_NRwpW4SMNBbtE8E_8z7l-SAzSo,127
+broccoli/activation.py,sha256=nrpTOrpg9k23_E4AJWy7VlXXAJCtCJCOR-TonEWJr04,3218
+broccoli/cnn.py,sha256=WjoPDSpe3ttwxCBNfCVRdaCHvbeZ7G-a5_i8fUsK_d8,4889
+broccoli/linear.py,sha256=i4U7ZC4ZWEH82YpDasx0Qs1pc3gkyL-3ajuyKCbsGTM,12649
+broccoli/rope.py,sha256=GRqApBNmYCFaDak0WL1xE_BC5CTTYKQU_PBdeTcQcjc,12557
+broccoli/tensor.py,sha256=um8mrxkYbvNDo-QvHlmJm8Aw6qcngOlUZPoAk_PMReA,4480
+broccoli/transformer.py,sha256=ULk-QQX3hAI14-aCKhp9QSebzX4KUjlisEGup2Eycck,25565
+broccoli/utils.py,sha256=oOWzn6dJ5nC_9r4zq0emmfmaYACJXJNFS48AOpW2jqc,358
+broccoli/vit.py,sha256=sC6K3FK3a8ojOgvNWSWhuZHBtnFrrTQbsDdlagcKJH4,22224
+broccoli_ml-9.5.1.dist-info/LICENSE,sha256=0BAzJE5BqQ7Iixp_AFdB2W1uO-HCRX-Qfun8PHt6yVM,1073
+broccoli_ml-9.5.1.dist-info/METADATA,sha256=HXRWnuc_-Gs_g37_RP3-POTLmi7sZamlzYv5SJEun1Y,1368
+broccoli_ml-9.5.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+broccoli_ml-9.5.1.dist-info/RECORD,,

broccoli_ml-9.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any