typeras 0.1.0__py3-none-any.whl

typeras/__init__.py

@@ -0,0 +1,11 @@
+from importlib.metadata import version
+
+from typeras import callbacks as callbacks
+from typeras import datasets as datasets
+from typeras import layers as layers
+from typeras import losses as losses
+from typeras import metrics as metrics
+from typeras import models as models
+from typeras import optimizers as optimizers
+
+__version__ = version("typeras")

typeras/callbacks/__init__.py

@@ -0,0 +1,2 @@
+from typeras.callbacks.callback import Callback as Callback
+from typeras.callbacks.progress_bar import ProgressBar as ProgressBar

typeras/callbacks/callback.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typeras.models.model import Model
+
+
+class Callback(ABC):
+    def __init__(self) -> None:
+        self._model = None
+
+    @property
+    def model(self) -> Model:
+        if self._model is None:
+            raise RuntimeError
+        return self._model
+
+    def build(self, model: Model) -> None:
+        self._model = model
+
+    def on_train_epoch_end(self, epoch: int, logs: dict[str, float]) -> None:
+        pass
+
+    def on_test_end(self, logs: dict[str, float]) -> None:
+        pass

typeras/callbacks/progress_bar.py

@@ -0,0 +1,16 @@
+from typeras.callbacks.callback import Callback
+
+
+class ProgressBar(Callback):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def on_train_epoch_end(self, epoch: int, logs: dict[str, float]) -> None:
+        log = f"Epoch {epoch + 1:{len(str(self.model.epochs))}d}/{self.model.epochs}: "
+        log += " - ".join(f"{k}: {v:.4f}" for k, v in logs.items())
+        print(log)
+
+    def on_test_end(self, logs: dict[str, float]) -> None:
+        log = "Evaluation: "
+        log += " - ".join(f"{k}: {v:.4f}" for k, v in logs.items())
+        print(log)

typeras/datasets/__init__.py

@@ -0,0 +1 @@
+from typeras.datasets import breast_cancer as breast_cancer

typeras/datasets/breast_cancer.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+from typing import Annotated
+
+import polars as pl
+import requests
+from dltype import FloatTensor, IntTensor, dltyped
+from torch import Tensor
+from typeguard import typechecked
+
+URL = "https://assets.startown.ai/datasets/breast-cancer/data.csv"
+
+
+@dltyped()
+@typechecked
+def load_data(
+    path: str | Path = "~/.typeras/datasets/breast_cancer",
+) -> tuple[
+    Annotated[Tensor, FloatTensor["n_samples=569 n_features=30"]],
+    Annotated[Tensor, IntTensor["n_samples=569 n_targets=1"]],
+]:
+    path = Path(path).expanduser()
+    path.mkdir(parents=True, exist_ok=True)
+
+    data_file = path / "data.csv"
+    if not data_file.exists():
+        response = requests.get(URL, timeout=30)
+        response.raise_for_status()
+        data_file.write_text(response.text)
+
+    df = pl.read_csv(data_file)
+    df = df.with_columns(pl.col("diagnosis").replace(["B", "M"], [0, 1]).cast(pl.Int64))
+
+    x = df.select(pl.col(pl.Float64)).to_torch(dtype=pl.Float32)
+    y = df.get_column("diagnosis").to_torch().unsqueeze(1)
+
+    return x, y

typeras/layers/__init__.py

@@ -0,0 +1,5 @@
+from typeras.layers import activations as activations
+from typeras.layers.activations.sigmoid import Sigmoid as Sigmoid
+from typeras.layers.dense import Dense as Dense
+from typeras.layers.identity import Identity as Identity
+from typeras.layers.layer import Layer as Layer

typeras/layers/activations/__init__.py

@@ -0,0 +1 @@
+from typeras.layers.activations.sigmoid import Sigmoid as Sigmoid

typeras/layers/activations/sigmoid.py

@@ -0,0 +1,20 @@
+from typing import Annotated
+
+from dltype import FloatTensor, dltyped
+from torch import Tensor, nn
+from typeguard import typechecked
+
+from typeras.layers.layer import Layer
+
+
+@typechecked
+class Sigmoid(Layer):
+    def __init__(self, name: str = "sigmoid") -> None:
+        super().__init__(name)
+
+    @dltyped()
+    def call(
+        self,
+        x: Annotated[Tensor, FloatTensor["..."]],
+    ) -> Annotated[Tensor, FloatTensor["..."]]:
+        return nn.Sigmoid()(x)

typeras/layers/dense.py

@@ -0,0 +1,60 @@
+from typing import Annotated
+
+from dltype import FloatTensor, dltyped
+from torch import Tensor, nn
+from typeguard import typechecked
+
+from typeras.layers.identity import Identity
+from typeras.layers.layer import Layer
+
+
+@typechecked
+class Dense(Layer):
+    def __init__(
+        self,
+        units: int,
+        activation: Layer | None = None,
+        use_bias: bool = True,
+        name: str = "dense",
+    ) -> None:
+        super().__init__(name)
+        self._units = units
+        self._activation = activation or Identity()
+        self._use_bias = use_bias
+
+        self._linear = None
+
+    @property
+    def units(self) -> int:
+        return self._units
+
+    @property
+    def activation(self) -> Layer:
+        return self._activation
+
+    @property
+    def use_bias(self) -> bool:
+        return self._use_bias
+
+    @property
+    def linear(self) -> nn.Linear:
+        if self._linear is None:
+            raise RuntimeError
+        return self._linear
+
+    def build(self, input_shape: tuple[int, ...]) -> None:
+        if self._is_built:
+            return
+
+        self._linear = nn.Linear(input_shape[-1], self.units, self.use_bias)
+        self._is_built = True
+
+    @dltyped(scope_provider="self")
+    def call(
+        self,
+        x: Annotated[Tensor, FloatTensor["... in_features"]],
+    ) -> Annotated[Tensor, FloatTensor["... out_features"]]:
+        return self.activation(self.linear(x))
+
+    def get_dltype_scope(self) -> dict[str, int]:
+        return {"out_features": self.units}

typeras/layers/identity.py

@@ -0,0 +1,20 @@
+from typing import Annotated
+
+from dltype import FloatTensor, dltyped
+from torch import Tensor, nn
+from typeguard import typechecked
+
+from typeras.layers.layer import Layer
+
+
+@typechecked
+class Identity(Layer):
+    def __init__(self, name: str = "identity") -> None:
+        super().__init__(name)
+
+    @dltyped()
+    def call(
+        self,
+        x: Annotated[Tensor, FloatTensor["..."]],
+    ) -> Annotated[Tensor, FloatTensor["..."]]:
+        return nn.Identity()(x)

typeras/layers/layer.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+from torch import Tensor, nn
+
+
+class Layer(ABC, nn.Module):
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self._name = name
+        self._is_built = False
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def is_built(self) -> bool:
+        return self._is_built
+
+    def build(self, input_shape: tuple[int, ...]) -> None:
+        if self._is_built:
+            return
+        self._is_built = True
+
+    @abstractmethod
+    def call(self, x: Tensor) -> Tensor: ...
+
+    def forward(self, x: Tensor) -> Tensor:
+        self.build(x.shape)
+        return self.call(x)

typeras/losses/__init__.py

@@ -0,0 +1,2 @@
+from typeras.losses.crossentropies import BinaryCrossentropy as BinaryCrossentropy
+from typeras.losses.loss import Loss as Loss

typeras/losses/crossentropies.py

@@ -0,0 +1,84 @@
+from typing import Annotated
+
+import torch
+from dltype import FloatTensor, IntTensor, dltyped
+from torch import Tensor, nn
+from typeguard import typechecked
+
+from typeras.losses.loss import Loss
+
+
+@typechecked
+class BinaryCrossentropy(Loss):
+    def __init__(
+        self,
+        from_logits: bool = False,
+        name: str = "binary_crossentropy",
+    ) -> None:
+        super().__init__(name)
+        self._from_logits = from_logits
+
+        self._value_batch = torch.tensor([])
+        self._value_sum = torch.tensor(0.0)
+        self._total = torch.tensor(0)
+        self._criterion = (
+            nn.BCELoss(reduction="none")
+            if not from_logits
+            else nn.BCEWithLogitsLoss(reduction="none")
+        )
+
+    @property
+    def from_logits(self) -> bool:
+        return self._from_logits
+
+    @property
+    @dltyped()
+    def value_batch(self) -> Annotated[Tensor, FloatTensor["batch_size n_features=1"]]:
+        return self._value_batch
+
+    @property
+    @dltyped()
+    def value_sum(self) -> Annotated[Tensor, FloatTensor[None]]:
+        return self._value_sum
+
+    @property
+    @dltyped()
+    def total(self) -> Annotated[Tensor, IntTensor[None]]:
+        return self._total
+
+    @property
+    def criterion(self) -> nn.BCELoss | nn.BCEWithLogitsLoss:
+        return self._criterion
+
+    @property
+    @dltyped()
+    def value(self) -> Annotated[Tensor, FloatTensor[None]]:
+        if self.total == 0:
+            return torch.tensor(0.0)
+        return self.value_sum / self.total
+
+    @dltyped()
+    def call(
+        self,
+        y_pred: Annotated[Tensor, FloatTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> Annotated[Tensor, FloatTensor[None]]:
+        return self.criterion(y_pred, y_true.float()).mean()
+
+    @dltyped()
+    def update(
+        self,
+        y_pred: Annotated[Tensor, FloatTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> None:
+        self._value_batch = self.criterion(y_pred, y_true.float())
+        self._value_sum += self.value_batch.detach().sum()
+        self._total += y_pred.size(0)
+
+    def reset(self) -> None:
+        self._value_batch = torch.tensor([])
+        self._value_sum = torch.tensor(0.0)
+        self._total = torch.tensor(0)
+
+    def backward(self) -> None:
+        self.value_batch.mean().backward()

typeras/losses/loss.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+
+from torch import Tensor
+
+
+class Loss(ABC):
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    def __call__(self, y_pred: Tensor, y_true: Tensor) -> Tensor:
+        return self.call(y_pred, y_true)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    @abstractmethod
+    def value(self) -> Tensor: ...
+
+    @abstractmethod
+    def call(self, y_pred: Tensor, y_true: Tensor) -> Tensor: ...
+
+    @abstractmethod
+    def update(self, y_pred: Tensor, y_true: Tensor) -> None: ...
+
+    @abstractmethod
+    def reset(self) -> None: ...
+
+    @abstractmethod
+    def backward(self) -> None: ...

typeras/metrics/__init__.py

@@ -0,0 +1,2 @@
+from typeras.metrics.accuracies import Accuracy as Accuracy
+from typeras.metrics.accuracies import BinaryAccuracy as BinaryAccuracy

typeras/metrics/accuracies.py

@@ -0,0 +1,110 @@
+from typing import Annotated
+
+import torch
+from dltype import FloatTensor, IntTensor, dltyped
+from torch import Tensor
+from typeguard import typechecked
+
+from typeras.metrics.metric import Metric
+
+
+@typechecked
+class Accuracy(Metric):
+    def __init__(self, name: str = "accuracy") -> None:
+        super().__init__(name)
+        self._count = torch.tensor(0)
+        self._total = torch.tensor(0)
+
+    @property
+    @dltyped()
+    def count(self) -> Annotated[Tensor, IntTensor[None]]:
+        return self._count
+
+    @property
+    @dltyped()
+    def total(self) -> Annotated[Tensor, IntTensor[None]]:
+        return self._total
+
+    @property
+    @dltyped()
+    def value(self) -> Annotated[Tensor, FloatTensor[None]]:
+        if self.total == 0:
+            return torch.tensor(0.0)
+        return self.count / self.total
+
+    @dltyped()
+    def call(
+        self,
+        y_pred: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> Annotated[Tensor, FloatTensor[None]]:
+        count = (y_pred == y_true).long().sum()
+        total = y_pred.size(0)
+        return count / total
+
+    @dltyped()
+    def update(
+        self,
+        y_pred: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> None:
+        self._count += (y_pred == y_true).long().sum()
+        self._total += y_pred.size(0)
+
+    def reset(self) -> None:
+        self._count = torch.tensor(0)
+        self._total = torch.tensor(0)
+
+
+@typechecked
+class BinaryAccuracy(Metric):
+    def __init__(self, threshold: float = 0.5, name: str = "binary_accuracy") -> None:
+        super().__init__(name)
+        self._threshold = torch.tensor(float(threshold))
+        self._count = torch.tensor(0)
+        self._total = torch.tensor(0)
+
+    @property
+    @dltyped()
+    def threshold(self) -> Annotated[Tensor, FloatTensor[None]]:
+        return self._threshold
+
+    @property
+    @dltyped()
+    def count(self) -> Annotated[Tensor, IntTensor[None]]:
+        return self._count
+
+    @property
+    @dltyped()
+    def total(self) -> Annotated[Tensor, IntTensor[None]]:
+        return self._total
+
+    @property
+    @dltyped()
+    def value(self) -> Annotated[Tensor, FloatTensor[None]]:
+        if self.total == 0:
+            return torch.tensor(0.0)
+        return self.count / self.total
+
+    @dltyped()
+    def call(
+        self,
+        y_pred: Annotated[Tensor, FloatTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> Annotated[Tensor, FloatTensor[None]]:
+        count = ((y_pred > self.threshold) == y_true).long().sum()
+        total = y_pred.size(0)
+        return count / total
+
+    @dltyped()
+    def update(
+        self,
+        y_pred: Annotated[Tensor, FloatTensor["batch_size n_features=1"]],
+        y_true: Annotated[Tensor, IntTensor["batch_size n_features=1"]],
+    ) -> None:
+        self._count += ((y_pred > self.threshold) == y_true).long().sum()
+        self._total += y_pred.size(0)
+
+    def reset(self) -> None:
+        self._count = torch.tensor(0)
+        self._total = torch.tensor(0)

typeras/metrics/metric.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+
+from torch import Tensor
+
+
+class Metric(ABC):
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    def __call__(self, y_pred: Tensor, y_true: Tensor) -> Tensor:
+        return self.call(y_pred, y_true)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    @abstractmethod
+    def value(self) -> Tensor: ...
+
+    @abstractmethod
+    def call(self, y_pred: Tensor, y_true: Tensor) -> Tensor: ...
+
+    @abstractmethod
+    def update(self, y_pred: Tensor, y_true: Tensor) -> None: ...
+
+    @abstractmethod
+    def reset(self) -> None: ...

typeras/models/__init__.py

@@ -0,0 +1 @@
+from typeras.models.model import Model as Model

typeras/models/model.py

@@ -0,0 +1,178 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Annotated
+
+import torch
+from dltype import FloatTensor, IntTensor, dltyped
+from torch import Tensor, nn
+from torch.utils.data import DataLoader, TensorDataset
+from typeguard import typechecked
+
+from typeras.callbacks.callback import Callback
+from typeras.losses.loss import Loss
+from typeras.metrics.metric import Metric
+from typeras.optimizers.optimizer import Optimizer
+
+
+@typechecked
+class Model(ABC, nn.Module):
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self._name = name
+        self._optimizer = None
+        self._loss = None
+        self._metrics = None
+        self._is_built = False
+        self._batch_size = 32
+        self._epochs = 1
+        self._callbacks = []
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def optimizer(self) -> Optimizer:
+        if self._optimizer is None:
+            raise RuntimeError
+        return self._optimizer
+
+    @property
+    def loss(self) -> Loss:
+        if self._loss is None:
+            raise RuntimeError
+        return self._loss
+
+    @property
+    def metrics(self) -> list[Metric]:
+        if self._metrics is None:
+            raise RuntimeError
+        return self._metrics
+
+    @property
+    def batch_size(self) -> int:
+        return self._batch_size
+
+    @property
+    def epochs(self) -> int:
+        return self._epochs
+
+    @property
+    def callbacks(self) -> list[Callback]:
+        return self._callbacks
+
+    def forward(
+        self,
+        x: Annotated[Tensor, FloatTensor["batch_size ..."]],
+    ) -> Annotated[Tensor, FloatTensor["batch_size ..."]]:
+        return self.call(x)
+
+    def build(self, input_shape: tuple[int, ...]) -> None:
+        if self._is_built:
+            return
+
+        with torch.no_grad():
+            self(torch.zeros((1, *input_shape[1:])))
+        self.optimizer.build(self.parameters())
+        self._is_built = True
+
+    @abstractmethod
+    def call(
+        self,
+        x: Annotated[Tensor, FloatTensor["batch_size ..."]],
+    ) -> Annotated[Tensor, FloatTensor["batch_size ..."]]: ...
+
+    def compile(
+        self,
+        optimizer: Optimizer,
+        loss: Loss,
+        metrics: Sequence[Metric] | None = None,
+    ) -> None:
+        self._optimizer = optimizer
+        self._loss = loss
+        self._metrics = list(metrics) if metrics is not None else []
+
+    @dltyped()
+    def fit(
+        self,
+        x: Annotated[Tensor, FloatTensor["batch_size ..."]],
+        y: Annotated[Tensor, IntTensor["batch_size ..."]],
+        batch_size: int = 32,
+        epochs: int = 1,
+        callbacks: Sequence[Callback] | None = None,
+    ) -> None:
+        self._batch_size = batch_size
+        self._epochs = epochs
+        self._callbacks = list(callbacks) if callbacks is not None else []
+
+        for callback in self.callbacks:
+            callback.build(self)
+
+        data_loader = DataLoader(
+            dataset=TensorDataset(x, y),
+            batch_size=batch_size,
+            shuffle=True,
+        )
+
+        self.build(x.shape)
+
+        for epoch in range(epochs):
+            self.train()
+
+            for x_train, y_train in data_loader:
+                y_pred = self(x_train)
+
+                self.loss.update(y_pred, y_train)
+                self.loss.backward()
+
+                self.optimizer.step()
+                self.optimizer.zero_grad()
+
+                for metric in self.metrics:
+                    metric.update(y_pred, y_train)
+
+            logs = {
+                self.loss.name: self.loss.value.item(),
+                **{m.name: m.value.item() for m in self.metrics},
+            }
+            for callback in self.callbacks:
+                callback.on_train_epoch_end(epoch, logs)
+
+            self.loss.reset()
+            for metric in self.metrics:
+                metric.reset()
+
+    @dltyped()
+    def evaluate(
+        self,
+        x: Annotated[Tensor, FloatTensor["batch_size ..."]],
+        y: Annotated[Tensor, IntTensor["batch_size ..."]],
+        batch_size: int = 32,
+    ) -> None:
+        data_loader = DataLoader(
+            dataset=TensorDataset(x, y),
+            batch_size=batch_size,
+            shuffle=False,
+        )
+
+        self.build(x.shape)
+
+        self.eval()
+        with torch.no_grad():
+            for x_test, y_test in data_loader:
+                y_pred = self(x_test)
+
+                self.loss.update(y_pred, y_test)
+                for metric in self.metrics:
+                    metric.update(y_pred, y_test)
+
+        logs = {
+            self.loss.name: self.loss.value.item(),
+            **{m.name: m.value.item() for m in self.metrics},
+        }
+        for callback in self.callbacks:
+            callback.on_test_end(logs)
+
+        self.loss.reset()
+        for metric in self.metrics:
+            metric.reset()

typeras/optimizers/__init__.py

@@ -0,0 +1,2 @@
+from typeras.optimizers.adam import Adam as Adam
+from typeras.optimizers.optimizer import Optimizer as Optimizer

typeras/optimizers/adam.py

@@ -0,0 +1,25 @@
+from collections.abc import Iterable
+from typing import Annotated
+
+import torch
+from dltype import FloatTensor, dltyped
+from torch import Tensor, nn, optim
+from typeguard import typechecked
+
+from typeras.optimizers.optimizer import Optimizer
+
+
+@typechecked
+class Adam(Optimizer):
+    def __init__(self, learning_rate: float = 1e-3, name: str = "adam") -> None:
+        super().__init__(name)
+        self._learning_rate = torch.tensor(learning_rate)
+
+    @property
+    @dltyped()
+    def learning_rate(self) -> Annotated[Tensor, FloatTensor[None]]:
+        return self._learning_rate
+
+    def build(self, params: Iterable[nn.Parameter]) -> None:
+        self._optimizer = optim.Adam(params, lr=self.learning_rate)
+        self._is_built = True

typeras/optimizers/optimizer.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+
+from torch import nn, optim
+from typeguard import typechecked
+
+
+@typechecked
+class Optimizer(ABC):
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._is_built = False
+        self._optimizer = None
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def is_built(self) -> bool:
+        return self._is_built
+
+    @property
+    def optimizer(self) -> optim.Optimizer:
+        if self._optimizer is None:
+            raise RuntimeError
+        return self._optimizer
+
+    @abstractmethod
+    def build(self, params: Iterable[nn.Parameter]) -> None: ...
+
+    def zero_grad(self) -> None:
+        self.optimizer.zero_grad()
+
+    def step(self) -> None:
+        self.optimizer.step()

typeras-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: typeras
+Version: 0.1.0
+Summary: A type-safe, Keras-like deep learning library built on PyTorch.
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: dltype>=0.16.0
+Requires-Dist: numpy>=2.5.1
+Requires-Dist: polars>=1.43.2
+Requires-Dist: requests>=2.34.2
+Requires-Dist: safetensors>=0.8.0
+Requires-Dist: torch>=2.13.0
+Requires-Dist: typeguard>=4.6.0
+Description-Content-Type: text/markdown
+
+# Typeras
+
+A type-safe, Keras-like deep learning library built on PyTorch.

typeras-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+typeras/__init__.py,sha256=P6xzZ3uqndqYdMKsWfs7skA61NXkSO7mFE6U5_XFZ8I,352
+typeras/callbacks/__init__.py,sha256=0ImAGmeTCDrm-1kv4so0nWk-_nh7Pm1eHZQ87lWmplY,130
+typeras/callbacks/callback.py,sha256=aC8E7HGDIw_rDfEKwDtNDcDJ44h29lKlg-LUWDIdZ88,605
+typeras/callbacks/progress_bar.py,sha256=WVffckidDMjwS5lK0ECdQ7Y1CpKjIfdk8SSuhjq2yeg,568
+typeras/datasets/__init__.py,sha256=vr8uRzr2buA4UnL9aX9AwHmRNFY8VMB8KTHf7_vcc3c,60
+typeras/datasets/breast_cancer.py,sha256=KtOU5IPgL0CM6EVpdeF52dZA7x31l0SUQaGUzIL_Lrc,1053
+typeras/layers/__init__.py,sha256=9Pa7oW0JmoCuy0cVv6JW_tX-0H2puhCrQ4qJisoZ-J4,273
+typeras/layers/dense.py,sha256=j27dV3daNRtBiD9m0b25U6hWtA-zRBhGxY3Vep22viM,1510
+typeras/layers/identity.py,sha256=GIHQeUycNvlCvNiFRD6G__0byNR3M1y2sZ6FbS_6Xfg,472
+typeras/layers/layer.py,sha256=uJAtHab9kO3X8ZbnQI1sniy0UVktwkM8eJQMOf8LsPE,672
+typeras/layers/activations/__init__.py,sha256=s26Ci6-xKxz5YNvTMCzO3nwR-zufcmRBpCEeRAwfQPQ,66
+typeras/layers/activations/sigmoid.py,sha256=IHwFmnkFS2Xl-m2a1ZrVfOofxPt8gKQxukbnstjYPEg,469
+typeras/losses/__init__.py,sha256=hD355TyHkQP1WisGIEodoagT7Zf9SHLxMx235BTf8O0,128
+typeras/losses/crossentropies.py,sha256=kmVYL3sRF3JhBjYCaCo7MkvD2bC2BxmxXDvLFb4I0FQ,2421
+typeras/losses/loss.py,sha256=VphqAbGzxBHDUd4daKAnAUjIUmh8W1qfWdWMb9qIxTo,681
+typeras/metrics/__init__.py,sha256=Ebof2iLpl7LmI4xqelp-Gp5Xn9R-Prs1WpXymttLvsQ,132
+typeras/metrics/accuracies.py,sha256=8rKw2_iASfii2UBioHhsW_woRjCbIO4IX1SM9G94sFs,3218
+typeras/metrics/metric.py,sha256=LWs9e5kJTrihQOMd52Se33guTOwwkmDN7hh_fHlOcnk,626
+typeras/models/__init__.py,sha256=Qa6GqjWcMJeM8eOwRuuHzqkbEgtklX1Enql-wCeidLE,48
+typeras/models/model.py,sha256=Klr5lBMuma98G-nTfW8FfuG0SSy0V3YwIwDYHwYYgc0,4879
+typeras/optimizers/__init__.py,sha256=PWbyBvaVYmNQC4l5VTKF-1H4CirxjtTS-OL9GVH38po,113
+typeras/optimizers/adam.py,sha256=LJi2-JBmsAYHooGH2Ld5D7SYbw85RQGGNzowF5Y-BZA,744
+typeras/optimizers/optimizer.py,sha256=DjMHwX0MiYB9uj5lB1kJ3KWmscCq3fbk5Bx5wA1_vvI,820
+typeras-0.1.0.dist-info/METADATA,sha256=zri14iFvN-9zkuWVS-yqX-47HTOAJb71DaH1ZtIK_DM,531
+typeras-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+typeras-0.1.0.dist-info/licenses/LICENSE,sha256=wP_qAjLl2mpvlTFrm0ZNc_QCz9CSIhbsiwCfJov433k,11338
+typeras-0.1.0.dist-info/RECORD,,

typeras-0.1.0.dist-info/WHEEL

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

typeras-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 StarTown
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.