torchsystem 0.1.0__py3-none-any.whl

torchsystem/__init__.py

@@ -0,0 +1,7 @@
+from torchsystem.aggregate import Aggregate
+from torchsystem.loaders import Loaders
+from torchsystem.storage import Models, Criterions, Optimizer, Datasets
+from torchsystem.compiler import Compiler
+from pybondi import Event, Command
+from pybondi.session import Session
+from pybondi.repository import Repository

torchsystem/aggregate.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from typing import Iterator
+from typing import Protocol
+from typing import overload
+from typing import Callable
+from torch import Tensor
+from torch.nn import Module
+from torch.utils.data import Dataset
+from pybondi.aggregate import Root
+
+class Loader(Protocol):
+    '''
+    Interface for the DataLoader class.     
+    '''
+    dataset: Dataset
+    
+    def __iter__(self) -> Iterator[Any]:...
+
+    @overload
+    def __iter__(self) -> Iterator[tuple[Tensor, Tensor]]:...
+
+
+class Aggregate(Module, ABC):
+
+    def __init__(self, id: Any):
+        super().__init__()
+        self.root = Root(id=id)
+        self.epoch = 0
+    
+    @property
+    def phase(self) -> str:
+        return 'train' if self.training else 'evaluation'
+    
+    @phase.setter
+    def phase(self, value: str):
+        self.train() if value == 'train' else self.eval()
+
+    @abstractmethod
+    def fit(self, data: Loader, callback: Callable): ...
+
+    @abstractmethod
+    def evaluate(self, data: Loader, callback: Callable): ...
+
+    def iterate(self, data: Loader, callback: Callable):
+        self.fit(data, callback) if self.training else self.evaluate(data, callback)

torchsystem/callbacks/average.py

@@ -0,0 +1,51 @@
+from torch import Tensor
+from pybondi.callbacks import Callback
+from torchsystem.callbacks.metrics import Metric, accuracy, predictions
+
+class Average:
+    def __init__(self):
+        self.value = 0.0
+
+    def update(self, sample: int, value: float) -> float:
+        self.value = (self.value * (sample - 1) + value) / sample
+        return self.value
+
+    def reset(self):
+        self.value = 0.0
+
+class Loss(Callback):
+    def __init__(self):
+        super().__init__()
+        self.epoch = 0
+        self.phase = None
+        self.average = Average()
+
+    def __call__(self, batch: int, loss: float, *args, **kwargs):
+        self.batch = batch
+        self.average.update(batch, loss)        
+
+    def flush(self):
+        self.publisher.publish('result', Metric('loss', self.average.value, self.batch, self.epoch, self.phase))
+        self.average.reset()
+        
+    def reset(self):
+        self.average.reset()
+
+
+class Accuracy(Callback):
+    def __init__(self):
+        super().__init__()
+        self.epoch = 0
+        self.phase = None
+        self.average = Average()
+        
+    def __call__(self, batch: int, _, output: Tensor, target: Tensor, *args, **kwargs):
+        self.batch = batch
+        self.average.update(batch, accuracy(predictions(output), target))
+
+    def flush(self):
+        self.publisher.publish('result', Metric('accuracy', self.average.value, self.batch, self.epoch, self.phase))
+        self.average.reset()
+
+    def reset(self):
+        self.average.reset()

torchsystem/callbacks/metrics.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Any
+from typing import Any
+from torch import Tensor
+from torch import argmax
+
+@dataclass
+class Metric:
+    name: str
+    value: Any
+    batch: int
+    epoch: int
+    phase: str
+    
+def accuracy(predictions: Tensor, target: Tensor) -> float:
+    return (predictions == target).float().mean().item()
+
+def predictions(output: Tensor) -> Tensor:
+    return argmax(output, dim=1)

torchsystem/commands.py

@@ -0,0 +1,89 @@
+from typing import Sequence
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pybondi import Command
+from pybondi.callbacks import Callback
+from torchsystem.aggregate import Aggregate
+from torchsystem.aggregate import Loader
+from torchsystem.events import Trained, Evaluated, Iterated
+
+@dataclass
+class Train(Command):
+    '''
+    The Train command is used to train the aggregate using the sequence of loaders provided. 
+    It bumps the epoch after training the aggregate.
+    '''
+    aggregate: Aggregate
+    loaders: Sequence[Loader]
+    callback: Callback
+    
+    def execute(self):
+        self.aggregate.phase = 'train'
+        self.callback.set('phase', self.aggregate.phase)
+        self.callback.set('epoch', self.aggregate.epoch)
+        start = datetime.now(timezone.utc)
+        for loader in self.loaders:
+            self.aggregate.fit(loader, self.callback)
+        end = datetime.now(timezone.utc)
+        self.aggregate.root.publish(event=Trained(
+            epoch=self.aggregate.epoch,
+            start=start,
+            end=end,
+            loaders=self.loaders,
+            aggregate=self.aggregate
+        ))
+        self.aggregate.epoch += 1
+
+@dataclass
+class Evaluate(Command):
+    '''
+    The Evaluate command is used to evaluate the aggregate using the sequence of loaders provided. 
+    The aggregate is put on evaluation mode. It does not bump the epoch since it is not training the aggregate. 
+    '''
+    aggregate: Aggregate
+    loaders: Sequence[Loader]
+    callback: Callback
+    
+    def execute(self):
+        self.aggregate.phase = 'evaluation'
+        self.callback.set('phase', self.aggregate.phase)
+        self.callback.set('epoch', self.aggregate.epoch)
+        start = datetime.now(timezone.utc)
+        for loader in self.loaders:
+            self.aggregate.evaluate(loader, self.callback)
+        end = datetime.now(timezone.utc)
+        self.aggregate.root.publish(event=Evaluated(
+            epoch=self.aggregate.epoch,
+            start=start,
+            end=end,
+            loaders=self.loaders,
+            aggregate=self.aggregate
+        ))
+
+@dataclass
+class Iterate(Command):
+    '''
+    The Iterate command is used to iterate over the sequence of loaders provided.
+    It determines the phase of the aggregate and calls the fit or evaluate method accordingly.
+    After iterating over the loaders, it bumps the epoch.
+    '''
+    aggregate: Aggregate
+    loaders: Sequence[tuple[str, Loader]]
+    callback: Callback
+    
+    def execute(self):
+        self.callback.set('epoch', self.aggregate.epoch)
+        start = datetime.now(timezone.utc)
+        for phase, loader in self.loaders:
+            self.aggregate.phase = phase
+            self.callback.set('phase', self.aggregate.phase )
+            self.aggregate.iterate(loader, self.callback)
+        end = datetime.now(timezone.utc)
+        self.aggregate.root.publish(event=Iterated(
+            epoch=self.aggregate.epoch,
+            start=start,
+            end=end,
+            loaders=self.loaders,
+            aggregate=self.aggregate
+        ))
+        self.aggregate.epoch += 1

torchsystem/compiler.py

@@ -0,0 +1,43 @@
+from typing import Callable
+from torch import compile
+from pybondi.aggregate import Factory
+from torchsystem.aggregate import Aggregate
+from torchsystem.settings import Settings
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+class Compiler:
+    '''
+    The Compiler class is used to compile several modules into a single aggregate.    
+
+    Parameters:
+        factory (Callable): A callable that returns an aggregate. Could be the aggregate's type
+        a function that initializes and returns an aggregate or a callable instance of a factory.
+    '''
+
+    def __init__(self, factory: Factory, settings: Settings = None):
+        self.settings = settings or Settings()
+        self.factory = factory
+
+    def compile(self, *args, **kwargs) -> Aggregate:
+        '''
+        Builds and compiles the aggregate using the factory provided.
+
+        Parameters:
+            *args: The positional arguments to pass to the factory.
+            **kwargs: The keyword arguments to pass to the factory.
+        '''
+        logger.info(f'Building and compiling the aggregate')
+        aggregate = self.factory(*args, **kwargs)
+        try:
+            compiled = compile(aggregate)
+            logger.info(f'Aggregate compiled successfully')
+            logger.info(f'Aggregate: {compiled}')
+            return compiled
+        except Exception as error:
+            logger.error(f'Error compiling the aggregate: {error}')
+            if self.settings.compilation.raise_on_error:
+                raise error
+            logger.info(f'Returning the uncompiled aggregate')
+            return aggregate

torchsystem/events.py

@@ -0,0 +1,41 @@
+from typing import Sequence
+from datetime import datetime
+from dataclasses import dataclass
+from pybondi import Event
+from torchsystem.aggregate import Aggregate, Loader
+
+@dataclass
+class Trained(Event):
+    '''
+    The Trained event is used to signal that the aggregate has been trained.
+    over a sequence of loaders.
+    '''
+    epoch: int
+    start: datetime
+    end: datetime
+    loaders: Sequence[Loader]
+    aggregate: Aggregate
+    
+@dataclass
+class Evaluated(Event):
+    '''
+    The Evaluated event is used to signal that the aggregate has been evaluated
+    over a sequence of loaders.
+    '''
+    epoch: int
+    start: datetime
+    end: datetime
+    loaders: Sequence[Loader]
+    aggregate: Aggregate
+
+@dataclass
+class Iterated(Event):
+    '''
+    The Iterated event is used to signal that the aggregate has been iterated
+    over a sequence of loaders.
+    '''
+    epoch: int
+    start: datetime
+    end: datetime
+    loaders: Sequence[tuple[str, Loader]]
+    aggregate: Aggregate

torchsystem/loaders.py

@@ -0,0 +1,53 @@
+from typing import Iterator
+from torch.utils.data import DataLoader
+from torch.utils.data import Dataset
+from torchsystem.aggregate import Loader
+from torchsystem.settings import Settings
+from mlregistry import Registry
+
+INFRASTRUCTURE_PARAMETERS = {'dataset', 'pin_memory', 'pin_memory_device' ,'num_workers'}
+
+class Loaders:
+    '''
+    This class acts as an iterable container for the data loaders. It allows decoupling the infrastructure
+    settings like devices from the domain settings of the dataloaders like batch size, shuffling, etc. When
+    you add a dataset to the loaders it will automatically register the dataset and it's dataloader in the
+    registry and add metadata to them.
+    '''
+
+    def __init__(self, settings: Settings = None, exclude_parameters: set[str] = INFRASTRUCTURE_PARAMETERS):
+        self.settings = settings or Settings()
+        self.registry = Registry(excluded_positions=[0], exclude_parameters=exclude_parameters)
+        self.registry.register(DataLoader, 'loader')
+        self.list = list[tuple[str, Loader]]()
+    
+    def add(self, phase: str, dataset: Dataset, batch_size: int, shuffle: bool = False, settings: Settings | None = None, **kwargs):
+        '''
+        Add a dataset to the loaders. The dataset is added with the phase, batch size, and shuffle settings.
+
+        Parameters:
+            phase: str: The phase of the dataset. It can be 'train', 'validation', or 'test'.
+            dataset: Dataset: The dataset to be added to the loaders.
+            batch_size: int: The batch size of the dataset.
+            shuffle: bool: Whether to shuffle the dataset or not.
+            settings: Settings: The settings to be used for the dataloader. If None, the default settings are used.
+            **kwargs: Any: Additional keyword arguments to be passed to the DataLoader.
+        '''
+
+        settings = settings or self.settings
+        loader = DataLoader(
+            dataset, 
+            batch_size=batch_size, 
+            shuffle=shuffle, 
+            pin_memory=self.settings.loaders.pin_memory,
+            pin_memory_device=self.settings.loaders.pin_memory_device,
+            num_workers=self.settings.loaders.num_of_workers,
+            **kwargs
+        )
+        self.list.append((phase, loader))
+
+    def __iter__(self) -> Iterator[tuple[str, Loader]]:
+        return iter(self.list)
+    
+    def clear(self):
+        self.list.clear()

torchsystem/settings.py

@@ -0,0 +1,26 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+class ModelSettings(BaseSettings):
+    device: str = Field(default='cpu')
+    model_config = SettingsConfigDict(env_prefix='MODEL_')
+
+class CompilerSettings(BaseSettings):
+    raise_on_error: bool = Field(default=False)
+    model_config = SettingsConfigDict(env_prefix='COMPILATION_')
+
+class LoaderSettings(BaseSettings):
+    pin_memory: bool = Field(default=False)
+    pin_memory_device: str = Field(default='')
+    num_of_workers: int = Field(default=0)
+    model_config = SettingsConfigDict(env_prefix='LOADER_')
+
+class WeightsSettings(BaseSettings):
+    directory: str = Field(default='data/weights')
+    model_config = SettingsConfigDict(env_prefix='WEIGHTS_')
+
+class Settings(BaseSettings):
+    model: BaseSettings = Field(default_factory=ModelSettings)
+    loaders: LoaderSettings = Field(default_factory=LoaderSettings)
+    compilation: CompilerSettings = Field(default_factory=CompilerSettings)
+    weights: WeightsSettings = Field(default_factory=WeightsSettings)

torchsystem/storage.py

@@ -0,0 +1,88 @@
+from os import path
+from typing import Optional
+from torch.nn import Module
+from torch.optim import Optimizer
+from torch.utils.data import Dataset
+from torchsystem.settings import Settings
+from torchsystem.weights import Weights
+from mlregistry import Registry
+from mlregistry import get_hash
+
+class Storage[T]:
+    '''
+    Base class for storage classes. It is responsible for coordinating the registry and weights of objects. 
+    '''
+    registry: Registry[T]
+    weights: Weights[T]
+    category: str
+    
+    @classmethod
+    def register(cls, type: type):
+        return cls.registry.register(type, cls.category)
+        
+    def get(self, name: str, *args, **kwargs) -> Optional[T]:
+        '''
+        Get an object from the registry and restore it's weights if available.
+
+        Parameters:
+            name (str): The name of the object.
+            *args: Positional arguments for initializing the object.
+            **kwargs: Keyword arguments for initializing the object.
+        '''
+
+        if not name in self.registry.keys():
+            return None
+        object = self.registry.get(name)(*args, **kwargs)
+        if hasattr(self, 'weights'):
+            self.weights.restore(object, f'{self.category}:{get_hash(object)}')
+        return object
+    
+    def store(self, object: T):
+        '''
+        Store the weights of an object in a given category, an assertion error is raised if the object is not registered.
+
+        Parameters:
+            object (T): The object to store.
+        '''
+        assert object.__class__.__name__ in self.registry.keys(), f'{object.__class__.__name__} not registered in {self.category}'
+        if hasattr(self, 'weights'):
+            self.weights.store(object, f'{self.category}:{get_hash(object)}')
+
+    def restore(self, object: T):
+        '''
+        Restore the weights of an object from a given category, an assertion error is raised if the object is not registered.
+
+        Parameters:
+            object (T): The object to restore.
+        '''
+        assert object.__class__.__name__ in self.registry.keys(), f'{object.__class__.__name__} not registered in {self.category}'
+        if hasattr(self, 'weights'):
+            self.weights.restore(object, f'{self.category}:{get_hash(object)}')
+
+class Models(Storage[Module]):
+    category = 'model'
+    registry = Registry()
+
+    def __init__(self, folder: str | None = None, settings: Settings = None):
+        self.settings = settings or Settings()
+        self.weights = Weights(path.join(self.settings.weights.directory, folder) if folder else self.settings.weights.directory)
+
+class Criterions(Storage[Module]):
+    category = 'criterion'
+    registry = Registry()
+
+    def __init__(self, folder: str | None = None, settings: Settings = None):
+        self.settings = settings or Settings()
+        self.weights = Weights(path.join(self.settings.weights.directory, folder) if folder else self.settings.weights.directory)
+
+class Optimizers(Storage[Optimizer]):
+    category = 'optimizer'
+    registry = Registry(excluded_positions=[0], exclude_parameters={'params'})
+    
+    def __init__(self, folder: str | None = None, settings: Settings = None):
+        self.settings = settings or Settings()
+        self.weights = Weights(path.join(self.settings.weights.directory, folder) if folder else self.settings.weights.directory)
+
+class Datasets(Storage[Dataset]):
+    category = 'dataset'
+    registry = Registry(exclude_parameters={'root', 'download'})

torchsystem/weights.py

@@ -0,0 +1,51 @@
+from os import makedirs
+from os import path, makedirs
+from logging import getLogger
+from torch import save, load
+from torch.nn import Module
+
+logger = getLogger(__name__)
+
+class Weights[T: Module]:
+    '''
+    Weights class is responsible for storing and restoring the weights of a module.
+
+    Args:
+        directory (str): The directory to store the weights.    
+    '''
+    def __init__(self, directory: str):
+        self.location = directory
+        if not path.exists(self.location):
+            makedirs(self.location)
+
+    
+    def store(self, module: T, filename: str):
+        '''
+        Store the weights of a module.
+
+        Parameters:
+            module (Module): The module to store the weights.
+            folder (str): The folder to store the weights.
+            filename (str): The filename to store the
+        '''
+        logger.info(f'Storing weights of {module.__class__.__name__} in {filename}.pth')	
+        save(module.state_dict(), path.join(self.location, filename + '.pth'))
+        logger.info(f'Weights stored successfully')
+        
+
+    def restore(self, module: T, filename: str):
+        '''
+        Restore the weights of a module.
+
+        Parameters:
+            module (Module): The module to restore the weights.
+            folder (str): The folder to restore the weights.
+            filename (str): The filename to restore the weights.
+        '''
+        logger.info(f'Restoring weights of {module.__class__.__name__} from {filename}.pth')
+        try:
+            state_dict = load(path.join(self.location, filename + '.pth'), weights_only=True)
+            module.load_state_dict(state_dict)
+            logger.info(f'Weights restored successfully')
+        except FileNotFoundError as error:
+            logger.warning(f'Error restoring weights: {error}')

torchsystem-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mapache Software
+
+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.

torchsystem-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: torchsystem
+Version: 0.1.0
+Summary: An IA training system, based on domain driven design and an event driven architecture, created on top of the pybondi library.
+License: MIT
+Author: Eric Cardozo
+Author-email: eric.m.cardozo@mi.unc.edu.ar
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: mlregistry (>=1.0.0,<2.0.0)
+Requires-Dist: pybondi (>=0.2.3,<0.3.0)
+Description-Content-Type: text/markdown
+
+# torch-system
+An IA training system, created using domain driven design and an event driven architecture.
+

torchsystem-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+torchsystem/__init__.py,sha256=-_IuDIA71zFptbspHgN5gWW4zPsCAAe1AThw9G4EqnE,310
+torchsystem/aggregate.py,sha256=YVNK3pqcyhMiRxhdwQmbZkMphfEigk5i43auKmyTwLo,1199
+torchsystem/callbacks/average.py,sha256=1p06GBZl3uIBF87DvKa5CLoajHTBdMkVEpXN8ivKqdM,1498
+torchsystem/callbacks/metrics.py,sha256=GanvN2_zHxucOvVWpB5YFlkS_lsS8rKos3vqdIs8-tM,429
+torchsystem/commands.py,sha256=9DnC3czK3ngPfz-_6iXAKYS4-OlQ1fsZrZ0zAO60P2E,3130
+torchsystem/compiler.py,sha256=fmUgkA7m3HTxc8cDWOk5OtHG8kiVAHbMVMlDqBsCeXY,1605
+torchsystem/events.py,sha256=Tm8BEGjrBIDVX06pkemD-b4BM14hzvWfXzNW2bpPyU0,993
+torchsystem/loaders.py,sha256=e2QtQ79Nc30Zm-DGxfwmO8ZfjJoOEyWhyt01AHMYsZM,2408
+torchsystem/settings.py,sha256=3--h06nWc0GcW3ehNDv9HLxW56GHxUtc9W7s20sYITY,1064
+torchsystem/storage.py,sha256=8USWlA3M8B1JShUBXBQUsxoLkees-u-1ftfIMW1EVlM,3474
+torchsystem/weights.py,sha256=6zoITMkjl9WC5BdH5L890-lwppoydRNRsGTnMii60q4,1806
+torchsystem-0.1.0.dist-info/LICENSE,sha256=xaMmSaui1itQNp2WE6mT7zoqwyhLqqObOA5YW7BqXnc,1073
+torchsystem-0.1.0.dist-info/METADATA,sha256=IsCJxZ9l5rCrlJqAldSwnWKYK9yl4Kft14t7YsUtlgQ,729
+torchsystem-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+torchsystem-0.1.0.dist-info/RECORD,,

torchsystem-0.1.0.dist-info/WHEEL

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