AbstractIntegratedModule 1.1.7.5__tar.gz → 1.1.9__tar.gz

{abstractintegratedmodule-1.1.7.5 → abstractintegratedmodule-1.1.9}/AbstractIntegratedModule.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.1.7.5
+Version: 1.1.9
 Summary: Integrated Pipeline with Specialized Non-LLM AI Agent Framework for ARM64 architecture
 Author: Micro-Novelty
 Author-email: Micro-Novelty <hernikpuspita5@gmail.com>

{abstractintegratedmodule-1.1.7.5 → abstractintegratedmodule-1.1.9}/AbstractIntegratedModule.py

@@ -730,6 +730,8 @@ class Transformer:
         
         self.cache = {}
 
+
+
     def _clear_forward_cache(self, keep_essential=True, max_age_forward_passes=5):
         """Clear cache entries older than max_age_forward_passes."""
         
@@ -1755,11 +1757,19 @@ class Transformer:
 
 class Dense:
     def __init__(self, x, input_size, output_size, activation=None):
-
         self.special_weight = GeometricWeightShaping(input_size, output_size)
         self.W = self.special_weight.weight_shaping(x)
-
         self.b = np.zeros((1, output_size))
+
+        self.params_shape = {
+            'W1': self.W.shape,
+            'b1': self.b.shape
+        }
+        self.params = {
+            'W1': self.W,
+            'b1': self.b
+        }
+        self.opt = AdamOptimizer(self.params_shape, lr=0.001, weight_decay=1e-4)
         self.activation_name = activation
        
 
@@ -1870,8 +1880,9 @@ class Dense:
 
         self.W -= (lr * dW) 
         self.b -= (lr * db) + (1.0 + perf_score) * 1e-5  # small bias regularization
-
-        return dx
+        
+        key_grads = {'W1': dW, 'b1': db}
+        return dx, key_grads
         
 
     	
@@ -1887,6 +1898,85 @@ class SoftmaxOutput:
         return dL_dZ
 
 
+
+
+class AdamOptimizer:
+    def __init__(self, params_shapes, lr=0.001, beta1=0.9, beta2=0.999,
+                 eps=1e-8, weight_decay=0.0, amsgrad=False):
+        """
+        params_shapes: dict of {param_name: shape} for every trainable param
+                        e.g. {'W1': (20,64), 'b1': (64,), 'W2': (64,3), 'b2': (3,)}
+        weight_decay:  decoupled weight decay coefficient (AdamW-style, 0 = off)
+        amsgrad:       if True, use the AMSGrad variant (max of v_hat history)
+        """
+        self.lr = lr
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.weight_decay = weight_decay
+        self.amsgrad = amsgrad
+        self.t = 0
+
+        self.m = {k: np.zeros(shape) for k, shape in params_shapes.items()}
+        self.v = {k: np.zeros(shape) for k, shape in params_shapes.items()}
+        if self.amsgrad:
+            self.v_max = {k: np.zeros(shape) for k, shape in params_shapes.items()}
+
+    def step(self, params, grads, lr=None, clip_norm=None):
+        self.t += 1
+        lr = self.lr if lr is None else lr
+        bc1 = 1 - self.beta1 ** self.t
+        bc2 = 1 - self.beta2 ** self.t
+
+        for key in grads:
+            g = grads[key]
+            g_shape = np.asarray(g).shape
+
+            # reinitialize any moment buffer whose shape has
+            # drifted from the current gradient, 
+            for buf_name, buf_dict in (('m', self.m), ('v', self.v)):
+                if key not in buf_dict or np.asarray(buf_dict[key]).shape != g_shape:
+                    if key in buf_dict:
+                        print(f'[⚠️] Adam: "{buf_name}" buffer for "{key}" stale '
+                            f'shape {np.asarray(buf_dict[key]).shape} != '
+                            f'expected {g_shape} — reinitializing to zeros')
+                    buf_dict[key] = np.zeros(g_shape)
+
+            if self.amsgrad and (key not in self.v_max or
+                                np.asarray(self.v_max[key]).shape != g_shape):
+                self.v_max[key] = np.zeros(g_shape)
+
+            if clip_norm is not None:
+                norm = np.linalg.norm(g)
+                if norm > clip_norm:
+                    g = g * (clip_norm / norm)
+
+            if self.weight_decay > 0:
+                params[key] -= lr * self.weight_decay * params[key]
+
+            self.m[key] = self.beta1 * self.m[key] + (1 - self.beta1) * g
+            self.v[key] = self.beta2 * self.v[key] + (1 - self.beta2) * (g ** 2)
+            m_hat = self.m[key] / bc1
+
+            if self.amsgrad:
+                self.v_max[key] = np.maximum(self.v_max[key], self.v[key])
+                v_hat = self.v_max[key] / bc2
+            else:
+                v_hat = self.v[key] / bc2
+
+            # distinguish "params also disagree" (a real backward()
+            # bug) from the moment-buffer case.
+            if np.asarray(params[key]).shape != g_shape:
+                raise ValueError(
+                    f'[!] params["{key}"] shape {np.asarray(params[key]).shape} '
+                    f'!= grads["{key}"] shape {g_shape} — trace backward() '
+                    f'for key "{key}", this is not a stale-buffer issue.'
+                )
+
+            params[key] -= lr * m_hat / (np.sqrt(v_hat) + self.eps)
+
+        return params
+
 # enhanced MLP with focused forward and backward for better handling of data with varying geometric complexity,
 # allowing it to complement the transformer module in the ensemble method.
 # providing robust performance across a wider range of data complexities by dynamically adjusting its learning focus based on the data's geometric properties.
@@ -1899,7 +1989,6 @@ class MLP:
         self.layers = []
         self.layers2 = []
         self.lr = 0.1
-        self.feed_layers = []
 
         self.error_counts = None
         self.pred_counts = None
@@ -1909,22 +1998,11 @@ class MLP:
         self.temp_anisotropy_sample = 0
 
         self.softmax = SoftmaxOutput()
-      
-
-    def feed_add(self, layer):
-        self.feed_layers.append(layer)
 
+      
     def add(self, layer):
         self.layers.append(layer)
 
-    def focused_forward(self, x, AME=None, anisotropy=None):    
-        performance_score = self.performance_calculation(x, AME=AME, anisotropy=anisotropy) 
-
-        for layer in self.feed_layers:
-            x = layer.forward(np.asarray(x, dtype=np.float64), performance_score)
-            
-        return self.softmax.forward(x) 
-
     def k_fold_split(self, X, y, k=5, seed=42, min_fold_size=2):
         X = np.asarray(X)
         y = np.asarray(y)
@@ -2090,21 +2168,13 @@ class MLP:
         return prob 
 
 
-    def focused_backward(self, grad, lr, AME, anisotropy):
-        grad = self.softmax.backward(grad)
-        perf_score = self.performance_calculation(grad, AME=AME, anisotropy=anisotropy)
-
-        for layer in reversed(self.feed_layers):
-            grad = layer.backward(grad, lr, perf_score)
-        return grad  
-
     def backward(self, grad, lr):
         grad = self.softmax.backward(grad)
         perf_score = self.performance_calculation(grad, AME=self.temp_AME_sample, anisotropy=self.temp_anisotropy_sample)
 
         for layer in reversed(self.layers):
-            grad = layer.backward(grad, lr, perf_score)
-        return grad
+            grad, key_grads = layer.backward(grad, lr, perf_score)
+        return grad, key_grads
             
     def predict(self, X, y, epochs=1000, verbose=True):
         for epoch in range(epochs):
@@ -2202,7 +2272,6 @@ class MLP:
     def train(self, X, y, epochs=1000, lr=0.01, verbose=True, max_samples_for_focused_fit=500):
         X = self._sanitize_string_chars(X)
         y = self._sanitize_string_chars(y)
-        focused_fit_condition = False
         parameters = sum(w.size for w in self.layers[0].W) + sum(b.size for b in self.layers[0].b)
 
         AME = self.AME_Encoder(X)     
@@ -2212,28 +2281,24 @@ class MLP:
         self.temp_AMR_sample = AMR
         self.temp_anisotropy_sample = anisotropy
 
-        focused_fit_condition = len(self.feed_layers) > 0 and anisotropy > 0.25 and AMR > 0.25 and len(X) < max_samples_for_focused_fit
-        print(f'[+] Focused fit condition: {focused_fit_condition} || Anisotropy: {self.anisotropy_measurement(X):.4f} || AME: {self.AME_Encoder(X):.4f}')
-
         training_not_allowed = np.isnan(anisotropy) or np.isinf(anisotropy) or np.isnan(AME) or np.isinf(AME) or AME < 0.1
         if training_not_allowed:
             print(f'[!] MLP Training not allowed due to unsuitable data characteristics. Anisotropy: {anisotropy:.4f}, AME: {AME:.4f}')
         else:
             print(f'[+] MLP Training started with: {parameters} Parameters.')
             for epoch in range(epochs):
-                if not focused_fit_condition:
-                    y_pred = self.forward(X, y=y, AME=AME, anisotropy=anisotropy, condition='training')
-                else:
-                    y_pred = self.focused_forward(X, AME=AME, anisotropy=anisotropy)
-
+                y_pred = self.forward(X, y=y, AME=AME, anisotropy=anisotropy, condition='training')
                 y_pred, y_true = self.adapt_predict_shape(y_pred, y)
                 
                 loss = Loss.categorical_crossentropy(y_true, y_pred)
                 grad = Loss.softmax_crossentropy_derivative(y_true, y_pred)
-                if focused_fit_condition:
-                    _ = self.focused_backward(grad, self.lr, AME, anisotropy)
-                else:
-                    _ = self.backward(grad, self.lr)
+                grad, key_grads = self.backward(grad, self.lr)
+                try:
+                    params = self.layers[0].opt.step(self.layers[0].params, key_grads, clip_norm=5.0)
+                except Exception as e:
+                    print(f'[>] AdamOptimizer failed: {e}')
+                    continue
+                
                 if np.isnan(loss) or np.isinf(loss):
                     if focused_fit_condition:
                         focused_fit_condition = False
@@ -3705,11 +3770,11 @@ class WeightedEnsemblePredictor:
         n_trans_classes = trans_probs.shape[1]        
         n_mlp_classes = mlp_probs.shape[1]
         
+        anisotropy = self.anisotropy_measurement(attn_weights)            
         n_classes = max(n_trans_classes, n_mlp_classes)       
         for i in range(batch_size):
             trans_row = np.zeros(n_classes)
-            mlp_row = np.zeros(n_classes)
-            
+            mlp_row = np.zeros(n_classes)         
             trans_row[:n_trans_classes] = trans_probs[i]
             mlp_row[:n_mlp_classes] = mlp_probs[i]
             
@@ -3717,8 +3782,7 @@ class WeightedEnsemblePredictor:
             mlp_row = mlp_row / (mlp_row.sum() + 1e-8)
 
             if i < len(attn_weights):
-                attn = attn_weights[i]
-                anisotropy = self.anisotropy_measurement(attn)                
+                attn = attn_weights[i]              
                 # Attention entropy: lower entropy = more focused = trust transformer more
                 if attn.size > 0:
                     attn_flat = attn.flatten()
@@ -3835,7 +3899,8 @@ class WeightedEnsemblePredictor:
             # Calculate weight based on meta features
             trans_conf = meta_features[i, 0]
             mlp_conf = meta_features[i, 1]
-            agreement = meta_features[i, 4]
+            agreement_idx = 6 if has_lstm else 4
+            agreement = meta_features[i, agreement_idx]
             
             trans_pred = int(np.argmax(trans_probs[i]))
             mlp_pred   = int(np.argmax(mlp_probs[i])) 
@@ -7240,7 +7305,7 @@ class AgentDistributedInference:
         # Sort keys for consistent serialization
         sorted_message = {k: signed_message[k] for k in sorted(signed_message.keys())}
 
-        message_bytes = json.dumps(sorted_message, sort_key=True, default=str).encode('utf-8')
+        message_bytes = json.dumps(sorted_message, sort_keys=True, default=str).encode('utf-8')
       
         key = self.secret_key.encode() if isinstance(self.secret_key, str) else self.secret_key
         signature = hmac.new(key, message_bytes, hashlib.sha256).hexdigest()
@@ -7354,7 +7419,7 @@ class AgentDistributedInference:
         # Sort keys for consistent serialization
         sorted_msg = {k: temp_msg[k] for k in sorted(temp_msg.keys())}
           
-        message_bytes = pickle.dumps(sorted_msg, protocol=pickle.HIGHEST_PROTOCOL)
+        message_bytes = json.dumps(sorted_msg, sort_keys=True, default=str).encode('utf-8')
          
         key = self.secret_key.encode() if isinstance(self.secret_key, str) else self.secret_key
         expected = hmac.new(key, message_bytes, hashlib.sha256).hexdigest()
@@ -7390,6 +7455,7 @@ class AgentDistributedInference:
             # Add to trusted list with FULL trust if not exists
             if agent_id not in self.trusted_agents:
                 self._add_trusted_agent(agent_id, token, TrustLevel.FULL, source="shared_secret")
+                return True
             else:
                 # Update trust level if higher
                 current_level = self.trusted_agents[agent_id].get('trust_level', TrustLevel.BASIC)
@@ -7397,6 +7463,7 @@ class AgentDistributedInference:
                     self.trusted_agents[agent_id]['trust_level'] = TrustLevel.FULL
                     print(f"[=] Upgraded trust level to FULL")
                     self.highly_trusted_peer.append(agent_id)
+                    return True
 
         elif agent_id in self.trusted_agents:
             stored_token = self.trusted_agents[agent_id]['token']
@@ -7493,7 +7560,7 @@ class AgentDistributedInference:
         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 
         bind_host = self._get_bind_host()
-        self.socket.bind(('0.0.0.0', self.port))
+        self.socket.bind((bind_host, self.port))
 
         self.socket.settimeout(1.0)
         self.socket.listen(5)
@@ -7572,7 +7639,7 @@ class AgentDistributedInference:
                     print(f"[-] Connection attempt from blocked IP: {host}")
                     self._log_security_event('connection_blocked', {'ip': host})
                     client.close()
-                    return
+                    continue
 
                 print(f"📡 Connected to agent at {addr}")
                 auth_msg = self._receive_message(client)
@@ -7587,7 +7654,7 @@ class AgentDistributedInference:
                     self._log_security_event('authentication_failed', {'agent': f"{addr[0]}:{addr[1]}"})
                     self.report_failure(id(self), 'authentication', reason=f'Failed authentication from {addr}')
                     client.close()
-                    return
+                    continue
 
                 # Send agent info to identify
                 self._send_agent_info(client)
@@ -10263,8 +10330,6 @@ class IntegratedPipeline:
         model.add(layer1)
         model.add(layer2)
 
-        model.feed_add(layer1)
-        model.feed_add(layer2)
 
         return y_onehot
 
@@ -10285,10 +10350,7 @@ class IntegratedPipeline:
         self.model3 = MLP() 
 
         self.model3.add(layer1)
-        self.model3.add(layer2)
-
-        self.model3.feed_add(first_feed_layer)   
-        self.model3.feed_add(sec_feed_layer)                
+        self.model3.add(layer2)               
 
         
     def automatic_parameterization(self, input_size, num_classes):