hno-hammerstein 0.1.0__tar.gz

hno_hammerstein-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Freitas de Jesus and Luiz Alberto Luz de Almeida
+
+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.

hno_hammerstein-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: hno-hammerstein
+Version: 0.1.0
+Summary: Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis
+Author: Daniel Freitas de Jesus and Luiz Alberto Luz de Almeida
+License: MIT
+Project-URL: Homepage, https://github.com/seu-usuario/hno-hammerstein
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: numpy>=1.21.0
+Dynamic: license-file
+
+# HNO-Hammerstein
+
+**Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)
+
+This package implements a Neural Operator based on the classic Hammerstein structure, designed to model non-linear dynamic systems with memory, such as magnetic hysteresis. 
+
+Unlike traditional neural networks (DeepONet, FNO), the HNO architecture explicitly separates the static non-linearity (input) from the latent dynamics (memory), ensuring physical interpretability and generalization across different temporal resolutions.
+
+---
+
+## Arquitetura / Architecture
+
+![Arquitetura HNO-Hammerstein](https://raw.githubusercontent.com/seu-usuario/hno-hammerstein/main/docs/arquitetura.png)
+
+O fluxo de dados é:
+1. **Não Linearidade Estática (Static Non-linearity):** `z(t) = N_theta(H(t))`
+2. **Contexto Global (Global Context):** `c = E_phi(z(t))`
+3. **Dinâmica Latente (Latent Dynamics):** `s(t) = Integrate(f_psi(s, z, c))`
+4. **Saída (Output):** `B(t) = G_omega(s(t), z(t))`
+
+---
+
+## Instalação / Installation
+
+```bash
+pip install hno-hammerstein
+
+#Uso Rápido / Quick Start
+import torch
+from hno_hammerstein import HNOHammerstein
+
+# Instancia a rede / Instantiate the network
+model = HNOHammerstein(
+    nonlinear_dim=32,
+    context_dim=32,
+    state_dim=64,
+    hidden_dim=64,
+    dropout=0.05
+)
+
+# Cria uma entrada fictícia / Create a dummy input: (batch=1, Nt=198, 1)
+h = torch.randn(1, 198, 1)
+
+# Predição / Prediction
+B_pred = model(h)
+print(B_pred.shape)  # torch.Size([1, 198, 1])
+
+
+#Licença / License
+Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+#Citação / Citation
+bibtex
+@mastersthesis{freitas2026hno,
+  title={Hammerstein Neural Operator (HNO): Um Novo Operador Neural para Modelagem de Histerese Magnética},
+  authors={Freitas, Daniel,  Almeida, Luiz}
+  school={Universidade Federal do ABC (UFABC)},
+  year={2026}
+}

hno_hammerstein-0.1.0/README.md

@@ -0,0 +1,63 @@
+# HNO-Hammerstein
+
+**Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)
+
+This package implements a Neural Operator based on the classic Hammerstein structure, designed to model non-linear dynamic systems with memory, such as magnetic hysteresis. 
+
+Unlike traditional neural networks (DeepONet, FNO), the HNO architecture explicitly separates the static non-linearity (input) from the latent dynamics (memory), ensuring physical interpretability and generalization across different temporal resolutions.
+
+---
+
+## Arquitetura / Architecture
+
+![Arquitetura HNO-Hammerstein](https://raw.githubusercontent.com/seu-usuario/hno-hammerstein/main/docs/arquitetura.png)
+
+O fluxo de dados é:
+1. **Não Linearidade Estática (Static Non-linearity):** `z(t) = N_theta(H(t))`
+2. **Contexto Global (Global Context):** `c = E_phi(z(t))`
+3. **Dinâmica Latente (Latent Dynamics):** `s(t) = Integrate(f_psi(s, z, c))`
+4. **Saída (Output):** `B(t) = G_omega(s(t), z(t))`
+
+---
+
+## Instalação / Installation
+
+```bash
+pip install hno-hammerstein
+
+#Uso Rápido / Quick Start
+import torch
+from hno_hammerstein import HNOHammerstein
+
+# Instancia a rede / Instantiate the network
+model = HNOHammerstein(
+    nonlinear_dim=32,
+    context_dim=32,
+    state_dim=64,
+    hidden_dim=64,
+    dropout=0.05
+)
+
+# Cria uma entrada fictícia / Create a dummy input: (batch=1, Nt=198, 1)
+h = torch.randn(1, 198, 1)
+
+# Predição / Prediction
+B_pred = model(h)
+print(B_pred.shape)  # torch.Size([1, 198, 1])
+
+
+#Licença / License
+Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+#Citação / Citation
+bibtex
+@mastersthesis{freitas2026hno,
+  title={Hammerstein Neural Operator (HNO): Um Novo Operador Neural para Modelagem de Histerese Magnética},
+  authors={Freitas, Daniel,  Almeida, Luiz}
+  school={Universidade Federal do ABC (UFABC)},
+  year={2026}
+}

hno_hammerstein-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hno-hammerstein"
+version = "0.1.0"
+description = "Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Daniel Freitas de Jesus and Luiz Alberto Luz de Almeida"}
+]
+dependencies = [
+    "torch>=2.0.0",
+    "numpy>=1.21.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/seu-usuario/hno-hammerstein"

hno_hammerstein-0.1.0/setup.cfg

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

hno_hammerstein-0.1.0/src/hno_hammerstein/__init__.py

@@ -0,0 +1 @@
+from .model import HNOHammerstein

hno_hammerstein-0.1.0/src/hno_hammerstein/model.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+"""
+HNO-Hammerstein (Variante H2) — Hammerstein Neural Operator with Latent Dynamics.
+
+Fluxo estrito de Hammerstein:
+    H(t) --> N_theta --> z(t) --> Contexto c(z)
+                                --> Estado s(t) (dinâmica causal + contexto)
+                                --> Saída B(t) = G_omega(s(t), z(t))
+
+A dinâmica vê z(t) e c(z), mas NUNCA vê H(t) cru.
+A saída vê s(t) e z(t), mas NUNCA vê H(t) cru.
+"""
+
+import torch
+import torch.nn as nn
+
+
+# ============================================================
+# 1. BLOCO NÃO LINEAR ESTÁTICO (N_theta)
+# ============================================================
+class NonlinearStaticOperator(nn.Module):
+    def __init__(self, nonlinear_dim=32, hidden_dim=64, dropout=0.05):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(1, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, nonlinear_dim),
+            nn.Tanh(),  # Limita z(t) entre -1 e 1
+        )
+
+    def forward(self, h):
+        # h: (batch, Nt, 1) -> z: (batch, Nt, nonlinear_dim)
+        return self.network(h)
+
+
+# ============================================================
+# 2. ENCODER GLOBAL (E_phi): c = E_phi(z(t))
+# ============================================================
+class GlobalContextEncoder(nn.Module):
+    """
+    Aprende o contexto global a partir de z(t).
+    NÃO vê H(t) cru.
+    """
+    def __init__(self, nonlinear_dim=32, context_dim=32, hidden_dim=64):
+        super().__init__()
+        self.conv = nn.Sequential(
+            nn.Conv1d(nonlinear_dim, 32, kernel_size=5, padding=2),
+            nn.GELU(),
+            nn.Conv1d(32, 64, kernel_size=5, padding=2),
+            nn.GELU(),
+        )
+        self.projection = nn.Sequential(
+            nn.Linear(64 * 2, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, context_dim),
+            nn.Tanh(),
+        )
+
+    def forward(self, z):
+        # z: (batch, Nt, nonlinear_dim)
+        x = z.transpose(1, 2)  # (batch, nonlinear_dim, Nt)
+        features = self.conv(x)
+        avg = features.mean(dim=-1)      # (batch, 64)
+        maximum = features.amax(dim=-1)  # (batch, 64)
+        combined = torch.cat([avg, maximum], dim=-1)  # (batch, 128)
+        return self.projection(combined)  # (batch, context_dim)
+
+
+# ============================================================
+# 3. DINÂMICA LATENTE (f_psi): ds/dt = f(s, z, c, tau)
+# ============================================================
+class LatentDynamicOperator(nn.Module):
+    """
+    Estado latente evoluindo no tempo.
+    Entrada: z(t), contexto c, estado anterior s, tempo tau.
+    NÃO vê H(t) cru.
+    """
+    def __init__(self, nonlinear_dim=32, context_dim=32, state_dim=64, hidden_dim=64, dropout=0.05):
+        super().__init__()
+        self.state_dim = state_dim
+
+        # Estado inicial condicionado por c e z(0)
+        self.initial_state = nn.Sequential(
+            nn.Linear(context_dim + nonlinear_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, state_dim),
+            nn.Tanh(),
+        )
+
+        # Dinâmica: entrada = [s, z, c, tau] -> derivada
+        self.state_dynamics = nn.Sequential(
+            nn.Linear(state_dim + nonlinear_dim + context_dim + 1, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, state_dim),
+            nn.Tanh(),
+        )
+
+        self.state_gain = nn.Parameter(torch.tensor(1.0))
+
+    def forward(self, z, context):
+        # z: (batch, Nt, nonlinear_dim)
+        # context: (batch, context_dim)
+        batch, nt, _ = z.shape
+        dtau = 1.0 / (nt - 1)
+
+        s = self.initial_state(torch.cat([context, z[:, 0, :]], dim=-1))
+        states = []
+
+        for k in range(nt):
+            z_k = z[:, k, :]
+            tau_k = torch.full((batch, 1), k * dtau, device=z.device, dtype=z.dtype)
+            dynamic_input = torch.cat([s, z_k, context, tau_k], dim=-1)
+            derivative = self.state_dynamics(dynamic_input)
+
+            states.append(s)
+            if k < nt - 1:
+                s = s + dtau * self.state_gain * derivative
+
+        return torch.stack(states, dim=1)  # (batch, Nt, state_dim)
+
+
+# ============================================================
+# 4. OPERADOR DE SAÍDA (G_omega): B(t) = G(s(t), z(t))
+# ============================================================
+class OutputOperator(nn.Module):
+    """
+    Reconstrói B(t) a partir do estado s(t) e do sinal não linear z(t).
+    NÃO vê H(t) cru.
+    """
+    def __init__(self, state_dim=64, nonlinear_dim=32, hidden_dim=64, dropout=0.05):
+        super().__init__()
+        input_dim = state_dim + nonlinear_dim
+        self.decoder = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, hidden_dim // 2),
+            nn.GELU(),
+            nn.Linear(hidden_dim // 2, 1),
+        )
+
+    def forward(self, states, z):
+        decoder_input = torch.cat([states, z], dim=-1)
+        return self.decoder(decoder_input)
+
+
+# ============================================================
+# 5. HNO-HAMMERSTEIN COMPLETO (Variante H2)
+# ============================================================
+class HNOHammerstein(nn.Module):
+    """
+    Estrutura:
+        z = N(H)           (não linearidade estática)
+        c = E(z)           (contexto global)
+        s = Dinâmica(z,c)  (estado latente)
+        B = G(s, z)        (saída)
+    """
+    def __init__(
+        self,
+        nonlinear_dim=32,
+        context_dim=32,
+        state_dim=64,
+        hidden_dim=64,
+        dropout=0.05,
+    ):
+        super().__init__()
+        self.static_operator = NonlinearStaticOperator(nonlinear_dim, hidden_dim, dropout)
+        self.context_encoder = GlobalContextEncoder(nonlinear_dim, context_dim, hidden_dim)
+        self.dynamic_operator = LatentDynamicOperator(nonlinear_dim, context_dim, state_dim, hidden_dim, dropout)
+        self.output_operator = OutputOperator(state_dim, nonlinear_dim, hidden_dim, dropout)
+
+    def forward(self, h):
+        if h.ndim != 3 or h.shape[-1] != 1:
+            raise ValueError("h deve ter formato (batch, Nt, 1).")
+        if h.shape[1] < 2:
+            raise ValueError("Nt precisa ser >= 2.")
+
+        # 1. H -> z (não linearidade estática)
+        z = self.static_operator(h)
+
+        # 2. z -> c (contexto global)
+        context = self.context_encoder(z)
+
+        # 3. z, c -> s (dinâmica com memória)
+        states = self.dynamic_operator(z, context)
+
+        # 4. s, z -> B (saída)
+        B_hat = self.output_operator(states, z)
+
+        return B_hat

hno_hammerstein-0.1.0/src/hno_hammerstein.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: hno-hammerstein
+Version: 0.1.0
+Summary: Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis
+Author: Daniel Freitas de Jesus and Luiz Alberto Luz de Almeida
+License: MIT
+Project-URL: Homepage, https://github.com/seu-usuario/hno-hammerstein
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: numpy>=1.21.0
+Dynamic: license-file
+
+# HNO-Hammerstein
+
+**Hammerstein Neural Operator with Latent Dynamics for Magnetic Hysteresis**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/)
+
+This package implements a Neural Operator based on the classic Hammerstein structure, designed to model non-linear dynamic systems with memory, such as magnetic hysteresis. 
+
+Unlike traditional neural networks (DeepONet, FNO), the HNO architecture explicitly separates the static non-linearity (input) from the latent dynamics (memory), ensuring physical interpretability and generalization across different temporal resolutions.
+
+---
+
+## Arquitetura / Architecture
+
+![Arquitetura HNO-Hammerstein](https://raw.githubusercontent.com/seu-usuario/hno-hammerstein/main/docs/arquitetura.png)
+
+O fluxo de dados é:
+1. **Não Linearidade Estática (Static Non-linearity):** `z(t) = N_theta(H(t))`
+2. **Contexto Global (Global Context):** `c = E_phi(z(t))`
+3. **Dinâmica Latente (Latent Dynamics):** `s(t) = Integrate(f_psi(s, z, c))`
+4. **Saída (Output):** `B(t) = G_omega(s(t), z(t))`
+
+---
+
+## Instalação / Installation
+
+```bash
+pip install hno-hammerstein
+
+#Uso Rápido / Quick Start
+import torch
+from hno_hammerstein import HNOHammerstein
+
+# Instancia a rede / Instantiate the network
+model = HNOHammerstein(
+    nonlinear_dim=32,
+    context_dim=32,
+    state_dim=64,
+    hidden_dim=64,
+    dropout=0.05
+)
+
+# Cria uma entrada fictícia / Create a dummy input: (batch=1, Nt=198, 1)
+h = torch.randn(1, 198, 1)
+
+# Predição / Prediction
+B_pred = model(h)
+print(B_pred.shape)  # torch.Size([1, 198, 1])
+
+
+#Licença / License
+Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+#Citação / Citation
+bibtex
+@mastersthesis{freitas2026hno,
+  title={Hammerstein Neural Operator (HNO): Um Novo Operador Neural para Modelagem de Histerese Magnética},
+  authors={Freitas, Daniel,  Almeida, Luiz}
+  school={Universidade Federal do ABC (UFABC)},
+  year={2026}
+}

hno_hammerstein-0.1.0/src/hno_hammerstein.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/hno_hammerstein/__init__.py
+src/hno_hammerstein/model.py
+src/hno_hammerstein.egg-info/PKG-INFO
+src/hno_hammerstein.egg-info/SOURCES.txt
+src/hno_hammerstein.egg-info/dependency_links.txt
+src/hno_hammerstein.egg-info/requires.txt
+src/hno_hammerstein.egg-info/top_level.txt

hno_hammerstein-0.1.0/src/hno_hammerstein.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hno_hammerstein-0.1.0/src/hno_hammerstein.egg-info/requires.txt

@@ -0,0 +1,2 @@
+torch>=2.0.0
+numpy>=1.21.0

hno_hammerstein-0.1.0/src/hno_hammerstein.egg-info/top_level.txt

@@ -0,0 +1 @@
+hno_hammerstein