Spaces:
Sleeping
Sleeping
| # 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.") | |
| gr.Markdown("---") | |
| gr.Markdown("### Important Note") | |
| gr.Markdown( | |
| "The layered SKA Neural Network presented here is a discrete approximation (a \u201cshadow\u201d) of the underlying continuous " | |
| "[Riemannian Neural Field (RNF)](https://doi.org/10.13140/RG.2.2.35650.24001).\n\n" | |
| "It is provided for educational purposes only to illustrate the core mechanism of local entropy reduction through decision shifts \u0394D.\n\n" | |
| "The true SKA dynamics and all its deeper properties live in the continuous RNF. " | |
| "The layered discretization is useful for teaching and rapid experimentation, but it is not the complete theory." | |
| ) | |
| 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) | |