wafer-core 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

wafer_core/lib/trace_compare/fusion_analyzer.py

@@ -1,25 +1,18 @@
-"""Fusion analysis using aligned kernel pairs.
+"""Fusion analysis for detecting kernel fusion differences between platforms.
 
-Detects kernel fusion patterns at the kernel-pair level within aligned layers.
+Detects fusion differences between AMD and NVIDIA by analyzing:
+1. Kernel types unique to each platform (one platform fuses them away)
+2. Sequence patterns (what comes before/after unique kernels)
+3. Count imbalances (one platform has significantly more calls)
 
-Key insight: When one platform has an operation type like "RMSNorm+GEMM" (containing '+'),
-that platform IS fusing. The OTHER platform runs the components separately.
+This is the pattern-based approach which is more reliable than alignment-based detection.
 """
 
 from collections import Counter, defaultdict
 from dataclasses import dataclass, field
 from typing import Any
 
-from .aligner import KernelPair, LayerAlignment
-
-
-# Maps fused operation names to their component operations
-FUSED_OPERATION_COMPONENTS: dict[str, list[str]] = {
-    "RMSNorm+GEMM": ["RMSNorm", "Dense GEMM"],
-    "SwiGLU+GEMM": ["SwiGLU", "Dense GEMM"],
-    "MoE GEMM+SwiGLU": ["MoE GEMM", "SwiGLU"],
-    "Embedding+RMSNorm+GEMM": ["Elementwise", "RMSNorm", "Dense GEMM"],  # Embedding is often Elementwise
-}
+from .classifier import classify, Op
 
 
 @dataclass
@@ -43,311 +36,467 @@ class FusionAnalysis:
     summary: dict[str, Any] = field(default_factory=dict)
 
 
-def _is_fused_operation(operation: str) -> bool:
-    """Check if an operation type represents a fused operation.
-    
-    Operations like 'RMSNorm+GEMM', 'MoE GEMM+SwiGLU' indicate fusion.
-    Also handles 'Fused (Unknown)' from heuristic detection.
-    """
-    return "+" in operation or operation == "Fused (Unknown)"
+def _classify_kernel(name: str, platform: str = "AMD") -> str:
+    """Classify a kernel name to its operation type."""
+    op, _pattern = classify(name, platform)
+    return op.value
 
 
-def _get_component_operations(fused_op: str) -> list[str]:
-    """Get the component operations for a fused operation type."""
-    if fused_op in FUSED_OPERATION_COMPONENTS:
-        return FUSED_OPERATION_COMPONENTS[fused_op]
-    
-    # Parse from the operation name itself (e.g., "RMSNorm+GEMM" -> ["RMSNorm", "GEMM"])
-    if "+" in fused_op:
-        parts = [p.strip() for p in fused_op.split("+")]
-        # Map shorthand to full names
-        mapping = {
-            "GEMM": "Dense GEMM",
-            "SwiGLU": "Triton Fused",
-        }
-        return [mapping.get(p, p) for p in parts]
-    
-    return []
+def _find_fusion_mappings(
+    trace1_kernels: list[dict],
+    trace2_kernels: list[dict],
+    trace1_name: str = "Trace1",
+    trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
+) -> list[dict]:
+    """Find fusion mappings by analyzing kernel execution sequence patterns.
 
+    This function identifies when one platform runs multiple kernels separately
+    while the other platform fuses them into a single kernel.
 
-def _find_component_kernels(
-    layer_alignment: LayerAlignment,
-    component_ops: list[str],
-    platform: str,
-) -> list[str]:
-    """Find kernels for component operations on the specified platform.
-    
     Args:
-        layer_alignment: Layer alignment data
-        component_ops: List of operation types to look for (e.g., ["RMSNorm", "Dense GEMM"])
-        platform: "AMD" or "NVIDIA"
-    
+        trace1_kernels: List of kernel events from first trace
+        trace2_kernels: List of kernel events from second trace
+        trace1_name: Name of first platform (e.g., "AMD")
+        trace2_name: Name of second platform (e.g., "NVIDIA")
+        trace1_platform: Platform string for classification ("AMD" or "NVIDIA")
+
     Returns:
-        List of kernel names found for these operations
+        List of mapping dictionaries with fusion details
     """
-    found_kernels: list[str] = []
+    mappings = []
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
+
+    # Sort kernels by timestamp
+    trace1_sorted = sorted(trace1_kernels, key=lambda k: k.get("ts", 0))
+    trace2_sorted = sorted(trace2_kernels, key=lambda k: k.get("ts", 0))
+
+    # Classify all kernels
+    trace1_types = [_classify_kernel(k.get("name", ""), trace1_platform) for k in trace1_sorted]
+    trace2_types = [_classify_kernel(k.get("name", ""), trace2_platform) for k in trace2_sorted]
+
+    # Find kernel types unique to each trace
+    trace1_type_set = set(trace1_types)
+    trace2_type_set = set(trace2_types)
+
+    trace1_only = trace1_type_set - trace2_type_set
+    trace2_only = trace2_type_set - trace1_type_set
+
+    # For each unique type in trace1, check if it's a fused operation
+    # If trace1 has a unique kernel type that trace2 doesn't have, trace1 is likely fusing
+    for unique_type in trace1_only:
+        # Skip "Other" since it's too generic
+        if unique_type == "Other":
+            continue
+
+        # If the unique type contains '+', it's explicitly a fused kernel
+        # This means trace1 (which has it) is fusing, not trace2
+        if "+" in unique_type:
+            # Parse components from the fused op name
+            components = [c.strip() for c in unique_type.split("+")]
+            indices = [i for i, t in enumerate(trace1_types) if t == unique_type]
+            
+            if len(indices) < 5:
+                continue
+                
+            mappings.append({
+                "fused_platform": trace1_name,
+                "fused_kernel_type": unique_type,
+                "fused_count": len(indices),
+                "unfused_platform": trace2_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: trace2_types.count(c) for c in components},
+                "pattern_count": len(indices),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace1_name} fuses {' + '.join(components)} into single kernel ({len(indices)} calls), {trace2_name} runs separately",
+            })
+            continue
+
+        # For non-fused unique types, find all occurrences
+        indices = [i for i, t in enumerate(trace1_types) if t == unique_type]
+
+        if len(indices) < 5:  # Need enough samples to be meaningful
+            continue
+
+        # Analyze what comes before each occurrence
+        before_types: dict[str, int] = defaultdict(int)
+
+        for idx in indices:
+            if idx > 0:
+                before_types[trace1_types[idx - 1]] += 1
+
+        # Find the most common pattern
+        if not before_types:
+            continue
+        most_common_before = max(before_types.items(), key=lambda x: x[1])
+
+        # If there's a strong pattern (>80% of occurrences) and trace2 has the preceding type,
+        # trace1 runs them separately while trace2 might fuse
+        if most_common_before[1] / len(indices) > 0.8:
+            fusion_candidate = most_common_before[0]
+
+            # Verify trace2 has this type but NOT the unique_type
+            if fusion_candidate in trace2_type_set:
+                trace1_fusion_count = trace1_types.count(fusion_candidate)
+                trace2_fusion_count = trace2_types.count(fusion_candidate)
+
+                mappings.append({
+                    "fused_platform": trace2_name,
+                    "fused_kernel_type": fusion_candidate,
+                    "fused_count": trace2_fusion_count,
+                    "unfused_platform": trace1_name,
+                    "unfused_sequence": [fusion_candidate, unique_type],
+                    "unfused_count_per_type": {
+                        fusion_candidate: trace1_fusion_count,
+                        unique_type: len(indices),
+                    },
+                    "pattern_count": len(indices),
+                    "pattern_confidence": most_common_before[1] / len(indices),
+                    "evidence": f"{trace1_name} runs {fusion_candidate} + {unique_type} separately, {trace2_name} fuses into {fusion_candidate}",
+                })
+
+    # Also check trace2-only types
+    for unique_type in trace2_only:
+        if unique_type == "Other":
+            continue
+
+        # If the unique type contains '+', it's explicitly a fused kernel
+        # This means trace2 (which has it) is fusing, not trace1
+        if "+" in unique_type:
+            components = [c.strip() for c in unique_type.split("+")]
+            indices = [i for i, t in enumerate(trace2_types) if t == unique_type]
+            
+            if len(indices) < 5:
+                continue
+                
+            mappings.append({
+                "fused_platform": trace2_name,
+                "fused_kernel_type": unique_type,
+                "fused_count": len(indices),
+                "unfused_platform": trace1_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: trace1_types.count(c) for c in components},
+                "pattern_count": len(indices),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace2_name} fuses {' + '.join(components)} into single kernel ({len(indices)} calls), {trace1_name} runs separately",
+            })
+            continue
+
+        indices = [i for i, t in enumerate(trace2_types) if t == unique_type]
+
+        if len(indices) < 5:
+            continue
+
+        before_types = defaultdict(int)
+
+        for idx in indices:
+            if idx > 0:
+                before_types[trace2_types[idx - 1]] += 1
+
+        if not before_types:
+            continue
+        most_common_before = max(before_types.items(), key=lambda x: x[1])
+
+        if most_common_before[1] / len(indices) > 0.8:
+            fusion_candidate = most_common_before[0]
+
+            if fusion_candidate in trace1_type_set:
+                trace1_fusion_count = trace1_types.count(fusion_candidate)
+                trace2_fusion_count = trace2_types.count(fusion_candidate)
+
+                mappings.append({
+                    "fused_platform": trace1_name,
+                    "fused_kernel_type": fusion_candidate,
+                    "fused_count": trace1_fusion_count,
+                    "unfused_platform": trace2_name,
+                    "unfused_sequence": [fusion_candidate, unique_type],
+                    "unfused_count_per_type": {
+                        fusion_candidate: trace2_fusion_count,
+                        unique_type: len(indices),
+                    },
+                    "pattern_count": len(indices),
+                    "pattern_confidence": most_common_before[1] / len(indices),
+                    "evidence": f"{trace2_name} runs {fusion_candidate} + {unique_type} separately, {trace1_name} fuses into {fusion_candidate}",
+                })
+
+    return mappings
+
+
+def _find_count_imbalance_fusions(
+    trace1_kernels: list[dict],
+    trace2_kernels: list[dict],
+    trace1_name: str = "Trace1",
+    trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
+) -> list[dict]:
+    """Find fusions by looking for significant count imbalances.
+
+    When one platform has significantly more kernel calls of a type (>3x),
+    it MAY suggest the other platform fuses those operations.
     
-    for pair in layer_alignment.kernel_pairs:
-        if pair.operation in component_ops:
-            if platform == "AMD" and pair.amd_kernel and pair.amd_count > 0:
-                found_kernels.append(pair.amd_kernel)
-            elif platform == "NVIDIA" and pair.nvidia_kernel and pair.nvidia_count > 0:
-                found_kernels.append(pair.nvidia_kernel)
+    NOTE: This is speculative - count differences can also indicate:
+    - Different algorithmic implementations
+    - Different library choices (cuBLAS vs hipBLAS)
+    - Different optimization strategies
     
-    return found_kernels
+    Only very large imbalances (>3x) with high counts are flagged.
+    """
+    mappings = []
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
+
+    # Classify all kernels
+    trace1_types = [_classify_kernel(k.get("name", ""), trace1_platform) for k in trace1_kernels]
+    trace2_types = [_classify_kernel(k.get("name", ""), trace2_platform) for k in trace2_kernels]
+
+    # Count by type
+    trace1_counts = Counter(trace1_types)
+    trace2_counts = Counter(trace2_types)
+
+    # Find common types with significant differences
+    common_types = set(trace1_counts.keys()) & set(trace2_counts.keys())
+
+    # Skip types that are likely just implementation differences, not fusion
+    skip_types = {"Reduce", "Copy/Memory", "Sync", "Other", "Elementwise"}
+
+    for ktype in common_types:
+        if ktype in skip_types:
+            continue
+
+        trace1_count = trace1_counts[ktype]
+        trace2_count = trace2_counts[ktype]
+
+        # Skip low counts - need significant samples
+        if trace1_count + trace2_count < 200:
+            continue
 
+        # Check if there's a very significant imbalance (>3x)
+        # Lower ratios are likely implementation differences, not fusion
+        if trace1_count == 0 or trace2_count == 0:
+            continue
 
-def detect_fusion_in_aligned_layers(
-    layer_alignments: list[LayerAlignment],
+        ratio = max(trace1_count, trace2_count) / min(trace1_count, trace2_count)
+
+        if ratio < 3.0:
+            continue
+
+        # Determine which platform has more (unfused) and which has fewer (fused)
+        if trace1_count > trace2_count:
+            unfused_platform = trace1_name
+            fused_platform = trace2_name
+            unfused_count = trace1_count
+            fused_count = trace2_count
+        else:
+            unfused_platform = trace2_name
+            fused_platform = trace1_name
+            unfused_count = trace2_count
+            fused_count = trace1_count
+
+        mappings.append({
+            "fused_platform": fused_platform,
+            "fused_kernel_type": ktype,
+            "fused_count": fused_count,
+            "unfused_platform": unfused_platform,
+            "unfused_sequence": [ktype],
+            "unfused_count_per_type": {ktype: unfused_count},
+            "pattern_count": unfused_count - fused_count,
+            "pattern_confidence": (unfused_count - fused_count) / unfused_count,
+            "evidence": f"{unfused_platform} calls {ktype} {ratio:.1f}x more ({unfused_count} vs {fused_count}) - possible fusion",
+        })
+
+    return mappings
+
+
+def _find_explicit_fused_operations(
+    trace1_kernels: list[dict],
+    trace2_kernels: list[dict],
+    trace1_name: str = "Trace1",
+    trace2_name: str = "Trace2",
+    trace1_platform: str = "AMD",
+) -> list[dict]:
+    """Find explicit fused operations (kernels with '+' in their classification).
+
+    These are operations like 'RMSNorm+GEMM' that are explicitly classified as fused.
+    """
+    mappings = []
+    trace2_platform = "NVIDIA" if trace1_platform == "AMD" else "AMD"
+
+    def get_fused_ops(kernels: list[dict], platform: str) -> dict[str, list[str]]:
+        """Get fused operations and their kernel names."""
+        fused_ops: dict[str, list[str]] = defaultdict(list)
+        for k in kernels:
+            name = k.get("name", "")
+            op, _pattern = classify(name, platform)
+            if "+" in op.value or op == Op.FUSED_UNKNOWN:
+                fused_ops[op.value].append(name)
+        return dict(fused_ops)
+
+    trace1_fused = get_fused_ops(trace1_kernels, trace1_platform)
+    trace2_fused = get_fused_ops(trace2_kernels, trace2_platform)
+
+    # Find fused operations unique to trace1
+    for fused_op, kernels in trace1_fused.items():
+        if fused_op not in trace2_fused:
+            # Parse components from the fused op name
+            if "+" in fused_op:
+                components = [c.strip() for c in fused_op.split("+")]
+            else:
+                components = [fused_op]
+
+            mappings.append({
+                "fused_platform": trace1_name,
+                "fused_kernel_type": fused_op,
+                "fused_count": len(kernels),
+                "unfused_platform": trace2_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: 0 for c in components},  # Unknown
+                "pattern_count": len(kernels),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace1_name} fuses {' + '.join(components)} into {fused_op} ({len(kernels)} calls)",
+                "fused_kernel_names": kernels[:3],  # Sample of kernel names
+            })
+
+    # Find fused operations unique to trace2
+    for fused_op, kernels in trace2_fused.items():
+        if fused_op not in trace1_fused:
+            if "+" in fused_op:
+                components = [c.strip() for c in fused_op.split("+")]
+            else:
+                components = [fused_op]
+
+            mappings.append({
+                "fused_platform": trace2_name,
+                "fused_kernel_type": fused_op,
+                "fused_count": len(kernels),
+                "unfused_platform": trace1_name,
+                "unfused_sequence": components,
+                "unfused_count_per_type": {c: 0 for c in components},
+                "pattern_count": len(kernels),
+                "pattern_confidence": 1.0,
+                "evidence": f"{trace2_name} fuses {' + '.join(components)} into {fused_op} ({len(kernels)} calls)",
+                "fused_kernel_names": kernels[:3],
+            })
+
+    return mappings
+
+
+def detect_fusion_patterns(
+    amd_kernels: list[dict],
+    nvidia_kernels: list[dict],
 ) -> FusionAnalysis:
-    """Detect fusion patterns from aligned layer data.
+    """Detect fusion patterns using explicit fused operation detection only.
+
+    This approach only reports high-confidence fusions where kernels are
+    explicitly classified as fused (e.g., 'RMSNorm+GEMM', 'SwiGLU+GEMM').
+    
+    We intentionally avoid speculative detection (sequence patterns, count
+    imbalances) because these produce too many false positives - count
+    differences are usually due to different implementations, not fusion.
 
     Args:
-        layer_alignments: List of aligned layers
+        amd_kernels: List of AMD kernel events
+        nvidia_kernels: List of NVIDIA kernel events
 
     Returns:
         FusionAnalysis with detected patterns
     """
-    fusion_patterns: list[FusionPattern] = []
+    all_mappings: list[dict] = []
+
+    # Only use explicit fused operations (highest confidence, no false positives)
+    # These are kernels explicitly classified with '+' in their operation type
+    explicit_fusions = _find_explicit_fused_operations(
+        amd_kernels, nvidia_kernels,
+        trace1_name="AMD", trace2_name="NVIDIA",
+        trace1_platform="AMD",
+    )
+    all_mappings.extend(explicit_fusions)
     
-    # Track patterns we've already seen to avoid duplicates
-    seen_patterns: set[tuple[int, str, str]] = set()  # (layer, operation, fused_platform)
-
-    for layer_alignment in layer_alignments:
-        for pair in layer_alignment.kernel_pairs:
-            is_fused_op = _is_fused_operation(pair.operation)
-            
-            # Case 1: AMD has a kernel for this operation, NVIDIA doesn't
-            if pair.amd_kernel and pair.amd_count > 0 and (pair.nvidia_kernel is None or pair.nvidia_count == 0):
-                if is_fused_op:
-                    # AMD HAS the fused kernel → AMD is fusing
-                    # Find what NVIDIA runs separately
-                    component_ops = _get_component_operations(pair.operation)
-                    unfused_kernels = _find_component_kernels(layer_alignment, component_ops, "NVIDIA")
-                    
-                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        if unfused_kernels:
-                            evidence = f"AMD fuses {' + '.join(component_ops)} into {pair.amd_kernel}, NVIDIA runs {len(unfused_kernels)} separate kernels"
-                        else:
-                            evidence = f"AMD fuses into {pair.amd_kernel}, NVIDIA runs components separately"
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="AMD",
-                                fused_kernel=pair.amd_kernel,
-                                unfused_kernels=unfused_kernels if unfused_kernels else component_ops,
-                                count=pair.amd_count,
-                                evidence=evidence,
-                            )
-                        )
-                else:
-                    # Regular case: AMD has a kernel that NVIDIA fuses into something else
-                    # This means NVIDIA is fusing (it doesn't need this separate kernel)
-                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        evidence = f"AMD runs {pair.amd_kernel} separately ({pair.amd_count}x), NVIDIA fuses this operation"
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="NVIDIA",
-                                fused_kernel="(fused into nearby kernel)",
-                                unfused_kernels=[pair.amd_kernel],
-                                count=pair.amd_count,
-                                evidence=evidence,
-                            )
-                        )
-            
-            # Case 2: NVIDIA has a kernel for this operation, AMD doesn't
-            elif pair.nvidia_kernel and pair.nvidia_count > 0 and (pair.amd_kernel is None or pair.amd_count == 0):
-                if is_fused_op:
-                    # NVIDIA HAS the fused kernel → NVIDIA is fusing
-                    # Find what AMD runs separately
-                    component_ops = _get_component_operations(pair.operation)
-                    unfused_kernels = _find_component_kernels(layer_alignment, component_ops, "AMD")
-                    
-                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        if unfused_kernels:
-                            evidence = f"NVIDIA fuses {' + '.join(component_ops)} into {pair.nvidia_kernel}, AMD runs {len(unfused_kernels)} separate kernels"
-                        else:
-                            evidence = f"NVIDIA fuses into {pair.nvidia_kernel}, AMD runs components separately"
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="NVIDIA",
-                                fused_kernel=pair.nvidia_kernel,
-                                unfused_kernels=unfused_kernels if unfused_kernels else component_ops,
-                                count=pair.nvidia_count,
-                                evidence=evidence,
-                            )
-                        )
-                else:
-                    # Regular case: NVIDIA has a kernel that AMD fuses into something else
-                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        evidence = f"NVIDIA runs {pair.nvidia_kernel} separately ({pair.nvidia_count}x), AMD fuses this operation"
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="AMD",
-                                fused_kernel="(fused into nearby kernel)",
-                                unfused_kernels=[pair.nvidia_kernel],
-                                count=pair.nvidia_count,
-                                evidence=evidence,
-                            )
-                        )
-            
-            # Case 3: Both have kernels but with very different counts (partial fusion)
-            elif (
-                pair.amd_kernel
-                and pair.nvidia_kernel
-                and pair.amd_count > 0
-                and pair.nvidia_count > 0
-            ):
-                count_ratio = pair.amd_count / pair.nvidia_count if pair.nvidia_count > 0 else float('inf')
-                
-                if count_ratio > 1.5:
-                    # AMD runs more → NVIDIA fuses some instances
-                    pattern_key = (layer_alignment.layer, pair.operation, "NVIDIA")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        evidence = (
-                            f"AMD runs {pair.amd_kernel} {count_ratio:.1f}x more "
-                            f"({pair.amd_count} vs {pair.nvidia_count}), NVIDIA partially fuses"
-                        )
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="NVIDIA",
-                                fused_kernel=pair.nvidia_kernel,
-                                unfused_kernels=[pair.amd_kernel],
-                                count=pair.amd_count - pair.nvidia_count,
-                                evidence=evidence,
-                            )
-                        )
-                
-                elif count_ratio < 0.67:
-                    # NVIDIA runs more → AMD fuses some instances
-                    inverse_ratio = pair.nvidia_count / pair.amd_count if pair.amd_count > 0 else float('inf')
-                    pattern_key = (layer_alignment.layer, pair.operation, "AMD")
-                    if pattern_key not in seen_patterns:
-                        seen_patterns.add(pattern_key)
-                        
-                        evidence = (
-                            f"NVIDIA runs {pair.nvidia_kernel} {inverse_ratio:.1f}x more "
-                            f"({pair.nvidia_count} vs {pair.amd_count}), AMD partially fuses"
-                        )
-                        
-                        fusion_patterns.append(
-                            FusionPattern(
-                                layer=layer_alignment.layer,
-                                operation=pair.operation,
-                                fused_platform="AMD",
-                                fused_kernel=pair.amd_kernel,
-                                unfused_kernels=[pair.nvidia_kernel],
-                                count=pair.nvidia_count - pair.amd_count,
-                                evidence=evidence,
-                            )
-                        )
-
-    # Aggregate patterns by operation type and fused platform
-    aggregated: dict[tuple[str, str], FusionPattern] = {}
-    for pattern in fusion_patterns:
-        key = (pattern.operation, pattern.fused_platform)
-        if key in aggregated:
-            existing = aggregated[key]
-            existing.count += pattern.count
-            # Merge unfused kernels (deduplicate)
-            for k in pattern.unfused_kernels:
-                if k not in existing.unfused_kernels:
-                    existing.unfused_kernels.append(k)
-        else:
-            aggregated[key] = FusionPattern(
-                layer=pattern.layer,
-                operation=pattern.operation,
-                fused_platform=pattern.fused_platform,
-                fused_kernel=pattern.fused_kernel,
-                unfused_kernels=list(pattern.unfused_kernels),
-                count=pattern.count,
-                evidence=pattern.evidence,
+    # NOTE: We intentionally skip sequence-based and count-imbalance detection
+    # because they produce false positives. Count differences between platforms
+    # are usually due to different library implementations (cuBLAS vs hipBLAS),
+    # not actual kernel fusion.
+
+    # Convert to FusionPattern objects
+    patterns: list[FusionPattern] = []
+    for mapping in all_mappings:
+        fused_kernel_names = mapping.get("fused_kernel_names", [])
+        fused_kernel = fused_kernel_names[0] if fused_kernel_names else mapping["fused_kernel_type"]
+        
+        patterns.append(
+            FusionPattern(
+                layer=0,  # Pattern-based analysis doesn't track layers
+                operation=mapping["fused_kernel_type"],
+                fused_platform=mapping["fused_platform"],
+                fused_kernel=fused_kernel,
+                unfused_kernels=mapping["unfused_sequence"],
+                count=mapping["pattern_count"],
+                evidence=mapping["evidence"],
             )
+        )
 
-    amd_fuses = sum(1 for p in aggregated.values() if p.fused_platform == "AMD")
-    nvidia_fuses = sum(1 for p in aggregated.values() if p.fused_platform == "NVIDIA")
+    amd_fuses = sum(1 for p in patterns if p.fused_platform == "AMD")
+    nvidia_fuses = sum(1 for p in patterns if p.fused_platform == "NVIDIA")
 
     return FusionAnalysis(
-        patterns=list(aggregated.values()),
+        patterns=patterns,
         summary={
             "amd_fuses": amd_fuses,
             "nvidia_fuses": nvidia_fuses,
-            "total_fusion_opportunities": len(aggregated),
+            "total_fusion_opportunities": len(patterns),
         },
     )
 
 
 def analyze_fusion_from_alignment(
-    layer_alignments: list[LayerAlignment],
+    layer_alignments: list[Any],
+    amd_kernels: list[dict] | None = None,
+    nvidia_kernels: list[dict] | None = None,
 ) -> dict[str, Any]:
-    """Analyze fusion from alignment data (for API compatibility).
+    """Analyze fusion from kernel data (for API compatibility).
 
     Args:
-        layer_alignments: List of aligned layers
+        layer_alignments: List of aligned layers (unused - kept for API compatibility)
+        amd_kernels: Optional list of AMD kernel events for pattern-based analysis
+        nvidia_kernels: Optional list of NVIDIA kernel events for pattern-based analysis
 
     Returns:
-        Dictionary with fusion analysis results (compatible with old API)
+        Dictionary with fusion analysis results
     """
-    fusion_analysis = detect_fusion_in_aligned_layers(layer_alignments)
+    # If raw kernels provided, use pattern-based analysis (preferred)
+    if amd_kernels is not None and nvidia_kernels is not None:
+        fusion_analysis = detect_fusion_patterns(amd_kernels, nvidia_kernels)
+    else:
+        # Fallback: empty analysis if no kernel data
+        fusion_analysis = FusionAnalysis(
+            patterns=[],
+            summary={"amd_fuses": 0, "nvidia_fuses": 0, "total_fusion_opportunities": 0},
+        )
 
     fusion_opportunities = []
     fusion_mappings = []
 
     for pattern in fusion_analysis.patterns:
         unfused_platform = "NVIDIA" if pattern.fused_platform == "AMD" else "AMD"
-        
-        fusion_opportunities.append(
-            {
-                "kernel_type": pattern.operation,
-                "layer": pattern.layer,
-                "fused_by": pattern.fused_platform,
-                "fused_kernel": pattern.fused_kernel,
-                "unfused_kernels": pattern.unfused_kernels,
-                "count": pattern.count,
-                "evidence": pattern.evidence,
-            }
-        )
 
-        fusion_mappings.append(
-            {
-                "fused_platform": pattern.fused_platform,
-                "fused_kernel_type": pattern.operation,
-                "fused_kernel_name": pattern.fused_kernel,
-                "unfused_platform": unfused_platform,
-                "unfused_sequence": pattern.unfused_kernels,
-                "pattern_count": pattern.count,
-                "evidence": pattern.evidence,
-                "layer": pattern.layer,
-            }
-        )
+        fusion_opportunities.append({
+            "kernel_type": pattern.operation,
+            "layer": pattern.layer,
+            "fused_by": pattern.fused_platform,
+            "fused_kernel": pattern.fused_kernel,
+            "unfused_kernels": pattern.unfused_kernels,
+            "count": pattern.count,
+            "evidence": pattern.evidence,
+        })
+
+        fusion_mappings.append({
+            "fused_platform": pattern.fused_platform,
+            "fused_kernel_type": pattern.operation,
+            "fused_kernel_name": pattern.fused_kernel,
+            "unfused_platform": unfused_platform,
+            "unfused_sequence": pattern.unfused_kernels,
+            "pattern_count": pattern.count,
+            "evidence": pattern.evidence,
+            "layer": pattern.layer,
+        })
 
     return {
         "fusion_opportunities": fusion_opportunities,