Update benchmark.py

benchmark.py

@@ -141,12 +141,16 @@ class BenchmarkMetrics:
                 self.prefill_time_std = float(np.std(self.prefill_times))
                 self.prefill_time_ci = self._bootstrap_ci(self.prefill_times, config)
                 self.prefill_tokens_per_sec = config.prefill_length / self.prefill_time_mean if self.prefill_time_mean > 0 else 0.0
+            else:
+                logger.debug("No prefill time data available")
             
             if self.prefill_peak_memories:
                 memories_mb = [m / (1024 * 1024) for m in self.prefill_peak_memories]
                 self.prefill_peak_memory_mean_mb = float(np.mean(memories_mb))
                 self.prefill_peak_memory_std_mb = float(np.std(memories_mb))
                 self.prefill_peak_memory_ci_mb = self._bootstrap_ci(memories_mb, config)
+            else:
+                logger.debug("No prefill memory data available")
             
             if self.decode_times:
                 self.decode_time_per_token_mean_ms = float(np.mean(self.decode_times) * 1000)
@@ -155,6 +159,8 @@ class BenchmarkMetrics:
                 self.decode_tokens_per_sec = 1.0 / np.mean(self.decode_times) if self.decode_times else 0.0
                 self.decode_time_p50_ms = float(np.percentile(self.decode_times, 50) * 1000)
                 self.decode_time_p95_ms = float(np.percentile(self.decode_times, 95) * 1000)
+            else:
+                logger.debug("No decode time data available")
             
             # Calculate end-to-end throughput
             if self.prefill_time_mean > 0 and self.decode_time_per_token_mean_ms > 0:
@@ -165,23 +171,37 @@ class BenchmarkMetrics:
             
             if self.decode_peak_memories:
                 self.decode_peak_memory_mean_mb = float(np.mean(self.decode_peak_memories) / (1024 * 1024))
+            else:
+                logger.debug("No decode memory data available")
             
             if self.prefill_perplexities:
                 self.prefill_perplexity_mean = float(np.mean(self.prefill_perplexities))
                 self.prefill_perplexity_std = float(np.std(self.prefill_perplexities))
                 self.prefill_perplexity_ci = self._bootstrap_ci(self.prefill_perplexities, config)
+                logger.info(f"Calculated prefill perplexity: mean={self.prefill_perplexity_mean:.2f}, "
+                           f"std={self.prefill_perplexity_std:.2f}, samples={len(self.prefill_perplexities)}")
+            else:
+                logger.warning("No prefill perplexity data available")
             
             if self.generation_perplexities:
                 self.generation_perplexity_mean = float(np.mean(self.generation_perplexities))
                 self.generation_perplexity_std = float(np.std(self.generation_perplexities))
                 self.generation_perplexity_ci = self._bootstrap_ci(self.generation_perplexities, config)
+                logger.info(f"Calculated generation perplexity: mean={self.generation_perplexity_mean:.2f}, "
+                           f"std={self.generation_perplexity_std:.2f}, samples={len(self.generation_perplexities)}")
+            else:
+                logger.warning("No generation perplexity data available")
             
             if self.compression_ratios:
                 self.compression_ratio_mean = float(np.mean(self.compression_ratios))
                 self.compression_ratio_std = float(np.std(self.compression_ratios))
+            else:
+                logger.debug("No compression ratio data available")
             
             if self.kv_cache_memory_samples_mb:
                 self.kv_cache_memory_mb = float(np.mean(self.kv_cache_memory_samples_mb))
+            else:
+                logger.debug("No KV cache memory data available")
                 
         except Exception as e:
             logger.error(f"Error calculating statistics: {e}")