Upload 11 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/MNIST/raw/t10k-images-idx3-ubyte filter=lfs diff=lfs merge=lfs -text
+data/MNIST/raw/train-images-idx3-ubyte filter=lfs diff=lfs merge=lfs -text
+logo.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,222 @@
+# SKA Tensor Net Explorer - Gradio App
+import torch
+import torch.nn as nn
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from torchvision import datasets, transforms
+import gradio as gr
+
+# Load MNIST from local data
+transform = transforms.Compose([transforms.ToTensor()])
+mnist_dataset = datasets.MNIST(root='./data', train=True, download=False, transform=transform)
+
+
+class SKAModel(nn.Module):
+    def __init__(self, input_size=784, layer_sizes=[256, 128, 64, 10], K=50):
+        super(SKAModel, self).__init__()
+        self.input_size = input_size
+        self.layer_sizes = layer_sizes
+        self.K = K
+
+        self.weights = nn.ParameterList()
+        self.biases = nn.ParameterList()
+        prev_size = input_size
+        for size in layer_sizes:
+            self.weights.append(nn.Parameter(torch.randn(prev_size, size) * 0.01))
+            self.biases.append(nn.Parameter(torch.zeros(size)))
+            prev_size = size
+
+        self.Z = [None] * len(layer_sizes)
+        self.Z_prev = [None] * len(layer_sizes)
+        self.D = [None] * len(layer_sizes)
+        self.D_prev = [None] * len(layer_sizes)
+        self.delta_D = [None] * len(layer_sizes)
+
+        self.frobenius_history = [[] for _ in range(len(layer_sizes))]
+        self.tensor_net_history = [[] for _ in range(len(layer_sizes))]
+
+    def forward(self, x):
+        batch_size = x.shape[0]
+        x = x.view(batch_size, -1)
+        for l in range(len(self.layer_sizes)):
+            z = torch.mm(x, self.weights[l]) + self.biases[l]
+            self.frobenius_history[l].append(torch.norm(z, p='fro').item())
+            d = torch.sigmoid(z)
+            self.Z[l] = z
+            self.D[l] = d
+            x = d
+        return x
+
+    def calculate_tensor_net(self):
+        for l in range(len(self.layer_sizes)):
+            if self.Z[l] is not None and self.Z_prev[l] is not None:
+                delta_Z = self.Z[l] - self.Z_prev[l]
+                # Tensor Net: Σ (D − ∇_z H) · ΔZ
+                D_prime = self.D[l] * (1 - self.D[l])
+                nabla_z_H = (1 / np.log(2)) * self.Z[l] * D_prime
+                tensor_net_step = torch.sum(delta_Z * (self.D[l] - nabla_z_H))
+                self.tensor_net_history[l].append(tensor_net_step.item())
+
+    def ska_update(self, inputs, learning_rate=0.01):
+        for l in range(len(self.layer_sizes)):
+            if self.D_prev[l] is not None:
+                self.delta_D[l] = self.D[l] - self.D_prev[l]
+                prev_output = inputs.view(inputs.shape[0], -1) if l == 0 else self.D_prev[l-1]
+                d_prime = self.D[l] * (1 - self.D[l])
+                gradient = -1 / np.log(2) * (self.Z[l] * d_prime + self.delta_D[l])
+                dW = torch.matmul(prev_output.t(), gradient) / prev_output.shape[0]
+                self.weights[l] = self.weights[l] - learning_rate * dW
+                self.biases[l] = self.biases[l] - learning_rate * gradient.mean(dim=0)
+
+    def initialize_tensors(self):
+        for l in range(len(self.layer_sizes)):
+            self.Z[l] = None
+            self.Z_prev[l] = None
+            self.D[l] = None
+            self.D_prev[l] = None
+            self.delta_D[l] = None
+            self.frobenius_history[l] = []
+            self.tensor_net_history[l] = []
+
+
+def get_mnist_subset(samples_per_class, data_seed=0):
+    targets = mnist_dataset.targets.numpy()
+    rng = np.random.RandomState(data_seed)
+    images_list = []
+    for digit in range(10):
+        all_indices = np.where(targets == digit)[0]
+        rng.shuffle(all_indices)
+        for idx in all_indices[:samples_per_class]:
+            img, _ = mnist_dataset[idx]
+            images_list.append(img)
+    return torch.stack(images_list)
+
+
+def run_tensor_net(n1, n2, n3, n4, K, tau, samples_per_class, data_seed):
+    layer_sizes = [int(n1), int(n2), int(n3), int(n4)]
+
+    K = int(K)
+    samples_per_class = int(samples_per_class)
+    data_seed = int(data_seed)
+    learning_rate = tau / K
+
+    inputs = get_mnist_subset(samples_per_class, data_seed)
+
+    torch.manual_seed(42)
+    np.random.seed(42)
+    model = SKAModel(input_size=784, layer_sizes=layer_sizes, K=K)
+    model.initialize_tensors()
+
+    for k in range(K):
+        model.forward(inputs)
+        if k > 0:
+            model.calculate_tensor_net()
+            model.ska_update(inputs, learning_rate)
+        model.D_prev = [d.clone().detach() if d is not None else None for d in model.D]
+        model.Z_prev = [z.clone().detach() if z is not None else None for z in model.Z]
+
+    num_layers = len(layer_sizes)
+
+    # Plot: Tensor Net per layer with zero-crossing markers
+    fig, ax = plt.subplots(figsize=(8, 5))
+    for l in range(num_layers):
+        data = model.tensor_net_history[l]
+        line, = ax.plot(data, label=f"Layer {l+1}")
+        if len(data) > 1:
+            arr = np.array(data)
+            crossings = np.where(np.diff(np.sign(arr)))[0]
+            for c in crossings:
+                x_cross = c + arr[c] / (arr[c] - arr[c + 1])
+                ax.axvline(x=x_cross, color=line.get_color(), linestyle=':', linewidth=1.2, alpha=0.8)
+    ax.axhline(y=0, color='black', linewidth=0.8, linestyle='--')
+    ax.set_title("Tensor Net Evolution Across Layers")
+    ax.set_xlabel("Step Index K")
+    ax.set_ylabel("Tensor Net")
+    ax.legend()
+    ax.grid(True)
+    fig.tight_layout()
+
+    # Plot 2: Tensor Net vs ||Z||_F scatter per layer
+    fig2, axes2 = plt.subplots(2, (num_layers + 1) // 2, figsize=(12, 8))
+    axes2_flat = axes2.flatten() if num_layers > 1 else [axes2]
+    for l in range(num_layers):
+        ax = axes2_flat[l]
+        tn = model.tensor_net_history[l]
+        frob = model.frobenius_history[l][1:len(tn) + 1]
+        min_len = min(len(tn), len(frob))
+        if min_len < 2:
+            ax.set_title(f"Layer {l+1}: Not enough data")
+            continue
+        tn_plot = tn[:min_len]
+        frob_plot = frob[:min_len]
+        sc = ax.scatter(frob_plot, tn_plot, c=range(min_len), cmap='Blues_r', s=50, alpha=0.8)
+        ax.plot(frob_plot, tn_plot, 'k-', alpha=0.3)
+        plt.colorbar(sc, ax=ax, label='Step')
+        ax.axhline(y=0, color='black', linewidth=0.8, linestyle='--')
+        ax.set_xlabel('Frobenius Norm of Knowledge Tensor Z')
+        ax.set_ylabel('Tensor Net')
+        ax.set_title(f'Layer {l+1}: Tensor Net vs. Knowledge Magnitude')
+        ax.grid(True, alpha=0.3)
+    for l in range(num_layers, len(axes2_flat)):
+        axes2_flat[l].set_visible(False)
+    fig2.tight_layout()
+
+    return fig, fig2
+
+
+with gr.Blocks(title="SKA Tensor Net Explorer") as demo:
+    gr.Image("logo.png", show_label=False, height=100, container=False)
+    gr.Markdown("# SKA Tensor Net Explorer")
+    gr.Markdown("Visualize the Tensor Net per layer. The zero-crossing marks the transition from unstructured to structured knowledge accumulation.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            n1_input = gr.Slider(8, 512, value=256, step=8, label="Layer 1 \u2014 neurons")
+            n2_input = gr.Slider(8, 512, value=128, step=8, label="Layer 2 \u2014 neurons")
+            n3_input = gr.Slider(8, 256, value=64,  step=8, label="Layer 3 \u2014 neurons")
+            n4_input = gr.Slider(2, 64,  value=10,  step=1, label="Layer 4 \u2014 neurons")
+            k_slider = gr.Slider(1, 200, value=50, step=1, label="K (forward steps)")
+            tau_slider = gr.Slider(0.1, 0.75, value=0.5, step=0.01, label="Learning budget \u03c4 (\u03c4 = \u03b7\u00b7K)")
+            samples_slider = gr.Slider(1, 100, value=100, step=1, label="Samples per class")
+            seed_slider = gr.Slider(0, 99, value=0, step=1, label="Data seed (shuffle samples)")
+            run_btn = gr.Button("Run Tensor Net", variant="primary")
+
+            gr.Markdown("---")
+            gr.Markdown("### Definitions")
+            gr.Markdown(
+                "| Quantity | Definition |\n|---|---|\n"
+                "| **Tensor Net** | \u03a3 (D \u2212 \u2207z H) \u00b7 \u0394Z |\n"
+                "| **\u2207z H** | \u2212(1/ln2) \u00b7 z \u00b7 D(1\u2212D) |\n"
+                "| **Zero-crossing** | phase transition |"
+            )
+
+            gr.Markdown("---")
+            gr.Markdown("### Reference Paper")
+            gr.HTML('<a href="https://arxiv.org/abs/2504.03214v1" target="_blank">arXiv:2504.03214v1</a>')
+
+            gr.Markdown("""
+**Abstract**
+
+This paper aims to extend the Structured Knowledge Accumulation (SKA) framework recently proposed by mahi. We introduce two core concepts: the Tensor Net function and the characteristic time property of neural learning. First, we reinterpret the learning rate as a time step in a continuous system. This transforms neural learning from discrete optimization into continuous-time evolution. We show that learning dynamics remain consistent when the product of learning rate and iteration steps stays constant. This reveals a time-invariant behavior and identifies an intrinsic timescale of the network. Second, we define the Tensor Net function as a measure that captures the relationship between decision probabilities, entropy gradients, and knowledge change. Additionally, we define its zero-crossing as the equilibrium state between decision probabilities and entropy gradients. We show that the convergence of entropy and knowledge flow provides a natural stopping condition, replacing arbitrary thresholds with an information-theoretic criterion. We also establish that SKA dynamics satisfy a variational principle based on the Euler-Lagrange equation. These findings extend SKA into a continuous and self-organizing learning model. The framework links computational learning with physical systems that evolve by natural laws. By understanding learning as a time-based process, we open new directions for building efficient, robust, and biologically-inspired AI systems.
+            """)
+
+            gr.Markdown("---")
+            gr.Markdown("### SKA Explorer Suite")
+            gr.HTML('<a href="https://huggingface.co/quant-iota" target="_blank">\u2b05 All Apps</a>')
+            gr.Markdown("---")
+            gr.Markdown("### About this App")
+            gr.Markdown("The Tensor Net captures the balance between decision probabilities D and entropy gradients \u2207z H, weighted by the knowledge change \u0394Z at each step. When positive, the network is accumulating knowledge in the direction of the entropy gradient. The zero-crossing — marked by dotted vertical lines — signals the onset of structured knowledge accumulation.")
+
+        with gr.Column(scale=2):
+            plot_tensor = gr.Plot(label="Tensor Net per Layer")
+            plot_scatter = gr.Plot(label="Tensor Net vs Frobenius Norm")
+
+    run_btn.click(
+        fn=run_tensor_net,
+        inputs=[n1_input, n2_input, n3_input, n4_input, k_slider, tau_slider, samples_slider, seed_slider],
+        outputs=[plot_tensor, plot_scatter],
+    )
+
+demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

data/MNIST/raw/t10k-images-idx3-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fa7898d509279e482958e8ce81c8e77db3f2f8254e26661ceb7762c4d494ce7
+size 7840016

data/MNIST/raw/t10k-images-idx3-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d422c7b0a1c1c79245a5bcf07fe86e33eeafee792b84584aec276f5a2dbc4e6
+size 1648877

data/MNIST/raw/t10k-labels-idx1-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7ae60f92e00ec6debd23a6088c31dbd2371eca3ffa0defaefb259924204aec6
+size 4542

data/MNIST/raw/train-images-idx3-ubyte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba891046e6505d7aadcbbe25680a0738ad16aec93bde7f9b65e87a2fc25776db
+size 47040016

data/MNIST/raw/train-images-idx3-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:440fcabf73cc546fa21475e81ea370265605f56be210a4024d2ca8f203523609
+size 9912422

data/MNIST/raw/train-labels-idx1-ubyte.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3552534a0a558bbed6aed32b30c495cca23d567ec52cac8be1a0730e8010255c
+size 28881

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+matplotlib
+seaborn
+numpy