PaperlayerView exact revision on arXiv

Source-linked AI summary

The Architect: Interactive Visualization of Deep Learning Mathematics Directly in Microsoft Excel

Mohammad Imrul Jubair, Tom Yeh

arXiv:2608.13572v1cs.HCcs.AI

TL;DR

Deep learning software often hides the arithmetic learners and practitioners need to inspect. The Architect generates reactive, editable Excel workbooks that expose forward and backward computations, supporting tracing, experimentation, and diagnosis in small networks.

  • Problem

    Deep learning tools often hide the concrete numerical state and arithmetic needed for learning and debugging.

  • Method

    The Architect generates Excel blueprints that combine editable controls with native formulas for inputs, parameters, activations, losses, gradients, and updates.

  • Results

    The system supports arithmetic tracing, learning-rate comparisons, and direct inspection of activation-related gradient failures.

  • Takeaways & Limitations

    The workbook helps users interact directly with the arithmetic of learning in small educational and diagnostic networks.

  • Takeaways & Limitations

    The system targets educational- and diagnostic-scale MLPs and becomes unsuitable when matrices are too large, recalculation is slow, or architectures are non-sequential.

Abstract

from arXiv · show

We present The Architect, a system that turns Microsoft Excel into an interactive view of deep learning mathematics. A user describes a neural network in a compact table. The system then generates a workbook that shows the full forward pass and, when requested, the backward pass and parameter updates. Computed values appear as live spreadsheet formulas, while user-controlled values such as inputs, weights, labels, and hyperparameters remain editable. Excel reactively updates the dependent computations through its recalculation engine. Most deep learning tools hide the numerical details behind library calls. Many visualization tools show architecture diagrams or training summaries, but they do not expose the full arithmetic of the model. The Architect focuses on that missing middle layer. It makes matrices, activations, losses, gradients, and updates visible as inspectable spreadsheet regions, with editable controls for values users naturally manipulate. The system also produces aligned PyTorch snippets, which helps users connect formulas to implementation. This report describes the motivation, design, implementation, and use cases of The Architect. We show how the system supports introductory arithmetic tracing, learning-rate exploration, diagnosis of dying ReLU, and inspection of vanishing gradients. The main idea is simple: spreadsheets already support formulas, direct editing, reactive recomputation, and tabular layout. These properties make them a useful medium for understanding how small educational and diagnostic neural networks compute.

1 Introduction · 2 Background and Motivation

The Architect addresses the transparency gap in deep learning by generating reactive Microsoft Excel workbooks that expose neural-network arithmetic as editable controls and live formulas. The report presents this spreadsheet-native system as a systems and interaction design contribution supported by illustrative scenarios and classroom observations, not formal learning or usability evidence.

  • 1 Introduction: The Architect generates reactive spreadsheet blueprints from compact network specifications, exposing inputs, weights, activations, losses, gradients, and updates through editable controls and native formulas.Changing a weight, input, target label, or learning rate triggers Excel recalculation of dependent values.
  • 1 Introduction: Its spreadsheet-native interaction style lets users inspect and edit deep learning arithmetic directly, rather than inferring numerical behavior from hidden framework calls or summarized views.The system also produces illustrative scenarios for learning and diagnosis.
  • 1 Introduction: The report positions The Architect as a systems and interaction design contribution, while formal evidence of improved learning, transfer, usability, or debugging performance remains future work.Support comes from illustrative scenarios and classroom deployment observations.
  • 2.1 Why Current Tools Leave a Gap: Frameworks and visualization tools support execution, structure, or behavior, but commonly conceal the concrete numerical state and full chain of matrix operations, derivatives, and updates.This gap affects both students moving from equations to code and engineers diagnosing unstable loss or weak gradients.
  • 2.2 Why a Spreadsheet Is a Good Fit: Spreadsheets fit neural-network mathematics because tabular rows and columns map naturally to vectors and matrices, while formulas, direct editing, automatic recalculation, and familiarity support inspection.Users can examine one cell, row, or layer at a time, enabling gradual exploration for learning and debugging.
  • 2.3 Transparency Gap: The transparency gap includes black-box interiors: standard tooling often shows inputs and outputs without revealing the model’s full numerical path between them.Making internal arithmetic visible creates an opportunity to inspect computations directly in a familiar environment.
  • 2.3 Transparency Gap: Interface friction arises when explanatory systems require users to learn a new interface alongside the mathematics, whereas a spreadsheet lowers that cost.This complements the system’s direct editing and cell-level inspection model.
  • 2.3 Transparency Gap: Backpropagation blind spots persist because existing tools often emphasize forward computation or model structure and summarize training through scalar metrics instead of explicit gradient pathways.The Architect targets this missing visibility by exposing internal arithmetic for direct inspection.

3 Design Goals · 4 System Overview

The Architect is designed to make neural-network mathematics transparent, complete for training, easy to author, and reactively manipulable within Excel. Its workbook workflow turns compact layer specifications into inspectable blueprints, persistent multi-epoch traces, and code-linked examples using spreadsheet-native interaction.

  • 3 Design Goals: The design targets mathematical transparency, training completeness, low interaction overhead, and reactive manipulability.Users should see real numbers and formulas, inspect inference and learning computations, work in a familiar environment, and observe effects after recalculation.
  • 4.1 Workflow: The workflow combines an Excel workbook and Office Script: users specify supported layers or operations, then generate inference-only or training blueprints.Supported operations include Linear, ReLU, Tanh, GELU, LayerNorm, Flatten, Softmax, cross-entropy loss, and mean-squared-error loss; training adds backpropagation, multiple epochs, and a dashboard.
  • 4.2 Specification Interface: The Architect tab uses one row per layer or operation, allowing users to change a row, regenerate the workbook, and compare variants without rewriting model code.The interface also specifies input type, batch size, backpropagation, and the number of epochs to materialize.
  • 4.3 Blueprint Representation: The Blueprint sheet presents each operation as a left-to-right block containing labeled inputs, parameters, outputs, matrices, transformations, and visible formulas.Linear blocks expose input, weight, bias, and output matrices, while nonlinearities show element-wise transformations and results.
  • 4.4 Backpropagation and Multi-Epoch Views: With backpropagation enabled, the workbook exposes losses, derivatives, gradients, and updates, while linked epoch sheets preserve updated parameters for persistent training inspection.Users can inspect a specific epoch as a stable object rather than a transient loop, supporting discussion and debugging of weight changes or gradient patterns.
  • 4.5 Data and Code Bridges: The workbook includes tinyDigits classification examples and generates aligned PyTorch snippets that connect formula-level spreadsheet regions with code-level model components.Code fragments are linked to corresponding layer blocks, while each tinyDigits sample appears as a small pixel grid.
  • 4.6 Spreadsheet-Native Interaction Techniques: Excel-native features support formula inspection, variable navigation, block initialization, cross-epoch chaining, dependency tracing, and workbook duplication for comparison.Editing cells such as class indices or hyperparameters triggers workbook-wide recomputation.

5 Implementation

The Architect generates live Excel workbooks from compact network descriptions using registered, address-aware formula templates and Excel’s dynamic array engine. Its consistent spreadsheet layout supports inspection of small educational and diagnostic networks, while more complex operations remain future extensions.

  • Workbook generation: The TypeScript Office Script reads the Architect tab, infers layer dimensions, clears prior content, and programmatically constructs the workbook.A registry tracks generated ranges, variables, and named items so later formulas can reference earlier addresses.
  • Formula construction: Generated workbook regions contain parameterized formulas with cell addresses assembled during generation rather than static values.The registry stores semantic information about blocks because backward formulas depend on forward-pass geometry and earlier regions.
  • Live workbook behavior: Excel’s dynamic array engine lets the script write formulas into anchor cells that spill into matrix ranges, keeping formulas inspectable and edits live through recalculation.This liveness is central to the workbook’s interaction style, although careful formula assembly increases generation complexity.
  • Visual organization: A consistent visual grammar arranges forward blocks left to right, gradients toward earlier layers, and repeated operations with labels, spacing, and grouping.Reusing patterns makes later workbook regions easier to navigate after users understand one linear or activation block.
  • Scope and extensibility: The prototype targets small educational and diagnostic examples, supporting fully connected networks and common operations suited to rectilinear layouts rather than large-scale training.Convolution, attention, and residual connections require new layout primitives for spatial neighborhoods, multiple inputs, or non-sequential dependencies.

6 Using the System · 7 Illustrative Scenarios

Sections 6–7 show how The Architect supports forward-pass explanation, training inspection, classroom use, and interactive diagnosis of neural-network behavior. Across consistent workbook regions, users can edit values, trace arithmetic, compare variants, and connect high-level summaries to local formulas.

  • 6.1 Inference-Only Blueprints: Inference mode generates only the forward pass, supporting introductory explanation, shape reasoning, and inspection of intermediate activations.
  • 6.2 Training Blueprints: Training mode adds loss computation, backward regions, parameter updates, epoch sheets, and dashboard summaries, creating a persistent training trace.
  • 6.3 Authoring and Comparison Workflow: Users specify a network, generate its blueprint, inspect a phenomenon, modify values, and regenerate or compare variants.
  • 6.3 Authoring and Comparison Workflow: Consistent workbook layouts let users compare architectures or hyperparameters through corresponding regions without mentally mapping between different interfaces.
  • 7.1 Tracing Introductory Arithmetic: Users can trace a small MLP cell by cell, follow formulas from outputs to inputs and weights, and observe downstream changes after editing a weight.
  • 7.2 Classroom Deployment Observations: In one graduate AI course, 82 students received an Architect assignment and 76 submitted generated workbooks, but the observations were not a controlled evaluation of learning outcomes.
  • 7.3 Diagnosing Dying ReLU: The backward view exposes zero ReLU gradients for negative pre-activations and directly contrasts them with gradient flow after switching to Tanh.
  • 7.4 Exploring Learning-Rate Sensitivity: Changing one learning-rate cell propagates through update magnitudes, later weights, epoch sheets, and dashboard summaries, enabling comparisons of under-training, stable training, and divergence.

8 Design Rationale · 9 Broader Implications · 10 Discussion

The Architect uses Excel’s computational and inspection affordances to make neural-network arithmetic directly visible, editable, and reactive. Its design is most valuable for small educational and diagnostic models, while remaining constrained by Excel’s layout, scale, feature, and evaluation limitations.

  • 8.1 Why a Spreadsheet Representation Works: Spreadsheets fit neural-network computation because both use arrays, repeated transformations, explicit dependencies, visible formulas, grid layout, and automatic recomputation.The visible cells are the computation itself, rather than a separate picture of it.
  • 8.2 Why the System Generates Workbooks: Programmatic generation supports many user-specified architectures while materializing linked forward-pass, backward-pass, and multi-epoch training views.This avoids restricting the system to a fixed collection of hand-authored workbook examples while preserving spreadsheet inspectability.
  • 8.3 Why Epochs Are Materialized as Separate Sheets; 8.4 Why Large Figures Matter: Separate epoch sheets preserve earlier training states for comparison, export, and reference, while large figures help readers verify that workbook regions and matrix blocks remain readable.Legibility is treated as functional because users need coherent views of gradients and dashboard regions.
  • 9.1 Productivity Software as a Research Substrate; 9.2 Transparency as Interaction Design: The Architect illustrates how mature productivity software can serve as an interaction substrate and how transparency can be designed around inspecting prediction-generating processes.The broader implication is to repurpose an established tool rather than always building a new interface.
  • 9.3 From Explanation to Experimentation: Because the generated workbook remains reactive, one artifact can function as a worked example, debugging surface, and experimental sandbox.Its contribution includes supporting several kinds of work, not only providing a static representation.
  • 10.1 Why Excel: Excel’s mature environment supports formula inspection, precedent tracing, named ranges, sheet duplication, charts, and cross-sheet references as integrated inspection techniques.The prototype also has costs: unused interface features and a convention-based boundary between generated formulas and editable controls, which future protection and validation could strengthen.
  • 10.2 Scope and Limitations: The system targets educational- and diagnostic-scale MLPs, where users can inspect mechanisms such as shapes, matrix products, activations, gradients, updates, and attenuation.It is not intended for production-scale networks: readability fails as matrices grow, recalculation slows, and sequential specifications exclude residual connections, attention, and convolutions without new rules.
  • 10.2 Scope and Limitations; 10.3 Future Directions: The evidence consists of representative scenarios and classroom observations rather than controlled studies, and practical costs include recent Excel dependencies, growing workbook size, and increasing recalculation cost.Future directions include fuller PyTorch export, broader operators, empirical learning and debugging studies, and exploration of other spreadsheet environments; the prototype aims to make important computations inspectable rather than replace training pipelines.

11 Conclusion · A Additional Generated Examples · B Supplementary Examples

The Architect makes neural-network mathematics visible, inspectable, and editable in Excel through generated formula-based workbooks and editable controls. Supplementary examples demonstrate the breadth of generated workbook views and supported investigations across network configurations and user modifications.

  • 11 Conclusion: The Architect exposes forward passes, losses, gradients, and updates through native Excel formulas and editable controls.This lets users interact directly with the arithmetic of learning.
  • 11 Conclusion: The system is a complementary environment for understanding, teaching, and debugging small educational and diagnostic neural networks.It is not intended to replace mainstream machine learning tooling.
  • B Supplementary Examples: Supplementary cases show complete Architect, Blueprint, epoch, and dashboard tabs for multiple configurations.Together, they illustrate the range of network specifications The Architect can generate and the investigations its workbooks support.
  • B Supplementary Examples: The examples include linear and linear-plus-ReLU networks, multi-layer models with losses and normalization, image-shaped inputs, and flatten operations.These cases document varied generated network structures.
  • B Supplementary Examples: The appendix includes tinyDigits classification, randomly generated architectures with multi-epoch training traces, and cases involving manual edits after generation.Users can modify values or class indices after workbook generation.
  • B Supplementary Examples: Users can directly edit generated formulas to investigate alternative behaviors.The appendix organizes these exported workbook examples as cases so they document system breadth without interrupting the main narrative.

B.1 Appendix Overview … B.8.1 Architect

The appendix progresses from simple forward-only examples to image-based and tinyDigits networks, culminating in random multi-epoch architectures with forward, backpropagation, weight updates, dashboards, and aligned implementation views.

  • B.1 Appendix Overview: The examples progress from readable basic operations to random architectures, dashboards, and post-generation interventions.The appendix moves from simple forward-only cases toward larger multi-epoch training cases.
  • B.2 Example 1: Simplest Linear Architecture: A single linear layer provides the minimal forward-only, matrix-first representation of the system.This is described as the most direct illustration of the system’s matrix-first representation.
  • B.3 Example 2: Linear Layer Followed by ReLU: Adding ReLU shows how the blueprint expands when a pointwise nonlinearity follows a linear block.The example extends the minimal configuration with a ReLU activation.
  • B.4 Example 3: Multi-Layer Architecture with Loss: A deeper forward pipeline with multiple operations and a loss function lays out a longer sequence of transformations.The illustrated pipeline includes Linear, ReLU, Tanh, LayerNorm, Softmax, and CELoss operations.
  • B.5 Example 4: Image Input with Flatten; B.6 Example 5: Image Input with Additional Operations: Image-input examples first render image-shaped data and flatten it into the matrix pipeline before applying linear and nonlinear operations.The workflows extend from Image 6 7 1 Flatten to Image 3 7 1 Flatten and subsequent network transformations.
  • B.7 Example 6: tinyDigits Input: The tinyDigits example connects bundled dataset samples to downstream computation through Flatten, Linear, ReLU, Softmax, and CELoss.The displayed configuration is tinyDigits 5 1 Flatten ↓ Linear 4 ↓ ReLU ↓ Linear 10 ↓ Softmax ↓ CELoss ↓.
  • B.8 Example 7: Random Architecture with tinyDigits and Epoch Views: A randomly generated tinyDigits architecture extends the blueprint into a training trace with backpropagation, multiple epochs, and dashboard summaries.The architecture includes Tanh, ReLU, GELU, LayerNorm, Linear, and MSELoss operations.
  • B.8.1 Architect: The Architect view exposes Blueprint Epoch 1 Tab, Blueprint Epoch 2 Tab, Blueprint Inference Tab, Forward ▼ Backprop ▲ Weight Update, and aligned PyTorch training code.The code shows num_epochs = 3 and an SGD optimizer with lr=0.1, alongside loss computation, gradient reset, and backward propagation.

B.9 Example 8: Random Architecture with Image Input and Multi-Epoch Training · B.9.1 Architect

Example 8 demonstrates The Architect on a larger randomly generated image-input network, with multiple epoch sheets and a dashboard for inspecting training dynamics over time. Its Architect workbook traces a multi-layer forward path and exposes repeated training operations, including backpropagation and weight updates.

  • B.9 Example 8: Random Architecture with Image Input and Multi-Epoch Training: The example uses a larger randomly generated architecture with image input, multiple epoch sheets, and a dashboard for inspecting training dynamics across time.The example is explicitly presented as a larger random architecture and includes multiple epoch sheets plus a dashboard.
  • B.9.1 Architect: The image-input network begins with Image 4 11 7 and Flatten, then applies Linear, GELU, Tanh, Softmax, and CELoss stages.The listed architecture includes Linear 4, GELU, Tanh, GELU, Tanh, Linear 8, GELU, Linear 6, GELU, Linear 10, Softmax, and CELoss.
  • B.9.1 Architect: The Architect view labels the image inputs as Image # 1 through Image # 11.The workbook listing contains eleven image labels.
  • B.9.1 Architect: The aligned implementation iterates training with `for epoch in range(num_epochs):`.The code excerpt explicitly shows an epoch loop.
  • B.9.1 Architect: Each training iteration resets gradients, backpropagates the loss, and updates weights with `W -= lr * dW`.The implementation excerpt names `optimizer.zero_grad()`, `L.backward()`, and `optimizer.step()` alongside their gradient and update roles.
  • B.9.1 Architect: The displayed workbook organizes computation into Forward, Backprop, and Weight Update stages.The stage labels recur across the workbook views.
  • B.9.1 Architect: A dashboard view includes an Epochs display and tracks weights from G₀ through G₁₁.The visible labels include `2 1.8 Epochs` and a weights row spanning G₀ to G₁₁.

B.10 Example 9: Post-Generation Value and Class Modifications

Example 9 shows that users can modify generated values and class indices for investigation. It presents the workbook as an exploratory debugging surface rather than merely a static export.

  • Example 9 examines post-generation modifications to values and class indices for investigation purposes.
  • Users can change generated values and class indices after the workbook is created.
  • The workbook serves as an exploratory debugging surface, not only a static export.

B.10.1 Architect

The Architect represents a neural-network computation as an Excel-oriented sequence of layers, from input through loss. Its workbook includes blueprint tabs, PyTorch code, and controls for forward computation, backpropagation, and weight updates.

  • Architecture: The displayed network runs from input through random initialization, linear, ReLU, Tanh, LayerNorm, Softmax, and CELoss stages.The sequence includes Linear 7, Linear 8, Linear 7, and Linear 9 layers.
  • Workbook views: The workbook provides Blueprint tabs for Epoch 1, Epoch 2, and Inference.These tabs organize the displayed computation across training and inference views.
  • Implementation and training: The system pairs the spreadsheet with PyTorch code and exposes Forward, Backprop, and Weight Update views.The implementation view includes forward and backpropagation controls, while the training view includes weight updates.
  • Training loop: The training code computes the loss, resets gradients, backpropagates dL/dW, and updates weights with W -= lr * dW.The shown loop calls loss_fn, optimizer.zero_grad(), L.backward(), and optimizer.step().

B.11 Example 10: Post-Generation Formula Editing · B.11.1 Architect

The example shows that generated Excel workbooks remain editable computational artifacts, including direct formula changes such as removing first-layer bias terms. The Architect subsection presents the network blueprint, workbook tabs, and aligned PyTorch training structure.

  • B.11 Example 10: Post-Generation Formula Editing: Generated Excel formulas can be edited directly after generation, preserving the workbook as an editable computational artifact.The documented intervention removes bias terms in the first linear layer to inspect resulting behavioral changes.
  • B.11 Example 10: Post-Generation Formula Editing: Removing bias terms in the first linear layer provides a concrete post-generation modification for inspecting changed behavior.This example specifically targets the first linear layer's bias terms.
  • B.11.1 Architect: The Architect network runs from input through Rand, linear, activation, normalization, softmax, and CELoss stages.The listed sequence includes Linear 7, ReLU, Tanh, Linear 8, Linear 7, LayerNorm, Linear 9, Softmax, and CELoss.
  • B.11.1 Architect: The workbook organizes generated computations across Blueprint Epoch 1, Blueprint Epoch 2, and Blueprint Inference tabs.These three tabs are explicitly listed in the Architect view.
  • B.11.1 Architect: The Architect includes PyTorch code with forward and backpropagation views, connecting spreadsheet computations to implementation.The displayed implementation begins with torch imports and includes forward and backpropagation sections.
  • B.11.1 Architect: The training loop computes loss, resets gradients, backpropagates, and updates weights using the learning rate.The code shows L = loss_fn(X_out, target), optimizer.zero_grad(), L.backward(), and optimizer.step().
  • B.11.1 Architect: The Architect interface exposes Forward, Backprop, and Weight Update views for examining the training computation.These view labels appear in the workbook interface.
Loading 2608.13572v1…