latest changs

Dockerfile

@@ -1,25 +1,23 @@
-# Use the official lightweight Python image
+# Use Python 3.9
 FROM python:3.9-slim
 
-# Set the working directory inside the container
+# Set working directory
 WORKDIR /code
 
-# 1. Copy requirements first (for better caching)
+# 1. Install dependencies
+# We copy requirements first to cache them effectively
 COPY ./requirements.txt /code/requirements.txt
-
-# 2. Install dependencies
-# We use --no-cache-dir to keep the image small
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# 3. Copy the rest of the application code
+# 2. Copy the rest of the application
 COPY . /code
 
-# 4. Create a non-root user (Security Best Practice for HF Spaces)
+# 3. Security: Create a non-root user (Required for HF Spaces)
 RUN useradd -m -u 1000 user
 USER user
 ENV HOME=/home/user \
 	PATH=/home/user/.local/bin:$PATH
 
-# 5. Define the command to run the app
-# IMPORTANT: Hugging Face expects port 7860, not 8000!
+# 4. Run the application
+# IMPORTANT: Hugging Face listens on port 7860 by default!
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

instrumentation.py

@@ -123,9 +123,21 @@ class Instrumentor:
             # Get the layer name
             layer_name = instance.__class__.__name__
 
-            # Emit op event for the layer
+            # Build inputs list - for Linear, include weight and bias
+            inputs = [x]
             meta = {'layer_type': layer_name}
-            instrumentor.tracer.op(layer_name.lower(), [x], result, meta)
+            
+            # For Linear layers, include weight and bias for visualization
+            if layer_name == 'Linear':
+                if hasattr(instance, 'weight'):
+                    inputs.append(instance.weight)
+                    meta['has_weight'] = True
+                if hasattr(instance, 'bias') and instance.bias is not None:
+                    inputs.append(instance.bias)
+                    meta['has_bias'] = True
+
+            # Emit op event for the layer
+            instrumentor.tracer.op(layer_name.lower(), inputs, result, meta)
 
             return result
 

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+numpy
+# Add any other libraries you import in your python code

static/index.html

@@ -204,16 +204,17 @@
       min-width: 50px;
     }
 
-    .layout-grid { gap: 10px; }  /* display: inline-grid set above */
+    .layout-grid { gap: 8px; }  /* display: inline-grid set above */
     .layout-binary { 
       grid-template-columns: auto auto; 
       grid-template-rows: auto auto;
-      gap: 12px; 
+      gap: 8px; 
     }
     .layout-unary { grid-template-columns: auto; }
-    .pos-left { grid-row: 1 / 3; grid-column: 1; align-self: center; }
-    .pos-top { grid-row: 1; grid-column: 2; }
-    .pos-result { grid-row: 2; grid-column: 2; }
+    /* Matmul layout: a on left, b on top-right, result on bottom-right */
+    .pos-left { grid-row: 2; grid-column: 1; align-self: start; }
+    .pos-top { grid-row: 1; grid-column: 2; align-self: end; }
+    .pos-result { grid-row: 2; grid-column: 2; align-self: start; }
     
     /* Element-wise operation layout: inputs side by side, result below left */
     .layout-elementwise {
@@ -234,6 +235,18 @@
       padding: 0 8px;
       user-select: none;
     }
+    
+    /* Linear layer layout: matmul-style with X on top, W on left, result at intersection */
+    .layout-linear {
+      display: inline-grid;
+      grid-template-columns: auto auto;
+      grid-template-rows: auto auto;
+      gap: 8px;
+    }
+    .linear-empty { grid-row: 1; grid-column: 1; } /* Empty top-left cell */
+    .linear-input { grid-row: 1; grid-column: 2; align-self: end; } /* X on top, aligned to bottom */
+    .linear-weight { grid-row: 2; grid-column: 1; align-self: start; } /* W on left, aligned to top */
+    .linear-output { grid-row: 2; grid-column: 2; align-self: start; } /* Result aligned to top with W */
 
     /* TOOLBAR */
     #toolbar {
@@ -1352,6 +1365,7 @@ box("Loss Computation", [y_pred, target_probs, loss], "6")
     const isElementwise = ['add', 'sub', 'mul', 'div'].includes(type) && inputs.length >= 2;
     const isMatmul = type === 'matmul' && inputs.length >= 2;
     const isLoss = ['mseloss', 'crossentropyloss', 'bceloss'].includes(type) && inputs.length >= 2;
+    const isLinear = type === 'linear' && inputs.length >= 2 && meta?.has_weight;
     
     // Determine output orientation for reduction operations
     let outputOrientation = 'auto';
@@ -1434,6 +1448,41 @@ box("Loss Computation", [y_pred, target_probs, loss], "6")
       return;
     }
     
+    if (isLinear) {
+      // Linear layer: show as matmul with bias trick
+      // inputs[0] = x, inputs[1] = weight, inputs[2] = bias (optional)
+      const x = inputs[0];
+      const weight = inputs[1];
+      const bias = inputs.length > 2 ? inputs[2] : null;
+      
+      const wrapper = document.createElement('div');
+      wrapper.className = 'layout-linear';
+      
+      // Empty cell for top-left (matmul alignment)
+      const emptyCell = document.createElement('div');
+      emptyCell.className = 'linear-empty';
+      wrapper.appendChild(emptyCell);
+      
+      // Input X (top-right position, like matmul)
+      const inputCard = createMatrixCard(x.name || 'x', x);
+      inputCard.classList.add('linear-input');
+      wrapper.appendChild(inputCard);
+      
+      // Weight matrix (left position)
+      let weightLabel = weight.name || 'W';
+      const weightCard = createMatrixCard(weightLabel, weight);
+      weightCard.classList.add('linear-weight');
+      wrapper.appendChild(weightCard);
+      
+      // Output (bottom-right, result of x @ W + b)
+      const outputCard = createMatrixCard(output.name || 'y', output);
+      outputCard.classList.add('linear-output');
+      wrapper.appendChild(outputCard);
+      
+      container.appendChild(wrapper);
+      return;
+    }
+    
     if (isMatmul) {
       // Matrix multiplication: keep grid layout for proper alignment
       const grid = document.createElement('div');