V5: W8A8 aprimorado (α aprendível via STE) + bug fix apply_w8a8_to_model + 4 hiperparâmetros auto-ajustáveis (T, τ, λ_ent, init_gate) + OOM-Killer fixes + num_layers_hyp=8 fixo

src/bigru_t/model/orq_cell.py

@@ -1,320 +1,37 @@
-"""orq_cell.py — OrqCell V6: Orquestrador com Mapa Auto-Organizável de Kohonen 4D.
-
-═══════════════════════════════════════════════════════════════════════════════
-V6 — MELHORIA MATEMÁTICA FUNDAMENTAL (vs V5)
-═══════════════════════════════════════════════════════════════════════════════
-
-Em V5, o OrqCell tinha um cache aprendível (L, d_cache) genérico, sem estrutura
-topológica. Em V6, o cache é um **Mapa Auto-Organizável de Kohonen (SOM) 4D**:
-
-ARRANJO QUADRIDIMENSIONAL:
-  Eixo 1 — módulo BiGRU4 (8 nós, um por BiGRU4 paralelo dentro de cada u8cell_T)
-  Eixo 2 — dimensão semântica do TransformerUnit (S_sem nós, default 4)
-  Eixo 3 — grid Kohonen X (S_x nós, default 4)
-  Eixo 4 — grid Kohonen Y (S_y nós, default 4)
-
-  Total de protótipos = 8 × S_sem × S_x × S_y (default: 8 × 4 × 4 × 4 = 512)
-
-Cada protótipo é um vetor ∈ R^{d_cache}. A topologia 4D define a vizinhança:
-  protótipos "próximos" no grid representam regiões semânticas próximas no
-  espaço latente das 8 BiGRU4 + TransformerUnit.
-
-ALGORITMO DE TREINO (Kohonen, diferenciável via STE):
-  Para cada entrada h ∈ R^{d_cache} (saída projetada de H):
-    1. Computa distâncias: d_i = ||h - w_i||² para todos os protótipos i
-    2. BMU (Best Matching Unit): i* = argmin_i d_i
-    3. Vizinhança gaussiana: h_i = exp(-dist_grid(i, i*)² / (2σ²))
-    4. Atualização (STE para argmin): w_i ← w_i + α · h_i · (h - w_i)
-       onde α é a taxa de aprendizado (decrescente), σ é a largura de vizinhança
-
-  O argmin não é diferenciável — usamos STE (gradiente passa direto) e uma
-  loss auxiliar de quantização: L_q = Σ_i h_i · ||h - w_i||² (ponderada pela
-  vizinhança, soft winner-takes-all).
-
-ÊNFASE NA VIZINHANÇA:
-  Em SOMs clássicos, σ decresce monotonicamente. Em V6, σ é **adaptativo**:
-  σ(t) = σ_min + (σ_max - σ_min) · exp(-t/τ_σ)
-  onde τ_σ é um hiperparâmetro aprendível (via MetaConfigurator V7).
-  Isso permite ao modelo decidir quão "loose" a vizinhança deve ser — em
-  fases de exploração (loss alta), σ grande (mais protótipos atualizados);
-  em fases de especialização (loss baixa), σ pequeno (apenas BMU).
-
-INTEGRAÇÃO COM CROSS-ATTENTION:
-  O SOM atua como "roteador topológico": para cada posição l do cache,
-  computa-se o BMU e a vizinhança, e pondera-se a contribuição dos K módulos
-  via cross-attention. A saída agregada combina:
-    - Informação topológica (BMU + vizinhança gaussiana)
-    - Informação de atenção (cross-attention cache↔módulos)
-
-REFERÊNCIAS:
-  - Kohonen, T. (1982). "Self-organized formation of topologically correct
-    feature maps". Biological Cybernetics, 43(1), 59-69.
-  - Kohonen, T. (2001). "Self-Organizing Maps" 3rd ed. Springer.
-  - Rojas, R. (2013). "Neural Networks" (cap. 17, SOM diferenciável).
-  - Van Hulle, M. M. (2012). "Self-organizing maps" (Handbook of Nat. Computing).
+"""orq_cell.py — OrqCell: orquestrador com cache aprendível + cross-attention.
+
+Reaproveita a filosofia do orquestrador cooperativo do v13.9.2, mas:
+- Cache aprendível (L, d_cache) substitui o "estado de trust" do v13.9.2
+- Cross-attention (cache = queries, módulos = keys/values) substitui o
+  gating por Confidence Gate
+- Média sobre as L posições do cache como saída agregada
+
+O cache é um "roteador aprendível" que decide quais módulos ativos devem
+contribuir para a representação final. Diferente do TrustNetwork do v13.9.2
+(TD-learning com softmax norm), o OrqCell usa attention pura — a seleção
+final dos módulos ativos é feita pelo Lema 1 no UnifiedModel.
 """
 from __future__ import annotations
 
-import math
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from typing import Optional
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# STE para argmin (Soft Winner-Takes-All com backward bem definido)
-# ═══════════════════════════════════════════════════════════════════════════
-class STEArgmin(torch.autograd.Function):
-    """Straight-Through Estimator para argmin.
-
-    Forward: retorna one-hot do argmin (winner-takes-all)
-    Backward: gradiente passa direto para todos os tensores de entrada
-              (distribuído uniformemente — aproximação soft)
-
-    Isso permite que o gradiente flua para os protótipos via a loss de
-    quantização L_q = Σ_i h_i · ||h - w_i||², mesmo que o BMU seja argmin.
-    """
-
-    @staticmethod
-    def forward(ctx, distances: torch.Tensor) -> torch.Tensor:
-        """distances: (..., N_prototypes) → one_hot: (..., N_prototypes)."""
-        bmu_idx = distances.argmin(dim=-1)  # (...)
-        one_hot = F.one_hot(bmu_idx, num_classes=distances.shape[-1]).to(
-            distances.dtype
-        )  # (..., N_prototypes)
-        ctx.save_for_backward(distances, one_hot)
-        return one_hot
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        distances, one_hot = ctx.saved_tensors
-        # STE: gradiente passa direto (distribuído proporcional ao 1/distance)
-        # Aproximação soft: gradientes maiores para protótipos mais próximos
-        # d/dw_i ||h - w_i||² = -2(h - w_i) → já flui naturalmente
-        return grad_output
-
-
-def ste_argmin(distances: torch.Tensor) -> torch.Tensor:
-    """Argmin com STE. Retorna one-hot do BMU."""
-    return STEArgmin.apply(distances)
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# KohonenSOM4D — Mapa Auto-Organizável 4D
-# ═══════════════════════════════════════════════════════════════════════════
-class KohonenSOM4D(nn.Module):
-    """Mapa Auto-Organizável de Kohonen 4D para o OrqCell V6.
-
-    Arranjo quadridimensional:
-      Eixo 0: módulo BiGRU4 (n_bigru=8)
-      Eixo 1: dimensão semântica do TransformerUnit (S_sem)
-      Eixo 2: grid Kohonen X (S_x)
-      Eixo 3: grid Kohonen Y (S_y)
-
-    Protótipos: tensor (n_bigru, S_sem, S_x, S_y, d_cache) — flatten para
-    N_prototypes = n_bigru × S_sem × S_x × S_y.
-
-    Vizinhança: gaussiana 4D no grid (distância Euclidiana entre índices 4D).
-
-    Args:
-        n_bigru: nº de BiGRU4 (default 8 — fixo na arquitetura u8cell_T)
-        S_sem: dimensão semântica do TransformerUnit (default 4)
-        S_x: tamanho do grid Kohonen X (default 4)
-        S_y: tamanho do grid Kohonen Y (default 4)
-        d_cache: dimensão do cache/protótipos
-        sigma_min: σ mínimo (vizinhança mínima — default 0.5)
-        sigma_max: σ máximo (vizinhança inicial — default 2.0)
-        alpha_init: taxa de aprendizado inicial (default 0.1)
-
-    Forward:
-        h: (batch, d_cache) →
-            bmu_onehot: (batch, N_prototypes) — one-hot do BMU
-            neighborhood: (batch, N_prototypes) — pesos gaussianos da vizinhança
-            quant_loss: escalar — Σ_i h_i · ||h - w_i||² (loss auxiliar)
-            bmu_4d: (batch, 4) — índice 4D do BMU (para logging)
-    """
-
-    def __init__(
-        self,
-        n_bigru: int = 8,
-        S_sem: int = 4,
-        S_x: int = 4,
-        S_y: int = 4,
-        d_cache: int = 128,
-        sigma_min: float = 0.5,
-        sigma_max: float = 2.0,
-        alpha_init: float = 0.1,
-    ):
-        super().__init__()
-        self.n_bigru = n_bigru
-        self.S_sem = S_sem
-        self.S_x = S_x
-        self.S_y = S_y
-        self.d_cache = d_cache
-        self.N_prototypes = n_bigru * S_sem * S_x * S_y
-
-        # Protótipos: (n_bigru, S_sem, S_x, S_y, d_cache) — inicializados pequenos
-        self.prototypes = nn.Parameter(
-            torch.randn(n_bigru, S_sem, S_x, S_y, d_cache) * 0.02
-        )
 
-        # Coordenadas 4D do grid (para computar vizinhança)
-        # Pré-computado: shape (N_prototypes, 4)
-        coords = []
-        for b in range(n_bigru):
-            for s in range(S_sem):
-                for x in range(S_x):
-                    for y in range(S_y):
-                        coords.append([float(b), float(s), float(x), float(y)])
-        self.register_buffer(
-            "grid_coords", torch.tensor(coords, dtype=torch.float32)
-        )  # (N_prototypes, 4)
 
-        # Hiperparâmetros de vizinhança (registrados como buffers, atualizados
-        # externamente pelo scheduler ou pelo MetaConfigurator)
-        self.register_buffer("sigma_min", torch.tensor(float(sigma_min)))
-        self.register_buffer("sigma_max", torch.tensor(float(sigma_max)))
-        self.register_buffer("alpha", torch.tensor(float(alpha_init)))
-        self.register_buffer("step_count", torch.tensor(0, dtype=torch.long))
-        # τ_σ: constante de tempo do decaimento de σ (aprendível no futuro)
-        self.register_buffer("tau_sigma", torch.tensor(100.0))
-
-    @property
-    def sigma_current(self) -> torch.Tensor:
-        """σ atual = σ_min + (σ_max - σ_min) · exp(-t/τ_σ)."""
-        decay = torch.exp(-self.step_count.float() / self.tau_sigma)
-        return self.sigma_min + (self.sigma_max - self.sigma_min) * decay
-
-    @property
-    def alpha_current(self) -> torch.Tensor:
-        """α atual = α_init · exp(-t/τ_α) com τ_α = 2·τ_σ."""
-        decay = torch.exp(-self.step_count.float() / (2.0 * self.tau_sigma))
-        return self.alpha * decay
-
-    def forward(
-        self,
-        h: torch.Tensor,
-        return_aux: bool = False,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Computa BMU, vizinhança e loss de quantização.
-
-        Args:
-            h: (batch, d_cache) — entrada (saída projetada de H)
-            return_aux: se True, retorna também bmu_4d e quant_loss detalhado
-
-        Returns:
-            bmu_onehot: (batch, N_prototypes) — one-hot do BMU (com STE)
-            neighborhood: (batch, N_prototypes) — pesos gaussianos
-            quant_loss: escalar — Σ_i h_i · ||h - w_i||² (auxiliary loss)
-        """
-        batch_size = h.shape[0]
-
-        # Flatten protótipos: (N_prototypes, d_cache)
-        W = self.prototypes.reshape(self.N_prototypes, self.d_cache)
-
-        # Distâncias Euidianas ao quadrado: (batch, N_prototypes)
-        # ||h - w_i||² = ||h||² - 2·h·w_i + ||w_i||²
-        h_sq = (h ** 2).sum(dim=-1, keepdim=True)            # (batch, 1)
-        w_sq = (W ** 2).sum(dim=-1, keepdim=True).t()         # (1, N_prototypes)
-        cross = h @ W.t()                                     # (batch, N_prototypes)
-        distances = h_sq - 2.0 * cross + w_sq                # (batch, N_prototypes)
-        distances = distances.clamp(min=0.0)                 # estabilidade numérica
-
-        # BMU via argmin com STE
-        bmu_onehot = ste_argmin(distances)  # (batch, N_prototypes)
-
-        # Vizinhança gaussiana 4D
-        # Para cada batch, pegar o BMU e computar pesos para todos os protótipos
-        bmu_idx = distances.argmin(dim=-1)  # (batch,)
-        bmu_coords = self.grid_coords[bmu_idx]  # (batch, 4)
-
-        # Distância 4D entre cada protótipo e o BMU
-        # grid_coords: (N_prototypes, 4), bmu_coords: (batch, 4)
-        # → (batch, N_prototypes, 4) via broadcasting
-        diff = self.grid_coords.unsqueeze(0) - bmu_coords.unsqueeze(1)  # (batch, N, 4)
-        grid_dist_sq = (diff ** 2).sum(dim=-1)  # (batch, N_prototypes)
-
-        sigma = self.sigma_current.clamp(min=1e-3)
-        neighborhood = torch.exp(-grid_dist_sq / (2.0 * sigma ** 2))  # (batch, N)
-
-        # Loss de quantização (soft winner-takes-all ponderado pela vizinhança)
-        # L_q = Σ_i h_i · ||h - w_i||²  (média sobre batch)
-        # Já temos distances = ||h - w_i||²
-        quant_loss = (neighborhood * distances).sum(dim=-1).mean()  # escalar
-
-        # Atualiza step_count (apenas em modo treino)
-        if self.training:
-            with torch.no_grad():
-                self.step_count += 1
-
-        if not return_aux:
-            return bmu_onehot, neighborhood, quant_loss
-
-        # Auxiliar para logging
-        bmu_4d = bmu_coords.long()  # (batch, 4)
-        return bmu_onehot, neighborhood, quant_loss, bmu_4d
-
-    @torch.no_grad()
-    def update_prototypes_online(self, h: torch.Tensor, bmu_onehot, neighborhood):
-        """Atualização online dos protótipos (estilo SOM clássico).
-
-        w_i ← w_i + α · h_i · (h - w_i)
-
-        Chamado externamente quando se quer fazer a atualização SOM explícita
-        (em adição à atualização por gradiente via quant_loss).
-        """
-        alpha = self.alpha_current
-        W = self.prototypes.reshape(self.N_prototypes, self.d_cache)
-        # h: (batch, d_cache), neighborhood: (batch, N_prototypes)
-        # Δw_i = α · Σ_batch h_i,batch · (h_batch - w_i) / batch_size
-        delta = neighborhood.t() @ h  # (N_prototypes, d_cache)
-        delta = delta - neighborhood.sum(dim=0, keepdim=True).t() * W  # (N, d_cache)
-        W.add_(alpha * delta / max(h.shape[0], 1))
-        self.prototypes.data = W.reshape(
-            self.n_bigru, self.S_sem, self.S_x, self.S_y, self.d_cache
-        )
-
-    def extra_repr(self) -> str:
-        return (
-            f"n_bigru={self.n_bigru}, S_sem={self.S_sem}, S_x={self.S_x}, "
-            f"S_y={self.S_y}, d_cache={self.d_cache}, "
-            f"N_prototypes={self.N_prototypes}, "
-            f"sigma={float(self.sigma_current.item()):.3f}, "
-            f"alpha={float(self.alpha_current.item()):.4f}, "
-            f"step={int(self.step_count.item())}"
-        )
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# OrqCell V6 — com KohonenSOM4D + Cross-Attention
-# ═══════════════════════════════════════════════════════════════════════════
 class OrqCell(nn.Module):
-    """OrqCell V6: Orquestrador com SOM 4D de Kohonen + cross-attention.
+    """Orquestrador com cache aprendível e cross-attention.
 
     Args:
-        cache_len: nº de posições no cache aprendível (L) — mantido para
-                   compatibilidade, mas em V6 o cache é o SOM 4D.
-        d_cache: dimensão do cache/protótipos
+        cache_len: nº de posições no cache aprendível (L)
+        d_cache: dimensão do cache
         d_model_in: dimensão de entrada (saída dos u8cell_T)
         nhead: nº de cabeças da cross-attention
         d_ff: dimensão interna do FFN
         dropout: probabilidade de dropout
-        n_bigru: nº de BiGRU4 no SOM (default 8)
-        S_sem, S_x, S_y: dimensões do SOM 4D
-        use_som: se True (default V6), usa SOM 4D; se False, cache V5 (compat)
 
     Forward:
         H: (batch, K, d_model_in) – saídas ponderadas dos K módulos
         → o: (batch, d_cache)
-        → (se return_aux=True) aux: dict com bmu_4d, quant_loss, neighborhood_entropy
-
-    V6 vs V5:
-      * Cache V5 = (L, d_cache) parâmetros livres, sem topologia
-      * Cache V6 = SOM 4D (8, S_sem, S_x, S_y, d_cache) com topologia Kohonen
-      * V6 adiciona loss de quantização L_q ao aux_dict
-      * V6 mantém cross-attention (cache=queries, módulos=keys/values)
-      * V6 computa BMU + vizinhança para cada batch
     """
 
     def __init__(
@@ -325,46 +42,23 @@ class OrqCell(nn.Module):
         nhead: int,
         d_ff: int,
         dropout: float = 0.1,
-        n_bigru: int = 8,
-        S_sem: int = 4,
-        S_x: int = 4,
-        S_y: int = 4,
-        use_som: bool = True,
     ):
         super().__init__()
         self.cache_len = cache_len
         self.d_cache = d_cache
-        self.use_som = use_som
+
+        # Cache aprendível (L, d_cache) — inicializado pequeno para estabilidade
+        self.cache = nn.Parameter(torch.randn(cache_len, d_cache) * 0.02)
 
         # Projeção da entrada para o espaço do cache
         self.proj_in = nn.Linear(d_model_in, d_cache)
 
-        if use_som:
-            # V6: SOM 4D de Kohonen como cache topológico
-            self.som = KohonenSOM4D(
-                n_bigru=n_bigru,
-                S_sem=S_sem,
-                S_x=S_x,
-                S_y=S_y,
-                d_cache=d_cache,
-            )
-            # Projeção do SOM (N_prototypes, d_cache) → (L, d_cache) para
-            # compatibilidade com a cross-attention (queries = L posições)
-            self.som_to_cache = nn.Linear(self.som.N_prototypes, cache_len, bias=False)
-            # Inicialização identidade-like (primeiras L linhas de N_prototypes)
-            with torch.no_grad():
-                eye = torch.eye(cache_len, self.som.N_prototypes)
-                self.som_to_cache.weight.copy_(eye * 0.1)
-        else:
-            # V5: cache aprendível simples (compat)
-            self.cache = nn.Parameter(torch.randn(cache_len, d_cache) * 0.02)
-
         # Cross-attention: queries = cache, keys/values = H_proj
         self.cross_attn = nn.MultiheadAttention(
             d_cache, nhead, dropout=dropout, batch_first=True
         )
 
-        # FFN (pre-norm style)
+        # FFN (pre-norm style, consistente com TransformerUnit)
         self.linear1 = nn.Linear(d_cache, d_ff)
         self.linear2 = nn.Linear(d_ff, d_cache)
         self.norm1 = nn.LayerNorm(d_cache)
@@ -373,59 +67,21 @@ class OrqCell(nn.Module):
         self.dropout2 = nn.Dropout(dropout)
         self.dropout_ff = nn.Dropout(dropout)
 
-    def forward(
-        self,
-        H: torch.Tensor,
-        return_aux: bool = False,
-    ) -> torch.Tensor:
-        """H: (batch, K, d_model_in) → o: (batch, d_cache).
-
-        Se return_aux=True, retorna (o, aux_dict) com métricas do SOM V6.
-        """
+    def forward(self, H: torch.Tensor) -> torch.Tensor:
+        """H: (batch, K, d_model_in) → o: (batch, d_cache)"""
         batch_size = H.size(0)
 
         # Projeta H para o espaço do cache
         H_proj = self.proj_in(H)  # (batch, K, d_cache)
 
-        # =====================================================================
-        # V6: Computa cache via SOM 4D
-        # =====================================================================
-        # h_mean: representação agregada de H para alimentar o SOM
-        h_mean = H_proj.mean(dim=1)  # (batch, d_cache)
-
-        if self.use_som:
-            # SOM forward: retorna bmu_onehot, neighborhood, quant_loss, [bmu_4d]
-            som_out = self.som(h_mean, return_aux=True)
-            bmu_onehot, neighborhood, quant_loss, bmu_4d = som_out
-
-            # Reconstrói cache topológico:
-            # Para cada batch, o cache é uma combinação linear dos protótipos,
-            # ponderada pela vizinhança gaussiana do BMU.
-            # cache_b = Σ_i neighborhood[b,i] · W[i]   → (batch, L, d_cache)
-            W_flat = self.som.prototypes.reshape(
-                self.som.N_prototypes, self.d_cache
-            )  # (N_prototypes, d_cache)
-            # cache_b: (batch, N_prototypes, d_cache) via broadcasting
-            cache_topo = neighborhood.unsqueeze(-1) * W_flat.unsqueeze(0)
-            # Reduz para (batch, L, d_cache) via projeção linear
-            # cache_topo: (batch, N_prototypes, d_cache) → transp → (batch, d_cache, N_prototypes)
-            # → som_to_cache → (batch, d_cache, L) → transp → (batch, L, d_cache)
-            cache = self.som_to_cache(cache_topo.transpose(1, 2)).transpose(1, 2)
-        else:
-            # V5 compat: cache é parâmetro (L, d_cache), expande para batch
-            cache = self.cache.unsqueeze(0).expand(batch_size, -1, -1)
-            quant_loss = torch.tensor(0.0, device=H.device)
-            bmu_4d = None
-            neighborhood = None
+        # Expande cache para o batch
+        cache = self.cache.unsqueeze(0).expand(batch_size, -1, -1)  # (batch, L, d_cache)
 
-        # =====================================================================
         # Cross-attention: queries = cache, keys/values = H_proj
-        # =====================================================================
+        # Pre-norm
         normed_cache = self.norm1(cache)
-        normed_H = self.norm1(H_proj)
-        attn_out, _ = self.cross_attn(
-            normed_cache, normed_H, normed_H, need_weights=False
-        )
+        normed_H = self.norm1(H_proj)  # compartilha norm1 (mesma dimensão)
+        attn_out, _ = self.cross_attn(normed_cache, normed_H, normed_H, need_weights=False)
         cache = cache + self.dropout1(attn_out)
 
         # FFN pre-norm
@@ -435,41 +91,4 @@ class OrqCell(nn.Module):
 
         # Saída = média sobre as L posições do cache
         o = cache.mean(dim=1)  # (batch, d_cache)
-
-        if not return_aux:
-            return o
-
-        # =====================================================================
-        # V6: Métricas auxiliares do SOM
-        # =====================================================================
-        aux = {
-            "som_quant_loss": float(quant_loss.item())
-            if isinstance(quant_loss, torch.Tensor)
-            else float(quant_loss),
-        }
-        if self.use_som:
-            aux["som_sigma"] = float(self.som.sigma_current.item())
-            aux["som_alpha"] = float(self.som.alpha_current.item())
-            aux["som_step"] = int(self.som.step_count.item())
-            aux["som_n_prototypes"] = self.som.N_prototypes
-            # Entropia da vizinhança (mede quão espalhada está a ativação)
-            if neighborhood is not None:
-                # Normaliza neighborhood para distribuição de probabilidade
-                neigh_norm = neighborhood / (neighborhood.sum(dim=-1, keepdim=True) + 1e-8)
-                entropy = -(neigh_norm * (neigh_norm + 1e-8).log()).sum(dim=-1).mean()
-                aux["som_neighborhood_entropy"] = float(entropy.item())
-                # Concentração do BMU (quanto menor, mais concentrado)
-                aux["som_bmu_concentration"] = float(
-                    bmu_onehot.sum(dim=-1).mean().item()
-                )
-            if bmu_4d is not None:
-                # Distribuição dos BMUs por eixo (para logging)
-                aux["som_bmu_axis0_mean"] = float(bmu_4d[:, 0].float().mean().item())
-                aux["som_bmu_axis1_mean"] = float(bmu_4d[:, 1].float().mean().item())
-                aux["som_bmu_axis2_mean"] = float(bmu_4d[:, 2].float().mean().item())
-                aux["som_bmu_axis3_mean"] = float(bmu_4d[:, 3].float().mean().item())
-
-        return o, aux
-
-
-__all__ = ["OrqCell", "KohonenSOM4D", "ste_argmin", "STEArgmin"]
+        return o