mill-dl 0.1.0__tar.gz

mill_dl-0.1.0/LICENSE

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

mill_dl-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: mill-dl
+Version: 0.1.0
+Summary: A simple deep learning framework in pure Python.
+Author: Bohdan Karpenko
+License: MIT License
+        
+        Copyright (c) 2026 b0gd5n
+        
+        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.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A simple deep learning framework in pure Python.

mill_dl-0.1.0/README.md

@@ -0,0 +1 @@
+A simple deep learning framework in pure Python.

mill_dl-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mill-dl"
+version = "0.1.0"
+description = "A simple deep learning framework in pure Python."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Bohdan Karpenko" }]
+requires-python = ">=3.8"
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["source"]

mill_dl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mill_dl-0.1.0/source/mill/__init__.py

@@ -0,0 +1,24 @@
+from .parameters import Parameter
+from .blocks import Dense, RectifiedLinearUnit
+from .distributions import Random
+from .generators import LinearCongruentialGenerator
+from .evaluators import MeanSquaredError
+from .updaters import StochasticGradientDescent
+from .pipeline import Sequential
+from .schedulers import Cosine
+from .stoppers import ValidationLossEarlyStopping
+
+__version__ = '0.1.0'
+
+__all__ = [
+    'Parameter',
+    'Dense',
+    'RectifiedLinearUnit',
+    'Random',
+    'LinearCongruentialGenerator',
+    'MeanSquaredError',
+    'StochasticGradientDescent',
+    'Sequential',
+    'Cosine',
+    'ValidationLossEarlyStopping',
+]

mill_dl-0.1.0/source/mill/blocks.py

@@ -0,0 +1,98 @@
+from .parameters import Parameter
+
+class Dense:
+    def __init__(self, inputs, outputs, distributor):
+        self.inputs = inputs
+        self.outputs = outputs
+
+        self.weights = Parameter(values=distributor.generate(inputs=inputs, outputs=outputs))
+        self.biases = Parameter(values=[])
+
+        self.last_inputs = []
+
+        for bias in range(outputs):
+            self.biases.values.append(0)
+            self.biases.gradients.append(0)
+
+    def forward(self, tensor, mode='inference'):
+        if mode == 'training':
+            self.last_inputs.append(tensor)
+
+        output = []
+
+        for batch in range(len(tensor)):
+            output.append([])
+
+            for node in range(self.outputs):
+                summand = self.biases.values[node]
+
+                for value in range(self.inputs):
+                    summand += tensor[batch][value] * self.weights.values[node * self.inputs + value]
+
+                output[batch].append(summand)
+
+        return output
+
+    def backward(self, tensor):
+        last_input = self.last_inputs.pop()
+
+        output = []
+
+        for batch in range(len(tensor)):
+            output.append([])
+
+            for node in range(self.outputs):
+                self.biases.gradients[node] += tensor[batch][node]
+
+                for value in range(self.inputs):
+                    self.weights.gradients[node * self.inputs + value] += tensor[batch][node] * last_input[batch][value]
+
+            for value in range(self.inputs):
+                summand = 0
+
+                for node in range(self.outputs):
+                    summand += tensor[batch][node] * self.weights.values[node * self.inputs + value]
+
+                output[batch].append(summand)
+
+        return output
+
+    def parameters(self):
+        return [self.weights, self.biases]
+
+class RectifiedLinearUnit:
+    def __init__(self):
+        self.last_inputs = []
+
+    def forward(self, tensor, mode='inference'):
+        if mode == 'training':
+            self.last_inputs.append(tensor)
+
+        output = []
+
+        for batch in range(len(tensor)):
+            output.append([])
+
+            for value in range(len(tensor[batch])):
+                if tensor[batch][value] > 0:
+                    output[batch].append(tensor[batch][value])
+                else:
+                    output[batch].append(0)
+
+        return output
+
+    def backward(self, tensor):
+        last_input = self.last_inputs.pop()
+
+        output = []
+
+        for batch in range(len(tensor)):
+            output.append([])
+
+            for value in range(len(tensor[batch])):
+                if last_input[batch][value] > 0:
+                    output[batch].append(tensor[batch][value])
+                else:
+                    output[batch].append(0)
+
+        return output

mill_dl-0.1.0/source/mill/distributions.py

@@ -0,0 +1,14 @@
+
+class Random:
+    def __init__(self, generator, minimal_value=-0.5, maximal_value=0.5):
+        self.generator = generator
+        self.minimal_value = minimal_value
+        self.maximal_value = maximal_value
+
+    def generate(self, inputs, outputs):
+        weights = []
+
+        for weight in range(inputs * outputs):
+            weights.append(self.generator.generate(minimal_value=self.minimal_value, maximal_value=self.maximal_value))
+
+        return weights

mill_dl-0.1.0/source/mill/evaluators.py

@@ -0,0 +1,21 @@
+
+class MeanSquaredError:
+    def evaluate(self, predictions, targets):
+        summand = 0
+
+        for batch in range(len(predictions)):
+            for value in range(len(predictions[batch])):
+                summand += (predictions[batch][value] - targets[batch][value]) ** 2
+
+        return summand / (len(predictions) * len(predictions[0]))
+
+    def backward(self, predictions, targets):
+        output = []
+
+        for batch in range(len(predictions)):
+            output.append([])
+
+            for value in range(len(predictions[batch])):
+                output[batch].append(2 * (predictions[batch][value] - targets[batch][value]) / (len(predictions) * len(predictions[0])))
+
+        return output

mill_dl-0.1.0/source/mill/generators.py

@@ -0,0 +1,14 @@
+
+class LinearCongruentialGenerator:
+    def __init__(self, seed=42):
+        self.seed = seed
+        self.state = seed % 4294967296
+
+        self.usages = 0
+
+    def generate(self, minimal_value, maximal_value):
+        self.state = (1664525 * self.state + 1013904223) % 4294967296
+
+        self.usages += 1
+
+        return minimal_value + (maximal_value - minimal_value) * self.state / 4294967296

mill_dl-0.1.0/source/mill/parameters.py

@@ -0,0 +1,12 @@
+
+class Parameter:
+    def __init__(self, values):
+        self.values = values
+        self.gradients = []
+
+        for value in range(len(values)):
+            self.gradients.append(0)
+
+    def clear(self):
+        for gradient in range(len(self.gradients)):
+            self.gradients[gradient] = 0

mill_dl-0.1.0/source/mill/pipeline.py

@@ -0,0 +1,60 @@
+
+class Sequential:
+    def __init__(self, *blocks):
+        self.blocks = blocks
+
+    def forward(self, tensor, mode='inference'):
+        current = tensor
+
+        for block in range(len(self.blocks)):
+            current = self.blocks[block].forward(current, mode=mode)
+
+        return current
+
+    def backward(self, tensor):
+        current = tensor
+
+        for block in reversed(range(len(self.blocks))):
+            current = self.blocks[block].backward(current)
+
+        return current
+
+    def parameters(self):
+        parameters = []
+
+        for block in range(len(self.blocks)):
+            if hasattr(self.blocks[block], 'parameters'):
+                block_parameters = self.blocks[block].parameters()
+
+                for parameter in range(len(block_parameters)):
+                    if not any(block_parameters[parameter] is parameters[existing] for existing in range(len(parameters))):
+                        parameters.append(block_parameters[parameter])
+
+        return parameters
+
+    def save(self, path='model.txt'):
+        parameters = self.parameters()
+
+        with open(path, 'w') as file:
+            for parameter in range(len(parameters)):
+                line = ''
+
+                for value in range(len(parameters[parameter].values)):
+                    if value > 0:
+                        line += ' '
+
+                    line += repr(float(parameters[parameter].values[value]))
+
+                file.write(line + '\n')
+
+    def load(self, path='model.txt'):
+        with open(path, 'r') as file:
+            lines = file.read().split('\n')
+
+        parameters = self.parameters()
+
+        for parameter in range(len(parameters)):
+            numbers = lines[parameter].split()
+
+            for value in range(len(parameters[parameter].values)):
+                parameters[parameter].values[value] = float(numbers[value])

mill_dl-0.1.0/source/mill/schedulers.py

@@ -0,0 +1,26 @@
+
+class Cosine:
+    def __init__(self, minimal_rate, maximal_rate, warming_steps, total_steps, iterations=16):
+        self.maximal_rate = maximal_rate
+        self.minimal_rate = minimal_rate
+        self.warming_steps = warming_steps
+        self.total_steps = total_steps
+        self.iterations = iterations
+
+    def cosine(self, angle):
+        summand = 1
+        term = 1
+
+        for index in range(1, self.iterations):
+            term *= -angle * angle / ((2 * index - 1) * (2 * index))
+            summand += term
+
+        return summand
+
+    def rate(self, step):
+        if step < self.warming_steps:
+            return self.maximal_rate * (step + 1) / self.warming_steps
+
+        progress = min(1, (step - self.warming_steps) / max(1, self.total_steps - self.warming_steps))
+
+        return self.minimal_rate + (self.maximal_rate - self.minimal_rate) * 0.5 * (1 + self.cosine(3.141592653589793 * progress))

mill_dl-0.1.0/source/mill/stoppers.py

@@ -0,0 +1,47 @@
+
+class ValidationLossEarlyStopping:
+    def __init__(self, model, evaluator, patience=8, minimum_improvement=0):
+        self.model = model
+        self.evaluator = evaluator
+        self.patience = patience
+        self.minimum_improvement = minimum_improvement
+
+        self.best_loss = float('inf')
+        self.best_epoch = -1
+        self.best_parameters = []
+        self.epochs_without_improvement = 0
+        self.epoch = 0
+
+    def check(self, inputs, targets):
+        loss = self.evaluator.evaluate(predictions=self.model.forward(tensor=inputs), targets=targets)
+
+        if loss < self.best_loss - self.minimum_improvement:
+            self.best_loss = loss
+            self.best_epoch = self.epoch
+            self.epochs_without_improvement = 0
+
+            self.remember()
+        else:
+            self.epochs_without_improvement += 1
+
+        self.epoch += 1
+
+        return self.epochs_without_improvement >= self.patience
+
+    def remember(self):
+        parameters = self.model.parameters()
+
+        self.best_parameters = []
+
+        for parameter in range(len(parameters)):
+            self.best_parameters.append([])
+
+            for value in range(len(parameters[parameter].values)):
+                self.best_parameters[parameter].append(parameters[parameter].values[value])
+
+    def restore(self):
+        parameters = self.model.parameters()
+
+        for parameter in range(len(parameters)):
+            for value in range(len(parameters[parameter].values)):
+                parameters[parameter].values[value] = self.best_parameters[parameter][value]

mill_dl-0.1.0/source/mill/updaters.py

@@ -0,0 +1,13 @@
+
+class StochasticGradientDescent:
+    def __init__(self, parameters):
+        self.parameters = parameters
+
+    def step(self, rate):
+        for parameter in range(len(self.parameters)):
+            for value in range(len(self.parameters[parameter].values)):
+                self.parameters[parameter].values[value] -= rate * self.parameters[parameter].gradients[value]
+
+    def clear(self):
+        for parameter in range(len(self.parameters)):
+            self.parameters[parameter].clear()

mill_dl-0.1.0/source/mill_dl.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: mill-dl
+Version: 0.1.0
+Summary: A simple deep learning framework in pure Python.
+Author: Bohdan Karpenko
+License: MIT License
+        
+        Copyright (c) 2026 b0gd5n
+        
+        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.
+        
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+A simple deep learning framework in pure Python.

mill_dl-0.1.0/source/mill_dl.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+source/mill/__init__.py
+source/mill/blocks.py
+source/mill/distributions.py
+source/mill/evaluators.py
+source/mill/generators.py
+source/mill/parameters.py
+source/mill/pipeline.py
+source/mill/schedulers.py
+source/mill/stoppers.py
+source/mill/updaters.py
+source/mill_dl.egg-info/PKG-INFO
+source/mill_dl.egg-info/SOURCES.txt
+source/mill_dl.egg-info/dependency_links.txt
+source/mill_dl.egg-info/top_level.txt

mill_dl-0.1.0/source/mill_dl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mill_dl-0.1.0/source/mill_dl.egg-info/top_level.txt

@@ -0,0 +1 @@
+mill