Conversation
fixed custom block ui
This is a pure migration from softmax-based loss inference to explicit loss function selection via a dedicated loss node. This fixes the critical bug where models with Softmax layers would incorrectly use CrossEntropyLoss, causing double softmax application. Changes: - Created backend loss nodes for PyTorch and TensorFlow - Added loss node validation in export views (required for export) - Updated orchestrators to extract loss config from loss node - Removed all has_softmax heuristic logic - Updated all processable node filters to skip 'loss' nodes - Loss function now explicitly specified by user via dropdown Supported loss types: - PyTorch: CrossEntropy, MSE, MAE, BCE, NLL, SmoothL1, KL Divergence - TensorFlow: SparseCategoricalCE, MSE, MAE, BCE, CategoricalCE, KL, Hinge Breaking change: Architectures without a loss node will now fail to export with a clear error message directing users to add the loss function node. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Implemented three critical enhancements to improve code generation quality and prevent silent failures: 1. Cycle Detection in Topological Sort - Added validation in base.py to detect cyclic graphs - Raises clear error if graph contains cycles - Lists nodes involved in the cycle for debugging - Prevents silent generation of incomplete code 2. Optimized Add Operation - Changed from torch.stack().sum(dim=0) to sum(tensor_list) - More efficient and cleaner implementation - Updated both template and legacy code - TensorFlow already uses optimal keras.layers.Add() 3. Improved Add/Concat Shape Validation - Enhanced validate_incoming_connection() for Add nodes - Enhanced validate_incoming_connection() for Concat nodes - Validates input shapes are defined - Validates concat dimension is valid for tensor rank - Better error messages for debugging 4. Comprehensive Loss Node Skip Coverage - Added 'loss' to all node filtering locations - Updated validation.py, enhanced_pytorch_codegen.py - Updated group generators (PyTorch & TensorFlow) - Updated base_orchestrator.py layer counting - Ensures loss nodes are consistently excluded from layer generation All changes maintain backward compatibility and add safety checks without breaking existing functionality. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Fixed overlapping title and port labels in the Loss function node: 1. Improved Port Positioning - Changed port spacing to start at 40% (was 33%) - Ports now distributed from 40% to 100% of card height - Prevents overlap with title/header section at top - Single port centers at 50% for better appearance 2. Enhanced Port Labels - Added backdrop-blur-sm for better readability - Increased z-index to ensure labels appear above other elements - Added shadow-sm for better visual separation 3. Output Handle Improvements - Added "Loss" label to output handle for clarity - Positioned output consistently with input labels - Maintained red color scheme for loss output 4. Card Height - Set minimum height of 120px for loss nodes - Ensures sufficient space for multiple input ports - Prevents cramped appearance Result: Clean, non-overlapping layout with clear port labeling for all loss function configurations. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Complete redesign of Loss node UI to prevent label overflow: 1. Port Labels Inside Card - Moved port labels into card content area (not floating) - Added "Inputs" section with color-coded port indicators - Labels now: red dot + "Predictions", orange dot + "Ground Truth" - Clean, contained layout 2. Simplified Handle Rendering - Handles positioned at card edges (33%, 66% for 2 ports) - Removed floating external labels - Color-coded handles match internal port indicators - Red/orange handles for inputs, red for output 3. Better Visual Design - Color dots (red, orange) match handle colors - Uppercase "INPUTS" section header - Proper spacing with space-y-1 - No more absolute positioning issues 4. Responsive Layout - Card height expands naturally with content - No fixed min-height constraints - Works for any number of ports (2-3) Result: Clean, professional loss node UI with all labels safely contained within card boundaries. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Improved handle positioning to align perfectly with port labels: 1. Pixel-Based Positioning - Changed from percentage to pixel-based positioning - Handles now positioned at fixed pixel offsets - Accounts for card padding, header, and label spacing 2. Calculated Alignment - 2 ports: handles at 60px and 82px from top - 3 ports: handles at 56px, 72px, and 88px from top - Aligns with actual rendered label positions 3. Label Row Enhancement - Added relative positioning to label rows - Added ID for potential future reference - Maintains color coordination Result: Input handles now align perfectly with their corresponding label text for a polished, professional look. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Added dedicated Ground Truth node for cleaner network design:
1. New GroundTruthNode
- Dedicated source node for ground truth labels
- Simpler alternative to DataLoader for labels only
- Category: Input & Data (orange color, Target icon)
- Configuration:
• Label Shape: JSON array (e.g., [1, 10])
• Custom Label: Optional custom name
• Note: Optional documentation
2. Security Enhancement
- Removed CSV upload functionality from DataLoader
- Prevents users from uploading massive files to server
- Eliminated csv_file and csv_filename config fields
- Maintains randomize option for synthetic data
3. Type System Updates
- Added 'groundtruth' to BlockType union
- Updated BlockNode exclusions for config warnings
- Auto-registered in node registry via index export
Benefits:
- Clearer separation of concerns (data vs labels)
- Simpler loss function connections
- Better visual organization in complex networks
- Enhanced server security (no large file uploads)
Usage:
Users can now create a Ground Truth node, configure
the label shape, and connect it directly to loss
function label inputs for cleaner network designs.
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Updated shape inference to properly handle all source node types:
1. Shape Propagation Initialization
- Previously: Only started from 'input' nodes
- Now: Starts from all source nodes (input, dataloader, groundtruth)
- Ensures all data sources trigger shape inference
2. Source Node Shape Computation
- Added dataloader and groundtruth to source node check
- Source nodes compute output shape from config alone
- No input shape required (they are data sources)
3. Benefits
- DataLoader output shapes propagate correctly to connected layers
- Ground Truth shapes propagate to loss function inputs
- Network architecture validates properly from all entry points
- Users see correct shape information throughout the flow
How It Works:
- When a DataLoader/GroundTruth is added or configured:
→ Shape computed from node config
→ Shape propagates to connected downstream nodes
→ Each layer computes its output from upstream input
→ Full network shape validation works correctly
Example Flow:
DataLoader [1,3,224,224] → Conv2D → Linear → Softmax
↓ ↓ ↓
[1,64,112,112] [1,128] [1,10]
Ground Truth [1,10] → Loss (Ground Truth input)
Previously, shapes might not propagate from DataLoader,
causing downstream nodes to show "Configure params" errors.
Now all source nodes properly initialize shape propagation.
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Fixed shape computation to be immediate and reactive: 1. addEdge - Immediate Output Shape Computation BEFORE: - Only set inputShape on target node - Relied on deferred inferDimensions() call - Output shape updated later asynchronously AFTER: - Set inputShape AND compute outputShape immediately - Uses targetNodeDef.computeOutputShape(newInput, config) - Changes visible instantly to user - Downstream propagation via inferDimensions() still occurs 2. updateNode - Config Change Shape Recalculation BEFORE: - Only updated node data - Called inferDimensions() for propagation - Current node's shape not immediately updated AFTER: - Detects config changes - Immediately recomputes outputShape for changed node - Handles source nodes (input/dataloader/groundtruth) specially - Uses inputShape for transform nodes - Propagates downstream via inferDimensions() 3. Benefits ✅ Instant visual feedback when connecting nodes ✅ Real-time shape updates when changing parameters ✅ Correct shape display before async propagation ✅ No stale shape data ✅ Better UX - immediate, not deferred Example Flow: User connects DataLoader → Conv2D: 1. Edge added 2. Conv2D.inputShape = [1, 3, 224, 224] (immediate) 3. Conv2D.outputShape = [1, 64, 112, 112] (immediate!) 4. inferDimensions() propagates to downstream nodes 5. User sees correct shape instantly User changes Conv2D out_channels: 64 → 128: 1. Config updated 2. Conv2D.outputShape recalculated: [1, 128, 112, 112] (immediate!) 3. inferDimensions() propagates to downstream nodes 4. All connected nodes update reactively This eliminates the lag between user actions and shape updates, providing a more responsive and intuitive experience. https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Input nodes are graph boundary markers, not data transformers:
1. Input Node Behavior
BEFORE:
- Always treated as source node
- Always computed shape from config
- Ignored incoming DataLoader connection
AFTER:
- Passthrough when connected to DataLoader
- Source when standalone (no incoming edges)
- Output shape = Input shape (no transformation)
2. Shape Inference Logic (inferDimensions)
Input Node Handling:
- If has incoming edges (connected to DataLoader):
→ inputShape = DataLoader.outputShape
→ outputShape = computeOutputShape(inputShape, config)
→ Result: outputShape = inputShape (passthrough)
- If no incoming edges (standalone):
→ outputShape = computeOutputShape(undefined, config)
→ Uses configured shape
→ Acts as source node
3. Propagation Starting Points
BEFORE:
- All Input, DataLoader, GroundTruth nodes
AFTER:
- All DataLoader nodes (always source)
- All GroundTruth nodes (always source)
- Input nodes WITHOUT incoming edges (acting as source)
- Input nodes WITH incoming edges are processed via dependency chain
4. Config Update Handling (updateNode)
Input Node Logic:
- Has inputShape → passthrough (output = input)
- No inputShape → source (output from config)
Example Flows:
Connected Input (Passthrough):
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ DataLoader │ → │ Input │ → │ Conv2D │
│ [1,3,224,224│ │ [1,3,224,224│ │ [1,64,112...]│
└─────────────┘ │ ↓ ↓ ↓ │ └─────────────┘
│ Same shape! │
└─────────────┘
Standalone Input (Source):
┌─────────────┐ ┌─────────────┐
│ Input │ → │ Conv2D │
│ [1,3,224,224│ │ [1,64,112...]│
│ (from config) └─────────────┘
└─────────────┘
Benefits:
✅ Input nodes correctly act as passthrough markers
✅ Shape flows naturally from DataLoader → Input → Model
✅ Input nodes can still be used standalone as sources
✅ No shape transformation at graph boundaries
✅ Cleaner, more intuitive behavior
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Two critical fixes for Loss and GroundTruth nodes:
1. GROUND TRUTH PORT SEMANTIC FIX
Problem:
- GroundTruth node used default output port (semantic: 'data')
- Loss node expects ground truth input (semantic: 'labels')
- Port compatibility check blocks 'data' → 'labels' connections
- Result: "Connection not allowed" error
Port Compatibility Logic (ports.ts):
```typescript
// 'labels' can only connect to 'labels'
if (source.semantic === 'labels') {
return target.semantic === 'labels'
}
// 'data' cannot connect to 'labels'
if (source.semantic === 'data') {
return ['data', 'anchor', 'positive', 'negative',
'predictions', 'input1', 'input2'].includes(target.semantic)
// 'labels' NOT included! ❌
}
```
Solution:
- Override getOutputPorts() in GroundTruthNode
- Set semantic: 'labels' instead of 'data'
- Now GroundTruth → Loss connection works! ✅
Changes to groundtruth.ts:
```typescript
getOutputPorts(config: BlockConfig): PortDefinition[] {
return [{
id: 'default',
label: 'Labels',
type: 'output',
semantic: 'labels', // ← Changed from 'data'
required: false,
description: 'Ground truth labels for training'
}]
}
```
2. LOSS NODE OUTPUT HANDLE REMOVAL
Problem:
- Loss nodes had output ports defined
- Loss functions are terminal/sink nodes
- They compute a scalar loss value for training
- Should NOT have outgoing connections
Before (loss.ts):
```typescript
getOutputPorts(config: BlockConfig): PortDefinition[] {
return [{
id: 'loss-output',
label: 'Loss',
type: 'output',
semantic: 'loss',
required: false,
description: 'Scalar loss value'
}]
}
```
After:
```typescript
getOutputPorts(config: BlockConfig): PortDefinition[] {
return [] // ← No output ports!
}
```
Result:
- No output handle shown on Loss nodes ✅
- Loss nodes act as proper terminal nodes ✅
- Prevents invalid downstream connections ✅
Connection Flow Examples:
BEFORE:
┌─────────────┐
│ GroundTruth │ semantic: 'data'
└──────┬──────┘
│ ❌ BLOCKED
↓
┌──────▼──────┐
│ Loss │ expects semantic: 'labels'
│ │ has output handle
└──────┬──────┘
│ Invalid!
↓
AFTER:
┌─────────────┐
│ GroundTruth │ semantic: 'labels'
└──────┬──────┘
│ ✅ ALLOWED
↓
┌──────▼──────┐
│ Loss │ accepts semantic: 'labels'
│ │ NO output handle
└─────────────┘ Terminal node!
Typical Training Setup:
┌─────────────┐ ┌─────────────┐
│ DataLoader │ → │ Input │
└─────────────┘ └──────┬──────┘
│
↓
┌──────▼──────┐
│ Conv2D │
└──────┬──────┘
│
↓
┌──────▼──────┐ ┌─────────────┐
│ Dense │ → │ Loss │ ← Terminal
└─────────────┘ ↗ └─────────────┘
│
┌─────────────┐ │
│ GroundTruth │ ──────────────────┘
└─────────────┘ semantic: 'labels'
Port Semantic Definitions:
- 'data': Regular activation/feature tensors
- 'labels': Ground truth labels for supervision
- 'predictions': Model prediction outputs
- 'loss': Loss values (currently unused, reserved for optimizer)
Benefits:
✅ GroundTruth → Loss connections now work
✅ Proper semantic type checking enforced
✅ Loss nodes correctly terminal (no outputs)
✅ Clear data vs labels distinction
✅ Prevents invalid connection patterns
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
…arnings
Problem:
Validation was showing incorrect warnings for source nodes:
- DataLoader: "has no input connection" ❌
- GroundTruth: "has no input connection" ❌
These are SOURCE nodes - they're SUPPOSED to have no inputs!
Root Cause (store.ts validateArchitecture):
```typescript
// BEFORE: Only excluded 'input' nodes
if (!hasInput && node.data.blockType !== 'input') {
errors.push({
nodeId: node.id,
message: `Block "${node.data.label}" has no input connection`,
type: 'warning'
})
}
```
This logic:
✅ Correctly excluded Input nodes
❌ Incorrectly flagged DataLoader nodes
❌ Incorrectly flagged GroundTruth nodes
Solution:
Identify source and terminal node types, exclude them from warnings:
```typescript
// Source nodes (input, dataloader, groundtruth) are SUPPOSED to have no inputs
const isSourceNode = node.data.blockType === 'input' ||
node.data.blockType === 'dataloader' ||
node.data.blockType === 'groundtruth'
if (!hasInput && !isSourceNode) {
errors.push({
nodeId: node.id,
message: `Block "${node.data.label}" has no input connection`,
type: 'warning'
})
}
// Terminal nodes (output, loss) are SUPPOSED to have no outputs
const isTerminalNode = node.data.blockType === 'output' ||
node.data.blockType === 'loss'
if (!hasOutput && !isTerminalNode) {
errors.push({
nodeId: node.id,
message: `Block "${node.data.label}" has no output connection`,
type: 'warning'
})
}
```
Node Type Classifications:
SOURCE NODES (no inputs expected):
- Input: Graph entry point (standalone or after DataLoader)
- DataLoader: Data source for training
- GroundTruth: Label source for supervision
TERMINAL NODES (no outputs expected):
- Output: Graph endpoint for inference
- Loss: Training objective endpoint
TRANSFORM NODES (need both inputs and outputs):
- All other nodes (Conv2D, Dense, etc.)
Validation Behavior:
BEFORE:
┌─────────────┐
│ DataLoader │ ⚠️ "has no input connection"
└─────────────┘
┌─────────────┐
│ GroundTruth │ ⚠️ "has no input connection"
└─────────────┘
AFTER:
┌─────────────┐
│ DataLoader │ ✅ No warning (source node)
└─────────────┘
┌─────────────┐
│ GroundTruth │ ✅ No warning (source node)
└─────────────┘
┌─────────────┐
│ Conv2D │ ⚠️ "has no input connection" (correct!)
└─────────────┘
┌─────────────┐
│ Loss │ ✅ No warning for no output (terminal node)
└─────────────┘
Example Valid Graph (No False Warnings):
┌─────────────┐ ┌─────────────┐
│ DataLoader │ → │ Input │ ✅ No warnings
└─────────────┘ └──────┬──────┘
│
↓
┌──────▼──────┐
│ Conv2D │ ✅ Has input & output
└──────┬──────┘
│
↓
┌──────▼──────┐
│ Dense │ ✅ Has input & output
└──────┬──────┘
│
↓
┌──────▼──────┐
┌─────────────┐ │ Loss │ ✅ No warning for no output
│ GroundTruth │ → │ │
└─────────────┘ └─────────────┘
✅ No warning ✅ Terminal node
Benefits:
✅ No false warnings for DataLoader
✅ No false warnings for GroundTruth
✅ No false warnings for Loss (no output)
✅ Clearer node type semantics
✅ Accurate validation feedback
✅ Better user experience
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
…atch
Critical fixes for PyTorch code generation:
1. GROUNDTRUTH NODE - MISSING FILE
Problem:
- Frontend has GroundTruth node definition (type: 'groundtruth')
- Backend had NO groundtruth.py file
- Code generation failed: "GroundTruth is not supported for PyTorch"
Solution - Created groundtruth.py:
```python
class GroundTruthNode(NodeDefinition):
@Property
def metadata(self) -> NodeMetadata:
return NodeMetadata(
type="groundtruth", # Matches frontend
label="Ground Truth",
category="input",
color="var(--color-orange)",
icon="Target",
description="Ground truth labels for training",
framework=Framework.PYTORCH
)
def compute_output_shape(...):
# Parse shape from config
shape_str = config.get("shape", "[1, 10]")
dims = self.parse_shape_string(shape_str)
return TensorShape(dims=dims, description="Ground truth labels")
def validate_incoming_connection(...):
# Source node - no incoming connections allowed
return "Ground Truth is a source node and cannot accept incoming connections"
```
Features:
- Configurable shape via JSON array (e.g., [batch, num_classes])
- Acts as source node (no inputs)
- Outputs ground truth labels for loss functions
- Auto-registered by NodeRegistry
2. MAXPOOL TYPE MISMATCH
Problem:
- Frontend: type = 'maxpool'
- Backend: type = 'maxpool2d' ❌ Mismatch!
- Code generation failed: "MaxPool is not supported for PyTorch"
- Registry lookup by type fails when names don't match
Solution:
Changed maxpool2d.py metadata type:
```python
# BEFORE:
type="maxpool2d" # ❌ Not found by registry
# AFTER:
type="maxpool" # ✅ Matches frontend
```
Node Registry Lookup Flow:
Frontend sends graph:
┌─────────────────────┐
│ Node: │
│ - id: "node-123" │
│ - type: "maxpool" │ ← Frontend type
│ - config: {...} │
└─────────────────────┘
↓
Backend codegen:
┌─────────────────────────────────────┐
│ get_node_definition("maxpool") │
│ ↓ │
│ NodeRegistry._registry[PYTORCH] │
│ ↓ │
│ Search for type="maxpool" │
│ ↓ │
│ ✅ Found! (after fix) │
│ OR │
│ ❌ Not found (before fix) │
└─────────────────────────────────────┘
Registry Auto-Loading:
1. NodeRegistry scans: block_manager/services/nodes/pytorch/
2. Imports all .py files
3. Finds NodeDefinition subclasses
4. Instantiates each class
5. Registers by metadata.type
Example:
```python
# groundtruth.py
class GroundTruthNode(NodeDefinition):
@Property
def metadata(self) -> NodeMetadata:
return NodeMetadata(
type="groundtruth", # ← This becomes the registry key
...
)
# Auto-registered as:
_registry[PYTORCH]["groundtruth"] = GroundTruthNode()
```
Node Classification:
SOURCE NODES (used in training, not in model layers):
✅ Input - Graph entry point
✅ DataLoader - Training data source
✅ GroundTruth - Label source (NEW!)
✅ Loss - Training objective
LAYER NODES (become PyTorch layers):
✅ Conv2D, Dense, MaxPool, etc.
Codegen Behavior (pytorch_orchestrator.py):
Source nodes are SKIPPED in layer generation:
```python
processable_nodes = [
n for n in sorted_nodes
if get_node_type(n) not in ('input', 'dataloader', 'output', 'loss')
]
# GroundTruth also skipped (doesn't generate layers)
```
Training Script Usage:
train.py will use these nodes:
┌─────────────┐
│ DataLoader │ → Provides batched input data
└─────────────┘
┌─────────────┐
│ GroundTruth │ → Provides batched labels
└─────────────┘
┌─────────────┐
│ Loss │ → loss_type, reduction, weights
└─────────────┘
Training Loop:
```python
for inputs, labels in dataloader: # From DataLoader node config
outputs = model(inputs)
loss = criterion(outputs, labels) # From Loss node config
loss.backward()
optimizer.step()
```
Files Changed:
NEW FILE:
- block_manager/services/nodes/pytorch/groundtruth.py
→ Full GroundTruth node implementation
MODIFIED:
- block_manager/services/nodes/pytorch/maxpool2d.py
→ Fixed type: "maxpool2d" → "maxpool"
Benefits:
✅ GroundTruth node now works in code generation
✅ MaxPool node now works in code generation
✅ Frontend-backend type consistency enforced
✅ Auto-registration via NodeRegistry
✅ Complete training script support
✅ All source nodes properly handled
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
…ation
Fix for "GroundTruthNode must implement get_pytorch_code_spec()" error:
1. ADDED get_pytorch_code_spec METHOD TO GROUNDTRUTH
Problem:
- GroundTruth was being processed as a layer node
- Missing required get_pytorch_code_spec() method
- Error: "GroundTruthNode must implement get_pytorch_code_spec()"
Solution - groundtruth.py:
```python
from ..base import LayerCodeSpec # Added import
def get_pytorch_code_spec(
self,
node_id: str,
config: Dict[str, Any],
input_shape: Optional[TensorShape],
output_shape: Optional[TensorShape]
) -> LayerCodeSpec:
"""
Ground truth nodes don't generate layer code - they only provide data
for the training script. This method exists for interface compatibility.
"""
sanitized_id = node_id.replace('-', '_')
return LayerCodeSpec(
class_name='GroundTruth',
layer_variable_name=f'{sanitized_id}_GroundTruth',
node_type='groundtruth',
node_id=node_id,
init_params={},
config_params=config,
input_shape_info={'dims': []},
output_shape_info={'dims': output_shape.dims if output_shape else []},
template_context={}
)
```
2. EXCLUDED GROUNDTRUTH FROM LAYER PROCESSING
Problem:
- GroundTruth is a SOURCE NODE (like DataLoader)
- Should NOT generate model layers
- Only used for training data/labels
- Was incorrectly processed as layer node
Solution - pytorch_orchestrator.py (5 locations):
A. Skip in processable_nodes (line 285-289):
```python
# BEFORE:
if get_node_type(n) not in ('input', 'dataloader', 'output', 'loss')
# AFTER:
if get_node_type(n) not in ('input', 'dataloader', 'groundtruth', 'output', 'loss')
```
B. Skip in internal layer specs (line 375):
```python
# BEFORE:
if node_type in ('input', 'output', 'dataloader', 'group', 'loss'):
# AFTER:
if node_type in ('input', 'output', 'dataloader', 'groundtruth', 'group', 'loss'):
```
C. Handle in shape computation (line 197-224):
```python
# Added after dataloader handling:
if node_type == 'groundtruth':
# Ground truth outputs label data
shape_str = config.get('shape', '[1, 10]')
try:
shape_list = json.loads(shape_str)
output_shape = TensorShape({
'dims': shape_list,
'description': 'Ground truth labels'
})
node_output_shapes[node_id] = output_shape
except (ValueError, TypeError):
node_output_shapes[node_id] = TensorShape({
'dims': [1, 10],
'description': 'Ground truth labels'
})
continue
```
D. Skip in layer counting (line 956):
```python
# BEFORE:
if get_node_type(n) not in ('input', 'output', 'dataloader', 'loss')
# AFTER:
if get_node_type(n) not in ('input', 'output', 'dataloader', 'groundtruth', 'loss')
```
E. Skip in forward pass (line 711):
```python
# BEFORE:
if get_node_type(n) not in ('output', 'loss')
# AFTER:
if get_node_type(n) not in ('output', 'loss', 'groundtruth')
```
Node Classification:
SOURCE NODES (no layer code generated):
┌─────────────┐
│ Input │ → Graph entry point
└─────────────┘
┌─────────────┐
│ DataLoader │ → Training data source
└─────────────┘
┌─────────────┐
│ GroundTruth │ → Label source (FIXED!)
└─────────────┘
TERMINAL NODES (no layer code generated):
┌─────────────┐
│ Output │ → Inference endpoint
└─────────────┘
┌─────────────┐
│ Loss │ → Training objective
└─────────────┘
LAYER NODES (generate PyTorch layers):
┌─────────────┐
│ Conv2D │ → nn.Conv2d layer
└─────────────┘
┌─────────────┐
│ MaxPool │ → nn.MaxPool2d layer
└─────────────┘
Code Generation Pipeline:
1. Sort nodes topologically
2. Filter processable nodes:
```python
# Exclude source/terminal nodes
processable = [n for n in sorted
if type not in ('input', 'dataloader', 'groundtruth', 'output', 'loss')]
```
3. Generate code specs for layers only:
```python
for node in processable:
node_def = get_node_definition(node_type)
spec = node_def.get_pytorch_code_spec(...)
code_specs.append(spec)
```
4. Render layer classes from specs
5. Generate model definition with layers
6. Generate training script (uses GroundTruth config!)
Training Script Usage:
GroundTruth shape is used for dataset validation:
```python
# From GroundTruth config: shape=[32, 10]
def __getitem__(self, idx):
image = ... # From DataLoader shape
label = ... # Must match GroundTruth shape [32, 10]
return image, label
```
Shape Computation Flow:
Input/DataLoader/GroundTruth are handled specially:
```python
if node_type == 'input':
shape_str = config.get('shape', '[1, 3, 224, 224]')
output_shape = parse_shape(shape_str)
node_output_shapes[node_id] = output_shape
continue # Don't process as layer
if node_type == 'dataloader':
shape_str = config.get('output_shape', '[1, 3, 224, 224]')
output_shape = parse_shape(shape_str)
node_output_shapes[node_id] = output_shape
continue # Don't process as layer
if node_type == 'groundtruth':
shape_str = config.get('shape', '[1, 10]')
output_shape = parse_shape(shape_str)
node_output_shapes[node_id] = output_shape
continue # Don't process as layer
```
Benefits:
✅ GroundTruth no longer generates layer code
✅ get_pytorch_code_spec implemented for interface compatibility
✅ Consistent with DataLoader/Input handling
✅ Shape properly computed for training validation
✅ Excluded from layer counting (model complexity)
✅ Excluded from forward pass generation
✅ Training script generation works correctly
Files Changed:
- project/block_manager/services/nodes/pytorch/groundtruth.py
→ Added LayerCodeSpec import
→ Added get_pytorch_code_spec method
- project/block_manager/services/codegen/pytorch_orchestrator.py
→ Added 'groundtruth' to 5 exclusion lists
→ Added groundtruth shape computation
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
Comprehensive fix for all missing get_pytorch_code_spec() methods and backend definitions.
AUDIT FINDINGS & FIXES:
1. MISSING get_pytorch_code_spec() METHODS - FIXED (9 nodes)
Critical issue: Layer nodes missing required method caused code generation failures.
Fixed nodes:
✅ avgpool2d.py - Added LayerCodeSpec with AvgPoolBlock
✅ adaptiveavgpool2d.py - Added LayerCodeSpec with AdaptiveAvgPool2DBlock
✅ conv1d.py - Added LayerCodeSpec with Conv1DBlock, derives in_channels from input
✅ conv3d.py - Added LayerCodeSpec with Conv3DBlock, derives in_channels from input
✅ embedding.py - Added LayerCodeSpec with EmbeddingBlock, handles optional params
✅ gru.py - Added LayerCodeSpec with GRUBlock, derives input_size, handles batch_first
✅ lstm.py - Added LayerCodeSpec with LSTMBlock, derives input_size, handles batch_first
✅ input.py - Added stub LayerCodeSpec (source node, no layer generated)
✅ dataloader.py - Added stub LayerCodeSpec (source node, no layer generated)
2. MISSING BACKEND DEFINITIONS - FIXED (1 critical)
Critical issue: Output node existed in frontend but missing in backend.
Created files:
✅ output.py - Complete Output node implementation
- Terminal node (marks model end)
- Passes through input shape
- Stub get_pytorch_code_spec (no layer generated)
- Handles 'predictions' semantic output
3. GROUP EXCLUSION ANALYSIS - VERIFIED CORRECT
Audit flagged potential inconsistency, but analysis shows intentional design:
Line 303 (_generate_code_specs):
- Group nodes NOT excluded
- Special handling at line 317 via group_generator
- Correct behavior: groups need processing, just differently
Line 390 (_generate_internal_layer_specs):
- Group nodes ARE excluded
- Prevents nested groups inside group blocks
- Correct behavior: different context, different rules
Conclusion: ✅ No fix needed - working as designed
IMPLEMENTATION DETAILS:
All get_pytorch_code_spec() implementations follow consistent pattern:
```python
def get_pytorch_code_spec(
self,
node_id: str,
config: Dict[str, Any],
input_shape: Optional[TensorShape],
output_shape: Optional[TensorShape]
) -> LayerCodeSpec:
"""Generate PyTorch code specification for {NodeType} layer"""
# Extract ALL relevant config parameters
param1 = config.get('param1', default)
param2 = config.get('param2', default)
# Derive parameters from shapes where needed
if input_shape:
derived_param = input_shape.dims[channel_idx]
# Sanitize node ID for Python variable names
sanitized_id = node_id.replace('-', '_')
class_name = '{NodeType}Block'
layer_var = f'{sanitized_id}_{NodeType}Block'
return LayerCodeSpec(
class_name=class_name,
layer_variable_name=layer_var,
node_type='nodetype', # Must match metadata.type!
node_id=node_id,
init_params={
'param1': param1,
'param2': param2
},
config_params=config,
input_shape_info={'dims': input_shape.dims if input_shape else []},
output_shape_info={'dims': output_shape.dims if output_shape else []},
template_context={
'param1': param1,
'param2': param2
}
)
```
KEY FEATURES:
Pooling Layers (AvgPool2D, AdaptiveAvgPool2D):
- Extract: kernel_size, stride, padding, output_size
- Simple parameter passing
Convolution Layers (Conv1D, Conv3D):
- Extract: out_channels, kernel_size, stride, padding, dilation, bias
- Derive: in_channels from input_shape.dims[1]
- Handle missing input shape gracefully
Recurrent Layers (LSTM, GRU):
- Extract: hidden_size, num_layers, bias, batch_first, dropout, bidirectional
- Derive: input_size from input_shape based on batch_first flag
- If batch_first=True: input_size = dims[2]
- If batch_first=False: input_size = dims[1]
Embedding Layer:
- Extract: num_embeddings, embedding_dim, padding_idx, max_norm, scale_grad_by_freq
- Handle optional parameters:
- padding_idx: Set to None if -1
- max_norm: Set to None if 0
Source Nodes (Input, DataLoader, GroundTruth):
- Minimal LayerCodeSpec (no actual layer generation)
- Empty init_params and template_context
- Node type matches metadata
- For interface compatibility only
Terminal Nodes (Output, Loss):
- Minimal LayerCodeSpec (no actual layer generation)
- Mark graph endpoints
- Output: marks model end
- Loss: provides training objective
NODE TYPE CONSISTENCY:
All node_type values match their metadata.type:
✅ avgpool2d.py → type="avgpool2d"
✅ adaptiveavgpool2d.py → type="adaptiveavgpool2d"
✅ conv1d.py → type="conv1d"
✅ conv3d.py → type="conv3d"
✅ embedding.py → type="embedding"
✅ gru.py → type="gru"
✅ lstm.py → type="lstm"
✅ input.py → type="input"
✅ dataloader.py → type="dataloader"
✅ output.py → type="output"
REGISTRY AUTO-LOADING:
All new/updated nodes automatically registered via NodeRegistry:
1. Scans: block_manager/services/nodes/pytorch/*.py
2. Finds: NodeDefinition subclasses
3. Instantiates: Each class
4. Registers: By metadata.type
Example:
```python
_registry[PYTORCH]["avgpool2d"] = AvgPool2DNode()
_registry[PYTORCH]["conv1d"] = Conv1DNode()
_registry[PYTORCH]["output"] = OutputNode()
# etc.
```
CODE GENERATION PIPELINE:
Now all nodes support complete pipeline:
1. ✅ Type lookup via registry
2. ✅ Shape computation
3. ✅ Code spec generation
4. ✅ Layer class rendering
5. ✅ Model definition assembly
6. ✅ Training script generation
IMPACT:
BEFORE:
- 9 layer nodes would fail code generation
- Output node lookups would fail
- Missing required interface methods
- Incomplete backend coverage
AFTER:
- ✅ All layer nodes generate code
- ✅ Output node fully supported
- ✅ Complete interface implementations
- ✅ Full frontend-backend parity
Files Changed:
MODIFIED (10 files):
- block_manager/services/nodes/pytorch/avgpool2d.py (+42 lines)
- block_manager/services/nodes/pytorch/adaptiveavgpool2d.py (+40 lines)
- block_manager/services/nodes/pytorch/conv1d.py (+52 lines)
- block_manager/services/nodes/pytorch/conv3d.py (+52 lines)
- block_manager/services/nodes/pytorch/embedding.py (+45 lines)
- block_manager/services/nodes/pytorch/gru.py (+56 lines)
- block_manager/services/nodes/pytorch/lstm.py (+56 lines)
- block_manager/services/nodes/pytorch/input.py (+18 lines)
- block_manager/services/nodes/pytorch/dataloader.py (+18 lines)
NEW FILES (1 file):
- block_manager/services/nodes/pytorch/output.py (+71 lines)
Total: 450+ lines of new code generation support
Benefits:
✅ Complete frontend-backend compatibility
✅ All layer types now generate code
✅ Output node fully functional
✅ Source nodes have interface compatibility
✅ Terminal nodes properly handled
✅ Consistent implementation patterns
✅ Full PyTorch code generation support
✅ No more "not supported" errors
https://claude.ai/code/session_01Q6JXRiSSRts2bXnZWZ6Fqf
- Implemented a new MetricsNode class for both PyTorch and TensorFlow to track multiple evaluation metrics during training. - Enhanced the configuration schema to include task type, metrics selection, number of classes, and averaging method. - Updated training scripts for both frameworks to incorporate metric initialization and computation. - Modified frontend components to support multi-select options for metrics configuration. - Added validation logic for metrics configuration to ensure consistency with task types. - Updated requirements to include torch and torchmetrics for PyTorch metrics support.
…hestrators, update training script for metrics handling, and adjust store logic for multiple inputs
Added a Product Hunt badge for ForgeOpus.
Added Product Hunt badge for ForgeOpus.
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
…12708117 Add Claude Code GitHub Workflow
Bumps the npm_and_yarn group with 4 updates in the /project/frontend directory: [js-yaml](https://github.com/nodeca/js-yaml), [lodash](https://github.com/lodash/lodash), [mdast-util-to-hast](https://github.com/syntax-tree/mdast-util-to-hast) and [react-router](https://github.com/remix-run/react-router/tree/HEAD/packages/react-router). Updates `js-yaml` from 4.1.0 to 4.1.1 - [Changelog](https://github.com/nodeca/js-yaml/blob/master/CHANGELOG.md) - [Commits](nodeca/js-yaml@4.1.0...4.1.1) Updates `lodash` from 4.17.21 to 4.17.23 - [Release notes](https://github.com/lodash/lodash/releases) - [Commits](lodash/lodash@4.17.21...4.17.23) Updates `mdast-util-to-hast` from 13.2.0 to 13.2.1 - [Release notes](https://github.com/syntax-tree/mdast-util-to-hast/releases) - [Commits](syntax-tree/mdast-util-to-hast@13.2.0...13.2.1) Updates `react-router` from 7.9.5 to 7.13.0 - [Release notes](https://github.com/remix-run/react-router/releases) - [Changelog](https://github.com/remix-run/react-router/blob/main/packages/react-router/CHANGELOG.md) - [Commits](https://github.com/remix-run/react-router/commits/react-router@7.13.0/packages/react-router) --- updated-dependencies: - dependency-name: js-yaml dependency-version: 4.1.1 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: lodash dependency-version: 4.17.23 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: mdast-util-to-hast dependency-version: 13.2.1 dependency-type: indirect dependency-group: npm_and_yarn - dependency-name: react-router dependency-version: 7.13.0 dependency-type: indirect dependency-group: npm_and_yarn ... Signed-off-by: dependabot[bot] <support@github.com>
- Add GroundTruthNode and MetricsNode imports/exports to pytorch/__init__.py - Add MetricsNode import/export to tensorflow/__init__.py - Add missing `import torch` to config.py.jinja2 template - Fix special node exclusion inconsistency in base_orchestrator.py (add loss, metrics, groundtruth to both _generate_code_specs and _generate_forward_pass filters) - Fix special node exclusion inconsistency in validation.py (add metrics, groundtruth alongside loss) - Remove torch, torchmetrics, tensorflow from backend requirements.txt (these belong only in generated project requirements) - Remove output handle from loss nodes in BlockNode.tsx to match LossNode definition (terminal node with no outputs) - Add GroundTruthNode export to TensorFlow index.ts for consistency with PyTorch Co-authored-by: Aaditya Jindal <RETR0-OS@users.noreply.github.com>
Updated workflow triggers for Claude Code Review.
Claude/audit code generation t w pbv
…rn/project/frontend/npm_and_yarn-f7ab689b53
…/frontend/npm_and_yarn-f7ab689b53 Dependabot/npm and yarn/project/frontend/npm and yarn f7ab689b53
Contributor
There was a problem hiding this comment.
Pull request overview
This PR expands VisionForge’s graph model/codegen to support additional “special” node types (e.g., groundtruth, metrics, loss) and improves export robustness (cycle detection, name sanitization), while also introducing GitHub Actions workflows for Claude-based assistance/review.
Changes:
- Added new node types/definitions (
groundtruth,metrics) and updated frontend store + UI to handle them in shape inference, validation, and rendering. - Updated backend code generation/orchestration/templates to exclude special nodes from layer/forward generation, add cycle diagnostics, sanitize project names, and add optional metric tracking in training templates.
- Added Claude GitHub Actions workflows and a README badge.
Reviewed changes
Copilot reviewed 55 out of 56 changed files in this pull request and generated 20 comments.
Show a summary per file
| File | Description |
|---|---|
| project/frontend/src/lib/types.ts | Adds groundtruth to BlockType (PR also introduces metrics usage). |
| project/frontend/src/lib/store.ts | Updates node update + inference/validation logic for source/terminal/special nodes. |
| project/frontend/src/lib/nodes/definitions/tensorflow/metrics.ts | Adds TensorFlow Metrics node definition + multiselect config schema. |
| project/frontend/src/lib/nodes/definitions/tensorflow/index.ts | Exports TF definitions including metrics and groundtruth. |
| project/frontend/src/lib/nodes/definitions/pytorch/metrics.ts | Adds PyTorch Metrics node definition + multiselect config schema. |
| project/frontend/src/lib/nodes/definitions/pytorch/loss.ts | Makes Loss node terminal (no output ports). |
| project/frontend/src/lib/nodes/definitions/pytorch/index.ts | Exports PyTorch groundtruth + metrics definitions. |
| project/frontend/src/lib/nodes/definitions/pytorch/groundtruth.ts | Adds GroundTruth source node definition and shape parsing. |
| project/frontend/src/lib/nodes/definitions/pytorch/dataloader.ts | Removes CSV upload-related config fields. |
| project/frontend/src/index.css | Styles group nodes to render with transparent background/border. |
| project/frontend/src/components/InternalNodeConfigPanel.tsx | Adds multiselect UI rendering with checkboxes for internal/group config. |
| project/frontend/src/components/GroupBlockNode.tsx | Adjusts handle placement and layout for group nodes. |
| project/frontend/src/components/ConfigPanel.tsx | Adds multiselect UI rendering with checkboxes for main config panel. |
| project/frontend/src/components/BlockNode.tsx | Updates node handle rendering for loss/metrics and adds input port display. |
| project/frontend/package.json | Bumps react-router-dom version. |
| project/block_manager/views/export_views.py | Adds backend validation requiring a loss node before export. |
| project/block_manager/services/validation.py | Skips shape validation for special nodes; adjusts required-input node set. |
| project/block_manager/services/nodes/tensorflow/metrics.py | Adds backend TensorFlow Metrics node definition. |
| project/block_manager/services/nodes/tensorflow/loss.py | Adds backend TensorFlow Loss node definition. |
| project/block_manager/services/nodes/tensorflow/concat.py | Strengthens per-connection validation (axis validity, shape presence). |
| project/block_manager/services/nodes/tensorflow/batchnorm2d.py | Renames TF batchnorm node metadata (type="batchnorm" etc.). |
| project/block_manager/services/nodes/tensorflow/add.py | Strengthens per-connection validation (shape presence). |
| project/block_manager/services/nodes/tensorflow/init.py | Exports TF loss/metrics nodes. |
| project/block_manager/services/nodes/templates/tensorflow/files/train.py.jinja2 | Adds optional metric tracking support in generated TF training script. |
| project/block_manager/services/nodes/templates/pytorch/layers/add.py.jinja2 | Changes add implementation to sum(tensor_list). |
| project/block_manager/services/nodes/templates/pytorch/files/train.py.jinja2 | Adds optional torchmetrics-based metric tracking. |
| project/block_manager/services/nodes/templates/pytorch/files/config.py.jinja2 | Makes device selection dynamic via torch.cuda.is_available(). |
| project/block_manager/services/nodes/pytorch/output.py | Adds backend PyTorch Output node definition. |
| project/block_manager/services/nodes/pytorch/metrics.py | Adds backend PyTorch Metrics node definition. |
| project/block_manager/services/nodes/pytorch/maxpool2d.py | Renames metadata type to maxpool. |
| project/block_manager/services/nodes/pytorch/lstm.py | Adds LayerCodeSpec generation for LSTM. |
| project/block_manager/services/nodes/pytorch/loss.py | Adds backend PyTorch Loss node definition. |
| project/block_manager/services/nodes/pytorch/input.py | Adds LayerCodeSpec for Input (interface compatibility). |
| project/block_manager/services/nodes/pytorch/gru.py | Adds LayerCodeSpec generation for GRU. |
| project/block_manager/services/nodes/pytorch/groundtruth.py | Adds backend PyTorch GroundTruth node definition. |
| project/block_manager/services/nodes/pytorch/embedding.py | Adds LayerCodeSpec generation for Embedding. |
| project/block_manager/services/nodes/pytorch/dataloader.py | Adds LayerCodeSpec for DataLoader (interface compatibility). |
| project/block_manager/services/nodes/pytorch/conv3d.py | Adds LayerCodeSpec generation for Conv3D. |
| project/block_manager/services/nodes/pytorch/conv1d.py | Adds LayerCodeSpec generation for Conv1D. |
| project/block_manager/services/nodes/pytorch/concat.py | Strengthens per-connection validation (dim validity, shape presence). |
| project/block_manager/services/nodes/pytorch/batchnorm2d.py | Renames metadata type to batchnorm and updates styling metadata. |
| project/block_manager/services/nodes/pytorch/avgpool2d.py | Adds LayerCodeSpec generation for AvgPool2D. |
| project/block_manager/services/nodes/pytorch/add.py | Strengthens per-connection validation (shape presence). |
| project/block_manager/services/nodes/pytorch/adaptiveavgpool2d.py | Adds LayerCodeSpec generation for AdaptiveAvgPool2D. |
| project/block_manager/services/nodes/pytorch/init.py | Exports PyTorch loss/metrics/groundtruth nodes. |
| project/block_manager/services/enhanced_pytorch_codegen.py | Updates add implementation + layer counting excludes loss. |
| project/block_manager/services/codegen/tensorflow_orchestrator.py | Adds sanitization + loss/metrics extraction and updated skip rules. |
| project/block_manager/services/codegen/tensorflow_group_generator.py | Excludes loss from group codegen paths. |
| project/block_manager/services/codegen/pytorch_orchestrator.py | Adds sanitization + groundtruth shape handling + skip rules. |
| project/block_manager/services/codegen/pytorch_group_generator.py | Excludes loss from group codegen paths. |
| project/block_manager/services/codegen/base_orchestrator.py | Extends special-node exclusions across base codegen stages. |
| project/block_manager/services/codegen/base.py | Adds explicit cycle detection error message in topological_sort. |
| README.md | Adds Product Hunt badge. |
| .github/workflows/claude.yml | Adds Claude Code workflow triggered by @claude mentions. |
| .github/workflows/claude-code-review.yml | Adds manual Claude Code Review workflow. |
Comments suppressed due to low confidence (1)
project/frontend/src/lib/types.ts:24
BlockTypeis missing'metrics', but the PR adds Metrics node definitions and store/UI logic checks forblockType === 'metrics'. This will break type-checking and may force unsafe casts; add'metrics'to theBlockTypeunion.
|
|
||
| # Count layers to estimate model complexity | ||
| layer_count = sum(1 for n in nodes if ClassDefinitionGenerator.get_node_type(n) not in ('input', 'output', 'dataloader')) | ||
| layer_count = sum(1 for n in nodes if ClassDefinitionGenerator.get_node_type(n) not in ('input', 'output', 'dataloader', 'loss')) |
There was a problem hiding this comment.
This legacy layer_count calculation excludes loss but still counts other special nodes like metrics/groundtruth (and BaseOrchestrator now excludes them). Update the exclusion list to keep complexity heuristics consistent with the main orchestrators.
Suggested change
| layer_count = sum(1 for n in nodes if ClassDefinitionGenerator.get_node_type(n) not in ('input', 'output', 'dataloader', 'loss')) | |
| layer_count = sum( | |
| 1 | |
| for n in nodes | |
| if ClassDefinitionGenerator.get_node_type(n) | |
| not in ('input', 'output', 'dataloader', 'loss', 'metrics', 'groundtruth') | |
| ) |
Comment on lines
+427
to
+429
| {field.type === 'multiselect' && field.options && ( | ||
| <div className="space-y-3 border border-input rounded-md p-3 bg-muted/30"> | ||
| {field.options.map((opt) => { |
There was a problem hiding this comment.
field.type === 'multiselect' is new here, but ConfigField['type'] in src/lib/types.ts doesn’t currently include 'multiselect'. In strict TS this makes the branch unreachable / a type error; update the shared ConfigField type (and defaults) to include multiselect.
Comment on lines
+545
to
+549
| // Terminal nodes (output, loss) are SUPPOSED to have no output connections | ||
| const isTerminalNode = node.data.blockType === 'output' || | ||
| node.data.blockType === 'loss' | ||
|
|
||
| if (!hasOutput && !isTerminalNode) { |
There was a problem hiding this comment.
Architecture validation treats only output and loss as terminal nodes, but the new metrics node has no output ports. As written, metrics nodes will always produce a "has no output connection" warning; include metrics in the terminal-node set (or derive terminal-ness from getOutputPorts().length === 0).
Comment on lines
+710
to
+717
| // Pure source nodes (dataloader, groundtruth) compute shape from config | ||
| if (node.data.blockType === 'dataloader' || node.data.blockType === 'groundtruth') { | ||
| if (nodeDef) { | ||
| // Use new registry method | ||
| // Source nodes don't need inputShape - compute from config alone | ||
| const outputShape = nodeDef.computeOutputShape(undefined, node.data.config) | ||
| node.data.outputShape = outputShape | ||
| } | ||
| } |
There was a problem hiding this comment.
New shape-inference behavior for groundtruth (source node) and multi-input terminal nodes (metrics) is added here, but there are existing store tests in the repo and none are updated/added in this PR for these cases. Add tests that cover: (1) groundtruth shape parsing + propagation to loss/metrics, and (2) validateArchitecture not warning for metrics as a terminal node.
Comment on lines
+147
to
148
| {data.blockType !== 'dataloader' && data.blockType !== 'loss' && data.blockType !== 'metrics' && ( | ||
| <> |
There was a problem hiding this comment.
GroundTruth is a source node (no incoming connections), but this condition still renders a left-side target handle for it (because it’s not excluded). Add groundtruth to the excluded block types so users can’t connect into it.
| from typing import Tuple, Dict | ||
| import time | ||
| {% if has_metrics %} | ||
| import torchmetrics |
There was a problem hiding this comment.
This template conditionally imports torchmetrics, but the exported project doesn’t appear to include a requirements/pyproject file in the templates. If users run the generated train.py without torchmetrics installed, it will crash on import; consider generating dependency instructions (or wrapping the import with a clear error message/fallback).
Suggested change
| import torchmetrics | |
| try: | |
| import torchmetrics | |
| except ImportError as e: | |
| raise ImportError( | |
| "torchmetrics is required when metrics are enabled in this training script. " | |
| "Install it with `pip install torchmetrics` or regenerate the project " | |
| "with metrics disabled in VisionForge." | |
| ) from e |
Comment on lines
+277
to
+281
| <div | ||
| key={`port-label-${i}`} | ||
| className="text-[10px] flex items-center gap-1.5 relative" | ||
| id={`loss-port-row-${i}`} | ||
| > |
There was a problem hiding this comment.
These rows use fixed DOM ids like loss-port-row-0, which will be duplicated across every Loss node instance on the canvas and produces invalid HTML/DOM. Drop the id attribute or include the node id in it (e.g., ${id}-${...}) so it stays unique.
Comment on lines
+293
to
+309
| <Checkbox | ||
| id={`${field.name}-${opt.value}`} | ||
| checked={isChecked} | ||
| onCheckedChange={(checked) => { | ||
| const newValues = Array.isArray(currentValues) ? [...currentValues] : [] | ||
| if (checked) { | ||
| if (!newValues.includes(opt.value)) { | ||
| newValues.push(opt.value) | ||
| } | ||
| } else { | ||
| const index = newValues.indexOf(opt.value) | ||
| if (index > -1) { | ||
| newValues.splice(index, 1) | ||
| } | ||
| } | ||
| handleConfigChange(field.name, newValues) | ||
| }} |
There was a problem hiding this comment.
Same onCheckedChange issue as ConfigPanel: Radix checkbox can emit 'indeterminate', but the handler treats it as truthy. Normalize to a boolean before updating the multiselect array.
Comment on lines
+3
to
+35
| on: | ||
| workflow_dispatch: | ||
|
|
||
| jobs: | ||
| claude-review: | ||
| # Optional: Filter by PR author | ||
| # if: | | ||
| # github.event.pull_request.user.login == 'external-contributor' || | ||
| # github.event.pull_request.user.login == 'new-developer' || | ||
| # github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' | ||
|
|
||
| runs-on: ubuntu-latest | ||
| permissions: | ||
| contents: read | ||
| pull-requests: read | ||
| issues: read | ||
| id-token: write | ||
|
|
||
| steps: | ||
| - name: Checkout repository | ||
| uses: actions/checkout@v4 | ||
| with: | ||
| fetch-depth: 1 | ||
|
|
||
| - name: Run Claude Code Review | ||
| id: claude-review | ||
| uses: anthropics/claude-code-action@v1 | ||
| with: | ||
| claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }} | ||
| plugin_marketplaces: 'https://github.com/anthropics/claude-code.git' | ||
| plugins: 'code-review@claude-code-plugins' | ||
| prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}' | ||
| # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md |
There was a problem hiding this comment.
workflow_dispatch runs don’t have a github.event.pull_request payload, so ${{ github.event.pull_request.number }} will be empty and the prompt will be wrong. Add an explicit input for PR number (or use pull_request-based triggers) and build the prompt from that input.
| layer_count = sum( | ||
| 1 for n in nodes | ||
| if get_node_type(n) not in ('input', 'output', 'dataloader') | ||
| if get_node_type(n) not in ('input', 'output', 'dataloader', 'groundtruth', 'loss') |
There was a problem hiding this comment.
Layer counting excludes groundtruth and loss but still counts metrics, which doesn’t generate layer code. Exclude metrics here as well so the adaptive hyperparameters reflect actual layer count (see base_orchestrator.py for the full exclusion set).
Suggested change
| if get_node_type(n) not in ('input', 'output', 'dataloader', 'groundtruth', 'loss') | |
| if get_node_type(n) not in ('input', 'output', 'dataloader', 'groundtruth', 'loss', 'metrics') |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
This pull request introduces two new GitHub Actions workflows for integrating Claude-based code review and code assistance, and makes several improvements to the code generation logic, especially for handling special node types in neural network graphs. The changes enhance workflow automation, improve error handling for cyclic graphs, and ensure that special node types like
loss,metrics, andgroundtruthare properly excluded from layer/code generation and shape computation.GitHub Actions Integration:
.github/workflows/claude.ymlto enable Claude-based code assistance triggered by comments or reviews mentioning@claude. This workflow checks for relevant events and invokes the Claude Code Action with appropriate permissions..github/workflows/claude-code-review.ymlto provide an on-demand Claude-powered code review workflow, which can be triggered manually.Code Generation Logic Improvements:
base_orchestrator.py,pytorch_orchestrator.py, andpytorch_group_generator.pyto consistently exclude special node types (loss,metrics,groundtruth) from layer, forward pass, and config generation. This prevents these nodes from being treated as regular layers in the generated code. [1] [2] [3] [4] [5] [6] [7] [8]pytorch_orchestrator.pyto handlegroundtruthnodes, extracting their shapes from config or falling back to a default, and to skip bothoutputandlossnodes.Error Handling and Usability:
topological_sortfunction to provide explicit error messages when a cycle is detected in the neural network graph, listing up to five involved node IDs.Project Name Sanitization:
pytorch_orchestrator.pyto ensure generated class and file names are valid Python identifiers, replacing non-alphanumeric characters with underscores. This sanitized name is now used throughout model and test code generation. [1] [2] [3] [4]Documentation:
README.mdfor improved project visibility.