Minimum limit addtition to the harware device validation

Author: MadhurKumar004

code_generator.py

@@ -25,6 +25,7 @@
     HybridOptimizationStatement,
     Identifier,
     InputStreamStatement,
+    LayerDeclaration,
     Literal,
     MemoryLimitStatement,
     ModelStatement,
@@ -176,7 +177,7 @@ def visit_optimize_for_statement(self, node: OptimizeForStatement) -> Any:
         return None
 
     def visit_memory_limit_statement(self, node: MemoryLimitStatement) -> Any:
-        self.config["memory_limit"] = node.limit_mb
+        self.config["memory_limit"] = node.limit_mb.value
         self.optimizations.append(f"Memory limit set to {node.limit_mb}MB")
         return None
 
@@ -217,6 +218,25 @@ def visit_pipeline_statement(self, node: PipelineStatement) -> Any:
         self.config["pipeline_steps"] = node.steps
         return None
 
+    def visit_layer_declaration(self, node: LayerDeclaration) -> Any:
+        """Visit a layer declaration node."""
+        # Extract layer information for code generation
+        layer_info = {
+            "name": node.name,
+            "type": node.layer_type.value,
+            "parameters": node.parameters,
+        }
+        
+        # Add to optimizations list for reporting
+        self.optimizations.append(f"Layer {node.name}: {node.layer_type.value}")
+        
+        # Store layer information in config for code generation
+        if "layers" not in self.config:
+            self.config["layers"] = []
+        self.config["layers"].append(layer_info)
+        
+        return None
+
     def visit_literal(self, node: Literal) -> Any:
         return node.value
 

edgeflow_ast.py

@@ -236,7 +236,7 @@ def accept(self, visitor: "ASTVisitor") -> Any:
 class MemoryLimitStatement(Statement):
     """Represents a memory limit statement: memory_limit: 64 MB"""
 
-    limit_mb: int
+    limit_mb: ConstrainedInt = field(default_factory=lambda: ConstrainedInt(64, 16, 10000))
 
     def accept(self, visitor: "ASTVisitor") -> Any:
         return visitor.visit_memory_limit_statement(self)
@@ -323,11 +323,11 @@ def accept(self, visitor: "ASTVisitor") -> Any:
 class LayerDeclaration(Statement):
     """Base class for layer declarations with type validation."""
 
-    name: str = field()
-    layer_type: LayerType = field()
+    name: str = ""
+    layer_type: LayerType = LayerType.CONV2D
     parameters: Dict[str, Any] = field(default_factory=dict)
-    source_line: Optional[int] = field(default=None)
-    source_column: Optional[int] = field(default=None)
+    source_line: Optional[int] = None
+    source_column: Optional[int] = None
 
     def __post_init__(self):
         """Post-initialization hook for subclasses."""
@@ -345,12 +345,12 @@ def validate_parameters(self) -> List[str]:
 class Conv2DDeclaration(LayerDeclaration):
     """Conv2D layer with type-constrained parameters."""
 
-    filters: ConstrainedInt = field()
-    kernel_size: KernelSize = field()
+    filters: ConstrainedInt = field(default_factory=lambda: ConstrainedInt(32))
+    kernel_size: KernelSize = field(default_factory=lambda: KernelSize(3))
     strides: StrideValue = field(default_factory=lambda: StrideValue(1))
-    padding: PaddingType = field(default=PaddingType.VALID)
-    activation: ActivationType = field(default=ActivationType.LINEAR)
-    use_bias: bool = field(default=True)
+    padding: PaddingType = PaddingType.VALID
+    activation: ActivationType = ActivationType.LINEAR
+    use_bias: bool = True
 
     def __post_init__(self):
         super().__post_init__()
@@ -392,9 +392,9 @@ def validate_parameters(self) -> List[str]:
 class DenseDeclaration(LayerDeclaration):
     """Dense layer with type-constrained parameters."""
 
-    units: ConstrainedInt = field()
-    activation: ActivationType = field(default=ActivationType.LINEAR)
-    use_bias: bool = field(default=True)
+    units: ConstrainedInt = field(default_factory=lambda: ConstrainedInt(128))
+    activation: ActivationType = ActivationType.LINEAR
+    use_bias: bool = True
 
     def __post_init__(self):
         super().__post_init__()
@@ -421,7 +421,7 @@ def validate_parameters(self) -> List[str]:
 class DropoutDeclaration(LayerDeclaration):
     """Dropout layer with type-constrained parameters."""
 
-    rate: DropoutRate = field()
+    rate: DropoutRate = field(default_factory=lambda: DropoutRate(0.5))
 
     def __post_init__(self):
         super().__post_init__()
@@ -444,9 +444,9 @@ def validate_parameters(self) -> List[str]:
 class MaxPool2DDeclaration(LayerDeclaration):
     """MaxPool2D layer with type-constrained parameters."""
 
-    pool_size: Union[int, Tuple[int, int]] = field()
-    strides: Optional[StrideValue] = field(default=None)
-    padding: PaddingType = field(default=PaddingType.VALID)
+    pool_size: Union[int, Tuple[int, int]] = 2
+    strides: Optional[StrideValue] = None
+    padding: PaddingType = PaddingType.VALID
 
     def __post_init__(self):
         super().__post_init__()
@@ -697,7 +697,7 @@ def create_program_from_dict(config: Dict[str, Any]) -> Program:
         statements.append(OptimizeForStatement(goal=config["optimize_for"]))
 
     if "memory_limit" in config:
-        statements.append(MemoryLimitStatement(limit_mb=config["memory_limit"]))
+        statements.append(MemoryLimitStatement(limit_mb=ConstrainedInt(config["memory_limit"], 16, 10000)))
 
     if "enable_fusion" in config:
         statements.append(FusionStatement(enabled=config["enable_fusion"]))
@@ -749,7 +749,7 @@ def print_ast(node: ASTNode, indent: int = 0) -> str:
     elif isinstance(node, OptimizeForStatement):
         result.append(f"{prefix}OptimizeForStatement(goal='{node.goal}')")
     elif isinstance(node, MemoryLimitStatement):
-        result.append(f"{prefix}MemoryLimitStatement(limit_mb={node.limit_mb})")
+        result.append(f"{prefix}MemoryLimitStatement(limit_mb={node.limit_mb.value})")
     elif isinstance(node, FusionStatement):
         result.append(f"{prefix}FusionStatement(enabled={node.enabled})")
     elif isinstance(node, FrameworkStatement):

fast_compile.py

@@ -714,5 +714,45 @@ def demo_fast_compiler():
     print(f"   • Intelligent optimization suggestions generated")
 
 
+def fast_compile_config(config: Dict[str, Any]) -> FastCompileResult:
+    """
+    Fast compile a configuration for immediate feedback.
+
+    Args:
+        config: EdgeFlow configuration dictionary
+
+    Returns:
+        FastCompileResult with validation and performance estimates
+    """
+    try:
+        from edgeflow_ir import IRBuilder
+
+        # Build IR graph from config
+        ir_builder = IRBuilder()
+        ir_graph = ir_builder.build_from_config(config)
+
+        # Get target device and quantization from config
+        target_device = config.get("target_device", "mobile")
+        quantization = config.get("quantize", "float32")
+
+        # Initialize fast compiler and run compilation
+        compiler = EdgeFlowFastCompiler()
+        result = compiler.fast_compile(ir_graph, target_device, quantization)
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Fast compile config failed: {e}")
+        return FastCompileResult(
+            success=False,
+            errors=[f"Configuration compilation failed: {str(e)}"],
+            warnings=[],
+            performance_metrics=None,
+            compile_time_ms=0.0,
+            device_compatibility={},
+            optimization_suggestions=[],
+        )
+
+
 if __name__ == "__main__":
     demo_fast_compiler()