addernet 0.1.0__tar.gz

addernet-0.1.0/LICENSE

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

addernet-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include addernet/src/*.c
+include addernet/src/*.h
+include README.md
+include LICENSE

addernet-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: addernet
+Version: 0.1.0
+Summary: Neural network with zero multiplications at inference. AdderNet + Hyperdimensional Computing.
+License: MIT
+Project-URL: Homepage, https://github.com/addernet/addernet
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# AdderNet
+
+Rede neural que **não usa multiplicação** na inferência. Zero.
+
+```
+Rede normal:   resultado = entrada * peso + bias    (mulsd + addsd)
+AdderNet:      resultado = tabela[entrada + offset]  (1 acesso à memória)
+```
+
+## O que faz?
+
+AdderNet aprende funções usando **apenas adição e subtração** durante o treinamento, e na hora de prever o resultado basta **ler uma posição da tabela** — nenhuma conta de verdade.
+
+Funciona bem para funções de **uma variável**: converter Celsius em Fahrenheit, aprender `y = 3x + 7`, etc.
+
+## Instalação
+
+**Requisitos**: GCC, Python 3.8+, numpy
+
+```bash
+cd addernet_lib
+make
+```
+
+Isso gera `libaddernet.so`.
+
+## Uso (Python)
+
+```python
+from addernet import AdderNetLayer
+
+# Criar a rede
+rede = AdderNetLayer(size=256, bias=50, input_min=-50, input_max=200, lr=0.1)
+
+# Dados de treino: Celsius -> Fahrenheit
+celsius    = [0, 10, 20, 25, 30, 37, 50, 80, 100]
+fahrenheit = [32, 50, 68, 77, 86, 98.6, 122, 176, 212]
+
+# Treinar
+rede.train(celsius, fahrenheit)
+
+# Prever
+print(rede.predict(37))   # 98.60
+print(rede.predict(100))  # 212.00
+```
+
+### Salvar e carregar
+
+```python
+# Salvar modelo treinado
+rede.save("meu_modelo.bin")
+
+# Carregar depois
+rede = AdderNetLayer.load("meu_modelo.bin")
+print(rede.predict(37))  # 98.60
+```
+
+### Previsão em lote (numpy)
+
+```python
+import numpy as np
+
+entradas = np.array([0, 25, 37, 100], dtype=np.float64)
+saidas = rede.predict_batch(entradas)
+# array([32.0, 77.0, 98.6, 212.0])
+```
+
+### Usando em C
+
+```c
+#include "addernet.h"
+
+an_layer *rede = an_layer_create(256, 50, -50, 200, 0.1);
+
+double inputs[]  = {0, 10, 25, 37, 100};
+double targets[] = {32, 50, 77, 98.6, 212};
+an_train(rede, inputs, targets, 5, 1000, 4000);
+
+double resultado = an_predict(rede, 37.0);  // 98.60
+
+an_save(rede, "modelo.bin");
+an_layer_free(rede);
+```
+
+Compile com:
+```bash
+gcc -O3 -o meu_programa meu_programa.c -L. -laddernet -lm
+```
+
+## Performance
+
+| Método | Velocidade | vs Python puro |
+|---|---|---|
+| Python AdderNet (dict) | ~31K pred/s | 1x |
+| C AdderNet (uma por uma via ctypes) | ~1.3M pred/s | ~42x |
+| C AdderNet (lote numpy) | ~247M pred/s | ~8000x |
+
+Para melhor performance em Python, use `predict_batch()` com arrays numpy.
+
+## Exemplos prontos
+
+```bash
+cd addernet_lib
+
+# Converter Celsius -> Fahrenheit
+python3 examples/celsius_fahrenheit.py
+
+# Aprender funções de adição
+python3 examples/addition.py
+
+# Benchmark de performance
+python3 examples/benchmark.py
+```
+
+## Limitações
+
+- Funciona para funções de **uma variável** (entrada inteira -> saída double)
+- A entrada é truncada para int antes de indexar a tabela
+- Para valores fora do range de treino, a precisão diminui (extrapolação linear)
+- Não substitui redes neurais convencionais para problemas complexos (visão, linguagem, etc.)
+
+## Como funciona?
+
+1. **Treino**: Para cada amostra, testa se `peso + lr` ou `peso - lr` reduz o erro. Aplica a melhor direção.
+2. **Expansão**: Interpola entre os pontos de treino para gerar dados densos, e extrapola além das bordas usando a inclinação dos dois pontos mais próximos.
+3. **Inferência**: A tabela já tem o resultado final. É só acessar `tabela[(entrada + offset) & máscara]` — uma leitura de memória, zero aritmética.
+
+## Arquivos
+
+```
+addernet_lib/
+├── addernet.h          Cabeçalho da API
+├── addernet.c          Implementação em C
+├── addernet.py         Bindings Python (ctypes)
+├── Makefile            Compilação
+├── test_main.c         Teste em C
+└── examples/
+    ├── celsius_fahrenheit.py
+    ├── addition.py
+    └── benchmark.py
+```

addernet-0.1.0/README.md

@@ -0,0 +1,141 @@
+# AdderNet
+
+Rede neural que **não usa multiplicação** na inferência. Zero.
+
+```
+Rede normal:   resultado = entrada * peso + bias    (mulsd + addsd)
+AdderNet:      resultado = tabela[entrada + offset]  (1 acesso à memória)
+```
+
+## O que faz?
+
+AdderNet aprende funções usando **apenas adição e subtração** durante o treinamento, e na hora de prever o resultado basta **ler uma posição da tabela** — nenhuma conta de verdade.
+
+Funciona bem para funções de **uma variável**: converter Celsius em Fahrenheit, aprender `y = 3x + 7`, etc.
+
+## Instalação
+
+**Requisitos**: GCC, Python 3.8+, numpy
+
+```bash
+cd addernet_lib
+make
+```
+
+Isso gera `libaddernet.so`.
+
+## Uso (Python)
+
+```python
+from addernet import AdderNetLayer
+
+# Criar a rede
+rede = AdderNetLayer(size=256, bias=50, input_min=-50, input_max=200, lr=0.1)
+
+# Dados de treino: Celsius -> Fahrenheit
+celsius    = [0, 10, 20, 25, 30, 37, 50, 80, 100]
+fahrenheit = [32, 50, 68, 77, 86, 98.6, 122, 176, 212]
+
+# Treinar
+rede.train(celsius, fahrenheit)
+
+# Prever
+print(rede.predict(37))   # 98.60
+print(rede.predict(100))  # 212.00
+```
+
+### Salvar e carregar
+
+```python
+# Salvar modelo treinado
+rede.save("meu_modelo.bin")
+
+# Carregar depois
+rede = AdderNetLayer.load("meu_modelo.bin")
+print(rede.predict(37))  # 98.60
+```
+
+### Previsão em lote (numpy)
+
+```python
+import numpy as np
+
+entradas = np.array([0, 25, 37, 100], dtype=np.float64)
+saidas = rede.predict_batch(entradas)
+# array([32.0, 77.0, 98.6, 212.0])
+```
+
+### Usando em C
+
+```c
+#include "addernet.h"
+
+an_layer *rede = an_layer_create(256, 50, -50, 200, 0.1);
+
+double inputs[]  = {0, 10, 25, 37, 100};
+double targets[] = {32, 50, 77, 98.6, 212};
+an_train(rede, inputs, targets, 5, 1000, 4000);
+
+double resultado = an_predict(rede, 37.0);  // 98.60
+
+an_save(rede, "modelo.bin");
+an_layer_free(rede);
+```
+
+Compile com:
+```bash
+gcc -O3 -o meu_programa meu_programa.c -L. -laddernet -lm
+```
+
+## Performance
+
+| Método | Velocidade | vs Python puro |
+|---|---|---|
+| Python AdderNet (dict) | ~31K pred/s | 1x |
+| C AdderNet (uma por uma via ctypes) | ~1.3M pred/s | ~42x |
+| C AdderNet (lote numpy) | ~247M pred/s | ~8000x |
+
+Para melhor performance em Python, use `predict_batch()` com arrays numpy.
+
+## Exemplos prontos
+
+```bash
+cd addernet_lib
+
+# Converter Celsius -> Fahrenheit
+python3 examples/celsius_fahrenheit.py
+
+# Aprender funções de adição
+python3 examples/addition.py
+
+# Benchmark de performance
+python3 examples/benchmark.py
+```
+
+## Limitações
+
+- Funciona para funções de **uma variável** (entrada inteira -> saída double)
+- A entrada é truncada para int antes de indexar a tabela
+- Para valores fora do range de treino, a precisão diminui (extrapolação linear)
+- Não substitui redes neurais convencionais para problemas complexos (visão, linguagem, etc.)
+
+## Como funciona?
+
+1. **Treino**: Para cada amostra, testa se `peso + lr` ou `peso - lr` reduz o erro. Aplica a melhor direção.
+2. **Expansão**: Interpola entre os pontos de treino para gerar dados densos, e extrapola além das bordas usando a inclinação dos dois pontos mais próximos.
+3. **Inferência**: A tabela já tem o resultado final. É só acessar `tabela[(entrada + offset) & máscara]` — uma leitura de memória, zero aritmética.
+
+## Arquivos
+
+```
+addernet_lib/
+├── addernet.h          Cabeçalho da API
+├── addernet.c          Implementação em C
+├── addernet.py         Bindings Python (ctypes)
+├── Makefile            Compilação
+├── test_main.c         Teste em C
+└── examples/
+    ├── celsius_fahrenheit.py
+    ├── addition.py
+    └── benchmark.py
+```

addernet-0.1.0/addernet/__init__.py

@@ -0,0 +1,29 @@
+import os
+import sys
+from pathlib import Path
+
+_HERE = Path(__file__).parent
+
+if sys.platform == "darwin":
+    _lib_hdc_name = "libaddernet_hdc.dylib"
+    _lib_addernet_name = "libaddernet.dylib"
+elif sys.platform == "win32":
+    _lib_hdc_name = "addernet_hdc.dll"
+    _lib_addernet_name = "addernet.dll"
+else:
+    _lib_hdc_name = "libaddernet_hdc.so"
+    _lib_addernet_name = "libaddernet.so"
+
+_need_build = False
+if not (_HERE / _lib_hdc_name).exists() or not (_HERE / _lib_addernet_name).exists():
+    _need_build = True
+
+if _need_build:
+    from . import build_ext
+    build_ext.build()
+
+from .addernet import AdderNetLayer
+from .addernet_hdc import AdderNetHDC
+
+__version__ = "0.1.0"
+__all__ = ["AdderNetLayer", "AdderNetHDC"]

addernet-0.1.0/addernet/addernet.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+AdderNet Python Bindings — ctypes interface to libaddernet.so
+==============================================================
+
+Usage:
+    from addernet import AdderNetLayer
+
+    layer = AdderNetLayer(size=256, bias=50, input_min=-50, input_max=200, lr=0.1)
+    layer.train(inputs, targets, epochs_raw=1000, epochs_expanded=4000)
+    result = layer.predict(37.0)
+    layer.save("model.bin")
+"""
+
+import os
+import ctypes
+import numpy as np
+
+# ---- Locate shared library ----
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_LIB_NAMES = [
+    os.path.join(_HERE, "libaddernet.so"),
+    os.path.join(_HERE, "libaddernet.dylib"),
+    "libaddernet.so",
+]
+
+_lib = None
+for _name in _LIB_NAMES:
+    try:
+        _lib = ctypes.CDLL(_name)
+        break
+    except OSError:
+        continue
+
+if _lib is None:
+    raise OSError(
+        "Cannot find libaddernet.so. "
+        "Build it first: cd addernet_lib && make"
+    )
+
+# ---- Opaque pointer type ----
+
+_AnLayerPtr = ctypes.c_void_p
+
+# ---- Function signatures ----
+
+_lib.an_layer_create.restype  = _AnLayerPtr
+_lib.an_layer_create.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_double]
+
+_lib.an_layer_free.restype  = None
+_lib.an_layer_free.argtypes = [_AnLayerPtr]
+
+_lib.an_train.restype  = ctypes.c_int
+_lib.an_train.argtypes = [
+    _AnLayerPtr,
+    ctypes.POINTER(ctypes.c_double),
+    ctypes.POINTER(ctypes.c_double),
+    ctypes.c_int,
+    ctypes.c_int,
+    ctypes.c_int,
+]
+
+_lib.an_predict.restype  = ctypes.c_double
+_lib.an_predict.argtypes = [_AnLayerPtr, ctypes.c_double]
+
+_lib.an_predict_batch.restype  = ctypes.c_int
+_lib.an_predict_batch.argtypes = [
+    _AnLayerPtr,
+    ctypes.POINTER(ctypes.c_double),
+    ctypes.POINTER(ctypes.c_double),
+    ctypes.c_int,
+]
+
+_lib.an_save.restype  = ctypes.c_int
+_lib.an_save.argtypes = [_AnLayerPtr, ctypes.c_char_p]
+
+_lib.an_load.restype  = _AnLayerPtr
+_lib.an_load.argtypes = [ctypes.c_char_p]
+
+_lib.an_get_offset.restype  = ctypes.c_int
+_lib.an_get_offset.argtypes = [_AnLayerPtr, ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+
+_lib.an_get_size.restype  = ctypes.c_int
+_lib.an_get_size.argtypes = [_AnLayerPtr]
+
+_lib.an_get_bias.restype  = ctypes.c_int
+_lib.an_get_bias.argtypes = [_AnLayerPtr]
+
+_lib.an_get_input_min.restype  = ctypes.c_int
+_lib.an_get_input_min.argtypes = [_AnLayerPtr]
+
+_lib.an_get_input_max.restype  = ctypes.c_int
+_lib.an_get_input_max.argtypes = [_AnLayerPtr]
+
+_lib.an_get_lr.restype  = ctypes.c_double
+_lib.an_get_lr.argtypes = [_AnLayerPtr]
+
+
+# ---- Python wrapper ----
+
+class AdderNetLayer:
+    """
+    Python wrapper around the C an_layer struct.
+    Provides train / predict / predict_batch / save / load using numpy arrays.
+    """
+
+    def __init__(self, size=256, bias=50, input_min=-50, input_max=200, lr=0.1,
+                 _ptr=None):
+        if _ptr is not None:
+            self._ptr = _ptr
+        else:
+            self._ptr = _lib.an_layer_create(size, bias, input_min, input_max, lr)
+            if not self._ptr:
+                raise MemoryError("an_layer_create failed")
+
+    def __del__(self):
+        if hasattr(self, "_ptr") and self._ptr:
+            _lib.an_layer_free(self._ptr)
+            self._ptr = None
+
+    def train(self, inputs, targets, epochs_raw=1000, epochs_expanded=4000):
+        """Train on input→target pairs. Accepts lists or numpy arrays."""
+        inputs  = np.ascontiguousarray(inputs,  dtype=np.float64)
+        targets = np.ascontiguousarray(targets, dtype=np.float64)
+        n = len(inputs)
+        if len(targets) != n:
+            raise ValueError("inputs and targets must have same length")
+        ret = _lib.an_train(
+            self._ptr,
+            inputs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            targets.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            n, epochs_raw, epochs_expanded,
+        )
+        if ret != 0:
+            raise RuntimeError("an_train failed")
+
+    def predict(self, x):
+        """Single prediction. Returns float."""
+        return _lib.an_predict(self._ptr, float(x))
+
+    def predict_batch(self, inputs):
+        """Batch prediction. Accepts numpy array, returns numpy array."""
+        inputs  = np.ascontiguousarray(inputs, dtype=np.float64)
+        n = len(inputs)
+        outputs = np.empty(n, dtype=np.float64)
+        _lib.an_predict_batch(
+            self._ptr,
+            inputs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            outputs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            n,
+        )
+        return outputs
+
+    def save(self, path):
+        """Save layer to binary file."""
+        ret = _lib.an_save(self._ptr, path.encode("utf-8"))
+        if ret != 0:
+            raise IOError(f"an_save failed: {path}")
+
+    @classmethod
+    def load(cls, path):
+        """Load layer from binary file. Returns new AdderNetLayer."""
+        ptr = _lib.an_load(path.encode("utf-8"))
+        if not ptr:
+            raise IOError(f"an_load failed: {path}")
+        return cls(_ptr=ptr)
+
+    @property
+    def offset_table(self):
+        """Return the offset table as a numpy array."""
+        n = _lib.an_get_size(self._ptr)
+        buf = np.empty(n, dtype=np.float64)
+        _lib.an_get_offset(
+            self._ptr,
+            buf.ctypes.data_as(ctypes.POINTER(ctypes.c_double)),
+            n,
+        )
+        return buf
+
+    @property
+    def size(self):
+        return _lib.an_get_size(self._ptr)
+
+    @property
+    def bias(self):
+        return _lib.an_get_bias(self._ptr)
+
+    @property
+    def input_min(self):
+        return _lib.an_get_input_min(self._ptr)
+
+    @property
+    def input_max(self):
+        return _lib.an_get_input_max(self._ptr)
+
+    @property
+    def lr(self):
+        return _lib.an_get_lr(self._ptr)
+
+    def __repr__(self):
+        return (f"AdderNetLayer(size={self.size}, bias={self.bias}, "
+                f"range=[{self.input_min},{self.input_max}], lr={self.lr})")