mini-torch-from-scratch 0.1.0__py3-none-any.whl

mini_torch/__init__.py

@@ -0,0 +1,4 @@
+from .autodiff import Nombre
+from .nn import Couche, MLP, Neuron
+
+__all__ = ["Nombre", "Neuron", "Couche", "MLP"]

mini_torch/autodiff.py

@@ -0,0 +1,144 @@
+import math
+
+
+class Nombre:
+    def __init__(self, h_val, _parent=(), _op=""):
+        self.h_val = h_val
+        self.b_val = 0.0
+        self._derive = lambda: None
+        self._parent = set(_parent)
+        self._op = _op
+
+    def __repr__(self):
+        return f"[h_val: {self.h_val}, b_val: {self.b_val}]"
+
+    def __add__(self, autre):
+        autre = autre if isinstance(autre, Nombre) else Nombre(h_val=autre)
+        somme = Nombre(
+            h_val=self.h_val + autre.h_val,
+            _parent=(self, autre),
+            _op="+",
+        )
+
+        def _derive():
+            self.b_val += somme.b_val
+            autre.b_val += somme.b_val
+
+        somme._derive = _derive
+        return somme
+
+    def __mul__(self, autre):
+        autre = autre if isinstance(autre, Nombre) else Nombre(h_val=autre)
+        produit = Nombre(
+            h_val=self.h_val * autre.h_val,
+            _parent=(self, autre),
+            _op="*",
+        )
+
+        def _derive():
+            self.b_val += autre.h_val * produit.b_val
+            autre.b_val += self.h_val * produit.b_val
+
+        produit._derive = _derive
+        return produit
+
+    def __pow__(self, autre):
+        if not isinstance(autre, (int, float)):
+            raise TypeError("L'exposant doit être un nombre.")
+
+        puissance = Nombre(
+            h_val=self.h_val**autre,
+            _parent=(self,),
+            _op=f"**{autre}",
+        )
+
+        def _derive():
+            self.b_val += autre * (self.h_val ** (autre - 1)) * puissance.b_val
+
+        puissance._derive = _derive
+        return puissance
+
+    def maximum(self, autre):
+        autre = autre if isinstance(autre, Nombre) else Nombre(h_val=autre)
+        max_val = Nombre(
+            h_val=max(self.h_val, autre.h_val),
+            _parent=(self, autre),
+            _op="max",
+        )
+
+        def _derive():
+            if self.h_val > autre.h_val:
+                self.b_val += max_val.b_val
+            elif autre.h_val > self.h_val:
+                autre.b_val += max_val.b_val
+            else:
+                self.b_val += 0.5 * max_val.b_val
+                autre.b_val += 0.5 * max_val.b_val
+
+        max_val._derive = _derive
+        return max_val
+
+    def __neg__(self):
+        return self * -1
+
+    def __sub__(self, autre):
+        return self + (-autre)
+
+    def __rsub__(self, autre):
+        return autre + (-self)
+
+    def __rmul__(self, autre):
+        return self * autre
+
+    def __radd__(self, autre):
+        return self + autre
+
+    def tanh(self):
+        t = math.tanh(self.h_val)
+        out = Nombre(h_val=t, _parent=(self,), _op="tanh")
+
+        def _derive():
+            self.b_val += (1 - t**2) * out.b_val
+
+        out._derive = _derive
+        return out
+
+    def exp(self):
+        out = Nombre(
+            h_val=math.exp(self.h_val),
+            _parent=(self,),
+            _op="exp",
+        )
+
+        def _derive():
+            self.b_val += out.h_val * out.b_val
+
+        out._derive = _derive
+        return out
+
+    def backward(self):
+        topo = []
+        seen = set()
+
+        def construire_graph(nbr):
+            if nbr not in seen:
+                seen.add(nbr)
+
+                for parent in nbr._parent:
+                    construire_graph(parent)
+
+                topo.append(nbr)
+
+        construire_graph(self)
+
+        for nbr in topo:
+            if nbr._parent:
+                nbr.b_val = 0.0
+
+        self.b_val = 1.0
+
+        for nbr in reversed(topo):
+            nbr._derive()
+
+    def _retropropager(self):
+        self.backward()

mini_torch/nn.py

@@ -0,0 +1,55 @@
+from .autodiff import Nombre
+
+
+class Neuron:
+    def __init__(self, poids, biais):
+        self.poids = [p if isinstance(p, Nombre) else Nombre(p) for p in poids]
+        self.biais = biais if isinstance(biais, Nombre) else Nombre(biais)
+
+    def propager(self, entrees):
+        if len(entrees) != len(self.poids):
+            raise ValueError(
+                f"Le neurone attend {len(self.poids)} entrées, "
+                f"mais en a reçu {len(entrees)}."
+            )
+
+        z = self.biais
+
+        for x, w in zip(entrees, self.poids):
+            x = x if isinstance(x, Nombre) else Nombre(x)
+            z = z + x * w
+
+        return z.tanh()
+
+    def parameters(self):
+        return self.poids + [self.biais]
+
+
+class Couche:
+    def __init__(self, neurons):
+        self.neurons = neurons
+
+    def propager(self, caracteres):
+        return [neuron.propager(caracteres) for neuron in self.neurons]
+
+    def parameters(self):
+        params = []
+        for neuron in self.neurons:
+            params.extend(neuron.parameters())
+        return params
+
+
+class MLP:
+    def __init__(self, couches):
+        self.couches = couches
+
+    def propager(self, entrees):
+        for couche_actuelle in self.couches:
+            entrees = couche_actuelle.propager(entrees)
+        return entrees
+
+    def parameters(self):
+        params = []
+        for couche_actuelle in self.couches:
+            params.extend(couche_actuelle.parameters())
+        return params

mini_torch_from_scratch-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: mini-torch-from-scratch
+Version: 0.1.0
+Summary: A small neural network and automatic differentiation framework
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Mini Torch from Scratch
+
+Un petit framework Python, sans dependance externe, pour l'autodiff scalaire et
+les reseaux fully connected (MLP). Il ne fournit pas encore de couches CNN.
+
+## Installation
+
+```powershell
+python -m pip install mini-torch-from-scratch
+```
+
+Le nom du paquet sur PyPI est `mini-torch-from-scratch`. Le nom d'import Python
+reste `mini_torch`.
+
+## Exemple
+
+```python
+from mini_torch import Couche, MLP, Neuron, Nombre
+
+reseau = MLP(
+    [
+        Couche([Neuron([0.5, -0.2], 0.1)]),
+        Couche([Neuron([0.8], 0.0)]),
+    ]
+)
+
+sortie = reseau.propager([2.0, 1.0])[0]
+perte = (sortie - 1.0) ** 2
+perte.backward()
+
+for parametre in reseau.parameters():
+    parametre.h_val -= 0.01 * parametre.b_val
+```
+
+`Nombre.backward()` calcule les gradients et les accumule sur les feuilles du
+graphe. Remets les gradients des parametres a zero avant une nouvelle etape
+d'optimisation si tu ne veux pas les accumuler.
+
+Pour voir un exemple d'entrainement complet depuis le depot :
+
+```powershell
+python -m examples.entrainement
+```
+
+## Tests
+
+Depuis la racine du depot :
+
+```powershell
+python -m unittest discover -s tests
+```
+
+## Construire et publier sur PyPI
+
+La publication n'est pas automatique. Pour publier toi-meme :
+
+1. Remplace le titulaire fictif dans `LICENSE` par ton nom ou celui de ton
+   organisation, puis cree un compte PyPI et verifie que le nom
+   `mini-torch-from-scratch` est toujours disponible. Sa disponibilite peut
+   changer.
+2. Depuis la racine du depot, construis et verifies les distributions :
+
+   ```powershell
+   python -m pip install --upgrade build twine
+   python -m build
+   python -m twine check dist/*
+   ```
+
+3. Configure tes identifiants PyPI selon la documentation officielle de Twine,
+   puis envoie les distributions :
+
+   ```powershell
+   python -m twine upload dist/*
+   ```
+
+Ne place pas de jeton PyPI dans le code source ni dans le depot. Augmente la
+version dans `pyproject.toml` avant chaque nouvelle publication.

mini_torch_from_scratch-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mini_torch/__init__.py,sha256=isATTvYziM-LW-yR-5BKKz-qx95Y2gQWhUv7XDOABxY,118
+mini_torch/autodiff.py,sha256=Zn4bxlt0G749unlt3eR9aFdxbUu0G1bX2_HIGC-FZ9c,3695
+mini_torch/nn.py,sha256=A97AS9mExiWO_4SWmMcGBNJXXPK0n5pJiQG63SDa7Vw,1526
+mini_torch_from_scratch-0.1.0.dist-info/licenses/LICENSE,sha256=6YR8E1abkg_9lfZxJwAIJPjOMOH-J0HBO2LXtNwR6A8,1092
+mini_torch_from_scratch-0.1.0.dist-info/METADATA,sha256=9bHMWx9beD8De6Bm7mSqxoSooCL-RUivu2V2R3kuYhU,2473
+mini_torch_from_scratch-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mini_torch_from_scratch-0.1.0.dist-info/top_level.txt,sha256=Tjy7Wli-5exd4kympiwVtQMpf-8564YZ-koIbi4Be4I,11
+mini_torch_from_scratch-0.1.0.dist-info/RECORD,,

mini_torch_from_scratch-0.1.0.dist-info/WHEEL

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

mini_torch_from_scratch-0.1.0.dist-info/licenses/LICENSE

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

mini_torch_from_scratch-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mini_torch