AbstractIntegratedModule 1.1.8__tar.gz → 1.1.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractIntegratedModule
-Version: 1.1.8
+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.8 → abstractintegratedmodule-1.1.9}/AbstractIntegratedModule.py

@@ -1757,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
        
 
@@ -1872,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
         
 
     	
@@ -1889,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.
@@ -1901,7 +1989,6 @@ class MLP:
         self.layers = []
         self.layers2 = []
         self.lr = 0.1
-        self.feed_layers = []
 
         self.error_counts = None
         self.pred_counts = None
@@ -1911,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)
@@ -2092,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):
@@ -2204,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)     
@@ -2214,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
@@ -10267,8 +10330,6 @@ class IntegratedPipeline:
         model.add(layer1)
         model.add(layer2)
 
-        model.feed_add(layer1)
-        model.feed_add(layer2)
 
         return y_onehot
 
@@ -10289,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):