File size: 8,395 Bytes
2248c41
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
# ==============================================================================
# R Script: Generation of Benchmark Plots for Native Qualcomm Hexagon NPU Binaries
# Standardized on 100 Runs per Model Variant (600 Total Inferences)
# Models: MobileNetV4, MobileNetV5, ScaleDetection_MobileNetV4
# Target Platform: Machine 2 - Qualcomm Snapdragon X Plus (Surface Pro 11 ARM64)
# ==============================================================================

results_base <- Sys.getenv("LITHO_RESULTS_DIR", unset = "results")
if (!dir.exists(results_base) && dir.exists("E:/fine tuning/rock identifier/lithotheque-edge-models/results")) {
  results_base <- "E:/fine tuning/rock identifier/lithotheque-edge-models/results"
}

v4_csv <- file.path(results_base, "MobileNetV4/machine_2/benchmark_machine_2_v4_native_100_runs.csv")
v5_csv <- file.path(results_base, "MobileNetV5/machine_2/benchmark_machine_2_v5_native_100_runs.csv")
scale_csv <- file.path(results_base, "ScaleDetection/machine_2/benchmark_machine_2_scale_native_100_runs.csv")
all_csv <- file.path(results_base, "consolidated/csv/benchmark_machine_2_native_binaries_100_runs.csv")

color_npu_w4 <- "#2A9D8F"   # Teal / W4A8 INT4 NPU
color_npu_int8 <- "#1D3557" # Navy / W8A8 INT8 NPU
grid_color <- "#EAEAEA"

cat("[INFO] Running R Native Snapdragon NPU Plot Generator (100 Runs)...\n")
cat("[INFO] Results Directory:", results_base, "\n")

# ------------------------------------------------------------------------------
# 1. Comparative Latency for All Models on Hexagon NPU (100 Runs AOT .bin)
# ------------------------------------------------------------------------------
if (file.exists(all_csv)) {
  df_all <- read.csv(all_csv, stringsAsFactors = FALSE)
  df_all$Latency_ms <- as.numeric(df_all$Latency_ms)
  
  out_png_all <- file.path(results_base, "consolidated/images/machine_2_native_binaries_comparison.png")
  dir.create(dirname(out_png_all), recursive = TRUE, showWarnings = FALSE)
  
  png(filename = out_png_all, width = 1200, height = 700, res = 130)
  par(mar = c(6, 6, 4, 2), bg = "#FAFAFA")
  
  agg <- aggregate(Latency_ms ~ Model + Format, data = df_all, FUN = mean)
  agg$Label <- paste0(agg$Model, "\n(", agg$Format, ")")
  cols <- ifelse(agg$Format == "W4A8", color_npu_w4, color_npu_int8)
  
  bp <- barplot(agg$Latency_ms, names.arg = agg$Label, col = cols, border = NA,
                ylim = c(0, max(agg$Latency_ms) * 1.25),
                main = "Machine 2 (Hexagon NPU): Standalone Native AOT Invocation Turnaround (100 Runs)",
                ylab = "Turnaround Latency (ms / cold invocation - includes CLI & Disk I/O)",
                font.main = 2, col.lab = "#333333", col.axis = "#555555", las = 1)
  grid(col = grid_color, lty = "dotted")
  barplot(agg$Latency_ms, names.arg = NA, col = cols, border = NA,
          ylim = c(0, max(agg$Latency_ms) * 1.25), yaxt = "n", xaxt = "n", add = TRUE)
  
  fps <- round(1000 / agg$Latency_ms, 1)
  text(bp, agg$Latency_ms + (max(agg$Latency_ms) * 0.03),
       labels = paste0(round(agg$Latency_ms, 1), " ms\n(", fps, " FPS)"),
       font = 2, cex = 0.85, col = "#222222")
  
  legend("topleft",
         legend = c("Hexagon HTP W4A8 AOT (.bin)", "Hexagon HTP W8A8 / INT8 AOT (.bin)"),
         fill = c(color_npu_w4, color_npu_int8), border = NA, bg = "white", box.col = "#DDDDDD")
  dev.off()
  cat("[OK] Generated:", out_png_all, "\n")
}

# ------------------------------------------------------------------------------
# 2. MobileNetV4 Native Stability Plot (100 Consecutive Passes on Hexagon NPU)
# ------------------------------------------------------------------------------
if (file.exists(v4_csv)) {
  df_v4 <- read.csv(v4_csv, stringsAsFactors = FALSE)
  df_v4$Latency_ms <- as.numeric(df_v4$Latency_ms)
  
  out_v4_png <- file.path(results_base, "MobileNetV4/machine_2/mobilenetv4_machine_2_native_stability.png")
  png(filename = out_v4_png, width = 1200, height = 600, res = 130)
  par(mar = c(5, 5, 4, 2), bg = "#FAFAFA")
  
  w4_runs <- df_v4$Latency_ms[df_v4$Format == "W4A8"]
  int8_runs <- df_v4$Latency_ms[df_v4$Format == "INT8"]
  
  plot(1:length(w4_runs), w4_runs, type = "l", col = color_npu_w4, lwd = 2,
       ylim = c(min(c(w4_runs, int8_runs)) * 0.9, max(c(w4_runs, int8_runs)) * 1.15),
       xlab = "Inference Run ID (100 Consecutive Field Images)", ylab = "Hardware Latency (ms)",
       main = "MobileNetV4: Native HTP Stability on Machine 2 (Hexagon NPU, 100 Runs)",
       las = 1, font.main = 2)
  grid(col = grid_color, lty = "dotted")
  lines(1:length(int8_runs), int8_runs, col = color_npu_int8, lwd = 2)
  
  legend("topright",
         legend = c(paste0("W4A8 (Mean: ", round(mean(w4_runs), 1), " ms, p95: ", round(quantile(w4_runs, 0.95), 1), " ms)"),
                    paste0("INT8 (Mean: ", round(mean(int8_runs), 1), " ms, p95: ", round(quantile(int8_runs, 0.95), 1), " ms)")),
         col = c(color_npu_w4, color_npu_int8), lty = 1, lwd = 2, bg = "white")
  dev.off()
  cat("[OK] Generated:", out_v4_png, "\n")
}

# ------------------------------------------------------------------------------
# 3. MobileNetV5 Native Stability Plot (100 Consecutive Passes on Hexagon NPU)
# ------------------------------------------------------------------------------
if (file.exists(v5_csv)) {
  df_v5 <- read.csv(v5_csv, stringsAsFactors = FALSE)
  df_v5$Latency_ms <- as.numeric(df_v5$Latency_ms)
  
  out_v5_png <- file.path(results_base, "MobileNetV5/machine_2/mobilenetv5_machine_2_native_stability.png")
  png(filename = out_v5_png, width = 1200, height = 600, res = 130)
  par(mar = c(5, 5, 4, 2), bg = "#FAFAFA")
  
  w4_runs <- df_v5$Latency_ms[df_v5$Format == "W4A8"]
  int8_runs <- df_v5$Latency_ms[df_v5$Format == "INT8"]
  
  plot(1:length(w4_runs), w4_runs, type = "l", col = color_npu_w4, lwd = 2,
       ylim = c(min(c(w4_runs, int8_runs)) * 0.95, max(c(w4_runs, int8_runs)) * 1.05),
       xlab = "Inference Run ID (100 Consecutive Field Images)", ylab = "Hardware Latency (ms)",
       main = "MobileNetV5: Native HTP Stability on Machine 2 (Hexagon NPU, 100 Runs)",
       las = 1, font.main = 2)
  grid(col = grid_color, lty = "dotted")
  lines(1:length(int8_runs), int8_runs, col = color_npu_int8, lwd = 2)
  
  legend("topright",
         legend = c(paste0("W4A8 (Mean: ", round(mean(w4_runs), 1), " ms, p95: ", round(quantile(w4_runs, 0.95), 1), " ms)"),
                    paste0("INT8 (Mean: ", round(mean(int8_runs), 1), " ms, p95: ", round(quantile(int8_runs, 0.95), 1), " ms)")),
         col = c(color_npu_w4, color_npu_int8), lty = 1, lwd = 2, bg = "white")
  dev.off()
  cat("[OK] Generated:", out_v5_png, "\n")
}

# ------------------------------------------------------------------------------
# 4. ScaleDetection V4 Native Plot (100 Consecutive Passes on Hexagon NPU)
# ------------------------------------------------------------------------------
if (file.exists(scale_csv)) {
  df_scale <- read.csv(scale_csv, stringsAsFactors = FALSE)
  df_scale$Latency_ms <- as.numeric(df_scale$Latency_ms)
  
  out_scale_png <- file.path(results_base, "ScaleDetection/machine_2/scaledetection_machine_2_native_stability.png")
  png(filename = out_scale_png, width = 1200, height = 600, res = 130)
  par(mar = c(5, 5, 4, 2), bg = "#FAFAFA")
  
  w4_runs <- df_scale$Latency_ms[df_scale$Format == "W4A8"]
  int8_runs <- df_scale$Latency_ms[df_scale$Format == "INT8"]
  
  plot(1:length(w4_runs), w4_runs, type = "l", col = color_npu_w4, lwd = 2,
       ylim = c(min(c(w4_runs, int8_runs)) * 0.9, max(c(w4_runs, int8_runs)) * 1.15),
       xlab = "Inference Run ID (100 Consecutive Macro Images)", ylab = "Hardware Latency (ms)",
       main = "ScaleDetection V4: 1024x1024 Metrology Stability on Machine 2 (Hexagon NPU, 100 Runs)",
       las = 1, font.main = 2)
  grid(col = grid_color, lty = "dotted")
  lines(1:length(int8_runs), int8_runs, col = color_npu_int8, lwd = 2)
  
  legend("topright",
         legend = c(paste0("W4A8 (Mean: ", round(mean(w4_runs), 1), " ms, p95: ", round(quantile(w4_runs, 0.95), 1), " ms)"),
                    paste0("INT8 (Mean: ", round(mean(int8_runs), 1), " ms, p95: ", round(quantile(int8_runs, 0.95), 1), " ms)")),
         col = c(color_npu_w4, color_npu_int8), lty = 1, lwd = 2, bg = "white")
  dev.off()
  cat("[OK] Generated:", out_scale_png, "\n")
}

cat("[SUCCESS] All 100-run native Snapdragon NPU plots generated successfully in English.\n")