Analyzer

MemoryAnalyzer(sensitivity: float = 0.05)

def detect_memory_leaks(self, tracking_results: TrackingResult) -> List[Dict[str, Any]]

analyzer = MemoryAnalyzer(sensitivity=0.05)
leaks = analyzer.detect_memory_leaks(tracking_results)

for leak in leaks:
    print(f"{leak['severity'].upper()}: {leak['description']}")

def analyze_fragmentation(self, profile_result: ProfileResult) -> Dict[str, float]

def detect_patterns(self, tracking_results: TrackingResult) -> List[Dict[str, Any]]

patterns = analyzer.detect_patterns(tracking_results)

for pattern in patterns:
    print(f"Pattern: {pattern['type']} - {pattern['description']}")

def analyze_efficiency(self, profile_result: ProfileResult) -> float

def correlate_with_performance(self, profile_result: ProfileResult) -> Dict[str, Any]

def analyze_memory_gaps(self, events: List[TelemetryEventV2]) -> List[GapFinding]

events = tracker.get_tracking_results().events
gaps = analyzer.analyze_memory_gaps(events)

for gap in gaps:
    print(f"Severity: {gap.severity}")
    print(f"Classification: {gap.classification}")
    print(f"Description: {gap.description}")

def score_optimization(
    self,
    profile_result: ProfileResult,
    events: Optional[List[TelemetryEventV2]] = None
) -> Dict[str, Any]

analyzer.thresholds = {
    'gap_ratio_threshold': 0.05,      # 5% of device total
    'gap_spike_zscore': 2.0,          # z-score for spike detection
    'gap_drift_r_squared': 0.6,       # R-squared for drift
    'gap_fragmentation_ratio': 0.3,   # fragmentation threshold
}

from tfmemprof.analyzer import MemoryAnalyzer
from tfmemprof.profiler import TFMemoryProfiler
from tfmemprof.tracker import MemoryTracker

# Run profiling and tracking
profiler = TFMemoryProfiler()
tracker = MemoryTracker(sampling_interval=0.5)

tracker.start_tracking()

with profiler.profile_context("training"):
    model.fit(x_train, y_train, epochs=5)

tracking_results = tracker.stop_tracking()
profile_results = profiler.get_results()

# Analyze results
analyzer = MemoryAnalyzer(sensitivity=0.05)

# Detect memory leaks
leaks = analyzer.detect_memory_leaks(tracking_results)
if leaks:
    print("\nMemory Leaks Detected:")
    for leak in leaks:
        print(f"  [{leak['severity']}] {leak['description']}")

# Analyze fragmentation
frag = analyzer.analyze_fragmentation(profile_results)
print(f"\nFragmentation Score: {frag['fragmentation_score']:.3f}")
print(f"Trend: {'increasing' if frag['trend'] > 0 else 'decreasing'}")

# Detect patterns
patterns = analyzer.detect_patterns(tracking_results)
for pattern in patterns:
    print(f"\nPattern: {pattern['type']}")
    print(f"  {pattern['description']}")

# Get efficiency score
efficiency = analyzer.analyze_efficiency(profile_results)
print(f"\nMemory Efficiency: {efficiency:.1f}/10")

# Performance correlation
perf = analyzer.correlate_with_performance(profile_results)
print("\nPerformance Recommendations:")
for rec in perf['recommendations']:
    print(f"  - {rec}")

# Comprehensive optimization scoring
events = tracking_results.events
opt_score = analyzer.score_optimization(profile_results, events=events)

print(f"\nOptimization Score: {opt_score['overall_score']:.1f}/10")
print("\nCategory Scores:")
for cat, score in opt_score['categories'].items():
    print(f"  {cat}: {score:.1f}/10")

print("\nPriority Actions:")
for action in opt_score['priority_actions']:
    print(f"  - {action}")

if 'gap_analysis' in opt_score:
    print("\nHidden Memory Gaps:")
    for gap in opt_score['gap_analysis']:
        print(f"  [{gap['severity']}] {gap['description']}")