From af0c4896d327b0bf8d275808464b9097fda30579 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:08:03 +0200
Subject: [PATCH 01/35] android: add matched QAIRT graph adapter and build
 helper

---
 android/qnn/build.sh               |  36 +++++++
 android/qnn/graph_tuning.c         | 159 +++++++++++++++++++++++++++++
 android/qnn/qairt-2.47-sha256.json |  10 ++
 android/qnn/test_graph_tuning.c    |  83 +++++++++++++++
 4 files changed, 288 insertions(+)
 create mode 100644 android/qnn/build.sh
 create mode 100644 android/qnn/graph_tuning.c
 create mode 100644 android/qnn/qairt-2.47-sha256.json
 create mode 100644 android/qnn/test_graph_tuning.c

diff --git a/android/qnn/build.sh b/android/qnn/build.sh
new file mode 100644
index 00000000..ea40bd28
--- /dev/null
+++ b/android/qnn/build.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Supply an independently obtained QAIRT 2.47 SDK; no vendor code is downloaded.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+: "${QNN_SDK_ROOT:?set QNN_SDK_ROOT to the QAIRT 2.47 SDK}"
+: "${ANDROID_NDK_HOME:?set ANDROID_NDK_HOME to NDK r30}"
+OUT=${1:?usage: android/qnn/build.sh OUTPUT_JNILIBS_DIRECTORY}
+INCLUDE="$QNN_SDK_ROOT/include/QNN"
+[[ -d "$INCLUDE" ]] || INCLUDE="$QNN_SDK_ROOT/include"
+BUILD=$(mktemp -d)
+trap 'rm -rf "$BUILD"' EXIT
+FLAGS=(-std=gnu11 -Wall -Wextra -Werror -I "$INCLUDE")
+cc "${FLAGS[@]}" -fPIC -shared "$HERE/test_graph_tuning.c" -DFAKE_BACKEND -o "$BUILD/libQnnHtp.so"
+cc "${FLAGS[@]}" -fPIC -shared "$HERE/graph_tuning.c" -ldl -pthread -o "$BUILD/libJetlinkQnnHtp.so"
+cc "${FLAGS[@]}" "$HERE/test_graph_tuning.c" -ldl -o "$BUILD/test-tuning"
+for setting in stock:0 memory:1 accurate:14 memory-accurate:15 no-fusion:2 no-short-hmx:4 high-sigmoid:8 invalid:0; do
+  JETLINK_QNN_TUNING="${setting%:*}" EXPECTED_FLAGS="${setting#*:}" "$BUILD/test-tuning" "$BUILD/libJetlinkQnnHtp.so"
+done
+TOOLCHAIN="$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin"
+mkdir -p "$OUT/arm64-v8a"
+"$TOOLCHAIN/aarch64-linux-android31-clang" "${FLAGS[@]}" -fPIC -shared "$HERE/graph_tuning.c" \
+  -ldl -llog -pthread -Wl,-z,relro,-z,now -o "$OUT/arm64-v8a/libJetlinkQnnHtp.so"
+python3 - "$QNN_SDK_ROOT" "$OUT/arm64-v8a" "$HERE/qairt-2.47-sha256.json" <<'PY'
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import sys
+sdk, out, manifest = map(Path, sys.argv[1:])
+for name, expected in json.loads(manifest.read_text()).items():
+    matches = [p for p in sdk.rglob(name) if p.is_file() and hashlib.sha256(p.read_bytes()).hexdigest() == expected]
+    if not matches:
+        raise SystemExit(f"No byte-matched QAIRT 2.47 library found: {name}")
+    shutil.copyfile(matches[0], out / name)
+print("Eight byte-matched vendor libraries and the tested graph adapter are ready.")
+PY
diff --git a/android/qnn/graph_tuning.c b/android/qnn/graph_tuning.c
new file mode 100644
index 00000000..188215f7
--- /dev/null
+++ b/android/qnn/graph_tuning.c
@@ -0,0 +1,159 @@
+// Research adapter over the public QNN API; one real, version-matched HTP backend.
+// Lets ORT use documented HTP graph options its provider does not expose.
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "QnnInterface.h"
+#include "HTP/QnnHtpCommon.h"
+#include "HTP/QnnHtpGraph.h"
+#ifdef __ANDROID__
+#include <android/log.h>
+#define TUNE_LOG(...) __android_log_print(ANDROID_LOG_INFO, "JetlinkQnnTune", __VA_ARGS__)
+#else
+#define TUNE_LOG(...) ((void)0)
+#endif
+
+static pthread_once_t initialized = PTHREAD_ONCE_INIT;
+static void *backend;
+static QnnInterface_t wrapped;
+static const QnnInterface_t *provider_list[] = {&wrapped};
+static QnnGraph_CreateFn_t real_create;
+static QnnContext_FreeFn_t real_context_free;
+static Qnn_ErrorHandle_t init_status = QNN_COMMON_ERROR_GENERAL;
+
+// Keep our configuration storage valid for the whole context lifetime. This
+// also accommodates backends that consume a setting during graph finalization.
+typedef struct ConfigStorage {
+  struct ConfigStorage *next;
+  Qnn_ContextHandle_t context;
+  QnnHtpGraph_CustomConfig_t custom[4];
+  QnnGraph_Config_t config[4];
+  const QnnGraph_Config_t *all[];
+} ConfigStorage;
+static ConfigStorage *retained;
+static pthread_mutex_t retained_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static Qnn_ErrorHandle_t tuned_context_free(Qnn_ContextHandle_t context,
+    Qnn_ProfileHandle_t profile) {
+  Qnn_ErrorHandle_t status = real_context_free(context, profile);
+  if (status != QNN_SUCCESS) return status;
+  pthread_mutex_lock(&retained_mutex);
+  ConfigStorage **link = &retained;
+  while (*link != NULL) {
+    ConfigStorage *entry = *link;
+    if (entry->context == context) {
+      *link = entry->next;
+      free(entry);
+    } else {
+      link = &entry->next;
+    }
+  }
+  pthread_mutex_unlock(&retained_mutex);
+  return status;
+}
+
+static Qnn_ErrorHandle_t tuned_create(Qnn_ContextHandle_t context, const char *name,
+    const QnnGraph_Config_t **original, Qnn_GraphHandle_t *graph) {
+  const char *tuning = getenv("JETLINK_QNN_TUNING");
+  TUNE_LOG("graphCreate graph=%s tuning=%s", name ? name : "", tuning ? tuning : "stock");
+  if (tuning == NULL || strcmp(tuning, "stock") == 0) {
+    return real_create(context, name, original, graph);
+  }
+  bool memory = strcmp(tuning, "memory") == 0 || strcmp(tuning, "memory-accurate") == 0;
+  bool accurate = strcmp(tuning, "accurate") == 0 || strcmp(tuning, "memory-accurate") == 0;
+  bool no_fusion = accurate || strcmp(tuning, "no-fusion") == 0;
+  bool no_short_hmx = accurate || strcmp(tuning, "no-short-hmx") == 0;
+  bool high_sigmoid = accurate || strcmp(tuning, "high-sigmoid") == 0;
+  if (!memory && !no_fusion && !no_short_hmx && !high_sigmoid) {
+    return QNN_COMMON_ERROR_INVALID_ARGUMENT;
+  }
+  size_t n_original = 0;
+  if (original != NULL) {
+    while (n_original < 128 && original[n_original] != NULL) ++n_original;
+    if (n_original == 128) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
+  }
+  ConfigStorage *storage = calloc(1, sizeof(*storage) + (n_original + 5) * sizeof(*storage->all));
+  if (storage == NULL) return QNN_COMMON_ERROR_MEM_ALLOC;
+  storage->context = context;
+  const QnnGraph_Config_t **all = storage->all;
+  for (size_t i=0; i<n_original; ++i) all[i]=original[i];
+  QnnHtpGraph_CustomConfig_t *custom = storage->custom;
+  QnnGraph_Config_t *config = storage->config;
+  size_t count = 0;
+#define ADD_CONFIG(OPTION, FIELD, VALUE) do { \
+    custom[count].option = OPTION; custom[count].FIELD = VALUE; \
+    config[count].option = QNN_GRAPH_CONFIG_OPTION_CUSTOM; \
+    config[count].customConfig = &custom[count]; \
+    all[n_original + count] = &config[count]; ++count; \
+  } while (0)
+  if (memory) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_VTCM_SIZE, vtcmSizeInMB, QNN_HTP_GRAPH_CONFIG_OPTION_MAX);
+  if (no_fusion) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION, advancedActivationFusion, false);
+  if (no_short_hmx) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_SHORT_DEPTH_CONV_ON_HMX_OFF, shortDepthConvOnHmxOff, true);
+  if (high_sigmoid) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_HIGH_PRECISION_SIGMOID, highPrecisionSigmoid, true);
+#undef ADD_CONFIG
+  Qnn_ErrorHandle_t status = real_create(context, name, all, graph);
+  TUNE_LOG("graphCreate added=%zu status=%llu", count, (unsigned long long)status);
+  if (status == QNN_SUCCESS) {
+    pthread_mutex_lock(&retained_mutex);
+    storage->next = retained;
+    retained = storage;
+    pthread_mutex_unlock(&retained_mutex);
+  } else {
+    free(storage);
+  }
+  return status;
+}
+
+static void initialize(void) {
+  Dl_info location;
+  if (dladdr((void *)&initialize, &location) == 0 || location.dli_fname == NULL) return;
+  const char *slash = strrchr(location.dli_fname, '/');
+  if (slash == NULL) return;
+  char path[4096];
+  if (snprintf(path, sizeof(path), "%.*s/libQnnHtp.so", (int)(slash-location.dli_fname), location.dli_fname) >= (int)sizeof(path)) return;
+  backend = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+  if (backend == NULL) {
+    fprintf(stderr, "Jetlink QNN adapter: cannot open the matched HTP backend: %s\n", dlerror());
+    return;
+  }
+  typedef Qnn_ErrorHandle_t (*GetProviders)(const QnnInterface_t ***, uint32_t *);
+  GetProviders get = (GetProviders)dlsym(backend, "QnnInterface_getProviders");
+  if (get == NULL) return;
+  const QnnInterface_t **providers = NULL;
+  uint32_t count = 0;
+  if (get(&providers, &count) != QNN_SUCCESS) return;
+  for (uint32_t i=0; i<count; ++i) {
+    const QnnInterface_t *p = providers[i];
+    if (p == NULL || p->backendId != QNN_BACKEND_ID_HTP ||
+        p->apiVersion.coreApiVersion.major != QNN_API_VERSION_MAJOR ||
+        p->apiVersion.coreApiVersion.minor < QNN_API_VERSION_MINOR) continue;
+    wrapped = *p;
+    real_create = p->QNN_INTERFACE_VER_NAME.graphCreate;
+    real_context_free = p->QNN_INTERFACE_VER_NAME.contextFree;
+    if (real_create == NULL || real_context_free == NULL) return;
+    wrapped.QNN_INTERFACE_VER_NAME.graphCreate = tuned_create;
+    wrapped.QNN_INTERFACE_VER_NAME.contextFree = tuned_context_free;
+    const char *build_id = "unavailable";
+    if (p->QNN_INTERFACE_VER_NAME.backendGetBuildId != NULL) {
+      p->QNN_INTERFACE_VER_NAME.backendGetBuildId(&build_id);
+    }
+    TUNE_LOG("backend core=%u.%u build=%s", p->apiVersion.coreApiVersion.major,
+             p->apiVersion.coreApiVersion.minor, build_id ? build_id : "unavailable");
+    init_status = QNN_SUCCESS;
+    return;
+  }
+}
+
+Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***providers, uint32_t *count) {
+  if (providers == NULL || count == NULL) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
+  pthread_once(&initialized, initialize);
+  if (init_status != QNN_SUCCESS) return init_status;
+  *providers = provider_list;
+  *count = 1;
+  return QNN_SUCCESS;
+}
diff --git a/android/qnn/qairt-2.47-sha256.json b/android/qnn/qairt-2.47-sha256.json
new file mode 100644
index 00000000..651d63ae
--- /dev/null
+++ b/android/qnn/qairt-2.47-sha256.json
@@ -0,0 +1,10 @@
+{
+  "libQnnGpu.so": "76f85140bb969b554660dc846c4ee900d5c5b645b5942667f87972b8a880e371",
+  "libQnnHtp.so": "c0488f2df87932a42ca0a563883e6fba190896bca439ad0fdaa2428358ab5092",
+  "libQnnHtpPrepare.so": "9988ce10ffee6813ffd218df308478f44dbc758cc89aed9cb98cfebb030ca72e",
+  "libQnnHtpV79Skel.so": "dd8987c17928e53877e51ce5739c550d3e74393bd5b1b5ccf311326eddb08612",
+  "libQnnHtpV79Stub.so": "5f7460da65239d97be7b1845c2cebe20a4b8a92805721d9be796b2c4e706f132",
+  "libQnnIr.so": "79043536d4ac324782c953c9092066d3418ec88626ac2384b2e81883a3f8f644",
+  "libQnnSaver.so": "d26d8002da0fbe829f58370465dc40b4e5a0fc2c2830c0608972817ac5835026",
+  "libQnnSystem.so": "077a8b20a53b216d006b85b58dd754a9e958e02f98e9c79d46619db6f8edfec9"
+}
diff --git a/android/qnn/test_graph_tuning.c b/android/qnn/test_graph_tuning.c
new file mode 100644
index 00000000..ef1c73e5
--- /dev/null
+++ b/android/qnn/test_graph_tuning.c
@@ -0,0 +1,83 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "QnnInterface.h"
+#include "HTP/QnnHtpCommon.h"
+#include "HTP/QnnHtpGraph.h"
+
+#ifdef FAKE_BACKEND
+static const QnnGraph_Config_t **saved[2];
+static size_t saved_count;
+static void check_configs(const QnnGraph_Config_t **configs) {
+  int flags = 0, priority = 0;
+  for (size_t i=0; configs && configs[i]; ++i) {
+    if (configs[i]->option == QNN_GRAPH_CONFIG_OPTION_PRIORITY) { ++priority; continue; }
+    assert(configs[i]->option == QNN_GRAPH_CONFIG_OPTION_CUSTOM);
+    const QnnHtpGraph_CustomConfig_t *c = configs[i]->customConfig;
+    switch(c->option) {
+      case QNN_HTP_GRAPH_CONFIG_OPTION_VTCM_SIZE: assert(c->vtcmSizeInMB==0); flags|=1; break;
+      case QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION: assert(!c->advancedActivationFusion); flags|=2; break;
+      case QNN_HTP_GRAPH_CONFIG_OPTION_SHORT_DEPTH_CONV_ON_HMX_OFF: assert(c->shortDepthConvOnHmxOff); flags|=4; break;
+      case QNN_HTP_GRAPH_CONFIG_OPTION_HIGH_PRECISION_SIGMOID: assert(c->highPrecisionSigmoid); flags|=8; break;
+      default: assert(false);
+    }
+  }
+  assert(flags==atoi(getenv("EXPECTED_FLAGS")));
+  assert(priority==1);
+}
+static Qnn_ErrorHandle_t create(Qnn_ContextHandle_t context, const char *name,
+    const QnnGraph_Config_t **configs, Qnn_GraphHandle_t *graph) {
+  (void)context; (void)name;
+  check_configs(configs);
+  assert(saved_count < 2);
+  saved[saved_count++] = configs;
+  *graph=(void *)0x1;
+  return QNN_SUCCESS;
+}
+static Qnn_ErrorHandle_t context_free(Qnn_ContextHandle_t context, Qnn_ProfileHandle_t profile) {
+  (void)context; (void)profile;
+  for (size_t i=0; i<saved_count; ++i) check_configs(saved[i]);
+  saved_count=0;
+  return QNN_SUCCESS;
+}
+Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***list, uint32_t *count) {
+  static QnnInterface_t p = QNN_INTERFACE_INIT;
+  static const QnnInterface_t *ps[] = {&p};
+  p.backendId=QNN_BACKEND_ID_HTP;
+  p.apiVersion.coreApiVersion.major=QNN_API_VERSION_MAJOR;
+  p.apiVersion.coreApiVersion.minor=QNN_API_VERSION_MINOR;
+  p.QNN_INTERFACE_VER_NAME.graphCreate=create;
+  p.QNN_INTERFACE_VER_NAME.contextFree=context_free;
+  *list=ps; *count=1;
+  return QNN_SUCCESS;
+}
+#else
+#include <dlfcn.h>
+int main(int argc,char **argv) {
+  assert(argc==2);
+  void *lib=dlopen(argv[1],RTLD_NOW|RTLD_LOCAL);
+  if(!lib) { puts(dlerror()); return 1; }
+  typedef Qnn_ErrorHandle_t (*Get)(const QnnInterface_t ***,uint32_t *);
+  Get get=(Get)dlsym(lib,"QnnInterface_getProviders");
+  assert(get);
+  assert(get(NULL,NULL)==QNN_COMMON_ERROR_INVALID_ARGUMENT);
+  const QnnInterface_t **p; uint32_t n;
+  assert(get(&p,&n)==QNN_SUCCESS && n==1);
+  QnnGraph_Config_t priority=QNN_GRAPH_CONFIG_INIT;
+  priority.option=QNN_GRAPH_CONFIG_OPTION_PRIORITY;
+  const QnnGraph_Config_t *configs[]={&priority,NULL};
+  Qnn_GraphHandle_t graph=NULL;
+  Qnn_ErrorHandle_t status=p[0]->QNN_INTERFACE_VER_NAME.graphCreate(NULL,"test",configs,&graph);
+  if(strcmp(getenv("JETLINK_QNN_TUNING"),"invalid")==0) assert(status==QNN_COMMON_ERROR_INVALID_ARGUMENT);
+  else {
+    assert(status==QNN_SUCCESS && graph==(void *)0x1);
+    assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(NULL,"second",configs,&graph)==QNN_SUCCESS);
+  }
+  assert(p[0]->QNN_INTERFACE_VER_NAME.contextFree(NULL,NULL)==QNN_SUCCESS);
+  puts("configuration forwarding and deferred lifetime passed");
+  return 0;
+}
+#endif

From 506671fce060b56f4fd29de7c09512ebf7899fb1 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:09:59 +0200
Subject: [PATCH 02/35] prefill: JetlinkKit

---
 JetlinkKit/Package.swift | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/JetlinkKit/Package.swift b/JetlinkKit/Package.swift
index 0e01a44c..7fc7cf7f 100644
--- a/JetlinkKit/Package.swift
+++ b/JetlinkKit/Package.swift
@@ -48,6 +48,7 @@ let package = Package(
     .library(name: "JetlinkLiteRT", targets: ["JetlinkLiteRT"]),
     .library(name: "jetlink", type: .dynamic, targets: ["JetlinkAndroid"]),
     .executable(name: "jetlink-server", targets: ["jetlink-server"]),
+    .executable(name: "jetlink-prefill-base", targets: ["jetlink-prefill-base"]),
   ],
   dependencies: [
     .package(url: "https://github.com/apple/swift-crypto.git", "3.0.0"..<"5.0.0"),
@@ -125,6 +126,7 @@ let package = Package(
         .target(name: "JetlinkLinux", condition: .when(platforms: [.linux])),
         .product(name: "ArgumentParser", package: "swift-argument-parser", condition: .when(platforms: [.macOS, .linux])),
       ]),
+    .executableTarget(name: "jetlink-prefill-base", dependencies: ["JetlinkONNX"]),
     // Helpers more than one test target uses: fixtures, scratch directories, waits, a fake network.
     .target(name: "JetlinkTestSupport", dependencies: ["JetlinkRegistry", "JetlinkServer"], path: "Tests/JetlinkTestSupport"),
     .testTarget(name: "JetlinkKitTests", dependencies: ["JetlinkKit", "JetlinkUI", "JetlinkTestSupport"], resources: [.copy("Fixtures")]),

From 033ca804be02aca039c3cc1ec000a7993bcee21e Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:11:10 +0200
Subject: [PATCH 03/35] prefill: JetlinkKit/Sources/COrt/include

---
 JetlinkKit/Sources/COrt/include/jl_ort.h | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/JetlinkKit/Sources/COrt/include/jl_ort.h b/JetlinkKit/Sources/COrt/include/jl_ort.h
index 2ab08937..21075924 100644
--- a/JetlinkKit/Sources/COrt/include/jl_ort.h
+++ b/JetlinkKit/Sources/COrt/include/jl_ort.h
@@ -36,6 +36,7 @@ enum {
 typedef struct jl_env jl_env;
 typedef struct jl_session jl_session;
 typedef struct jl_binding jl_binding;
+typedef struct jl_shared_allocator jl_shared_allocator;
 
 typedef struct {
   const char *key;
@@ -77,10 +78,19 @@ char *jl_session_io_info(const jl_session *session, int output, size_t index,
                          char *name, size_t name_cap, int *elem_type,
                          int64_t *dims, size_t dims_cap, size_t *rank);
 
+// QNN's host-accessible RPC memory. The session must outlive this allocator,
+// and every allocation and binding must be freed before releasing it.
+char *jl_shared_allocator_create(jl_session *session, jl_shared_allocator **out);
+char *jl_shared_allocator_alloc(jl_shared_allocator *allocator, size_t bytes, void **out);
+void jl_shared_allocator_free(jl_shared_allocator *allocator, void *data);
+void jl_shared_allocator_release(jl_shared_allocator *allocator);
+size_t jl_shared_allocator_total_bytes(const jl_shared_allocator *allocator);
+
 // Binds caller-owned buffers to a session's inputs and outputs once, for
 // jl_binding_run to run with. The buffers must outlive the binding.
 char *jl_binding_create(jl_session *session, const jl_tensor *inputs, size_t n_inputs,
-                        const jl_tensor *outputs, size_t n_outputs, jl_binding **out);
+                        const jl_tensor *outputs, size_t n_outputs,
+                        const jl_shared_allocator *shared, jl_binding **out);
 char *jl_binding_run(jl_binding *binding);
 void jl_binding_release(jl_binding *binding);
 

From afb9e54f421b87ad78097d56169e566216401885 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:12:45 +0200
Subject: [PATCH 04/35] prefill: JetlinkKit/Sources/COrt

---
 JetlinkKit/Sources/COrt/jl_ort.c | 117 +++++++++++++++++++++++++++++--
 1 file changed, 112 insertions(+), 5 deletions(-)

diff --git a/JetlinkKit/Sources/COrt/jl_ort.c b/JetlinkKit/Sources/COrt/jl_ort.c
index 77422489..ba4dc5ba 100644
--- a/JetlinkKit/Sources/COrt/jl_ort.c
+++ b/JetlinkKit/Sources/COrt/jl_ort.c
@@ -2,6 +2,7 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #include <onnxruntime/onnxruntime_c_api.h>
 
@@ -15,6 +16,7 @@ struct jl_env {
 
 struct jl_session {
   OrtSession *session;
+  int profiling;
 };
 
 struct jl_binding {
@@ -24,6 +26,13 @@ struct jl_binding {
   size_t n_values;
 };
 
+struct jl_shared_allocator {
+  OrtSession *session;
+  OrtAllocator *allocator;
+  OrtMemoryInfo *memory;
+  size_t total_bytes;
+};
+
 #ifdef JL_ORT_DLOPEN
 // NULL when the library or its entry point is missing; jl_env_create says why.
 static const OrtApiBase *base(void) {
@@ -157,6 +166,23 @@ char *jl_session_create(jl_env *env, const char *model_path, const char *provide
   for (size_t i = 0; error == NULL && i < n_config; i++) {
     error = take(api()->AddSessionConfigEntry(so, config[i].key, config[i].value));
   }
+  const char *profile = getenv("JETLINK_ORT_PROFILE");
+  if (error == NULL && profile != NULL && profile[0] != '\0') {
+    char path[4096];
+    snprintf(path, sizeof(path), "%s-ort-%p", profile, (void *)so);
+    error = take(api()->EnableProfiling(so, path));
+  }
+  if (error == NULL && provider != NULL && strcmp(provider, "QNN") == 0 && getenv("JETLINK_QNN_STRICT") != NULL) {
+    for (size_t i = 0; i < n_options; i++) {
+      if ((strcmp(options[i].key, "backend_type") == 0 &&
+           (strcmp(options[i].value, "htp") == 0 || strcmp(options[i].value, "gpu") == 0)) ||
+          (strcmp(options[i].key, "backend_path") == 0 && strstr(options[i].value, "libJetlinkQnnHtp.so") != NULL)) {
+        // A heterogeneous test must fail if either accelerator leaves compute on the CPU.
+        error = take(api()->AddSessionConfigEntry(so, "session.disable_cpu_ep_fallback", "1"));
+        break;
+      }
+    }
+  }
   if (error == NULL && provider != NULL) {
     const char **keys = calloc(n_options + 1, sizeof(char *));
     const char **values = calloc(n_options + 1, sizeof(char *));
@@ -181,6 +207,7 @@ char *jl_session_create(jl_env *env, const char *model_path, const char *provide
   }
   if (error == NULL) {
     error = take(api()->CreateSession(env->env, model_path, so, &session->session));
+    session->profiling = profile != NULL && profile[0] != '\0';
   }
   api()->ReleaseSessionOptions(so);
   if (error != NULL) {
@@ -195,6 +222,19 @@ void jl_session_release(jl_session *session) {
   if (session == NULL) {
     return;
   }
+  if (session->profiling) {
+    OrtAllocator *allocator = NULL;
+    char *filename = NULL;
+    OrtStatus *status = api()->GetAllocatorWithDefaultOptions(&allocator);
+    if (status == NULL) {
+      free(take(api()->SessionEndProfiling(session->session, allocator, &filename)));
+      if (filename != NULL) {
+        free(take(api()->AllocatorFree(allocator, filename)));
+      }
+    } else {
+      free(take(status));
+    }
+  }
   api()->ReleaseSession(session->session);
   free(session);
 }
@@ -274,14 +314,76 @@ void jl_binding_release(jl_binding *binding) {
   free(binding);
 }
 
+void jl_shared_allocator_release(jl_shared_allocator *allocator) {
+  if (allocator == NULL) return;
+  if (allocator->allocator != NULL) api()->ReleaseAllocator(allocator->allocator);
+  if (allocator->memory != NULL) api()->ReleaseMemoryInfo(allocator->memory);
+  free(allocator);
+}
+
+char *jl_shared_allocator_create(jl_session *session, jl_shared_allocator **out) {
+  if (session == NULL || out == NULL) return copy("shared allocator needs a session and output");
+  *out = NULL;
+  jl_shared_allocator *allocator = calloc(1, sizeof(*allocator));
+  if (allocator == NULL) return copy("out of memory");
+  allocator->session = session->session;
+  char *error = take(api()->CreateMemoryInfo("QnnHtpShared", OrtDeviceAllocator, 0,
+                                             OrtMemTypeDefault, &allocator->memory));
+  if (error == NULL) error = take(api()->CreateAllocator(session->session, allocator->memory, &allocator->allocator));
+  const OrtMemoryInfo *actual = NULL;
+  if (error == NULL) error = take(api()->AllocatorGetInfo(allocator->allocator, &actual));
+  int different = 1;
+  if (error == NULL) error = take(api()->CompareMemoryInfo(allocator->memory, actual, &different));
+  if (error == NULL && different != 0) error = copy("session did not return QNN shared memory");
+  if (error != NULL) {
+    jl_shared_allocator_release(allocator);
+    return error;
+  }
+  *out = allocator;
+  return NULL;
+}
+
+char *jl_shared_allocator_alloc(jl_shared_allocator *allocator, size_t bytes, void **out) {
+  if (allocator == NULL || out == NULL) return copy("invalid shared allocation");
+  *out = NULL;
+  if (bytes > SIZE_MAX - allocator->total_bytes) return copy("shared allocation byte count overflow");
+  char *error = take(api()->AllocatorAlloc(allocator->allocator, bytes, out));
+  if (error == NULL && *out == NULL) error = copy("QNN shared allocator returned no memory");
+  if (error == NULL) allocator->total_bytes += bytes;
+  return error;
+}
+
+void jl_shared_allocator_free(jl_shared_allocator *allocator, void *data) {
+  if (allocator == NULL || data == NULL) return;
+  char *error = take(api()->AllocatorFree(allocator->allocator, data));
+  if (error != NULL) {
+    fprintf(stderr, "Jetlink QNN shared memory free: %s\n", error);
+    free(error);
+  }
+}
+
+size_t jl_shared_allocator_total_bytes(const jl_shared_allocator *allocator) {
+  return allocator == NULL ? 0 : allocator->total_bytes;
+}
+
 static char *wrap(const OrtMemoryInfo *memory, const jl_tensor *t, OrtValue **out) {
   return take(api()->CreateTensorWithDataAsOrtValue(memory, t->data, t->nbytes, t->dims, t->rank,
                                                     (ONNXTensorElementDataType)t->elem_type, out));
 }
 
 char *jl_binding_create(jl_session *session, const jl_tensor *inputs, size_t n_inputs,
-                        const jl_tensor *outputs, size_t n_outputs, jl_binding **out) {
+                        const jl_tensor *outputs, size_t n_outputs,
+                        const jl_shared_allocator *shared, jl_binding **out) {
   *out = NULL;
+  if (shared != NULL && shared->session != session->session) {
+    // ORT's QNN allocator tracks RPC allocations globally. A second HTP
+    // context can register the same host-accessible allocation. Verify that
+    // this target session really exposes QnnHtpShared; CPU/GPU may not claim it.
+    jl_shared_allocator *compatible = NULL;
+    char *error = jl_shared_allocator_create(session, &compatible);
+    if (error != NULL) return error;
+    jl_shared_allocator_release(compatible);
+  }
   jl_binding *binding = calloc(1, sizeof(jl_binding));
   if (binding == NULL) {
     return copy("out of memory");
@@ -292,8 +394,13 @@ char *jl_binding_create(jl_session *session, const jl_tensor *inputs, size_t n_i
     free(binding);
     return copy("out of memory");
   }
-  OrtMemoryInfo *memory = NULL;
-  char *error = take(api()->CreateCpuMemoryInfo(OrtArenaAllocator, OrtMemTypeDefault, &memory));
+  OrtMemoryInfo *cpu_memory = NULL;
+  const OrtMemoryInfo *memory = shared != NULL ? shared->memory : NULL;
+  char *error = NULL;
+  if (memory == NULL) {
+    error = take(api()->CreateCpuMemoryInfo(OrtArenaAllocator, OrtMemTypeDefault, &cpu_memory));
+    memory = cpu_memory;
+  }
   if (error == NULL) {
     error = take(api()->CreateIoBinding(session->session, &binding->binding));
   }
@@ -311,8 +418,8 @@ char *jl_binding_create(jl_session *session, const jl_tensor *inputs, size_t n_i
       error = take(api()->BindOutput(binding->binding, outputs[i].name, *value));
     }
   }
-  if (memory != NULL) {
-    api()->ReleaseMemoryInfo(memory);
+  if (cpu_memory != NULL) {
+    api()->ReleaseMemoryInfo(cpu_memory);
   }
   if (error != NULL) {
     jl_binding_release(binding);

From f9e5ea8972e0f1ddf07285a380077c6ca73b856b Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:13:36 +0200
Subject: [PATCH 05/35] prefill: JetlinkKit/Sources/JetlinkAndroid

---
 JetlinkKit/Sources/JetlinkAndroid/Bridge.swift | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift b/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
index 29e537bb..a545f061 100644
--- a/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
+++ b/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
@@ -174,6 +174,23 @@
       guard let cache = config["cache"] as? String, !cache.isEmpty else {
         throw HostFailure("no cache directory")
       }
+      let parallel = config["device"] as? String == "htp-parallel"
+      setenv("JETLINK_QNN_TUNING", parallel ? "no-fusion" : "stock", 1)
+      if parallel { setenv("JETLINK_QNN_STRICT", "1", 1) } else { unsetenv("JETLINK_QNN_STRICT") }
+      setenv("JETLINK_PARALLEL_SERIAL", (config["parallel_serial"] as? Bool) == true ? "1" : "0", 1)
+      if let path = config["parallel_bundle"] as? String, parallel {
+        setenv("JETLINK_PREFILL_BUNDLE", path, 1)
+      } else {
+        unsetenv("JETLINK_PREFILL_BUNDLE")
+      }
+      if let path = config["parallel_trace_path"] as? String, parallel {
+        setenv("JETLINK_PARALLEL_TRACE", path, 1)
+      } else {
+        unsetenv("JETLINK_PARALLEL_TRACE")
+      }
+      if let dir = config["native_library_dir"] as? String {
+        setenv("JETLINK_QNN_LIBRARY_DIR", dir, 1)
+      }
       let backend = try Host.backend(config)
       let configuration = Server.Configuration(
         port: UInt16(clamping: (config["port"] as? NSNumber)?.intValue ?? Int(Wire.defaultPort)),

From bed9b72e1336a232f64d069ffa188f48bc7dcb61 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:15:06 +0200
Subject: [PATCH 06/35] prefill: JetlinkKit/Sources/JetlinkONNX

---
 .../JetlinkONNX/CoreMLPreparation.swift       |  7 ++-
 .../Sources/JetlinkONNX/QnnPreparation.swift  | 51 +++++++++++++++++++
 2 files changed, 56 insertions(+), 2 deletions(-)
 create mode 100644 JetlinkKit/Sources/JetlinkONNX/QnnPreparation.swift

diff --git a/JetlinkKit/Sources/JetlinkONNX/CoreMLPreparation.swift b/JetlinkKit/Sources/JetlinkONNX/CoreMLPreparation.swift
index dc79ff7f..0bd9483e 100644
--- a/JetlinkKit/Sources/JetlinkONNX/CoreMLPreparation.swift
+++ b/JetlinkKit/Sources/JetlinkONNX/CoreMLPreparation.swift
@@ -42,6 +42,8 @@ public enum CoreMLPreparation {
     /// (`--device ane-whole`): model.onnx, with the policy's norms prescaled
     /// and the vision heads in fp32.
     case aneWhole
+    /// Offline base for the hash-bound Cinque V3 causal-prefill compiler.
+    case qnnPrefillBase
     /// One model for TensorRT or the CPU: model.onnx, tinygrad's ops
     /// stripped and the images fp16, nothing else changed.
     case plain
@@ -119,7 +121,7 @@ public enum CoreMLPreparation {
     var tiles = 0
     if layout != .plain {
       gathers = try Patches.normalizeGatherIndices(&g, src)
-      gemms = try Patches.gemmWithTransposedWeight(&g, src)
+      if layout != .qnnPrefillBase { gemms = try Patches.gemmWithTransposedWeight(&g, src) }
       tiles = try Patches.expandToTile(&g, src)
     }
     var norms = 0
@@ -128,6 +130,7 @@ public enum CoreMLPreparation {
       norms = try Patches.prescaleLayerNorm(&g)
       heads = try Patches.headsInFP32(&g, src)
     }
+    if layout == .qnnPrefillBase { norms = try QnnPreparation.fusedLayerNorms(&g) }
     model.graph = g
 
     var parts: [(name: String, model: Model)]
@@ -135,7 +138,7 @@ public enum CoreMLPreparation {
     case .split:
       let (vision, policy) = try Split.visionPolicy(model)
       parts = [("vision", vision), ("policy", policy)]
-    case .whole, .aneWhole, .plain:
+    case .whole, .aneWhole, .qnnPrefillBase, .plain:
       parts = [("model", model)]
     }
     for i in parts.indices where layout != .plain {
diff --git a/JetlinkKit/Sources/JetlinkONNX/QnnPreparation.swift b/JetlinkKit/Sources/JetlinkONNX/QnnPreparation.swift
new file mode 100644
index 00000000..a0ed707e
--- /dev/null
+++ b/JetlinkKit/Sources/JetlinkONNX/QnnPreparation.swift
@@ -0,0 +1,51 @@
+import Foundation
+
+/// Range-safe fp16 preparation for the validated experimental QNN profile.
+public enum QnnPreparation {
+  /// Keep the native LayerNormalization kernel instead of expanding it into
+  /// seventeen elementwise/reduction operations. A power-of-two input scale
+  /// and epsilon/k^2 preserve the real-valued expression; device parity is
+  /// still required because the HTP's fp16 arithmetic differs from the CPU.
+  static func fusedLayerNorms(_ graph: inout Graph, k: Float = 4) throws -> Int {
+    let types = Patches.staticTypes(graph)
+    let dimensions = Patches.staticDims(graph)
+    let constant = "__qnn_fused_norm_scale4"
+    guard !graph.initializers.contains(where: { $0.key == constant }) else {
+      throw OnnxError("reserved QNN normalization constant already present")
+    }
+    var rewritten: [Node] = []
+    var count = 0
+    for (index, original) in graph.nodes.enumerated() {
+      var node = original
+      if node.op == "LayerNormalization", let input = node.inputs.first, types[input] == DataType.float16 {
+        guard node.outputs.dropFirst().allSatisfy({ $0.isEmpty }) else {
+          throw OnnxError("experimental fused normalization does not rewrite optional statistics outputs")
+        }
+        let scaled = "__qnn_fused_norm_\(index)"
+        rewritten.append(Node(inputs: [input, constant], outputs: [scaled], name: scaled, opType: "Mul"))
+        node.inputs[0] = scaled
+        let epsilon = (node.attribute("epsilon")?.f ?? 1e-5) / (k * k)
+        node.attributes.removeAll { $0.name == "epsilon" }
+        var encoded = Encoded()
+        encoded.stringField(1, "epsilon")
+        encoded.tag(2, .fixed32)
+        let bits = epsilon.bitPattern
+        for shift in stride(from: 0, to: 32, by: 8) { encoded.byte(UInt8(truncatingIfNeeded: bits >> shift)) }
+        encoded.intField(20, 1)
+        node.attributes.append(Attribute(bytes: .owned(encoded.tail), name: "epsilon", type: 1, i: 0, f: epsilon, ints: [], s: "", floats: [], t: nil))
+        if let shape = dimensions[input] { graph.valueInfo.append(.tensor(scaled, DataType.float16, shape)) }
+        count += 1
+      }
+      rewritten.append(node)
+    }
+    if count > 0 {
+      graph.initializers.append(
+        Tensor(
+          name: constant, dims: [], dataType: DataType.float16,
+          raw: .owned(Elements.encode([1 / k], as: DataType.float16))))
+    }
+    graph.nodes = rewritten
+    return count
+  }
+
+}

From b8acd651df02ba478026306b67b057c1e928873f Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:15:29 +0200
Subject: [PATCH 07/35] prefill: JetlinkKit/Sources/JetlinkORT

---
 JetlinkKit/Sources/JetlinkORT/Ort.swift       |  41 ++++++-
 .../Sources/JetlinkORT/OrtBackend.swift       |  64 ++++++++--
 JetlinkKit/Sources/JetlinkORT/OrtEngine.swift | 110 ++++++++++++++++--
 .../Sources/JetlinkORT/SessionDAG.swift       |  81 +++++++++++++
 4 files changed, 276 insertions(+), 20 deletions(-)
 create mode 100644 JetlinkKit/Sources/JetlinkORT/SessionDAG.swift

diff --git a/JetlinkKit/Sources/JetlinkORT/Ort.swift b/JetlinkKit/Sources/JetlinkORT/Ort.swift
index 3a6830ad..e0d7e92a 100644
--- a/JetlinkKit/Sources/JetlinkORT/Ort.swift
+++ b/JetlinkKit/Sources/JetlinkORT/Ort.swift
@@ -113,11 +113,48 @@ final class OrtSession: @unchecked Sendable {
   }
 }
 
+/// Host-accessible allocations tracked by QNN for RPC memory registration.
+/// Retaining the session keeps its allocator valid until every buffer is freed.
+final class OrtSharedAllocator: @unchecked Sendable {
+  let pointer: OpaquePointer
+  private let session: OrtSession
+
+  init(session: OrtSession) throws {
+    self.session = session
+    var allocator: OpaquePointer?
+    try OrtError.check(jl_shared_allocator_create(session.pointer, &allocator))
+    guard let allocator else { throw OrtError("QNN returned no shared allocator") }
+    pointer = allocator
+  }
+
+  deinit { jl_shared_allocator_release(pointer) }
+
+  var totalBytes: Int { jl_shared_allocator_total_bytes(pointer) }
+
+  var hostAllocator: HostAllocator {
+    HostAllocator(
+      allocate: { [self] bytes in
+        var memory: UnsafeMutableRawPointer?
+        try OrtError.check(jl_shared_allocator_alloc(pointer, bytes, &memory))
+        guard let memory else { throw OrtError("QNN shared allocation returned no pointer") }
+        return memory
+      },
+      free: { [self] memory in
+        jl_shared_allocator_free(pointer, memory)
+      })
+  }
+}
+
 /// Caller-owned buffers bound to one session's inputs and outputs.
 final class OrtBinding {
   private let pointer: OpaquePointer
+  private let sharedAllocator: OrtSharedAllocator?
 
-  init(session: OrtSession, inputs: [(TensorSpec, UnsafeMutableRawPointer)], outputs: [(TensorSpec, UnsafeMutableRawPointer)]) throws {
+  init(
+    session: OrtSession, inputs: [(TensorSpec, UnsafeMutableRawPointer)], outputs: [(TensorSpec, UnsafeMutableRawPointer)],
+    sharedAllocator: OrtSharedAllocator? = nil
+  ) throws {
+    self.sharedAllocator = sharedAllocator
     var names: [UnsafeMutablePointer<CChar>?] = []
     var dims: [UnsafeMutablePointer<Int64>] = []
     defer {
@@ -135,7 +172,7 @@ final class OrtBinding {
     let ins = inputs.map { tensor($0.0, $0.1) }
     let outs = outputs.map { tensor($0.0, $0.1) }
     var binding: OpaquePointer?
-    try OrtError.check(jl_binding_create(session.pointer, ins, ins.count, outs, outs.count, &binding))
+    try OrtError.check(jl_binding_create(session.pointer, ins, ins.count, outs, outs.count, sharedAllocator?.pointer, &binding))
     guard let binding else { throw OrtError("onnxruntime returned no binding") }
     pointer = binding
   }
diff --git a/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift b/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
index a789aba3..fb10656d 100644
--- a/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
+++ b/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
@@ -25,6 +25,8 @@ public enum OrtProfile: String, CaseIterable, Sendable {
   /// fp16 whatever the graph says, so its fp32 heads are fp16 there too, and
   /// only the parity check can say whether that is close enough.
   case htpWhole = "htp-whole"
+  /// Experimental same-frame (HTP vision || GPU history) -> HTP decode -> CPU join.
+  case htpParallel = "htp-parallel"
   /// The whole graph on the Adreno GPU.
   case gpu
   /// onnxruntime's CPU provider alone: for tests, the emulator and Linux,
@@ -36,7 +38,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
     #if canImport(Metal)
       [.ane, .aneWhole, .coreml, .cpu]
     #elseif os(Android)
-      [.htp, .htpWhole, .gpu, .cpu]
+      [.htp, .htpWhole, .htpParallel, .gpu, .cpu]
     #else
       [.cpu]
     #endif
@@ -50,6 +52,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
     case .aneWhole: [("model", .coreML("ALL"))]
     case .htp: [("vision", .htp), ("policy", .qnnGPU)]
     case .htpWhole: [("model", .htp)]
+    case .htpParallel: [("vision", .htp), ("history", .qnnGPU), ("decode", .htp), ("join", .cpu)]
     case .gpu: [("model", .qnnGPU)]
     case .cpu: [("model", .cpu)]
     }
@@ -64,6 +67,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
     switch self {
     case .ane, .htp: .split
     case .aneWhole, .htpWhole: .aneWhole
+    case .htpParallel: .qnnPrefillBase  // loaded from the verified offline bundle
     case .coreml, .gpu: .whole
     case .cpu:
       #if os(Android)
@@ -77,7 +81,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
   /// What a build writes: 5 is every graph split on `ane` and Expand as Tile
   /// on both, 6 the plain graph. An artifact prepared under another rebuilds.
   public var prepareVersion: Int {
-    layout == .plain ? 6 : 5
+    self == .htpParallel ? 10 : (layout == .plain ? 6 : 5)
   }
 
   var usesCoreML: Bool {
@@ -122,8 +126,8 @@ enum OrtUnit: Equatable {
 /// and their manifest (OrtArtifact), CoreML's compiled models or QNN's EP
 /// context beside them.
 ///
-/// Nothing QNN has run on a Snapdragon yet: its options follow onnxruntime
-/// 1.29's QNN documentation and source.
+/// The causal-prefill profile has been measured on SM8750 with Cinque V3;
+/// other QNN profiles and hardware keep their existing behavior.
 public final class OrtBackend: EngineBackend {
   /// A first NPU compile with no earlier build to go by. The QNN graph
   /// finalization of a big model is minutes on a phone (unmeasured).
@@ -156,7 +160,11 @@ public final class OrtBackend: EngineBackend {
   public var runtimeVersion: String { OrtRuntime.version }
 
   public func deviceTag() -> String {
-    sanitize("\(profile.rawValue)-\(chip)")
+    if profile == .htpParallel {
+      let mode = ProcessInfo.processInfo.environment["JETLINK_PARALLEL_SERIAL"] == "1" ? "serial" : "parallel"
+      return sanitize("htp-parallel-\(chip)-fused4-qairt247-no-fusion-sharedio-\(CausalPrefillBundle.identity)-\(mode)")
+    }
+    return sanitize("\(profile.rawValue)-\(chip)")
   }
 
   public func deriveSpec(model: URL, sha256: String, nbytes: Int64, frameSkip: Int) throws -> ModelSpec {
@@ -165,7 +173,16 @@ public final class OrtBackend: EngineBackend {
 
   /// QNN's options for a unit, as onnxruntime 1.29 names them.
   func providerOptions(_ unit: OrtUnit) -> [String: String] {
-    switch unit {
+    if profile == .htpParallel && unit == .htp {
+      return [
+        "backend_path": (ProcessInfo.processInfo.environment["JETLINK_QNN_LIBRARY_DIR"].map { "\($0)/" } ?? "") + "libJetlinkQnnHtp.so",
+        "soc_model": "69", "htp_arch": "79",
+        "htp_performance_mode": keepAlive ? "burst" : "sustained_high_performance",
+        "htp_graph_finalization_optimization_mode": "3", "enable_htp_fp16_precision": "1",
+        "qnn_context_priority": "high", "enable_htp_shared_memory_allocator": "1",
+      ]
+    }
+    return switch unit {
     case .htp:
       [
         "backend_type": "htp",
@@ -201,16 +218,40 @@ public final class OrtBackend: EngineBackend {
     }
   }
 
+  /// Fail before compiling or loading on unvalidated hardware/runtime stacks.
+  private func validateParallel() throws {
+    guard profile == .htpParallel else { return }
+    guard chip == "SM8750", OrtRuntime.version == "1.29.0",
+      ProcessInfo.processInfo.environment["JETLINK_QNN_TUNING"] == "no-fusion",
+      ProcessInfo.processInfo.environment["JETLINK_QNN_STRICT"] == "1"
+    else {
+      throw HostError.invalid("causal-prefill requires the opt-in SM8750 / ORT 1.29 / QAIRT 2.47 build; see docs/android-causal-prefill.md")
+    }
+  }
+
+  private func engine(_ artifact: URL, _ manifest: [[String: Any]], keepAlive: Bool, keepCPUWarm: Bool) throws -> OrtEngine {
+    try OrtEngine(
+      plans: plans(artifact, manifest), device: deviceTag(), keepAlive: keepAlive, keepCPUWarm: keepCPUWarm,
+      dataflow: profile == .htpParallel,
+      parallel: ProcessInfo.processInfo.environment["JETLINK_PARALLEL_SERIAL"] != "1")
+  }
+
   // MARK: build
 
   public func build(model: URL, artifact: URL, report: @escaping ProgressFn, metaExtra: [String: Any]) throws {
+    try validateParallel()
     let started = Date()
     let expect = Artifact.sidecar(artifact)
     try Artifact.build(artifact, metaExtra: metaExtra, report: report) { staged in
       try FileManager.default.createDirectory(at: staged, withIntermediateDirectories: true)
       report("patch", 0, profile.usesCoreML ? "preparing the model for CoreML" : "preparing the model")
-      let prepared = try preparer.prepare(model: model, into: staged, layout: profile.layout) {
-        CoreMLPreparation.cacheKey(stem: artifact.deletingPathExtension().lastPathComponent, part: $0)
+      let prepared: PreparedModel
+      if profile == .htpParallel {
+        prepared = try CausalPrefillBundle.prepare(model: model, into: staged)
+      } else {
+        prepared = try preparer.prepare(model: model, into: staged, layout: profile.layout) {
+          CoreMLPreparation.cacheKey(stem: artifact.deletingPathExtension().lastPathComponent, part: $0)
+        }
       }
       log.info("prepared \(model.lastPathComponent): \(prepared.summary)")
       let sessions = profile.sessions
@@ -247,7 +288,7 @@ public final class OrtBackend: EngineBackend {
       }
       // Prove it runs before calling it built: minutes on a CPU, so it ticks.
       let providers = try Ticker.during(interval: 1, Ticker.paced("load", "loading the model to check it runs", took: 0, report: report)) {
-        let engine = try OrtEngine(plans: plans(staged, manifest), device: deviceTag(), keepAlive: false, keepCPUWarm: false)
+        let engine = try self.engine(staged, manifest, keepAlive: false, keepCPUWarm: false)
         defer { engine.close() }
         try engine.run()
         return engine.providers
@@ -297,7 +338,7 @@ public final class OrtBackend: EngineBackend {
       report(stage, frac, msg)
     }
     let engine = try Ticker.during(interval: 2, tick) {
-      try OrtEngine(plans: plans(staged, manifest), device: deviceTag(), keepAlive: false, keepCPUWarm: false)
+      try self.engine(staged, manifest, keepAlive: false, keepCPUWarm: false)
     }
     defer { engine.close() }
     let (converted, compiled) = progress.measure()
@@ -326,6 +367,7 @@ public final class OrtBackend: EngineBackend {
   // MARK: load
 
   public func load(artifact: URL, report: @escaping ProgressFn) throws -> any Engine {
+    try validateParallel()
     let (manifest, meta) = try OrtArtifact.open(artifact, version: profile.prepareVersion) { entry in
       guard let unit = OrtUnit(entry: entry) else { return "a session names no unit" }
       // Without its compile, onnxruntime would recompile under a "loading"
@@ -338,7 +380,7 @@ public final class OrtBackend: EngineBackend {
     }
     let what = profile.usesCoreML ? "the CoreML model" : "the model"
     let (engine, seconds) = try Artifact.load(artifact, meta: meta, what: what, report: report) {
-      try OrtEngine(plans: plans(artifact, manifest), device: deviceTag(), keepAlive: keepAlive, keepCPUWarm: keepCPUWarm)
+      try self.engine(artifact, manifest, keepAlive: keepAlive, keepCPUWarm: keepCPUWarm)
     }
     log.info("onnxruntime sessions on \(profile.rawValue) in \(String(format: "%.1f", seconds)) s: \(engine.providers.joined(separator: " then "))")
     return engine
diff --git a/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift b/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
index f12f9e18..dc6cceed 100644
--- a/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
+++ b/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
@@ -56,7 +56,7 @@ public struct SessionPlan: Sendable, Equatable {
   }
 }
 
-/// A loaded model: a chain of onnxruntime sessions run back to back over
+/// A loaded model: a chain or dependency DAG of onnxruntime sessions over
 /// buffers the engine owns, the Swift form of the Python ort worker.
 ///
 /// The host writes a frame's inputs into `hostInput(_:)`, calls `run()`, and
@@ -70,19 +70,33 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
   /// Whether the CPU is kept warm beside this engine: a busy thread, or
   /// Android's performance hints.
   public var keepsCPUWarm: Bool { keepWarm != nil || hint != nil }
-  public override var notes: String { "CPU keep-warm \(keepsCPUWarm ? "on" : "off")" }
+  public override var notes: String {
+    "CPU keep-warm \(keepsCPUWarm ? "on" : "off"); QNN shared I/O \(sharedAllocator == nil ? "off" : "on")"
+      + (schedule == nil ? "" : "; session DAG \(parallelExecution ? "parallel" : "serial control")")
+  }
   public override var coolsWhenIdle: Bool { usesNeuralEngine }
 
   private let chain: [OrtSession]
+  private let sharedAllocator: OrtSharedAllocator?
+  private let sharedSessions: [Bool]
   private var bindings: [[OrtBinding]] = []  // [parity][session]
   private let keepAlive: MetalKeepAlive?
   private let keepWarm: CPUKeepWarm?
   private let hint: PerformanceHint?
   private let usesNeuralEngine: Bool
+  private let schedule: SessionDAG?
+  private let parallelExecution: Bool
+  private var measuredFrames = 0
+  private var stageTotals: [UInt64] = []
+  private var overlapTotal: UInt64 = 0
+  private var trace: [[StageStamp]] = []
 
   /// `keepAlive` keeps the GPU clocked up between frames, `keepCPUWarm` the
   /// CPU; each only where a plan runs on that unit.
-  public init(plans: [SessionPlan], device: String, keepAlive: Bool = true, keepCPUWarm: Bool = true) throws {
+  public init(
+    plans: [SessionPlan], device: String, keepAlive: Bool = true, keepCPUWarm: Bool = true,
+    dataflow: Bool = false, parallel: Bool = true
+  ) throws {
     self.device = device
     var chain: [OrtSession] = []
     for plan in plans {
@@ -90,6 +104,18 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
     }
     self.chain = chain
     self.providers = plans.map(\.label)
+    self.schedule = dataflow ? try SessionDAG(inputs: chain.map { $0.inputs.map(\.name) }, outputs: chain.map { $0.outputs.map(\.name) }) : nil
+    self.parallelExecution = parallel
+    self.stageTotals = Array(repeating: 0, count: chain.count)
+    let sharedSessions = plans.map { $0.options["enable_htp_shared_memory_allocator"] == "1" }
+    for (index, enabled) in sharedSessions.enumerated() where enabled {
+      guard plans[index].provider == "QNN", plans[index].usesNeuralEngine, !plans[index].usesGPU else {
+        throw OrtError("only verified QNN HTP sessions may bind QNN shared memory")
+      }
+    }
+    let shared = try sharedSessions.firstIndex(of: true).map { try OrtSharedAllocator(session: chain[$0]) }
+    self.sharedAllocator = shared
+    self.sharedSessions = sharedSessions
 
     // What the host stages: every session's inputs no earlier session
     // produces. What it can read: every session's outputs no later one reads.
@@ -108,10 +134,25 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
         outputs[spec.name] = spec
       }
     }
+    if dataflow {
+      let written = Set(chain.flatMap { $0.outputs.map(\.name) })
+      let read = Set(chain.flatMap { $0.inputs.map(\.name) })
+      inputs = [:]
+      outputs = [:]
+      for session in chain {
+        for spec in session.inputs where !written.contains(spec.name) { inputs[spec.name] = spec }
+        for spec in session.outputs where !read.contains(spec.name) { outputs[spec.name] = spec }
+      }
+    }
     // One buffer per tensor name: inputs, hand-offs and outputs alike.
     var sizes: [String: Int] = [:]
+    var tensorTypes: [String: TensorSpec] = [:]
     for session in chain {
       for spec in session.inputs + session.outputs {
+        if let previous = tensorTypes[spec.name], previous != spec {
+          throw OrtError("incompatible session tensor \(spec.name)")
+        }
+        tensorTypes[spec.name] = spec
         sizes[spec.name] = max(sizes[spec.name] ?? 0, spec.byteCount)
       }
     }
@@ -122,7 +163,7 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
     let hint = warmCPU ? PerformanceHint.make() : nil
     self.hint = hint
     self.keepWarm = warmCPU && hint == nil ? CPUKeepWarm() : nil
-    try super.init(inputs: inputs, outputs: outputs, sizes: sizes)
+    try super.init(inputs: inputs, outputs: outputs, sizes: sizes, allocator: shared?.hostAllocator ?? .heap)
     // A throw from here on closes through deinit.
     try rebind([])
   }
@@ -145,14 +186,20 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
     var sets: [[OrtBinding]] = []
     for p in 0..<(pairs.isEmpty ? 1 : 2) {
       var set: [OrtBinding] = []
-      for session in chain {
+      for (index, session) in chain.enumerated() {
         let ins = session.inputs.map { ($0, buffer($0.name, parity: p)!) }
         let outs = session.outputs.map { spec -> (TensorSpec, UnsafeMutableRawPointer) in
           guard let input = outputOf[spec.name] else { return (spec, buffer(spec.name, parity: p)!) }
           // writes the buffer the state_ input reads next run
           return (spec, buffer(input, parity: p ^ 1)!)
         }
-        set.append(try OrtBinding(session: session, inputs: ins, outputs: outs))
+        // RPC buffers are host-accessible. GPU and CPU sessions use ordinary
+        // CPU tensor metadata over those pointers; only HTP contexts register
+        // them as QnnHtpShared. Every context stays alive until all buffers free.
+        set.append(
+          try OrtBinding(
+            session: session, inputs: ins, outputs: outs,
+            sharedAllocator: sharedSessions[index] ? sharedAllocator : nil))
       }
       sets.append(set)
     }
@@ -172,6 +219,25 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
   }
 
   public override func execute() throws {
+    if let schedule {
+      let times = StageTimings(count: chain.count)
+      try schedule.run(parallel: parallelExecution) { index in
+        let start = DispatchTime.now().uptimeNanoseconds
+        defer { times.record(index, start: start, end: DispatchTime.now().uptimeNanoseconds) }
+        try self.bindings[self.parity][index].run()
+      }
+      let stamps = times.snapshot()
+      measuredFrames += 1
+      for (index, stamp) in stamps.enumerated() { stageTotals[index] += stamp.end - stamp.start }
+      for layer in schedule.layers where layer.count > 1 {
+        let group = layer.map { stamps[$0] }
+        let total = group.reduce(UInt64(0)) { $0 + $1.end - $1.start }
+        let span = group.map(\.end).max()! - group.map(\.start).min()!
+        if total > span { overlapTotal += total - span }
+      }
+      if trace.count < 128 { trace.append(stamps) }
+      return
+    }
     for binding in bindings[parity] {
       try binding.run()
     }
@@ -181,11 +247,41 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
   /// second is the steady state.
   public override func warm() throws -> String {
     _ = try super.warm()
-    return "onnxruntime \(OrtRuntime.version) on \(device) in process, sessions \(providers.joined(separator: " then "))"
+    let shared = sharedAllocator.map { "; QNN shared I/O: \($0.totalBytes) bytes allocated" } ?? ""
+    return "onnxruntime \(OrtRuntime.version) on \(device) in process, sessions \(providers.joined(separator: " then "))\(shared)"
+  }
+
+  public override func flushTiming() {
+    guard let schedule, measuredFrames > 0 else { return }
+    let ms = stageTotals.map { Double($0) / Double(measuredFrames) / 1e6 }
+    let overlap = Double(overlapTotal) / Double(measuredFrames) / 1e6
+    ServerLog(category: "parallel").info(
+      "session DAG \(parallelExecution ? "parallel" : "serial"): \(measuredFrames) runs, provider stage means \(ms) ms, mean provider-call overlap \(overlap) ms"
+    )
+    guard let path = ProcessInfo.processInfo.environment["JETLINK_PARALLEL_TRACE"], !path.isEmpty else { return }
+    let payload: [String: Any] = [
+      "device": device, "parallel": parallelExecution, "layers": schedule.layers, "providers": providers,
+      "runs_since_load": measuredFrames, "stage_mean_ms": ms, "mean_provider_call_overlap_ms": overlap,
+      "scope": "Synchronous provider API spans; not accelerator occupancy percentages. Includes warmup and correctness runs since load.",
+      "trace": trace.enumerated().map { frame, stamps in
+        [
+          "frame": frame,
+          "stages": stamps.enumerated().map { index, stamp in
+            ["index": index, "start_ns": stamp.start, "end_ns": stamp.end] as [String: Any]
+          },
+        ] as [String: Any]
+      },
+    ]
+    do {
+      let target = URL(fileURLWithPath: path)
+      try FileManager.default.createDirectory(at: target.deletingLastPathComponent(), withIntermediateDirectories: true)
+      try JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted, .sortedKeys]).write(to: target, options: .atomic)
+    } catch { ServerLog(category: "parallel").warning("could not save stage trace: \(error)") }
   }
 
   public override func close() {
     guard !isClosed else { return }
+    flushTiming()
     keepAlive?.close()
     keepWarm?.close()
     hint?.close()
diff --git a/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift b/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift
new file mode 100644
index 00000000..980c54f1
--- /dev/null
+++ b/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift
@@ -0,0 +1,81 @@
+import Foundation
+
+/// A dataflow schedule over session I/O. Every layer is a completion barrier;
+/// sessions in one layer read completed tensors and have disjoint outputs.
+struct SessionDAG: Sendable {
+  let layers: [[Int]]
+
+  init(inputs: [[String]], outputs: [[String]]) throws {
+    guard inputs.count == outputs.count, !inputs.isEmpty else { throw OrtError("empty or inconsistent session DAG") }
+    var producers: [String: Int] = [:]
+    for (index, names) in outputs.enumerated() {
+      for name in names {
+        guard producers.updateValue(index, forKey: name) == nil else { throw OrtError("multiple sessions write \(name)") }
+      }
+    }
+    let dependencies = inputs.enumerated().map { index, names in
+      Set(names.compactMap { producers[$0] }.filter { $0 != index })
+    }
+    var waiting = Set(inputs.indices), completed = Set<Int>(), result: [[Int]] = []
+    while !waiting.isEmpty {
+      let ready = waiting.filter { dependencies[$0].isSubset(of: completed) }.sorted()
+      guard !ready.isEmpty else { throw OrtError("session dependency cycle") }
+      result.append(ready)
+      completed.formUnion(ready)
+      waiting.subtract(ready)
+    }
+    layers = result
+  }
+
+  func run(parallel: Bool, stage: @Sendable (Int) throws -> Void) throws {
+    for layer in layers {
+      if parallel && layer.count > 1 {
+        let failure = FirstFailure()
+        // concurrentPerform returns only after every branch has completed,
+        // including when one failed. No tensor can be freed or reused early.
+        DispatchQueue.concurrentPerform(iterations: layer.count) { offset in
+          do { try stage(layer[offset]) } catch { failure.store(error) }
+        }
+        if let error = failure.error { throw error }
+      } else {
+        for index in layer { try stage(index) }
+      }
+    }
+  }
+}
+
+private final class FirstFailure: @unchecked Sendable {
+  private let lock = NSLock()
+  private var value: (any Error)?
+  func store(_ error: any Error) {
+    lock.lock()
+    defer { lock.unlock() }
+    if value == nil { value = error }
+  }
+  var error: (any Error)? {
+    lock.lock()
+    defer { lock.unlock() }
+    return value
+  }
+}
+
+struct StageStamp: Sendable {
+  let start: UInt64
+  let end: UInt64
+}
+
+final class StageTimings: @unchecked Sendable {
+  private let lock = NSLock()
+  private var values: [StageStamp?]
+  init(count: Int) { values = Array(repeating: nil, count: count) }
+  func record(_ index: Int, start: UInt64, end: UInt64) {
+    lock.lock()
+    values[index] = StageStamp(start: start, end: end)
+    lock.unlock()
+  }
+  func snapshot() -> [StageStamp] {
+    lock.lock()
+    defer { lock.unlock() }
+    return values.compactMap { $0 }
+  }
+}

From 61bbb59a5fb6f2a0698cd1920fe9b55f3d880c15 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:16:30 +0200
Subject: [PATCH 08/35] prefill: JetlinkKit/Sources/JetlinkServer

---
 .../JetlinkServer/CausalPrefillBundle.swift   | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift

diff --git a/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift b/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift
new file mode 100644
index 00000000..15030f7f
--- /dev/null
+++ b/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift
@@ -0,0 +1,68 @@
+import Foundation
+import JetlinkRegistry
+
+/// An offline-compiled, hash-bound research graph bundle for this exact model.
+/// The same model's weights and recurrent contract are preserved. This is not a
+/// generic compiler: another model must receive its own validated bundle.
+package enum CausalPrefillBundle {
+  package static let identity = "causal-prefill-v1-5a159599"
+  private static let manifestSHA = "5a159599f57ce154026baf967825cc4890e2e93ebca00adda1819b1c5354b7a3"
+  private static let sourceSHA = "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4"
+
+  private struct Manifest: Decodable {
+    let format: Int
+    let strategy: String
+    let sourceModelSHA256: String
+    let parts: [Part]
+    private enum CodingKeys: String, CodingKey {
+      case format, strategy, parts
+      case sourceModelSHA256 = "source_model_sha256"
+    }
+  }
+  private struct Part: Decodable {
+    let name: String
+    let file: String
+    let unit: String
+    let weightBytes: Int64
+    let sha256: String
+    private enum CodingKeys: String, CodingKey {
+      case name, file, unit, sha256
+      case weightBytes = "weight_bytes"
+    }
+  }
+
+  package static func prepare(model: URL, into directory: URL) throws -> PreparedModel {
+    guard let path = ProcessInfo.processInfo.environment["JETLINK_PREFILL_BUNDLE"], !path.isEmpty else {
+      throw HostError.invalid("the validated causal-prefill model bundle is missing")
+    }
+    let bundle = URL(fileURLWithPath: path, isDirectory: true)
+    let manifestURL = bundle.appendingPathComponent("manifest.json")
+    guard try Registry.hashFile(manifestURL).0 == manifestSHA else {
+      throw HostError.invalid("causal-prefill manifest does not match this engine")
+    }
+    let manifest = try JSONDecoder().decode(Manifest.self, from: Data(contentsOf: manifestURL))
+    guard manifest.format == 1, manifest.strategy == "causal-prefill-v1",
+      manifest.sourceModelSHA256 == sourceSHA,
+      manifest.parts.map(\.name) == ["vision", "history", "decode", "join"],
+      manifest.parts.map(\.unit) == ["htp", "gpu", "htp", "cpu"],
+      try Registry.hashFile(model).0 == sourceSHA
+    else {
+      throw HostError.invalid("causal-prefill supports only the validated Cinque Terre V3 model")
+    }
+    var parts: [PreparedModel.Part] = []
+    for part in manifest.parts {
+      guard part.file == "\(part.name).onnx", part.weightBytes >= 0,
+        CacheLayout.isSHA256(part.sha256)
+      else {
+        throw HostError.invalid("invalid causal-prefill part identity")
+      }
+      let source = bundle.appendingPathComponent(part.file)
+      guard try Registry.hashFile(source).0 == part.sha256 else {
+        throw HostError.invalid("causal-prefill part \(part.name) failed its hash check")
+      }
+      try FileManager.default.copyItem(at: source, to: directory.appendingPathComponent(part.file))
+      parts.append(.init(name: part.name, file: part.file, weightBytes: part.weightBytes))
+    }
+    return PreparedModel(parts: parts, summary: "hash-verified causal past/current split; original weights and same-frame feedback")
+  }
+}

From 085705d517563a7a1766ae3a27bbb65c5cdec43e Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:17:04 +0200
Subject: [PATCH 09/35] prefill: JetlinkKit/Sources/jetlink-prefill-base

---
 JetlinkKit/Sources/jetlink-prefill-base/main.swift | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 JetlinkKit/Sources/jetlink-prefill-base/main.swift

diff --git a/JetlinkKit/Sources/jetlink-prefill-base/main.swift b/JetlinkKit/Sources/jetlink-prefill-base/main.swift
new file mode 100644
index 00000000..4905544f
--- /dev/null
+++ b/JetlinkKit/Sources/jetlink-prefill-base/main.swift
@@ -0,0 +1,14 @@
+import Foundation
+import JetlinkONNX
+
+// Called by scripts/android/compile_causal_prefill.py after its source hash check.
+guard CommandLine.arguments.count == 3 else {
+  fatalError("usage: jetlink-prefill-base SOURCE.onnx OUTPUT_DIRECTORY")
+}
+let source = URL(fileURLWithPath: CommandLine.arguments[1])
+let directory = URL(fileURLWithPath: CommandLine.arguments[2], isDirectory: true)
+// Fixed legacy metadata is part of the byte-verified experimental bundle.
+let report = try CoreMLPreparation.prepare(
+  source: source, into: directory, layout: .qnnPrefillBase,
+  cacheKey: { _ in "xiaomiNativeStable1model" })
+print("prepared \(report.parts.count) base graph, \(report.norms) fp16 normalizations")

From 85bf811e4485bf7415a90d52bd95e086862d4c0c Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:17:59 +0200
Subject: [PATCH 10/35] prefill: JetlinkKit/Tests/JetlinkServerTests

---
 .../CausalPrefillBundleTests.swift            | 32 +++++++
 .../CausalSessionEngineTests.swift            | 45 ++++++++++
 .../JetlinkServerTests/OrtBackendTests.swift  | 17 +++-
 .../OrtSharedMemoryTests.swift                | 15 ++++
 .../JetlinkServerTests/SessionDAGTests.swift  | 88 +++++++++++++++++++
 5 files changed, 196 insertions(+), 1 deletion(-)
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/SessionDAGTests.swift

diff --git a/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift b/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
new file mode 100644
index 00000000..a9d4725a
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
@@ -0,0 +1,32 @@
+import Foundation
+import JetlinkTestSupport
+import Testing
+
+@testable import JetlinkServer
+
+@Suite("Hash-bound causal bundle", .serialized)
+struct CausalPrefillBundleTests {
+  @Test("The real manifest decodes, but an unvalidated source cannot be substituted")
+  func sourceIdentity() throws {
+    let temporary = try TemporaryDirectory()
+    let bundle = temporary.url.appending(path: "bundle")
+    let staged = temporary.url.appending(path: "staged")
+    try FileManager.default.createDirectory(at: bundle, withIntermediateDirectories: true)
+    try FileManager.default.createDirectory(at: staged, withIntermediateDirectories: true)
+    try FileManager.default.copyItem(at: Fixture.url("causal_prefill_manifest.json"), to: bundle.appending(path: "manifest.json"))
+    let previous = ProcessInfo.processInfo.environment["JETLINK_PREFILL_BUNDLE"]
+    setenv("JETLINK_PREFILL_BUNDLE", bundle.path, 1)
+    defer {
+      if let previous { setenv("JETLINK_PREFILL_BUNDLE", previous, 1) } else { unsetenv("JETLINK_PREFILL_BUNDLE") }
+    }
+    #expect(throws: HostError.self) {
+      _ = try CausalPrefillBundle.prepare(model: Fixture.url("tiny_stateful.onnx"), into: staged)
+    }
+    #expect(try FileManager.default.contentsOfDirectory(atPath: staged.path).isEmpty)
+    // A valid model cannot make an altered manifest acceptable either.
+    try Data("{}".utf8).write(to: bundle.appending(path: "manifest.json"))
+    #expect(throws: HostError.self) {
+      _ = try CausalPrefillBundle.prepare(model: Fixture.url("tiny_stateful.onnx"), into: staged)
+    }
+  }
+}
diff --git a/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift b/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
new file mode 100644
index 00000000..bb909b04
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
@@ -0,0 +1,45 @@
+import Foundation
+import Testing
+
+@testable import JetlinkORT
+@testable import JetlinkServer
+
+@Suite("Same-frame recurrent session DAG", .serialized)
+struct CausalSessionEngineTests {
+  @Test("Real ORT bindings follow dependencies and loop the same state in either schedule", arguments: [false, true])
+  func statefulBindings(parallel: Bool) throws {
+    // Deliberately not topological: graph I/O, rather than array position,
+    // identifies host tensors and orders the completion barriers.
+    let plans = ["join", "decode", "history", "vision"].map {
+      SessionPlan(model: Fixture.url("parallel_\($0).onnx"), provider: nil, label: "CPU")
+    }
+    let engine = try OrtEngine(
+      plans: plans, device: "test", keepAlive: false, keepCPUWarm: false,
+      dataflow: true, parallel: parallel)
+    defer { engine.close() }
+    #expect(Set(engine.inputs.keys) == ["x", "state_h"])
+    #expect(Set(engine.outputs.keys) == ["outputs", "next_state_h"])
+    try engine.loopState([("state_h", "next_state_h")])
+    let x = try #require(engine.hostInput("x"))
+    let output = try #require(engine.output("outputs"))
+    x.storeBytes(of: Float(2), as: Float.self)
+    for frame in 0..<20 {
+      try engine.run()
+      #expect(output.load(as: Float.self) == Float(5 + frame))
+    }
+    engine.resetState()
+    try engine.run()
+    #expect(output.load(as: Float.self) == 5)
+  }
+
+  @Test("Unsupported hardware is rejected before model preparation or loading")
+  func unsupportedHardware() throws {
+    let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer(), chip: "SM8650")
+    #expect(throws: HostError.self) {
+      try backend.build(model: Fixture.url("tiny_stateful.onnx"), artifact: URL(fileURLWithPath: "/unused"), report: { _, _, _ in }, metaExtra: [:])
+    }
+    #expect(throws: HostError.self) {
+      _ = try backend.load(artifact: URL(fileURLWithPath: "/unused"), report: { _, _, _ in })
+    }
+  }
+}
diff --git a/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift b/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
index c5faa603..a359b6a0 100644
--- a/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
+++ b/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
@@ -24,6 +24,7 @@ struct OrtBackendTests {
       (.aneWhole, ["model"], [.coreML("ALL")], "aneWhole"),
       (.htp, ["vision", "policy"], [.htp, .qnnGPU], "split"),
       (.htpWhole, ["model"], [.htp], "aneWhole"),
+      (.htpParallel, ["vision", "history", "decode", "join"], [.htp, .qnnGPU, .htp, .cpu], "qnnPrefillBase"),
       (.gpu, ["model"], [.qnnGPU], "whole"),
       (.cpu, ["model"], [.cpu], cpuLayout),
     ]
@@ -37,12 +38,26 @@ struct OrtBackendTests {
     #if canImport(Metal)
       #expect(OrtProfile.available == [.ane, .aneWhole, .coreml, .cpu])
     #elseif os(Android)
-      #expect(OrtProfile.available == [.htp, .htpWhole, .gpu, .cpu])
+      #expect(OrtProfile.available == [.htp, .htpWhole, .htpParallel, .gpu, .cpu])
     #else
       #expect(OrtProfile.available == [.cpu])
     #endif
   }
 
+  @Test("Only the new profile requests the validated HTP shared-memory stack")
+  func parallelOptions() {
+    let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer(), chip: "SM8750")
+    let options = backend.providerOptions(.htp)
+    #expect(options["backend_path"]?.hasSuffix("libJetlinkQnnHtp.so") == true)
+    #expect(options["soc_model"] == "69" && options["htp_arch"] == "79")
+    #expect(options["enable_htp_shared_memory_allocator"] == "1")
+    #expect(backend.deviceTag().contains(CausalPrefillBundle.identity))
+    #expect(OrtProfile.htpParallel.prepareVersion == 10)
+    let legacy = OrtBackend(profile: .htp, preparer: ONNXPreparer(), chip: "SM8750")
+    #expect(legacy.providerOptions(.htp)["enable_htp_shared_memory_allocator"] == nil)
+    #expect(legacy.deviceTag() == "htp-SM8750")
+  }
+
   @Test("Each unit's session plan and provider options")
   func plans() {
     let backend = OrtBackend(profile: .htp, preparer: ONNXPreparer())
diff --git a/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift b/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
new file mode 100644
index 00000000..e0182cb0
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
@@ -0,0 +1,15 @@
+import Foundation
+import Testing
+
+@testable import JetlinkORT
+
+@Suite("QNN shared memory", .serialized)
+struct OrtSharedMemoryTests {
+  @Test("A CPU session cannot silently substitute heap memory for QNN RPC memory")
+  func cpuDoesNotPretendToShare() throws {
+    let session = try OrtSession(model: Golden("tiny_stateful").model, provider: nil)
+    #expect(throws: OrtError.self) {
+      _ = try OrtSharedAllocator(session: session)
+    }
+  }
+}
diff --git a/JetlinkKit/Tests/JetlinkServerTests/SessionDAGTests.swift b/JetlinkKit/Tests/JetlinkServerTests/SessionDAGTests.swift
new file mode 100644
index 00000000..b95081eb
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/SessionDAGTests.swift
@@ -0,0 +1,88 @@
+import Foundation
+import Testing
+
+@testable import JetlinkORT
+
+@Suite("Fork/join session scheduling", .serialized)
+struct SessionDAGTests {
+  private func fork() throws -> SessionDAG {
+    try SessionDAG(
+      inputs: [["image"], ["vision"], ["vision"], ["off", "on"]],
+      outputs: [["vision"], ["off"], ["on"], ["output"]])
+  }
+
+  @Test("Independent policies overlap, and assembly sees both complete")
+  func forkJoin() throws {
+    let dag = try fork()
+    #expect(dag.layers == [[0], [1, 2], [3]])
+    let progress = Progress()
+    let offEntered = DispatchSemaphore(value: 0), onEntered = DispatchSemaphore(value: 0)
+    try dag.run(parallel: true) { stage in
+      switch stage {
+      case 0: progress.finish(0)
+      case 1:
+        #expect(progress.contains(0))
+        offEntered.signal()
+        #expect(onEntered.wait(timeout: .now() + 2) == .success)
+        progress.finish(1)
+      case 2:
+        #expect(progress.contains(0))
+        onEntered.signal()
+        #expect(offEntered.wait(timeout: .now() + 2) == .success)
+        progress.finish(2)
+      default:
+        #expect(progress.contains(1) && progress.contains(2))
+        progress.finish(3)
+      }
+    }
+    #expect(progress.contains(3))
+  }
+
+  @Test("A failing branch is joined before the error escapes; assembly is skipped")
+  func failureJoins() throws {
+    let dag = try fork()
+    let progress = Progress()
+    let entered = DispatchSemaphore(value: 0)
+    #expect(throws: Failure.self) {
+      try dag.run(parallel: true) { stage in
+        if stage == 1 {
+          entered.signal()
+          throw Failure.expected
+        }
+        if stage == 2 {
+          #expect(entered.wait(timeout: .now() + 2) == .success)
+          Thread.sleep(forTimeInterval: 0.02)
+          progress.finish(2)
+        }
+        if stage == 3 { progress.finish(3) }
+      }
+    }
+    #expect(progress.contains(2))
+    #expect(!progress.contains(3))
+  }
+
+  @Test("The same DAG can run serially for a controlled timing comparison")
+  func serialControl() throws {
+    let dag = try fork()
+    let progress = Progress()
+    try dag.run(parallel: false) { stage in
+      if stage > 0 { #expect(progress.contains(stage - 1)) }
+      progress.finish(stage)
+    }
+    #expect(progress.contains(3))
+  }
+
+  @Test("Cycles and competing writers are rejected before sessions run")
+  func rejectsInvalid() {
+    #expect(throws: (any Error).self) { try SessionDAG(inputs: [["b"], ["a"]], outputs: [["a"], ["b"]]) }
+    #expect(throws: (any Error).self) { try SessionDAG(inputs: [["x"], ["y"]], outputs: [["a"], ["a"]]) }
+  }
+}
+
+private enum Failure: Error { case expected }
+private final class Progress: @unchecked Sendable {
+  private let lock = NSLock()
+  private var completed = Set<Int>()
+  func finish(_ stage: Int) { lock.lock(); completed.insert(stage); lock.unlock() }
+  func contains(_ stage: Int) -> Bool { lock.lock(); defer { lock.unlock() }; return completed.contains(stage) }
+}

From 823edd20028a47d5d0993a43e268b7fe8fcb50cb Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:18:29 +0200
Subject: [PATCH 11/35] prefill: JetlinkKit/Tests/JetlinkServerTests/Fixtures

---
 .../Fixtures/causal_prefill_manifest.json     | 136 ++++++++++++++++++
 .../Fixtures/parallel_decode.onnx             | Bin 0 -> 94 bytes
 .../Fixtures/parallel_history.onnx            | Bin 0 -> 109 bytes
 .../Fixtures/parallel_join.onnx               | Bin 0 -> 164 bytes
 .../Fixtures/parallel_vision.onnx             | Bin 0 -> 96 bytes
 5 files changed, 136 insertions(+)
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/Fixtures/causal_prefill_manifest.json
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_decode.onnx
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_history.onnx
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_join.onnx
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_vision.onnx

diff --git a/JetlinkKit/Tests/JetlinkServerTests/Fixtures/causal_prefill_manifest.json b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/causal_prefill_manifest.json
new file mode 100644
index 00000000..b77f21e3
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/causal_prefill_manifest.json
@@ -0,0 +1,136 @@
+{
+  "format": 1,
+  "strategy": "causal-prefill-v1",
+  "source_model_sha256": "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4",
+  "prepared_model_sha256": "4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166",
+  "parts": [
+    {
+      "name": "vision",
+      "file": "vision.onnx",
+      "unit": "htp",
+      "nodes": 500,
+      "weight_bytes": 705804828,
+      "inputs": [
+        "new_img",
+        "state_img_q"
+      ],
+      "outputs": [
+        "view_39",
+        "linear_76",
+        "linear_77",
+        "linear_78",
+        "linear_79",
+        "linear_80",
+        "mul_36",
+        "linear_82",
+        "linear_81",
+        "view_60",
+        "next_state_img_q"
+      ],
+      "sha256": "49a4c1c1778884f87f26360d4256e6238f059a8f840c136c614ebabd548d59bc"
+    },
+    {
+      "name": "history",
+      "file": "history.onnx",
+      "unit": "gpu",
+      "nodes": 327,
+      "weight_bytes": 40836830,
+      "inputs": [
+        "desire",
+        "traffic_convention",
+        "action_t",
+        "state_desire_q",
+        "state_feat_q"
+      ],
+      "outputs": [
+        "prefill_0_key",
+        "prefill_0_value",
+        "prefill_1_key",
+        "prefill_1_value",
+        "prefill_2_key",
+        "prefill_2_value",
+        "prefill_3_key",
+        "prefill_3_value",
+        "prefill_4_key",
+        "prefill_4_value",
+        "prefill_5_key",
+        "prefill_5_value",
+        "prefill_6_key",
+        "prefill_6_value",
+        "prefill_7_key",
+        "prefill_7_value"
+      ],
+      "sha256": "1370a34bbdb94027f1a99e833f09c639a904f7b716ede3de51cfe04aef73f359"
+    },
+    {
+      "name": "decode",
+      "file": "decode.onnx",
+      "unit": "htp",
+      "nodes": 422,
+      "weight_bytes": 57434348,
+      "inputs": [
+        "view_39",
+        "desire",
+        "traffic_convention",
+        "action_t",
+        "state_desire_q",
+        "prefill_0_key",
+        "prefill_0_value",
+        "prefill_1_key",
+        "prefill_1_value",
+        "prefill_2_key",
+        "prefill_2_value",
+        "prefill_3_key",
+        "prefill_3_value",
+        "prefill_4_key",
+        "prefill_4_value",
+        "prefill_5_key",
+        "prefill_5_value",
+        "prefill_6_key",
+        "prefill_6_value",
+        "prefill_7_key",
+        "prefill_7_value"
+      ],
+      "outputs": [
+        "mul_41",
+        "mul_42",
+        "linear_120",
+        "linear_126",
+        "mul_48"
+      ],
+      "sha256": "ce475ff23e7740281ae1a894c8eb332c0c2486e5701e38c0f55d7b21e0e56e52"
+    },
+    {
+      "name": "join",
+      "file": "join.onnx",
+      "unit": "cpu",
+      "nodes": 9,
+      "weight_bytes": 68,
+      "inputs": [
+        "linear_76",
+        "linear_77",
+        "linear_78",
+        "linear_79",
+        "linear_80",
+        "mul_36",
+        "linear_82",
+        "linear_81",
+        "view_60",
+        "mul_41",
+        "mul_42",
+        "linear_120",
+        "linear_126",
+        "mul_48",
+        "state_feat_q",
+        "desire",
+        "state_desire_q"
+      ],
+      "outputs": [
+        "outputs",
+        "next_state_feat_q",
+        "next_state_desire_q"
+      ],
+      "sha256": "a4e72d70d8580283d1ba21af3b458fc4eca3dcf4e0ab3f01eda41a761a78873f"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_decode.onnx b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_decode.onnx
new file mode 100644
index 0000000000000000000000000000000000000000..e466c503a9d21cf712abc193d546c83369453921
GIT binary patch
literal 94
zcmd<!vI^ni<6=zYVoVZZtW;ulOi2;qFGws(%*jd3iBCyQ&QD2=;s+`a;^N}qU=(8E
YV&Y%~2_zv4Bmo5~kp-MsxEKV404kIXwEzGB

literal 0
HcmV?d00001

diff --git a/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_history.onnx b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_history.onnx
new file mode 100644
index 0000000000000000000000000000000000000000..517f00819e39d20ee0187380f42a7d1ac2a6f8a5
GIT binary patch
literal 109
zcmd<!vP$L><6<u^Ni0c?&){Ot&r20zOj2TYOi2+EC`c?y%*jd3iO<L^F3B&d)Z*u0
t6kt?hVPI&mcLFJm5`}9O;^N}qU=(8EV&Y&-;^$&aLKbjh;bIUF0sx~k71jU%

literal 0
HcmV?d00001

diff --git a/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_join.onnx b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_join.onnx
new file mode 100644
index 0000000000000000000000000000000000000000..b331ca09192436930dff50c646e11fc8ae78a2d2
GIT binary patch
literal 164
zcmd<!vYN@rCC0^ADa4*%T2fG2Qmn+`nUb1Ul37y8CC$Z{B*c@KT2T^TT#{Il8lQoX
z6yhyNEK1DDNzIAR%FoP;;s=?*#l^wFD8$0W#K8y>NJ17!66Jzffg&u$g<=D;oD&Nd
HgMbhKJQXA2

literal 0
HcmV?d00001

diff --git a/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_vision.onnx b/JetlinkKit/Tests/JetlinkServerTests/Fixtures/parallel_vision.onnx
new file mode 100644
index 0000000000000000000000000000000000000000..653d04c616acc7a423b6fc4651a9d75bd41079e3
GIT binary patch
literal 96
zcmd<!vI^r8;9{)cVlFAq7h+6QV)iY~5#ldMEK1DDNzI8b%Ph{!&(q@PU=(0fVqsul
laBu>tjN%9C5#r+F;9wMD;bP)oOacldA`3XNa4`r70RY495Gnuw

literal 0
HcmV?d00001


From 5dd2fe0521da924cce0dd96c9bf59efe0c69732e Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:19:18 +0200
Subject: [PATCH 12/35] prefill: android/app

---
 android/app/build.gradle.kts | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts
index 058b1c99..5193714c 100644
--- a/android/app/build.gradle.kts
+++ b/android/app/build.gradle.kts
@@ -22,6 +22,26 @@ val jetlinkVersionCode: Int =
     jetlinkVersion.split(".").map { it.takeWhile(Char::isDigit).toIntOrNull() ?: 0 }
         .let { (it.getOrElse(0) { 0 } * 10000) + (it.getOrElse(1) { 0 } * 100) + it.getOrElse(2) { 0 } }
 
+// Explicit build opt-in: standard releases still package the Maven QNN runtime.
+val causalPrefill = providers.gradleProperty("jetlink.causalPrefill").orNull == "true"
+val qairtJniDir = providers.gradleProperty("jetlink.qairtJniDir").orNull
+if (causalPrefill) {
+    check(qairtJniDir != null) { "causal-prefill needs the matched QAIRT 2.47 jniLibs; see docs/android-causal-prefill.md" }
+    @Suppress("UNCHECKED_CAST")
+    val matched = groovy.json.JsonSlurper().parse(rootDir.resolve("qnn/qairt-2.47-sha256.json")) as Map<String, String>
+    for ((name, expected) in matched) {
+        val library = File(qairtJniDir, "arm64-v8a/$name")
+        check(library.isFile) { "missing QAIRT 2.47 library: $name" }
+        val actual = MessageDigest.getInstance("SHA-256").digest(library.readBytes()).joinToString("") { "%02x".format(it) }
+        check(actual == expected) { "$name differs from the validated QAIRT 2.47 stack" }
+    }
+    for (name in listOf("libJetlinkQnnHtp.so", "libQnnHtp.so", "libQnnGpu.so", "libQnnHtpV79Stub.so", "libQnnHtpV79Skel.so")) {
+        check(File(qairtJniDir, "arm64-v8a/$name").isFile) { "missing matched library: $name" }
+    }
+} else {
+    check(qairtJniDir == null) { "jetlink.qairtJniDir is only supported with jetlink.causalPrefill=true" }
+}
+
 android {
     namespace = "io.zoompilot.jetlink"
     compileSdk = 37
@@ -36,6 +56,7 @@ android {
         targetSdk = 36
         versionCode = jetlinkVersionCode
         versionName = jetlinkVersion
+        buildConfigField("boolean", "EXPERIMENTAL_CAUSAL_PREFILL", causalPrefill.toString())
         // The QNN runtime is arm64 only, and so is every Snapdragon with an NPU
         // worth driving on. The emulator on an Apple silicon Mac is arm64 too.
         ndk { abiFilters += "arm64-v8a" }
@@ -84,6 +105,8 @@ android {
         }
     }
 
+    if (causalPrefill) sourceSets.getByName("main").jniLibs.srcDir(qairtJniDir!!)
+
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
@@ -132,7 +155,9 @@ dependencies {
     implementation(libs.kotlinx.coroutines.android)
     implementation(libs.kotlinx.serialization.json)
     // libonnxruntime.so with the QNN provider, and the QNN runtime's libraries
-    implementation(libs.onnxruntime.qnn)
+    implementation(libs.onnxruntime.qnn) {
+        if (causalPrefill) exclude(group = "com.qualcomm.qti", module = "qnn-runtime")
+    }
     debugImplementation(libs.compose.ui.tooling)
 
     onnxruntimeAar(variantOf(libs.onnxruntime.qnn) { artifactType("aar") })

From 8fd3712fb146fb52f4867adf85f4b635df6100cb Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:21:42 +0200
Subject: [PATCH 13/35] prefill:
 android/app/src/main/java/io/zoompilot/jetlink/server

---
 .../java/io/zoompilot/jetlink/server/ServerController.kt   | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt b/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
index c14ae1cf..86bfcfc7 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
@@ -5,6 +5,7 @@ import android.net.Uri
 import android.os.Build
 import android.util.Log
 import io.zoompilot.jetlink.settings.Chip
+import io.zoompilot.jetlink.settings.Processor
 import io.zoompilot.jetlink.settings.SettingsValues
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -99,6 +100,12 @@ class ServerController(private val context: Context, private val scope: Coroutin
         // a model compiled for the NPU is good for this system build alone
         put("firmware", Build.FINGERPRINT)
         put("native_library_dir", context.applicationInfo.nativeLibraryDir)
+        if (processor == Processor.NpuGpuParallel) {
+            context.getExternalFilesDir(null)?.let { directory ->
+                put("parallel_bundle", File(directory, "causal-prefill-v1").absolutePath)
+                if (settings.developer) put("parallel_trace_path", File(directory, "parallel-stages.json").absolutePath)
+            }
+        }
     }
 
     /** Follows the snapshot and the log for as long as the app runs. */

From 27203726a17aad18e5b2ff3d274409ab2cb850fc Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:22:07 +0200
Subject: [PATCH 14/35] prefill:
 android/app/src/main/java/io/zoompilot/jetlink/settings

---
 .../src/main/java/io/zoompilot/jetlink/settings/Chip.kt    | 4 +++-
 .../main/java/io/zoompilot/jetlink/settings/Settings.kt    | 7 +++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt b/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
index 1addc86c..28b35e41 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
@@ -1,6 +1,7 @@
 package io.zoompilot.jetlink.settings
 
 import android.os.Build
+import io.zoompilot.jetlink.BuildConfig
 
 /**
  * The phone's SoC, and whether its NPU can run the model. QNN runs the
@@ -28,7 +29,8 @@ object Chip {
     fun tensorGeneration(model: String): Int? = tensorModel.find(model.trim())?.groupValues?.get(1)?.toIntOrNull()
 
     /** What this phone's Settings offer. */
-    fun processors(current: Processor): List<Processor> = Processor.choices(isQualcomm, hasTensorNpu, isEmulator, current)
+    fun processors(current: Processor): List<Processor> = Processor.choices(isQualcomm, hasTensorNpu, isEmulator, current,
+        parallel = BuildConfig.EXPERIMENTAL_CAUSAL_PREFILL && model == "SM8750")
 
     /** What Automatic runs on here. */
     val automatic: Processor by lazy { Processor.automatic(hasTensorNpu, isEmulator) }
diff --git a/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt b/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
index c4845926..23fae898 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
@@ -44,6 +44,9 @@ enum class Processor(val backend: Backend, val device: String, val title: String
      */
     NpuGpu(Backend.Ort, "htp", "NPU + GPU"),
 
+    /** Same-frame history/vision overlap; only in the explicitly enabled SM8750 build. */
+    NpuGpuParallel(Backend.Ort, "htp-parallel", "NPU + GPU (experimental)"),
+
     /** The CPU: the emulator and tests. Seconds a frame with a real model. */
     Cpu(Backend.Ort, "cpu", "CPU");
 
@@ -88,9 +91,9 @@ enum class Processor(val backend: Backend, val device: String, val title: String
          * CPU is offered on a Snapdragon only once chosen; the emulator offers
          * everything, for testing.
          */
-        fun choices(qualcomm: Boolean, tensorNpu: Boolean, emulator: Boolean, current: Processor): List<Processor> = when {
+        fun choices(qualcomm: Boolean, tensorNpu: Boolean, emulator: Boolean, current: Processor, parallel: Boolean = false): List<Processor> = when {
             emulator -> entries
-            qualcomm -> entries.filter { it != TensorNpu && (it != Cpu || current == Cpu) }
+            qualcomm -> entries.filter { it != TensorNpu && (it != Cpu || current == Cpu) && (it != NpuGpuParallel || parallel) }
             tensorNpu -> listOf(Auto, TensorNpu, Gpu, Cpu)
             else -> listOf(Auto, Gpu, Cpu)
         }

From 4163e1f2834c92ee9e431f15c85c7d7a9c83d9d4 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:22:30 +0200
Subject: [PATCH 15/35] prefill:
 android/app/src/test/java/io/zoompilot/jetlink/settings

---
 .../io/zoompilot/jetlink/settings/ProcessorTest.kt  | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt b/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
index 78a2fa12..e6fa4cca 100644
--- a/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
+++ b/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
@@ -20,6 +20,15 @@ class ProcessorTest {
         )
     }
 
+    @Test
+    fun parallelNeedsExplicitOptIn() {
+        assertFalse(Processor.NpuGpuParallel in Processor.choices(true, false, false, Processor.Auto))
+        assertTrue(Processor.NpuGpuParallel in Processor.choices(true, false, false, Processor.Auto, parallel = true))
+        assertFalse(Processor.NpuGpuParallel in Processor.choices(false, true, false, Processor.Auto, parallel = true))
+        assertEquals(Processor.NpuGpuParallel, Processor.of("htp-parallel"))
+        assertEquals(Processor.NpuGpu, Processor.of("htp"))
+    }
+
     @Test
     fun aGoogleTensorOffersItsNpu() {
         assertEquals(
@@ -69,9 +78,9 @@ class ProcessorTest {
 
     @Test
     fun onlyOnnxruntimesNpuAndGpuChoicesNeedQnn() {
-        assertEquals(listOf(Processor.Npu, Processor.NpuGpu), Processor.entries.filter { it.usesQnn })
+        assertEquals(listOf(Processor.Npu, Processor.NpuGpu, Processor.NpuGpuParallel), Processor.entries.filter { it.usesQnn })
         assertEquals(
-            listOf(Backend.Ort, Backend.LiteRt, Backend.LiteRt, Backend.Ort, Backend.Ort),
+            listOf(Backend.Ort, Backend.LiteRt, Backend.LiteRt, Backend.Ort, Backend.Ort, Backend.Ort),
             Processor.entries.filter { it != Processor.Auto }.map { it.backend },
         )
     }

From b0479356977b23967f13e4453f6fdffcc1f702d5 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:22:55 +0200
Subject: [PATCH 16/35] prefill: docs

---
 docs/android-causal-prefill.md | 180 +++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 docs/android-causal-prefill.md

diff --git a/docs/android-causal-prefill.md b/docs/android-causal-prefill.md
new file mode 100644
index 00000000..e19c6d14
--- /dev/null
+++ b/docs/android-causal-prefill.md
@@ -0,0 +1,180 @@
+# Android: experimental same-frame Snapdragon causal prefill
+
+This opt-in profile runs Cinque Terre V3 on the SM8750's Hexagon NPU and
+Adreno GPU in parallel. It does not replace Automatic, NPU, or the existing
+sequential NPU + GPU setting. It is limited to one validated model export and
+one matched runtime stack; unsupported inputs fail with an error.
+
+The Xiaomi 15 prototype completed a ten-minute, 20 Hz synthetic benchmark:
+**27.2 ms mean, 29.5 ms P99, 36.2 ms max, 12,001 frames, zero over 50 ms**.
+The original CPU accuracy gates passed on 128 identical synthetic frames before
+and after the sustained run. [Screenshot, accuracy logs and machine-readable
+results](evidence/sm8750-causal-prefill/README.md) distinguish the measured
+prototype from the upstream port. Physical comma USB, car charging and road
+behavior have not been validated by these results.
+
+## Why this can overlap without adding a frame of delay
+
+The model's eight attention masks are causal. Historical queries cannot read
+the current image tokens, so the GPU can compute the 256 historical tokens
+while the NPU computes the current image's vision features. The NPU then runs
+the 32 current queries against **all 288 original keys and values**. Nothing is
+reused from an earlier image to substitute for current-frame work.
+
+```mermaid
+flowchart LR
+  I[Current image and image history] --> V[NPU: vision]
+  H[Feature and desire history] --> P[GPU: historical tokens and K/V]
+  V --> D[NPU: current queries against past and current K/V]
+  P --> D
+  D --> J[CPU: original output and queue assembly]
+  V --> J
+  J --> O[Same-frame output and next recurrent state]
+```
+
+`SessionDAG` derives completion barriers from graph I/O, rejects cycles and
+multiple writers, and joins every worker before returning an error. The engine
+double-buffers recurrent state and binds HTP sessions to host-accessible RPC
+allocations. GPU and CPU sessions use ordinary CPU tensor metadata over those
+pointers. They do not claim to be QNN shared allocators.
+
+The existing fp16 normalization expression is prescaled by 1/4, with epsilon
+divided by 16, to keep intermediates in range without expanding each native
+LayerNormalization into many slower operations. This preserves the real-valued
+formula, not bitwise floating-point results. Original CPU output gates remain
+the acceptance criterion. The HTP graph adapter disables advanced activation
+fusion; it forwards the other backend functions and retains custom graph
+configuration until context destruction.
+
+## Reproduce the exact model bundle
+
+Tested tools: Swift 6.4, Python 3.12, ONNX 1.23.2, NumPy 2.5.4, ORT 1.29.0,
+NDK r30, Android API 31 native target, QAIRT 2.47.0.260601 and HTP v79.
+Use the original catalog export with SHA-256:
+
+```
+404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4
+```
+
+From a Linux checkout with the [Android build prerequisites](../android/README.md):
+
+```bash
+python3 -m venv .venv-prefill
+.venv-prefill/bin/python -m pip install -r scripts/android/requirements-causal-prefill.txt
+swift build --package-path JetlinkKit --product jetlink-prefill-base
+BASE_TOOL="$(swift build --package-path JetlinkKit --show-bin-path)/jetlink-prefill-base"
+.venv-prefill/bin/python scripts/android/compile_causal_prefill.py \
+  --model /path/to/404a18cfd86d2963.onnx \
+  --base-tool "$BASE_TOOL" --out /path/to/causal-prefill-v1
+```
+
+The output directory must be empty. The compiler checks the original model
+hash, the intermediate graph hash, all four final graph hashes, and the exact
+manifest bytes against the phone-tested bundle. The app independently verifies
+the source model, manifest and each part before copying into its private cache.
+This is deliberately a model-specific compiler, not a general ONNX optimizer.
+No weights, output slices, correlation thresholds or feedback contract are changed.
+
+## Build the opt-in Android app
+
+Obtain QAIRT 2.47.0.260601 through Qualcomm's normal SDK distribution. Vendor
+headers, libraries and model weights are not redistributed in this repository.
+Use the complete matching HTP, GPU, prepare, system, IR, saver and v79 stub/skel
+set: mixing an older Maven runtime with newer DSP libraries does not work.
+
+```bash
+export QNN_SDK_ROOT=/path/to/qairt/2.47.0.260601
+export ANDROID_NDK_HOME=/path/to/android-ndk-r30
+bash android/qnn/build.sh /path/to/qairt-jni
+cd android
+./gradlew :app:assembleRelease :app:testDebugUnitTest \
+  -Pjetlink.causalPrefill=true -Pjetlink.qairtJniDir=/path/to/qairt-jni
+```
+
+The helper builds and tests the small graph adapter, then locates the eight
+vendor libraries by their pinned byte hashes. Gradle verifies those same
+hashes, requires the adapter and replaces the Maven QNN runtime only for this
+opt-in build. Ordinary builds require no new SDK or property.
+
+Install with the project's existing signing/install workflow. An APK signed
+with a different key cannot update the official APK in place; preserve app
+data and the previous APK before changing a locally signed installation.
+
+Stage only the four ONNX files and manifest generated above into the app's
+external files directory. For a USB-debugging development device:
+
+```bash
+BUNDLE=/sdcard/Android/data/io.zoompilot.jetlink.android/files/causal-prefill-v1
+adb shell mkdir -p "$BUNDLE"
+adb push /path/to/causal-prefill-v1/. "$BUNDLE/"
+adb shell chmod 755 "$BUNDLE"
+adb shell chmod 644 "$BUNDLE/vision.onnx" "$BUNDLE/history.onnx" \
+  "$BUNDLE/decode.onnx" "$BUNDLE/join.onnx" "$BUNDLE/manifest.json"
+```
+
+The directory must be traversable by the app; an ADB-created shell-only 770
+directory prevents loading. Select **NPU + GPU (experimental)** on an SM8750.
+The existing NPU + GPU choice remains the original sequential profile. Keep
+the original Cinque Terre V3 model downloaded/imported in Jetlink as usual.
+Enable Keep NPU awake, Keep CPU awake and Keep screen on to reproduce the
+measured configuration. Initial HTP compilation can take several minutes. Missing or different bundles
+produce an error; there is no silent substitution of another model or CPU work.
+
+## Validation and limits
+
+The measured prototype used shared I/O, burst mode, CPU performance hints and
+the screen awake. Airplane mode with Wi-Fi and Bluetooth off stabilized the
+test conditions. It was not counted as an inference optimization.
+
+| Run | Duration | Mean | P99 |
+| --- | --- | --- | --- |
+| Range-safe NPU-only control | 1 minute | 33.8 ms | 34.7 ms |
+| Same four graphs, shared buffers, serial control | 1 minute | 45.2 ms | 47.2 ms |
+| Causal parallel, ordinary heap buffers | 1 minute | 27.6 ms | 30.5 ms |
+| Causal parallel, shared buffers | 1 minute | 26.8 ms | 29.0 ms |
+| Normal USB-capable prototype, causal parallel/shared | 10 minutes | 27.2 ms | 29.5 ms |
+
+These were sequential runs on one phone, without randomized order or fixed
+temperature/clocks. Provider API spans overlap by about 22.1 ms in the sustained
+run; this and the identical-graphs serial control demonstrate useful concurrent
+execution. They do **not** establish an NPU/GPU busy percentage. Available QNN
+profiling events did not provide comparable hardware timestamps, so there is no
+claim of 100% accelerator utilization. See [ORT's QNN provider documentation](https://onnxruntime.ai/docs/execution-providers/QNN-ExecutionProvider.html)
+for shared memory and fallback configuration.
+
+The phone's battery temperature rose from 36.6°C to 45.4°C and battery charge
+fell from 62% to 55% despite PC USB power. Every recorded Android thermal status
+and all 61 benchmark windows remained Normal. That status does not mean the
+phone was cool or that a car adapter can sustain charging. Test the actual
+mount, cable, power adapter and comma connection while parked before any use.
+
+The prototype's two 128-frame checks use the unchanged original CPU model,
+identical inputs and independent recurrent state on both sides. The checked-in
+logs include per-slice/per-column results and the original 0.999-correlation or
+existing quiet-output error fallback. Synthetic correctness is not a driving
+validation or a guarantee for every input, temperature or firmware update.
+
+For another phone accuracy capture, use the existing `scripts/verify_parity.py`
+without changing its comparison thresholds. With the original model already
+cached, the new profile loaded, and Developer mode enabled, a parked development
+device can be checked over an ADB TCP forward:
+
+```bash
+adb forward tcp:15599 tcp:5599
+python scripts/verify_parity.py capture --host 127.0.0.1 --port 15599 \
+  --sha256 404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4 \
+  --nbytes 766354845 --n 128 --dir parity-prefill
+python scripts/verify_parity.py reference --onnx /path/to/404a18cfd86d2963.onnx --dir parity-prefill
+python scripts/verify_parity.py compare --dir parity-prefill
+adb forward --remove tcp:15599
+```
+
+For a developer serial control, set `parallel_serial: true` in the native start
+configuration, keeping the same graphs and shared buffers. Its artifact tag is
+separate. With Developer mode enabled, `parallel-stages.json` records synchronous
+provider-call timing spans in the external files directory. Disable Developer
+mode after collecting a test; the comma does not need the TCP listener.
+
+To stop using the experiment, choose an existing processor setting. Automatic
+and existing profiles retain their original options and caches. Reinstalling a
+previous APK signed with the same key is a separate local rollback option.

From 8e4da9aef34a104b4ebd75cb5b3c546cc76fb570 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:23:18 +0200
Subject: [PATCH 17/35] prefill: docs/evidence/sm8750-causal-prefill

---
 docs/evidence/sm8750-causal-prefill/README.md |   13 +
 .../accuracy-postheat.txt                     | 2195 +++++++++++++++++
 .../accuracy-preheat.txt                      | 2195 +++++++++++++++++
 .../sm8750-causal-prefill/results.json        |  124 +
 .../sm8750-causal-prefill/ten-minute.png      |  Bin 0 -> 238348 bytes
 .../sm8750-causal-prefill/windows.json        |  312 +++
 6 files changed, 4839 insertions(+)
 create mode 100644 docs/evidence/sm8750-causal-prefill/README.md
 create mode 100644 docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
 create mode 100644 docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
 create mode 100644 docs/evidence/sm8750-causal-prefill/results.json
 create mode 100644 docs/evidence/sm8750-causal-prefill/ten-minute.png
 create mode 100644 docs/evidence/sm8750-causal-prefill/windows.json

diff --git a/docs/evidence/sm8750-causal-prefill/README.md b/docs/evidence/sm8750-causal-prefill/README.md
new file mode 100644
index 00000000..c5607fa6
--- /dev/null
+++ b/docs/evidence/sm8750-causal-prefill/README.md
@@ -0,0 +1,13 @@
+# SM8750 causal-prefill evidence
+
+These are unmodified benchmark pixels and sanitized numeric/log results from the
+Xiaomi 15 prototype, not a screenshot of the upstream port. No device serial,
+network address, signing key, model weights or Qualcomm SDK binaries are included.
+
+![Ten-minute benchmark on Xiaomi 15](ten-minute.png)
+
+`results.json` records the conditions, controls and limitations. Both accuracy
+logs compare 128 identical synthetic input frames against the unchanged original
+CPU model, each side maintaining its own recurrent state; thresholds are unchanged.
+`windows.json` contains all 61 reported ten-second windows, including the final
+one-frame window. This is a model/host benchmark, not physical comma USB validation.
diff --git a/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt b/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
new file mode 100644
index 00000000..4f1c806c
--- /dev/null
+++ b/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
@@ -0,0 +1,2195 @@
+
+frame 0: corr 0.999958  max abs 0.5625
+    action                   corr 0.999995  max abs   0.0254  mean abs 0.00935   (by error, pooled)
+    desire_pred              corr 0.999935  max abs   0.0742  mean abs 0.03164
+    desire_state             corr 0.999999  max abs   0.0352  mean abs 0.01514   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1760  mean abs 0.01292
+    lane_lines               corr 0.999849  max abs   0.1744  mean abs 0.02085
+    lane_lines_prob          corr 0.999929  max abs   0.0820  mean abs 0.03079   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.5625  mean abs 0.06143
+    lead_prob                corr 0.999970  max abs   0.0259  mean abs 0.01986   (by error, pooled)
+    meta                     corr 0.999946  max abs   0.0781  mean abs 0.03238
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.3125  mean abs 0.00838
+    pose                     corr 0.999991  max abs   0.0263  mean abs 0.00968   (by error, pooled)
+    road_edges               corr 0.999897  max abs   0.1812  mean abs 0.02426
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00774   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00722   (by error, pooled)
+
+frame 1: corr 0.999965  max abs 0.5625
+    action                   corr 0.999995  max abs   0.0195  mean abs 0.00592   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0586  mean abs 0.02458
+    desire_state             corr 0.999998  max abs   0.0703  mean abs 0.02783   (by error, pooled)
+    hidden_state             corr 0.999959  max abs   0.1367  mean abs 0.01146
+    lane_lines               corr 0.999973  max abs   0.0723  mean abs 0.01279
+    lane_lines_prob          corr 0.999843  max abs   0.1172  mean abs 0.04391   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.05298
+    lead_prob                corr 0.999970  max abs   0.0149  mean abs 0.01196   (by error, pooled)
+    meta                     corr 0.999965  max abs   0.0723  mean abs 0.03016
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.3125  mean abs 0.00710
+    pose                     corr 0.999990  max abs   0.0325  mean abs 0.00972   (by error, pooled)
+    road_edges               corr 0.999977  max abs   0.0586  mean abs 0.01384
+    road_transform           corr 0.999988  max abs   0.0508  mean abs 0.00994   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00493   (by error, pooled)
+
+frame 2: corr 0.999959  max abs 0.6250
+    action                   corr 0.999999  max abs   0.0078  mean abs 0.00211   (by error, pooled)
+    desire_pred              corr 0.999968  max abs   0.0605  mean abs 0.02356
+    desire_state             corr 0.999993  max abs   0.1016  mean abs 0.03271   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1260  mean abs 0.01132
+    lane_lines               corr 0.999958  max abs   0.0918  mean abs 0.01606
+    lane_lines_prob          corr 0.999901  max abs   0.1445  mean abs 0.05713   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.6250  mean abs 0.06016
+    lead_prob                corr 0.999952  max abs   0.0151  mean abs 0.00798   (by error, pooled)
+    meta                     corr 0.999933  max abs   0.0742  mean abs 0.03206
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.2812  mean abs 0.00562
+    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00661   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0664  mean abs 0.01870
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00669   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00395   (by error, pooled)
+
+frame 3: corr 0.999948  max abs 0.9375
+    action                   corr 0.999999  max abs   0.0137  mean abs 0.00553   (by error, pooled)
+    desire_pred              corr 0.999983  max abs   0.0430  mean abs 0.01556
+    desire_state             corr 0.999982  max abs   0.1562  mean abs 0.04858   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1719  mean abs 0.01187
+    lane_lines               corr 0.999931  max abs   0.1543  mean abs 0.01625
+    lane_lines_prob          corr 0.999935  max abs   0.1602  mean abs 0.07416   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.9375  mean abs 0.09328
+    lead_prob                corr 0.999958  max abs   0.0251  mean abs 0.01619   (by error, pooled)
+    meta                     corr 0.999968  max abs   0.0586  mean abs 0.02109
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999990  max abs   0.3750  mean abs 0.00852
+    pose                     corr 0.999984  max abs   0.0356  mean abs 0.01209   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1445  mean abs 0.01664
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00841   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0293  mean abs 0.00949   (by error, pooled)
+
+frame 4: corr 0.999936  max abs 1.1250
+    action                   corr 0.999990  max abs   0.0293  mean abs 0.01129   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0889  mean abs 0.02840
+    desire_state             corr 0.999994  max abs   0.0781  mean abs 0.02625   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01377
+    lane_lines               corr 0.999962  max abs   0.1016  mean abs 0.01430
+    lane_lines_prob          corr 0.999939  max abs   0.0781  mean abs 0.03470   (by error, pooled)
+    lead                     corr 0.999992  max abs   1.1250  mean abs 0.12237
+    lead_prob                corr 0.998717  max abs   0.0957  mean abs 0.06934   (by error, pooled)
+    meta                     corr 0.999845  max abs   0.1270  mean abs 0.04110
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2500  mean abs 0.00861
+    pose                     corr 0.999979  max abs   0.0527  mean abs 0.01070   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.0781  mean abs 0.01325
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01077   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01534   (by error, pooled)
+
+frame 5: corr 0.999922  max abs 1.2500
+    action                   corr 0.999986  max abs   0.0352  mean abs 0.01266   (by error, pooled)
+    desire_pred              corr 0.999942  max abs   0.0859  mean abs 0.02830
+    desire_state             corr 0.999986  max abs   0.0938  mean abs 0.04843   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1680  mean abs 0.01347
+    lane_lines               corr 0.999954  max abs   0.1211  mean abs 0.01651
+    lane_lines_prob          corr 0.999963  max abs   0.1445  mean abs 0.06146   (by error, pooled)
+    lead                     corr 0.999991  max abs   1.2500  mean abs 0.14001
+    lead_prob                corr 0.998733  max abs   0.0557  mean abs 0.04069   (by error, pooled)
+    meta                     corr 0.999961  max abs   0.0762  mean abs 0.02302
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2188  mean abs 0.00735
+    pose                     corr 0.999984  max abs   0.0352  mean abs 0.01015   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.0703  mean abs 0.02004
+    road_transform           corr 0.999994  max abs   0.0430  mean abs 0.01166   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0254  mean abs 0.00882   (by error, pooled)
+
+frame 6: corr 0.999956  max abs 1.9375
+    action                   corr 0.999984  max abs   0.0303  mean abs 0.01663   (by error, pooled)
+    desire_pred              corr 0.999923  max abs   0.0723  mean abs 0.03256
+    desire_state             corr 0.999981  max abs   0.1797  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999937  max abs   0.2617  mean abs 0.01539
+    lane_lines               corr 0.999922  max abs   0.1406  mean abs 0.01865
+    lane_lines_prob          corr 0.999917  max abs   0.1484  mean abs 0.04865   (by error, pooled)
+    lead                     corr 0.999999  max abs   1.9375  mean abs 0.20451
+    lead_prob                corr 1.000000  max abs   0.0293  mean abs 0.02539   (by error, pooled)
+    meta                     corr 0.999912  max abs   0.0898  mean abs 0.03182
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.5625  mean abs 0.01942
+    pose                     corr 0.999977  max abs   0.1484  mean abs 0.02388   (by error, pooled)
+    road_edges               corr 0.999917  max abs   0.1367  mean abs 0.02554
+    road_transform           corr 0.999996  max abs   0.0547  mean abs 0.01525   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0469  mean abs 0.01279   (by error, pooled)
+
+frame 7: corr 0.999989  max abs 0.3750
+    action                   corr 0.999992  max abs   0.0117  mean abs 0.00634   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0645  mean abs 0.02985
+    desire_state             corr 0.999963  max abs   0.2266  mean abs 0.08472   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2041  mean abs 0.01477
+    lane_lines               corr 0.999930  max abs   0.0663  mean abs 0.01972
+    lane_lines_prob          corr 0.999946  max abs   0.1445  mean abs 0.05638   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.3750  mean abs 0.03846
+    lead_prob                corr 0.998477  max abs   0.0254  mean abs 0.01107   (by error, pooled)
+    meta                     corr 0.999903  max abs   0.0898  mean abs 0.03162
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.1875  mean abs 0.00468
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.01124   (by error, pooled)
+    road_edges               corr 0.999918  max abs   0.0898  mean abs 0.02571
+    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00873   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00268   (by error, pooled)
+
+frame 8: corr 0.999981  max abs 0.5625
+    action                   corr 0.999987  max abs   0.0225  mean abs 0.00929   (by error, pooled)
+    desire_pred              corr 0.999943  max abs   0.0762  mean abs 0.02660
+    desire_state             corr 0.999995  max abs   0.0938  mean abs 0.04443   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2560  mean abs 0.01368
+    lane_lines               corr 0.999960  max abs   0.0439  mean abs 0.01421
+    lane_lines_prob          corr 0.999889  max abs   0.1523  mean abs 0.04752   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06036
+    lead_prob                corr 0.999987  max abs   0.0576  mean abs 0.05111   (by error, pooled)
+    meta                     corr 0.999894  max abs   0.0879  mean abs 0.03913
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0625  mean abs 0.00604
+    pose                     corr 0.999994  max abs   0.0273  mean abs 0.00865   (by error, pooled)
+    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02148
+    road_transform           corr 0.999996  max abs   0.0469  mean abs 0.01174   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0625  mean abs 0.01505   (by error, pooled)
+
+frame 9: corr 0.999973  max abs 0.5625
+    action                   corr 0.999999  max abs   0.0195  mean abs 0.00897   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0586  mean abs 0.02765
+    desire_state             corr 0.999996  max abs   0.1094  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1299  mean abs 0.01198
+    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01406
+    lane_lines_prob          corr 0.999991  max abs   0.0703  mean abs 0.03381   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06239
+    lead_prob                corr 0.999959  max abs   0.0474  mean abs 0.03698   (by error, pooled)
+    meta                     corr 0.999940  max abs   0.0859  mean abs 0.03474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.3750  mean abs 0.00992
+    pose                     corr 0.999994  max abs   0.0220  mean abs 0.00801   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0938  mean abs 0.01654
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00441   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0156  mean abs 0.00653   (by error, pooled)
+
+frame 10: corr 0.999978  max abs 0.2500
+    action                   corr 1.000000  max abs   0.0117  mean abs 0.00580   (by error, pooled)
+    desire_pred              corr 0.999956  max abs   0.0601  mean abs 0.03251
+    desire_state             corr 0.999998  max abs   0.0508  mean abs 0.03198   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.0996  mean abs 0.01128
+    lane_lines               corr 0.999972  max abs   0.0586  mean abs 0.01554
+    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03271   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.2500  mean abs 0.02018
+    lead_prob                corr 0.999886  max abs   0.0420  mean abs 0.03019   (by error, pooled)
+    meta                     corr 0.999935  max abs   0.1050  mean abs 0.03611
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00385
+    pose                     corr 0.999996  max abs   0.0172  mean abs 0.00643   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0586  mean abs 0.01438
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00417   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00426   (by error, pooled)
+
+frame 11: corr 0.999976  max abs 0.2500
+    action                   corr 1.000000  max abs   0.0020  mean abs 0.00052   (by error, pooled)
+    desire_pred              corr 0.999966  max abs   0.0625  mean abs 0.02907
+    desire_state             corr 0.999999  max abs   0.0625  mean abs 0.03687   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1348  mean abs 0.01212
+    lane_lines               corr 0.999965  max abs   0.0859  mean abs 0.01512
+    lane_lines_prob          corr 0.999983  max abs   0.0547  mean abs 0.03186   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.2500  mean abs 0.02342
+    lead_prob                corr 0.999887  max abs   0.0355  mean abs 0.02243   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0869  mean abs 0.03073
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00297
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00640   (by error, pooled)
+    road_edges               corr 0.999965  max abs   0.0801  mean abs 0.01600
+    road_transform           corr 0.999994  max abs   0.0273  mean abs 0.00709   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00430   (by error, pooled)
+
+frame 12: corr 0.999975  max abs 0.4375
+    action                   corr 0.999999  max abs   0.0098  mean abs 0.00491   (by error, pooled)
+    desire_pred              corr 0.999981  max abs   0.0625  mean abs 0.02130
+    desire_state             corr 0.999993  max abs   0.1406  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1543  mean abs 0.01343
+    lane_lines               corr 0.999969  max abs   0.1172  mean abs 0.01423
+    lane_lines_prob          corr 0.999945  max abs   0.0820  mean abs 0.03003   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.4375  mean abs 0.04305
+    lead_prob                corr 0.999977  max abs   0.0791  mean abs 0.06405   (by error, pooled)
+    meta                     corr 0.999881  max abs   0.0850  mean abs 0.03032
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00616
+    pose                     corr 0.999994  max abs   0.0239  mean abs 0.00555   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.1094  mean abs 0.01357
+    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00775   (by error, pooled)
+    wide_from_device_euler   corr 0.999986  max abs   0.0410  mean abs 0.00981   (by error, pooled)
+
+frame 13: corr 0.999963  max abs 0.7500
+    action                   corr 0.999979  max abs   0.0293  mean abs 0.01082   (by error, pooled)
+    desire_pred              corr 0.999881  max abs   0.0918  mean abs 0.04098
+    desire_state             corr 0.999992  max abs   0.1328  mean abs 0.06201   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2285  mean abs 0.01348
+    lane_lines               corr 0.999945  max abs   0.1289  mean abs 0.01795
+    lane_lines_prob          corr 0.999691  max abs   0.1641  mean abs 0.06439   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.7500  mean abs 0.06569
+    lead_prob                corr 0.999548  max abs   0.0918  mean abs 0.07259   (by error, pooled)
+    meta                     corr 0.999852  max abs   0.0889  mean abs 0.03951
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999985  max abs   0.3750  mean abs 0.01534
+    pose                     corr 0.999964  max abs   0.0781  mean abs 0.01469   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.1172  mean abs 0.01816
+    road_transform           corr 0.999999  max abs   0.0391  mean abs 0.01190   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.01145   (by error, pooled)
+
+frame 14: corr 0.999945  max abs 0.9375
+    action                   corr 0.999982  max abs   0.0391  mean abs 0.01599   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03196
+    desire_state             corr 0.999988  max abs   0.2031  mean abs 0.09033   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2109  mean abs 0.01363
+    lane_lines               corr 0.999974  max abs   0.0859  mean abs 0.01198
+    lane_lines_prob          corr 0.999923  max abs   0.1289  mean abs 0.04303   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.9375  mean abs 0.08604
+    lead_prob                corr 0.998518  max abs   0.0938  mean abs 0.07617   (by error, pooled)
+    meta                     corr 0.999948  max abs   0.0625  mean abs 0.02685
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999971  max abs   0.5000  mean abs 0.01917
+    pose                     corr 0.999960  max abs   0.0742  mean abs 0.01417   (by error, pooled)
+    road_edges               corr 0.999941  max abs   0.0781  mean abs 0.01981
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00857   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0312  mean abs 0.00654   (by error, pooled)
+
+frame 15: corr 0.999964  max abs 1.2500
+    action                   corr 0.999983  max abs   0.0176  mean abs 0.00940   (by error, pooled)
+    desire_pred              corr 0.999929  max abs   0.0625  mean abs 0.03351
+    desire_state             corr 0.999991  max abs   0.1641  mean abs 0.10449   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2324  mean abs 0.01531
+    lane_lines               corr 0.999947  max abs   0.1406  mean abs 0.01695
+    lane_lines_prob          corr 0.999976  max abs   0.1367  mean abs 0.06481   (by error, pooled)
+    lead                     corr 0.999999  max abs   1.2500  mean abs 0.12303
+    lead_prob                corr 0.999926  max abs   0.0635  mean abs 0.05813   (by error, pooled)
+    meta                     corr 0.999902  max abs   0.0928  mean abs 0.03267
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2188  mean abs 0.01202
+    pose                     corr 0.999990  max abs   0.1172  mean abs 0.01868   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.1094  mean abs 0.01495
+    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.01289   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0391  mean abs 0.01213   (by error, pooled)
+
+frame 16: corr 0.999982  max abs 0.6250
+    action                   corr 0.999956  max abs   0.0127  mean abs 0.00645   (by error, pooled)
+    desire_pred              corr 0.999934  max abs   0.0723  mean abs 0.03220
+    desire_state             corr 0.999984  max abs   0.1367  mean abs 0.06238   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2305  mean abs 0.01469
+    lane_lines               corr 0.999920  max abs   0.0703  mean abs 0.02025
+    lane_lines_prob          corr 0.999967  max abs   0.1289  mean abs 0.04867   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.6250  mean abs 0.04697
+    lead_prob                corr 0.999966  max abs   0.0566  mean abs 0.03809   (by error, pooled)
+    meta                     corr 0.999876  max abs   0.0957  mean abs 0.03783
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.1250  mean abs 0.00539
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01058   (by error, pooled)
+    road_edges               corr 0.999919  max abs   0.0859  mean abs 0.02313
+    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00425   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00884   (by error, pooled)
+
+frame 17: corr 0.999974  max abs 0.3438
+    action                   corr 0.999987  max abs   0.0176  mean abs 0.00995   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0730  mean abs 0.02846
+    desire_state             corr 0.999996  max abs   0.0781  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2465  mean abs 0.01365
+    lane_lines               corr 0.999956  max abs   0.0781  mean abs 0.01486
+    lane_lines_prob          corr 0.999933  max abs   0.0977  mean abs 0.03257   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01697
+    lead_prob                corr 0.999995  max abs   0.0449  mean abs 0.03735   (by error, pooled)
+    meta                     corr 0.999928  max abs   0.0703  mean abs 0.02939
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999986  max abs   0.3438  mean abs 0.01366
+    pose                     corr 0.999992  max abs   0.0273  mean abs 0.01085   (by error, pooled)
+    road_edges               corr 0.999927  max abs   0.0664  mean abs 0.02052
+    road_transform           corr 0.999998  max abs   0.0469  mean abs 0.01369   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0430  mean abs 0.01115   (by error, pooled)
+
+frame 18: corr 0.999965  max abs 0.5000
+    action                   corr 0.999996  max abs   0.0215  mean abs 0.00996   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0859  mean abs 0.02974
+    desire_state             corr 0.999984  max abs   0.1562  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1289  mean abs 0.01180
+    lane_lines               corr 0.999970  max abs   0.0488  mean abs 0.01406
+    lane_lines_prob          corr 0.999973  max abs   0.0742  mean abs 0.02954   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5000  mean abs 0.04836
+    lead_prob                corr 0.998951  max abs   0.0811  mean abs 0.06120   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0781  mean abs 0.03228
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.3125  mean abs 0.01052
+    pose                     corr 0.999993  max abs   0.0273  mean abs 0.00879   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0527  mean abs 0.01554
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00458   (by error, pooled)
+
+frame 19: corr 0.999975  max abs 0.1250
+    action                   corr 0.999999  max abs   0.0078  mean abs 0.00311   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0552  mean abs 0.03011
+    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.04626   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.0938  mean abs 0.01092
+    lane_lines               corr 0.999966  max abs   0.0752  mean abs 0.01557
+    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03101   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1250  mean abs 0.01557
+    lead_prob                corr 0.999727  max abs   0.0410  mean abs 0.03109   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.1123  mean abs 0.03805
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0781  mean abs 0.00426
+    pose                     corr 0.999996  max abs   0.0176  mean abs 0.00608   (by error, pooled)
+    road_edges               corr 0.999955  max abs   0.1152  mean abs 0.01849
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00466   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0195  mean abs 0.00459   (by error, pooled)
+
+frame 20: corr 0.999975  max abs 0.2812
+    action                   corr 0.999998  max abs   0.0098  mean abs 0.00377   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0547  mean abs 0.02860
+    desire_state             corr 0.999990  max abs   0.1484  mean abs 0.06494   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1543  mean abs 0.01206
+    lane_lines               corr 0.999976  max abs   0.0605  mean abs 0.01370
+    lane_lines_prob          corr 0.999979  max abs   0.0742  mean abs 0.03647   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2812  mean abs 0.02069
+    lead_prob                corr 0.999753  max abs   0.0480  mean abs 0.04075   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0811  mean abs 0.03298
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0410  mean abs 0.00367
+    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00504   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0820  mean abs 0.01513
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00507   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0273  mean abs 0.00690   (by error, pooled)
+
+frame 21: corr 0.999971  max abs 0.5625
+    action                   corr 0.999993  max abs   0.0176  mean abs 0.00978   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0518  mean abs 0.02562
+    desire_state             corr 0.999990  max abs   0.0703  mean abs 0.04370   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1807  mean abs 0.01358
+    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01265
+    lane_lines_prob          corr 0.999970  max abs   0.0513  mean abs 0.02728   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5625  mean abs 0.04740
+    lead_prob                corr 0.999391  max abs   0.1055  mean abs 0.08830   (by error, pooled)
+    meta                     corr 0.999906  max abs   0.0745  mean abs 0.02863
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2500  mean abs 0.01053
+    pose                     corr 0.999985  max abs   0.0352  mean abs 0.01017   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.1050  mean abs 0.01557
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00575   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00983   (by error, pooled)
+
+frame 22: corr 0.999969  max abs 0.4268
+    action                   corr 0.999983  max abs   0.0195  mean abs 0.01143   (by error, pooled)
+    desire_pred              corr 0.999962  max abs   0.0459  mean abs 0.02286
+    desire_state             corr 0.999980  max abs   0.1250  mean abs 0.06152   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2227  mean abs 0.01495
+    lane_lines               corr 0.999953  max abs   0.1172  mean abs 0.01816
+    lane_lines_prob          corr 0.999918  max abs   0.0859  mean abs 0.04413   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1875  mean abs 0.02029
+    lead_prob                corr 0.999892  max abs   0.1221  mean abs 0.11019   (by error, pooled)
+    meta                     corr 0.999892  max abs   0.0825  mean abs 0.03034
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.4268  mean abs 0.01207
+    pose                     corr 0.999986  max abs   0.0625  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1484  mean abs 0.02380
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00580   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00493   (by error, pooled)
+
+frame 23: corr 0.999967  max abs 0.3125
+    action                   corr 0.999976  max abs   0.0293  mean abs 0.01263   (by error, pooled)
+    desire_pred              corr 0.999899  max abs   0.1211  mean abs 0.03755
+    desire_state             corr 0.999985  max abs   0.1211  mean abs 0.05103   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1680  mean abs 0.01385
+    lane_lines               corr 0.999970  max abs   0.0898  mean abs 0.01397
+    lane_lines_prob          corr 0.999913  max abs   0.1094  mean abs 0.03763   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.3125  mean abs 0.04054
+    lead_prob                corr 0.999069  max abs   0.0996  mean abs 0.08008   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0625  mean abs 0.02667
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1875  mean abs 0.01065
+    pose                     corr 0.999981  max abs   0.0430  mean abs 0.01038   (by error, pooled)
+    road_edges               corr 0.999970  max abs   0.0664  mean abs 0.01592
+    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.01101   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00721   (by error, pooled)
+
+frame 24: corr 0.999969  max abs 0.6875
+    action                   corr 0.999922  max abs   0.0151  mean abs 0.00975   (by error, pooled)
+    desire_pred              corr 0.999961  max abs   0.0625  mean abs 0.02347
+    desire_state             corr 0.999981  max abs   0.2344  mean abs 0.10645   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2109  mean abs 0.01523
+    lane_lines               corr 0.999950  max abs   0.1641  mean abs 0.01631
+    lane_lines_prob          corr 0.999966  max abs   0.1016  mean abs 0.05735   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.6875  mean abs 0.06699
+    lead_prob                corr 0.996577  max abs   0.0117  mean abs 0.00781   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0645  mean abs 0.02625
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.2188  mean abs 0.00971
+    pose                     corr 0.999992  max abs   0.0859  mean abs 0.01700   (by error, pooled)
+    road_edges               corr 0.999942  max abs   0.1230  mean abs 0.01850
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.01053   (by error, pooled)
+    wide_from_device_euler   corr 0.999989  max abs   0.0312  mean abs 0.01248   (by error, pooled)
+
+frame 25: corr 0.999982  max abs 0.2500
+    action                   corr 0.999981  max abs   0.0068  mean abs 0.00417   (by error, pooled)
+    desire_pred              corr 0.999944  max abs   0.0781  mean abs 0.02817
+    desire_state             corr 0.999991  max abs   0.0859  mean abs 0.05078   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2109  mean abs 0.01473
+    lane_lines               corr 0.999940  max abs   0.0820  mean abs 0.01846
+    lane_lines_prob          corr 0.999904  max abs   0.1289  mean abs 0.05077   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1875  mean abs 0.01383
+    lead_prob                corr 0.998654  max abs   0.0273  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999831  max abs   0.1279  mean abs 0.04345
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2500  mean abs 0.00592
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00996   (by error, pooled)
+    road_edges               corr 0.999938  max abs   0.0957  mean abs 0.02302
+    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.01206   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00624   (by error, pooled)
+
+frame 26: corr 0.999971  max abs 0.3379
+    action                   corr 0.999962  max abs   0.0234  mean abs 0.01273   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0762  mean abs 0.02478
+    desire_state             corr 0.999988  max abs   0.0781  mean abs 0.04614   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2463  mean abs 0.01360
+    lane_lines               corr 0.999934  max abs   0.1152  mean abs 0.01807
+    lane_lines_prob          corr 0.999944  max abs   0.1055  mean abs 0.03624   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.1172  mean abs 0.01570
+    lead_prob                corr 0.999976  max abs   0.0762  mean abs 0.07357   (by error, pooled)
+    meta                     corr 0.999915  max abs   0.0938  mean abs 0.03423
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.3379  mean abs 0.01435
+    pose                     corr 0.999992  max abs   0.0293  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999920  max abs   0.0957  mean abs 0.01895
+    road_transform           corr 0.999989  max abs   0.0586  mean abs 0.01320   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0508  mean abs 0.01084   (by error, pooled)
+
+frame 27: corr 0.999974  max abs 0.2344
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00674   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0840  mean abs 0.02877
+    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.12048   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1123  mean abs 0.01212
+    lane_lines               corr 0.999966  max abs   0.0664  mean abs 0.01772
+    lane_lines_prob          corr 0.999944  max abs   0.1211  mean abs 0.05255   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01196
+    lead_prob                corr 0.998386  max abs   0.1042  mean abs 0.08252   (by error, pooled)
+    meta                     corr 0.999922  max abs   0.0938  mean abs 0.03512
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1562  mean abs 0.00559
+    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00537   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0977  mean abs 0.01668
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00343   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0117  mean abs 0.00427   (by error, pooled)
+
+frame 28: corr 0.999975  max abs 0.3125
+    action                   corr 0.999993  max abs   0.0166  mean abs 0.00888   (by error, pooled)
+    desire_pred              corr 0.999975  max abs   0.0547  mean abs 0.02318
+    desire_state             corr 0.999988  max abs   0.1133  mean abs 0.07367   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1133  mean abs 0.01113
+    lane_lines               corr 0.999960  max abs   0.0977  mean abs 0.01409
+    lane_lines_prob          corr 0.999996  max abs   0.0430  mean abs 0.02063   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3125  mean abs 0.02101
+    lead_prob                corr 0.996397  max abs   0.0938  mean abs 0.07812   (by error, pooled)
+    meta                     corr 0.999967  max abs   0.0801  mean abs 0.02487
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1172  mean abs 0.00626
+    pose                     corr 0.999997  max abs   0.0166  mean abs 0.00535   (by error, pooled)
+    road_edges               corr 0.999956  max abs   0.1523  mean abs 0.01539
+    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.00521   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00262   (by error, pooled)
+
+frame 29: corr 0.999973  max abs 0.2188
+    action                   corr 0.999996  max abs   0.0127  mean abs 0.00696   (by error, pooled)
+    desire_pred              corr 0.999959  max abs   0.0586  mean abs 0.03296
+    desire_state             corr 0.999995  max abs   0.1562  mean abs 0.07239   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01184
+    lane_lines               corr 0.999973  max abs   0.0449  mean abs 0.01383
+    lane_lines_prob          corr 0.999993  max abs   0.1133  mean abs 0.07458   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2188  mean abs 0.01581
+    lead_prob                corr 0.993557  max abs   0.0977  mean abs 0.07812   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0840  mean abs 0.02687
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00604
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00598   (by error, pooled)
+    road_edges               corr 0.999954  max abs   0.1016  mean abs 0.01897
+    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00655   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00886   (by error, pooled)
+
+frame 30: corr 0.999970  max abs 0.2500
+    action                   corr 0.999992  max abs   0.0127  mean abs 0.00661   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02797
+    desire_state             corr 0.999989  max abs   0.1484  mean abs 0.08813   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1660  mean abs 0.01359
+    lane_lines               corr 0.999958  max abs   0.1328  mean abs 0.01609
+    lane_lines_prob          corr 0.999952  max abs   0.0869  mean abs 0.03772   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02438
+    lead_prob                corr 0.999354  max abs   0.1243  mean abs 0.10343   (by error, pooled)
+    meta                     corr 0.999791  max abs   0.1304  mean abs 0.04929
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00752
+    pose                     corr 0.999992  max abs   0.0234  mean abs 0.00691   (by error, pooled)
+    road_edges               corr 0.999963  max abs   0.1719  mean abs 0.01888
+    road_transform           corr 0.999992  max abs   0.0273  mean abs 0.00793   (by error, pooled)
+    wide_from_device_euler   corr 0.999985  max abs   0.0371  mean abs 0.00851   (by error, pooled)
+
+frame 31: corr 0.999970  max abs 0.2188
+    action                   corr 0.999980  max abs   0.0225  mean abs 0.01251   (by error, pooled)
+    desire_pred              corr 0.999933  max abs   0.0664  mean abs 0.02856
+    desire_state             corr 0.999975  max abs   0.1094  mean abs 0.07178   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.2129  mean abs 0.01353
+    lane_lines               corr 0.999958  max abs   0.0820  mean abs 0.01609
+    lane_lines_prob          corr 0.999901  max abs   0.1523  mean abs 0.05202   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.2188  mean abs 0.02764
+    lead_prob                corr 0.998387  max abs   0.1116  mean abs 0.09253   (by error, pooled)
+    meta                     corr 0.999832  max abs   0.1172  mean abs 0.04155
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1250  mean abs 0.00817
+    pose                     corr 0.999979  max abs   0.0547  mean abs 0.01210   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0940  mean abs 0.01712
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00768   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0273  mean abs 0.01210   (by error, pooled)
+
+frame 32: corr 0.999958  max abs 0.1445
+    action                   corr 0.999989  max abs   0.0215  mean abs 0.01032   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03190
+    desire_state             corr 0.999968  max abs   0.1250  mean abs 0.05859   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1445  mean abs 0.01330
+    lane_lines               corr 0.999972  max abs   0.0664  mean abs 0.01441
+    lane_lines_prob          corr 0.999905  max abs   0.1367  mean abs 0.09381   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.1094  mean abs 0.01503
+    lead_prob                corr 0.999998  max abs   0.0508  mean abs 0.03385   (by error, pooled)
+    meta                     corr 0.999972  max abs   0.0547  mean abs 0.02026
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1406  mean abs 0.00554
+    pose                     corr 0.999985  max abs   0.0352  mean abs 0.00878   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0547  mean abs 0.01838
+    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00694   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00592   (by error, pooled)
+
+frame 33: corr 0.999962  max abs 0.8750
+    action                   corr 0.999959  max abs   0.0176  mean abs 0.00947   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0703  mean abs 0.01862
+    desire_state             corr 0.999979  max abs   0.1562  mean abs 0.05762   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2500  mean abs 0.01529
+    lane_lines               corr 0.999955  max abs   0.1133  mean abs 0.01632
+    lane_lines_prob          corr 0.999931  max abs   0.1055  mean abs 0.04333   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.8750  mean abs 0.06872
+    lead_prob                corr 0.999956  max abs   0.0391  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999934  max abs   0.0752  mean abs 0.02529
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.2969  mean abs 0.01298
+    pose                     corr 0.999994  max abs   0.0625  mean abs 0.01658   (by error, pooled)
+    road_edges               corr 0.999960  max abs   0.1016  mean abs 0.01799
+    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00815   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01118   (by error, pooled)
+
+frame 34: corr 0.999979  max abs 0.1963
+    action                   corr 0.999977  max abs   0.0098  mean abs 0.00539   (by error, pooled)
+    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03787
+    desire_state             corr 0.999991  max abs   0.1133  mean abs 0.03394   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1963  mean abs 0.01470
+    lane_lines               corr 0.999939  max abs   0.0742  mean abs 0.01944
+    lane_lines_prob          corr 0.999938  max abs   0.1875  mean abs 0.07463   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01449
+    lead_prob                corr 0.999656  max abs   0.0391  mean abs 0.02604   (by error, pooled)
+    meta                     corr 0.999890  max abs   0.0820  mean abs 0.03731
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1875  mean abs 0.00495
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00991   (by error, pooled)
+    road_edges               corr 0.999935  max abs   0.0654  mean abs 0.02561
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00750   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00332   (by error, pooled)
+
+frame 35: corr 0.999960  max abs 0.3438
+    action                   corr 0.999962  max abs   0.0225  mean abs 0.01250   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0605  mean abs 0.02122
+    desire_state             corr 0.999907  max abs   0.2266  mean abs 0.08117   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2641  mean abs 0.01373
+    lane_lines               corr 0.999954  max abs   0.0684  mean abs 0.01481
+    lane_lines_prob          corr 0.999964  max abs   0.0586  mean abs 0.03961   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03551
+    lead_prob                corr 0.999775  max abs   0.1289  mean abs 0.11133   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.0820  mean abs 0.02702
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.2656  mean abs 0.01050
+    pose                     corr 0.999989  max abs   0.0430  mean abs 0.01239   (by error, pooled)
+    road_edges               corr 0.999960  max abs   0.0547  mean abs 0.01449
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00890   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0586  mean abs 0.01375   (by error, pooled)
+
+frame 36: corr 0.999964  max abs 0.1562
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00779   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.02402
+    desire_state             corr 0.999954  max abs   0.1445  mean abs 0.05359   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01207
+    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01368
+    lane_lines_prob          corr 0.999960  max abs   0.0703  mean abs 0.02673   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.1406  mean abs 0.01257
+    lead_prob                corr 0.999999  max abs   0.1211  mean abs 0.10026   (by error, pooled)
+    meta                     corr 0.999919  max abs   0.1055  mean abs 0.03351
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1562  mean abs 0.00708
+    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00659   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.1152  mean abs 0.01726
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00571   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00621   (by error, pooled)
+
+frame 37: corr 0.999957  max abs 0.3496
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00745   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0566  mean abs 0.02777
+    desire_state             corr 0.999970  max abs   0.1680  mean abs 0.06909   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1162  mean abs 0.01122
+    lane_lines               corr 0.999969  max abs   0.0703  mean abs 0.01477
+    lane_lines_prob          corr 0.999990  max abs   0.0977  mean abs 0.04390   (by error, pooled)
+    lead                     corr 0.999850  max abs   0.3496  mean abs 0.02815
+    lead_prob                corr 0.999963  max abs   0.0664  mean abs 0.05339   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.1074  mean abs 0.03950
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00420
+    pose                     corr 0.999995  max abs   0.0195  mean abs 0.00651   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0742  mean abs 0.01435
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00619   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00489   (by error, pooled)
+
+frame 38: corr 0.999958  max abs 0.2031
+    action                   corr 0.999996  max abs   0.0107  mean abs 0.00541   (by error, pooled)
+    desire_pred              corr 0.999972  max abs   0.0508  mean abs 0.02396
+    desire_state             corr 0.999985  max abs   0.1172  mean abs 0.05750   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1406  mean abs 0.01202
+    lane_lines               corr 0.999966  max abs   0.0898  mean abs 0.01373
+    lane_lines_prob          corr 0.999834  max abs   0.1016  mean abs 0.05020   (by error, pooled)
+    lead                     corr 0.999981  max abs   0.2031  mean abs 0.01509
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06576   (by error, pooled)
+    meta                     corr 0.999912  max abs   0.0977  mean abs 0.04185
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00351
+    pose                     corr 0.999999  max abs   0.0156  mean abs 0.00536   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0977  mean abs 0.01437
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00442   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00266   (by error, pooled)
+
+frame 39: corr 0.999960  max abs 0.6250
+    action                   corr 0.999991  max abs   0.0132  mean abs 0.00716   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.1094  mean abs 0.02056
+    desire_state             corr 0.999984  max abs   0.0996  mean abs 0.02930   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1465  mean abs 0.01390
+    lane_lines               corr 0.999971  max abs   0.0938  mean abs 0.01416
+    lane_lines_prob          corr 0.999846  max abs   0.1211  mean abs 0.04431   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.6250  mean abs 0.04044
+    lead_prob                corr 0.999763  max abs   0.1094  mean abs 0.07975   (by error, pooled)
+    meta                     corr 0.999865  max abs   0.1030  mean abs 0.04137
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00369
+    pose                     corr 0.999994  max abs   0.0186  mean abs 0.00503   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.1250  mean abs 0.01266
+    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00752   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0234  mean abs 0.00624   (by error, pooled)
+
+frame 40: corr 0.999953  max abs 0.3906
+    action                   corr 0.999974  max abs   0.0332  mean abs 0.01743   (by error, pooled)
+    desire_pred              corr 0.999906  max abs   0.0859  mean abs 0.03478
+    desire_state             corr 0.999907  max abs   0.3196  mean abs 0.13505   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2617  mean abs 0.01366
+    lane_lines               corr 0.999937  max abs   0.1445  mean abs 0.01839
+    lane_lines_prob          corr 0.999892  max abs   0.0820  mean abs 0.04476   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.1641  mean abs 0.01987
+    lead_prob                corr 0.999859  max abs   0.1113  mean abs 0.09342   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.0957  mean abs 0.04024
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999964  max abs   0.3906  mean abs 0.01614
+    pose                     corr 0.999949  max abs   0.0918  mean abs 0.01791   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.1250  mean abs 0.01758
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00533   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0156  mean abs 0.00559   (by error, pooled)
+
+frame 41: corr 0.999952  max abs 0.2649
+    action                   corr 0.999977  max abs   0.0273  mean abs 0.01492   (by error, pooled)
+    desire_pred              corr 0.999943  max abs   0.0664  mean abs 0.02870
+    desire_state             corr 0.999941  max abs   0.2649  mean abs 0.12741   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1953  mean abs 0.01348
+    lane_lines               corr 0.999967  max abs   0.0664  mean abs 0.01465
+    lane_lines_prob          corr 0.999892  max abs   0.1211  mean abs 0.05054   (by error, pooled)
+    lead                     corr 0.999983  max abs   0.2500  mean abs 0.01946
+    lead_prob                corr 0.999977  max abs   0.0664  mean abs 0.05632   (by error, pooled)
+    meta                     corr 0.999961  max abs   0.0586  mean abs 0.02646
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999978  max abs   0.2188  mean abs 0.01064
+    pose                     corr 0.999968  max abs   0.0664  mean abs 0.01268   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0664  mean abs 0.01754
+    road_transform           corr 0.999993  max abs   0.0586  mean abs 0.01044   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00557   (by error, pooled)
+
+frame 42: corr 0.999964  max abs 1.0000
+    action                   corr 0.999953  max abs   0.0176  mean abs 0.00957   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0742  mean abs 0.02237
+    desire_state             corr 0.999991  max abs   0.1719  mean abs 0.06738   (by error, pooled)
+    hidden_state             corr 0.999939  max abs   0.2227  mean abs 0.01551
+    lane_lines               corr 0.999949  max abs   0.1641  mean abs 0.01721
+    lane_lines_prob          corr 0.999959  max abs   0.0938  mean abs 0.05408   (by error, pooled)
+    lead                     corr 0.999998  max abs   1.0000  mean abs 0.08374
+    lead_prob                corr 0.999980  max abs   0.0469  mean abs 0.03320   (by error, pooled)
+    meta                     corr 0.999960  max abs   0.0586  mean abs 0.02051
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999990  max abs   0.3750  mean abs 0.01489
+    pose                     corr 0.999992  max abs   0.0938  mean abs 0.01833   (by error, pooled)
+    road_edges               corr 0.999953  max abs   0.0762  mean abs 0.01858
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00704   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0469  mean abs 0.01246   (by error, pooled)
+
+frame 43: corr 0.999981  max abs 0.1992
+    action                   corr 0.999961  max abs   0.0125  mean abs 0.00572   (by error, pooled)
+    desire_pred              corr 0.999924  max abs   0.0879  mean abs 0.03424
+    desire_state             corr 0.999996  max abs   0.1328  mean abs 0.06543   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1992  mean abs 0.01496
+    lane_lines               corr 0.999933  max abs   0.0671  mean abs 0.01937
+    lane_lines_prob          corr 0.999934  max abs   0.1328  mean abs 0.04815   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01052
+    lead_prob                corr 0.999974  max abs   0.0508  mean abs 0.03483   (by error, pooled)
+    meta                     corr 0.999854  max abs   0.1182  mean abs 0.04098
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00588
+    pose                     corr 0.999997  max abs   0.0352  mean abs 0.01159   (by error, pooled)
+    road_edges               corr 0.999912  max abs   0.1035  mean abs 0.02590
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.01020   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0059  mean abs 0.00200   (by error, pooled)
+
+frame 44: corr 0.999961  max abs 0.3125
+    action                   corr 0.999956  max abs   0.0234  mean abs 0.01290   (by error, pooled)
+    desire_pred              corr 0.999867  max abs   0.0938  mean abs 0.04165
+    desire_state             corr 0.999985  max abs   0.2422  mean abs 0.05908   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2340  mean abs 0.01324
+    lane_lines               corr 0.999964  max abs   0.0625  mean abs 0.01566
+    lane_lines_prob          corr 0.999985  max abs   0.0859  mean abs 0.04950   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.3125  mean abs 0.02699
+    lead_prob                corr 0.999996  max abs   0.0879  mean abs 0.08333   (by error, pooled)
+    meta                     corr 0.999895  max abs   0.0820  mean abs 0.03589
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999979  max abs   0.2891  mean abs 0.01164
+    pose                     corr 0.999988  max abs   0.0312  mean abs 0.01193   (by error, pooled)
+    road_edges               corr 0.999947  max abs   0.0664  mean abs 0.01609
+    road_transform           corr 0.999998  max abs   0.0430  mean abs 0.01035   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0391  mean abs 0.01245   (by error, pooled)
+
+frame 45: corr 0.999960  max abs 0.2188
+    action                   corr 0.999986  max abs   0.0215  mean abs 0.01061   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0684  mean abs 0.02888
+    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.08240   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1289  mean abs 0.01152
+    lane_lines               corr 0.999971  max abs   0.0386  mean abs 0.01310
+    lane_lines_prob          corr 0.999984  max abs   0.1055  mean abs 0.03467   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0625  mean abs 0.00760
+    lead_prob                corr 0.999935  max abs   0.1196  mean abs 0.10030   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.1250  mean abs 0.04695
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999980  max abs   0.2188  mean abs 0.00956
+    pose                     corr 0.999992  max abs   0.0259  mean abs 0.00762   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0547  mean abs 0.01518
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00335   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0098  mean abs 0.00296   (by error, pooled)
+
+frame 46: corr 0.999949  max abs 0.5820
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00638   (by error, pooled)
+    desire_pred              corr 0.999979  max abs   0.0488  mean abs 0.02080
+    desire_state             corr 0.999981  max abs   0.1047  mean abs 0.04221   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1211  mean abs 0.01127
+    lane_lines               corr 0.999982  max abs   0.0371  mean abs 0.01206
+    lane_lines_prob          corr 0.999974  max abs   0.0977  mean abs 0.03348   (by error, pooled)
+    lead                     corr 0.999142  max abs   0.5820  mean abs 0.03989
+    lead_prob                corr 0.999995  max abs   0.1250  mean abs 0.10645   (by error, pooled)
+    meta                     corr 0.999931  max abs   0.0957  mean abs 0.03604
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00399
+    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00574   (by error, pooled)
+    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01141
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00580   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00620   (by error, pooled)
+
+frame 47: corr 0.999940  max abs 0.6406
+    action                   corr 0.999993  max abs   0.0137  mean abs 0.00554   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0625  mean abs 0.03202
+    desire_state             corr 0.999962  max abs   0.2131  mean abs 0.06779   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1309  mean abs 0.01206
+    lane_lines               corr 0.999979  max abs   0.0762  mean abs 0.01445
+    lane_lines_prob          corr 0.999939  max abs   0.1367  mean abs 0.07001   (by error, pooled)
+    lead                     corr 0.999672  max abs   0.6406  mean abs 0.04770
+    lead_prob                corr 0.999975  max abs   0.0820  mean abs 0.06803   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0898  mean abs 0.03575
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0225  mean abs 0.00445
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00622   (by error, pooled)
+    road_edges               corr 0.999949  max abs   0.0781  mean abs 0.01724
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00491   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00885   (by error, pooled)
+
+frame 48: corr 0.999957  max abs 0.6250
+    action                   corr 0.999982  max abs   0.0195  mean abs 0.01069   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.0625  mean abs 0.02208
+    desire_state             corr 0.999986  max abs   0.1328  mean abs 0.05737   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1494  mean abs 0.01378
+    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01422
+    lane_lines_prob          corr 0.999956  max abs   0.0977  mean abs 0.04120   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.6250  mean abs 0.04285
+    lead_prob                corr 0.999936  max abs   0.1133  mean abs 0.09619   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.0902  mean abs 0.03599
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.1875  mean abs 0.00748
+    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00550   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.1250  mean abs 0.01621
+    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00393   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00656   (by error, pooled)
+
+frame 49: corr 0.999953  max abs 0.4375
+    action                   corr 0.999980  max abs   0.0293  mean abs 0.01551   (by error, pooled)
+    desire_pred              corr 0.999976  max abs   0.0508  mean abs 0.01759
+    desire_state             corr 0.999958  max abs   0.2617  mean abs 0.10352   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2109  mean abs 0.01310
+    lane_lines               corr 0.999950  max abs   0.0977  mean abs 0.01608
+    lane_lines_prob          corr 0.999894  max abs   0.1172  mean abs 0.04683   (by error, pooled)
+    lead                     corr 0.999969  max abs   0.4375  mean abs 0.03150
+    lead_prob                corr 0.999853  max abs   0.0996  mean abs 0.07861   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0859  mean abs 0.02841
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999973  max abs   0.1660  mean abs 0.01430
+    pose                     corr 0.999979  max abs   0.0410  mean abs 0.01245   (by error, pooled)
+    road_edges               corr 0.999964  max abs   0.1055  mean abs 0.01792
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00677   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0234  mean abs 0.00919   (by error, pooled)
+
+frame 50: corr 0.999943  max abs 0.5234
+    action                   corr 0.999964  max abs   0.0322  mean abs 0.01672   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03007
+    desire_state             corr 0.999955  max abs   0.2969  mean abs 0.10749   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1875  mean abs 0.01355
+    lane_lines               corr 0.999968  max abs   0.0898  mean abs 0.01383
+    lane_lines_prob          corr 0.999863  max abs   0.1758  mean abs 0.06085   (by error, pooled)
+    lead                     corr 0.999869  max abs   0.5234  mean abs 0.03819
+    lead_prob                corr 0.999837  max abs   0.1289  mean abs 0.10059   (by error, pooled)
+    meta                     corr 0.999929  max abs   0.0820  mean abs 0.03109
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999969  max abs   0.1680  mean abs 0.01198
+    pose                     corr 0.999969  max abs   0.0645  mean abs 0.01497   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.0762  mean abs 0.01593
+    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00938   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0098  mean abs 0.00296   (by error, pooled)
+
+frame 51: corr 0.999965  max abs 1.0000
+    action                   corr 0.999955  max abs   0.0171  mean abs 0.00784   (by error, pooled)
+    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02560
+    desire_state             corr 0.999986  max abs   0.2344  mean abs 0.11670   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2461  mean abs 0.01509
+    lane_lines               corr 0.999951  max abs   0.0938  mean abs 0.01672
+    lane_lines_prob          corr 0.999965  max abs   0.0923  mean abs 0.04596   (by error, pooled)
+    lead                     corr 0.999997  max abs   1.0000  mean abs 0.07913
+    lead_prob                corr 0.999973  max abs   0.0742  mean abs 0.04818   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0635  mean abs 0.02527
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2812  mean abs 0.01103
+    pose                     corr 0.999996  max abs   0.0625  mean abs 0.01496   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0859  mean abs 0.01813
+    road_transform           corr 0.999997  max abs   0.0391  mean abs 0.00987   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0352  mean abs 0.00953   (by error, pooled)
+
+frame 52: corr 0.999978  max abs 0.2012
+    action                   corr 0.999939  max abs   0.0176  mean abs 0.00873   (by error, pooled)
+    desire_pred              corr 0.999917  max abs   0.0859  mean abs 0.03464
+    desire_state             corr 0.999988  max abs   0.1250  mean abs 0.07446   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2012  mean abs 0.01484
+    lane_lines               corr 0.999930  max abs   0.0728  mean abs 0.01964
+    lane_lines_prob          corr 0.999950  max abs   0.0859  mean abs 0.04348   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01256
+    lead_prob                corr 0.999933  max abs   0.0420  mean abs 0.02441   (by error, pooled)
+    meta                     corr 0.999891  max abs   0.0859  mean abs 0.04246
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1094  mean abs 0.00555
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00976   (by error, pooled)
+    road_edges               corr 0.999877  max abs   0.1211  mean abs 0.03057
+    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00986   (by error, pooled)
+    wide_from_device_euler   corr 0.999987  max abs   0.0293  mean abs 0.00785   (by error, pooled)
+
+frame 53: corr 0.999953  max abs 0.3594
+    action                   corr 0.999955  max abs   0.0264  mean abs 0.01454   (by error, pooled)
+    desire_pred              corr 0.999863  max abs   0.0909  mean abs 0.04372
+    desire_state             corr 0.999980  max abs   0.1289  mean abs 0.09619   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2233  mean abs 0.01320
+    lane_lines               corr 0.999966  max abs   0.0430  mean abs 0.01369
+    lane_lines_prob          corr 0.999981  max abs   0.0898  mean abs 0.04086   (by error, pooled)
+    lead                     corr 0.999975  max abs   0.3594  mean abs 0.03772
+    lead_prob                corr 1.000000  max abs   0.1113  mean abs 0.10026   (by error, pooled)
+    meta                     corr 0.999829  max abs   0.1133  mean abs 0.04773
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999965  max abs   0.3359  mean abs 0.01300
+    pose                     corr 0.999988  max abs   0.0337  mean abs 0.01259   (by error, pooled)
+    road_edges               corr 0.999928  max abs   0.0664  mean abs 0.02024
+    road_transform           corr 0.999998  max abs   0.0391  mean abs 0.00905   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0664  mean abs 0.01831   (by error, pooled)
+
+frame 54: corr 0.999957  max abs 0.2812
+    action                   corr 0.999996  max abs   0.0107  mean abs 0.00582   (by error, pooled)
+    desire_pred              corr 0.999951  max abs   0.0625  mean abs 0.03176
+    desire_state             corr 0.999988  max abs   0.0859  mean abs 0.04181   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1094  mean abs 0.01179
+    lane_lines               corr 0.999965  max abs   0.0625  mean abs 0.01655
+    lane_lines_prob          corr 0.999982  max abs   0.1602  mean abs 0.07764   (by error, pooled)
+    lead                     corr 0.999964  max abs   0.2812  mean abs 0.02281
+    lead_prob                corr 0.999936  max abs   0.1270  mean abs 0.10685   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0977  mean abs 0.04134
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0508  mean abs 0.00573
+    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00550   (by error, pooled)
+    road_edges               corr 0.999951  max abs   0.0938  mean abs 0.01782
+    road_transform           corr 0.999994  max abs   0.0352  mean abs 0.00506   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0117  mean abs 0.00426   (by error, pooled)
+
+frame 55: corr 0.999957  max abs 0.3438
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00665   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0664  mean abs 0.02021
+    desire_state             corr 0.999981  max abs   0.0703  mean abs 0.04671   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1152  mean abs 0.01115
+    lane_lines               corr 0.999975  max abs   0.0664  mean abs 0.01440
+    lane_lines_prob          corr 0.999967  max abs   0.1172  mean abs 0.04901   (by error, pooled)
+    lead                     corr 0.999812  max abs   0.3438  mean abs 0.02753
+    lead_prob                corr 0.999817  max abs   0.1270  mean abs 0.09538   (by error, pooled)
+    meta                     corr 0.999947  max abs   0.0879  mean abs 0.03769
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00460
+    pose                     corr 0.999997  max abs   0.0137  mean abs 0.00518   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0742  mean abs 0.01324
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00457   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0137  mean abs 0.00523   (by error, pooled)
+
+frame 56: corr 0.999956  max abs 0.2725
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00525   (by error, pooled)
+    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02641
+    desire_state             corr 0.999997  max abs   0.0781  mean abs 0.03787   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01219
+    lane_lines               corr 0.999980  max abs   0.0566  mean abs 0.01184
+    lane_lines_prob          corr 0.999868  max abs   0.0801  mean abs 0.04492   (by error, pooled)
+    lead                     corr 0.999601  max abs   0.2725  mean abs 0.02176
+    lead_prob                corr 0.999846  max abs   0.1016  mean abs 0.07747   (by error, pooled)
+    meta                     corr 0.999915  max abs   0.0918  mean abs 0.03517
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0645  mean abs 0.00431
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00586   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0820  mean abs 0.01239
+    road_transform           corr 0.999995  max abs   0.0273  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0312  mean abs 0.01176   (by error, pooled)
+
+frame 57: corr 0.999956  max abs 0.3750
+    action                   corr 0.999985  max abs   0.0181  mean abs 0.00963   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0840  mean abs 0.03075
+    desire_state             corr 0.999990  max abs   0.1641  mean abs 0.07544   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1709  mean abs 0.01410
+    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01614
+    lane_lines_prob          corr 0.999859  max abs   0.1719  mean abs 0.06293   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.3750  mean abs 0.02853
+    lead_prob                corr 0.999945  max abs   0.0859  mean abs 0.07056   (by error, pooled)
+    meta                     corr 0.999730  max abs   0.1221  mean abs 0.04862
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00455
+    pose                     corr 0.999991  max abs   0.0264  mean abs 0.00733   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.1484  mean abs 0.01666
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00581   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00560   (by error, pooled)
+
+frame 58: corr 0.999957  max abs 0.2344
+    action                   corr 0.999990  max abs   0.0176  mean abs 0.00778   (by error, pooled)
+    desire_pred              corr 0.999951  max abs   0.0820  mean abs 0.02925
+    desire_state             corr 0.999976  max abs   0.2344  mean abs 0.08923   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1797  mean abs 0.01294
+    lane_lines               corr 0.999962  max abs   0.0898  mean abs 0.01531
+    lane_lines_prob          corr 0.999956  max abs   0.1406  mean abs 0.04791   (by error, pooled)
+    lead                     corr 0.999965  max abs   0.2266  mean abs 0.01826
+    lead_prob                corr 0.999449  max abs   0.1094  mean abs 0.08789   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0840  mean abs 0.02789
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999989  max abs   0.1172  mean abs 0.00709
+    pose                     corr 0.999986  max abs   0.0332  mean abs 0.00896   (by error, pooled)
+    road_edges               corr 0.999958  max abs   0.0762  mean abs 0.01881
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00638   (by error, pooled)
+    wide_from_device_euler   corr 0.999990  max abs   0.0273  mean abs 0.00886   (by error, pooled)
+
+frame 59: corr 0.999930  max abs 0.4062
+    action                   corr 0.999972  max abs   0.0303  mean abs 0.01643   (by error, pooled)
+    desire_pred              corr 0.999927  max abs   0.0918  mean abs 0.03131
+    desire_state             corr 0.999944  max abs   0.3750  mean abs 0.15173   (by error, pooled)
+    hidden_state             corr 0.999942  max abs   0.2227  mean abs 0.01407
+    lane_lines               corr 0.999958  max abs   0.1094  mean abs 0.01538
+    lane_lines_prob          corr 0.999842  max abs   0.1602  mean abs 0.06467   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.4062  mean abs 0.05356
+    lead_prob                corr 0.999797  max abs   0.0723  mean abs 0.05273   (by error, pooled)
+    meta                     corr 0.999951  max abs   0.0879  mean abs 0.02836
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999951  max abs   0.2422  mean abs 0.01267
+    pose                     corr 0.999965  max abs   0.0664  mean abs 0.01563   (by error, pooled)
+    road_edges               corr 0.999949  max abs   0.0859  mean abs 0.01721
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00719   (by error, pooled)
+
+frame 60: corr 0.999953  max abs 1.0000
+    action                   corr 0.999916  max abs   0.0254  mean abs 0.01387   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0684  mean abs 0.02454
+    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.05286   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2129  mean abs 0.01532
+    lane_lines               corr 0.999956  max abs   0.0664  mean abs 0.01584
+    lane_lines_prob          corr 0.999989  max abs   0.1016  mean abs 0.04890   (by error, pooled)
+    lead                     corr 0.999992  max abs   1.0000  mean abs 0.07129
+    lead_prob                corr 0.999970  max abs   0.0234  mean abs 0.01530   (by error, pooled)
+    meta                     corr 0.999944  max abs   0.0752  mean abs 0.02185
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999975  max abs   0.3750  mean abs 0.01604
+    pose                     corr 0.999991  max abs   0.0859  mean abs 0.01885   (by error, pooled)
+    road_edges               corr 0.999929  max abs   0.0938  mean abs 0.02242
+    road_transform           corr 0.999997  max abs   0.0508  mean abs 0.01206   (by error, pooled)
+    wide_from_device_euler   corr 0.999986  max abs   0.0449  mean abs 0.01542   (by error, pooled)
+
+frame 61: corr 0.999977  max abs 0.1719
+    action                   corr 0.999976  max abs   0.0110  mean abs 0.00571   (by error, pooled)
+    desire_pred              corr 0.999891  max abs   0.0957  mean abs 0.03925
+    desire_state             corr 0.999997  max abs   0.1094  mean abs 0.04929   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1719  mean abs 0.01461
+    lane_lines               corr 0.999884  max abs   0.1038  mean abs 0.02350
+    lane_lines_prob          corr 0.999950  max abs   0.1133  mean abs 0.05789   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.0625  mean abs 0.00837
+    lead_prob                corr 0.999996  max abs   0.0300  mean abs 0.01326   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.0898  mean abs 0.04400
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1328  mean abs 0.00503
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00992   (by error, pooled)
+    road_edges               corr 0.999869  max abs   0.1055  mean abs 0.03016
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01394   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00525   (by error, pooled)
+
+frame 62: corr 0.999960  max abs 0.3125
+    action                   corr 0.999978  max abs   0.0215  mean abs 0.01225   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0781  mean abs 0.02914
+    desire_state             corr 0.999993  max abs   0.1836  mean abs 0.09161   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2567  mean abs 0.01361
+    lane_lines               corr 0.999948  max abs   0.0547  mean abs 0.01539
+    lane_lines_prob          corr 0.999908  max abs   0.1406  mean abs 0.04785   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.2812  mean abs 0.02750
+    lead_prob                corr 0.999994  max abs   0.1069  mean abs 0.08285   (by error, pooled)
+    meta                     corr 0.999832  max abs   0.1113  mean abs 0.04802
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999967  max abs   0.3125  mean abs 0.01284
+    pose                     corr 0.999995  max abs   0.0234  mean abs 0.00736   (by error, pooled)
+    road_edges               corr 0.999888  max abs   0.0762  mean abs 0.02576
+    road_transform           corr 0.999996  max abs   0.0586  mean abs 0.01589   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0625  mean abs 0.01701   (by error, pooled)
+
+frame 63: corr 0.999957  max abs 0.2812
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00650   (by error, pooled)
+    desire_pred              corr 0.999947  max abs   0.0625  mean abs 0.03246
+    desire_state             corr 0.999977  max abs   0.2812  mean abs 0.15918   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1172  mean abs 0.01182
+    lane_lines               corr 0.999977  max abs   0.0488  mean abs 0.01284
+    lane_lines_prob          corr 0.999981  max abs   0.0742  mean abs 0.03076   (by error, pooled)
+    lead                     corr 0.999970  max abs   0.2188  mean abs 0.01843
+    lead_prob                corr 0.999815  max abs   0.1631  mean abs 0.13082   (by error, pooled)
+    meta                     corr 0.999893  max abs   0.1172  mean abs 0.04738
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0781  mean abs 0.00548
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00508   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0703  mean abs 0.01408
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00530   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00687   (by error, pooled)
+
+frame 64: corr 0.999965  max abs 0.1797
+    action                   corr 0.999996  max abs   0.0137  mean abs 0.00573   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.0586  mean abs 0.02530
+    desire_state             corr 0.999986  max abs   0.1797  mean abs 0.10046   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1094  mean abs 0.01099
+    lane_lines               corr 0.999959  max abs   0.0820  mean abs 0.01630
+    lane_lines_prob          corr 0.999910  max abs   0.1094  mean abs 0.04137   (by error, pooled)
+    lead                     corr 0.999964  max abs   0.1328  mean abs 0.00961
+    lead_prob                corr 0.999999  max abs   0.0703  mean abs 0.06543   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0908  mean abs 0.03479
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00662
+    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00592   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.1016  mean abs 0.01671
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00400   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00458   (by error, pooled)
+
+frame 65: corr 0.999955  max abs 0.3066
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00378   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0820  mean abs 0.03578
+    desire_state             corr 0.999981  max abs   0.2109  mean abs 0.08820   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1289  mean abs 0.01225
+    lane_lines               corr 0.999969  max abs   0.0742  mean abs 0.01382
+    lane_lines_prob          corr 0.999911  max abs   0.0781  mean abs 0.03632   (by error, pooled)
+    lead                     corr 0.999721  max abs   0.3066  mean abs 0.02560
+    lead_prob                corr 0.999990  max abs   0.0859  mean abs 0.06999   (by error, pooled)
+    meta                     corr 0.999897  max abs   0.1035  mean abs 0.04263
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0278  mean abs 0.00595
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00621   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0918  mean abs 0.01782
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00547   (by error, pooled)
+    wide_from_device_euler   corr 0.999987  max abs   0.0391  mean abs 0.01046   (by error, pooled)
+
+frame 66: corr 0.999963  max abs 0.2500
+    action                   corr 0.999981  max abs   0.0215  mean abs 0.01265   (by error, pooled)
+    desire_pred              corr 0.999946  max abs   0.0625  mean abs 0.02707
+    desire_state             corr 0.999988  max abs   0.2500  mean abs 0.10840   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.2002  mean abs 0.01356
+    lane_lines               corr 0.999966  max abs   0.1387  mean abs 0.01399
+    lane_lines_prob          corr 0.999910  max abs   0.0793  mean abs 0.04556   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.1328  mean abs 0.01790
+    lead_prob                corr 0.999748  max abs   0.1641  mean abs 0.10872   (by error, pooled)
+    meta                     corr 0.999933  max abs   0.0657  mean abs 0.02508
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.0625  mean abs 0.00973
+    pose                     corr 0.999984  max abs   0.0410  mean abs 0.01082   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.1250  mean abs 0.01564
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00556   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00655   (by error, pooled)
+
+frame 67: corr 0.999957  max abs 0.2344
+    action                   corr 0.999978  max abs   0.0273  mean abs 0.01236   (by error, pooled)
+    desire_pred              corr 0.999907  max abs   0.0820  mean abs 0.03851
+    desire_state             corr 0.999987  max abs   0.1875  mean abs 0.09302   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1855  mean abs 0.01315
+    lane_lines               corr 0.999942  max abs   0.1328  mean abs 0.01776
+    lane_lines_prob          corr 0.999937  max abs   0.1094  mean abs 0.02963   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.1875  mean abs 0.02484
+    lead_prob                corr 0.999982  max abs   0.1445  mean abs 0.12012   (by error, pooled)
+    meta                     corr 0.999887  max abs   0.0977  mean abs 0.03546
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999984  max abs   0.2344  mean abs 0.01087
+    pose                     corr 0.999981  max abs   0.0391  mean abs 0.01217   (by error, pooled)
+    road_edges               corr 0.999946  max abs   0.1016  mean abs 0.01812
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00768   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0293  mean abs 0.00722   (by error, pooled)
+
+frame 68: corr 0.999950  max abs 0.2148
+    action                   corr 0.999973  max abs   0.0332  mean abs 0.01659   (by error, pooled)
+    desire_pred              corr 0.999921  max abs   0.0742  mean abs 0.03478
+    desire_state             corr 0.999979  max abs   0.2109  mean abs 0.10840   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.2148  mean abs 0.01354
+    lane_lines               corr 0.999962  max abs   0.0566  mean abs 0.01385
+    lane_lines_prob          corr 0.999875  max abs   0.1016  mean abs 0.04523   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.2031  mean abs 0.02641
+    lead_prob                corr 0.999954  max abs   0.1250  mean abs 0.09928   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0547  mean abs 0.02170
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999975  max abs   0.1641  mean abs 0.01313
+    pose                     corr 0.999970  max abs   0.0566  mean abs 0.01544   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0781  mean abs 0.01303
+    road_transform           corr 0.999993  max abs   0.0430  mean abs 0.00872   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00362   (by error, pooled)
+
+frame 69: corr 0.999968  max abs 0.5625
+    action                   corr 0.999962  max abs   0.0151  mean abs 0.00745   (by error, pooled)
+    desire_pred              corr 0.999940  max abs   0.0938  mean abs 0.02908
+    desire_state             corr 0.999984  max abs   0.1719  mean abs 0.09521   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.1953  mean abs 0.01517
+    lane_lines               corr 0.999940  max abs   0.0938  mean abs 0.01824
+    lane_lines_prob          corr 0.999938  max abs   0.1445  mean abs 0.05496   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5625  mean abs 0.05521
+    lead_prob                corr 0.999977  max abs   0.0684  mean abs 0.05176   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0840  mean abs 0.02844
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2031  mean abs 0.00985
+    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01493   (by error, pooled)
+    road_edges               corr 0.999904  max abs   0.1094  mean abs 0.02694
+    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.00889   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0352  mean abs 0.01180   (by error, pooled)
+
+frame 70: corr 0.999977  max abs 0.3125
+    action                   corr 0.999972  max abs   0.0129  mean abs 0.00566   (by error, pooled)
+    desire_pred              corr 0.999886  max abs   0.1113  mean abs 0.04156
+    desire_state             corr 0.999998  max abs   0.1016  mean abs 0.05786   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1758  mean abs 0.01456
+    lane_lines               corr 0.999905  max abs   0.0802  mean abs 0.02389
+    lane_lines_prob          corr 0.999826  max abs   0.2500  mean abs 0.09526   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02130
+    lead_prob                corr 0.999998  max abs   0.0811  mean abs 0.07210   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.1133  mean abs 0.04726
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.3125  mean abs 0.00817
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00944   (by error, pooled)
+    road_edges               corr 0.999890  max abs   0.0894  mean abs 0.02809
+    road_transform           corr 0.999991  max abs   0.0312  mean abs 0.01126   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00299   (by error, pooled)
+
+frame 71: corr 0.999950  max abs 0.3438
+    action                   corr 0.999978  max abs   0.0215  mean abs 0.01211   (by error, pooled)
+    desire_pred              corr 0.999920  max abs   0.0807  mean abs 0.03205
+    desire_state             corr 0.999996  max abs   0.2188  mean abs 0.09253   (by error, pooled)
+    hidden_state             corr 0.999947  max abs   0.2341  mean abs 0.01328
+    lane_lines               corr 0.999953  max abs   0.0898  mean abs 0.01493
+    lane_lines_prob          corr 0.999982  max abs   0.0508  mean abs 0.02563   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.04068
+    lead_prob                corr 0.999966  max abs   0.1367  mean abs 0.10775   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.1094  mean abs 0.05435
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999981  max abs   0.2344  mean abs 0.01384
+    pose                     corr 0.999987  max abs   0.0312  mean abs 0.01272   (by error, pooled)
+    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02025
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00433   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00757   (by error, pooled)
+
+frame 72: corr 0.999965  max abs 0.1211
+    action                   corr 0.999994  max abs   0.0137  mean abs 0.00534   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0664  mean abs 0.03443
+    desire_state             corr 0.999995  max abs   0.0781  mean abs 0.03052   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01144
+    lane_lines               corr 0.999965  max abs   0.0703  mean abs 0.01386
+    lane_lines_prob          corr 0.999937  max abs   0.1211  mean abs 0.04553   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.0938  mean abs 0.00948
+    lead_prob                corr 0.999937  max abs   0.1016  mean abs 0.06445   (by error, pooled)
+    meta                     corr 0.999926  max abs   0.1016  mean abs 0.03933
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1016  mean abs 0.00674
+    pose                     corr 0.999995  max abs   0.0244  mean abs 0.00696   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01637
+    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00678   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0156  mean abs 0.00522   (by error, pooled)
+
+frame 73: corr 0.999964  max abs 0.2422
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00574   (by error, pooled)
+    desire_pred              corr 0.999945  max abs   0.0605  mean abs 0.03956
+    desire_state             corr 0.999969  max abs   0.2422  mean abs 0.08496   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1230  mean abs 0.01152
+    lane_lines               corr 0.999980  max abs   0.0430  mean abs 0.01133
+    lane_lines_prob          corr 0.999959  max abs   0.1133  mean abs 0.05399   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0469  mean abs 0.00878
+    lead_prob                corr 0.999995  max abs   0.0898  mean abs 0.07878   (by error, pooled)
+    meta                     corr 0.999917  max abs   0.1191  mean abs 0.03578
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00729
+    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00591   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0781  mean abs 0.01458
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00506   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
+
+frame 74: corr 0.999962  max abs 0.1289
+    action                   corr 0.999998  max abs   0.0088  mean abs 0.00378   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0547  mean abs 0.02530
+    desire_state             corr 0.999978  max abs   0.1250  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1289  mean abs 0.01225
+    lane_lines               corr 0.999983  max abs   0.0488  mean abs 0.01069
+    lane_lines_prob          corr 0.999953  max abs   0.0820  mean abs 0.04108   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0216  mean abs 0.00366
+    lead_prob                corr 0.999999  max abs   0.0508  mean abs 0.04525   (by error, pooled)
+    meta                     corr 0.999931  max abs   0.0977  mean abs 0.03667
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0938  mean abs 0.00628
+    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00738   (by error, pooled)
+    road_edges               corr 0.999982  max abs   0.0762  mean abs 0.01163
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00798   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0273  mean abs 0.00852   (by error, pooled)
+
+frame 75: corr 0.999965  max abs 0.1802
+    action                   corr 0.999983  max abs   0.0181  mean abs 0.01035   (by error, pooled)
+    desire_pred              corr 0.999947  max abs   0.0645  mean abs 0.02671
+    desire_state             corr 0.999994  max abs   0.1367  mean abs 0.05273   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1802  mean abs 0.01418
+    lane_lines               corr 0.999977  max abs   0.0938  mean abs 0.01250
+    lane_lines_prob          corr 0.999884  max abs   0.0957  mean abs 0.03717   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1094  mean abs 0.01454
+    lead_prob                corr 0.999984  max abs   0.1094  mean abs 0.08919   (by error, pooled)
+    meta                     corr 0.999863  max abs   0.0909  mean abs 0.03252
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1406  mean abs 0.00598
+    pose                     corr 0.999991  max abs   0.0312  mean abs 0.00796   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0935  mean abs 0.01715
+    road_transform           corr 0.999994  max abs   0.0293  mean abs 0.00751   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00364   (by error, pooled)
+
+frame 76: corr 0.999955  max abs 0.2588
+    action                   corr 0.999980  max abs   0.0273  mean abs 0.01375   (by error, pooled)
+    desire_pred              corr 0.999935  max abs   0.0820  mean abs 0.02995
+    desire_state             corr 0.999972  max abs   0.2588  mean abs 0.14471   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2383  mean abs 0.01328
+    lane_lines               corr 0.999969  max abs   0.0898  mean abs 0.01368
+    lane_lines_prob          corr 0.999914  max abs   0.0938  mean abs 0.03456   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.1250  mean abs 0.01952
+    lead_prob                corr 0.999992  max abs   0.0938  mean abs 0.08008   (by error, pooled)
+    meta                     corr 0.999916  max abs   0.0840  mean abs 0.03474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.1875  mean abs 0.01056
+    pose                     corr 0.999962  max abs   0.0625  mean abs 0.01739   (by error, pooled)
+    road_edges               corr 0.999984  max abs   0.0664  mean abs 0.01294
+    road_transform           corr 1.000000  max abs   0.0234  mean abs 0.00646   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00525   (by error, pooled)
+
+frame 77: corr 0.999951  max abs 0.3906
+    action                   corr 0.999970  max abs   0.0322  mean abs 0.01698   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.01995
+    desire_state             corr 0.999907  max abs   0.3906  mean abs 0.19397   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.1758  mean abs 0.01404
+    lane_lines               corr 0.999972  max abs   0.1133  mean abs 0.01270
+    lane_lines_prob          corr 0.999942  max abs   0.0859  mean abs 0.03262   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.1562  mean abs 0.02014
+    lead_prob                corr 0.999992  max abs   0.1465  mean abs 0.12314   (by error, pooled)
+    meta                     corr 0.999966  max abs   0.0723  mean abs 0.02376
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999984  max abs   0.2031  mean abs 0.01073
+    pose                     corr 0.999977  max abs   0.0547  mean abs 0.01181   (by error, pooled)
+    road_edges               corr 0.999977  max abs   0.0781  mean abs 0.01255
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00620   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0312  mean abs 0.01147   (by error, pooled)
+
+frame 78: corr 0.999968  max abs 0.8125
+    action                   corr 0.999945  max abs   0.0176  mean abs 0.00992   (by error, pooled)
+    desire_pred              corr 0.999977  max abs   0.0586  mean abs 0.01959
+    desire_state             corr 0.999985  max abs   0.1729  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2227  mean abs 0.01550
+    lane_lines               corr 0.999957  max abs   0.1406  mean abs 0.01580
+    lane_lines_prob          corr 0.999853  max abs   0.1797  mean abs 0.05075   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.8125  mean abs 0.07051
+    lead_prob                corr 0.999988  max abs   0.1138  mean abs 0.10042   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.0693  mean abs 0.02624
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1875  mean abs 0.01092
+    pose                     corr 0.999994  max abs   0.0703  mean abs 0.01583   (by error, pooled)
+    road_edges               corr 0.999944  max abs   0.0996  mean abs 0.02373
+    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01103   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.01083   (by error, pooled)
+
+frame 79: corr 0.999981  max abs 0.1953
+    action                   corr 0.999993  max abs   0.0068  mean abs 0.00330   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03223
+    desire_state             corr 0.999988  max abs   0.1230  mean abs 0.05566   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1953  mean abs 0.01466
+    lane_lines               corr 0.999930  max abs   0.0938  mean abs 0.02010
+    lane_lines_prob          corr 0.999953  max abs   0.1172  mean abs 0.06225   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01362
+    lead_prob                corr 0.999989  max abs   0.0771  mean abs 0.06576   (by error, pooled)
+    meta                     corr 0.999859  max abs   0.1152  mean abs 0.04403
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1875  mean abs 0.00592
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01025   (by error, pooled)
+    road_edges               corr 0.999916  max abs   0.0781  mean abs 0.02472
+    road_transform           corr 0.999992  max abs   0.0508  mean abs 0.01150   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.00590   (by error, pooled)
+
+frame 80: corr 0.999966  max abs 0.2447
+    action                   corr 0.999955  max abs   0.0244  mean abs 0.01292   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0703  mean abs 0.02839
+    desire_state             corr 0.999985  max abs   0.1719  mean abs 0.06842   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2447  mean abs 0.01320
+    lane_lines               corr 0.999966  max abs   0.0469  mean abs 0.01316
+    lane_lines_prob          corr 0.999978  max abs   0.0685  mean abs 0.03523   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.1562  mean abs 0.02241
+    lead_prob                corr 0.999989  max abs   0.1465  mean abs 0.12874   (by error, pooled)
+    meta                     corr 0.999904  max abs   0.0859  mean abs 0.03536
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00775
+    pose                     corr 0.999993  max abs   0.0273  mean abs 0.01102   (by error, pooled)
+    road_edges               corr 0.999933  max abs   0.0762  mean abs 0.01956
+    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01118   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0391  mean abs 0.01375   (by error, pooled)
+
+frame 81: corr 0.999958  max abs 0.1680
+    action                   corr 0.999988  max abs   0.0205  mean abs 0.00917   (by error, pooled)
+    desire_pred              corr 0.999936  max abs   0.0688  mean abs 0.03357
+    desire_state             corr 0.999965  max abs   0.1289  mean abs 0.07713   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01147
+    lane_lines               corr 0.999936  max abs   0.1211  mean abs 0.01838
+    lane_lines_prob          corr 0.999911  max abs   0.1055  mean abs 0.03925   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.0508  mean abs 0.00909
+    lead_prob                corr 0.999975  max abs   0.1523  mean abs 0.12354   (by error, pooled)
+    meta                     corr 0.999839  max abs   0.1426  mean abs 0.05474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00678
+    pose                     corr 0.999993  max abs   0.0283  mean abs 0.00774   (by error, pooled)
+    road_edges               corr 0.999924  max abs   0.1680  mean abs 0.02038
+    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00653   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00264   (by error, pooled)
+
+frame 82: corr 0.999961  max abs 0.1594
+    action                   corr 0.999997  max abs   0.0088  mean abs 0.00259   (by error, pooled)
+    desire_pred              corr 0.999950  max abs   0.0781  mean abs 0.03089
+    desire_state             corr 0.999990  max abs   0.1172  mean abs 0.07062   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1289  mean abs 0.01148
+    lane_lines               corr 0.999967  max abs   0.0625  mean abs 0.01310
+    lane_lines_prob          corr 0.999949  max abs   0.0840  mean abs 0.04501   (by error, pooled)
+    lead                     corr 0.999844  max abs   0.1594  mean abs 0.01475
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.07214   (by error, pooled)
+    meta                     corr 0.999943  max abs   0.0762  mean abs 0.03255
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00434
+    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00594   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0586  mean abs 0.01416
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00416   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0137  mean abs 0.00295   (by error, pooled)
+
+frame 83: corr 0.999955  max abs 0.2578
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00385   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0742  mean abs 0.02845
+    desire_state             corr 0.999985  max abs   0.1309  mean abs 0.03833   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1328  mean abs 0.01242
+    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01571
+    lane_lines_prob          corr 0.999971  max abs   0.1211  mean abs 0.05807   (by error, pooled)
+    lead                     corr 0.999982  max abs   0.2578  mean abs 0.02209
+    lead_prob                corr 0.999999  max abs   0.0977  mean abs 0.08310   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.0898  mean abs 0.03797
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00380
+    pose                     corr 0.999997  max abs   0.0273  mean abs 0.00770   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0781  mean abs 0.01535
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00790   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00981   (by error, pooled)
+
+frame 84: corr 0.999958  max abs 0.3125
+    action                   corr 0.999986  max abs   0.0161  mean abs 0.00913   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0586  mean abs 0.02159
+    desire_state             corr 0.999929  max abs   0.1484  mean abs 0.08228   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1641  mean abs 0.01399
+    lane_lines               corr 0.999933  max abs   0.2227  mean abs 0.01733
+    lane_lines_prob          corr 0.999822  max abs   0.0898  mean abs 0.05341   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.3125  mean abs 0.02349
+    lead_prob                corr 0.999966  max abs   0.1680  mean abs 0.14006   (by error, pooled)
+    meta                     corr 0.999860  max abs   0.0996  mean abs 0.03439
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00519
+    pose                     corr 0.999989  max abs   0.0264  mean abs 0.00699   (by error, pooled)
+    road_edges               corr 0.999965  max abs   0.1250  mean abs 0.01487
+    road_transform           corr 0.999992  max abs   0.0312  mean abs 0.00808   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
+
+frame 85: corr 0.999955  max abs 0.3750
+    action                   corr 0.999969  max abs   0.0234  mean abs 0.01309   (by error, pooled)
+    desire_pred              corr 0.999931  max abs   0.0625  mean abs 0.02937
+    desire_state             corr 0.999725  max abs   0.3613  mean abs 0.19666   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01400
+    lane_lines               corr 0.999966  max abs   0.1133  mean abs 0.01702
+    lane_lines_prob          corr 0.999995  max abs   0.0762  mean abs 0.04250   (by error, pooled)
+    lead                     corr 0.999957  max abs   0.3750  mean abs 0.03565
+    lead_prob                corr 0.999985  max abs   0.2383  mean abs 0.19333   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.0762  mean abs 0.02420
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999987  max abs   0.1875  mean abs 0.00896
+    pose                     corr 0.999974  max abs   0.0781  mean abs 0.01537   (by error, pooled)
+    road_edges               corr 0.999981  max abs   0.0625  mean abs 0.01499
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00857   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0215  mean abs 0.00817   (by error, pooled)
+
+frame 86: corr 0.999929  max abs 0.4688
+    action                   corr 0.999969  max abs   0.0332  mean abs 0.01874   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0625  mean abs 0.03150
+    desire_state             corr 0.999726  max abs   0.3828  mean abs 0.18327   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2188  mean abs 0.01377
+    lane_lines               corr 0.999964  max abs   0.0977  mean abs 0.01412
+    lane_lines_prob          corr 0.999902  max abs   0.1211  mean abs 0.04495   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.4688  mean abs 0.05692
+    lead_prob                corr 0.999998  max abs   0.1328  mean abs 0.10693   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0742  mean abs 0.02528
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999959  max abs   0.2422  mean abs 0.01130
+    pose                     corr 0.999958  max abs   0.0762  mean abs 0.01647   (by error, pooled)
+    road_edges               corr 0.999942  max abs   0.0664  mean abs 0.02047
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00914   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00462   (by error, pooled)
+
+frame 87: corr 0.999969  max abs 0.8125
+    action                   corr 0.999944  max abs   0.0159  mean abs 0.00849   (by error, pooled)
+    desire_pred              corr 0.999961  max abs   0.0547  mean abs 0.02374
+    desire_state             corr 0.999984  max abs   0.1875  mean abs 0.09924   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2227  mean abs 0.01549
+    lane_lines               corr 0.999949  max abs   0.1328  mean abs 0.01768
+    lane_lines_prob          corr 0.999975  max abs   0.1562  mean abs 0.05096   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.8125  mean abs 0.06905
+    lead_prob                corr 0.999998  max abs   0.0582  mean abs 0.04545   (by error, pooled)
+    meta                     corr 0.999914  max abs   0.0977  mean abs 0.03504
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00920
+    pose                     corr 0.999995  max abs   0.0547  mean abs 0.01569   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0820  mean abs 0.02022
+    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.00987   (by error, pooled)
+    wide_from_device_euler   corr 0.999989  max abs   0.0371  mean abs 0.01217   (by error, pooled)
+
+frame 88: corr 0.999980  max abs 0.2500
+    action                   corr 0.999933  max abs   0.0154  mean abs 0.00757   (by error, pooled)
+    desire_pred              corr 0.999926  max abs   0.0781  mean abs 0.03278
+    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.09424   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1973  mean abs 0.01472
+    lane_lines               corr 0.999923  max abs   0.1016  mean abs 0.02050
+    lane_lines_prob          corr 0.999851  max abs   0.1992  mean abs 0.06371   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02078
+    lead_prob                corr 1.000000  max abs   0.0381  mean abs 0.03597   (by error, pooled)
+    meta                     corr 0.999879  max abs   0.1069  mean abs 0.03890
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1562  mean abs 0.00626
+    pose                     corr 0.999997  max abs   0.0332  mean abs 0.01122   (by error, pooled)
+    road_edges               corr 0.999909  max abs   0.0762  mean abs 0.02562
+    road_transform           corr 0.999995  max abs   0.0391  mean abs 0.01119   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0273  mean abs 0.01143   (by error, pooled)
+
+frame 89: corr 0.999968  max abs 0.2764
+    action                   corr 0.999955  max abs   0.0205  mean abs 0.01051   (by error, pooled)
+    desire_pred              corr 0.999926  max abs   0.0820  mean abs 0.03086
+    desire_state             corr 0.999993  max abs   0.1523  mean abs 0.05615   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2764  mean abs 0.01343
+    lane_lines               corr 0.999954  max abs   0.0723  mean abs 0.01570
+    lane_lines_prob          corr 0.999981  max abs   0.0487  mean abs 0.02660   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.1250  mean abs 0.01621
+    lead_prob                corr 0.999996  max abs   0.1006  mean abs 0.08167   (by error, pooled)
+    meta                     corr 0.999892  max abs   0.0879  mean abs 0.03854
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00805
+    pose                     corr 0.999994  max abs   0.0254  mean abs 0.00778   (by error, pooled)
+    road_edges               corr 0.999943  max abs   0.0547  mean abs 0.01786
+    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.01035   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0234  mean abs 0.00754   (by error, pooled)
+
+frame 90: corr 0.999954  max abs 0.4531
+    action                   corr 0.999991  max abs   0.0195  mean abs 0.00842   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0898  mean abs 0.02631
+    desire_state             corr 0.999939  max abs   0.1797  mean abs 0.09821   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1084  mean abs 0.01168
+    lane_lines               corr 0.999973  max abs   0.0566  mean abs 0.01503
+    lane_lines_prob          corr 0.999935  max abs   0.1055  mean abs 0.03369   (by error, pooled)
+    lead                     corr 0.999975  max abs   0.4531  mean abs 0.03565
+    lead_prob                corr 0.999992  max abs   0.1172  mean abs 0.09489   (by error, pooled)
+    meta                     corr 0.999906  max abs   0.1152  mean abs 0.04144
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00543
+    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00641   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01678
+    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00587   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00654   (by error, pooled)
+
+frame 91: corr 0.999962  max abs 0.1289
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00372   (by error, pooled)
+    desire_pred              corr 0.999940  max abs   0.0664  mean abs 0.03883
+    desire_state             corr 0.999991  max abs   0.1084  mean abs 0.05154   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1172  mean abs 0.01148
+    lane_lines               corr 0.999970  max abs   0.0684  mean abs 0.01578
+    lane_lines_prob          corr 0.999932  max abs   0.1289  mean abs 0.06403   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.1172  mean abs 0.01015
+    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05021   (by error, pooled)
+    meta                     corr 0.999922  max abs   0.1211  mean abs 0.04145
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00476
+    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00593   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0781  mean abs 0.01442
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00554   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
+
+frame 92: corr 0.999957  max abs 0.2812
+    action                   corr 0.999995  max abs   0.0117  mean abs 0.00358   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0625  mean abs 0.02961
+    desire_state             corr 0.999972  max abs   0.1562  mean abs 0.07922   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1406  mean abs 0.01247
+    lane_lines               corr 0.999979  max abs   0.0508  mean abs 0.01284
+    lane_lines_prob          corr 0.999871  max abs   0.1016  mean abs 0.04956   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.2812  mean abs 0.02249
+    lead_prob                corr 0.999993  max abs   0.1270  mean abs 0.11068   (by error, pooled)
+    meta                     corr 0.999877  max abs   0.1221  mean abs 0.04130
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00477
+    pose                     corr 0.999996  max abs   0.0273  mean abs 0.00755   (by error, pooled)
+    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01250
+    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00717   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.00916   (by error, pooled)
+
+frame 93: corr 0.999964  max abs 0.2656
+    action                   corr 0.999981  max abs   0.0215  mean abs 0.01099   (by error, pooled)
+    desire_pred              corr 0.999945  max abs   0.0742  mean abs 0.02887
+    desire_state             corr 0.999988  max abs   0.2656  mean abs 0.13892   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1895  mean abs 0.01406
+    lane_lines               corr 0.999968  max abs   0.1484  mean abs 0.01591
+    lane_lines_prob          corr 0.999764  max abs   0.1172  mean abs 0.05365   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.2500  mean abs 0.01816
+    lead_prob                corr 0.999967  max abs   0.1289  mean abs 0.10742   (by error, pooled)
+    meta                     corr 0.999924  max abs   0.0586  mean abs 0.02599
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00600
+    pose                     corr 0.999987  max abs   0.0391  mean abs 0.00918   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.1562  mean abs 0.01684
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00882   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0195  mean abs 0.00754   (by error, pooled)
+
+frame 94: corr 0.999953  max abs 0.3281
+    action                   corr 0.999966  max abs   0.0332  mean abs 0.01728   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0576  mean abs 0.02705
+    desire_state             corr 0.999938  max abs   0.3281  mean abs 0.16232   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2441  mean abs 0.01358
+    lane_lines               corr 0.999950  max abs   0.1250  mean abs 0.01747
+    lane_lines_prob          corr 0.999927  max abs   0.1055  mean abs 0.03625   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.2188  mean abs 0.03006
+    lead_prob                corr 0.999986  max abs   0.1157  mean abs 0.08781   (by error, pooled)
+    meta                     corr 0.999953  max abs   0.0781  mean abs 0.03182
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999970  max abs   0.2656  mean abs 0.01275
+    pose                     corr 0.999957  max abs   0.0762  mean abs 0.01822   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0898  mean abs 0.01856
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00948   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
+
+frame 95: corr 0.999938  max abs 0.4082
+    action                   corr 0.999969  max abs   0.0303  mean abs 0.01691   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0879  mean abs 0.02904
+    desire_state             corr 0.999939  max abs   0.4082  mean abs 0.19031   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2344  mean abs 0.01422
+    lane_lines               corr 0.999959  max abs   0.0547  mean abs 0.01523
+    lane_lines_prob          corr 0.999916  max abs   0.1211  mean abs 0.05078   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.3750  mean abs 0.05143
+    lead_prob                corr 0.999944  max abs   0.0874  mean abs 0.06909   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0586  mean abs 0.02371
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999955  max abs   0.3125  mean abs 0.01530
+    pose                     corr 0.999956  max abs   0.0820  mean abs 0.01721   (by error, pooled)
+    road_edges               corr 0.999957  max abs   0.0703  mean abs 0.01671
+    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.00905   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00428   (by error, pooled)
+
+frame 96: corr 0.999974  max abs 0.6875
+    action                   corr 0.999935  max abs   0.0173  mean abs 0.00852   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0781  mean abs 0.02634
+    desire_state             corr 0.999994  max abs   0.1562  mean abs 0.06445   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2266  mean abs 0.01531
+    lane_lines               corr 0.999951  max abs   0.1055  mean abs 0.01672
+    lane_lines_prob          corr 0.999990  max abs   0.0669  mean abs 0.04776   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.6875  mean abs 0.05516
+    lead_prob                corr 0.999996  max abs   0.0723  mean abs 0.06380   (by error, pooled)
+    meta                     corr 0.999932  max abs   0.0693  mean abs 0.02632
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00871
+    pose                     corr 0.999994  max abs   0.0469  mean abs 0.01649   (by error, pooled)
+    road_edges               corr 0.999946  max abs   0.0938  mean abs 0.02024
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01207   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0273  mean abs 0.00922   (by error, pooled)
+
+frame 97: corr 0.999982  max abs 0.4688
+    action                   corr 0.999967  max abs   0.0128  mean abs 0.00407   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0645  mean abs 0.02573
+    desire_state             corr 0.999995  max abs   0.1406  mean abs 0.06787   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1719  mean abs 0.01441
+    lane_lines               corr 0.999932  max abs   0.0606  mean abs 0.01968
+    lane_lines_prob          corr 0.999916  max abs   0.1445  mean abs 0.05452   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.4375  mean abs 0.02955
+    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05046   (by error, pooled)
+    meta                     corr 0.999821  max abs   0.1304  mean abs 0.04943
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.4688  mean abs 0.00954
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00943   (by error, pooled)
+    road_edges               corr 0.999859  max abs   0.1133  mean abs 0.03283
+    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.01045   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0234  mean abs 0.00787   (by error, pooled)
+
+frame 98: corr 0.999965  max abs 0.2734
+    action                   corr 0.999956  max abs   0.0273  mean abs 0.01571   (by error, pooled)
+    desire_pred              corr 0.999915  max abs   0.0781  mean abs 0.03284
+    desire_state             corr 0.999988  max abs   0.2734  mean abs 0.11719   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.2268  mean abs 0.01300
+    lane_lines               corr 0.999953  max abs   0.1113  mean abs 0.01482
+    lane_lines_prob          corr 0.999880  max abs   0.1016  mean abs 0.04564   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.1562  mean abs 0.02120
+    lead_prob                corr 1.000000  max abs   0.1094  mean abs 0.09202   (by error, pooled)
+    meta                     corr 0.999857  max abs   0.1113  mean abs 0.04895
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.0938  mean abs 0.01117
+    pose                     corr 0.999989  max abs   0.0288  mean abs 0.01237   (by error, pooled)
+    road_edges               corr 0.999928  max abs   0.0703  mean abs 0.02029
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00760   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01018   (by error, pooled)
+
+frame 99: corr 0.999963  max abs 0.2969
+    action                   corr 0.999987  max abs   0.0205  mean abs 0.00918   (by error, pooled)
+    desire_pred              corr 0.999938  max abs   0.0840  mean abs 0.03076
+    desire_state             corr 0.999991  max abs   0.2812  mean abs 0.08911   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01180
+    lane_lines               corr 0.999977  max abs   0.0410  mean abs 0.01467
+    lane_lines_prob          corr 0.999966  max abs   0.1289  mean abs 0.05359   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.2969  mean abs 0.02333
+    lead_prob                corr 0.999997  max abs   0.1367  mean abs 0.10441   (by error, pooled)
+    meta                     corr 0.999887  max abs   0.1074  mean abs 0.04481
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00535
+    pose                     corr 0.999995  max abs   0.0210  mean abs 0.00590   (by error, pooled)
+    road_edges               corr 0.999970  max abs   0.0508  mean abs 0.01679
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00702   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00458   (by error, pooled)
+
+frame 100: corr 0.999960  max abs 0.3140
+    action                   corr 0.999999  max abs   0.0068  mean abs 0.00314   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0518  mean abs 0.02459
+    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.03195   (by error, pooled)
+    hidden_state             corr 0.999957  max abs   0.1230  mean abs 0.01118
+    lane_lines               corr 0.999979  max abs   0.0430  mean abs 0.01357
+    lane_lines_prob          corr 0.999985  max abs   0.1094  mean abs 0.05763   (by error, pooled)
+    lead                     corr 0.999643  max abs   0.3140  mean abs 0.02712
+    lead_prob                corr 0.999987  max abs   0.1484  mean abs 0.10547   (by error, pooled)
+    meta                     corr 0.999940  max abs   0.1025  mean abs 0.04166
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00346
+    pose                     corr 0.999996  max abs   0.0202  mean abs 0.00544   (by error, pooled)
+    road_edges               corr 0.999976  max abs   0.0586  mean abs 0.01420
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00505   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0176  mean abs 0.00522   (by error, pooled)
+
+frame 101: corr 0.999937  max abs 0.6641
+    action                   corr 0.999995  max abs   0.0117  mean abs 0.00354   (by error, pooled)
+    desire_pred              corr 0.999969  max abs   0.0518  mean abs 0.02815
+    desire_state             corr 0.999997  max abs   0.2031  mean abs 0.10266   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1328  mean abs 0.01220
+    lane_lines               corr 0.999969  max abs   0.0879  mean abs 0.01564
+    lane_lines_prob          corr 0.999955  max abs   0.1211  mean abs 0.05682   (by error, pooled)
+    lead                     corr 0.999883  max abs   0.6641  mean abs 0.05588
+    lead_prob                corr 0.999992  max abs   0.1055  mean abs 0.09163   (by error, pooled)
+    meta                     corr 0.999959  max abs   0.0684  mean abs 0.02910
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00550
+    pose                     corr 0.999996  max abs   0.0234  mean abs 0.00685   (by error, pooled)
+    road_edges               corr 0.999976  max abs   0.0977  mean abs 0.01863
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00360   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00559   (by error, pooled)
+
+frame 102: corr 0.999960  max abs 0.4375
+    action                   corr 0.999981  max abs   0.0176  mean abs 0.01045   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0625  mean abs 0.02755
+    desire_state             corr 0.999986  max abs   0.2500  mean abs 0.08447   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2061  mean abs 0.01456
+    lane_lines               corr 0.999943  max abs   0.0977  mean abs 0.01675
+    lane_lines_prob          corr 0.999863  max abs   0.1328  mean abs 0.04132   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.4375  mean abs 0.03030
+    lead_prob                corr 0.999967  max abs   0.1816  mean abs 0.15218   (by error, pooled)
+    meta                     corr 0.999813  max abs   0.1104  mean abs 0.03652
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1406  mean abs 0.00664
+    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00640   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.1016  mean abs 0.01384
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00606   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00754   (by error, pooled)
+
+frame 103: corr 0.999953  max abs 0.3125
+    action                   corr 0.999974  max abs   0.0312  mean abs 0.01668   (by error, pooled)
+    desire_pred              corr 0.999972  max abs   0.0547  mean abs 0.01977
+    desire_state             corr 0.999959  max abs   0.3125  mean abs 0.14893   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2480  mean abs 0.01366
+    lane_lines               corr 0.999964  max abs   0.0508  mean abs 0.01451
+    lane_lines_prob          corr 0.999887  max abs   0.0898  mean abs 0.03701   (by error, pooled)
+    lead                     corr 0.999976  max abs   0.1875  mean abs 0.02543
+    lead_prob                corr 0.999992  max abs   0.1816  mean abs 0.14639   (by error, pooled)
+    meta                     corr 0.999946  max abs   0.0645  mean abs 0.02294
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999969  max abs   0.1719  mean abs 0.01478
+    pose                     corr 0.999950  max abs   0.0918  mean abs 0.01696   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0703  mean abs 0.01472
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00523   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00459   (by error, pooled)
+
+frame 104: corr 0.999931  max abs 0.4531
+    action                   corr 0.999925  max abs   0.0488  mean abs 0.02509   (by error, pooled)
+    desire_pred              corr 0.999900  max abs   0.1133  mean abs 0.03461
+    desire_state             corr 0.999958  max abs   0.4531  mean abs 0.17236   (by error, pooled)
+    hidden_state             corr 0.999937  max abs   0.3125  mean abs 0.01452
+    lane_lines               corr 0.999932  max abs   0.1484  mean abs 0.01686
+    lane_lines_prob          corr 0.999916  max abs   0.0781  mean abs 0.03748   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.4219  mean abs 0.05753
+    lead_prob                corr 0.999988  max abs   0.1245  mean abs 0.10400   (by error, pooled)
+    meta                     corr 0.999924  max abs   0.0684  mean abs 0.02939
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999922  max abs   0.3203  mean abs 0.01911
+    pose                     corr 0.999917  max abs   0.1250  mean abs 0.02585   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1367  mean abs 0.01656
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00823   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00626   (by error, pooled)
+
+frame 105: corr 0.999974  max abs 0.5000
+    action                   corr 0.999913  max abs   0.0165  mean abs 0.00865   (by error, pooled)
+    desire_pred              corr 0.999969  max abs   0.0625  mean abs 0.02130
+    desire_state             corr 0.999995  max abs   0.1875  mean abs 0.10400   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01515
+    lane_lines               corr 0.999951  max abs   0.0859  mean abs 0.01761
+    lane_lines_prob          corr 0.999951  max abs   0.1211  mean abs 0.04994   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5000  mean abs 0.04795
+    lead_prob                corr 0.999998  max abs   0.0432  mean abs 0.03849   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0713  mean abs 0.02498
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2188  mean abs 0.00823
+    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01456   (by error, pooled)
+    road_edges               corr 0.999936  max abs   0.1016  mean abs 0.02360
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00979   (by error, pooled)
+    wide_from_device_euler   corr 0.999979  max abs   0.0586  mean abs 0.01897   (by error, pooled)
+
+frame 106: corr 0.999980  max abs 0.2812
+    action                   corr 0.999940  max abs   0.0161  mean abs 0.00698   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03064
+    desire_state             corr 0.999992  max abs   0.2812  mean abs 0.12402   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2051  mean abs 0.01456
+    lane_lines               corr 0.999937  max abs   0.0898  mean abs 0.01915
+    lane_lines_prob          corr 0.999958  max abs   0.1367  mean abs 0.04807   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02541
+    lead_prob                corr 0.999987  max abs   0.0225  mean abs 0.01662   (by error, pooled)
+    meta                     corr 0.999880  max abs   0.0974  mean abs 0.04307
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2188  mean abs 0.00707
+    pose                     corr 0.999998  max abs   0.0371  mean abs 0.01430   (by error, pooled)
+    road_edges               corr 0.999895  max abs   0.0840  mean abs 0.02671
+    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00865   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00527   (by error, pooled)
+
+frame 107: corr 0.999963  max abs 0.2578
+    action                   corr 0.999936  max abs   0.0254  mean abs 0.01272   (by error, pooled)
+    desire_pred              corr 0.999894  max abs   0.0859  mean abs 0.04031
+    desire_state             corr 0.999993  max abs   0.2344  mean abs 0.13184   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2578  mean abs 0.01329
+    lane_lines               corr 0.999950  max abs   0.0684  mean abs 0.01641
+    lane_lines_prob          corr 0.999886  max abs   0.1328  mean abs 0.04726   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2188  mean abs 0.02691
+    lead_prob                corr 0.999999  max abs   0.0918  mean abs 0.08065   (by error, pooled)
+    meta                     corr 0.999884  max abs   0.0938  mean abs 0.04264
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1250  mean abs 0.00996
+    pose                     corr 0.999991  max abs   0.0273  mean abs 0.01014   (by error, pooled)
+    road_edges               corr 0.999945  max abs   0.0547  mean abs 0.01736
+    road_transform           corr 0.999999  max abs   0.0352  mean abs 0.01168   (by error, pooled)
+    wide_from_device_euler   corr 0.999990  max abs   0.0547  mean abs 0.01050   (by error, pooled)
+
+frame 108: corr 0.999953  max abs 0.4531
+    action                   corr 0.999987  max abs   0.0195  mean abs 0.00795   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02743
+    desire_state             corr 0.999997  max abs   0.1406  mean abs 0.09192   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01158
+    lane_lines               corr 0.999943  max abs   0.1113  mean abs 0.01750
+    lane_lines_prob          corr 0.999988  max abs   0.0781  mean abs 0.03223   (by error, pooled)
+    lead                     corr 0.999908  max abs   0.4531  mean abs 0.03446
+    lead_prob                corr 0.999998  max abs   0.1406  mean abs 0.11532   (by error, pooled)
+    meta                     corr 0.999873  max abs   0.1250  mean abs 0.05239
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.0938  mean abs 0.00566
+    pose                     corr 0.999994  max abs   0.0244  mean abs 0.00634   (by error, pooled)
+    road_edges               corr 0.999941  max abs   0.1289  mean abs 0.01927
+    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.00839   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00524   (by error, pooled)
+
+frame 109: corr 0.999954  max abs 0.4180
+    action                   corr 0.999988  max abs   0.0176  mean abs 0.00489   (by error, pooled)
+    desire_pred              corr 0.999974  max abs   0.0513  mean abs 0.02330
+    desire_state             corr 0.999998  max abs   0.1250  mean abs 0.07495   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1328  mean abs 0.01146
+    lane_lines               corr 0.999977  max abs   0.0391  mean abs 0.01328
+    lane_lines_prob          corr 0.999983  max abs   0.0840  mean abs 0.05257   (by error, pooled)
+    lead                     corr 0.999588  max abs   0.4180  mean abs 0.03676
+    lead_prob                corr 0.999994  max abs   0.1133  mean abs 0.08333   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0938  mean abs 0.03899
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0547  mean abs 0.00356
+    pose                     corr 0.999997  max abs   0.0146  mean abs 0.00483   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0664  mean abs 0.01521
+    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00294   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00524   (by error, pooled)
+
+frame 110: corr 0.999944  max abs 0.6172
+    action                   corr 0.999995  max abs   0.0103  mean abs 0.00399   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0469  mean abs 0.02397
+    desire_state             corr 0.999998  max abs   0.1562  mean abs 0.09961   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1367  mean abs 0.01232
+    lane_lines               corr 0.999978  max abs   0.0430  mean abs 0.01240
+    lane_lines_prob          corr 0.999844  max abs   0.1562  mean abs 0.06067   (by error, pooled)
+    lead                     corr 0.999893  max abs   0.6172  mean abs 0.05073
+    lead_prob                corr 1.000000  max abs   0.1172  mean abs 0.09749   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0791  mean abs 0.03100
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00384
+    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00671   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0508  mean abs 0.01545
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00384   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00461   (by error, pooled)
+
+frame 111: corr 0.999959  max abs 0.5312
+    action                   corr 0.999960  max abs   0.0195  mean abs 0.01176   (by error, pooled)
+    desire_pred              corr 0.999920  max abs   0.0840  mean abs 0.03464
+    desire_state             corr 0.999993  max abs   0.2812  mean abs 0.11523   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2031  mean abs 0.01398
+    lane_lines               corr 0.999968  max abs   0.1172  mean abs 0.01418
+    lane_lines_prob          corr 0.999807  max abs   0.1562  mean abs 0.05011   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.5312  mean abs 0.03607
+    lead_prob                corr 0.999997  max abs   0.1406  mean abs 0.12394   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.0845  mean abs 0.03692
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1094  mean abs 0.00736
+    pose                     corr 0.999982  max abs   0.0488  mean abs 0.01071   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.1064  mean abs 0.01599
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00743   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01372   (by error, pooled)
+
+frame 112: corr 0.999948  max abs 0.6094
+    action                   corr 0.999985  max abs   0.0215  mean abs 0.01196   (by error, pooled)
+    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03555
+    desire_state             corr 0.999985  max abs   0.2812  mean abs 0.10107   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1875  mean abs 0.01316
+    lane_lines               corr 0.999961  max abs   0.1016  mean abs 0.01541
+    lane_lines_prob          corr 0.999942  max abs   0.1289  mean abs 0.05780   (by error, pooled)
+    lead                     corr 0.999869  max abs   0.6094  mean abs 0.04577
+    lead_prob                corr 0.999958  max abs   0.1523  mean abs 0.13216   (by error, pooled)
+    meta                     corr 0.999923  max abs   0.0830  mean abs 0.03416
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999989  max abs   0.1406  mean abs 0.00782
+    pose                     corr 0.999979  max abs   0.0488  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999963  max abs   0.1367  mean abs 0.01753
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01037   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0273  mean abs 0.01014   (by error, pooled)
+
+frame 113: corr 0.999945  max abs 0.3906
+    action                   corr 0.999976  max abs   0.0215  mean abs 0.01273   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0742  mean abs 0.02438
+    desire_state             corr 0.999966  max abs   0.3906  mean abs 0.18146   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2207  mean abs 0.01415
+    lane_lines               corr 0.999949  max abs   0.0703  mean abs 0.01507
+    lane_lines_prob          corr 0.999955  max abs   0.1836  mean abs 0.08813   (by error, pooled)
+    lead                     corr 0.999950  max abs   0.3594  mean abs 0.03518
+    lead_prob                corr 0.999997  max abs   0.1204  mean abs 0.10881   (by error, pooled)
+    meta                     corr 0.999959  max abs   0.0859  mean abs 0.02720
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999968  max abs   0.2500  mean abs 0.01138
+    pose                     corr 0.999973  max abs   0.0742  mean abs 0.01349   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0732  mean abs 0.01426
+    road_transform           corr 0.999997  max abs   0.0469  mean abs 0.01157   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0352  mean abs 0.00819   (by error, pooled)
+
+frame 114: corr 0.999977  max abs 0.2500
+    action                   corr 0.999948  max abs   0.0137  mean abs 0.00829   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0723  mean abs 0.02789
+    desire_state             corr 0.999999  max abs   0.0938  mean abs 0.04590   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.2266  mean abs 0.01504
+    lane_lines               corr 0.999955  max abs   0.0742  mean abs 0.01699
+    lane_lines_prob          corr 0.999911  max abs   0.1016  mean abs 0.04504   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02027
+    lead_prob                corr 1.000000  max abs   0.0273  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999923  max abs   0.0771  mean abs 0.02855
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1250  mean abs 0.00655
+    pose                     corr 0.999997  max abs   0.0391  mean abs 0.01290   (by error, pooled)
+    road_edges               corr 0.999938  max abs   0.1055  mean abs 0.02351
+    road_transform           corr 0.999994  max abs   0.0391  mean abs 0.01192   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0312  mean abs 0.01053   (by error, pooled)
+
+frame 115: corr 0.999975  max abs 0.1973
+    action                   corr 0.999970  max abs   0.0099  mean abs 0.00616   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0703  mean abs 0.02835
+    desire_state             corr 0.999996  max abs   0.1875  mean abs 0.05118   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1973  mean abs 0.01474
+    lane_lines               corr 0.999930  max abs   0.0828  mean abs 0.01965
+    lane_lines_prob          corr 0.999954  max abs   0.1484  mean abs 0.05995   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1875  mean abs 0.02071
+    lead_prob                corr 1.000000  max abs   0.0078  mean abs 0.00602   (by error, pooled)
+    meta                     corr 0.999873  max abs   0.0957  mean abs 0.04756
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1406  mean abs 0.00567
+    pose                     corr 0.999997  max abs   0.0312  mean abs 0.01022   (by error, pooled)
+    road_edges               corr 0.999918  max abs   0.0801  mean abs 0.02640
+    road_transform           corr 0.999991  max abs   0.0430  mean abs 0.01060   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00495   (by error, pooled)
+
+frame 116: corr 0.999961  max abs 0.2969
+    action                   corr 0.999985  max abs   0.0215  mean abs 0.01168   (by error, pooled)
+    desire_pred              corr 0.999968  max abs   0.0664  mean abs 0.02393
+    desire_state             corr 0.999998  max abs   0.1094  mean abs 0.04852   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2087  mean abs 0.01298
+    lane_lines               corr 0.999968  max abs   0.0566  mean abs 0.01403
+    lane_lines_prob          corr 0.999986  max abs   0.0347  mean abs 0.01764   (by error, pooled)
+    lead                     corr 0.999980  max abs   0.2969  mean abs 0.02488
+    lead_prob                corr 0.999984  max abs   0.1191  mean abs 0.10319   (by error, pooled)
+    meta                     corr 0.999928  max abs   0.0771  mean abs 0.02890
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00775
+    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00745   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0508  mean abs 0.01542
+    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00904   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00690   (by error, pooled)
+
+frame 117: corr 0.999954  max abs 0.3789
+    action                   corr 0.999992  max abs   0.0166  mean abs 0.00689   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0645  mean abs 0.02583
+    desire_state             corr 0.999997  max abs   0.1445  mean abs 0.05884   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1064  mean abs 0.01166
+    lane_lines               corr 0.999947  max abs   0.0957  mean abs 0.01594
+    lane_lines_prob          corr 0.999974  max abs   0.0898  mean abs 0.03943   (by error, pooled)
+    lead                     corr 0.999884  max abs   0.3789  mean abs 0.02770
+    lead_prob                corr 0.999992  max abs   0.1133  mean abs 0.09017   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0957  mean abs 0.03598
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00442
+    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00573   (by error, pooled)
+    road_edges               corr 0.999919  max abs   0.1562  mean abs 0.02071
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00465   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00556   (by error, pooled)
+
+frame 118: corr 0.999960  max abs 0.2109
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00535   (by error, pooled)
+    desire_pred              corr 0.999964  max abs   0.0527  mean abs 0.02887
+    desire_state             corr 0.999994  max abs   0.1719  mean abs 0.07617   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1348  mean abs 0.01152
+    lane_lines               corr 0.999978  max abs   0.0469  mean abs 0.01234
+    lane_lines_prob          corr 0.999978  max abs   0.1016  mean abs 0.04746   (by error, pooled)
+    lead                     corr 0.999812  max abs   0.2109  mean abs 0.02105
+    lead_prob                corr 1.000000  max abs   0.0488  mean abs 0.03874   (by error, pooled)
+    meta                     corr 0.999942  max abs   0.0977  mean abs 0.03279
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00391
+    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00621   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0586  mean abs 0.01422
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00684   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0195  mean abs 0.00588   (by error, pooled)
+
+frame 119: corr 0.999951  max abs 0.4375
+    action                   corr 0.999996  max abs   0.0098  mean abs 0.00417   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0938  mean abs 0.03431
+    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1328  mean abs 0.01282
+    lane_lines               corr 0.999970  max abs   0.0703  mean abs 0.01402
+    lane_lines_prob          corr 0.999878  max abs   0.1172  mean abs 0.05511   (by error, pooled)
+    lead                     corr 0.999853  max abs   0.4375  mean abs 0.03405
+    lead_prob                corr 0.999991  max abs   0.0811  mean abs 0.06934   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0942  mean abs 0.02893
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00401
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00472   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.0898  mean abs 0.01303
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00474   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00657   (by error, pooled)
+
+frame 120: corr 0.999960  max abs 0.4062
+    action                   corr 0.999989  max abs   0.0176  mean abs 0.00978   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0586  mean abs 0.02430
+    desire_state             corr 0.999991  max abs   0.4062  mean abs 0.12085   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.2031  mean abs 0.01419
+    lane_lines               corr 0.999974  max abs   0.0508  mean abs 0.01306
+    lane_lines_prob          corr 0.999733  max abs   0.1191  mean abs 0.06177   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.2031  mean abs 0.01690
+    lead_prob                corr 0.999973  max abs   0.1289  mean abs 0.10352   (by error, pooled)
+    meta                     corr 0.999857  max abs   0.1025  mean abs 0.03659
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00584
+    pose                     corr 0.999994  max abs   0.0225  mean abs 0.00426   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.1094  mean abs 0.01329
+    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00621   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0215  mean abs 0.00591   (by error, pooled)
+
+frame 121: corr 0.999962  max abs 0.2500
+    action                   corr 0.999990  max abs   0.0156  mean abs 0.00754   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0703  mean abs 0.02387
+    desire_state             corr 0.999997  max abs   0.1250  mean abs 0.07739   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1891  mean abs 0.01339
+    lane_lines               corr 0.999962  max abs   0.0781  mean abs 0.01564
+    lane_lines_prob          corr 0.999968  max abs   0.1016  mean abs 0.03210   (by error, pooled)
+    lead                     corr 0.999974  max abs   0.2500  mean abs 0.02315
+    lead_prob                corr 0.999928  max abs   0.1523  mean abs 0.11491   (by error, pooled)
+    meta                     corr 0.999944  max abs   0.0645  mean abs 0.02519
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0625  mean abs 0.00574
+    pose                     corr 0.999988  max abs   0.0312  mean abs 0.00842   (by error, pooled)
+    road_edges               corr 0.999974  max abs   0.0469  mean abs 0.01429
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00516   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00232   (by error, pooled)
+
+frame 122: corr 0.999948  max abs 0.2969
+    action                   corr 0.999968  max abs   0.0312  mean abs 0.01652   (by error, pooled)
+    desire_pred              corr 0.999927  max abs   0.0703  mean abs 0.03409
+    desire_state             corr 0.999990  max abs   0.1875  mean abs 0.08521   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01412
+    lane_lines               corr 0.999949  max abs   0.1113  mean abs 0.01569
+    lane_lines_prob          corr 0.999798  max abs   0.1562  mean abs 0.05511   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.2500  mean abs 0.03205
+    lead_prob                corr 1.000000  max abs   0.1250  mean abs 0.10596   (by error, pooled)
+    meta                     corr 0.999950  max abs   0.0674  mean abs 0.02443
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999974  max abs   0.2969  mean abs 0.01309
+    pose                     corr 0.999968  max abs   0.0723  mean abs 0.01480   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0664  mean abs 0.01521
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00962   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.01079   (by error, pooled)
+
+frame 123: corr 0.999976  max abs 0.2344
+    action                   corr 0.999952  max abs   0.0132  mean abs 0.00711   (by error, pooled)
+    desire_pred              corr 0.999922  max abs   0.0938  mean abs 0.03134
+    desire_state             corr 0.999997  max abs   0.2344  mean abs 0.12500   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2227  mean abs 0.01535
+    lane_lines               corr 0.999956  max abs   0.1992  mean abs 0.01691
+    lane_lines_prob          corr 0.999977  max abs   0.0742  mean abs 0.03278   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.0938  mean abs 0.01147
+    lead_prob                corr 0.999993  max abs   0.0801  mean abs 0.06852   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0820  mean abs 0.02964
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0938  mean abs 0.00542
+    pose                     corr 0.999996  max abs   0.0391  mean abs 0.01335   (by error, pooled)
+    road_edges               corr 0.999917  max abs   0.1191  mean abs 0.02572
+    road_transform           corr 0.999998  max abs   0.0508  mean abs 0.01346   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0664  mean abs 0.01964   (by error, pooled)
+
+frame 124: corr 0.999980  max abs 0.4375
+    action                   corr 0.999969  max abs   0.0110  mean abs 0.00586   (by error, pooled)
+    desire_pred              corr 0.999933  max abs   0.0781  mean abs 0.02951
+    desire_state             corr 0.999995  max abs   0.2188  mean abs 0.07031   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1875  mean abs 0.01447
+    lane_lines               corr 0.999927  max abs   0.0819  mean abs 0.02048
+    lane_lines_prob          corr 0.999910  max abs   0.1133  mean abs 0.04207   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.4375  mean abs 0.03287
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06250   (by error, pooled)
+    meta                     corr 0.999785  max abs   0.1270  mean abs 0.05262
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00628
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01204   (by error, pooled)
+    road_edges               corr 0.999824  max abs   0.0977  mean abs 0.03520
+    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00906   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00298   (by error, pooled)
+
+frame 125: corr 0.999957  max abs 0.3438
+    action                   corr 0.999962  max abs   0.0244  mean abs 0.01410   (by error, pooled)
+    desire_pred              corr 0.999950  max abs   0.0586  mean abs 0.02645
+    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.09778   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2255  mean abs 0.01294
+    lane_lines               corr 0.999959  max abs   0.0918  mean abs 0.01333
+    lane_lines_prob          corr 0.999903  max abs   0.0923  mean abs 0.05426   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03918
+    lead_prob                corr 0.999986  max abs   0.2031  mean abs 0.16895   (by error, pooled)
+    meta                     corr 0.999932  max abs   0.0703  mean abs 0.03028
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999988  max abs   0.1953  mean abs 0.01131
+    pose                     corr 0.999985  max abs   0.0342  mean abs 0.01261   (by error, pooled)
+    road_edges               corr 0.999922  max abs   0.0938  mean abs 0.02053
+    road_transform           corr 1.000000  max abs   0.0117  mean abs 0.00393   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.00853   (by error, pooled)
+
+frame 126: corr 0.999960  max abs 0.2578
+    action                   corr 0.999991  max abs   0.0156  mean abs 0.00438   (by error, pooled)
+    desire_pred              corr 0.999962  max abs   0.0547  mean abs 0.02731
+    desire_state             corr 0.999994  max abs   0.2188  mean abs 0.07812   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1113  mean abs 0.01155
+    lane_lines               corr 0.999968  max abs   0.0684  mean abs 0.01624
+    lane_lines_prob          corr 0.999971  max abs   0.1133  mean abs 0.04700   (by error, pooled)
+    lead                     corr 0.999937  max abs   0.2578  mean abs 0.02101
+    lead_prob                corr 0.999975  max abs   0.1094  mean abs 0.07161   (by error, pooled)
+    meta                     corr 0.999894  max abs   0.1211  mean abs 0.04689
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00547
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00515   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.1035  mean abs 0.01622
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00253   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0195  mean abs 0.00555   (by error, pooled)
+
+frame 127: corr 0.999965  max abs 0.1562
+    action                   corr 0.999996  max abs   0.0098  mean abs 0.00293   (by error, pooled)
+    desire_pred              corr 0.999952  max abs   0.0625  mean abs 0.03529
+    desire_state             corr 0.999996  max abs   0.1562  mean abs 0.06836   (by error, pooled)
+    hidden_state             corr 0.999957  max abs   0.1289  mean abs 0.01113
+    lane_lines               corr 0.999977  max abs   0.0527  mean abs 0.01463
+    lane_lines_prob          corr 0.999979  max abs   0.1328  mean abs 0.07121   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.0410  mean abs 0.00503
+    lead_prob                corr 1.000000  max abs   0.0938  mean abs 0.08236   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.1123  mean abs 0.03691
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00458
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00642   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0801  mean abs 0.01637
+    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00351   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00623   (by error, pooled)
+
+pooled over 128 frames, per slice and per column:
+    action                   corr 0.999979  by error, max abs 0.04883 <= 0.5352     max abs   0.0488  mean abs 0.00918
+    desire_pred              corr 0.999945  (compared whole)                        max abs   0.1211  mean abs 0.02895
+    desire_state             corr 0.999975  by error, max abs 0.4531 <= 5.253       max abs   0.4531  mean abs 0.08140
+    hidden_state             corr 0.999949  (compared whole)                        max abs   0.3125  mean abs 0.01328
+    lane_lines               corr 0.999954  worst col 0.999855 mu[1]                    max abs   0.2227  mean abs 0.01569
+    lane_lines_prob          corr 0.999883  by error, max abs 0.25 <= 0.7902        max abs   0.2500  mean abs 0.04763
+    lead                     corr 0.999978  worst col 0.999952 mu[0]    (4 by error)    max abs   1.9375  mean abs 0.03572
+    lead_prob                corr 0.999930  by error, max abs 0.2383 <= 0.9055      max abs   0.2383  mean abs 0.07485
+    meta                     corr 0.999907  (compared whole)                        max abs   0.1426  mean abs 0.03486
+    pad                      corr 1.000000  by error, max abs 0 <= 0                max abs   0.0000  mean abs 0.00000
+    plan                     corr 0.999987  worst col 0.999864 std[5]   (10 by error)   max abs   0.5625  mean abs 0.00823
+    pose                     corr 0.999988  no column correlated        (12 by error)   max abs   0.1484  mean abs 0.01025
+    road_edges               corr 0.999947  worst col 0.999837 mu[1]                    max abs   0.1812  mean abs 0.01831
+    road_transform           corr 0.999995  no column correlated        (12 by error)   max abs   0.0586  mean abs 0.00786
+    wide_from_device_euler   corr 0.999993  no column correlated        (6 by error)    max abs   0.0664  mean abs 0.00767
+
+OK: every slice and every column at or above corr 0.999, or within 10% of its largest value where too small or too quiet to correlate, per frame and pooled over all 128 frames
diff --git a/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt b/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
new file mode 100644
index 00000000..4f1c806c
--- /dev/null
+++ b/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
@@ -0,0 +1,2195 @@
+
+frame 0: corr 0.999958  max abs 0.5625
+    action                   corr 0.999995  max abs   0.0254  mean abs 0.00935   (by error, pooled)
+    desire_pred              corr 0.999935  max abs   0.0742  mean abs 0.03164
+    desire_state             corr 0.999999  max abs   0.0352  mean abs 0.01514   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1760  mean abs 0.01292
+    lane_lines               corr 0.999849  max abs   0.1744  mean abs 0.02085
+    lane_lines_prob          corr 0.999929  max abs   0.0820  mean abs 0.03079   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.5625  mean abs 0.06143
+    lead_prob                corr 0.999970  max abs   0.0259  mean abs 0.01986   (by error, pooled)
+    meta                     corr 0.999946  max abs   0.0781  mean abs 0.03238
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.3125  mean abs 0.00838
+    pose                     corr 0.999991  max abs   0.0263  mean abs 0.00968   (by error, pooled)
+    road_edges               corr 0.999897  max abs   0.1812  mean abs 0.02426
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00774   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00722   (by error, pooled)
+
+frame 1: corr 0.999965  max abs 0.5625
+    action                   corr 0.999995  max abs   0.0195  mean abs 0.00592   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0586  mean abs 0.02458
+    desire_state             corr 0.999998  max abs   0.0703  mean abs 0.02783   (by error, pooled)
+    hidden_state             corr 0.999959  max abs   0.1367  mean abs 0.01146
+    lane_lines               corr 0.999973  max abs   0.0723  mean abs 0.01279
+    lane_lines_prob          corr 0.999843  max abs   0.1172  mean abs 0.04391   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.05298
+    lead_prob                corr 0.999970  max abs   0.0149  mean abs 0.01196   (by error, pooled)
+    meta                     corr 0.999965  max abs   0.0723  mean abs 0.03016
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.3125  mean abs 0.00710
+    pose                     corr 0.999990  max abs   0.0325  mean abs 0.00972   (by error, pooled)
+    road_edges               corr 0.999977  max abs   0.0586  mean abs 0.01384
+    road_transform           corr 0.999988  max abs   0.0508  mean abs 0.00994   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00493   (by error, pooled)
+
+frame 2: corr 0.999959  max abs 0.6250
+    action                   corr 0.999999  max abs   0.0078  mean abs 0.00211   (by error, pooled)
+    desire_pred              corr 0.999968  max abs   0.0605  mean abs 0.02356
+    desire_state             corr 0.999993  max abs   0.1016  mean abs 0.03271   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1260  mean abs 0.01132
+    lane_lines               corr 0.999958  max abs   0.0918  mean abs 0.01606
+    lane_lines_prob          corr 0.999901  max abs   0.1445  mean abs 0.05713   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.6250  mean abs 0.06016
+    lead_prob                corr 0.999952  max abs   0.0151  mean abs 0.00798   (by error, pooled)
+    meta                     corr 0.999933  max abs   0.0742  mean abs 0.03206
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.2812  mean abs 0.00562
+    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00661   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0664  mean abs 0.01870
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00669   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00395   (by error, pooled)
+
+frame 3: corr 0.999948  max abs 0.9375
+    action                   corr 0.999999  max abs   0.0137  mean abs 0.00553   (by error, pooled)
+    desire_pred              corr 0.999983  max abs   0.0430  mean abs 0.01556
+    desire_state             corr 0.999982  max abs   0.1562  mean abs 0.04858   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1719  mean abs 0.01187
+    lane_lines               corr 0.999931  max abs   0.1543  mean abs 0.01625
+    lane_lines_prob          corr 0.999935  max abs   0.1602  mean abs 0.07416   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.9375  mean abs 0.09328
+    lead_prob                corr 0.999958  max abs   0.0251  mean abs 0.01619   (by error, pooled)
+    meta                     corr 0.999968  max abs   0.0586  mean abs 0.02109
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999990  max abs   0.3750  mean abs 0.00852
+    pose                     corr 0.999984  max abs   0.0356  mean abs 0.01209   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1445  mean abs 0.01664
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00841   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0293  mean abs 0.00949   (by error, pooled)
+
+frame 4: corr 0.999936  max abs 1.1250
+    action                   corr 0.999990  max abs   0.0293  mean abs 0.01129   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0889  mean abs 0.02840
+    desire_state             corr 0.999994  max abs   0.0781  mean abs 0.02625   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01377
+    lane_lines               corr 0.999962  max abs   0.1016  mean abs 0.01430
+    lane_lines_prob          corr 0.999939  max abs   0.0781  mean abs 0.03470   (by error, pooled)
+    lead                     corr 0.999992  max abs   1.1250  mean abs 0.12237
+    lead_prob                corr 0.998717  max abs   0.0957  mean abs 0.06934   (by error, pooled)
+    meta                     corr 0.999845  max abs   0.1270  mean abs 0.04110
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2500  mean abs 0.00861
+    pose                     corr 0.999979  max abs   0.0527  mean abs 0.01070   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.0781  mean abs 0.01325
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01077   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01534   (by error, pooled)
+
+frame 5: corr 0.999922  max abs 1.2500
+    action                   corr 0.999986  max abs   0.0352  mean abs 0.01266   (by error, pooled)
+    desire_pred              corr 0.999942  max abs   0.0859  mean abs 0.02830
+    desire_state             corr 0.999986  max abs   0.0938  mean abs 0.04843   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1680  mean abs 0.01347
+    lane_lines               corr 0.999954  max abs   0.1211  mean abs 0.01651
+    lane_lines_prob          corr 0.999963  max abs   0.1445  mean abs 0.06146   (by error, pooled)
+    lead                     corr 0.999991  max abs   1.2500  mean abs 0.14001
+    lead_prob                corr 0.998733  max abs   0.0557  mean abs 0.04069   (by error, pooled)
+    meta                     corr 0.999961  max abs   0.0762  mean abs 0.02302
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2188  mean abs 0.00735
+    pose                     corr 0.999984  max abs   0.0352  mean abs 0.01015   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.0703  mean abs 0.02004
+    road_transform           corr 0.999994  max abs   0.0430  mean abs 0.01166   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0254  mean abs 0.00882   (by error, pooled)
+
+frame 6: corr 0.999956  max abs 1.9375
+    action                   corr 0.999984  max abs   0.0303  mean abs 0.01663   (by error, pooled)
+    desire_pred              corr 0.999923  max abs   0.0723  mean abs 0.03256
+    desire_state             corr 0.999981  max abs   0.1797  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999937  max abs   0.2617  mean abs 0.01539
+    lane_lines               corr 0.999922  max abs   0.1406  mean abs 0.01865
+    lane_lines_prob          corr 0.999917  max abs   0.1484  mean abs 0.04865   (by error, pooled)
+    lead                     corr 0.999999  max abs   1.9375  mean abs 0.20451
+    lead_prob                corr 1.000000  max abs   0.0293  mean abs 0.02539   (by error, pooled)
+    meta                     corr 0.999912  max abs   0.0898  mean abs 0.03182
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.5625  mean abs 0.01942
+    pose                     corr 0.999977  max abs   0.1484  mean abs 0.02388   (by error, pooled)
+    road_edges               corr 0.999917  max abs   0.1367  mean abs 0.02554
+    road_transform           corr 0.999996  max abs   0.0547  mean abs 0.01525   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0469  mean abs 0.01279   (by error, pooled)
+
+frame 7: corr 0.999989  max abs 0.3750
+    action                   corr 0.999992  max abs   0.0117  mean abs 0.00634   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0645  mean abs 0.02985
+    desire_state             corr 0.999963  max abs   0.2266  mean abs 0.08472   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2041  mean abs 0.01477
+    lane_lines               corr 0.999930  max abs   0.0663  mean abs 0.01972
+    lane_lines_prob          corr 0.999946  max abs   0.1445  mean abs 0.05638   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.3750  mean abs 0.03846
+    lead_prob                corr 0.998477  max abs   0.0254  mean abs 0.01107   (by error, pooled)
+    meta                     corr 0.999903  max abs   0.0898  mean abs 0.03162
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.1875  mean abs 0.00468
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.01124   (by error, pooled)
+    road_edges               corr 0.999918  max abs   0.0898  mean abs 0.02571
+    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00873   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00268   (by error, pooled)
+
+frame 8: corr 0.999981  max abs 0.5625
+    action                   corr 0.999987  max abs   0.0225  mean abs 0.00929   (by error, pooled)
+    desire_pred              corr 0.999943  max abs   0.0762  mean abs 0.02660
+    desire_state             corr 0.999995  max abs   0.0938  mean abs 0.04443   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2560  mean abs 0.01368
+    lane_lines               corr 0.999960  max abs   0.0439  mean abs 0.01421
+    lane_lines_prob          corr 0.999889  max abs   0.1523  mean abs 0.04752   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06036
+    lead_prob                corr 0.999987  max abs   0.0576  mean abs 0.05111   (by error, pooled)
+    meta                     corr 0.999894  max abs   0.0879  mean abs 0.03913
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0625  mean abs 0.00604
+    pose                     corr 0.999994  max abs   0.0273  mean abs 0.00865   (by error, pooled)
+    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02148
+    road_transform           corr 0.999996  max abs   0.0469  mean abs 0.01174   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0625  mean abs 0.01505   (by error, pooled)
+
+frame 9: corr 0.999973  max abs 0.5625
+    action                   corr 0.999999  max abs   0.0195  mean abs 0.00897   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0586  mean abs 0.02765
+    desire_state             corr 0.999996  max abs   0.1094  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1299  mean abs 0.01198
+    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01406
+    lane_lines_prob          corr 0.999991  max abs   0.0703  mean abs 0.03381   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06239
+    lead_prob                corr 0.999959  max abs   0.0474  mean abs 0.03698   (by error, pooled)
+    meta                     corr 0.999940  max abs   0.0859  mean abs 0.03474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.3750  mean abs 0.00992
+    pose                     corr 0.999994  max abs   0.0220  mean abs 0.00801   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0938  mean abs 0.01654
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00441   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0156  mean abs 0.00653   (by error, pooled)
+
+frame 10: corr 0.999978  max abs 0.2500
+    action                   corr 1.000000  max abs   0.0117  mean abs 0.00580   (by error, pooled)
+    desire_pred              corr 0.999956  max abs   0.0601  mean abs 0.03251
+    desire_state             corr 0.999998  max abs   0.0508  mean abs 0.03198   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.0996  mean abs 0.01128
+    lane_lines               corr 0.999972  max abs   0.0586  mean abs 0.01554
+    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03271   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.2500  mean abs 0.02018
+    lead_prob                corr 0.999886  max abs   0.0420  mean abs 0.03019   (by error, pooled)
+    meta                     corr 0.999935  max abs   0.1050  mean abs 0.03611
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00385
+    pose                     corr 0.999996  max abs   0.0172  mean abs 0.00643   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0586  mean abs 0.01438
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00417   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00426   (by error, pooled)
+
+frame 11: corr 0.999976  max abs 0.2500
+    action                   corr 1.000000  max abs   0.0020  mean abs 0.00052   (by error, pooled)
+    desire_pred              corr 0.999966  max abs   0.0625  mean abs 0.02907
+    desire_state             corr 0.999999  max abs   0.0625  mean abs 0.03687   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1348  mean abs 0.01212
+    lane_lines               corr 0.999965  max abs   0.0859  mean abs 0.01512
+    lane_lines_prob          corr 0.999983  max abs   0.0547  mean abs 0.03186   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.2500  mean abs 0.02342
+    lead_prob                corr 0.999887  max abs   0.0355  mean abs 0.02243   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0869  mean abs 0.03073
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00297
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00640   (by error, pooled)
+    road_edges               corr 0.999965  max abs   0.0801  mean abs 0.01600
+    road_transform           corr 0.999994  max abs   0.0273  mean abs 0.00709   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00430   (by error, pooled)
+
+frame 12: corr 0.999975  max abs 0.4375
+    action                   corr 0.999999  max abs   0.0098  mean abs 0.00491   (by error, pooled)
+    desire_pred              corr 0.999981  max abs   0.0625  mean abs 0.02130
+    desire_state             corr 0.999993  max abs   0.1406  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1543  mean abs 0.01343
+    lane_lines               corr 0.999969  max abs   0.1172  mean abs 0.01423
+    lane_lines_prob          corr 0.999945  max abs   0.0820  mean abs 0.03003   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.4375  mean abs 0.04305
+    lead_prob                corr 0.999977  max abs   0.0791  mean abs 0.06405   (by error, pooled)
+    meta                     corr 0.999881  max abs   0.0850  mean abs 0.03032
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00616
+    pose                     corr 0.999994  max abs   0.0239  mean abs 0.00555   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.1094  mean abs 0.01357
+    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00775   (by error, pooled)
+    wide_from_device_euler   corr 0.999986  max abs   0.0410  mean abs 0.00981   (by error, pooled)
+
+frame 13: corr 0.999963  max abs 0.7500
+    action                   corr 0.999979  max abs   0.0293  mean abs 0.01082   (by error, pooled)
+    desire_pred              corr 0.999881  max abs   0.0918  mean abs 0.04098
+    desire_state             corr 0.999992  max abs   0.1328  mean abs 0.06201   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2285  mean abs 0.01348
+    lane_lines               corr 0.999945  max abs   0.1289  mean abs 0.01795
+    lane_lines_prob          corr 0.999691  max abs   0.1641  mean abs 0.06439   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.7500  mean abs 0.06569
+    lead_prob                corr 0.999548  max abs   0.0918  mean abs 0.07259   (by error, pooled)
+    meta                     corr 0.999852  max abs   0.0889  mean abs 0.03951
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999985  max abs   0.3750  mean abs 0.01534
+    pose                     corr 0.999964  max abs   0.0781  mean abs 0.01469   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.1172  mean abs 0.01816
+    road_transform           corr 0.999999  max abs   0.0391  mean abs 0.01190   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.01145   (by error, pooled)
+
+frame 14: corr 0.999945  max abs 0.9375
+    action                   corr 0.999982  max abs   0.0391  mean abs 0.01599   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03196
+    desire_state             corr 0.999988  max abs   0.2031  mean abs 0.09033   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2109  mean abs 0.01363
+    lane_lines               corr 0.999974  max abs   0.0859  mean abs 0.01198
+    lane_lines_prob          corr 0.999923  max abs   0.1289  mean abs 0.04303   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.9375  mean abs 0.08604
+    lead_prob                corr 0.998518  max abs   0.0938  mean abs 0.07617   (by error, pooled)
+    meta                     corr 0.999948  max abs   0.0625  mean abs 0.02685
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999971  max abs   0.5000  mean abs 0.01917
+    pose                     corr 0.999960  max abs   0.0742  mean abs 0.01417   (by error, pooled)
+    road_edges               corr 0.999941  max abs   0.0781  mean abs 0.01981
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00857   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0312  mean abs 0.00654   (by error, pooled)
+
+frame 15: corr 0.999964  max abs 1.2500
+    action                   corr 0.999983  max abs   0.0176  mean abs 0.00940   (by error, pooled)
+    desire_pred              corr 0.999929  max abs   0.0625  mean abs 0.03351
+    desire_state             corr 0.999991  max abs   0.1641  mean abs 0.10449   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2324  mean abs 0.01531
+    lane_lines               corr 0.999947  max abs   0.1406  mean abs 0.01695
+    lane_lines_prob          corr 0.999976  max abs   0.1367  mean abs 0.06481   (by error, pooled)
+    lead                     corr 0.999999  max abs   1.2500  mean abs 0.12303
+    lead_prob                corr 0.999926  max abs   0.0635  mean abs 0.05813   (by error, pooled)
+    meta                     corr 0.999902  max abs   0.0928  mean abs 0.03267
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2188  mean abs 0.01202
+    pose                     corr 0.999990  max abs   0.1172  mean abs 0.01868   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.1094  mean abs 0.01495
+    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.01289   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0391  mean abs 0.01213   (by error, pooled)
+
+frame 16: corr 0.999982  max abs 0.6250
+    action                   corr 0.999956  max abs   0.0127  mean abs 0.00645   (by error, pooled)
+    desire_pred              corr 0.999934  max abs   0.0723  mean abs 0.03220
+    desire_state             corr 0.999984  max abs   0.1367  mean abs 0.06238   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2305  mean abs 0.01469
+    lane_lines               corr 0.999920  max abs   0.0703  mean abs 0.02025
+    lane_lines_prob          corr 0.999967  max abs   0.1289  mean abs 0.04867   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.6250  mean abs 0.04697
+    lead_prob                corr 0.999966  max abs   0.0566  mean abs 0.03809   (by error, pooled)
+    meta                     corr 0.999876  max abs   0.0957  mean abs 0.03783
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.1250  mean abs 0.00539
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01058   (by error, pooled)
+    road_edges               corr 0.999919  max abs   0.0859  mean abs 0.02313
+    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00425   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00884   (by error, pooled)
+
+frame 17: corr 0.999974  max abs 0.3438
+    action                   corr 0.999987  max abs   0.0176  mean abs 0.00995   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0730  mean abs 0.02846
+    desire_state             corr 0.999996  max abs   0.0781  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2465  mean abs 0.01365
+    lane_lines               corr 0.999956  max abs   0.0781  mean abs 0.01486
+    lane_lines_prob          corr 0.999933  max abs   0.0977  mean abs 0.03257   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01697
+    lead_prob                corr 0.999995  max abs   0.0449  mean abs 0.03735   (by error, pooled)
+    meta                     corr 0.999928  max abs   0.0703  mean abs 0.02939
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999986  max abs   0.3438  mean abs 0.01366
+    pose                     corr 0.999992  max abs   0.0273  mean abs 0.01085   (by error, pooled)
+    road_edges               corr 0.999927  max abs   0.0664  mean abs 0.02052
+    road_transform           corr 0.999998  max abs   0.0469  mean abs 0.01369   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0430  mean abs 0.01115   (by error, pooled)
+
+frame 18: corr 0.999965  max abs 0.5000
+    action                   corr 0.999996  max abs   0.0215  mean abs 0.00996   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0859  mean abs 0.02974
+    desire_state             corr 0.999984  max abs   0.1562  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1289  mean abs 0.01180
+    lane_lines               corr 0.999970  max abs   0.0488  mean abs 0.01406
+    lane_lines_prob          corr 0.999973  max abs   0.0742  mean abs 0.02954   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.5000  mean abs 0.04836
+    lead_prob                corr 0.998951  max abs   0.0811  mean abs 0.06120   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0781  mean abs 0.03228
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.3125  mean abs 0.01052
+    pose                     corr 0.999993  max abs   0.0273  mean abs 0.00879   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0527  mean abs 0.01554
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00458   (by error, pooled)
+
+frame 19: corr 0.999975  max abs 0.1250
+    action                   corr 0.999999  max abs   0.0078  mean abs 0.00311   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0552  mean abs 0.03011
+    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.04626   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.0938  mean abs 0.01092
+    lane_lines               corr 0.999966  max abs   0.0752  mean abs 0.01557
+    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03101   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1250  mean abs 0.01557
+    lead_prob                corr 0.999727  max abs   0.0410  mean abs 0.03109   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.1123  mean abs 0.03805
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0781  mean abs 0.00426
+    pose                     corr 0.999996  max abs   0.0176  mean abs 0.00608   (by error, pooled)
+    road_edges               corr 0.999955  max abs   0.1152  mean abs 0.01849
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00466   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0195  mean abs 0.00459   (by error, pooled)
+
+frame 20: corr 0.999975  max abs 0.2812
+    action                   corr 0.999998  max abs   0.0098  mean abs 0.00377   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0547  mean abs 0.02860
+    desire_state             corr 0.999990  max abs   0.1484  mean abs 0.06494   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1543  mean abs 0.01206
+    lane_lines               corr 0.999976  max abs   0.0605  mean abs 0.01370
+    lane_lines_prob          corr 0.999979  max abs   0.0742  mean abs 0.03647   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2812  mean abs 0.02069
+    lead_prob                corr 0.999753  max abs   0.0480  mean abs 0.04075   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0811  mean abs 0.03298
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0410  mean abs 0.00367
+    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00504   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0820  mean abs 0.01513
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00507   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0273  mean abs 0.00690   (by error, pooled)
+
+frame 21: corr 0.999971  max abs 0.5625
+    action                   corr 0.999993  max abs   0.0176  mean abs 0.00978   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0518  mean abs 0.02562
+    desire_state             corr 0.999990  max abs   0.0703  mean abs 0.04370   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1807  mean abs 0.01358
+    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01265
+    lane_lines_prob          corr 0.999970  max abs   0.0513  mean abs 0.02728   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5625  mean abs 0.04740
+    lead_prob                corr 0.999391  max abs   0.1055  mean abs 0.08830   (by error, pooled)
+    meta                     corr 0.999906  max abs   0.0745  mean abs 0.02863
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.2500  mean abs 0.01053
+    pose                     corr 0.999985  max abs   0.0352  mean abs 0.01017   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.1050  mean abs 0.01557
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00575   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00983   (by error, pooled)
+
+frame 22: corr 0.999969  max abs 0.4268
+    action                   corr 0.999983  max abs   0.0195  mean abs 0.01143   (by error, pooled)
+    desire_pred              corr 0.999962  max abs   0.0459  mean abs 0.02286
+    desire_state             corr 0.999980  max abs   0.1250  mean abs 0.06152   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2227  mean abs 0.01495
+    lane_lines               corr 0.999953  max abs   0.1172  mean abs 0.01816
+    lane_lines_prob          corr 0.999918  max abs   0.0859  mean abs 0.04413   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1875  mean abs 0.02029
+    lead_prob                corr 0.999892  max abs   0.1221  mean abs 0.11019   (by error, pooled)
+    meta                     corr 0.999892  max abs   0.0825  mean abs 0.03034
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.4268  mean abs 0.01207
+    pose                     corr 0.999986  max abs   0.0625  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1484  mean abs 0.02380
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00580   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00493   (by error, pooled)
+
+frame 23: corr 0.999967  max abs 0.3125
+    action                   corr 0.999976  max abs   0.0293  mean abs 0.01263   (by error, pooled)
+    desire_pred              corr 0.999899  max abs   0.1211  mean abs 0.03755
+    desire_state             corr 0.999985  max abs   0.1211  mean abs 0.05103   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1680  mean abs 0.01385
+    lane_lines               corr 0.999970  max abs   0.0898  mean abs 0.01397
+    lane_lines_prob          corr 0.999913  max abs   0.1094  mean abs 0.03763   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.3125  mean abs 0.04054
+    lead_prob                corr 0.999069  max abs   0.0996  mean abs 0.08008   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0625  mean abs 0.02667
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1875  mean abs 0.01065
+    pose                     corr 0.999981  max abs   0.0430  mean abs 0.01038   (by error, pooled)
+    road_edges               corr 0.999970  max abs   0.0664  mean abs 0.01592
+    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.01101   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00721   (by error, pooled)
+
+frame 24: corr 0.999969  max abs 0.6875
+    action                   corr 0.999922  max abs   0.0151  mean abs 0.00975   (by error, pooled)
+    desire_pred              corr 0.999961  max abs   0.0625  mean abs 0.02347
+    desire_state             corr 0.999981  max abs   0.2344  mean abs 0.10645   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2109  mean abs 0.01523
+    lane_lines               corr 0.999950  max abs   0.1641  mean abs 0.01631
+    lane_lines_prob          corr 0.999966  max abs   0.1016  mean abs 0.05735   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.6875  mean abs 0.06699
+    lead_prob                corr 0.996577  max abs   0.0117  mean abs 0.00781   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0645  mean abs 0.02625
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.2188  mean abs 0.00971
+    pose                     corr 0.999992  max abs   0.0859  mean abs 0.01700   (by error, pooled)
+    road_edges               corr 0.999942  max abs   0.1230  mean abs 0.01850
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.01053   (by error, pooled)
+    wide_from_device_euler   corr 0.999989  max abs   0.0312  mean abs 0.01248   (by error, pooled)
+
+frame 25: corr 0.999982  max abs 0.2500
+    action                   corr 0.999981  max abs   0.0068  mean abs 0.00417   (by error, pooled)
+    desire_pred              corr 0.999944  max abs   0.0781  mean abs 0.02817
+    desire_state             corr 0.999991  max abs   0.0859  mean abs 0.05078   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2109  mean abs 0.01473
+    lane_lines               corr 0.999940  max abs   0.0820  mean abs 0.01846
+    lane_lines_prob          corr 0.999904  max abs   0.1289  mean abs 0.05077   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1875  mean abs 0.01383
+    lead_prob                corr 0.998654  max abs   0.0273  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999831  max abs   0.1279  mean abs 0.04345
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2500  mean abs 0.00592
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00996   (by error, pooled)
+    road_edges               corr 0.999938  max abs   0.0957  mean abs 0.02302
+    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.01206   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00624   (by error, pooled)
+
+frame 26: corr 0.999971  max abs 0.3379
+    action                   corr 0.999962  max abs   0.0234  mean abs 0.01273   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0762  mean abs 0.02478
+    desire_state             corr 0.999988  max abs   0.0781  mean abs 0.04614   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2463  mean abs 0.01360
+    lane_lines               corr 0.999934  max abs   0.1152  mean abs 0.01807
+    lane_lines_prob          corr 0.999944  max abs   0.1055  mean abs 0.03624   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.1172  mean abs 0.01570
+    lead_prob                corr 0.999976  max abs   0.0762  mean abs 0.07357   (by error, pooled)
+    meta                     corr 0.999915  max abs   0.0938  mean abs 0.03423
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.3379  mean abs 0.01435
+    pose                     corr 0.999992  max abs   0.0293  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999920  max abs   0.0957  mean abs 0.01895
+    road_transform           corr 0.999989  max abs   0.0586  mean abs 0.01320   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0508  mean abs 0.01084   (by error, pooled)
+
+frame 27: corr 0.999974  max abs 0.2344
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00674   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0840  mean abs 0.02877
+    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.12048   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1123  mean abs 0.01212
+    lane_lines               corr 0.999966  max abs   0.0664  mean abs 0.01772
+    lane_lines_prob          corr 0.999944  max abs   0.1211  mean abs 0.05255   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01196
+    lead_prob                corr 0.998386  max abs   0.1042  mean abs 0.08252   (by error, pooled)
+    meta                     corr 0.999922  max abs   0.0938  mean abs 0.03512
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1562  mean abs 0.00559
+    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00537   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0977  mean abs 0.01668
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00343   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0117  mean abs 0.00427   (by error, pooled)
+
+frame 28: corr 0.999975  max abs 0.3125
+    action                   corr 0.999993  max abs   0.0166  mean abs 0.00888   (by error, pooled)
+    desire_pred              corr 0.999975  max abs   0.0547  mean abs 0.02318
+    desire_state             corr 0.999988  max abs   0.1133  mean abs 0.07367   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1133  mean abs 0.01113
+    lane_lines               corr 0.999960  max abs   0.0977  mean abs 0.01409
+    lane_lines_prob          corr 0.999996  max abs   0.0430  mean abs 0.02063   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3125  mean abs 0.02101
+    lead_prob                corr 0.996397  max abs   0.0938  mean abs 0.07812   (by error, pooled)
+    meta                     corr 0.999967  max abs   0.0801  mean abs 0.02487
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1172  mean abs 0.00626
+    pose                     corr 0.999997  max abs   0.0166  mean abs 0.00535   (by error, pooled)
+    road_edges               corr 0.999956  max abs   0.1523  mean abs 0.01539
+    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.00521   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00262   (by error, pooled)
+
+frame 29: corr 0.999973  max abs 0.2188
+    action                   corr 0.999996  max abs   0.0127  mean abs 0.00696   (by error, pooled)
+    desire_pred              corr 0.999959  max abs   0.0586  mean abs 0.03296
+    desire_state             corr 0.999995  max abs   0.1562  mean abs 0.07239   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01184
+    lane_lines               corr 0.999973  max abs   0.0449  mean abs 0.01383
+    lane_lines_prob          corr 0.999993  max abs   0.1133  mean abs 0.07458   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2188  mean abs 0.01581
+    lead_prob                corr 0.993557  max abs   0.0977  mean abs 0.07812   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0840  mean abs 0.02687
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00604
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00598   (by error, pooled)
+    road_edges               corr 0.999954  max abs   0.1016  mean abs 0.01897
+    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00655   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00886   (by error, pooled)
+
+frame 30: corr 0.999970  max abs 0.2500
+    action                   corr 0.999992  max abs   0.0127  mean abs 0.00661   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02797
+    desire_state             corr 0.999989  max abs   0.1484  mean abs 0.08813   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1660  mean abs 0.01359
+    lane_lines               corr 0.999958  max abs   0.1328  mean abs 0.01609
+    lane_lines_prob          corr 0.999952  max abs   0.0869  mean abs 0.03772   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02438
+    lead_prob                corr 0.999354  max abs   0.1243  mean abs 0.10343   (by error, pooled)
+    meta                     corr 0.999791  max abs   0.1304  mean abs 0.04929
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00752
+    pose                     corr 0.999992  max abs   0.0234  mean abs 0.00691   (by error, pooled)
+    road_edges               corr 0.999963  max abs   0.1719  mean abs 0.01888
+    road_transform           corr 0.999992  max abs   0.0273  mean abs 0.00793   (by error, pooled)
+    wide_from_device_euler   corr 0.999985  max abs   0.0371  mean abs 0.00851   (by error, pooled)
+
+frame 31: corr 0.999970  max abs 0.2188
+    action                   corr 0.999980  max abs   0.0225  mean abs 0.01251   (by error, pooled)
+    desire_pred              corr 0.999933  max abs   0.0664  mean abs 0.02856
+    desire_state             corr 0.999975  max abs   0.1094  mean abs 0.07178   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.2129  mean abs 0.01353
+    lane_lines               corr 0.999958  max abs   0.0820  mean abs 0.01609
+    lane_lines_prob          corr 0.999901  max abs   0.1523  mean abs 0.05202   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.2188  mean abs 0.02764
+    lead_prob                corr 0.998387  max abs   0.1116  mean abs 0.09253   (by error, pooled)
+    meta                     corr 0.999832  max abs   0.1172  mean abs 0.04155
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1250  mean abs 0.00817
+    pose                     corr 0.999979  max abs   0.0547  mean abs 0.01210   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0940  mean abs 0.01712
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00768   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0273  mean abs 0.01210   (by error, pooled)
+
+frame 32: corr 0.999958  max abs 0.1445
+    action                   corr 0.999989  max abs   0.0215  mean abs 0.01032   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03190
+    desire_state             corr 0.999968  max abs   0.1250  mean abs 0.05859   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1445  mean abs 0.01330
+    lane_lines               corr 0.999972  max abs   0.0664  mean abs 0.01441
+    lane_lines_prob          corr 0.999905  max abs   0.1367  mean abs 0.09381   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.1094  mean abs 0.01503
+    lead_prob                corr 0.999998  max abs   0.0508  mean abs 0.03385   (by error, pooled)
+    meta                     corr 0.999972  max abs   0.0547  mean abs 0.02026
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1406  mean abs 0.00554
+    pose                     corr 0.999985  max abs   0.0352  mean abs 0.00878   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0547  mean abs 0.01838
+    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00694   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00592   (by error, pooled)
+
+frame 33: corr 0.999962  max abs 0.8750
+    action                   corr 0.999959  max abs   0.0176  mean abs 0.00947   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0703  mean abs 0.01862
+    desire_state             corr 0.999979  max abs   0.1562  mean abs 0.05762   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2500  mean abs 0.01529
+    lane_lines               corr 0.999955  max abs   0.1133  mean abs 0.01632
+    lane_lines_prob          corr 0.999931  max abs   0.1055  mean abs 0.04333   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.8750  mean abs 0.06872
+    lead_prob                corr 0.999956  max abs   0.0391  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999934  max abs   0.0752  mean abs 0.02529
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.2969  mean abs 0.01298
+    pose                     corr 0.999994  max abs   0.0625  mean abs 0.01658   (by error, pooled)
+    road_edges               corr 0.999960  max abs   0.1016  mean abs 0.01799
+    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00815   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01118   (by error, pooled)
+
+frame 34: corr 0.999979  max abs 0.1963
+    action                   corr 0.999977  max abs   0.0098  mean abs 0.00539   (by error, pooled)
+    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03787
+    desire_state             corr 0.999991  max abs   0.1133  mean abs 0.03394   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1963  mean abs 0.01470
+    lane_lines               corr 0.999939  max abs   0.0742  mean abs 0.01944
+    lane_lines_prob          corr 0.999938  max abs   0.1875  mean abs 0.07463   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01449
+    lead_prob                corr 0.999656  max abs   0.0391  mean abs 0.02604   (by error, pooled)
+    meta                     corr 0.999890  max abs   0.0820  mean abs 0.03731
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1875  mean abs 0.00495
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00991   (by error, pooled)
+    road_edges               corr 0.999935  max abs   0.0654  mean abs 0.02561
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00750   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00332   (by error, pooled)
+
+frame 35: corr 0.999960  max abs 0.3438
+    action                   corr 0.999962  max abs   0.0225  mean abs 0.01250   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0605  mean abs 0.02122
+    desire_state             corr 0.999907  max abs   0.2266  mean abs 0.08117   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2641  mean abs 0.01373
+    lane_lines               corr 0.999954  max abs   0.0684  mean abs 0.01481
+    lane_lines_prob          corr 0.999964  max abs   0.0586  mean abs 0.03961   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03551
+    lead_prob                corr 0.999775  max abs   0.1289  mean abs 0.11133   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.0820  mean abs 0.02702
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.2656  mean abs 0.01050
+    pose                     corr 0.999989  max abs   0.0430  mean abs 0.01239   (by error, pooled)
+    road_edges               corr 0.999960  max abs   0.0547  mean abs 0.01449
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00890   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0586  mean abs 0.01375   (by error, pooled)
+
+frame 36: corr 0.999964  max abs 0.1562
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00779   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.02402
+    desire_state             corr 0.999954  max abs   0.1445  mean abs 0.05359   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01207
+    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01368
+    lane_lines_prob          corr 0.999960  max abs   0.0703  mean abs 0.02673   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.1406  mean abs 0.01257
+    lead_prob                corr 0.999999  max abs   0.1211  mean abs 0.10026   (by error, pooled)
+    meta                     corr 0.999919  max abs   0.1055  mean abs 0.03351
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1562  mean abs 0.00708
+    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00659   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.1152  mean abs 0.01726
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00571   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00621   (by error, pooled)
+
+frame 37: corr 0.999957  max abs 0.3496
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00745   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0566  mean abs 0.02777
+    desire_state             corr 0.999970  max abs   0.1680  mean abs 0.06909   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1162  mean abs 0.01122
+    lane_lines               corr 0.999969  max abs   0.0703  mean abs 0.01477
+    lane_lines_prob          corr 0.999990  max abs   0.0977  mean abs 0.04390   (by error, pooled)
+    lead                     corr 0.999850  max abs   0.3496  mean abs 0.02815
+    lead_prob                corr 0.999963  max abs   0.0664  mean abs 0.05339   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.1074  mean abs 0.03950
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00420
+    pose                     corr 0.999995  max abs   0.0195  mean abs 0.00651   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0742  mean abs 0.01435
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00619   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00489   (by error, pooled)
+
+frame 38: corr 0.999958  max abs 0.2031
+    action                   corr 0.999996  max abs   0.0107  mean abs 0.00541   (by error, pooled)
+    desire_pred              corr 0.999972  max abs   0.0508  mean abs 0.02396
+    desire_state             corr 0.999985  max abs   0.1172  mean abs 0.05750   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1406  mean abs 0.01202
+    lane_lines               corr 0.999966  max abs   0.0898  mean abs 0.01373
+    lane_lines_prob          corr 0.999834  max abs   0.1016  mean abs 0.05020   (by error, pooled)
+    lead                     corr 0.999981  max abs   0.2031  mean abs 0.01509
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06576   (by error, pooled)
+    meta                     corr 0.999912  max abs   0.0977  mean abs 0.04185
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00351
+    pose                     corr 0.999999  max abs   0.0156  mean abs 0.00536   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0977  mean abs 0.01437
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00442   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00266   (by error, pooled)
+
+frame 39: corr 0.999960  max abs 0.6250
+    action                   corr 0.999991  max abs   0.0132  mean abs 0.00716   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.1094  mean abs 0.02056
+    desire_state             corr 0.999984  max abs   0.0996  mean abs 0.02930   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1465  mean abs 0.01390
+    lane_lines               corr 0.999971  max abs   0.0938  mean abs 0.01416
+    lane_lines_prob          corr 0.999846  max abs   0.1211  mean abs 0.04431   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.6250  mean abs 0.04044
+    lead_prob                corr 0.999763  max abs   0.1094  mean abs 0.07975   (by error, pooled)
+    meta                     corr 0.999865  max abs   0.1030  mean abs 0.04137
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00369
+    pose                     corr 0.999994  max abs   0.0186  mean abs 0.00503   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.1250  mean abs 0.01266
+    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00752   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0234  mean abs 0.00624   (by error, pooled)
+
+frame 40: corr 0.999953  max abs 0.3906
+    action                   corr 0.999974  max abs   0.0332  mean abs 0.01743   (by error, pooled)
+    desire_pred              corr 0.999906  max abs   0.0859  mean abs 0.03478
+    desire_state             corr 0.999907  max abs   0.3196  mean abs 0.13505   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2617  mean abs 0.01366
+    lane_lines               corr 0.999937  max abs   0.1445  mean abs 0.01839
+    lane_lines_prob          corr 0.999892  max abs   0.0820  mean abs 0.04476   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.1641  mean abs 0.01987
+    lead_prob                corr 0.999859  max abs   0.1113  mean abs 0.09342   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.0957  mean abs 0.04024
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999964  max abs   0.3906  mean abs 0.01614
+    pose                     corr 0.999949  max abs   0.0918  mean abs 0.01791   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.1250  mean abs 0.01758
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00533   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0156  mean abs 0.00559   (by error, pooled)
+
+frame 41: corr 0.999952  max abs 0.2649
+    action                   corr 0.999977  max abs   0.0273  mean abs 0.01492   (by error, pooled)
+    desire_pred              corr 0.999943  max abs   0.0664  mean abs 0.02870
+    desire_state             corr 0.999941  max abs   0.2649  mean abs 0.12741   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1953  mean abs 0.01348
+    lane_lines               corr 0.999967  max abs   0.0664  mean abs 0.01465
+    lane_lines_prob          corr 0.999892  max abs   0.1211  mean abs 0.05054   (by error, pooled)
+    lead                     corr 0.999983  max abs   0.2500  mean abs 0.01946
+    lead_prob                corr 0.999977  max abs   0.0664  mean abs 0.05632   (by error, pooled)
+    meta                     corr 0.999961  max abs   0.0586  mean abs 0.02646
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999978  max abs   0.2188  mean abs 0.01064
+    pose                     corr 0.999968  max abs   0.0664  mean abs 0.01268   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0664  mean abs 0.01754
+    road_transform           corr 0.999993  max abs   0.0586  mean abs 0.01044   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00557   (by error, pooled)
+
+frame 42: corr 0.999964  max abs 1.0000
+    action                   corr 0.999953  max abs   0.0176  mean abs 0.00957   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0742  mean abs 0.02237
+    desire_state             corr 0.999991  max abs   0.1719  mean abs 0.06738   (by error, pooled)
+    hidden_state             corr 0.999939  max abs   0.2227  mean abs 0.01551
+    lane_lines               corr 0.999949  max abs   0.1641  mean abs 0.01721
+    lane_lines_prob          corr 0.999959  max abs   0.0938  mean abs 0.05408   (by error, pooled)
+    lead                     corr 0.999998  max abs   1.0000  mean abs 0.08374
+    lead_prob                corr 0.999980  max abs   0.0469  mean abs 0.03320   (by error, pooled)
+    meta                     corr 0.999960  max abs   0.0586  mean abs 0.02051
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999990  max abs   0.3750  mean abs 0.01489
+    pose                     corr 0.999992  max abs   0.0938  mean abs 0.01833   (by error, pooled)
+    road_edges               corr 0.999953  max abs   0.0762  mean abs 0.01858
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00704   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0469  mean abs 0.01246   (by error, pooled)
+
+frame 43: corr 0.999981  max abs 0.1992
+    action                   corr 0.999961  max abs   0.0125  mean abs 0.00572   (by error, pooled)
+    desire_pred              corr 0.999924  max abs   0.0879  mean abs 0.03424
+    desire_state             corr 0.999996  max abs   0.1328  mean abs 0.06543   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1992  mean abs 0.01496
+    lane_lines               corr 0.999933  max abs   0.0671  mean abs 0.01937
+    lane_lines_prob          corr 0.999934  max abs   0.1328  mean abs 0.04815   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01052
+    lead_prob                corr 0.999974  max abs   0.0508  mean abs 0.03483   (by error, pooled)
+    meta                     corr 0.999854  max abs   0.1182  mean abs 0.04098
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00588
+    pose                     corr 0.999997  max abs   0.0352  mean abs 0.01159   (by error, pooled)
+    road_edges               corr 0.999912  max abs   0.1035  mean abs 0.02590
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.01020   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0059  mean abs 0.00200   (by error, pooled)
+
+frame 44: corr 0.999961  max abs 0.3125
+    action                   corr 0.999956  max abs   0.0234  mean abs 0.01290   (by error, pooled)
+    desire_pred              corr 0.999867  max abs   0.0938  mean abs 0.04165
+    desire_state             corr 0.999985  max abs   0.2422  mean abs 0.05908   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2340  mean abs 0.01324
+    lane_lines               corr 0.999964  max abs   0.0625  mean abs 0.01566
+    lane_lines_prob          corr 0.999985  max abs   0.0859  mean abs 0.04950   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.3125  mean abs 0.02699
+    lead_prob                corr 0.999996  max abs   0.0879  mean abs 0.08333   (by error, pooled)
+    meta                     corr 0.999895  max abs   0.0820  mean abs 0.03589
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999979  max abs   0.2891  mean abs 0.01164
+    pose                     corr 0.999988  max abs   0.0312  mean abs 0.01193   (by error, pooled)
+    road_edges               corr 0.999947  max abs   0.0664  mean abs 0.01609
+    road_transform           corr 0.999998  max abs   0.0430  mean abs 0.01035   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0391  mean abs 0.01245   (by error, pooled)
+
+frame 45: corr 0.999960  max abs 0.2188
+    action                   corr 0.999986  max abs   0.0215  mean abs 0.01061   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0684  mean abs 0.02888
+    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.08240   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1289  mean abs 0.01152
+    lane_lines               corr 0.999971  max abs   0.0386  mean abs 0.01310
+    lane_lines_prob          corr 0.999984  max abs   0.1055  mean abs 0.03467   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0625  mean abs 0.00760
+    lead_prob                corr 0.999935  max abs   0.1196  mean abs 0.10030   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.1250  mean abs 0.04695
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999980  max abs   0.2188  mean abs 0.00956
+    pose                     corr 0.999992  max abs   0.0259  mean abs 0.00762   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.0547  mean abs 0.01518
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00335   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0098  mean abs 0.00296   (by error, pooled)
+
+frame 46: corr 0.999949  max abs 0.5820
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00638   (by error, pooled)
+    desire_pred              corr 0.999979  max abs   0.0488  mean abs 0.02080
+    desire_state             corr 0.999981  max abs   0.1047  mean abs 0.04221   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1211  mean abs 0.01127
+    lane_lines               corr 0.999982  max abs   0.0371  mean abs 0.01206
+    lane_lines_prob          corr 0.999974  max abs   0.0977  mean abs 0.03348   (by error, pooled)
+    lead                     corr 0.999142  max abs   0.5820  mean abs 0.03989
+    lead_prob                corr 0.999995  max abs   0.1250  mean abs 0.10645   (by error, pooled)
+    meta                     corr 0.999931  max abs   0.0957  mean abs 0.03604
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00399
+    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00574   (by error, pooled)
+    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01141
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00580   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00620   (by error, pooled)
+
+frame 47: corr 0.999940  max abs 0.6406
+    action                   corr 0.999993  max abs   0.0137  mean abs 0.00554   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0625  mean abs 0.03202
+    desire_state             corr 0.999962  max abs   0.2131  mean abs 0.06779   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1309  mean abs 0.01206
+    lane_lines               corr 0.999979  max abs   0.0762  mean abs 0.01445
+    lane_lines_prob          corr 0.999939  max abs   0.1367  mean abs 0.07001   (by error, pooled)
+    lead                     corr 0.999672  max abs   0.6406  mean abs 0.04770
+    lead_prob                corr 0.999975  max abs   0.0820  mean abs 0.06803   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0898  mean abs 0.03575
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0225  mean abs 0.00445
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00622   (by error, pooled)
+    road_edges               corr 0.999949  max abs   0.0781  mean abs 0.01724
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00491   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00885   (by error, pooled)
+
+frame 48: corr 0.999957  max abs 0.6250
+    action                   corr 0.999982  max abs   0.0195  mean abs 0.01069   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.0625  mean abs 0.02208
+    desire_state             corr 0.999986  max abs   0.1328  mean abs 0.05737   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1494  mean abs 0.01378
+    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01422
+    lane_lines_prob          corr 0.999956  max abs   0.0977  mean abs 0.04120   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.6250  mean abs 0.04285
+    lead_prob                corr 0.999936  max abs   0.1133  mean abs 0.09619   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.0902  mean abs 0.03599
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.1875  mean abs 0.00748
+    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00550   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.1250  mean abs 0.01621
+    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00393   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00656   (by error, pooled)
+
+frame 49: corr 0.999953  max abs 0.4375
+    action                   corr 0.999980  max abs   0.0293  mean abs 0.01551   (by error, pooled)
+    desire_pred              corr 0.999976  max abs   0.0508  mean abs 0.01759
+    desire_state             corr 0.999958  max abs   0.2617  mean abs 0.10352   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2109  mean abs 0.01310
+    lane_lines               corr 0.999950  max abs   0.0977  mean abs 0.01608
+    lane_lines_prob          corr 0.999894  max abs   0.1172  mean abs 0.04683   (by error, pooled)
+    lead                     corr 0.999969  max abs   0.4375  mean abs 0.03150
+    lead_prob                corr 0.999853  max abs   0.0996  mean abs 0.07861   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0859  mean abs 0.02841
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999973  max abs   0.1660  mean abs 0.01430
+    pose                     corr 0.999979  max abs   0.0410  mean abs 0.01245   (by error, pooled)
+    road_edges               corr 0.999964  max abs   0.1055  mean abs 0.01792
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00677   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0234  mean abs 0.00919   (by error, pooled)
+
+frame 50: corr 0.999943  max abs 0.5234
+    action                   corr 0.999964  max abs   0.0322  mean abs 0.01672   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03007
+    desire_state             corr 0.999955  max abs   0.2969  mean abs 0.10749   (by error, pooled)
+    hidden_state             corr 0.999946  max abs   0.1875  mean abs 0.01355
+    lane_lines               corr 0.999968  max abs   0.0898  mean abs 0.01383
+    lane_lines_prob          corr 0.999863  max abs   0.1758  mean abs 0.06085   (by error, pooled)
+    lead                     corr 0.999869  max abs   0.5234  mean abs 0.03819
+    lead_prob                corr 0.999837  max abs   0.1289  mean abs 0.10059   (by error, pooled)
+    meta                     corr 0.999929  max abs   0.0820  mean abs 0.03109
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999969  max abs   0.1680  mean abs 0.01198
+    pose                     corr 0.999969  max abs   0.0645  mean abs 0.01497   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.0762  mean abs 0.01593
+    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00938   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0098  mean abs 0.00296   (by error, pooled)
+
+frame 51: corr 0.999965  max abs 1.0000
+    action                   corr 0.999955  max abs   0.0171  mean abs 0.00784   (by error, pooled)
+    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02560
+    desire_state             corr 0.999986  max abs   0.2344  mean abs 0.11670   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2461  mean abs 0.01509
+    lane_lines               corr 0.999951  max abs   0.0938  mean abs 0.01672
+    lane_lines_prob          corr 0.999965  max abs   0.0923  mean abs 0.04596   (by error, pooled)
+    lead                     corr 0.999997  max abs   1.0000  mean abs 0.07913
+    lead_prob                corr 0.999973  max abs   0.0742  mean abs 0.04818   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0635  mean abs 0.02527
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2812  mean abs 0.01103
+    pose                     corr 0.999996  max abs   0.0625  mean abs 0.01496   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0859  mean abs 0.01813
+    road_transform           corr 0.999997  max abs   0.0391  mean abs 0.00987   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0352  mean abs 0.00953   (by error, pooled)
+
+frame 52: corr 0.999978  max abs 0.2012
+    action                   corr 0.999939  max abs   0.0176  mean abs 0.00873   (by error, pooled)
+    desire_pred              corr 0.999917  max abs   0.0859  mean abs 0.03464
+    desire_state             corr 0.999988  max abs   0.1250  mean abs 0.07446   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2012  mean abs 0.01484
+    lane_lines               corr 0.999930  max abs   0.0728  mean abs 0.01964
+    lane_lines_prob          corr 0.999950  max abs   0.0859  mean abs 0.04348   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01256
+    lead_prob                corr 0.999933  max abs   0.0420  mean abs 0.02441   (by error, pooled)
+    meta                     corr 0.999891  max abs   0.0859  mean abs 0.04246
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1094  mean abs 0.00555
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00976   (by error, pooled)
+    road_edges               corr 0.999877  max abs   0.1211  mean abs 0.03057
+    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00986   (by error, pooled)
+    wide_from_device_euler   corr 0.999987  max abs   0.0293  mean abs 0.00785   (by error, pooled)
+
+frame 53: corr 0.999953  max abs 0.3594
+    action                   corr 0.999955  max abs   0.0264  mean abs 0.01454   (by error, pooled)
+    desire_pred              corr 0.999863  max abs   0.0909  mean abs 0.04372
+    desire_state             corr 0.999980  max abs   0.1289  mean abs 0.09619   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.2233  mean abs 0.01320
+    lane_lines               corr 0.999966  max abs   0.0430  mean abs 0.01369
+    lane_lines_prob          corr 0.999981  max abs   0.0898  mean abs 0.04086   (by error, pooled)
+    lead                     corr 0.999975  max abs   0.3594  mean abs 0.03772
+    lead_prob                corr 1.000000  max abs   0.1113  mean abs 0.10026   (by error, pooled)
+    meta                     corr 0.999829  max abs   0.1133  mean abs 0.04773
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999965  max abs   0.3359  mean abs 0.01300
+    pose                     corr 0.999988  max abs   0.0337  mean abs 0.01259   (by error, pooled)
+    road_edges               corr 0.999928  max abs   0.0664  mean abs 0.02024
+    road_transform           corr 0.999998  max abs   0.0391  mean abs 0.00905   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0664  mean abs 0.01831   (by error, pooled)
+
+frame 54: corr 0.999957  max abs 0.2812
+    action                   corr 0.999996  max abs   0.0107  mean abs 0.00582   (by error, pooled)
+    desire_pred              corr 0.999951  max abs   0.0625  mean abs 0.03176
+    desire_state             corr 0.999988  max abs   0.0859  mean abs 0.04181   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1094  mean abs 0.01179
+    lane_lines               corr 0.999965  max abs   0.0625  mean abs 0.01655
+    lane_lines_prob          corr 0.999982  max abs   0.1602  mean abs 0.07764   (by error, pooled)
+    lead                     corr 0.999964  max abs   0.2812  mean abs 0.02281
+    lead_prob                corr 0.999936  max abs   0.1270  mean abs 0.10685   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0977  mean abs 0.04134
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0508  mean abs 0.00573
+    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00550   (by error, pooled)
+    road_edges               corr 0.999951  max abs   0.0938  mean abs 0.01782
+    road_transform           corr 0.999994  max abs   0.0352  mean abs 0.00506   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0117  mean abs 0.00426   (by error, pooled)
+
+frame 55: corr 0.999957  max abs 0.3438
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00665   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0664  mean abs 0.02021
+    desire_state             corr 0.999981  max abs   0.0703  mean abs 0.04671   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1152  mean abs 0.01115
+    lane_lines               corr 0.999975  max abs   0.0664  mean abs 0.01440
+    lane_lines_prob          corr 0.999967  max abs   0.1172  mean abs 0.04901   (by error, pooled)
+    lead                     corr 0.999812  max abs   0.3438  mean abs 0.02753
+    lead_prob                corr 0.999817  max abs   0.1270  mean abs 0.09538   (by error, pooled)
+    meta                     corr 0.999947  max abs   0.0879  mean abs 0.03769
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00460
+    pose                     corr 0.999997  max abs   0.0137  mean abs 0.00518   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0742  mean abs 0.01324
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00457   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0137  mean abs 0.00523   (by error, pooled)
+
+frame 56: corr 0.999956  max abs 0.2725
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00525   (by error, pooled)
+    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02641
+    desire_state             corr 0.999997  max abs   0.0781  mean abs 0.03787   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01219
+    lane_lines               corr 0.999980  max abs   0.0566  mean abs 0.01184
+    lane_lines_prob          corr 0.999868  max abs   0.0801  mean abs 0.04492   (by error, pooled)
+    lead                     corr 0.999601  max abs   0.2725  mean abs 0.02176
+    lead_prob                corr 0.999846  max abs   0.1016  mean abs 0.07747   (by error, pooled)
+    meta                     corr 0.999915  max abs   0.0918  mean abs 0.03517
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0645  mean abs 0.00431
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00586   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0820  mean abs 0.01239
+    road_transform           corr 0.999995  max abs   0.0273  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0312  mean abs 0.01176   (by error, pooled)
+
+frame 57: corr 0.999956  max abs 0.3750
+    action                   corr 0.999985  max abs   0.0181  mean abs 0.00963   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0840  mean abs 0.03075
+    desire_state             corr 0.999990  max abs   0.1641  mean abs 0.07544   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1709  mean abs 0.01410
+    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01614
+    lane_lines_prob          corr 0.999859  max abs   0.1719  mean abs 0.06293   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.3750  mean abs 0.02853
+    lead_prob                corr 0.999945  max abs   0.0859  mean abs 0.07056   (by error, pooled)
+    meta                     corr 0.999730  max abs   0.1221  mean abs 0.04862
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00455
+    pose                     corr 0.999991  max abs   0.0264  mean abs 0.00733   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.1484  mean abs 0.01666
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00581   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00560   (by error, pooled)
+
+frame 58: corr 0.999957  max abs 0.2344
+    action                   corr 0.999990  max abs   0.0176  mean abs 0.00778   (by error, pooled)
+    desire_pred              corr 0.999951  max abs   0.0820  mean abs 0.02925
+    desire_state             corr 0.999976  max abs   0.2344  mean abs 0.08923   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1797  mean abs 0.01294
+    lane_lines               corr 0.999962  max abs   0.0898  mean abs 0.01531
+    lane_lines_prob          corr 0.999956  max abs   0.1406  mean abs 0.04791   (by error, pooled)
+    lead                     corr 0.999965  max abs   0.2266  mean abs 0.01826
+    lead_prob                corr 0.999449  max abs   0.1094  mean abs 0.08789   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0840  mean abs 0.02789
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999989  max abs   0.1172  mean abs 0.00709
+    pose                     corr 0.999986  max abs   0.0332  mean abs 0.00896   (by error, pooled)
+    road_edges               corr 0.999958  max abs   0.0762  mean abs 0.01881
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00638   (by error, pooled)
+    wide_from_device_euler   corr 0.999990  max abs   0.0273  mean abs 0.00886   (by error, pooled)
+
+frame 59: corr 0.999930  max abs 0.4062
+    action                   corr 0.999972  max abs   0.0303  mean abs 0.01643   (by error, pooled)
+    desire_pred              corr 0.999927  max abs   0.0918  mean abs 0.03131
+    desire_state             corr 0.999944  max abs   0.3750  mean abs 0.15173   (by error, pooled)
+    hidden_state             corr 0.999942  max abs   0.2227  mean abs 0.01407
+    lane_lines               corr 0.999958  max abs   0.1094  mean abs 0.01538
+    lane_lines_prob          corr 0.999842  max abs   0.1602  mean abs 0.06467   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.4062  mean abs 0.05356
+    lead_prob                corr 0.999797  max abs   0.0723  mean abs 0.05273   (by error, pooled)
+    meta                     corr 0.999951  max abs   0.0879  mean abs 0.02836
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999951  max abs   0.2422  mean abs 0.01267
+    pose                     corr 0.999965  max abs   0.0664  mean abs 0.01563   (by error, pooled)
+    road_edges               corr 0.999949  max abs   0.0859  mean abs 0.01721
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00628   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00719   (by error, pooled)
+
+frame 60: corr 0.999953  max abs 1.0000
+    action                   corr 0.999916  max abs   0.0254  mean abs 0.01387   (by error, pooled)
+    desire_pred              corr 0.999965  max abs   0.0684  mean abs 0.02454
+    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.05286   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2129  mean abs 0.01532
+    lane_lines               corr 0.999956  max abs   0.0664  mean abs 0.01584
+    lane_lines_prob          corr 0.999989  max abs   0.1016  mean abs 0.04890   (by error, pooled)
+    lead                     corr 0.999992  max abs   1.0000  mean abs 0.07129
+    lead_prob                corr 0.999970  max abs   0.0234  mean abs 0.01530   (by error, pooled)
+    meta                     corr 0.999944  max abs   0.0752  mean abs 0.02185
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999975  max abs   0.3750  mean abs 0.01604
+    pose                     corr 0.999991  max abs   0.0859  mean abs 0.01885   (by error, pooled)
+    road_edges               corr 0.999929  max abs   0.0938  mean abs 0.02242
+    road_transform           corr 0.999997  max abs   0.0508  mean abs 0.01206   (by error, pooled)
+    wide_from_device_euler   corr 0.999986  max abs   0.0449  mean abs 0.01542   (by error, pooled)
+
+frame 61: corr 0.999977  max abs 0.1719
+    action                   corr 0.999976  max abs   0.0110  mean abs 0.00571   (by error, pooled)
+    desire_pred              corr 0.999891  max abs   0.0957  mean abs 0.03925
+    desire_state             corr 0.999997  max abs   0.1094  mean abs 0.04929   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1719  mean abs 0.01461
+    lane_lines               corr 0.999884  max abs   0.1038  mean abs 0.02350
+    lane_lines_prob          corr 0.999950  max abs   0.1133  mean abs 0.05789   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.0625  mean abs 0.00837
+    lead_prob                corr 0.999996  max abs   0.0300  mean abs 0.01326   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.0898  mean abs 0.04400
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1328  mean abs 0.00503
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00992   (by error, pooled)
+    road_edges               corr 0.999869  max abs   0.1055  mean abs 0.03016
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01394   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00525   (by error, pooled)
+
+frame 62: corr 0.999960  max abs 0.3125
+    action                   corr 0.999978  max abs   0.0215  mean abs 0.01225   (by error, pooled)
+    desire_pred              corr 0.999932  max abs   0.0781  mean abs 0.02914
+    desire_state             corr 0.999993  max abs   0.1836  mean abs 0.09161   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2567  mean abs 0.01361
+    lane_lines               corr 0.999948  max abs   0.0547  mean abs 0.01539
+    lane_lines_prob          corr 0.999908  max abs   0.1406  mean abs 0.04785   (by error, pooled)
+    lead                     corr 0.999991  max abs   0.2812  mean abs 0.02750
+    lead_prob                corr 0.999994  max abs   0.1069  mean abs 0.08285   (by error, pooled)
+    meta                     corr 0.999832  max abs   0.1113  mean abs 0.04802
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999967  max abs   0.3125  mean abs 0.01284
+    pose                     corr 0.999995  max abs   0.0234  mean abs 0.00736   (by error, pooled)
+    road_edges               corr 0.999888  max abs   0.0762  mean abs 0.02576
+    road_transform           corr 0.999996  max abs   0.0586  mean abs 0.01589   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0625  mean abs 0.01701   (by error, pooled)
+
+frame 63: corr 0.999957  max abs 0.2812
+    action                   corr 0.999994  max abs   0.0146  mean abs 0.00650   (by error, pooled)
+    desire_pred              corr 0.999947  max abs   0.0625  mean abs 0.03246
+    desire_state             corr 0.999977  max abs   0.2812  mean abs 0.15918   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1172  mean abs 0.01182
+    lane_lines               corr 0.999977  max abs   0.0488  mean abs 0.01284
+    lane_lines_prob          corr 0.999981  max abs   0.0742  mean abs 0.03076   (by error, pooled)
+    lead                     corr 0.999970  max abs   0.2188  mean abs 0.01843
+    lead_prob                corr 0.999815  max abs   0.1631  mean abs 0.13082   (by error, pooled)
+    meta                     corr 0.999893  max abs   0.1172  mean abs 0.04738
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0781  mean abs 0.00548
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00508   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0703  mean abs 0.01408
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00530   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00687   (by error, pooled)
+
+frame 64: corr 0.999965  max abs 0.1797
+    action                   corr 0.999996  max abs   0.0137  mean abs 0.00573   (by error, pooled)
+    desire_pred              corr 0.999971  max abs   0.0586  mean abs 0.02530
+    desire_state             corr 0.999986  max abs   0.1797  mean abs 0.10046   (by error, pooled)
+    hidden_state             corr 0.999958  max abs   0.1094  mean abs 0.01099
+    lane_lines               corr 0.999959  max abs   0.0820  mean abs 0.01630
+    lane_lines_prob          corr 0.999910  max abs   0.1094  mean abs 0.04137   (by error, pooled)
+    lead                     corr 0.999964  max abs   0.1328  mean abs 0.00961
+    lead_prob                corr 0.999999  max abs   0.0703  mean abs 0.06543   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0908  mean abs 0.03479
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00662
+    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00592   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.1016  mean abs 0.01671
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00400   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00458   (by error, pooled)
+
+frame 65: corr 0.999955  max abs 0.3066
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00378   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0820  mean abs 0.03578
+    desire_state             corr 0.999981  max abs   0.2109  mean abs 0.08820   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1289  mean abs 0.01225
+    lane_lines               corr 0.999969  max abs   0.0742  mean abs 0.01382
+    lane_lines_prob          corr 0.999911  max abs   0.0781  mean abs 0.03632   (by error, pooled)
+    lead                     corr 0.999721  max abs   0.3066  mean abs 0.02560
+    lead_prob                corr 0.999990  max abs   0.0859  mean abs 0.06999   (by error, pooled)
+    meta                     corr 0.999897  max abs   0.1035  mean abs 0.04263
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0278  mean abs 0.00595
+    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00621   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0918  mean abs 0.01782
+    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00547   (by error, pooled)
+    wide_from_device_euler   corr 0.999987  max abs   0.0391  mean abs 0.01046   (by error, pooled)
+
+frame 66: corr 0.999963  max abs 0.2500
+    action                   corr 0.999981  max abs   0.0215  mean abs 0.01265   (by error, pooled)
+    desire_pred              corr 0.999946  max abs   0.0625  mean abs 0.02707
+    desire_state             corr 0.999988  max abs   0.2500  mean abs 0.10840   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.2002  mean abs 0.01356
+    lane_lines               corr 0.999966  max abs   0.1387  mean abs 0.01399
+    lane_lines_prob          corr 0.999910  max abs   0.0793  mean abs 0.04556   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.1328  mean abs 0.01790
+    lead_prob                corr 0.999748  max abs   0.1641  mean abs 0.10872   (by error, pooled)
+    meta                     corr 0.999933  max abs   0.0657  mean abs 0.02508
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.0625  mean abs 0.00973
+    pose                     corr 0.999984  max abs   0.0410  mean abs 0.01082   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.1250  mean abs 0.01564
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00556   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00655   (by error, pooled)
+
+frame 67: corr 0.999957  max abs 0.2344
+    action                   corr 0.999978  max abs   0.0273  mean abs 0.01236   (by error, pooled)
+    desire_pred              corr 0.999907  max abs   0.0820  mean abs 0.03851
+    desire_state             corr 0.999987  max abs   0.1875  mean abs 0.09302   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1855  mean abs 0.01315
+    lane_lines               corr 0.999942  max abs   0.1328  mean abs 0.01776
+    lane_lines_prob          corr 0.999937  max abs   0.1094  mean abs 0.02963   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.1875  mean abs 0.02484
+    lead_prob                corr 0.999982  max abs   0.1445  mean abs 0.12012   (by error, pooled)
+    meta                     corr 0.999887  max abs   0.0977  mean abs 0.03546
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999984  max abs   0.2344  mean abs 0.01087
+    pose                     corr 0.999981  max abs   0.0391  mean abs 0.01217   (by error, pooled)
+    road_edges               corr 0.999946  max abs   0.1016  mean abs 0.01812
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00768   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0293  mean abs 0.00722   (by error, pooled)
+
+frame 68: corr 0.999950  max abs 0.2148
+    action                   corr 0.999973  max abs   0.0332  mean abs 0.01659   (by error, pooled)
+    desire_pred              corr 0.999921  max abs   0.0742  mean abs 0.03478
+    desire_state             corr 0.999979  max abs   0.2109  mean abs 0.10840   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.2148  mean abs 0.01354
+    lane_lines               corr 0.999962  max abs   0.0566  mean abs 0.01385
+    lane_lines_prob          corr 0.999875  max abs   0.1016  mean abs 0.04523   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.2031  mean abs 0.02641
+    lead_prob                corr 0.999954  max abs   0.1250  mean abs 0.09928   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0547  mean abs 0.02170
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999975  max abs   0.1641  mean abs 0.01313
+    pose                     corr 0.999970  max abs   0.0566  mean abs 0.01544   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0781  mean abs 0.01303
+    road_transform           corr 0.999993  max abs   0.0430  mean abs 0.00872   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00362   (by error, pooled)
+
+frame 69: corr 0.999968  max abs 0.5625
+    action                   corr 0.999962  max abs   0.0151  mean abs 0.00745   (by error, pooled)
+    desire_pred              corr 0.999940  max abs   0.0938  mean abs 0.02908
+    desire_state             corr 0.999984  max abs   0.1719  mean abs 0.09521   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.1953  mean abs 0.01517
+    lane_lines               corr 0.999940  max abs   0.0938  mean abs 0.01824
+    lane_lines_prob          corr 0.999938  max abs   0.1445  mean abs 0.05496   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5625  mean abs 0.05521
+    lead_prob                corr 0.999977  max abs   0.0684  mean abs 0.05176   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0840  mean abs 0.02844
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2031  mean abs 0.00985
+    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01493   (by error, pooled)
+    road_edges               corr 0.999904  max abs   0.1094  mean abs 0.02694
+    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.00889   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0352  mean abs 0.01180   (by error, pooled)
+
+frame 70: corr 0.999977  max abs 0.3125
+    action                   corr 0.999972  max abs   0.0129  mean abs 0.00566   (by error, pooled)
+    desire_pred              corr 0.999886  max abs   0.1113  mean abs 0.04156
+    desire_state             corr 0.999998  max abs   0.1016  mean abs 0.05786   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1758  mean abs 0.01456
+    lane_lines               corr 0.999905  max abs   0.0802  mean abs 0.02389
+    lane_lines_prob          corr 0.999826  max abs   0.2500  mean abs 0.09526   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02130
+    lead_prob                corr 0.999998  max abs   0.0811  mean abs 0.07210   (by error, pooled)
+    meta                     corr 0.999866  max abs   0.1133  mean abs 0.04726
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999993  max abs   0.3125  mean abs 0.00817
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00944   (by error, pooled)
+    road_edges               corr 0.999890  max abs   0.0894  mean abs 0.02809
+    road_transform           corr 0.999991  max abs   0.0312  mean abs 0.01126   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00299   (by error, pooled)
+
+frame 71: corr 0.999950  max abs 0.3438
+    action                   corr 0.999978  max abs   0.0215  mean abs 0.01211   (by error, pooled)
+    desire_pred              corr 0.999920  max abs   0.0807  mean abs 0.03205
+    desire_state             corr 0.999996  max abs   0.2188  mean abs 0.09253   (by error, pooled)
+    hidden_state             corr 0.999947  max abs   0.2341  mean abs 0.01328
+    lane_lines               corr 0.999953  max abs   0.0898  mean abs 0.01493
+    lane_lines_prob          corr 0.999982  max abs   0.0508  mean abs 0.02563   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.04068
+    lead_prob                corr 0.999966  max abs   0.1367  mean abs 0.10775   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.1094  mean abs 0.05435
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999981  max abs   0.2344  mean abs 0.01384
+    pose                     corr 0.999987  max abs   0.0312  mean abs 0.01272   (by error, pooled)
+    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02025
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00433   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00757   (by error, pooled)
+
+frame 72: corr 0.999965  max abs 0.1211
+    action                   corr 0.999994  max abs   0.0137  mean abs 0.00534   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0664  mean abs 0.03443
+    desire_state             corr 0.999995  max abs   0.0781  mean abs 0.03052   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01144
+    lane_lines               corr 0.999965  max abs   0.0703  mean abs 0.01386
+    lane_lines_prob          corr 0.999937  max abs   0.1211  mean abs 0.04553   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.0938  mean abs 0.00948
+    lead_prob                corr 0.999937  max abs   0.1016  mean abs 0.06445   (by error, pooled)
+    meta                     corr 0.999926  max abs   0.1016  mean abs 0.03933
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1016  mean abs 0.00674
+    pose                     corr 0.999995  max abs   0.0244  mean abs 0.00696   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01637
+    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00678   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0156  mean abs 0.00522   (by error, pooled)
+
+frame 73: corr 0.999964  max abs 0.2422
+    action                   corr 0.999992  max abs   0.0156  mean abs 0.00574   (by error, pooled)
+    desire_pred              corr 0.999945  max abs   0.0605  mean abs 0.03956
+    desire_state             corr 0.999969  max abs   0.2422  mean abs 0.08496   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1230  mean abs 0.01152
+    lane_lines               corr 0.999980  max abs   0.0430  mean abs 0.01133
+    lane_lines_prob          corr 0.999959  max abs   0.1133  mean abs 0.05399   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0469  mean abs 0.00878
+    lead_prob                corr 0.999995  max abs   0.0898  mean abs 0.07878   (by error, pooled)
+    meta                     corr 0.999917  max abs   0.1191  mean abs 0.03578
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00729
+    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00591   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0781  mean abs 0.01458
+    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00506   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
+
+frame 74: corr 0.999962  max abs 0.1289
+    action                   corr 0.999998  max abs   0.0088  mean abs 0.00378   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0547  mean abs 0.02530
+    desire_state             corr 0.999978  max abs   0.1250  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1289  mean abs 0.01225
+    lane_lines               corr 0.999983  max abs   0.0488  mean abs 0.01069
+    lane_lines_prob          corr 0.999953  max abs   0.0820  mean abs 0.04108   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.0216  mean abs 0.00366
+    lead_prob                corr 0.999999  max abs   0.0508  mean abs 0.04525   (by error, pooled)
+    meta                     corr 0.999931  max abs   0.0977  mean abs 0.03667
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0938  mean abs 0.00628
+    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00738   (by error, pooled)
+    road_edges               corr 0.999982  max abs   0.0762  mean abs 0.01163
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00798   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0273  mean abs 0.00852   (by error, pooled)
+
+frame 75: corr 0.999965  max abs 0.1802
+    action                   corr 0.999983  max abs   0.0181  mean abs 0.01035   (by error, pooled)
+    desire_pred              corr 0.999947  max abs   0.0645  mean abs 0.02671
+    desire_state             corr 0.999994  max abs   0.1367  mean abs 0.05273   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1802  mean abs 0.01418
+    lane_lines               corr 0.999977  max abs   0.0938  mean abs 0.01250
+    lane_lines_prob          corr 0.999884  max abs   0.0957  mean abs 0.03717   (by error, pooled)
+    lead                     corr 0.999997  max abs   0.1094  mean abs 0.01454
+    lead_prob                corr 0.999984  max abs   0.1094  mean abs 0.08919   (by error, pooled)
+    meta                     corr 0.999863  max abs   0.0909  mean abs 0.03252
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1406  mean abs 0.00598
+    pose                     corr 0.999991  max abs   0.0312  mean abs 0.00796   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0935  mean abs 0.01715
+    road_transform           corr 0.999994  max abs   0.0293  mean abs 0.00751   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00364   (by error, pooled)
+
+frame 76: corr 0.999955  max abs 0.2588
+    action                   corr 0.999980  max abs   0.0273  mean abs 0.01375   (by error, pooled)
+    desire_pred              corr 0.999935  max abs   0.0820  mean abs 0.02995
+    desire_state             corr 0.999972  max abs   0.2588  mean abs 0.14471   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2383  mean abs 0.01328
+    lane_lines               corr 0.999969  max abs   0.0898  mean abs 0.01368
+    lane_lines_prob          corr 0.999914  max abs   0.0938  mean abs 0.03456   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.1250  mean abs 0.01952
+    lead_prob                corr 0.999992  max abs   0.0938  mean abs 0.08008   (by error, pooled)
+    meta                     corr 0.999916  max abs   0.0840  mean abs 0.03474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999982  max abs   0.1875  mean abs 0.01056
+    pose                     corr 0.999962  max abs   0.0625  mean abs 0.01739   (by error, pooled)
+    road_edges               corr 0.999984  max abs   0.0664  mean abs 0.01294
+    road_transform           corr 1.000000  max abs   0.0234  mean abs 0.00646   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00525   (by error, pooled)
+
+frame 77: corr 0.999951  max abs 0.3906
+    action                   corr 0.999970  max abs   0.0322  mean abs 0.01698   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.01995
+    desire_state             corr 0.999907  max abs   0.3906  mean abs 0.19397   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.1758  mean abs 0.01404
+    lane_lines               corr 0.999972  max abs   0.1133  mean abs 0.01270
+    lane_lines_prob          corr 0.999942  max abs   0.0859  mean abs 0.03262   (by error, pooled)
+    lead                     corr 0.999989  max abs   0.1562  mean abs 0.02014
+    lead_prob                corr 0.999992  max abs   0.1465  mean abs 0.12314   (by error, pooled)
+    meta                     corr 0.999966  max abs   0.0723  mean abs 0.02376
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999984  max abs   0.2031  mean abs 0.01073
+    pose                     corr 0.999977  max abs   0.0547  mean abs 0.01181   (by error, pooled)
+    road_edges               corr 0.999977  max abs   0.0781  mean abs 0.01255
+    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00620   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0312  mean abs 0.01147   (by error, pooled)
+
+frame 78: corr 0.999968  max abs 0.8125
+    action                   corr 0.999945  max abs   0.0176  mean abs 0.00992   (by error, pooled)
+    desire_pred              corr 0.999977  max abs   0.0586  mean abs 0.01959
+    desire_state             corr 0.999985  max abs   0.1729  mean abs 0.07568   (by error, pooled)
+    hidden_state             corr 0.999940  max abs   0.2227  mean abs 0.01550
+    lane_lines               corr 0.999957  max abs   0.1406  mean abs 0.01580
+    lane_lines_prob          corr 0.999853  max abs   0.1797  mean abs 0.05075   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.8125  mean abs 0.07051
+    lead_prob                corr 0.999988  max abs   0.1138  mean abs 0.10042   (by error, pooled)
+    meta                     corr 0.999930  max abs   0.0693  mean abs 0.02624
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1875  mean abs 0.01092
+    pose                     corr 0.999994  max abs   0.0703  mean abs 0.01583   (by error, pooled)
+    road_edges               corr 0.999944  max abs   0.0996  mean abs 0.02373
+    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01103   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.01083   (by error, pooled)
+
+frame 79: corr 0.999981  max abs 0.1953
+    action                   corr 0.999993  max abs   0.0068  mean abs 0.00330   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03223
+    desire_state             corr 0.999988  max abs   0.1230  mean abs 0.05566   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1953  mean abs 0.01466
+    lane_lines               corr 0.999930  max abs   0.0938  mean abs 0.02010
+    lane_lines_prob          corr 0.999953  max abs   0.1172  mean abs 0.06225   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01362
+    lead_prob                corr 0.999989  max abs   0.0771  mean abs 0.06576   (by error, pooled)
+    meta                     corr 0.999859  max abs   0.1152  mean abs 0.04403
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1875  mean abs 0.00592
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01025   (by error, pooled)
+    road_edges               corr 0.999916  max abs   0.0781  mean abs 0.02472
+    road_transform           corr 0.999992  max abs   0.0508  mean abs 0.01150   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.00590   (by error, pooled)
+
+frame 80: corr 0.999966  max abs 0.2447
+    action                   corr 0.999955  max abs   0.0244  mean abs 0.01292   (by error, pooled)
+    desire_pred              corr 0.999948  max abs   0.0703  mean abs 0.02839
+    desire_state             corr 0.999985  max abs   0.1719  mean abs 0.06842   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2447  mean abs 0.01320
+    lane_lines               corr 0.999966  max abs   0.0469  mean abs 0.01316
+    lane_lines_prob          corr 0.999978  max abs   0.0685  mean abs 0.03523   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.1562  mean abs 0.02241
+    lead_prob                corr 0.999989  max abs   0.1465  mean abs 0.12874   (by error, pooled)
+    meta                     corr 0.999904  max abs   0.0859  mean abs 0.03536
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00775
+    pose                     corr 0.999993  max abs   0.0273  mean abs 0.01102   (by error, pooled)
+    road_edges               corr 0.999933  max abs   0.0762  mean abs 0.01956
+    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01118   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0391  mean abs 0.01375   (by error, pooled)
+
+frame 81: corr 0.999958  max abs 0.1680
+    action                   corr 0.999988  max abs   0.0205  mean abs 0.00917   (by error, pooled)
+    desire_pred              corr 0.999936  max abs   0.0688  mean abs 0.03357
+    desire_state             corr 0.999965  max abs   0.1289  mean abs 0.07713   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01147
+    lane_lines               corr 0.999936  max abs   0.1211  mean abs 0.01838
+    lane_lines_prob          corr 0.999911  max abs   0.1055  mean abs 0.03925   (by error, pooled)
+    lead                     corr 0.999996  max abs   0.0508  mean abs 0.00909
+    lead_prob                corr 0.999975  max abs   0.1523  mean abs 0.12354   (by error, pooled)
+    meta                     corr 0.999839  max abs   0.1426  mean abs 0.05474
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00678
+    pose                     corr 0.999993  max abs   0.0283  mean abs 0.00774   (by error, pooled)
+    road_edges               corr 0.999924  max abs   0.1680  mean abs 0.02038
+    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00653   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00264   (by error, pooled)
+
+frame 82: corr 0.999961  max abs 0.1594
+    action                   corr 0.999997  max abs   0.0088  mean abs 0.00259   (by error, pooled)
+    desire_pred              corr 0.999950  max abs   0.0781  mean abs 0.03089
+    desire_state             corr 0.999990  max abs   0.1172  mean abs 0.07062   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1289  mean abs 0.01148
+    lane_lines               corr 0.999967  max abs   0.0625  mean abs 0.01310
+    lane_lines_prob          corr 0.999949  max abs   0.0840  mean abs 0.04501   (by error, pooled)
+    lead                     corr 0.999844  max abs   0.1594  mean abs 0.01475
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.07214   (by error, pooled)
+    meta                     corr 0.999943  max abs   0.0762  mean abs 0.03255
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00434
+    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00594   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0586  mean abs 0.01416
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00416   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0137  mean abs 0.00295   (by error, pooled)
+
+frame 83: corr 0.999955  max abs 0.2578
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00385   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0742  mean abs 0.02845
+    desire_state             corr 0.999985  max abs   0.1309  mean abs 0.03833   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1328  mean abs 0.01242
+    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01571
+    lane_lines_prob          corr 0.999971  max abs   0.1211  mean abs 0.05807   (by error, pooled)
+    lead                     corr 0.999982  max abs   0.2578  mean abs 0.02209
+    lead_prob                corr 0.999999  max abs   0.0977  mean abs 0.08310   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.0898  mean abs 0.03797
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00380
+    pose                     corr 0.999997  max abs   0.0273  mean abs 0.00770   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.0781  mean abs 0.01535
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00790   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00981   (by error, pooled)
+
+frame 84: corr 0.999958  max abs 0.3125
+    action                   corr 0.999986  max abs   0.0161  mean abs 0.00913   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0586  mean abs 0.02159
+    desire_state             corr 0.999929  max abs   0.1484  mean abs 0.08228   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1641  mean abs 0.01399
+    lane_lines               corr 0.999933  max abs   0.2227  mean abs 0.01733
+    lane_lines_prob          corr 0.999822  max abs   0.0898  mean abs 0.05341   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.3125  mean abs 0.02349
+    lead_prob                corr 0.999966  max abs   0.1680  mean abs 0.14006   (by error, pooled)
+    meta                     corr 0.999860  max abs   0.0996  mean abs 0.03439
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00519
+    pose                     corr 0.999989  max abs   0.0264  mean abs 0.00699   (by error, pooled)
+    road_edges               corr 0.999965  max abs   0.1250  mean abs 0.01487
+    road_transform           corr 0.999992  max abs   0.0312  mean abs 0.00808   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
+
+frame 85: corr 0.999955  max abs 0.3750
+    action                   corr 0.999969  max abs   0.0234  mean abs 0.01309   (by error, pooled)
+    desire_pred              corr 0.999931  max abs   0.0625  mean abs 0.02937
+    desire_state             corr 0.999725  max abs   0.3613  mean abs 0.19666   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01400
+    lane_lines               corr 0.999966  max abs   0.1133  mean abs 0.01702
+    lane_lines_prob          corr 0.999995  max abs   0.0762  mean abs 0.04250   (by error, pooled)
+    lead                     corr 0.999957  max abs   0.3750  mean abs 0.03565
+    lead_prob                corr 0.999985  max abs   0.2383  mean abs 0.19333   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.0762  mean abs 0.02420
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999987  max abs   0.1875  mean abs 0.00896
+    pose                     corr 0.999974  max abs   0.0781  mean abs 0.01537   (by error, pooled)
+    road_edges               corr 0.999981  max abs   0.0625  mean abs 0.01499
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00857   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0215  mean abs 0.00817   (by error, pooled)
+
+frame 86: corr 0.999929  max abs 0.4688
+    action                   corr 0.999969  max abs   0.0332  mean abs 0.01874   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0625  mean abs 0.03150
+    desire_state             corr 0.999726  max abs   0.3828  mean abs 0.18327   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2188  mean abs 0.01377
+    lane_lines               corr 0.999964  max abs   0.0977  mean abs 0.01412
+    lane_lines_prob          corr 0.999902  max abs   0.1211  mean abs 0.04495   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.4688  mean abs 0.05692
+    lead_prob                corr 0.999998  max abs   0.1328  mean abs 0.10693   (by error, pooled)
+    meta                     corr 0.999945  max abs   0.0742  mean abs 0.02528
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999959  max abs   0.2422  mean abs 0.01130
+    pose                     corr 0.999958  max abs   0.0762  mean abs 0.01647   (by error, pooled)
+    road_edges               corr 0.999942  max abs   0.0664  mean abs 0.02047
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00914   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00462   (by error, pooled)
+
+frame 87: corr 0.999969  max abs 0.8125
+    action                   corr 0.999944  max abs   0.0159  mean abs 0.00849   (by error, pooled)
+    desire_pred              corr 0.999961  max abs   0.0547  mean abs 0.02374
+    desire_state             corr 0.999984  max abs   0.1875  mean abs 0.09924   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2227  mean abs 0.01549
+    lane_lines               corr 0.999949  max abs   0.1328  mean abs 0.01768
+    lane_lines_prob          corr 0.999975  max abs   0.1562  mean abs 0.05096   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.8125  mean abs 0.06905
+    lead_prob                corr 0.999998  max abs   0.0582  mean abs 0.04545   (by error, pooled)
+    meta                     corr 0.999914  max abs   0.0977  mean abs 0.03504
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00920
+    pose                     corr 0.999995  max abs   0.0547  mean abs 0.01569   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0820  mean abs 0.02022
+    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.00987   (by error, pooled)
+    wide_from_device_euler   corr 0.999989  max abs   0.0371  mean abs 0.01217   (by error, pooled)
+
+frame 88: corr 0.999980  max abs 0.2500
+    action                   corr 0.999933  max abs   0.0154  mean abs 0.00757   (by error, pooled)
+    desire_pred              corr 0.999926  max abs   0.0781  mean abs 0.03278
+    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.09424   (by error, pooled)
+    hidden_state             corr 0.999948  max abs   0.1973  mean abs 0.01472
+    lane_lines               corr 0.999923  max abs   0.1016  mean abs 0.02050
+    lane_lines_prob          corr 0.999851  max abs   0.1992  mean abs 0.06371   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02078
+    lead_prob                corr 1.000000  max abs   0.0381  mean abs 0.03597   (by error, pooled)
+    meta                     corr 0.999879  max abs   0.1069  mean abs 0.03890
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.1562  mean abs 0.00626
+    pose                     corr 0.999997  max abs   0.0332  mean abs 0.01122   (by error, pooled)
+    road_edges               corr 0.999909  max abs   0.0762  mean abs 0.02562
+    road_transform           corr 0.999995  max abs   0.0391  mean abs 0.01119   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0273  mean abs 0.01143   (by error, pooled)
+
+frame 89: corr 0.999968  max abs 0.2764
+    action                   corr 0.999955  max abs   0.0205  mean abs 0.01051   (by error, pooled)
+    desire_pred              corr 0.999926  max abs   0.0820  mean abs 0.03086
+    desire_state             corr 0.999993  max abs   0.1523  mean abs 0.05615   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2764  mean abs 0.01343
+    lane_lines               corr 0.999954  max abs   0.0723  mean abs 0.01570
+    lane_lines_prob          corr 0.999981  max abs   0.0487  mean abs 0.02660   (by error, pooled)
+    lead                     corr 0.999998  max abs   0.1250  mean abs 0.01621
+    lead_prob                corr 0.999996  max abs   0.1006  mean abs 0.08167   (by error, pooled)
+    meta                     corr 0.999892  max abs   0.0879  mean abs 0.03854
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00805
+    pose                     corr 0.999994  max abs   0.0254  mean abs 0.00778   (by error, pooled)
+    road_edges               corr 0.999943  max abs   0.0547  mean abs 0.01786
+    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.01035   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0234  mean abs 0.00754   (by error, pooled)
+
+frame 90: corr 0.999954  max abs 0.4531
+    action                   corr 0.999991  max abs   0.0195  mean abs 0.00842   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0898  mean abs 0.02631
+    desire_state             corr 0.999939  max abs   0.1797  mean abs 0.09821   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1084  mean abs 0.01168
+    lane_lines               corr 0.999973  max abs   0.0566  mean abs 0.01503
+    lane_lines_prob          corr 0.999935  max abs   0.1055  mean abs 0.03369   (by error, pooled)
+    lead                     corr 0.999975  max abs   0.4531  mean abs 0.03565
+    lead_prob                corr 0.999992  max abs   0.1172  mean abs 0.09489   (by error, pooled)
+    meta                     corr 0.999906  max abs   0.1152  mean abs 0.04144
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00543
+    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00641   (by error, pooled)
+    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01678
+    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00587   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00654   (by error, pooled)
+
+frame 91: corr 0.999962  max abs 0.1289
+    action                   corr 0.999997  max abs   0.0098  mean abs 0.00372   (by error, pooled)
+    desire_pred              corr 0.999940  max abs   0.0664  mean abs 0.03883
+    desire_state             corr 0.999991  max abs   0.1084  mean abs 0.05154   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1172  mean abs 0.01148
+    lane_lines               corr 0.999970  max abs   0.0684  mean abs 0.01578
+    lane_lines_prob          corr 0.999932  max abs   0.1289  mean abs 0.06403   (by error, pooled)
+    lead                     corr 0.999987  max abs   0.1172  mean abs 0.01015
+    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05021   (by error, pooled)
+    meta                     corr 0.999922  max abs   0.1211  mean abs 0.04145
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00476
+    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00593   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0781  mean abs 0.01442
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00554   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
+
+frame 92: corr 0.999957  max abs 0.2812
+    action                   corr 0.999995  max abs   0.0117  mean abs 0.00358   (by error, pooled)
+    desire_pred              corr 0.999967  max abs   0.0625  mean abs 0.02961
+    desire_state             corr 0.999972  max abs   0.1562  mean abs 0.07922   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1406  mean abs 0.01247
+    lane_lines               corr 0.999979  max abs   0.0508  mean abs 0.01284
+    lane_lines_prob          corr 0.999871  max abs   0.1016  mean abs 0.04956   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.2812  mean abs 0.02249
+    lead_prob                corr 0.999993  max abs   0.1270  mean abs 0.11068   (by error, pooled)
+    meta                     corr 0.999877  max abs   0.1221  mean abs 0.04130
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00477
+    pose                     corr 0.999996  max abs   0.0273  mean abs 0.00755   (by error, pooled)
+    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01250
+    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00717   (by error, pooled)
+    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.00916   (by error, pooled)
+
+frame 93: corr 0.999964  max abs 0.2656
+    action                   corr 0.999981  max abs   0.0215  mean abs 0.01099   (by error, pooled)
+    desire_pred              corr 0.999945  max abs   0.0742  mean abs 0.02887
+    desire_state             corr 0.999988  max abs   0.2656  mean abs 0.13892   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1895  mean abs 0.01406
+    lane_lines               corr 0.999968  max abs   0.1484  mean abs 0.01591
+    lane_lines_prob          corr 0.999764  max abs   0.1172  mean abs 0.05365   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.2500  mean abs 0.01816
+    lead_prob                corr 0.999967  max abs   0.1289  mean abs 0.10742   (by error, pooled)
+    meta                     corr 0.999924  max abs   0.0586  mean abs 0.02599
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00600
+    pose                     corr 0.999987  max abs   0.0391  mean abs 0.00918   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.1562  mean abs 0.01684
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00882   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0195  mean abs 0.00754   (by error, pooled)
+
+frame 94: corr 0.999953  max abs 0.3281
+    action                   corr 0.999966  max abs   0.0332  mean abs 0.01728   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0576  mean abs 0.02705
+    desire_state             corr 0.999938  max abs   0.3281  mean abs 0.16232   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2441  mean abs 0.01358
+    lane_lines               corr 0.999950  max abs   0.1250  mean abs 0.01747
+    lane_lines_prob          corr 0.999927  max abs   0.1055  mean abs 0.03625   (by error, pooled)
+    lead                     corr 0.999990  max abs   0.2188  mean abs 0.03006
+    lead_prob                corr 0.999986  max abs   0.1157  mean abs 0.08781   (by error, pooled)
+    meta                     corr 0.999953  max abs   0.0781  mean abs 0.03182
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999970  max abs   0.2656  mean abs 0.01275
+    pose                     corr 0.999957  max abs   0.0762  mean abs 0.01822   (by error, pooled)
+    road_edges               corr 0.999952  max abs   0.0898  mean abs 0.01856
+    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00948   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
+
+frame 95: corr 0.999938  max abs 0.4082
+    action                   corr 0.999969  max abs   0.0303  mean abs 0.01691   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0879  mean abs 0.02904
+    desire_state             corr 0.999939  max abs   0.4082  mean abs 0.19031   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2344  mean abs 0.01422
+    lane_lines               corr 0.999959  max abs   0.0547  mean abs 0.01523
+    lane_lines_prob          corr 0.999916  max abs   0.1211  mean abs 0.05078   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.3750  mean abs 0.05143
+    lead_prob                corr 0.999944  max abs   0.0874  mean abs 0.06909   (by error, pooled)
+    meta                     corr 0.999956  max abs   0.0586  mean abs 0.02371
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999955  max abs   0.3125  mean abs 0.01530
+    pose                     corr 0.999956  max abs   0.0820  mean abs 0.01721   (by error, pooled)
+    road_edges               corr 0.999957  max abs   0.0703  mean abs 0.01671
+    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.00905   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00428   (by error, pooled)
+
+frame 96: corr 0.999974  max abs 0.6875
+    action                   corr 0.999935  max abs   0.0173  mean abs 0.00852   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0781  mean abs 0.02634
+    desire_state             corr 0.999994  max abs   0.1562  mean abs 0.06445   (by error, pooled)
+    hidden_state             corr 0.999941  max abs   0.2266  mean abs 0.01531
+    lane_lines               corr 0.999951  max abs   0.1055  mean abs 0.01672
+    lane_lines_prob          corr 0.999990  max abs   0.0669  mean abs 0.04776   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.6875  mean abs 0.05516
+    lead_prob                corr 0.999996  max abs   0.0723  mean abs 0.06380   (by error, pooled)
+    meta                     corr 0.999932  max abs   0.0693  mean abs 0.02632
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00871
+    pose                     corr 0.999994  max abs   0.0469  mean abs 0.01649   (by error, pooled)
+    road_edges               corr 0.999946  max abs   0.0938  mean abs 0.02024
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01207   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0273  mean abs 0.00922   (by error, pooled)
+
+frame 97: corr 0.999982  max abs 0.4688
+    action                   corr 0.999967  max abs   0.0128  mean abs 0.00407   (by error, pooled)
+    desire_pred              corr 0.999949  max abs   0.0645  mean abs 0.02573
+    desire_state             corr 0.999995  max abs   0.1406  mean abs 0.06787   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1719  mean abs 0.01441
+    lane_lines               corr 0.999932  max abs   0.0606  mean abs 0.01968
+    lane_lines_prob          corr 0.999916  max abs   0.1445  mean abs 0.05452   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.4375  mean abs 0.02955
+    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05046   (by error, pooled)
+    meta                     corr 0.999821  max abs   0.1304  mean abs 0.04943
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.4688  mean abs 0.00954
+    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00943   (by error, pooled)
+    road_edges               corr 0.999859  max abs   0.1133  mean abs 0.03283
+    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.01045   (by error, pooled)
+    wide_from_device_euler   corr 0.999992  max abs   0.0234  mean abs 0.00787   (by error, pooled)
+
+frame 98: corr 0.999965  max abs 0.2734
+    action                   corr 0.999956  max abs   0.0273  mean abs 0.01571   (by error, pooled)
+    desire_pred              corr 0.999915  max abs   0.0781  mean abs 0.03284
+    desire_state             corr 0.999988  max abs   0.2734  mean abs 0.11719   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.2268  mean abs 0.01300
+    lane_lines               corr 0.999953  max abs   0.1113  mean abs 0.01482
+    lane_lines_prob          corr 0.999880  max abs   0.1016  mean abs 0.04564   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.1562  mean abs 0.02120
+    lead_prob                corr 1.000000  max abs   0.1094  mean abs 0.09202   (by error, pooled)
+    meta                     corr 0.999857  max abs   0.1113  mean abs 0.04895
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999991  max abs   0.0938  mean abs 0.01117
+    pose                     corr 0.999989  max abs   0.0288  mean abs 0.01237   (by error, pooled)
+    road_edges               corr 0.999928  max abs   0.0703  mean abs 0.02029
+    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00760   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01018   (by error, pooled)
+
+frame 99: corr 0.999963  max abs 0.2969
+    action                   corr 0.999987  max abs   0.0205  mean abs 0.00918   (by error, pooled)
+    desire_pred              corr 0.999938  max abs   0.0840  mean abs 0.03076
+    desire_state             corr 0.999991  max abs   0.2812  mean abs 0.08911   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01180
+    lane_lines               corr 0.999977  max abs   0.0410  mean abs 0.01467
+    lane_lines_prob          corr 0.999966  max abs   0.1289  mean abs 0.05359   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.2969  mean abs 0.02333
+    lead_prob                corr 0.999997  max abs   0.1367  mean abs 0.10441   (by error, pooled)
+    meta                     corr 0.999887  max abs   0.1074  mean abs 0.04481
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00535
+    pose                     corr 0.999995  max abs   0.0210  mean abs 0.00590   (by error, pooled)
+    road_edges               corr 0.999970  max abs   0.0508  mean abs 0.01679
+    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00702   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00458   (by error, pooled)
+
+frame 100: corr 0.999960  max abs 0.3140
+    action                   corr 0.999999  max abs   0.0068  mean abs 0.00314   (by error, pooled)
+    desire_pred              corr 0.999970  max abs   0.0518  mean abs 0.02459
+    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.03195   (by error, pooled)
+    hidden_state             corr 0.999957  max abs   0.1230  mean abs 0.01118
+    lane_lines               corr 0.999979  max abs   0.0430  mean abs 0.01357
+    lane_lines_prob          corr 0.999985  max abs   0.1094  mean abs 0.05763   (by error, pooled)
+    lead                     corr 0.999643  max abs   0.3140  mean abs 0.02712
+    lead_prob                corr 0.999987  max abs   0.1484  mean abs 0.10547   (by error, pooled)
+    meta                     corr 0.999940  max abs   0.1025  mean abs 0.04166
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00346
+    pose                     corr 0.999996  max abs   0.0202  mean abs 0.00544   (by error, pooled)
+    road_edges               corr 0.999976  max abs   0.0586  mean abs 0.01420
+    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00505   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0176  mean abs 0.00522   (by error, pooled)
+
+frame 101: corr 0.999937  max abs 0.6641
+    action                   corr 0.999995  max abs   0.0117  mean abs 0.00354   (by error, pooled)
+    desire_pred              corr 0.999969  max abs   0.0518  mean abs 0.02815
+    desire_state             corr 0.999997  max abs   0.2031  mean abs 0.10266   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1328  mean abs 0.01220
+    lane_lines               corr 0.999969  max abs   0.0879  mean abs 0.01564
+    lane_lines_prob          corr 0.999955  max abs   0.1211  mean abs 0.05682   (by error, pooled)
+    lead                     corr 0.999883  max abs   0.6641  mean abs 0.05588
+    lead_prob                corr 0.999992  max abs   0.1055  mean abs 0.09163   (by error, pooled)
+    meta                     corr 0.999959  max abs   0.0684  mean abs 0.02910
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00550
+    pose                     corr 0.999996  max abs   0.0234  mean abs 0.00685   (by error, pooled)
+    road_edges               corr 0.999976  max abs   0.0977  mean abs 0.01863
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00360   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00559   (by error, pooled)
+
+frame 102: corr 0.999960  max abs 0.4375
+    action                   corr 0.999981  max abs   0.0176  mean abs 0.01045   (by error, pooled)
+    desire_pred              corr 0.999954  max abs   0.0625  mean abs 0.02755
+    desire_state             corr 0.999986  max abs   0.2500  mean abs 0.08447   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2061  mean abs 0.01456
+    lane_lines               corr 0.999943  max abs   0.0977  mean abs 0.01675
+    lane_lines_prob          corr 0.999863  max abs   0.1328  mean abs 0.04132   (by error, pooled)
+    lead                     corr 0.999993  max abs   0.4375  mean abs 0.03030
+    lead_prob                corr 0.999967  max abs   0.1816  mean abs 0.15218   (by error, pooled)
+    meta                     corr 0.999813  max abs   0.1104  mean abs 0.03652
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1406  mean abs 0.00664
+    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00640   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.1016  mean abs 0.01384
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00606   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00754   (by error, pooled)
+
+frame 103: corr 0.999953  max abs 0.3125
+    action                   corr 0.999974  max abs   0.0312  mean abs 0.01668   (by error, pooled)
+    desire_pred              corr 0.999972  max abs   0.0547  mean abs 0.01977
+    desire_state             corr 0.999959  max abs   0.3125  mean abs 0.14893   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2480  mean abs 0.01366
+    lane_lines               corr 0.999964  max abs   0.0508  mean abs 0.01451
+    lane_lines_prob          corr 0.999887  max abs   0.0898  mean abs 0.03701   (by error, pooled)
+    lead                     corr 0.999976  max abs   0.1875  mean abs 0.02543
+    lead_prob                corr 0.999992  max abs   0.1816  mean abs 0.14639   (by error, pooled)
+    meta                     corr 0.999946  max abs   0.0645  mean abs 0.02294
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999969  max abs   0.1719  mean abs 0.01478
+    pose                     corr 0.999950  max abs   0.0918  mean abs 0.01696   (by error, pooled)
+    road_edges               corr 0.999969  max abs   0.0703  mean abs 0.01472
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00523   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00459   (by error, pooled)
+
+frame 104: corr 0.999931  max abs 0.4531
+    action                   corr 0.999925  max abs   0.0488  mean abs 0.02509   (by error, pooled)
+    desire_pred              corr 0.999900  max abs   0.1133  mean abs 0.03461
+    desire_state             corr 0.999958  max abs   0.4531  mean abs 0.17236   (by error, pooled)
+    hidden_state             corr 0.999937  max abs   0.3125  mean abs 0.01452
+    lane_lines               corr 0.999932  max abs   0.1484  mean abs 0.01686
+    lane_lines_prob          corr 0.999916  max abs   0.0781  mean abs 0.03748   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.4219  mean abs 0.05753
+    lead_prob                corr 0.999988  max abs   0.1245  mean abs 0.10400   (by error, pooled)
+    meta                     corr 0.999924  max abs   0.0684  mean abs 0.02939
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999922  max abs   0.3203  mean abs 0.01911
+    pose                     corr 0.999917  max abs   0.1250  mean abs 0.02585   (by error, pooled)
+    road_edges               corr 0.999948  max abs   0.1367  mean abs 0.01656
+    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00823   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00626   (by error, pooled)
+
+frame 105: corr 0.999974  max abs 0.5000
+    action                   corr 0.999913  max abs   0.0165  mean abs 0.00865   (by error, pooled)
+    desire_pred              corr 0.999969  max abs   0.0625  mean abs 0.02130
+    desire_state             corr 0.999995  max abs   0.1875  mean abs 0.10400   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01515
+    lane_lines               corr 0.999951  max abs   0.0859  mean abs 0.01761
+    lane_lines_prob          corr 0.999951  max abs   0.1211  mean abs 0.04994   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.5000  mean abs 0.04795
+    lead_prob                corr 0.999998  max abs   0.0432  mean abs 0.03849   (by error, pooled)
+    meta                     corr 0.999937  max abs   0.0713  mean abs 0.02498
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.2188  mean abs 0.00823
+    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01456   (by error, pooled)
+    road_edges               corr 0.999936  max abs   0.1016  mean abs 0.02360
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00979   (by error, pooled)
+    wide_from_device_euler   corr 0.999979  max abs   0.0586  mean abs 0.01897   (by error, pooled)
+
+frame 106: corr 0.999980  max abs 0.2812
+    action                   corr 0.999940  max abs   0.0161  mean abs 0.00698   (by error, pooled)
+    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03064
+    desire_state             corr 0.999992  max abs   0.2812  mean abs 0.12402   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2051  mean abs 0.01456
+    lane_lines               corr 0.999937  max abs   0.0898  mean abs 0.01915
+    lane_lines_prob          corr 0.999958  max abs   0.1367  mean abs 0.04807   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02541
+    lead_prob                corr 0.999987  max abs   0.0225  mean abs 0.01662   (by error, pooled)
+    meta                     corr 0.999880  max abs   0.0974  mean abs 0.04307
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.2188  mean abs 0.00707
+    pose                     corr 0.999998  max abs   0.0371  mean abs 0.01430   (by error, pooled)
+    road_edges               corr 0.999895  max abs   0.0840  mean abs 0.02671
+    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00865   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00527   (by error, pooled)
+
+frame 107: corr 0.999963  max abs 0.2578
+    action                   corr 0.999936  max abs   0.0254  mean abs 0.01272   (by error, pooled)
+    desire_pred              corr 0.999894  max abs   0.0859  mean abs 0.04031
+    desire_state             corr 0.999993  max abs   0.2344  mean abs 0.13184   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.2578  mean abs 0.01329
+    lane_lines               corr 0.999950  max abs   0.0684  mean abs 0.01641
+    lane_lines_prob          corr 0.999886  max abs   0.1328  mean abs 0.04726   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2188  mean abs 0.02691
+    lead_prob                corr 0.999999  max abs   0.0918  mean abs 0.08065   (by error, pooled)
+    meta                     corr 0.999884  max abs   0.0938  mean abs 0.04264
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999992  max abs   0.1250  mean abs 0.00996
+    pose                     corr 0.999991  max abs   0.0273  mean abs 0.01014   (by error, pooled)
+    road_edges               corr 0.999945  max abs   0.0547  mean abs 0.01736
+    road_transform           corr 0.999999  max abs   0.0352  mean abs 0.01168   (by error, pooled)
+    wide_from_device_euler   corr 0.999990  max abs   0.0547  mean abs 0.01050   (by error, pooled)
+
+frame 108: corr 0.999953  max abs 0.4531
+    action                   corr 0.999987  max abs   0.0195  mean abs 0.00795   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02743
+    desire_state             corr 0.999997  max abs   0.1406  mean abs 0.09192   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01158
+    lane_lines               corr 0.999943  max abs   0.1113  mean abs 0.01750
+    lane_lines_prob          corr 0.999988  max abs   0.0781  mean abs 0.03223   (by error, pooled)
+    lead                     corr 0.999908  max abs   0.4531  mean abs 0.03446
+    lead_prob                corr 0.999998  max abs   0.1406  mean abs 0.11532   (by error, pooled)
+    meta                     corr 0.999873  max abs   0.1250  mean abs 0.05239
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.0938  mean abs 0.00566
+    pose                     corr 0.999994  max abs   0.0244  mean abs 0.00634   (by error, pooled)
+    road_edges               corr 0.999941  max abs   0.1289  mean abs 0.01927
+    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.00839   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00524   (by error, pooled)
+
+frame 109: corr 0.999954  max abs 0.4180
+    action                   corr 0.999988  max abs   0.0176  mean abs 0.00489   (by error, pooled)
+    desire_pred              corr 0.999974  max abs   0.0513  mean abs 0.02330
+    desire_state             corr 0.999998  max abs   0.1250  mean abs 0.07495   (by error, pooled)
+    hidden_state             corr 0.999956  max abs   0.1328  mean abs 0.01146
+    lane_lines               corr 0.999977  max abs   0.0391  mean abs 0.01328
+    lane_lines_prob          corr 0.999983  max abs   0.0840  mean abs 0.05257   (by error, pooled)
+    lead                     corr 0.999588  max abs   0.4180  mean abs 0.03676
+    lead_prob                corr 0.999994  max abs   0.1133  mean abs 0.08333   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0938  mean abs 0.03899
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0547  mean abs 0.00356
+    pose                     corr 0.999997  max abs   0.0146  mean abs 0.00483   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0664  mean abs 0.01521
+    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00294   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00524   (by error, pooled)
+
+frame 110: corr 0.999944  max abs 0.6172
+    action                   corr 0.999995  max abs   0.0103  mean abs 0.00399   (by error, pooled)
+    desire_pred              corr 0.999978  max abs   0.0469  mean abs 0.02397
+    desire_state             corr 0.999998  max abs   0.1562  mean abs 0.09961   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.1367  mean abs 0.01232
+    lane_lines               corr 0.999978  max abs   0.0430  mean abs 0.01240
+    lane_lines_prob          corr 0.999844  max abs   0.1562  mean abs 0.06067   (by error, pooled)
+    lead                     corr 0.999893  max abs   0.6172  mean abs 0.05073
+    lead_prob                corr 1.000000  max abs   0.1172  mean abs 0.09749   (by error, pooled)
+    meta                     corr 0.999939  max abs   0.0791  mean abs 0.03100
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00384
+    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00671   (by error, pooled)
+    road_edges               corr 0.999972  max abs   0.0508  mean abs 0.01545
+    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00384   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00461   (by error, pooled)
+
+frame 111: corr 0.999959  max abs 0.5312
+    action                   corr 0.999960  max abs   0.0195  mean abs 0.01176   (by error, pooled)
+    desire_pred              corr 0.999920  max abs   0.0840  mean abs 0.03464
+    desire_state             corr 0.999993  max abs   0.2812  mean abs 0.11523   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.2031  mean abs 0.01398
+    lane_lines               corr 0.999968  max abs   0.1172  mean abs 0.01418
+    lane_lines_prob          corr 0.999807  max abs   0.1562  mean abs 0.05011   (by error, pooled)
+    lead                     corr 0.999984  max abs   0.5312  mean abs 0.03607
+    lead_prob                corr 0.999997  max abs   0.1406  mean abs 0.12394   (by error, pooled)
+    meta                     corr 0.999862  max abs   0.0845  mean abs 0.03692
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999995  max abs   0.1094  mean abs 0.00736
+    pose                     corr 0.999982  max abs   0.0488  mean abs 0.01071   (by error, pooled)
+    road_edges               corr 0.999967  max abs   0.1064  mean abs 0.01599
+    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00743   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01372   (by error, pooled)
+
+frame 112: corr 0.999948  max abs 0.6094
+    action                   corr 0.999985  max abs   0.0215  mean abs 0.01196   (by error, pooled)
+    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03555
+    desire_state             corr 0.999985  max abs   0.2812  mean abs 0.10107   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1875  mean abs 0.01316
+    lane_lines               corr 0.999961  max abs   0.1016  mean abs 0.01541
+    lane_lines_prob          corr 0.999942  max abs   0.1289  mean abs 0.05780   (by error, pooled)
+    lead                     corr 0.999869  max abs   0.6094  mean abs 0.04577
+    lead_prob                corr 0.999958  max abs   0.1523  mean abs 0.13216   (by error, pooled)
+    meta                     corr 0.999923  max abs   0.0830  mean abs 0.03416
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999989  max abs   0.1406  mean abs 0.00782
+    pose                     corr 0.999979  max abs   0.0488  mean abs 0.01189   (by error, pooled)
+    road_edges               corr 0.999963  max abs   0.1367  mean abs 0.01753
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01037   (by error, pooled)
+    wide_from_device_euler   corr 1.000000  max abs   0.0273  mean abs 0.01014   (by error, pooled)
+
+frame 113: corr 0.999945  max abs 0.3906
+    action                   corr 0.999976  max abs   0.0215  mean abs 0.01273   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0742  mean abs 0.02438
+    desire_state             corr 0.999966  max abs   0.3906  mean abs 0.18146   (by error, pooled)
+    hidden_state             corr 0.999944  max abs   0.2207  mean abs 0.01415
+    lane_lines               corr 0.999949  max abs   0.0703  mean abs 0.01507
+    lane_lines_prob          corr 0.999955  max abs   0.1836  mean abs 0.08813   (by error, pooled)
+    lead                     corr 0.999950  max abs   0.3594  mean abs 0.03518
+    lead_prob                corr 0.999997  max abs   0.1204  mean abs 0.10881   (by error, pooled)
+    meta                     corr 0.999959  max abs   0.0859  mean abs 0.02720
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999968  max abs   0.2500  mean abs 0.01138
+    pose                     corr 0.999973  max abs   0.0742  mean abs 0.01349   (by error, pooled)
+    road_edges               corr 0.999962  max abs   0.0732  mean abs 0.01426
+    road_transform           corr 0.999997  max abs   0.0469  mean abs 0.01157   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0352  mean abs 0.00819   (by error, pooled)
+
+frame 114: corr 0.999977  max abs 0.2500
+    action                   corr 0.999948  max abs   0.0137  mean abs 0.00829   (by error, pooled)
+    desire_pred              corr 0.999957  max abs   0.0723  mean abs 0.02789
+    desire_state             corr 0.999999  max abs   0.0938  mean abs 0.04590   (by error, pooled)
+    hidden_state             corr 0.999945  max abs   0.2266  mean abs 0.01504
+    lane_lines               corr 0.999955  max abs   0.0742  mean abs 0.01699
+    lane_lines_prob          corr 0.999911  max abs   0.1016  mean abs 0.04504   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02027
+    lead_prob                corr 1.000000  max abs   0.0273  mean abs 0.02344   (by error, pooled)
+    meta                     corr 0.999923  max abs   0.0771  mean abs 0.02855
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1250  mean abs 0.00655
+    pose                     corr 0.999997  max abs   0.0391  mean abs 0.01290   (by error, pooled)
+    road_edges               corr 0.999938  max abs   0.1055  mean abs 0.02351
+    road_transform           corr 0.999994  max abs   0.0391  mean abs 0.01192   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0312  mean abs 0.01053   (by error, pooled)
+
+frame 115: corr 0.999975  max abs 0.1973
+    action                   corr 0.999970  max abs   0.0099  mean abs 0.00616   (by error, pooled)
+    desire_pred              corr 0.999939  max abs   0.0703  mean abs 0.02835
+    desire_state             corr 0.999996  max abs   0.1875  mean abs 0.05118   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.1973  mean abs 0.01474
+    lane_lines               corr 0.999930  max abs   0.0828  mean abs 0.01965
+    lane_lines_prob          corr 0.999954  max abs   0.1484  mean abs 0.05995   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.1875  mean abs 0.02071
+    lead_prob                corr 1.000000  max abs   0.0078  mean abs 0.00602   (by error, pooled)
+    meta                     corr 0.999873  max abs   0.0957  mean abs 0.04756
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1406  mean abs 0.00567
+    pose                     corr 0.999997  max abs   0.0312  mean abs 0.01022   (by error, pooled)
+    road_edges               corr 0.999918  max abs   0.0801  mean abs 0.02640
+    road_transform           corr 0.999991  max abs   0.0430  mean abs 0.01060   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00495   (by error, pooled)
+
+frame 116: corr 0.999961  max abs 0.2969
+    action                   corr 0.999985  max abs   0.0215  mean abs 0.01168   (by error, pooled)
+    desire_pred              corr 0.999968  max abs   0.0664  mean abs 0.02393
+    desire_state             corr 0.999998  max abs   0.1094  mean abs 0.04852   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2087  mean abs 0.01298
+    lane_lines               corr 0.999968  max abs   0.0566  mean abs 0.01403
+    lane_lines_prob          corr 0.999986  max abs   0.0347  mean abs 0.01764   (by error, pooled)
+    lead                     corr 0.999980  max abs   0.2969  mean abs 0.02488
+    lead_prob                corr 0.999984  max abs   0.1191  mean abs 0.10319   (by error, pooled)
+    meta                     corr 0.999928  max abs   0.0771  mean abs 0.02890
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00775
+    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00745   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0508  mean abs 0.01542
+    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00904   (by error, pooled)
+    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00690   (by error, pooled)
+
+frame 117: corr 0.999954  max abs 0.3789
+    action                   corr 0.999992  max abs   0.0166  mean abs 0.00689   (by error, pooled)
+    desire_pred              corr 0.999963  max abs   0.0645  mean abs 0.02583
+    desire_state             corr 0.999997  max abs   0.1445  mean abs 0.05884   (by error, pooled)
+    hidden_state             corr 0.999954  max abs   0.1064  mean abs 0.01166
+    lane_lines               corr 0.999947  max abs   0.0957  mean abs 0.01594
+    lane_lines_prob          corr 0.999974  max abs   0.0898  mean abs 0.03943   (by error, pooled)
+    lead                     corr 0.999884  max abs   0.3789  mean abs 0.02770
+    lead_prob                corr 0.999992  max abs   0.1133  mean abs 0.09017   (by error, pooled)
+    meta                     corr 0.999927  max abs   0.0957  mean abs 0.03598
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00442
+    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00573   (by error, pooled)
+    road_edges               corr 0.999919  max abs   0.1562  mean abs 0.02071
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00465   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00556   (by error, pooled)
+
+frame 118: corr 0.999960  max abs 0.2109
+    action                   corr 0.999993  max abs   0.0146  mean abs 0.00535   (by error, pooled)
+    desire_pred              corr 0.999964  max abs   0.0527  mean abs 0.02887
+    desire_state             corr 0.999994  max abs   0.1719  mean abs 0.07617   (by error, pooled)
+    hidden_state             corr 0.999955  max abs   0.1348  mean abs 0.01152
+    lane_lines               corr 0.999978  max abs   0.0469  mean abs 0.01234
+    lane_lines_prob          corr 0.999978  max abs   0.1016  mean abs 0.04746   (by error, pooled)
+    lead                     corr 0.999812  max abs   0.2109  mean abs 0.02105
+    lead_prob                corr 1.000000  max abs   0.0488  mean abs 0.03874   (by error, pooled)
+    meta                     corr 0.999942  max abs   0.0977  mean abs 0.03279
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00391
+    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00621   (by error, pooled)
+    road_edges               corr 0.999973  max abs   0.0586  mean abs 0.01422
+    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00684   (by error, pooled)
+    wide_from_device_euler   corr 0.999996  max abs   0.0195  mean abs 0.00588   (by error, pooled)
+
+frame 119: corr 0.999951  max abs 0.4375
+    action                   corr 0.999996  max abs   0.0098  mean abs 0.00417   (by error, pooled)
+    desire_pred              corr 0.999960  max abs   0.0938  mean abs 0.03431
+    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.04102   (by error, pooled)
+    hidden_state             corr 0.999950  max abs   0.1328  mean abs 0.01282
+    lane_lines               corr 0.999970  max abs   0.0703  mean abs 0.01402
+    lane_lines_prob          corr 0.999878  max abs   0.1172  mean abs 0.05511   (by error, pooled)
+    lead                     corr 0.999853  max abs   0.4375  mean abs 0.03405
+    lead_prob                corr 0.999991  max abs   0.0811  mean abs 0.06934   (by error, pooled)
+    meta                     corr 0.999936  max abs   0.0942  mean abs 0.02893
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00401
+    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00472   (by error, pooled)
+    road_edges               corr 0.999975  max abs   0.0898  mean abs 0.01303
+    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00474   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00657   (by error, pooled)
+
+frame 120: corr 0.999960  max abs 0.4062
+    action                   corr 0.999989  max abs   0.0176  mean abs 0.00978   (by error, pooled)
+    desire_pred              corr 0.999958  max abs   0.0586  mean abs 0.02430
+    desire_state             corr 0.999991  max abs   0.4062  mean abs 0.12085   (by error, pooled)
+    hidden_state             corr 0.999951  max abs   0.2031  mean abs 0.01419
+    lane_lines               corr 0.999974  max abs   0.0508  mean abs 0.01306
+    lane_lines_prob          corr 0.999733  max abs   0.1191  mean abs 0.06177   (by error, pooled)
+    lead                     corr 0.999994  max abs   0.2031  mean abs 0.01690
+    lead_prob                corr 0.999973  max abs   0.1289  mean abs 0.10352   (by error, pooled)
+    meta                     corr 0.999857  max abs   0.1025  mean abs 0.03659
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00584
+    pose                     corr 0.999994  max abs   0.0225  mean abs 0.00426   (by error, pooled)
+    road_edges               corr 0.999980  max abs   0.1094  mean abs 0.01329
+    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00621   (by error, pooled)
+    wide_from_device_euler   corr 0.999995  max abs   0.0215  mean abs 0.00591   (by error, pooled)
+
+frame 121: corr 0.999962  max abs 0.2500
+    action                   corr 0.999990  max abs   0.0156  mean abs 0.00754   (by error, pooled)
+    desire_pred              corr 0.999955  max abs   0.0703  mean abs 0.02387
+    desire_state             corr 0.999997  max abs   0.1250  mean abs 0.07739   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1891  mean abs 0.01339
+    lane_lines               corr 0.999962  max abs   0.0781  mean abs 0.01564
+    lane_lines_prob          corr 0.999968  max abs   0.1016  mean abs 0.03210   (by error, pooled)
+    lead                     corr 0.999974  max abs   0.2500  mean abs 0.02315
+    lead_prob                corr 0.999928  max abs   0.1523  mean abs 0.11491   (by error, pooled)
+    meta                     corr 0.999944  max abs   0.0645  mean abs 0.02519
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0625  mean abs 0.00574
+    pose                     corr 0.999988  max abs   0.0312  mean abs 0.00842   (by error, pooled)
+    road_edges               corr 0.999974  max abs   0.0469  mean abs 0.01429
+    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00516   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00232   (by error, pooled)
+
+frame 122: corr 0.999948  max abs 0.2969
+    action                   corr 0.999968  max abs   0.0312  mean abs 0.01652   (by error, pooled)
+    desire_pred              corr 0.999927  max abs   0.0703  mean abs 0.03409
+    desire_state             corr 0.999990  max abs   0.1875  mean abs 0.08521   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01412
+    lane_lines               corr 0.999949  max abs   0.1113  mean abs 0.01569
+    lane_lines_prob          corr 0.999798  max abs   0.1562  mean abs 0.05511   (by error, pooled)
+    lead                     corr 0.999995  max abs   0.2500  mean abs 0.03205
+    lead_prob                corr 1.000000  max abs   0.1250  mean abs 0.10596   (by error, pooled)
+    meta                     corr 0.999950  max abs   0.0674  mean abs 0.02443
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999974  max abs   0.2969  mean abs 0.01309
+    pose                     corr 0.999968  max abs   0.0723  mean abs 0.01480   (by error, pooled)
+    road_edges               corr 0.999959  max abs   0.0664  mean abs 0.01521
+    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00962   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.01079   (by error, pooled)
+
+frame 123: corr 0.999976  max abs 0.2344
+    action                   corr 0.999952  max abs   0.0132  mean abs 0.00711   (by error, pooled)
+    desire_pred              corr 0.999922  max abs   0.0938  mean abs 0.03134
+    desire_state             corr 0.999997  max abs   0.2344  mean abs 0.12500   (by error, pooled)
+    hidden_state             corr 0.999943  max abs   0.2227  mean abs 0.01535
+    lane_lines               corr 0.999956  max abs   0.1992  mean abs 0.01691
+    lane_lines_prob          corr 0.999977  max abs   0.0742  mean abs 0.03278   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.0938  mean abs 0.01147
+    lead_prob                corr 0.999993  max abs   0.0801  mean abs 0.06852   (by error, pooled)
+    meta                     corr 0.999941  max abs   0.0820  mean abs 0.02964
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0938  mean abs 0.00542
+    pose                     corr 0.999996  max abs   0.0391  mean abs 0.01335   (by error, pooled)
+    road_edges               corr 0.999917  max abs   0.1191  mean abs 0.02572
+    road_transform           corr 0.999998  max abs   0.0508  mean abs 0.01346   (by error, pooled)
+    wide_from_device_euler   corr 0.999994  max abs   0.0664  mean abs 0.01964   (by error, pooled)
+
+frame 124: corr 0.999980  max abs 0.4375
+    action                   corr 0.999969  max abs   0.0110  mean abs 0.00586   (by error, pooled)
+    desire_pred              corr 0.999933  max abs   0.0781  mean abs 0.02951
+    desire_state             corr 0.999995  max abs   0.2188  mean abs 0.07031   (by error, pooled)
+    hidden_state             corr 0.999952  max abs   0.1875  mean abs 0.01447
+    lane_lines               corr 0.999927  max abs   0.0819  mean abs 0.02048
+    lane_lines_prob          corr 0.999910  max abs   0.1133  mean abs 0.04207   (by error, pooled)
+    lead                     corr 1.000000  max abs   0.4375  mean abs 0.03287
+    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06250   (by error, pooled)
+    meta                     corr 0.999785  max abs   0.1270  mean abs 0.05262
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00628
+    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01204   (by error, pooled)
+    road_edges               corr 0.999824  max abs   0.0977  mean abs 0.03520
+    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00906   (by error, pooled)
+    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00298   (by error, pooled)
+
+frame 125: corr 0.999957  max abs 0.3438
+    action                   corr 0.999962  max abs   0.0244  mean abs 0.01410   (by error, pooled)
+    desire_pred              corr 0.999950  max abs   0.0586  mean abs 0.02645
+    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.09778   (by error, pooled)
+    hidden_state             corr 0.999949  max abs   0.2255  mean abs 0.01294
+    lane_lines               corr 0.999959  max abs   0.0918  mean abs 0.01333
+    lane_lines_prob          corr 0.999903  max abs   0.0923  mean abs 0.05426   (by error, pooled)
+    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03918
+    lead_prob                corr 0.999986  max abs   0.2031  mean abs 0.16895   (by error, pooled)
+    meta                     corr 0.999932  max abs   0.0703  mean abs 0.03028
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999988  max abs   0.1953  mean abs 0.01131
+    pose                     corr 0.999985  max abs   0.0342  mean abs 0.01261   (by error, pooled)
+    road_edges               corr 0.999922  max abs   0.0938  mean abs 0.02053
+    road_transform           corr 1.000000  max abs   0.0117  mean abs 0.00393   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.00853   (by error, pooled)
+
+frame 126: corr 0.999960  max abs 0.2578
+    action                   corr 0.999991  max abs   0.0156  mean abs 0.00438   (by error, pooled)
+    desire_pred              corr 0.999962  max abs   0.0547  mean abs 0.02731
+    desire_state             corr 0.999994  max abs   0.2188  mean abs 0.07812   (by error, pooled)
+    hidden_state             corr 0.999953  max abs   0.1113  mean abs 0.01155
+    lane_lines               corr 0.999968  max abs   0.0684  mean abs 0.01624
+    lane_lines_prob          corr 0.999971  max abs   0.1133  mean abs 0.04700   (by error, pooled)
+    lead                     corr 0.999937  max abs   0.2578  mean abs 0.02101
+    lead_prob                corr 0.999975  max abs   0.1094  mean abs 0.07161   (by error, pooled)
+    meta                     corr 0.999894  max abs   0.1211  mean abs 0.04689
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00547
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00515   (by error, pooled)
+    road_edges               corr 0.999966  max abs   0.1035  mean abs 0.01622
+    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00253   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0195  mean abs 0.00555   (by error, pooled)
+
+frame 127: corr 0.999965  max abs 0.1562
+    action                   corr 0.999996  max abs   0.0098  mean abs 0.00293   (by error, pooled)
+    desire_pred              corr 0.999952  max abs   0.0625  mean abs 0.03529
+    desire_state             corr 0.999996  max abs   0.1562  mean abs 0.06836   (by error, pooled)
+    hidden_state             corr 0.999957  max abs   0.1289  mean abs 0.01113
+    lane_lines               corr 0.999977  max abs   0.0527  mean abs 0.01463
+    lane_lines_prob          corr 0.999979  max abs   0.1328  mean abs 0.07121   (by error, pooled)
+    lead                     corr 0.999992  max abs   0.0410  mean abs 0.00503
+    lead_prob                corr 1.000000  max abs   0.0938  mean abs 0.08236   (by error, pooled)
+    meta                     corr 0.999921  max abs   0.1123  mean abs 0.03691
+    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
+    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00458
+    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00642   (by error, pooled)
+    road_edges               corr 0.999961  max abs   0.0801  mean abs 0.01637
+    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00351   (by error, pooled)
+    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00623   (by error, pooled)
+
+pooled over 128 frames, per slice and per column:
+    action                   corr 0.999979  by error, max abs 0.04883 <= 0.5352     max abs   0.0488  mean abs 0.00918
+    desire_pred              corr 0.999945  (compared whole)                        max abs   0.1211  mean abs 0.02895
+    desire_state             corr 0.999975  by error, max abs 0.4531 <= 5.253       max abs   0.4531  mean abs 0.08140
+    hidden_state             corr 0.999949  (compared whole)                        max abs   0.3125  mean abs 0.01328
+    lane_lines               corr 0.999954  worst col 0.999855 mu[1]                    max abs   0.2227  mean abs 0.01569
+    lane_lines_prob          corr 0.999883  by error, max abs 0.25 <= 0.7902        max abs   0.2500  mean abs 0.04763
+    lead                     corr 0.999978  worst col 0.999952 mu[0]    (4 by error)    max abs   1.9375  mean abs 0.03572
+    lead_prob                corr 0.999930  by error, max abs 0.2383 <= 0.9055      max abs   0.2383  mean abs 0.07485
+    meta                     corr 0.999907  (compared whole)                        max abs   0.1426  mean abs 0.03486
+    pad                      corr 1.000000  by error, max abs 0 <= 0                max abs   0.0000  mean abs 0.00000
+    plan                     corr 0.999987  worst col 0.999864 std[5]   (10 by error)   max abs   0.5625  mean abs 0.00823
+    pose                     corr 0.999988  no column correlated        (12 by error)   max abs   0.1484  mean abs 0.01025
+    road_edges               corr 0.999947  worst col 0.999837 mu[1]                    max abs   0.1812  mean abs 0.01831
+    road_transform           corr 0.999995  no column correlated        (12 by error)   max abs   0.0586  mean abs 0.00786
+    wide_from_device_euler   corr 0.999993  no column correlated        (6 by error)    max abs   0.0664  mean abs 0.00767
+
+OK: every slice and every column at or above corr 0.999, or within 10% of its largest value where too small or too quiet to correlate, per frame and pooled over all 128 frames
diff --git a/docs/evidence/sm8750-causal-prefill/results.json b/docs/evidence/sm8750-causal-prefill/results.json
new file mode 100644
index 00000000..f8d1a159
--- /dev/null
+++ b/docs/evidence/sm8750-causal-prefill/results.json
@@ -0,0 +1,124 @@
+{
+  "recorded_utc": "2026-10-19T21:26:39.479789+00:00",
+  "device": {
+    "model": "Xiaomi 15",
+    "soc": "SM8750",
+    "htp_arch": 79,
+    "android": 17,
+    "ram_gb": 12
+  },
+  "prototype_version": "0.8.7-xiaomi-parallel3",
+  "prototype_apk_sha256": "9d3d6ab5b8b50b4c3861cc9314e15a9c805f4f836ddc1e67befefa1f94a6d173",
+  "model_sha256": "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4",
+  "runtime": {
+    "ort": "1.29.0",
+    "qairt": "2.47.0.260601",
+    "htp_fp16": true,
+    "strict_cpu_fallback_disabled": true
+  },
+  "ten_minute": {
+    "mean_ms": 27.2,
+    "p99_ms": 29.5,
+    "max_ms": 36.2,
+    "verdict": "Fast Enough"
+  },
+  "frames": 12001,
+  "over_50_ms": 0,
+  "over_35_ms": 2,
+  "model_mean_ms": 26.8,
+  "conditions": {
+    "airplane_mode": true,
+    "wifi": false,
+    "bluetooth": false,
+    "pc_usb_power": true,
+    "mounted_in_car": false
+  },
+  "heat_and_power": {
+    "battery_start_celsius": 36.6,
+    "battery_end_celsius": 45.4,
+    "battery_start_percent": 62,
+    "battery_end_percent": 55,
+    "android_thermal_status_samples": [
+      0
+    ],
+    "all_61_window_labels": "Normal",
+    "pc_usb_maintained_charge": false
+  },
+  "accuracy": {
+    "preheat": {
+      "frames": 128,
+      "same_inputs": true,
+      "original_cpu_model_unchanged": true,
+      "own_recurrent_state_on_both": true,
+      "thresholds_changed": false,
+      "all_pass": true,
+      "compare_exit": 0,
+      "synthetic_frames": true
+    },
+    "postheat": {
+      "frames": 128,
+      "same_inputs": true,
+      "original_cpu_model_unchanged": true,
+      "own_recurrent_state_on_both": true,
+      "thresholds_changed": false,
+      "all_pass": true,
+      "compare_exit": 0,
+      "synthetic_frames": true
+    }
+  },
+  "api_stage_summary": {
+    "device": "htp-parallel-SM8750-fused4-qairt247-no-fusion-sharedio-causal-prefill-v1-5a159599-parallel",
+    "layers": [
+      [
+        0,
+        1
+      ],
+      [
+        2
+      ],
+      [
+        3
+      ]
+    ],
+    "mean_provider_call_overlap_ms": 22.06991302423647,
+    "parallel": true,
+    "providers": [
+      "QNN(htp)",
+      "QNN(gpu)",
+      "QNN(htp)",
+      "CPU"
+    ],
+    "runs_since_load": 12213,
+    "scope": "Synchronous provider API spans; not accelerator occupancy percentages. Includes warmup and correctness runs since load.",
+    "stage_mean_ms": [
+      22.202267282813395,
+      22.66791940817162,
+      2.0565780671415705,
+      1.8389383253090967
+    ]
+  },
+  "one_minute_controls": {
+    "npu_only": {
+      "mean_ms": 33.8,
+      "p99_ms": 34.7
+    },
+    "same_graphs_serial_shared": {
+      "mean_ms": 45.2,
+      "p99_ms": 47.2
+    },
+    "parallel_heap": {
+      "mean_ms": 27.6,
+      "p99_ms": 30.5
+    },
+    "parallel_shared": {
+      "mean_ms": 26.8,
+      "p99_ms": 29.0
+    }
+  },
+  "limits": [
+    "Synthetic benchmark, not a car or driving validation.",
+    "Sequential controls; temperature and clocks were not fixed or randomized.",
+    "Provider-call overlap is not hardware occupancy or proof of 100 percent NPU utilization.",
+    "Screenshot and hardware measurements are from the prototype; the upstream port is independently build/test checked."
+  ]
+}
diff --git a/docs/evidence/sm8750-causal-prefill/ten-minute.png b/docs/evidence/sm8750-causal-prefill/ten-minute.png
new file mode 100644
index 0000000000000000000000000000000000000000..280c11fb275b5789651dceb9518b58c702b94a2c
GIT binary patch
literal 238348
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

literal 0
HcmV?d00001

diff --git a/docs/evidence/sm8750-causal-prefill/windows.json b/docs/evidence/sm8750-causal-prefill/windows.json
new file mode 100644
index 00000000..e60fc5c9
--- /dev/null
+++ b/docs/evidence/sm8750-causal-prefill/windows.json
@@ -0,0 +1,312 @@
+{
+  "windows": [
+    {
+      "start_second": 0,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 10,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 20,
+      "p99_ms": 29.8,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 30,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 40,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 50,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 60,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 70,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 80,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 90,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 100,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 110,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 120,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 130,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 140,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 150,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 160,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 170,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 180,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 190,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 200,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 210,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 220,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 230,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 240,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 250,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 260,
+      "p99_ms": 30.8,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 270,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 280,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 290,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 300,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 310,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 320,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 330,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 340,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 350,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 360,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 370,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 380,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 390,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 400,
+      "p99_ms": 29.9,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 410,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 420,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 430,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 440,
+      "p99_ms": 29.9,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 450,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 460,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 470,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 480,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 490,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 500,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 510,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 520,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 530,
+      "p99_ms": 30.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 540,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 550,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 560,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 570,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 580,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 590,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 600,
+      "p99_ms": 27.1,
+      "thermal": "Normal"
+    }
+  ],
+  "all_normal": true,
+  "min_window_p99_ms": 27.1,
+  "max_window_p99_ms": 30.8
+}
\ No newline at end of file

From 911d36332cb5537522c7ea91f2079bc22461887a Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:23:43 +0200
Subject: [PATCH 18/35] prefill: scripts/android

---
 .../android/causal-prefill-cut-points.json    | 110 +++++++
 scripts/android/causal-prefill-manifest.json  | 136 +++++++++
 scripts/android/compile_causal_prefill.py     | 278 ++++++++++++++++++
 .../android/requirements-causal-prefill.txt   |   3 +
 4 files changed, 527 insertions(+)
 create mode 100644 scripts/android/causal-prefill-cut-points.json
 create mode 100644 scripts/android/causal-prefill-manifest.json
 create mode 100644 scripts/android/compile_causal_prefill.py
 create mode 100644 scripts/android/requirements-causal-prefill.txt

diff --git a/scripts/android/causal-prefill-cut-points.json b/scripts/android/causal-prefill-cut-points.json
new file mode 100644
index 00000000..c16a3fba
--- /dev/null
+++ b/scripts/android/causal-prefill-cut-points.json
@@ -0,0 +1,110 @@
+[
+  {
+    "name": "vision",
+    "file": "vision.onnx",
+    "unit": "htp",
+    "after": [],
+    "inputs": [
+      "new_img",
+      "state_img_q"
+    ],
+    "outputs": [
+      "view_39",
+      "linear_76",
+      "linear_77",
+      "linear_78",
+      "linear_79",
+      "linear_80",
+      "mul_36",
+      "linear_82",
+      "linear_81",
+      "view_60",
+      "next_state_img_q"
+    ],
+    "nodes": 500,
+    "weight_bytes": 705804828,
+    "sha256": "56c0b305332e0de7ba2388c530287d3169c552a98ddd752520f4ef3766c1035f"
+  },
+  {
+    "name": "off",
+    "file": "off.onnx",
+    "unit": "htp",
+    "after": [
+      "vision"
+    ],
+    "inputs": [
+      "view_39",
+      "desire",
+      "traffic_convention",
+      "action_t",
+      "state_desire_q",
+      "state_feat_q"
+    ],
+    "outputs": [
+      "mul_41",
+      "mul_42",
+      "linear_120",
+      "linear_126",
+      "next_state_desire_q"
+    ],
+    "nodes": 230,
+    "weight_bytes": 32757604,
+    "sha256": "14304ea9fe4ca891ae7fb9a9c0e6f20c479837653944c4ff72777373adc52215"
+  },
+  {
+    "name": "on",
+    "file": "on.onnx",
+    "unit": "gpu",
+    "after": [
+      "vision"
+    ],
+    "inputs": [
+      "view_39",
+      "desire",
+      "traffic_convention",
+      "action_t",
+      "state_desire_q",
+      "state_feat_q"
+    ],
+    "outputs": [
+      "mul_48"
+    ],
+    "nodes": 208,
+    "weight_bytes": 25287078,
+    "sha256": "85d7c83ec14f8bafd7ae899ffb3f905840edf8c85de0b1a6ba1de41c315d903e"
+  },
+  {
+    "name": "join",
+    "file": "join.onnx",
+    "unit": "cpu",
+    "after": [
+      "vision",
+      "off",
+      "on"
+    ],
+    "inputs": [
+      "linear_76",
+      "linear_77",
+      "linear_78",
+      "linear_79",
+      "linear_80",
+      "mul_36",
+      "linear_82",
+      "linear_81",
+      "view_60",
+      "mul_41",
+      "mul_42",
+      "linear_120",
+      "linear_126",
+      "mul_48",
+      "state_feat_q"
+    ],
+    "outputs": [
+      "outputs",
+      "next_state_feat_q"
+    ],
+    "nodes": 6,
+    "weight_bytes": 44,
+    "sha256": "014a7415f2a15b6278e2217957ac8e5e65beeac55a2033fc123bfd3284cfb2e3"
+  }
+]
\ No newline at end of file
diff --git a/scripts/android/causal-prefill-manifest.json b/scripts/android/causal-prefill-manifest.json
new file mode 100644
index 00000000..b77f21e3
--- /dev/null
+++ b/scripts/android/causal-prefill-manifest.json
@@ -0,0 +1,136 @@
+{
+  "format": 1,
+  "strategy": "causal-prefill-v1",
+  "source_model_sha256": "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4",
+  "prepared_model_sha256": "4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166",
+  "parts": [
+    {
+      "name": "vision",
+      "file": "vision.onnx",
+      "unit": "htp",
+      "nodes": 500,
+      "weight_bytes": 705804828,
+      "inputs": [
+        "new_img",
+        "state_img_q"
+      ],
+      "outputs": [
+        "view_39",
+        "linear_76",
+        "linear_77",
+        "linear_78",
+        "linear_79",
+        "linear_80",
+        "mul_36",
+        "linear_82",
+        "linear_81",
+        "view_60",
+        "next_state_img_q"
+      ],
+      "sha256": "49a4c1c1778884f87f26360d4256e6238f059a8f840c136c614ebabd548d59bc"
+    },
+    {
+      "name": "history",
+      "file": "history.onnx",
+      "unit": "gpu",
+      "nodes": 327,
+      "weight_bytes": 40836830,
+      "inputs": [
+        "desire",
+        "traffic_convention",
+        "action_t",
+        "state_desire_q",
+        "state_feat_q"
+      ],
+      "outputs": [
+        "prefill_0_key",
+        "prefill_0_value",
+        "prefill_1_key",
+        "prefill_1_value",
+        "prefill_2_key",
+        "prefill_2_value",
+        "prefill_3_key",
+        "prefill_3_value",
+        "prefill_4_key",
+        "prefill_4_value",
+        "prefill_5_key",
+        "prefill_5_value",
+        "prefill_6_key",
+        "prefill_6_value",
+        "prefill_7_key",
+        "prefill_7_value"
+      ],
+      "sha256": "1370a34bbdb94027f1a99e833f09c639a904f7b716ede3de51cfe04aef73f359"
+    },
+    {
+      "name": "decode",
+      "file": "decode.onnx",
+      "unit": "htp",
+      "nodes": 422,
+      "weight_bytes": 57434348,
+      "inputs": [
+        "view_39",
+        "desire",
+        "traffic_convention",
+        "action_t",
+        "state_desire_q",
+        "prefill_0_key",
+        "prefill_0_value",
+        "prefill_1_key",
+        "prefill_1_value",
+        "prefill_2_key",
+        "prefill_2_value",
+        "prefill_3_key",
+        "prefill_3_value",
+        "prefill_4_key",
+        "prefill_4_value",
+        "prefill_5_key",
+        "prefill_5_value",
+        "prefill_6_key",
+        "prefill_6_value",
+        "prefill_7_key",
+        "prefill_7_value"
+      ],
+      "outputs": [
+        "mul_41",
+        "mul_42",
+        "linear_120",
+        "linear_126",
+        "mul_48"
+      ],
+      "sha256": "ce475ff23e7740281ae1a894c8eb332c0c2486e5701e38c0f55d7b21e0e56e52"
+    },
+    {
+      "name": "join",
+      "file": "join.onnx",
+      "unit": "cpu",
+      "nodes": 9,
+      "weight_bytes": 68,
+      "inputs": [
+        "linear_76",
+        "linear_77",
+        "linear_78",
+        "linear_79",
+        "linear_80",
+        "mul_36",
+        "linear_82",
+        "linear_81",
+        "view_60",
+        "mul_41",
+        "mul_42",
+        "linear_120",
+        "linear_126",
+        "mul_48",
+        "state_feat_q",
+        "desire",
+        "state_desire_q"
+      ],
+      "outputs": [
+        "outputs",
+        "next_state_feat_q",
+        "next_state_desire_q"
+      ],
+      "sha256": "a4e72d70d8580283d1ba21af3b458fc4eca3dcf4e0ab3f01eda41a761a78873f"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/scripts/android/compile_causal_prefill.py b/scripts/android/compile_causal_prefill.py
new file mode 100644
index 00000000..cae4d41b
--- /dev/null
+++ b/scripts/android/compile_causal_prefill.py
@@ -0,0 +1,278 @@
+"""Exact causal past/current partition of the audited Cinque V3 fp16 graph.
+
+Vision and past-token computation are independent in the same frame. The decoder
+waits for both and uses every original past/current attention key and value.
+No model parameters, recurrent feedback, frame IDs, or accuracy gates change.
+"""
+
+from pathlib import Path
+import copy
+import hashlib
+import json
+import numpy as np
+import onnx
+from onnx import helper as h, numpy_helper as nh
+from onnx.utils import Extractor
+
+import argparse
+import subprocess
+import tempfile
+
+parser = argparse.ArgumentParser(description=__doc__)
+parser.add_argument("--model", type=Path, required=True, help="original Cinque V3 model")
+parser.add_argument("--out", type=Path, required=True)
+parser.add_argument("--base-tool", type=Path, required=True, help="built jetlink-prefill-base executable")
+args = parser.parse_args()
+assert onnx.__version__ == "1.23.2", "reproduction is pinned to onnx==1.23.2"
+assert np.__version__ == "2.5.4", "reproduction is pinned to numpy==2.5.4"
+assert hashlib.sha256(args.model.read_bytes()).hexdigest() == "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4", (
+  "only the validated Cinque V3 export is supported"
+)
+OUT = args.out.resolve()
+OUT.mkdir(parents=True, exist_ok=True)
+assert not any(OUT.iterdir()), "choose an empty output directory"
+temporary = tempfile.TemporaryDirectory(prefix="jetlink-prefill-base-")
+source = Path(temporary.name) / "model.onnx"
+subprocess.run([str(args.base_tool.resolve()), str(args.model.resolve()), temporary.name], check=True)
+assert hashlib.sha256(source.read_bytes()).hexdigest() == "4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166", (
+  "base graph differs from the phone-validated graph"
+)
+m = onnx.load(source)
+ex = Extractor(m)
+plan = json.loads(Path(__file__).with_name("causal-prefill-cut-points.json").read_text())
+vision_terms = plan[0]['outputs'][1:-1]
+policy_terms = [*plan[1]['outputs'][:-1], *plan[2]['outputs']]
+original_inputs = [v.name for v in m.graph.input]
+other_inputs = [v for v in original_inputs if v not in ['new_img', 'state_img_q']]
+policy = ex.extract_model(['view_39', *other_inputs], policy_terms)
+shapes = {v.name: copy.deepcopy(v) for v in [*policy.graph.input, *policy.graph.output, *policy.graph.value_info]}
+producer = {s: n for n in policy.graph.node for s in n.output}
+users = {}
+for n in policy.graph.node:
+  for s in n.input:
+    users.setdefault(s, []).append(n)
+attention = []
+for n in policy.graph.node:
+  if n.op_type != 'Softmax':
+    continue
+  where = producer[n.input[0]]
+  assert where.op_type == 'Where'
+  negative_mask = producer[where.input[0]]
+  assert negative_mask.op_type == 'Not'
+  score = producer[where.input[2]]
+  assert score.op_type == 'Mul'
+  qk = producer[score.input[0]]
+  assert qk.op_type == 'MatMul'
+  kt = producer[qk.input[1]]
+  assert kt.op_type == 'Transpose'
+  av = [x for x in users[n.output[0]] if x.op_type == 'MatMul']
+  assert len(av) == 1 and av[0].input[0] == n.output[0]
+  attention.append({'mask': negative_mask.input[0], 'key': kt.input[0], 'value': av[0].input[1], 'key_transpose': kt.name, 'value_product': av[0].name})
+assert len(attention) == 8
+
+
+def prune(model):
+  g = model.graph
+  producers = {s: n for n in g.node for s in n.output}
+  needed = {v.name for v in g.output}
+  pending = list(needed)
+  nodes = set()
+  while pending:
+    s = pending.pop()
+    if s not in producers:
+      continue
+    node = producers[s]
+    if node.name in nodes:
+      continue
+    nodes.add(node.name)
+    for i in node.input:
+      if i and i not in needed:
+        needed.add(i)
+        pending.append(i)
+  kept = [n for n in g.node if n.name in nodes]
+  del g.node[:]
+  g.node.extend(kept)
+  for field in ['initializer', 'input']:
+    seq = getattr(g, field)
+    retained = [v for v in seq if v.name in needed]
+    del seq[:]
+    seq.extend(retained)
+  del g.value_info[:]
+  model = onnx.shape_inference.infer_shapes(model, strict_mode=True, data_prop=True)
+  onnx.checker.check_model(model, full_check=True)
+  return model
+
+
+def make(role):
+  part = copy.deepcopy(policy)
+  g = part.graph
+  init = {v.name: v for v in g.initializer}
+  prod = {s: n for n in g.node for s in n.output}
+  length = 256 if role == 'history' else 32
+  blocks = 8 if role == 'history' else 1
+
+  def constant(name, arr):
+    t = nh.from_array(np.asarray(arr), name)
+    if name in init:
+      init[name].CopyFrom(t)
+    else:
+      g.initializer.append(t)
+      init[name] = g.initializer[-1]
+    return name
+
+  # The eight historical feature blocks are 24...31 of the 32-block
+  # historical window. The ninth block is the current view_39 image feature.
+  old_idx = nh.to_array(init['val_551'])
+  assert old_idx.shape == (9, 1) and np.array_equal(old_idx.reshape(-1), np.arange(-9, 0))
+  if role == 'history':
+    cat = prod['cat_3']
+    assert cat.op_type == 'Concat' and list(cat.input) == ['_to_copy_1', 'unsqueeze_1']
+    cat.CopyFrom(h.make_node('Identity', ['_to_copy_1'], ['cat_3'], name='prefill_history_only'))
+    constant('val_551', (old_idx + 33)[:8].astype(np.int64))
+  else:
+    index = prod['index']
+    index.CopyFrom(h.make_node('Unsqueeze', ['view_39', 'val_3'], ['index'], name='prefill_current_only'))
+  # Desire windows and temporal positions are token-local embedding inputs.
+  desire_indices = nh.to_array(init['val_569']).reshape(9, 25)
+  constant('val_569', (desire_indices[:8] if role == 'history' else desire_indices[8:]).reshape(-1))
+  # Temporal position broadcasts must select the same absolute positions.
+  temporal = ['unsqueeze_4', 'unsqueeze_8']
+  for name in temporal:
+    if name in init:
+      a = nh.to_array(init[name])
+      assert list(a.shape) == [9, 1, 512], (name, a.shape)
+      constant(name + '__' + role, a[:8] if role == 'history' else a[8:])
+  nodes = []
+  for n in g.node:
+    nodes.append(n)
+    for name in temporal:
+      if name not in n.output:
+        continue
+      output = name + '__' + role
+      start = 0 if role == 'history' else 8
+      end = 8 if role == 'history' else 9
+      args = [
+        constant(output + '__start', np.array([start], np.int64)),
+        constant(output + '__end', np.array([end], np.int64)),
+        constant(output + '__axis', np.array([0], np.int64)),
+      ]
+      nodes.append(h.make_node('Slice', [name, *args], [output], name=output))
+  # Retarget only consumers of the positions, leaving the Slice source intact.
+  for n in nodes:
+    if n.op_type == 'Slice' and n.name.endswith('__' + role):
+      continue
+    for i, s in enumerate(n.input):
+      if s in temporal:
+        n.input[i] = s + '__' + role
+  del g.node[:]
+  g.node.extend(nodes)
+  # Clone shape constants for each Reshape so no unrelated shape changes.
+  for n in g.node:
+    if n.op_type != 'Reshape' or n.input[1] not in init:
+      continue
+    a = nh.to_array(init[n.input[1]])
+    if not np.any((a == 288) | (a == 9)):
+      continue
+    b = np.where(a == 288, length, np.where(a == 9, blocks, a))
+    n.input[1] = constant(n.input[1] + '__' + role, b)
+  # Causal attention allows past queries to be evaluated without current data.
+  for info in attention:
+    mask = nh.to_array(init[info['mask']])
+    assert mask.shape == (1, 1, 288, 288) and not mask[:, :, :256, 256:].any()
+    selected = mask[:, :, :256, :256] if role == 'history' else mask[:, :, 256:, :]
+    constant(info['mask'], selected)
+  past = []
+  insert_before = {}
+  renamed = {}
+  for i, info in enumerate(attention):
+    for kind in ['key', 'value']:
+      current = info[kind]
+      cached = f'prefill_{i}_{kind}'
+      past.append(h.make_tensor_value_info(cached, onnx.TensorProto.FLOAT16, [1, 8, 256, 64]))
+      if role == 'history':
+        # A named graph output may still feed later layers. QNN GPU
+        # rejects output Identity aliases in that case; rename the
+        # producer and all consumers instead, with no arithmetic op.
+        renamed[current] = cached
+      else:
+        target = info['key_transpose'] if kind == 'key' else info['value_product']
+        joined = f'{cached}__with_current'
+        insert_before.setdefault(target, []).append(h.make_node('Concat', [cached, current], [joined], name=joined, axis=2))
+        node = next(n for n in g.node if n.name == target)
+        node.input[0 if kind == 'key' else 1] = joined
+  if role == 'history':
+    for n in g.node:
+      for field in [n.input, n.output]:
+        for at, value in enumerate(field):
+          if value in renamed:
+            field[at] = renamed[value]
+    del g.output[:]
+    g.output.extend(past)
+  else:
+    g.input.extend(past)
+    ordered = []
+    for n in g.node:
+      ordered.extend(insert_before.get(n.name, []))
+      ordered.append(n)
+      if n.op_type == 'Gather' and n.input[1] in init:
+        a = nh.to_array(init[n.input[1]])
+        if a.size == 1 and int(a.reshape(-1)[0]) == 287:
+          n.input[1] = constant(n.input[1] + '__' + role, np.array(31, dtype=a.dtype))
+    del g.node[:]
+    g.node.extend(ordered)
+  part = prune(part)
+  assert ('view_39' not in [v.name for v in part.graph.input]) == (role == 'history')
+  if role == 'decode':
+    assert 'state_feat_q' not in [v.name for v in part.graph.input]
+  return part
+
+
+records = []
+models = [
+  ('vision', ex.extract_model(['new_img', 'state_img_q'], plan[0]['outputs']), 'htp'),
+  ('history', make('history'), 'gpu'),
+  ('decode', make('decode'), 'htp'),
+  (
+    'join',
+    ex.extract_model([*vision_terms, *policy_terms, 'state_feat_q', 'desire', 'state_desire_q'], ['outputs', 'next_state_feat_q', 'next_state_desire_q']),
+    'cpu',
+  ),
+]
+for name, part, unit in models:
+  part = prune(part)
+  path = OUT / (name + '.onnx')
+  onnx.save(part, path)
+  onnx.checker.check_model(str(path), full_check=True)
+  record = {
+    'name': name,
+    'file': path.name,
+    'unit': unit,
+    'nodes': len(part.graph.node),
+    'weight_bytes': sum(len(t.raw_data) for t in part.graph.initializer),
+    'inputs': [v.name for v in part.graph.input],
+    'outputs': [v.name for v in part.graph.output],
+    'sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+  }
+  records.append(record)
+  print(json.dumps(record), flush=True)
+(OUT / 'plan.json').write_text(json.dumps(records, indent=2))
+(OUT / 'manifest.json').write_text(
+  json.dumps(
+    {
+      'format': 1,
+      'strategy': 'causal-prefill-v1',
+      'source_model_sha256': '404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4',
+      'prepared_model_sha256': '4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166',
+      'parts': records,
+    },
+    indent=2,
+  )
+)
+print('Saved exact same-frame (vision || history) -> decode -> join.', flush=True)
+
+expected = json.loads(Path(__file__).with_name("causal-prefill-manifest.json").read_text())
+assert (OUT / "manifest.json").read_bytes() == Path(__file__).with_name("causal-prefill-manifest.json").read_bytes(), (
+  "generated bundle differs from the validated bundle"
+)
+print("All four generated graph hashes and the manifest exactly match the phone-tested bundle.")
+temporary.cleanup()
diff --git a/scripts/android/requirements-causal-prefill.txt b/scripts/android/requirements-causal-prefill.txt
new file mode 100644
index 00000000..7a49b3a4
--- /dev/null
+++ b/scripts/android/requirements-causal-prefill.txt
@@ -0,0 +1,3 @@
+onnx==1.23.2
+numpy==2.5.4
+onnxruntime==1.29.0

From e681e507b5e83384f3316da1d25b4cce823e5ea9 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Tue, 20 Oct 2026 00:25:06 +0200
Subject: [PATCH 19/35] prefill: docs/evidence/sm8750-causal-prefill

---
 .../sm8750-causal-prefill/windows.json        | 622 +++++++++---------
 1 file changed, 311 insertions(+), 311 deletions(-)

diff --git a/docs/evidence/sm8750-causal-prefill/windows.json b/docs/evidence/sm8750-causal-prefill/windows.json
index e60fc5c9..5ac166f6 100644
--- a/docs/evidence/sm8750-causal-prefill/windows.json
+++ b/docs/evidence/sm8750-causal-prefill/windows.json
@@ -1,312 +1,312 @@
-{
-  "windows": [
-    {
-      "start_second": 0,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 10,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 20,
-      "p99_ms": 29.8,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 30,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 40,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 50,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 60,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 70,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 80,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 90,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 100,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 110,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 120,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 130,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 140,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 150,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 160,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 170,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 180,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 190,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 200,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 210,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 220,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 230,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 240,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 250,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 260,
-      "p99_ms": 30.8,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 270,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 280,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 290,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 300,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 310,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 320,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 330,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 340,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 350,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 360,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 370,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 380,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 390,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 400,
-      "p99_ms": 29.9,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 410,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 420,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 430,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 440,
-      "p99_ms": 29.9,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 450,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 460,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 470,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 480,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 490,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 500,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 510,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 520,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 530,
-      "p99_ms": 30.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 540,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 550,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 560,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 570,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 580,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 590,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 600,
-      "p99_ms": 27.1,
-      "thermal": "Normal"
-    }
-  ],
-  "all_normal": true,
-  "min_window_p99_ms": 27.1,
-  "max_window_p99_ms": 30.8
+{
+  "windows": [
+    {
+      "start_second": 0,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 10,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 20,
+      "p99_ms": 29.8,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 30,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 40,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 50,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 60,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 70,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 80,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 90,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 100,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 110,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 120,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 130,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 140,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 150,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 160,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 170,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 180,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 190,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 200,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 210,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 220,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 230,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 240,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 250,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 260,
+      "p99_ms": 30.8,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 270,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 280,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 290,
+      "p99_ms": 29.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 300,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 310,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 320,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 330,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 340,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 350,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 360,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 370,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 380,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 390,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 400,
+      "p99_ms": 29.9,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 410,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 420,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 430,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 440,
+      "p99_ms": 29.9,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 450,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 460,
+      "p99_ms": 29.3,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 470,
+      "p99_ms": 29.1,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 480,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 490,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 500,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 510,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 520,
+      "p99_ms": 29.6,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 530,
+      "p99_ms": 30.0,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 540,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 550,
+      "p99_ms": 29.2,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 560,
+      "p99_ms": 29.5,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 570,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 580,
+      "p99_ms": 29.4,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 590,
+      "p99_ms": 29.7,
+      "thermal": "Normal"
+    },
+    {
+      "start_second": 600,
+      "p99_ms": 27.1,
+      "thermal": "Normal"
+    }
+  ],
+  "all_normal": true,
+  "min_window_p99_ms": 27.1,
+  "max_window_p99_ms": 30.8
 }
\ No newline at end of file

From 39cbd9a92b8598ef1ebc1006b973da2858f0d382 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:50:12 +0200
Subject: [PATCH 20/35] QNN: remove device-pinned research adapter

---
 android/qnn/build.sh               |  36 -------
 android/qnn/graph_tuning.c         | 159 -----------------------------
 android/qnn/qairt-2.47-sha256.json |  10 --
 android/qnn/test_graph_tuning.c    |  83 ---------------
 4 files changed, 288 deletions(-)
 delete mode 100644 android/qnn/build.sh
 delete mode 100644 android/qnn/graph_tuning.c
 delete mode 100644 android/qnn/qairt-2.47-sha256.json
 delete mode 100644 android/qnn/test_graph_tuning.c

diff --git a/android/qnn/build.sh b/android/qnn/build.sh
deleted file mode 100644
index ea40bd28..00000000
--- a/android/qnn/build.sh
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-# Supply an independently obtained QAIRT 2.47 SDK; no vendor code is downloaded.
-set -euo pipefail
-HERE="$(cd "$(dirname "$0")" && pwd)"
-: "${QNN_SDK_ROOT:?set QNN_SDK_ROOT to the QAIRT 2.47 SDK}"
-: "${ANDROID_NDK_HOME:?set ANDROID_NDK_HOME to NDK r30}"
-OUT=${1:?usage: android/qnn/build.sh OUTPUT_JNILIBS_DIRECTORY}
-INCLUDE="$QNN_SDK_ROOT/include/QNN"
-[[ -d "$INCLUDE" ]] || INCLUDE="$QNN_SDK_ROOT/include"
-BUILD=$(mktemp -d)
-trap 'rm -rf "$BUILD"' EXIT
-FLAGS=(-std=gnu11 -Wall -Wextra -Werror -I "$INCLUDE")
-cc "${FLAGS[@]}" -fPIC -shared "$HERE/test_graph_tuning.c" -DFAKE_BACKEND -o "$BUILD/libQnnHtp.so"
-cc "${FLAGS[@]}" -fPIC -shared "$HERE/graph_tuning.c" -ldl -pthread -o "$BUILD/libJetlinkQnnHtp.so"
-cc "${FLAGS[@]}" "$HERE/test_graph_tuning.c" -ldl -o "$BUILD/test-tuning"
-for setting in stock:0 memory:1 accurate:14 memory-accurate:15 no-fusion:2 no-short-hmx:4 high-sigmoid:8 invalid:0; do
-  JETLINK_QNN_TUNING="${setting%:*}" EXPECTED_FLAGS="${setting#*:}" "$BUILD/test-tuning" "$BUILD/libJetlinkQnnHtp.so"
-done
-TOOLCHAIN="$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin"
-mkdir -p "$OUT/arm64-v8a"
-"$TOOLCHAIN/aarch64-linux-android31-clang" "${FLAGS[@]}" -fPIC -shared "$HERE/graph_tuning.c" \
-  -ldl -llog -pthread -Wl,-z,relro,-z,now -o "$OUT/arm64-v8a/libJetlinkQnnHtp.so"
-python3 - "$QNN_SDK_ROOT" "$OUT/arm64-v8a" "$HERE/qairt-2.47-sha256.json" <<'PY'
-import hashlib
-import json
-from pathlib import Path
-import shutil
-import sys
-sdk, out, manifest = map(Path, sys.argv[1:])
-for name, expected in json.loads(manifest.read_text()).items():
-    matches = [p for p in sdk.rglob(name) if p.is_file() and hashlib.sha256(p.read_bytes()).hexdigest() == expected]
-    if not matches:
-        raise SystemExit(f"No byte-matched QAIRT 2.47 library found: {name}")
-    shutil.copyfile(matches[0], out / name)
-print("Eight byte-matched vendor libraries and the tested graph adapter are ready.")
-PY
diff --git a/android/qnn/graph_tuning.c b/android/qnn/graph_tuning.c
deleted file mode 100644
index 188215f7..00000000
--- a/android/qnn/graph_tuning.c
+++ /dev/null
@@ -1,159 +0,0 @@
-// Research adapter over the public QNN API; one real, version-matched HTP backend.
-// Lets ORT use documented HTP graph options its provider does not expose.
-#define _GNU_SOURCE
-#include <dlfcn.h>
-#include <pthread.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "QnnInterface.h"
-#include "HTP/QnnHtpCommon.h"
-#include "HTP/QnnHtpGraph.h"
-#ifdef __ANDROID__
-#include <android/log.h>
-#define TUNE_LOG(...) __android_log_print(ANDROID_LOG_INFO, "JetlinkQnnTune", __VA_ARGS__)
-#else
-#define TUNE_LOG(...) ((void)0)
-#endif
-
-static pthread_once_t initialized = PTHREAD_ONCE_INIT;
-static void *backend;
-static QnnInterface_t wrapped;
-static const QnnInterface_t *provider_list[] = {&wrapped};
-static QnnGraph_CreateFn_t real_create;
-static QnnContext_FreeFn_t real_context_free;
-static Qnn_ErrorHandle_t init_status = QNN_COMMON_ERROR_GENERAL;
-
-// Keep our configuration storage valid for the whole context lifetime. This
-// also accommodates backends that consume a setting during graph finalization.
-typedef struct ConfigStorage {
-  struct ConfigStorage *next;
-  Qnn_ContextHandle_t context;
-  QnnHtpGraph_CustomConfig_t custom[4];
-  QnnGraph_Config_t config[4];
-  const QnnGraph_Config_t *all[];
-} ConfigStorage;
-static ConfigStorage *retained;
-static pthread_mutex_t retained_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static Qnn_ErrorHandle_t tuned_context_free(Qnn_ContextHandle_t context,
-    Qnn_ProfileHandle_t profile) {
-  Qnn_ErrorHandle_t status = real_context_free(context, profile);
-  if (status != QNN_SUCCESS) return status;
-  pthread_mutex_lock(&retained_mutex);
-  ConfigStorage **link = &retained;
-  while (*link != NULL) {
-    ConfigStorage *entry = *link;
-    if (entry->context == context) {
-      *link = entry->next;
-      free(entry);
-    } else {
-      link = &entry->next;
-    }
-  }
-  pthread_mutex_unlock(&retained_mutex);
-  return status;
-}
-
-static Qnn_ErrorHandle_t tuned_create(Qnn_ContextHandle_t context, const char *name,
-    const QnnGraph_Config_t **original, Qnn_GraphHandle_t *graph) {
-  const char *tuning = getenv("JETLINK_QNN_TUNING");
-  TUNE_LOG("graphCreate graph=%s tuning=%s", name ? name : "", tuning ? tuning : "stock");
-  if (tuning == NULL || strcmp(tuning, "stock") == 0) {
-    return real_create(context, name, original, graph);
-  }
-  bool memory = strcmp(tuning, "memory") == 0 || strcmp(tuning, "memory-accurate") == 0;
-  bool accurate = strcmp(tuning, "accurate") == 0 || strcmp(tuning, "memory-accurate") == 0;
-  bool no_fusion = accurate || strcmp(tuning, "no-fusion") == 0;
-  bool no_short_hmx = accurate || strcmp(tuning, "no-short-hmx") == 0;
-  bool high_sigmoid = accurate || strcmp(tuning, "high-sigmoid") == 0;
-  if (!memory && !no_fusion && !no_short_hmx && !high_sigmoid) {
-    return QNN_COMMON_ERROR_INVALID_ARGUMENT;
-  }
-  size_t n_original = 0;
-  if (original != NULL) {
-    while (n_original < 128 && original[n_original] != NULL) ++n_original;
-    if (n_original == 128) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
-  }
-  ConfigStorage *storage = calloc(1, sizeof(*storage) + (n_original + 5) * sizeof(*storage->all));
-  if (storage == NULL) return QNN_COMMON_ERROR_MEM_ALLOC;
-  storage->context = context;
-  const QnnGraph_Config_t **all = storage->all;
-  for (size_t i=0; i<n_original; ++i) all[i]=original[i];
-  QnnHtpGraph_CustomConfig_t *custom = storage->custom;
-  QnnGraph_Config_t *config = storage->config;
-  size_t count = 0;
-#define ADD_CONFIG(OPTION, FIELD, VALUE) do { \
-    custom[count].option = OPTION; custom[count].FIELD = VALUE; \
-    config[count].option = QNN_GRAPH_CONFIG_OPTION_CUSTOM; \
-    config[count].customConfig = &custom[count]; \
-    all[n_original + count] = &config[count]; ++count; \
-  } while (0)
-  if (memory) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_VTCM_SIZE, vtcmSizeInMB, QNN_HTP_GRAPH_CONFIG_OPTION_MAX);
-  if (no_fusion) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION, advancedActivationFusion, false);
-  if (no_short_hmx) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_SHORT_DEPTH_CONV_ON_HMX_OFF, shortDepthConvOnHmxOff, true);
-  if (high_sigmoid) ADD_CONFIG(QNN_HTP_GRAPH_CONFIG_OPTION_HIGH_PRECISION_SIGMOID, highPrecisionSigmoid, true);
-#undef ADD_CONFIG
-  Qnn_ErrorHandle_t status = real_create(context, name, all, graph);
-  TUNE_LOG("graphCreate added=%zu status=%llu", count, (unsigned long long)status);
-  if (status == QNN_SUCCESS) {
-    pthread_mutex_lock(&retained_mutex);
-    storage->next = retained;
-    retained = storage;
-    pthread_mutex_unlock(&retained_mutex);
-  } else {
-    free(storage);
-  }
-  return status;
-}
-
-static void initialize(void) {
-  Dl_info location;
-  if (dladdr((void *)&initialize, &location) == 0 || location.dli_fname == NULL) return;
-  const char *slash = strrchr(location.dli_fname, '/');
-  if (slash == NULL) return;
-  char path[4096];
-  if (snprintf(path, sizeof(path), "%.*s/libQnnHtp.so", (int)(slash-location.dli_fname), location.dli_fname) >= (int)sizeof(path)) return;
-  backend = dlopen(path, RTLD_NOW | RTLD_LOCAL);
-  if (backend == NULL) {
-    fprintf(stderr, "Jetlink QNN adapter: cannot open the matched HTP backend: %s\n", dlerror());
-    return;
-  }
-  typedef Qnn_ErrorHandle_t (*GetProviders)(const QnnInterface_t ***, uint32_t *);
-  GetProviders get = (GetProviders)dlsym(backend, "QnnInterface_getProviders");
-  if (get == NULL) return;
-  const QnnInterface_t **providers = NULL;
-  uint32_t count = 0;
-  if (get(&providers, &count) != QNN_SUCCESS) return;
-  for (uint32_t i=0; i<count; ++i) {
-    const QnnInterface_t *p = providers[i];
-    if (p == NULL || p->backendId != QNN_BACKEND_ID_HTP ||
-        p->apiVersion.coreApiVersion.major != QNN_API_VERSION_MAJOR ||
-        p->apiVersion.coreApiVersion.minor < QNN_API_VERSION_MINOR) continue;
-    wrapped = *p;
-    real_create = p->QNN_INTERFACE_VER_NAME.graphCreate;
-    real_context_free = p->QNN_INTERFACE_VER_NAME.contextFree;
-    if (real_create == NULL || real_context_free == NULL) return;
-    wrapped.QNN_INTERFACE_VER_NAME.graphCreate = tuned_create;
-    wrapped.QNN_INTERFACE_VER_NAME.contextFree = tuned_context_free;
-    const char *build_id = "unavailable";
-    if (p->QNN_INTERFACE_VER_NAME.backendGetBuildId != NULL) {
-      p->QNN_INTERFACE_VER_NAME.backendGetBuildId(&build_id);
-    }
-    TUNE_LOG("backend core=%u.%u build=%s", p->apiVersion.coreApiVersion.major,
-             p->apiVersion.coreApiVersion.minor, build_id ? build_id : "unavailable");
-    init_status = QNN_SUCCESS;
-    return;
-  }
-}
-
-Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***providers, uint32_t *count) {
-  if (providers == NULL || count == NULL) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
-  pthread_once(&initialized, initialize);
-  if (init_status != QNN_SUCCESS) return init_status;
-  *providers = provider_list;
-  *count = 1;
-  return QNN_SUCCESS;
-}
diff --git a/android/qnn/qairt-2.47-sha256.json b/android/qnn/qairt-2.47-sha256.json
deleted file mode 100644
index 651d63ae..00000000
--- a/android/qnn/qairt-2.47-sha256.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "libQnnGpu.so": "76f85140bb969b554660dc846c4ee900d5c5b645b5942667f87972b8a880e371",
-  "libQnnHtp.so": "c0488f2df87932a42ca0a563883e6fba190896bca439ad0fdaa2428358ab5092",
-  "libQnnHtpPrepare.so": "9988ce10ffee6813ffd218df308478f44dbc758cc89aed9cb98cfebb030ca72e",
-  "libQnnHtpV79Skel.so": "dd8987c17928e53877e51ce5739c550d3e74393bd5b1b5ccf311326eddb08612",
-  "libQnnHtpV79Stub.so": "5f7460da65239d97be7b1845c2cebe20a4b8a92805721d9be796b2c4e706f132",
-  "libQnnIr.so": "79043536d4ac324782c953c9092066d3418ec88626ac2384b2e81883a3f8f644",
-  "libQnnSaver.so": "d26d8002da0fbe829f58370465dc40b4e5a0fc2c2830c0608972817ac5835026",
-  "libQnnSystem.so": "077a8b20a53b216d006b85b58dd754a9e958e02f98e9c79d46619db6f8edfec9"
-}
diff --git a/android/qnn/test_graph_tuning.c b/android/qnn/test_graph_tuning.c
deleted file mode 100644
index ef1c73e5..00000000
--- a/android/qnn/test_graph_tuning.c
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "QnnInterface.h"
-#include "HTP/QnnHtpCommon.h"
-#include "HTP/QnnHtpGraph.h"
-
-#ifdef FAKE_BACKEND
-static const QnnGraph_Config_t **saved[2];
-static size_t saved_count;
-static void check_configs(const QnnGraph_Config_t **configs) {
-  int flags = 0, priority = 0;
-  for (size_t i=0; configs && configs[i]; ++i) {
-    if (configs[i]->option == QNN_GRAPH_CONFIG_OPTION_PRIORITY) { ++priority; continue; }
-    assert(configs[i]->option == QNN_GRAPH_CONFIG_OPTION_CUSTOM);
-    const QnnHtpGraph_CustomConfig_t *c = configs[i]->customConfig;
-    switch(c->option) {
-      case QNN_HTP_GRAPH_CONFIG_OPTION_VTCM_SIZE: assert(c->vtcmSizeInMB==0); flags|=1; break;
-      case QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION: assert(!c->advancedActivationFusion); flags|=2; break;
-      case QNN_HTP_GRAPH_CONFIG_OPTION_SHORT_DEPTH_CONV_ON_HMX_OFF: assert(c->shortDepthConvOnHmxOff); flags|=4; break;
-      case QNN_HTP_GRAPH_CONFIG_OPTION_HIGH_PRECISION_SIGMOID: assert(c->highPrecisionSigmoid); flags|=8; break;
-      default: assert(false);
-    }
-  }
-  assert(flags==atoi(getenv("EXPECTED_FLAGS")));
-  assert(priority==1);
-}
-static Qnn_ErrorHandle_t create(Qnn_ContextHandle_t context, const char *name,
-    const QnnGraph_Config_t **configs, Qnn_GraphHandle_t *graph) {
-  (void)context; (void)name;
-  check_configs(configs);
-  assert(saved_count < 2);
-  saved[saved_count++] = configs;
-  *graph=(void *)0x1;
-  return QNN_SUCCESS;
-}
-static Qnn_ErrorHandle_t context_free(Qnn_ContextHandle_t context, Qnn_ProfileHandle_t profile) {
-  (void)context; (void)profile;
-  for (size_t i=0; i<saved_count; ++i) check_configs(saved[i]);
-  saved_count=0;
-  return QNN_SUCCESS;
-}
-Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***list, uint32_t *count) {
-  static QnnInterface_t p = QNN_INTERFACE_INIT;
-  static const QnnInterface_t *ps[] = {&p};
-  p.backendId=QNN_BACKEND_ID_HTP;
-  p.apiVersion.coreApiVersion.major=QNN_API_VERSION_MAJOR;
-  p.apiVersion.coreApiVersion.minor=QNN_API_VERSION_MINOR;
-  p.QNN_INTERFACE_VER_NAME.graphCreate=create;
-  p.QNN_INTERFACE_VER_NAME.contextFree=context_free;
-  *list=ps; *count=1;
-  return QNN_SUCCESS;
-}
-#else
-#include <dlfcn.h>
-int main(int argc,char **argv) {
-  assert(argc==2);
-  void *lib=dlopen(argv[1],RTLD_NOW|RTLD_LOCAL);
-  if(!lib) { puts(dlerror()); return 1; }
-  typedef Qnn_ErrorHandle_t (*Get)(const QnnInterface_t ***,uint32_t *);
-  Get get=(Get)dlsym(lib,"QnnInterface_getProviders");
-  assert(get);
-  assert(get(NULL,NULL)==QNN_COMMON_ERROR_INVALID_ARGUMENT);
-  const QnnInterface_t **p; uint32_t n;
-  assert(get(&p,&n)==QNN_SUCCESS && n==1);
-  QnnGraph_Config_t priority=QNN_GRAPH_CONFIG_INIT;
-  priority.option=QNN_GRAPH_CONFIG_OPTION_PRIORITY;
-  const QnnGraph_Config_t *configs[]={&priority,NULL};
-  Qnn_GraphHandle_t graph=NULL;
-  Qnn_ErrorHandle_t status=p[0]->QNN_INTERFACE_VER_NAME.graphCreate(NULL,"test",configs,&graph);
-  if(strcmp(getenv("JETLINK_QNN_TUNING"),"invalid")==0) assert(status==QNN_COMMON_ERROR_INVALID_ARGUMENT);
-  else {
-    assert(status==QNN_SUCCESS && graph==(void *)0x1);
-    assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(NULL,"second",configs,&graph)==QNN_SUCCESS);
-  }
-  assert(p[0]->QNN_INTERFACE_VER_NAME.contextFree(NULL,NULL)==QNN_SUCCESS);
-  puts("configuration forwarding and deferred lifetime passed");
-  return 0;
-}
-#endif

From 6b015a972f0151c352fdf8817a572f0a324f0c99 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:51:49 +0200
Subject: [PATCH 21/35] Docs: keep benchmark evidence linked, outside the diff

---
 docs/evidence/sm8750-causal-prefill/README.md |   13 -
 .../accuracy-postheat.txt                     | 2195 -----------------
 .../accuracy-preheat.txt                      | 2195 -----------------
 .../sm8750-causal-prefill/results.json        |  124 -
 .../sm8750-causal-prefill/ten-minute.png      |  Bin 238348 -> 0 bytes
 .../sm8750-causal-prefill/windows.json        |  312 ---
 6 files changed, 4839 deletions(-)
 delete mode 100644 docs/evidence/sm8750-causal-prefill/README.md
 delete mode 100644 docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
 delete mode 100644 docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
 delete mode 100644 docs/evidence/sm8750-causal-prefill/results.json
 delete mode 100644 docs/evidence/sm8750-causal-prefill/ten-minute.png
 delete mode 100644 docs/evidence/sm8750-causal-prefill/windows.json

diff --git a/docs/evidence/sm8750-causal-prefill/README.md b/docs/evidence/sm8750-causal-prefill/README.md
deleted file mode 100644
index c5607fa6..00000000
--- a/docs/evidence/sm8750-causal-prefill/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# SM8750 causal-prefill evidence
-
-These are unmodified benchmark pixels and sanitized numeric/log results from the
-Xiaomi 15 prototype, not a screenshot of the upstream port. No device serial,
-network address, signing key, model weights or Qualcomm SDK binaries are included.
-
-![Ten-minute benchmark on Xiaomi 15](ten-minute.png)
-
-`results.json` records the conditions, controls and limitations. Both accuracy
-logs compare 128 identical synthetic input frames against the unchanged original
-CPU model, each side maintaining its own recurrent state; thresholds are unchanged.
-`windows.json` contains all 61 reported ten-second windows, including the final
-one-frame window. This is a model/host benchmark, not physical comma USB validation.
diff --git a/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt b/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
deleted file mode 100644
index 4f1c806c..00000000
--- a/docs/evidence/sm8750-causal-prefill/accuracy-postheat.txt
+++ /dev/null
@@ -1,2195 +0,0 @@
-
-frame 0: corr 0.999958  max abs 0.5625
-    action                   corr 0.999995  max abs   0.0254  mean abs 0.00935   (by error, pooled)
-    desire_pred              corr 0.999935  max abs   0.0742  mean abs 0.03164
-    desire_state             corr 0.999999  max abs   0.0352  mean abs 0.01514   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1760  mean abs 0.01292
-    lane_lines               corr 0.999849  max abs   0.1744  mean abs 0.02085
-    lane_lines_prob          corr 0.999929  max abs   0.0820  mean abs 0.03079   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.5625  mean abs 0.06143
-    lead_prob                corr 0.999970  max abs   0.0259  mean abs 0.01986   (by error, pooled)
-    meta                     corr 0.999946  max abs   0.0781  mean abs 0.03238
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.3125  mean abs 0.00838
-    pose                     corr 0.999991  max abs   0.0263  mean abs 0.00968   (by error, pooled)
-    road_edges               corr 0.999897  max abs   0.1812  mean abs 0.02426
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00774   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00722   (by error, pooled)
-
-frame 1: corr 0.999965  max abs 0.5625
-    action                   corr 0.999995  max abs   0.0195  mean abs 0.00592   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0586  mean abs 0.02458
-    desire_state             corr 0.999998  max abs   0.0703  mean abs 0.02783   (by error, pooled)
-    hidden_state             corr 0.999959  max abs   0.1367  mean abs 0.01146
-    lane_lines               corr 0.999973  max abs   0.0723  mean abs 0.01279
-    lane_lines_prob          corr 0.999843  max abs   0.1172  mean abs 0.04391   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.05298
-    lead_prob                corr 0.999970  max abs   0.0149  mean abs 0.01196   (by error, pooled)
-    meta                     corr 0.999965  max abs   0.0723  mean abs 0.03016
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.3125  mean abs 0.00710
-    pose                     corr 0.999990  max abs   0.0325  mean abs 0.00972   (by error, pooled)
-    road_edges               corr 0.999977  max abs   0.0586  mean abs 0.01384
-    road_transform           corr 0.999988  max abs   0.0508  mean abs 0.00994   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00493   (by error, pooled)
-
-frame 2: corr 0.999959  max abs 0.6250
-    action                   corr 0.999999  max abs   0.0078  mean abs 0.00211   (by error, pooled)
-    desire_pred              corr 0.999968  max abs   0.0605  mean abs 0.02356
-    desire_state             corr 0.999993  max abs   0.1016  mean abs 0.03271   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1260  mean abs 0.01132
-    lane_lines               corr 0.999958  max abs   0.0918  mean abs 0.01606
-    lane_lines_prob          corr 0.999901  max abs   0.1445  mean abs 0.05713   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.6250  mean abs 0.06016
-    lead_prob                corr 0.999952  max abs   0.0151  mean abs 0.00798   (by error, pooled)
-    meta                     corr 0.999933  max abs   0.0742  mean abs 0.03206
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.2812  mean abs 0.00562
-    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00661   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0664  mean abs 0.01870
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00669   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00395   (by error, pooled)
-
-frame 3: corr 0.999948  max abs 0.9375
-    action                   corr 0.999999  max abs   0.0137  mean abs 0.00553   (by error, pooled)
-    desire_pred              corr 0.999983  max abs   0.0430  mean abs 0.01556
-    desire_state             corr 0.999982  max abs   0.1562  mean abs 0.04858   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1719  mean abs 0.01187
-    lane_lines               corr 0.999931  max abs   0.1543  mean abs 0.01625
-    lane_lines_prob          corr 0.999935  max abs   0.1602  mean abs 0.07416   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.9375  mean abs 0.09328
-    lead_prob                corr 0.999958  max abs   0.0251  mean abs 0.01619   (by error, pooled)
-    meta                     corr 0.999968  max abs   0.0586  mean abs 0.02109
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999990  max abs   0.3750  mean abs 0.00852
-    pose                     corr 0.999984  max abs   0.0356  mean abs 0.01209   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1445  mean abs 0.01664
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00841   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0293  mean abs 0.00949   (by error, pooled)
-
-frame 4: corr 0.999936  max abs 1.1250
-    action                   corr 0.999990  max abs   0.0293  mean abs 0.01129   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0889  mean abs 0.02840
-    desire_state             corr 0.999994  max abs   0.0781  mean abs 0.02625   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01377
-    lane_lines               corr 0.999962  max abs   0.1016  mean abs 0.01430
-    lane_lines_prob          corr 0.999939  max abs   0.0781  mean abs 0.03470   (by error, pooled)
-    lead                     corr 0.999992  max abs   1.1250  mean abs 0.12237
-    lead_prob                corr 0.998717  max abs   0.0957  mean abs 0.06934   (by error, pooled)
-    meta                     corr 0.999845  max abs   0.1270  mean abs 0.04110
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2500  mean abs 0.00861
-    pose                     corr 0.999979  max abs   0.0527  mean abs 0.01070   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.0781  mean abs 0.01325
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01077   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01534   (by error, pooled)
-
-frame 5: corr 0.999922  max abs 1.2500
-    action                   corr 0.999986  max abs   0.0352  mean abs 0.01266   (by error, pooled)
-    desire_pred              corr 0.999942  max abs   0.0859  mean abs 0.02830
-    desire_state             corr 0.999986  max abs   0.0938  mean abs 0.04843   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1680  mean abs 0.01347
-    lane_lines               corr 0.999954  max abs   0.1211  mean abs 0.01651
-    lane_lines_prob          corr 0.999963  max abs   0.1445  mean abs 0.06146   (by error, pooled)
-    lead                     corr 0.999991  max abs   1.2500  mean abs 0.14001
-    lead_prob                corr 0.998733  max abs   0.0557  mean abs 0.04069   (by error, pooled)
-    meta                     corr 0.999961  max abs   0.0762  mean abs 0.02302
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2188  mean abs 0.00735
-    pose                     corr 0.999984  max abs   0.0352  mean abs 0.01015   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.0703  mean abs 0.02004
-    road_transform           corr 0.999994  max abs   0.0430  mean abs 0.01166   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0254  mean abs 0.00882   (by error, pooled)
-
-frame 6: corr 0.999956  max abs 1.9375
-    action                   corr 0.999984  max abs   0.0303  mean abs 0.01663   (by error, pooled)
-    desire_pred              corr 0.999923  max abs   0.0723  mean abs 0.03256
-    desire_state             corr 0.999981  max abs   0.1797  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999937  max abs   0.2617  mean abs 0.01539
-    lane_lines               corr 0.999922  max abs   0.1406  mean abs 0.01865
-    lane_lines_prob          corr 0.999917  max abs   0.1484  mean abs 0.04865   (by error, pooled)
-    lead                     corr 0.999999  max abs   1.9375  mean abs 0.20451
-    lead_prob                corr 1.000000  max abs   0.0293  mean abs 0.02539   (by error, pooled)
-    meta                     corr 0.999912  max abs   0.0898  mean abs 0.03182
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.5625  mean abs 0.01942
-    pose                     corr 0.999977  max abs   0.1484  mean abs 0.02388   (by error, pooled)
-    road_edges               corr 0.999917  max abs   0.1367  mean abs 0.02554
-    road_transform           corr 0.999996  max abs   0.0547  mean abs 0.01525   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0469  mean abs 0.01279   (by error, pooled)
-
-frame 7: corr 0.999989  max abs 0.3750
-    action                   corr 0.999992  max abs   0.0117  mean abs 0.00634   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0645  mean abs 0.02985
-    desire_state             corr 0.999963  max abs   0.2266  mean abs 0.08472   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2041  mean abs 0.01477
-    lane_lines               corr 0.999930  max abs   0.0663  mean abs 0.01972
-    lane_lines_prob          corr 0.999946  max abs   0.1445  mean abs 0.05638   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.3750  mean abs 0.03846
-    lead_prob                corr 0.998477  max abs   0.0254  mean abs 0.01107   (by error, pooled)
-    meta                     corr 0.999903  max abs   0.0898  mean abs 0.03162
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.1875  mean abs 0.00468
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.01124   (by error, pooled)
-    road_edges               corr 0.999918  max abs   0.0898  mean abs 0.02571
-    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00873   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00268   (by error, pooled)
-
-frame 8: corr 0.999981  max abs 0.5625
-    action                   corr 0.999987  max abs   0.0225  mean abs 0.00929   (by error, pooled)
-    desire_pred              corr 0.999943  max abs   0.0762  mean abs 0.02660
-    desire_state             corr 0.999995  max abs   0.0938  mean abs 0.04443   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2560  mean abs 0.01368
-    lane_lines               corr 0.999960  max abs   0.0439  mean abs 0.01421
-    lane_lines_prob          corr 0.999889  max abs   0.1523  mean abs 0.04752   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06036
-    lead_prob                corr 0.999987  max abs   0.0576  mean abs 0.05111   (by error, pooled)
-    meta                     corr 0.999894  max abs   0.0879  mean abs 0.03913
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0625  mean abs 0.00604
-    pose                     corr 0.999994  max abs   0.0273  mean abs 0.00865   (by error, pooled)
-    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02148
-    road_transform           corr 0.999996  max abs   0.0469  mean abs 0.01174   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0625  mean abs 0.01505   (by error, pooled)
-
-frame 9: corr 0.999973  max abs 0.5625
-    action                   corr 0.999999  max abs   0.0195  mean abs 0.00897   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0586  mean abs 0.02765
-    desire_state             corr 0.999996  max abs   0.1094  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1299  mean abs 0.01198
-    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01406
-    lane_lines_prob          corr 0.999991  max abs   0.0703  mean abs 0.03381   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06239
-    lead_prob                corr 0.999959  max abs   0.0474  mean abs 0.03698   (by error, pooled)
-    meta                     corr 0.999940  max abs   0.0859  mean abs 0.03474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.3750  mean abs 0.00992
-    pose                     corr 0.999994  max abs   0.0220  mean abs 0.00801   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0938  mean abs 0.01654
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00441   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0156  mean abs 0.00653   (by error, pooled)
-
-frame 10: corr 0.999978  max abs 0.2500
-    action                   corr 1.000000  max abs   0.0117  mean abs 0.00580   (by error, pooled)
-    desire_pred              corr 0.999956  max abs   0.0601  mean abs 0.03251
-    desire_state             corr 0.999998  max abs   0.0508  mean abs 0.03198   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.0996  mean abs 0.01128
-    lane_lines               corr 0.999972  max abs   0.0586  mean abs 0.01554
-    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03271   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.2500  mean abs 0.02018
-    lead_prob                corr 0.999886  max abs   0.0420  mean abs 0.03019   (by error, pooled)
-    meta                     corr 0.999935  max abs   0.1050  mean abs 0.03611
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00385
-    pose                     corr 0.999996  max abs   0.0172  mean abs 0.00643   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0586  mean abs 0.01438
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00417   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00426   (by error, pooled)
-
-frame 11: corr 0.999976  max abs 0.2500
-    action                   corr 1.000000  max abs   0.0020  mean abs 0.00052   (by error, pooled)
-    desire_pred              corr 0.999966  max abs   0.0625  mean abs 0.02907
-    desire_state             corr 0.999999  max abs   0.0625  mean abs 0.03687   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1348  mean abs 0.01212
-    lane_lines               corr 0.999965  max abs   0.0859  mean abs 0.01512
-    lane_lines_prob          corr 0.999983  max abs   0.0547  mean abs 0.03186   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.2500  mean abs 0.02342
-    lead_prob                corr 0.999887  max abs   0.0355  mean abs 0.02243   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0869  mean abs 0.03073
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00297
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00640   (by error, pooled)
-    road_edges               corr 0.999965  max abs   0.0801  mean abs 0.01600
-    road_transform           corr 0.999994  max abs   0.0273  mean abs 0.00709   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00430   (by error, pooled)
-
-frame 12: corr 0.999975  max abs 0.4375
-    action                   corr 0.999999  max abs   0.0098  mean abs 0.00491   (by error, pooled)
-    desire_pred              corr 0.999981  max abs   0.0625  mean abs 0.02130
-    desire_state             corr 0.999993  max abs   0.1406  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1543  mean abs 0.01343
-    lane_lines               corr 0.999969  max abs   0.1172  mean abs 0.01423
-    lane_lines_prob          corr 0.999945  max abs   0.0820  mean abs 0.03003   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.4375  mean abs 0.04305
-    lead_prob                corr 0.999977  max abs   0.0791  mean abs 0.06405   (by error, pooled)
-    meta                     corr 0.999881  max abs   0.0850  mean abs 0.03032
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00616
-    pose                     corr 0.999994  max abs   0.0239  mean abs 0.00555   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.1094  mean abs 0.01357
-    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00775   (by error, pooled)
-    wide_from_device_euler   corr 0.999986  max abs   0.0410  mean abs 0.00981   (by error, pooled)
-
-frame 13: corr 0.999963  max abs 0.7500
-    action                   corr 0.999979  max abs   0.0293  mean abs 0.01082   (by error, pooled)
-    desire_pred              corr 0.999881  max abs   0.0918  mean abs 0.04098
-    desire_state             corr 0.999992  max abs   0.1328  mean abs 0.06201   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2285  mean abs 0.01348
-    lane_lines               corr 0.999945  max abs   0.1289  mean abs 0.01795
-    lane_lines_prob          corr 0.999691  max abs   0.1641  mean abs 0.06439   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.7500  mean abs 0.06569
-    lead_prob                corr 0.999548  max abs   0.0918  mean abs 0.07259   (by error, pooled)
-    meta                     corr 0.999852  max abs   0.0889  mean abs 0.03951
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999985  max abs   0.3750  mean abs 0.01534
-    pose                     corr 0.999964  max abs   0.0781  mean abs 0.01469   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.1172  mean abs 0.01816
-    road_transform           corr 0.999999  max abs   0.0391  mean abs 0.01190   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.01145   (by error, pooled)
-
-frame 14: corr 0.999945  max abs 0.9375
-    action                   corr 0.999982  max abs   0.0391  mean abs 0.01599   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03196
-    desire_state             corr 0.999988  max abs   0.2031  mean abs 0.09033   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2109  mean abs 0.01363
-    lane_lines               corr 0.999974  max abs   0.0859  mean abs 0.01198
-    lane_lines_prob          corr 0.999923  max abs   0.1289  mean abs 0.04303   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.9375  mean abs 0.08604
-    lead_prob                corr 0.998518  max abs   0.0938  mean abs 0.07617   (by error, pooled)
-    meta                     corr 0.999948  max abs   0.0625  mean abs 0.02685
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999971  max abs   0.5000  mean abs 0.01917
-    pose                     corr 0.999960  max abs   0.0742  mean abs 0.01417   (by error, pooled)
-    road_edges               corr 0.999941  max abs   0.0781  mean abs 0.01981
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00857   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0312  mean abs 0.00654   (by error, pooled)
-
-frame 15: corr 0.999964  max abs 1.2500
-    action                   corr 0.999983  max abs   0.0176  mean abs 0.00940   (by error, pooled)
-    desire_pred              corr 0.999929  max abs   0.0625  mean abs 0.03351
-    desire_state             corr 0.999991  max abs   0.1641  mean abs 0.10449   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2324  mean abs 0.01531
-    lane_lines               corr 0.999947  max abs   0.1406  mean abs 0.01695
-    lane_lines_prob          corr 0.999976  max abs   0.1367  mean abs 0.06481   (by error, pooled)
-    lead                     corr 0.999999  max abs   1.2500  mean abs 0.12303
-    lead_prob                corr 0.999926  max abs   0.0635  mean abs 0.05813   (by error, pooled)
-    meta                     corr 0.999902  max abs   0.0928  mean abs 0.03267
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2188  mean abs 0.01202
-    pose                     corr 0.999990  max abs   0.1172  mean abs 0.01868   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.1094  mean abs 0.01495
-    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.01289   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0391  mean abs 0.01213   (by error, pooled)
-
-frame 16: corr 0.999982  max abs 0.6250
-    action                   corr 0.999956  max abs   0.0127  mean abs 0.00645   (by error, pooled)
-    desire_pred              corr 0.999934  max abs   0.0723  mean abs 0.03220
-    desire_state             corr 0.999984  max abs   0.1367  mean abs 0.06238   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2305  mean abs 0.01469
-    lane_lines               corr 0.999920  max abs   0.0703  mean abs 0.02025
-    lane_lines_prob          corr 0.999967  max abs   0.1289  mean abs 0.04867   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.6250  mean abs 0.04697
-    lead_prob                corr 0.999966  max abs   0.0566  mean abs 0.03809   (by error, pooled)
-    meta                     corr 0.999876  max abs   0.0957  mean abs 0.03783
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.1250  mean abs 0.00539
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01058   (by error, pooled)
-    road_edges               corr 0.999919  max abs   0.0859  mean abs 0.02313
-    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00425   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00884   (by error, pooled)
-
-frame 17: corr 0.999974  max abs 0.3438
-    action                   corr 0.999987  max abs   0.0176  mean abs 0.00995   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0730  mean abs 0.02846
-    desire_state             corr 0.999996  max abs   0.0781  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2465  mean abs 0.01365
-    lane_lines               corr 0.999956  max abs   0.0781  mean abs 0.01486
-    lane_lines_prob          corr 0.999933  max abs   0.0977  mean abs 0.03257   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01697
-    lead_prob                corr 0.999995  max abs   0.0449  mean abs 0.03735   (by error, pooled)
-    meta                     corr 0.999928  max abs   0.0703  mean abs 0.02939
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999986  max abs   0.3438  mean abs 0.01366
-    pose                     corr 0.999992  max abs   0.0273  mean abs 0.01085   (by error, pooled)
-    road_edges               corr 0.999927  max abs   0.0664  mean abs 0.02052
-    road_transform           corr 0.999998  max abs   0.0469  mean abs 0.01369   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0430  mean abs 0.01115   (by error, pooled)
-
-frame 18: corr 0.999965  max abs 0.5000
-    action                   corr 0.999996  max abs   0.0215  mean abs 0.00996   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0859  mean abs 0.02974
-    desire_state             corr 0.999984  max abs   0.1562  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1289  mean abs 0.01180
-    lane_lines               corr 0.999970  max abs   0.0488  mean abs 0.01406
-    lane_lines_prob          corr 0.999973  max abs   0.0742  mean abs 0.02954   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5000  mean abs 0.04836
-    lead_prob                corr 0.998951  max abs   0.0811  mean abs 0.06120   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0781  mean abs 0.03228
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.3125  mean abs 0.01052
-    pose                     corr 0.999993  max abs   0.0273  mean abs 0.00879   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0527  mean abs 0.01554
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00458   (by error, pooled)
-
-frame 19: corr 0.999975  max abs 0.1250
-    action                   corr 0.999999  max abs   0.0078  mean abs 0.00311   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0552  mean abs 0.03011
-    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.04626   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.0938  mean abs 0.01092
-    lane_lines               corr 0.999966  max abs   0.0752  mean abs 0.01557
-    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03101   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1250  mean abs 0.01557
-    lead_prob                corr 0.999727  max abs   0.0410  mean abs 0.03109   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.1123  mean abs 0.03805
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0781  mean abs 0.00426
-    pose                     corr 0.999996  max abs   0.0176  mean abs 0.00608   (by error, pooled)
-    road_edges               corr 0.999955  max abs   0.1152  mean abs 0.01849
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00466   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0195  mean abs 0.00459   (by error, pooled)
-
-frame 20: corr 0.999975  max abs 0.2812
-    action                   corr 0.999998  max abs   0.0098  mean abs 0.00377   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0547  mean abs 0.02860
-    desire_state             corr 0.999990  max abs   0.1484  mean abs 0.06494   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1543  mean abs 0.01206
-    lane_lines               corr 0.999976  max abs   0.0605  mean abs 0.01370
-    lane_lines_prob          corr 0.999979  max abs   0.0742  mean abs 0.03647   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2812  mean abs 0.02069
-    lead_prob                corr 0.999753  max abs   0.0480  mean abs 0.04075   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0811  mean abs 0.03298
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0410  mean abs 0.00367
-    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00504   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0820  mean abs 0.01513
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00507   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0273  mean abs 0.00690   (by error, pooled)
-
-frame 21: corr 0.999971  max abs 0.5625
-    action                   corr 0.999993  max abs   0.0176  mean abs 0.00978   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0518  mean abs 0.02562
-    desire_state             corr 0.999990  max abs   0.0703  mean abs 0.04370   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1807  mean abs 0.01358
-    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01265
-    lane_lines_prob          corr 0.999970  max abs   0.0513  mean abs 0.02728   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5625  mean abs 0.04740
-    lead_prob                corr 0.999391  max abs   0.1055  mean abs 0.08830   (by error, pooled)
-    meta                     corr 0.999906  max abs   0.0745  mean abs 0.02863
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2500  mean abs 0.01053
-    pose                     corr 0.999985  max abs   0.0352  mean abs 0.01017   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.1050  mean abs 0.01557
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00575   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00983   (by error, pooled)
-
-frame 22: corr 0.999969  max abs 0.4268
-    action                   corr 0.999983  max abs   0.0195  mean abs 0.01143   (by error, pooled)
-    desire_pred              corr 0.999962  max abs   0.0459  mean abs 0.02286
-    desire_state             corr 0.999980  max abs   0.1250  mean abs 0.06152   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2227  mean abs 0.01495
-    lane_lines               corr 0.999953  max abs   0.1172  mean abs 0.01816
-    lane_lines_prob          corr 0.999918  max abs   0.0859  mean abs 0.04413   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1875  mean abs 0.02029
-    lead_prob                corr 0.999892  max abs   0.1221  mean abs 0.11019   (by error, pooled)
-    meta                     corr 0.999892  max abs   0.0825  mean abs 0.03034
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.4268  mean abs 0.01207
-    pose                     corr 0.999986  max abs   0.0625  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1484  mean abs 0.02380
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00580   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00493   (by error, pooled)
-
-frame 23: corr 0.999967  max abs 0.3125
-    action                   corr 0.999976  max abs   0.0293  mean abs 0.01263   (by error, pooled)
-    desire_pred              corr 0.999899  max abs   0.1211  mean abs 0.03755
-    desire_state             corr 0.999985  max abs   0.1211  mean abs 0.05103   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1680  mean abs 0.01385
-    lane_lines               corr 0.999970  max abs   0.0898  mean abs 0.01397
-    lane_lines_prob          corr 0.999913  max abs   0.1094  mean abs 0.03763   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.3125  mean abs 0.04054
-    lead_prob                corr 0.999069  max abs   0.0996  mean abs 0.08008   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0625  mean abs 0.02667
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1875  mean abs 0.01065
-    pose                     corr 0.999981  max abs   0.0430  mean abs 0.01038   (by error, pooled)
-    road_edges               corr 0.999970  max abs   0.0664  mean abs 0.01592
-    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.01101   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00721   (by error, pooled)
-
-frame 24: corr 0.999969  max abs 0.6875
-    action                   corr 0.999922  max abs   0.0151  mean abs 0.00975   (by error, pooled)
-    desire_pred              corr 0.999961  max abs   0.0625  mean abs 0.02347
-    desire_state             corr 0.999981  max abs   0.2344  mean abs 0.10645   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2109  mean abs 0.01523
-    lane_lines               corr 0.999950  max abs   0.1641  mean abs 0.01631
-    lane_lines_prob          corr 0.999966  max abs   0.1016  mean abs 0.05735   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.6875  mean abs 0.06699
-    lead_prob                corr 0.996577  max abs   0.0117  mean abs 0.00781   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0645  mean abs 0.02625
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.2188  mean abs 0.00971
-    pose                     corr 0.999992  max abs   0.0859  mean abs 0.01700   (by error, pooled)
-    road_edges               corr 0.999942  max abs   0.1230  mean abs 0.01850
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.01053   (by error, pooled)
-    wide_from_device_euler   corr 0.999989  max abs   0.0312  mean abs 0.01248   (by error, pooled)
-
-frame 25: corr 0.999982  max abs 0.2500
-    action                   corr 0.999981  max abs   0.0068  mean abs 0.00417   (by error, pooled)
-    desire_pred              corr 0.999944  max abs   0.0781  mean abs 0.02817
-    desire_state             corr 0.999991  max abs   0.0859  mean abs 0.05078   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2109  mean abs 0.01473
-    lane_lines               corr 0.999940  max abs   0.0820  mean abs 0.01846
-    lane_lines_prob          corr 0.999904  max abs   0.1289  mean abs 0.05077   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1875  mean abs 0.01383
-    lead_prob                corr 0.998654  max abs   0.0273  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999831  max abs   0.1279  mean abs 0.04345
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2500  mean abs 0.00592
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00996   (by error, pooled)
-    road_edges               corr 0.999938  max abs   0.0957  mean abs 0.02302
-    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.01206   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00624   (by error, pooled)
-
-frame 26: corr 0.999971  max abs 0.3379
-    action                   corr 0.999962  max abs   0.0234  mean abs 0.01273   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0762  mean abs 0.02478
-    desire_state             corr 0.999988  max abs   0.0781  mean abs 0.04614   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2463  mean abs 0.01360
-    lane_lines               corr 0.999934  max abs   0.1152  mean abs 0.01807
-    lane_lines_prob          corr 0.999944  max abs   0.1055  mean abs 0.03624   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.1172  mean abs 0.01570
-    lead_prob                corr 0.999976  max abs   0.0762  mean abs 0.07357   (by error, pooled)
-    meta                     corr 0.999915  max abs   0.0938  mean abs 0.03423
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.3379  mean abs 0.01435
-    pose                     corr 0.999992  max abs   0.0293  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999920  max abs   0.0957  mean abs 0.01895
-    road_transform           corr 0.999989  max abs   0.0586  mean abs 0.01320   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0508  mean abs 0.01084   (by error, pooled)
-
-frame 27: corr 0.999974  max abs 0.2344
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00674   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0840  mean abs 0.02877
-    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.12048   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1123  mean abs 0.01212
-    lane_lines               corr 0.999966  max abs   0.0664  mean abs 0.01772
-    lane_lines_prob          corr 0.999944  max abs   0.1211  mean abs 0.05255   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01196
-    lead_prob                corr 0.998386  max abs   0.1042  mean abs 0.08252   (by error, pooled)
-    meta                     corr 0.999922  max abs   0.0938  mean abs 0.03512
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1562  mean abs 0.00559
-    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00537   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0977  mean abs 0.01668
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00343   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0117  mean abs 0.00427   (by error, pooled)
-
-frame 28: corr 0.999975  max abs 0.3125
-    action                   corr 0.999993  max abs   0.0166  mean abs 0.00888   (by error, pooled)
-    desire_pred              corr 0.999975  max abs   0.0547  mean abs 0.02318
-    desire_state             corr 0.999988  max abs   0.1133  mean abs 0.07367   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1133  mean abs 0.01113
-    lane_lines               corr 0.999960  max abs   0.0977  mean abs 0.01409
-    lane_lines_prob          corr 0.999996  max abs   0.0430  mean abs 0.02063   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3125  mean abs 0.02101
-    lead_prob                corr 0.996397  max abs   0.0938  mean abs 0.07812   (by error, pooled)
-    meta                     corr 0.999967  max abs   0.0801  mean abs 0.02487
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1172  mean abs 0.00626
-    pose                     corr 0.999997  max abs   0.0166  mean abs 0.00535   (by error, pooled)
-    road_edges               corr 0.999956  max abs   0.1523  mean abs 0.01539
-    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.00521   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00262   (by error, pooled)
-
-frame 29: corr 0.999973  max abs 0.2188
-    action                   corr 0.999996  max abs   0.0127  mean abs 0.00696   (by error, pooled)
-    desire_pred              corr 0.999959  max abs   0.0586  mean abs 0.03296
-    desire_state             corr 0.999995  max abs   0.1562  mean abs 0.07239   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01184
-    lane_lines               corr 0.999973  max abs   0.0449  mean abs 0.01383
-    lane_lines_prob          corr 0.999993  max abs   0.1133  mean abs 0.07458   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2188  mean abs 0.01581
-    lead_prob                corr 0.993557  max abs   0.0977  mean abs 0.07812   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0840  mean abs 0.02687
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00604
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00598   (by error, pooled)
-    road_edges               corr 0.999954  max abs   0.1016  mean abs 0.01897
-    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00655   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00886   (by error, pooled)
-
-frame 30: corr 0.999970  max abs 0.2500
-    action                   corr 0.999992  max abs   0.0127  mean abs 0.00661   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02797
-    desire_state             corr 0.999989  max abs   0.1484  mean abs 0.08813   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1660  mean abs 0.01359
-    lane_lines               corr 0.999958  max abs   0.1328  mean abs 0.01609
-    lane_lines_prob          corr 0.999952  max abs   0.0869  mean abs 0.03772   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02438
-    lead_prob                corr 0.999354  max abs   0.1243  mean abs 0.10343   (by error, pooled)
-    meta                     corr 0.999791  max abs   0.1304  mean abs 0.04929
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00752
-    pose                     corr 0.999992  max abs   0.0234  mean abs 0.00691   (by error, pooled)
-    road_edges               corr 0.999963  max abs   0.1719  mean abs 0.01888
-    road_transform           corr 0.999992  max abs   0.0273  mean abs 0.00793   (by error, pooled)
-    wide_from_device_euler   corr 0.999985  max abs   0.0371  mean abs 0.00851   (by error, pooled)
-
-frame 31: corr 0.999970  max abs 0.2188
-    action                   corr 0.999980  max abs   0.0225  mean abs 0.01251   (by error, pooled)
-    desire_pred              corr 0.999933  max abs   0.0664  mean abs 0.02856
-    desire_state             corr 0.999975  max abs   0.1094  mean abs 0.07178   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.2129  mean abs 0.01353
-    lane_lines               corr 0.999958  max abs   0.0820  mean abs 0.01609
-    lane_lines_prob          corr 0.999901  max abs   0.1523  mean abs 0.05202   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.2188  mean abs 0.02764
-    lead_prob                corr 0.998387  max abs   0.1116  mean abs 0.09253   (by error, pooled)
-    meta                     corr 0.999832  max abs   0.1172  mean abs 0.04155
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1250  mean abs 0.00817
-    pose                     corr 0.999979  max abs   0.0547  mean abs 0.01210   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0940  mean abs 0.01712
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00768   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0273  mean abs 0.01210   (by error, pooled)
-
-frame 32: corr 0.999958  max abs 0.1445
-    action                   corr 0.999989  max abs   0.0215  mean abs 0.01032   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03190
-    desire_state             corr 0.999968  max abs   0.1250  mean abs 0.05859   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1445  mean abs 0.01330
-    lane_lines               corr 0.999972  max abs   0.0664  mean abs 0.01441
-    lane_lines_prob          corr 0.999905  max abs   0.1367  mean abs 0.09381   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.1094  mean abs 0.01503
-    lead_prob                corr 0.999998  max abs   0.0508  mean abs 0.03385   (by error, pooled)
-    meta                     corr 0.999972  max abs   0.0547  mean abs 0.02026
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1406  mean abs 0.00554
-    pose                     corr 0.999985  max abs   0.0352  mean abs 0.00878   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0547  mean abs 0.01838
-    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00694   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00592   (by error, pooled)
-
-frame 33: corr 0.999962  max abs 0.8750
-    action                   corr 0.999959  max abs   0.0176  mean abs 0.00947   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0703  mean abs 0.01862
-    desire_state             corr 0.999979  max abs   0.1562  mean abs 0.05762   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2500  mean abs 0.01529
-    lane_lines               corr 0.999955  max abs   0.1133  mean abs 0.01632
-    lane_lines_prob          corr 0.999931  max abs   0.1055  mean abs 0.04333   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.8750  mean abs 0.06872
-    lead_prob                corr 0.999956  max abs   0.0391  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999934  max abs   0.0752  mean abs 0.02529
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.2969  mean abs 0.01298
-    pose                     corr 0.999994  max abs   0.0625  mean abs 0.01658   (by error, pooled)
-    road_edges               corr 0.999960  max abs   0.1016  mean abs 0.01799
-    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00815   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01118   (by error, pooled)
-
-frame 34: corr 0.999979  max abs 0.1963
-    action                   corr 0.999977  max abs   0.0098  mean abs 0.00539   (by error, pooled)
-    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03787
-    desire_state             corr 0.999991  max abs   0.1133  mean abs 0.03394   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1963  mean abs 0.01470
-    lane_lines               corr 0.999939  max abs   0.0742  mean abs 0.01944
-    lane_lines_prob          corr 0.999938  max abs   0.1875  mean abs 0.07463   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01449
-    lead_prob                corr 0.999656  max abs   0.0391  mean abs 0.02604   (by error, pooled)
-    meta                     corr 0.999890  max abs   0.0820  mean abs 0.03731
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1875  mean abs 0.00495
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00991   (by error, pooled)
-    road_edges               corr 0.999935  max abs   0.0654  mean abs 0.02561
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00750   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00332   (by error, pooled)
-
-frame 35: corr 0.999960  max abs 0.3438
-    action                   corr 0.999962  max abs   0.0225  mean abs 0.01250   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0605  mean abs 0.02122
-    desire_state             corr 0.999907  max abs   0.2266  mean abs 0.08117   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2641  mean abs 0.01373
-    lane_lines               corr 0.999954  max abs   0.0684  mean abs 0.01481
-    lane_lines_prob          corr 0.999964  max abs   0.0586  mean abs 0.03961   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03551
-    lead_prob                corr 0.999775  max abs   0.1289  mean abs 0.11133   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.0820  mean abs 0.02702
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.2656  mean abs 0.01050
-    pose                     corr 0.999989  max abs   0.0430  mean abs 0.01239   (by error, pooled)
-    road_edges               corr 0.999960  max abs   0.0547  mean abs 0.01449
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00890   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0586  mean abs 0.01375   (by error, pooled)
-
-frame 36: corr 0.999964  max abs 0.1562
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00779   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.02402
-    desire_state             corr 0.999954  max abs   0.1445  mean abs 0.05359   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01207
-    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01368
-    lane_lines_prob          corr 0.999960  max abs   0.0703  mean abs 0.02673   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.1406  mean abs 0.01257
-    lead_prob                corr 0.999999  max abs   0.1211  mean abs 0.10026   (by error, pooled)
-    meta                     corr 0.999919  max abs   0.1055  mean abs 0.03351
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1562  mean abs 0.00708
-    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00659   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.1152  mean abs 0.01726
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00571   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00621   (by error, pooled)
-
-frame 37: corr 0.999957  max abs 0.3496
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00745   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0566  mean abs 0.02777
-    desire_state             corr 0.999970  max abs   0.1680  mean abs 0.06909   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1162  mean abs 0.01122
-    lane_lines               corr 0.999969  max abs   0.0703  mean abs 0.01477
-    lane_lines_prob          corr 0.999990  max abs   0.0977  mean abs 0.04390   (by error, pooled)
-    lead                     corr 0.999850  max abs   0.3496  mean abs 0.02815
-    lead_prob                corr 0.999963  max abs   0.0664  mean abs 0.05339   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.1074  mean abs 0.03950
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00420
-    pose                     corr 0.999995  max abs   0.0195  mean abs 0.00651   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0742  mean abs 0.01435
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00619   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00489   (by error, pooled)
-
-frame 38: corr 0.999958  max abs 0.2031
-    action                   corr 0.999996  max abs   0.0107  mean abs 0.00541   (by error, pooled)
-    desire_pred              corr 0.999972  max abs   0.0508  mean abs 0.02396
-    desire_state             corr 0.999985  max abs   0.1172  mean abs 0.05750   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1406  mean abs 0.01202
-    lane_lines               corr 0.999966  max abs   0.0898  mean abs 0.01373
-    lane_lines_prob          corr 0.999834  max abs   0.1016  mean abs 0.05020   (by error, pooled)
-    lead                     corr 0.999981  max abs   0.2031  mean abs 0.01509
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06576   (by error, pooled)
-    meta                     corr 0.999912  max abs   0.0977  mean abs 0.04185
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00351
-    pose                     corr 0.999999  max abs   0.0156  mean abs 0.00536   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0977  mean abs 0.01437
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00442   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00266   (by error, pooled)
-
-frame 39: corr 0.999960  max abs 0.6250
-    action                   corr 0.999991  max abs   0.0132  mean abs 0.00716   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.1094  mean abs 0.02056
-    desire_state             corr 0.999984  max abs   0.0996  mean abs 0.02930   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1465  mean abs 0.01390
-    lane_lines               corr 0.999971  max abs   0.0938  mean abs 0.01416
-    lane_lines_prob          corr 0.999846  max abs   0.1211  mean abs 0.04431   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.6250  mean abs 0.04044
-    lead_prob                corr 0.999763  max abs   0.1094  mean abs 0.07975   (by error, pooled)
-    meta                     corr 0.999865  max abs   0.1030  mean abs 0.04137
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00369
-    pose                     corr 0.999994  max abs   0.0186  mean abs 0.00503   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.1250  mean abs 0.01266
-    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00752   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0234  mean abs 0.00624   (by error, pooled)
-
-frame 40: corr 0.999953  max abs 0.3906
-    action                   corr 0.999974  max abs   0.0332  mean abs 0.01743   (by error, pooled)
-    desire_pred              corr 0.999906  max abs   0.0859  mean abs 0.03478
-    desire_state             corr 0.999907  max abs   0.3196  mean abs 0.13505   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2617  mean abs 0.01366
-    lane_lines               corr 0.999937  max abs   0.1445  mean abs 0.01839
-    lane_lines_prob          corr 0.999892  max abs   0.0820  mean abs 0.04476   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.1641  mean abs 0.01987
-    lead_prob                corr 0.999859  max abs   0.1113  mean abs 0.09342   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.0957  mean abs 0.04024
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999964  max abs   0.3906  mean abs 0.01614
-    pose                     corr 0.999949  max abs   0.0918  mean abs 0.01791   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.1250  mean abs 0.01758
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00533   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0156  mean abs 0.00559   (by error, pooled)
-
-frame 41: corr 0.999952  max abs 0.2649
-    action                   corr 0.999977  max abs   0.0273  mean abs 0.01492   (by error, pooled)
-    desire_pred              corr 0.999943  max abs   0.0664  mean abs 0.02870
-    desire_state             corr 0.999941  max abs   0.2649  mean abs 0.12741   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1953  mean abs 0.01348
-    lane_lines               corr 0.999967  max abs   0.0664  mean abs 0.01465
-    lane_lines_prob          corr 0.999892  max abs   0.1211  mean abs 0.05054   (by error, pooled)
-    lead                     corr 0.999983  max abs   0.2500  mean abs 0.01946
-    lead_prob                corr 0.999977  max abs   0.0664  mean abs 0.05632   (by error, pooled)
-    meta                     corr 0.999961  max abs   0.0586  mean abs 0.02646
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999978  max abs   0.2188  mean abs 0.01064
-    pose                     corr 0.999968  max abs   0.0664  mean abs 0.01268   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0664  mean abs 0.01754
-    road_transform           corr 0.999993  max abs   0.0586  mean abs 0.01044   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00557   (by error, pooled)
-
-frame 42: corr 0.999964  max abs 1.0000
-    action                   corr 0.999953  max abs   0.0176  mean abs 0.00957   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0742  mean abs 0.02237
-    desire_state             corr 0.999991  max abs   0.1719  mean abs 0.06738   (by error, pooled)
-    hidden_state             corr 0.999939  max abs   0.2227  mean abs 0.01551
-    lane_lines               corr 0.999949  max abs   0.1641  mean abs 0.01721
-    lane_lines_prob          corr 0.999959  max abs   0.0938  mean abs 0.05408   (by error, pooled)
-    lead                     corr 0.999998  max abs   1.0000  mean abs 0.08374
-    lead_prob                corr 0.999980  max abs   0.0469  mean abs 0.03320   (by error, pooled)
-    meta                     corr 0.999960  max abs   0.0586  mean abs 0.02051
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999990  max abs   0.3750  mean abs 0.01489
-    pose                     corr 0.999992  max abs   0.0938  mean abs 0.01833   (by error, pooled)
-    road_edges               corr 0.999953  max abs   0.0762  mean abs 0.01858
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00704   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0469  mean abs 0.01246   (by error, pooled)
-
-frame 43: corr 0.999981  max abs 0.1992
-    action                   corr 0.999961  max abs   0.0125  mean abs 0.00572   (by error, pooled)
-    desire_pred              corr 0.999924  max abs   0.0879  mean abs 0.03424
-    desire_state             corr 0.999996  max abs   0.1328  mean abs 0.06543   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1992  mean abs 0.01496
-    lane_lines               corr 0.999933  max abs   0.0671  mean abs 0.01937
-    lane_lines_prob          corr 0.999934  max abs   0.1328  mean abs 0.04815   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01052
-    lead_prob                corr 0.999974  max abs   0.0508  mean abs 0.03483   (by error, pooled)
-    meta                     corr 0.999854  max abs   0.1182  mean abs 0.04098
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00588
-    pose                     corr 0.999997  max abs   0.0352  mean abs 0.01159   (by error, pooled)
-    road_edges               corr 0.999912  max abs   0.1035  mean abs 0.02590
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.01020   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0059  mean abs 0.00200   (by error, pooled)
-
-frame 44: corr 0.999961  max abs 0.3125
-    action                   corr 0.999956  max abs   0.0234  mean abs 0.01290   (by error, pooled)
-    desire_pred              corr 0.999867  max abs   0.0938  mean abs 0.04165
-    desire_state             corr 0.999985  max abs   0.2422  mean abs 0.05908   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2340  mean abs 0.01324
-    lane_lines               corr 0.999964  max abs   0.0625  mean abs 0.01566
-    lane_lines_prob          corr 0.999985  max abs   0.0859  mean abs 0.04950   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.3125  mean abs 0.02699
-    lead_prob                corr 0.999996  max abs   0.0879  mean abs 0.08333   (by error, pooled)
-    meta                     corr 0.999895  max abs   0.0820  mean abs 0.03589
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999979  max abs   0.2891  mean abs 0.01164
-    pose                     corr 0.999988  max abs   0.0312  mean abs 0.01193   (by error, pooled)
-    road_edges               corr 0.999947  max abs   0.0664  mean abs 0.01609
-    road_transform           corr 0.999998  max abs   0.0430  mean abs 0.01035   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0391  mean abs 0.01245   (by error, pooled)
-
-frame 45: corr 0.999960  max abs 0.2188
-    action                   corr 0.999986  max abs   0.0215  mean abs 0.01061   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0684  mean abs 0.02888
-    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.08240   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1289  mean abs 0.01152
-    lane_lines               corr 0.999971  max abs   0.0386  mean abs 0.01310
-    lane_lines_prob          corr 0.999984  max abs   0.1055  mean abs 0.03467   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0625  mean abs 0.00760
-    lead_prob                corr 0.999935  max abs   0.1196  mean abs 0.10030   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.1250  mean abs 0.04695
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999980  max abs   0.2188  mean abs 0.00956
-    pose                     corr 0.999992  max abs   0.0259  mean abs 0.00762   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0547  mean abs 0.01518
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00335   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0098  mean abs 0.00296   (by error, pooled)
-
-frame 46: corr 0.999949  max abs 0.5820
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00638   (by error, pooled)
-    desire_pred              corr 0.999979  max abs   0.0488  mean abs 0.02080
-    desire_state             corr 0.999981  max abs   0.1047  mean abs 0.04221   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1211  mean abs 0.01127
-    lane_lines               corr 0.999982  max abs   0.0371  mean abs 0.01206
-    lane_lines_prob          corr 0.999974  max abs   0.0977  mean abs 0.03348   (by error, pooled)
-    lead                     corr 0.999142  max abs   0.5820  mean abs 0.03989
-    lead_prob                corr 0.999995  max abs   0.1250  mean abs 0.10645   (by error, pooled)
-    meta                     corr 0.999931  max abs   0.0957  mean abs 0.03604
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00399
-    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00574   (by error, pooled)
-    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01141
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00580   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00620   (by error, pooled)
-
-frame 47: corr 0.999940  max abs 0.6406
-    action                   corr 0.999993  max abs   0.0137  mean abs 0.00554   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0625  mean abs 0.03202
-    desire_state             corr 0.999962  max abs   0.2131  mean abs 0.06779   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1309  mean abs 0.01206
-    lane_lines               corr 0.999979  max abs   0.0762  mean abs 0.01445
-    lane_lines_prob          corr 0.999939  max abs   0.1367  mean abs 0.07001   (by error, pooled)
-    lead                     corr 0.999672  max abs   0.6406  mean abs 0.04770
-    lead_prob                corr 0.999975  max abs   0.0820  mean abs 0.06803   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0898  mean abs 0.03575
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0225  mean abs 0.00445
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00622   (by error, pooled)
-    road_edges               corr 0.999949  max abs   0.0781  mean abs 0.01724
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00491   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00885   (by error, pooled)
-
-frame 48: corr 0.999957  max abs 0.6250
-    action                   corr 0.999982  max abs   0.0195  mean abs 0.01069   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.0625  mean abs 0.02208
-    desire_state             corr 0.999986  max abs   0.1328  mean abs 0.05737   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1494  mean abs 0.01378
-    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01422
-    lane_lines_prob          corr 0.999956  max abs   0.0977  mean abs 0.04120   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.6250  mean abs 0.04285
-    lead_prob                corr 0.999936  max abs   0.1133  mean abs 0.09619   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.0902  mean abs 0.03599
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.1875  mean abs 0.00748
-    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00550   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.1250  mean abs 0.01621
-    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00393   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00656   (by error, pooled)
-
-frame 49: corr 0.999953  max abs 0.4375
-    action                   corr 0.999980  max abs   0.0293  mean abs 0.01551   (by error, pooled)
-    desire_pred              corr 0.999976  max abs   0.0508  mean abs 0.01759
-    desire_state             corr 0.999958  max abs   0.2617  mean abs 0.10352   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2109  mean abs 0.01310
-    lane_lines               corr 0.999950  max abs   0.0977  mean abs 0.01608
-    lane_lines_prob          corr 0.999894  max abs   0.1172  mean abs 0.04683   (by error, pooled)
-    lead                     corr 0.999969  max abs   0.4375  mean abs 0.03150
-    lead_prob                corr 0.999853  max abs   0.0996  mean abs 0.07861   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0859  mean abs 0.02841
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999973  max abs   0.1660  mean abs 0.01430
-    pose                     corr 0.999979  max abs   0.0410  mean abs 0.01245   (by error, pooled)
-    road_edges               corr 0.999964  max abs   0.1055  mean abs 0.01792
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00677   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0234  mean abs 0.00919   (by error, pooled)
-
-frame 50: corr 0.999943  max abs 0.5234
-    action                   corr 0.999964  max abs   0.0322  mean abs 0.01672   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03007
-    desire_state             corr 0.999955  max abs   0.2969  mean abs 0.10749   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1875  mean abs 0.01355
-    lane_lines               corr 0.999968  max abs   0.0898  mean abs 0.01383
-    lane_lines_prob          corr 0.999863  max abs   0.1758  mean abs 0.06085   (by error, pooled)
-    lead                     corr 0.999869  max abs   0.5234  mean abs 0.03819
-    lead_prob                corr 0.999837  max abs   0.1289  mean abs 0.10059   (by error, pooled)
-    meta                     corr 0.999929  max abs   0.0820  mean abs 0.03109
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999969  max abs   0.1680  mean abs 0.01198
-    pose                     corr 0.999969  max abs   0.0645  mean abs 0.01497   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.0762  mean abs 0.01593
-    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00938   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0098  mean abs 0.00296   (by error, pooled)
-
-frame 51: corr 0.999965  max abs 1.0000
-    action                   corr 0.999955  max abs   0.0171  mean abs 0.00784   (by error, pooled)
-    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02560
-    desire_state             corr 0.999986  max abs   0.2344  mean abs 0.11670   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2461  mean abs 0.01509
-    lane_lines               corr 0.999951  max abs   0.0938  mean abs 0.01672
-    lane_lines_prob          corr 0.999965  max abs   0.0923  mean abs 0.04596   (by error, pooled)
-    lead                     corr 0.999997  max abs   1.0000  mean abs 0.07913
-    lead_prob                corr 0.999973  max abs   0.0742  mean abs 0.04818   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0635  mean abs 0.02527
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2812  mean abs 0.01103
-    pose                     corr 0.999996  max abs   0.0625  mean abs 0.01496   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0859  mean abs 0.01813
-    road_transform           corr 0.999997  max abs   0.0391  mean abs 0.00987   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0352  mean abs 0.00953   (by error, pooled)
-
-frame 52: corr 0.999978  max abs 0.2012
-    action                   corr 0.999939  max abs   0.0176  mean abs 0.00873   (by error, pooled)
-    desire_pred              corr 0.999917  max abs   0.0859  mean abs 0.03464
-    desire_state             corr 0.999988  max abs   0.1250  mean abs 0.07446   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2012  mean abs 0.01484
-    lane_lines               corr 0.999930  max abs   0.0728  mean abs 0.01964
-    lane_lines_prob          corr 0.999950  max abs   0.0859  mean abs 0.04348   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01256
-    lead_prob                corr 0.999933  max abs   0.0420  mean abs 0.02441   (by error, pooled)
-    meta                     corr 0.999891  max abs   0.0859  mean abs 0.04246
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1094  mean abs 0.00555
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00976   (by error, pooled)
-    road_edges               corr 0.999877  max abs   0.1211  mean abs 0.03057
-    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00986   (by error, pooled)
-    wide_from_device_euler   corr 0.999987  max abs   0.0293  mean abs 0.00785   (by error, pooled)
-
-frame 53: corr 0.999953  max abs 0.3594
-    action                   corr 0.999955  max abs   0.0264  mean abs 0.01454   (by error, pooled)
-    desire_pred              corr 0.999863  max abs   0.0909  mean abs 0.04372
-    desire_state             corr 0.999980  max abs   0.1289  mean abs 0.09619   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2233  mean abs 0.01320
-    lane_lines               corr 0.999966  max abs   0.0430  mean abs 0.01369
-    lane_lines_prob          corr 0.999981  max abs   0.0898  mean abs 0.04086   (by error, pooled)
-    lead                     corr 0.999975  max abs   0.3594  mean abs 0.03772
-    lead_prob                corr 1.000000  max abs   0.1113  mean abs 0.10026   (by error, pooled)
-    meta                     corr 0.999829  max abs   0.1133  mean abs 0.04773
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999965  max abs   0.3359  mean abs 0.01300
-    pose                     corr 0.999988  max abs   0.0337  mean abs 0.01259   (by error, pooled)
-    road_edges               corr 0.999928  max abs   0.0664  mean abs 0.02024
-    road_transform           corr 0.999998  max abs   0.0391  mean abs 0.00905   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0664  mean abs 0.01831   (by error, pooled)
-
-frame 54: corr 0.999957  max abs 0.2812
-    action                   corr 0.999996  max abs   0.0107  mean abs 0.00582   (by error, pooled)
-    desire_pred              corr 0.999951  max abs   0.0625  mean abs 0.03176
-    desire_state             corr 0.999988  max abs   0.0859  mean abs 0.04181   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1094  mean abs 0.01179
-    lane_lines               corr 0.999965  max abs   0.0625  mean abs 0.01655
-    lane_lines_prob          corr 0.999982  max abs   0.1602  mean abs 0.07764   (by error, pooled)
-    lead                     corr 0.999964  max abs   0.2812  mean abs 0.02281
-    lead_prob                corr 0.999936  max abs   0.1270  mean abs 0.10685   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0977  mean abs 0.04134
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0508  mean abs 0.00573
-    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00550   (by error, pooled)
-    road_edges               corr 0.999951  max abs   0.0938  mean abs 0.01782
-    road_transform           corr 0.999994  max abs   0.0352  mean abs 0.00506   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0117  mean abs 0.00426   (by error, pooled)
-
-frame 55: corr 0.999957  max abs 0.3438
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00665   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0664  mean abs 0.02021
-    desire_state             corr 0.999981  max abs   0.0703  mean abs 0.04671   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1152  mean abs 0.01115
-    lane_lines               corr 0.999975  max abs   0.0664  mean abs 0.01440
-    lane_lines_prob          corr 0.999967  max abs   0.1172  mean abs 0.04901   (by error, pooled)
-    lead                     corr 0.999812  max abs   0.3438  mean abs 0.02753
-    lead_prob                corr 0.999817  max abs   0.1270  mean abs 0.09538   (by error, pooled)
-    meta                     corr 0.999947  max abs   0.0879  mean abs 0.03769
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00460
-    pose                     corr 0.999997  max abs   0.0137  mean abs 0.00518   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0742  mean abs 0.01324
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00457   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0137  mean abs 0.00523   (by error, pooled)
-
-frame 56: corr 0.999956  max abs 0.2725
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00525   (by error, pooled)
-    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02641
-    desire_state             corr 0.999997  max abs   0.0781  mean abs 0.03787   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01219
-    lane_lines               corr 0.999980  max abs   0.0566  mean abs 0.01184
-    lane_lines_prob          corr 0.999868  max abs   0.0801  mean abs 0.04492   (by error, pooled)
-    lead                     corr 0.999601  max abs   0.2725  mean abs 0.02176
-    lead_prob                corr 0.999846  max abs   0.1016  mean abs 0.07747   (by error, pooled)
-    meta                     corr 0.999915  max abs   0.0918  mean abs 0.03517
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0645  mean abs 0.00431
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00586   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0820  mean abs 0.01239
-    road_transform           corr 0.999995  max abs   0.0273  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0312  mean abs 0.01176   (by error, pooled)
-
-frame 57: corr 0.999956  max abs 0.3750
-    action                   corr 0.999985  max abs   0.0181  mean abs 0.00963   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0840  mean abs 0.03075
-    desire_state             corr 0.999990  max abs   0.1641  mean abs 0.07544   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1709  mean abs 0.01410
-    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01614
-    lane_lines_prob          corr 0.999859  max abs   0.1719  mean abs 0.06293   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.3750  mean abs 0.02853
-    lead_prob                corr 0.999945  max abs   0.0859  mean abs 0.07056   (by error, pooled)
-    meta                     corr 0.999730  max abs   0.1221  mean abs 0.04862
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00455
-    pose                     corr 0.999991  max abs   0.0264  mean abs 0.00733   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.1484  mean abs 0.01666
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00581   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00560   (by error, pooled)
-
-frame 58: corr 0.999957  max abs 0.2344
-    action                   corr 0.999990  max abs   0.0176  mean abs 0.00778   (by error, pooled)
-    desire_pred              corr 0.999951  max abs   0.0820  mean abs 0.02925
-    desire_state             corr 0.999976  max abs   0.2344  mean abs 0.08923   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1797  mean abs 0.01294
-    lane_lines               corr 0.999962  max abs   0.0898  mean abs 0.01531
-    lane_lines_prob          corr 0.999956  max abs   0.1406  mean abs 0.04791   (by error, pooled)
-    lead                     corr 0.999965  max abs   0.2266  mean abs 0.01826
-    lead_prob                corr 0.999449  max abs   0.1094  mean abs 0.08789   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0840  mean abs 0.02789
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999989  max abs   0.1172  mean abs 0.00709
-    pose                     corr 0.999986  max abs   0.0332  mean abs 0.00896   (by error, pooled)
-    road_edges               corr 0.999958  max abs   0.0762  mean abs 0.01881
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00638   (by error, pooled)
-    wide_from_device_euler   corr 0.999990  max abs   0.0273  mean abs 0.00886   (by error, pooled)
-
-frame 59: corr 0.999930  max abs 0.4062
-    action                   corr 0.999972  max abs   0.0303  mean abs 0.01643   (by error, pooled)
-    desire_pred              corr 0.999927  max abs   0.0918  mean abs 0.03131
-    desire_state             corr 0.999944  max abs   0.3750  mean abs 0.15173   (by error, pooled)
-    hidden_state             corr 0.999942  max abs   0.2227  mean abs 0.01407
-    lane_lines               corr 0.999958  max abs   0.1094  mean abs 0.01538
-    lane_lines_prob          corr 0.999842  max abs   0.1602  mean abs 0.06467   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.4062  mean abs 0.05356
-    lead_prob                corr 0.999797  max abs   0.0723  mean abs 0.05273   (by error, pooled)
-    meta                     corr 0.999951  max abs   0.0879  mean abs 0.02836
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999951  max abs   0.2422  mean abs 0.01267
-    pose                     corr 0.999965  max abs   0.0664  mean abs 0.01563   (by error, pooled)
-    road_edges               corr 0.999949  max abs   0.0859  mean abs 0.01721
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00719   (by error, pooled)
-
-frame 60: corr 0.999953  max abs 1.0000
-    action                   corr 0.999916  max abs   0.0254  mean abs 0.01387   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0684  mean abs 0.02454
-    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.05286   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2129  mean abs 0.01532
-    lane_lines               corr 0.999956  max abs   0.0664  mean abs 0.01584
-    lane_lines_prob          corr 0.999989  max abs   0.1016  mean abs 0.04890   (by error, pooled)
-    lead                     corr 0.999992  max abs   1.0000  mean abs 0.07129
-    lead_prob                corr 0.999970  max abs   0.0234  mean abs 0.01530   (by error, pooled)
-    meta                     corr 0.999944  max abs   0.0752  mean abs 0.02185
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999975  max abs   0.3750  mean abs 0.01604
-    pose                     corr 0.999991  max abs   0.0859  mean abs 0.01885   (by error, pooled)
-    road_edges               corr 0.999929  max abs   0.0938  mean abs 0.02242
-    road_transform           corr 0.999997  max abs   0.0508  mean abs 0.01206   (by error, pooled)
-    wide_from_device_euler   corr 0.999986  max abs   0.0449  mean abs 0.01542   (by error, pooled)
-
-frame 61: corr 0.999977  max abs 0.1719
-    action                   corr 0.999976  max abs   0.0110  mean abs 0.00571   (by error, pooled)
-    desire_pred              corr 0.999891  max abs   0.0957  mean abs 0.03925
-    desire_state             corr 0.999997  max abs   0.1094  mean abs 0.04929   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1719  mean abs 0.01461
-    lane_lines               corr 0.999884  max abs   0.1038  mean abs 0.02350
-    lane_lines_prob          corr 0.999950  max abs   0.1133  mean abs 0.05789   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.0625  mean abs 0.00837
-    lead_prob                corr 0.999996  max abs   0.0300  mean abs 0.01326   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.0898  mean abs 0.04400
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1328  mean abs 0.00503
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00992   (by error, pooled)
-    road_edges               corr 0.999869  max abs   0.1055  mean abs 0.03016
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01394   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00525   (by error, pooled)
-
-frame 62: corr 0.999960  max abs 0.3125
-    action                   corr 0.999978  max abs   0.0215  mean abs 0.01225   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0781  mean abs 0.02914
-    desire_state             corr 0.999993  max abs   0.1836  mean abs 0.09161   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2567  mean abs 0.01361
-    lane_lines               corr 0.999948  max abs   0.0547  mean abs 0.01539
-    lane_lines_prob          corr 0.999908  max abs   0.1406  mean abs 0.04785   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.2812  mean abs 0.02750
-    lead_prob                corr 0.999994  max abs   0.1069  mean abs 0.08285   (by error, pooled)
-    meta                     corr 0.999832  max abs   0.1113  mean abs 0.04802
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999967  max abs   0.3125  mean abs 0.01284
-    pose                     corr 0.999995  max abs   0.0234  mean abs 0.00736   (by error, pooled)
-    road_edges               corr 0.999888  max abs   0.0762  mean abs 0.02576
-    road_transform           corr 0.999996  max abs   0.0586  mean abs 0.01589   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0625  mean abs 0.01701   (by error, pooled)
-
-frame 63: corr 0.999957  max abs 0.2812
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00650   (by error, pooled)
-    desire_pred              corr 0.999947  max abs   0.0625  mean abs 0.03246
-    desire_state             corr 0.999977  max abs   0.2812  mean abs 0.15918   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1172  mean abs 0.01182
-    lane_lines               corr 0.999977  max abs   0.0488  mean abs 0.01284
-    lane_lines_prob          corr 0.999981  max abs   0.0742  mean abs 0.03076   (by error, pooled)
-    lead                     corr 0.999970  max abs   0.2188  mean abs 0.01843
-    lead_prob                corr 0.999815  max abs   0.1631  mean abs 0.13082   (by error, pooled)
-    meta                     corr 0.999893  max abs   0.1172  mean abs 0.04738
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0781  mean abs 0.00548
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00508   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0703  mean abs 0.01408
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00530   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00687   (by error, pooled)
-
-frame 64: corr 0.999965  max abs 0.1797
-    action                   corr 0.999996  max abs   0.0137  mean abs 0.00573   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.0586  mean abs 0.02530
-    desire_state             corr 0.999986  max abs   0.1797  mean abs 0.10046   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1094  mean abs 0.01099
-    lane_lines               corr 0.999959  max abs   0.0820  mean abs 0.01630
-    lane_lines_prob          corr 0.999910  max abs   0.1094  mean abs 0.04137   (by error, pooled)
-    lead                     corr 0.999964  max abs   0.1328  mean abs 0.00961
-    lead_prob                corr 0.999999  max abs   0.0703  mean abs 0.06543   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0908  mean abs 0.03479
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00662
-    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00592   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.1016  mean abs 0.01671
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00400   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00458   (by error, pooled)
-
-frame 65: corr 0.999955  max abs 0.3066
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00378   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0820  mean abs 0.03578
-    desire_state             corr 0.999981  max abs   0.2109  mean abs 0.08820   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1289  mean abs 0.01225
-    lane_lines               corr 0.999969  max abs   0.0742  mean abs 0.01382
-    lane_lines_prob          corr 0.999911  max abs   0.0781  mean abs 0.03632   (by error, pooled)
-    lead                     corr 0.999721  max abs   0.3066  mean abs 0.02560
-    lead_prob                corr 0.999990  max abs   0.0859  mean abs 0.06999   (by error, pooled)
-    meta                     corr 0.999897  max abs   0.1035  mean abs 0.04263
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0278  mean abs 0.00595
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00621   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0918  mean abs 0.01782
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00547   (by error, pooled)
-    wide_from_device_euler   corr 0.999987  max abs   0.0391  mean abs 0.01046   (by error, pooled)
-
-frame 66: corr 0.999963  max abs 0.2500
-    action                   corr 0.999981  max abs   0.0215  mean abs 0.01265   (by error, pooled)
-    desire_pred              corr 0.999946  max abs   0.0625  mean abs 0.02707
-    desire_state             corr 0.999988  max abs   0.2500  mean abs 0.10840   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.2002  mean abs 0.01356
-    lane_lines               corr 0.999966  max abs   0.1387  mean abs 0.01399
-    lane_lines_prob          corr 0.999910  max abs   0.0793  mean abs 0.04556   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.1328  mean abs 0.01790
-    lead_prob                corr 0.999748  max abs   0.1641  mean abs 0.10872   (by error, pooled)
-    meta                     corr 0.999933  max abs   0.0657  mean abs 0.02508
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.0625  mean abs 0.00973
-    pose                     corr 0.999984  max abs   0.0410  mean abs 0.01082   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.1250  mean abs 0.01564
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00556   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00655   (by error, pooled)
-
-frame 67: corr 0.999957  max abs 0.2344
-    action                   corr 0.999978  max abs   0.0273  mean abs 0.01236   (by error, pooled)
-    desire_pred              corr 0.999907  max abs   0.0820  mean abs 0.03851
-    desire_state             corr 0.999987  max abs   0.1875  mean abs 0.09302   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1855  mean abs 0.01315
-    lane_lines               corr 0.999942  max abs   0.1328  mean abs 0.01776
-    lane_lines_prob          corr 0.999937  max abs   0.1094  mean abs 0.02963   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.1875  mean abs 0.02484
-    lead_prob                corr 0.999982  max abs   0.1445  mean abs 0.12012   (by error, pooled)
-    meta                     corr 0.999887  max abs   0.0977  mean abs 0.03546
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999984  max abs   0.2344  mean abs 0.01087
-    pose                     corr 0.999981  max abs   0.0391  mean abs 0.01217   (by error, pooled)
-    road_edges               corr 0.999946  max abs   0.1016  mean abs 0.01812
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00768   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0293  mean abs 0.00722   (by error, pooled)
-
-frame 68: corr 0.999950  max abs 0.2148
-    action                   corr 0.999973  max abs   0.0332  mean abs 0.01659   (by error, pooled)
-    desire_pred              corr 0.999921  max abs   0.0742  mean abs 0.03478
-    desire_state             corr 0.999979  max abs   0.2109  mean abs 0.10840   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.2148  mean abs 0.01354
-    lane_lines               corr 0.999962  max abs   0.0566  mean abs 0.01385
-    lane_lines_prob          corr 0.999875  max abs   0.1016  mean abs 0.04523   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.2031  mean abs 0.02641
-    lead_prob                corr 0.999954  max abs   0.1250  mean abs 0.09928   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0547  mean abs 0.02170
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999975  max abs   0.1641  mean abs 0.01313
-    pose                     corr 0.999970  max abs   0.0566  mean abs 0.01544   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0781  mean abs 0.01303
-    road_transform           corr 0.999993  max abs   0.0430  mean abs 0.00872   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00362   (by error, pooled)
-
-frame 69: corr 0.999968  max abs 0.5625
-    action                   corr 0.999962  max abs   0.0151  mean abs 0.00745   (by error, pooled)
-    desire_pred              corr 0.999940  max abs   0.0938  mean abs 0.02908
-    desire_state             corr 0.999984  max abs   0.1719  mean abs 0.09521   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.1953  mean abs 0.01517
-    lane_lines               corr 0.999940  max abs   0.0938  mean abs 0.01824
-    lane_lines_prob          corr 0.999938  max abs   0.1445  mean abs 0.05496   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5625  mean abs 0.05521
-    lead_prob                corr 0.999977  max abs   0.0684  mean abs 0.05176   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0840  mean abs 0.02844
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2031  mean abs 0.00985
-    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01493   (by error, pooled)
-    road_edges               corr 0.999904  max abs   0.1094  mean abs 0.02694
-    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.00889   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0352  mean abs 0.01180   (by error, pooled)
-
-frame 70: corr 0.999977  max abs 0.3125
-    action                   corr 0.999972  max abs   0.0129  mean abs 0.00566   (by error, pooled)
-    desire_pred              corr 0.999886  max abs   0.1113  mean abs 0.04156
-    desire_state             corr 0.999998  max abs   0.1016  mean abs 0.05786   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1758  mean abs 0.01456
-    lane_lines               corr 0.999905  max abs   0.0802  mean abs 0.02389
-    lane_lines_prob          corr 0.999826  max abs   0.2500  mean abs 0.09526   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02130
-    lead_prob                corr 0.999998  max abs   0.0811  mean abs 0.07210   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.1133  mean abs 0.04726
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.3125  mean abs 0.00817
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00944   (by error, pooled)
-    road_edges               corr 0.999890  max abs   0.0894  mean abs 0.02809
-    road_transform           corr 0.999991  max abs   0.0312  mean abs 0.01126   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00299   (by error, pooled)
-
-frame 71: corr 0.999950  max abs 0.3438
-    action                   corr 0.999978  max abs   0.0215  mean abs 0.01211   (by error, pooled)
-    desire_pred              corr 0.999920  max abs   0.0807  mean abs 0.03205
-    desire_state             corr 0.999996  max abs   0.2188  mean abs 0.09253   (by error, pooled)
-    hidden_state             corr 0.999947  max abs   0.2341  mean abs 0.01328
-    lane_lines               corr 0.999953  max abs   0.0898  mean abs 0.01493
-    lane_lines_prob          corr 0.999982  max abs   0.0508  mean abs 0.02563   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.04068
-    lead_prob                corr 0.999966  max abs   0.1367  mean abs 0.10775   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.1094  mean abs 0.05435
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999981  max abs   0.2344  mean abs 0.01384
-    pose                     corr 0.999987  max abs   0.0312  mean abs 0.01272   (by error, pooled)
-    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02025
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00433   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00757   (by error, pooled)
-
-frame 72: corr 0.999965  max abs 0.1211
-    action                   corr 0.999994  max abs   0.0137  mean abs 0.00534   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0664  mean abs 0.03443
-    desire_state             corr 0.999995  max abs   0.0781  mean abs 0.03052   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01144
-    lane_lines               corr 0.999965  max abs   0.0703  mean abs 0.01386
-    lane_lines_prob          corr 0.999937  max abs   0.1211  mean abs 0.04553   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.0938  mean abs 0.00948
-    lead_prob                corr 0.999937  max abs   0.1016  mean abs 0.06445   (by error, pooled)
-    meta                     corr 0.999926  max abs   0.1016  mean abs 0.03933
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1016  mean abs 0.00674
-    pose                     corr 0.999995  max abs   0.0244  mean abs 0.00696   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01637
-    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00678   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0156  mean abs 0.00522   (by error, pooled)
-
-frame 73: corr 0.999964  max abs 0.2422
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00574   (by error, pooled)
-    desire_pred              corr 0.999945  max abs   0.0605  mean abs 0.03956
-    desire_state             corr 0.999969  max abs   0.2422  mean abs 0.08496   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1230  mean abs 0.01152
-    lane_lines               corr 0.999980  max abs   0.0430  mean abs 0.01133
-    lane_lines_prob          corr 0.999959  max abs   0.1133  mean abs 0.05399   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0469  mean abs 0.00878
-    lead_prob                corr 0.999995  max abs   0.0898  mean abs 0.07878   (by error, pooled)
-    meta                     corr 0.999917  max abs   0.1191  mean abs 0.03578
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00729
-    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00591   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0781  mean abs 0.01458
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00506   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
-
-frame 74: corr 0.999962  max abs 0.1289
-    action                   corr 0.999998  max abs   0.0088  mean abs 0.00378   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0547  mean abs 0.02530
-    desire_state             corr 0.999978  max abs   0.1250  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1289  mean abs 0.01225
-    lane_lines               corr 0.999983  max abs   0.0488  mean abs 0.01069
-    lane_lines_prob          corr 0.999953  max abs   0.0820  mean abs 0.04108   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0216  mean abs 0.00366
-    lead_prob                corr 0.999999  max abs   0.0508  mean abs 0.04525   (by error, pooled)
-    meta                     corr 0.999931  max abs   0.0977  mean abs 0.03667
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0938  mean abs 0.00628
-    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00738   (by error, pooled)
-    road_edges               corr 0.999982  max abs   0.0762  mean abs 0.01163
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00798   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0273  mean abs 0.00852   (by error, pooled)
-
-frame 75: corr 0.999965  max abs 0.1802
-    action                   corr 0.999983  max abs   0.0181  mean abs 0.01035   (by error, pooled)
-    desire_pred              corr 0.999947  max abs   0.0645  mean abs 0.02671
-    desire_state             corr 0.999994  max abs   0.1367  mean abs 0.05273   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1802  mean abs 0.01418
-    lane_lines               corr 0.999977  max abs   0.0938  mean abs 0.01250
-    lane_lines_prob          corr 0.999884  max abs   0.0957  mean abs 0.03717   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1094  mean abs 0.01454
-    lead_prob                corr 0.999984  max abs   0.1094  mean abs 0.08919   (by error, pooled)
-    meta                     corr 0.999863  max abs   0.0909  mean abs 0.03252
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1406  mean abs 0.00598
-    pose                     corr 0.999991  max abs   0.0312  mean abs 0.00796   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0935  mean abs 0.01715
-    road_transform           corr 0.999994  max abs   0.0293  mean abs 0.00751   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00364   (by error, pooled)
-
-frame 76: corr 0.999955  max abs 0.2588
-    action                   corr 0.999980  max abs   0.0273  mean abs 0.01375   (by error, pooled)
-    desire_pred              corr 0.999935  max abs   0.0820  mean abs 0.02995
-    desire_state             corr 0.999972  max abs   0.2588  mean abs 0.14471   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2383  mean abs 0.01328
-    lane_lines               corr 0.999969  max abs   0.0898  mean abs 0.01368
-    lane_lines_prob          corr 0.999914  max abs   0.0938  mean abs 0.03456   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.1250  mean abs 0.01952
-    lead_prob                corr 0.999992  max abs   0.0938  mean abs 0.08008   (by error, pooled)
-    meta                     corr 0.999916  max abs   0.0840  mean abs 0.03474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.1875  mean abs 0.01056
-    pose                     corr 0.999962  max abs   0.0625  mean abs 0.01739   (by error, pooled)
-    road_edges               corr 0.999984  max abs   0.0664  mean abs 0.01294
-    road_transform           corr 1.000000  max abs   0.0234  mean abs 0.00646   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00525   (by error, pooled)
-
-frame 77: corr 0.999951  max abs 0.3906
-    action                   corr 0.999970  max abs   0.0322  mean abs 0.01698   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.01995
-    desire_state             corr 0.999907  max abs   0.3906  mean abs 0.19397   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.1758  mean abs 0.01404
-    lane_lines               corr 0.999972  max abs   0.1133  mean abs 0.01270
-    lane_lines_prob          corr 0.999942  max abs   0.0859  mean abs 0.03262   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.1562  mean abs 0.02014
-    lead_prob                corr 0.999992  max abs   0.1465  mean abs 0.12314   (by error, pooled)
-    meta                     corr 0.999966  max abs   0.0723  mean abs 0.02376
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999984  max abs   0.2031  mean abs 0.01073
-    pose                     corr 0.999977  max abs   0.0547  mean abs 0.01181   (by error, pooled)
-    road_edges               corr 0.999977  max abs   0.0781  mean abs 0.01255
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00620   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0312  mean abs 0.01147   (by error, pooled)
-
-frame 78: corr 0.999968  max abs 0.8125
-    action                   corr 0.999945  max abs   0.0176  mean abs 0.00992   (by error, pooled)
-    desire_pred              corr 0.999977  max abs   0.0586  mean abs 0.01959
-    desire_state             corr 0.999985  max abs   0.1729  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2227  mean abs 0.01550
-    lane_lines               corr 0.999957  max abs   0.1406  mean abs 0.01580
-    lane_lines_prob          corr 0.999853  max abs   0.1797  mean abs 0.05075   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.8125  mean abs 0.07051
-    lead_prob                corr 0.999988  max abs   0.1138  mean abs 0.10042   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.0693  mean abs 0.02624
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1875  mean abs 0.01092
-    pose                     corr 0.999994  max abs   0.0703  mean abs 0.01583   (by error, pooled)
-    road_edges               corr 0.999944  max abs   0.0996  mean abs 0.02373
-    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01103   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.01083   (by error, pooled)
-
-frame 79: corr 0.999981  max abs 0.1953
-    action                   corr 0.999993  max abs   0.0068  mean abs 0.00330   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03223
-    desire_state             corr 0.999988  max abs   0.1230  mean abs 0.05566   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1953  mean abs 0.01466
-    lane_lines               corr 0.999930  max abs   0.0938  mean abs 0.02010
-    lane_lines_prob          corr 0.999953  max abs   0.1172  mean abs 0.06225   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01362
-    lead_prob                corr 0.999989  max abs   0.0771  mean abs 0.06576   (by error, pooled)
-    meta                     corr 0.999859  max abs   0.1152  mean abs 0.04403
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1875  mean abs 0.00592
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01025   (by error, pooled)
-    road_edges               corr 0.999916  max abs   0.0781  mean abs 0.02472
-    road_transform           corr 0.999992  max abs   0.0508  mean abs 0.01150   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.00590   (by error, pooled)
-
-frame 80: corr 0.999966  max abs 0.2447
-    action                   corr 0.999955  max abs   0.0244  mean abs 0.01292   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0703  mean abs 0.02839
-    desire_state             corr 0.999985  max abs   0.1719  mean abs 0.06842   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2447  mean abs 0.01320
-    lane_lines               corr 0.999966  max abs   0.0469  mean abs 0.01316
-    lane_lines_prob          corr 0.999978  max abs   0.0685  mean abs 0.03523   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.1562  mean abs 0.02241
-    lead_prob                corr 0.999989  max abs   0.1465  mean abs 0.12874   (by error, pooled)
-    meta                     corr 0.999904  max abs   0.0859  mean abs 0.03536
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00775
-    pose                     corr 0.999993  max abs   0.0273  mean abs 0.01102   (by error, pooled)
-    road_edges               corr 0.999933  max abs   0.0762  mean abs 0.01956
-    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01118   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0391  mean abs 0.01375   (by error, pooled)
-
-frame 81: corr 0.999958  max abs 0.1680
-    action                   corr 0.999988  max abs   0.0205  mean abs 0.00917   (by error, pooled)
-    desire_pred              corr 0.999936  max abs   0.0688  mean abs 0.03357
-    desire_state             corr 0.999965  max abs   0.1289  mean abs 0.07713   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01147
-    lane_lines               corr 0.999936  max abs   0.1211  mean abs 0.01838
-    lane_lines_prob          corr 0.999911  max abs   0.1055  mean abs 0.03925   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.0508  mean abs 0.00909
-    lead_prob                corr 0.999975  max abs   0.1523  mean abs 0.12354   (by error, pooled)
-    meta                     corr 0.999839  max abs   0.1426  mean abs 0.05474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00678
-    pose                     corr 0.999993  max abs   0.0283  mean abs 0.00774   (by error, pooled)
-    road_edges               corr 0.999924  max abs   0.1680  mean abs 0.02038
-    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00653   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00264   (by error, pooled)
-
-frame 82: corr 0.999961  max abs 0.1594
-    action                   corr 0.999997  max abs   0.0088  mean abs 0.00259   (by error, pooled)
-    desire_pred              corr 0.999950  max abs   0.0781  mean abs 0.03089
-    desire_state             corr 0.999990  max abs   0.1172  mean abs 0.07062   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1289  mean abs 0.01148
-    lane_lines               corr 0.999967  max abs   0.0625  mean abs 0.01310
-    lane_lines_prob          corr 0.999949  max abs   0.0840  mean abs 0.04501   (by error, pooled)
-    lead                     corr 0.999844  max abs   0.1594  mean abs 0.01475
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.07214   (by error, pooled)
-    meta                     corr 0.999943  max abs   0.0762  mean abs 0.03255
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00434
-    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00594   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0586  mean abs 0.01416
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00416   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0137  mean abs 0.00295   (by error, pooled)
-
-frame 83: corr 0.999955  max abs 0.2578
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00385   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0742  mean abs 0.02845
-    desire_state             corr 0.999985  max abs   0.1309  mean abs 0.03833   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1328  mean abs 0.01242
-    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01571
-    lane_lines_prob          corr 0.999971  max abs   0.1211  mean abs 0.05807   (by error, pooled)
-    lead                     corr 0.999982  max abs   0.2578  mean abs 0.02209
-    lead_prob                corr 0.999999  max abs   0.0977  mean abs 0.08310   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.0898  mean abs 0.03797
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00380
-    pose                     corr 0.999997  max abs   0.0273  mean abs 0.00770   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0781  mean abs 0.01535
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00790   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00981   (by error, pooled)
-
-frame 84: corr 0.999958  max abs 0.3125
-    action                   corr 0.999986  max abs   0.0161  mean abs 0.00913   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0586  mean abs 0.02159
-    desire_state             corr 0.999929  max abs   0.1484  mean abs 0.08228   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1641  mean abs 0.01399
-    lane_lines               corr 0.999933  max abs   0.2227  mean abs 0.01733
-    lane_lines_prob          corr 0.999822  max abs   0.0898  mean abs 0.05341   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.3125  mean abs 0.02349
-    lead_prob                corr 0.999966  max abs   0.1680  mean abs 0.14006   (by error, pooled)
-    meta                     corr 0.999860  max abs   0.0996  mean abs 0.03439
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00519
-    pose                     corr 0.999989  max abs   0.0264  mean abs 0.00699   (by error, pooled)
-    road_edges               corr 0.999965  max abs   0.1250  mean abs 0.01487
-    road_transform           corr 0.999992  max abs   0.0312  mean abs 0.00808   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
-
-frame 85: corr 0.999955  max abs 0.3750
-    action                   corr 0.999969  max abs   0.0234  mean abs 0.01309   (by error, pooled)
-    desire_pred              corr 0.999931  max abs   0.0625  mean abs 0.02937
-    desire_state             corr 0.999725  max abs   0.3613  mean abs 0.19666   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01400
-    lane_lines               corr 0.999966  max abs   0.1133  mean abs 0.01702
-    lane_lines_prob          corr 0.999995  max abs   0.0762  mean abs 0.04250   (by error, pooled)
-    lead                     corr 0.999957  max abs   0.3750  mean abs 0.03565
-    lead_prob                corr 0.999985  max abs   0.2383  mean abs 0.19333   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.0762  mean abs 0.02420
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999987  max abs   0.1875  mean abs 0.00896
-    pose                     corr 0.999974  max abs   0.0781  mean abs 0.01537   (by error, pooled)
-    road_edges               corr 0.999981  max abs   0.0625  mean abs 0.01499
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00857   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0215  mean abs 0.00817   (by error, pooled)
-
-frame 86: corr 0.999929  max abs 0.4688
-    action                   corr 0.999969  max abs   0.0332  mean abs 0.01874   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0625  mean abs 0.03150
-    desire_state             corr 0.999726  max abs   0.3828  mean abs 0.18327   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2188  mean abs 0.01377
-    lane_lines               corr 0.999964  max abs   0.0977  mean abs 0.01412
-    lane_lines_prob          corr 0.999902  max abs   0.1211  mean abs 0.04495   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.4688  mean abs 0.05692
-    lead_prob                corr 0.999998  max abs   0.1328  mean abs 0.10693   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0742  mean abs 0.02528
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999959  max abs   0.2422  mean abs 0.01130
-    pose                     corr 0.999958  max abs   0.0762  mean abs 0.01647   (by error, pooled)
-    road_edges               corr 0.999942  max abs   0.0664  mean abs 0.02047
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00914   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00462   (by error, pooled)
-
-frame 87: corr 0.999969  max abs 0.8125
-    action                   corr 0.999944  max abs   0.0159  mean abs 0.00849   (by error, pooled)
-    desire_pred              corr 0.999961  max abs   0.0547  mean abs 0.02374
-    desire_state             corr 0.999984  max abs   0.1875  mean abs 0.09924   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2227  mean abs 0.01549
-    lane_lines               corr 0.999949  max abs   0.1328  mean abs 0.01768
-    lane_lines_prob          corr 0.999975  max abs   0.1562  mean abs 0.05096   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.8125  mean abs 0.06905
-    lead_prob                corr 0.999998  max abs   0.0582  mean abs 0.04545   (by error, pooled)
-    meta                     corr 0.999914  max abs   0.0977  mean abs 0.03504
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00920
-    pose                     corr 0.999995  max abs   0.0547  mean abs 0.01569   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0820  mean abs 0.02022
-    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.00987   (by error, pooled)
-    wide_from_device_euler   corr 0.999989  max abs   0.0371  mean abs 0.01217   (by error, pooled)
-
-frame 88: corr 0.999980  max abs 0.2500
-    action                   corr 0.999933  max abs   0.0154  mean abs 0.00757   (by error, pooled)
-    desire_pred              corr 0.999926  max abs   0.0781  mean abs 0.03278
-    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.09424   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1973  mean abs 0.01472
-    lane_lines               corr 0.999923  max abs   0.1016  mean abs 0.02050
-    lane_lines_prob          corr 0.999851  max abs   0.1992  mean abs 0.06371   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02078
-    lead_prob                corr 1.000000  max abs   0.0381  mean abs 0.03597   (by error, pooled)
-    meta                     corr 0.999879  max abs   0.1069  mean abs 0.03890
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1562  mean abs 0.00626
-    pose                     corr 0.999997  max abs   0.0332  mean abs 0.01122   (by error, pooled)
-    road_edges               corr 0.999909  max abs   0.0762  mean abs 0.02562
-    road_transform           corr 0.999995  max abs   0.0391  mean abs 0.01119   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0273  mean abs 0.01143   (by error, pooled)
-
-frame 89: corr 0.999968  max abs 0.2764
-    action                   corr 0.999955  max abs   0.0205  mean abs 0.01051   (by error, pooled)
-    desire_pred              corr 0.999926  max abs   0.0820  mean abs 0.03086
-    desire_state             corr 0.999993  max abs   0.1523  mean abs 0.05615   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2764  mean abs 0.01343
-    lane_lines               corr 0.999954  max abs   0.0723  mean abs 0.01570
-    lane_lines_prob          corr 0.999981  max abs   0.0487  mean abs 0.02660   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.1250  mean abs 0.01621
-    lead_prob                corr 0.999996  max abs   0.1006  mean abs 0.08167   (by error, pooled)
-    meta                     corr 0.999892  max abs   0.0879  mean abs 0.03854
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00805
-    pose                     corr 0.999994  max abs   0.0254  mean abs 0.00778   (by error, pooled)
-    road_edges               corr 0.999943  max abs   0.0547  mean abs 0.01786
-    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.01035   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0234  mean abs 0.00754   (by error, pooled)
-
-frame 90: corr 0.999954  max abs 0.4531
-    action                   corr 0.999991  max abs   0.0195  mean abs 0.00842   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0898  mean abs 0.02631
-    desire_state             corr 0.999939  max abs   0.1797  mean abs 0.09821   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1084  mean abs 0.01168
-    lane_lines               corr 0.999973  max abs   0.0566  mean abs 0.01503
-    lane_lines_prob          corr 0.999935  max abs   0.1055  mean abs 0.03369   (by error, pooled)
-    lead                     corr 0.999975  max abs   0.4531  mean abs 0.03565
-    lead_prob                corr 0.999992  max abs   0.1172  mean abs 0.09489   (by error, pooled)
-    meta                     corr 0.999906  max abs   0.1152  mean abs 0.04144
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00543
-    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00641   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01678
-    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00587   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00654   (by error, pooled)
-
-frame 91: corr 0.999962  max abs 0.1289
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00372   (by error, pooled)
-    desire_pred              corr 0.999940  max abs   0.0664  mean abs 0.03883
-    desire_state             corr 0.999991  max abs   0.1084  mean abs 0.05154   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1172  mean abs 0.01148
-    lane_lines               corr 0.999970  max abs   0.0684  mean abs 0.01578
-    lane_lines_prob          corr 0.999932  max abs   0.1289  mean abs 0.06403   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.1172  mean abs 0.01015
-    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05021   (by error, pooled)
-    meta                     corr 0.999922  max abs   0.1211  mean abs 0.04145
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00476
-    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00593   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0781  mean abs 0.01442
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00554   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
-
-frame 92: corr 0.999957  max abs 0.2812
-    action                   corr 0.999995  max abs   0.0117  mean abs 0.00358   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0625  mean abs 0.02961
-    desire_state             corr 0.999972  max abs   0.1562  mean abs 0.07922   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1406  mean abs 0.01247
-    lane_lines               corr 0.999979  max abs   0.0508  mean abs 0.01284
-    lane_lines_prob          corr 0.999871  max abs   0.1016  mean abs 0.04956   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.2812  mean abs 0.02249
-    lead_prob                corr 0.999993  max abs   0.1270  mean abs 0.11068   (by error, pooled)
-    meta                     corr 0.999877  max abs   0.1221  mean abs 0.04130
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00477
-    pose                     corr 0.999996  max abs   0.0273  mean abs 0.00755   (by error, pooled)
-    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01250
-    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00717   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.00916   (by error, pooled)
-
-frame 93: corr 0.999964  max abs 0.2656
-    action                   corr 0.999981  max abs   0.0215  mean abs 0.01099   (by error, pooled)
-    desire_pred              corr 0.999945  max abs   0.0742  mean abs 0.02887
-    desire_state             corr 0.999988  max abs   0.2656  mean abs 0.13892   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1895  mean abs 0.01406
-    lane_lines               corr 0.999968  max abs   0.1484  mean abs 0.01591
-    lane_lines_prob          corr 0.999764  max abs   0.1172  mean abs 0.05365   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.2500  mean abs 0.01816
-    lead_prob                corr 0.999967  max abs   0.1289  mean abs 0.10742   (by error, pooled)
-    meta                     corr 0.999924  max abs   0.0586  mean abs 0.02599
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00600
-    pose                     corr 0.999987  max abs   0.0391  mean abs 0.00918   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.1562  mean abs 0.01684
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00882   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0195  mean abs 0.00754   (by error, pooled)
-
-frame 94: corr 0.999953  max abs 0.3281
-    action                   corr 0.999966  max abs   0.0332  mean abs 0.01728   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0576  mean abs 0.02705
-    desire_state             corr 0.999938  max abs   0.3281  mean abs 0.16232   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2441  mean abs 0.01358
-    lane_lines               corr 0.999950  max abs   0.1250  mean abs 0.01747
-    lane_lines_prob          corr 0.999927  max abs   0.1055  mean abs 0.03625   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.2188  mean abs 0.03006
-    lead_prob                corr 0.999986  max abs   0.1157  mean abs 0.08781   (by error, pooled)
-    meta                     corr 0.999953  max abs   0.0781  mean abs 0.03182
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999970  max abs   0.2656  mean abs 0.01275
-    pose                     corr 0.999957  max abs   0.0762  mean abs 0.01822   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0898  mean abs 0.01856
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00948   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
-
-frame 95: corr 0.999938  max abs 0.4082
-    action                   corr 0.999969  max abs   0.0303  mean abs 0.01691   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0879  mean abs 0.02904
-    desire_state             corr 0.999939  max abs   0.4082  mean abs 0.19031   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2344  mean abs 0.01422
-    lane_lines               corr 0.999959  max abs   0.0547  mean abs 0.01523
-    lane_lines_prob          corr 0.999916  max abs   0.1211  mean abs 0.05078   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.3750  mean abs 0.05143
-    lead_prob                corr 0.999944  max abs   0.0874  mean abs 0.06909   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0586  mean abs 0.02371
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999955  max abs   0.3125  mean abs 0.01530
-    pose                     corr 0.999956  max abs   0.0820  mean abs 0.01721   (by error, pooled)
-    road_edges               corr 0.999957  max abs   0.0703  mean abs 0.01671
-    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.00905   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00428   (by error, pooled)
-
-frame 96: corr 0.999974  max abs 0.6875
-    action                   corr 0.999935  max abs   0.0173  mean abs 0.00852   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0781  mean abs 0.02634
-    desire_state             corr 0.999994  max abs   0.1562  mean abs 0.06445   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2266  mean abs 0.01531
-    lane_lines               corr 0.999951  max abs   0.1055  mean abs 0.01672
-    lane_lines_prob          corr 0.999990  max abs   0.0669  mean abs 0.04776   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.6875  mean abs 0.05516
-    lead_prob                corr 0.999996  max abs   0.0723  mean abs 0.06380   (by error, pooled)
-    meta                     corr 0.999932  max abs   0.0693  mean abs 0.02632
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00871
-    pose                     corr 0.999994  max abs   0.0469  mean abs 0.01649   (by error, pooled)
-    road_edges               corr 0.999946  max abs   0.0938  mean abs 0.02024
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01207   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0273  mean abs 0.00922   (by error, pooled)
-
-frame 97: corr 0.999982  max abs 0.4688
-    action                   corr 0.999967  max abs   0.0128  mean abs 0.00407   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0645  mean abs 0.02573
-    desire_state             corr 0.999995  max abs   0.1406  mean abs 0.06787   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1719  mean abs 0.01441
-    lane_lines               corr 0.999932  max abs   0.0606  mean abs 0.01968
-    lane_lines_prob          corr 0.999916  max abs   0.1445  mean abs 0.05452   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.4375  mean abs 0.02955
-    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05046   (by error, pooled)
-    meta                     corr 0.999821  max abs   0.1304  mean abs 0.04943
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.4688  mean abs 0.00954
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00943   (by error, pooled)
-    road_edges               corr 0.999859  max abs   0.1133  mean abs 0.03283
-    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.01045   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0234  mean abs 0.00787   (by error, pooled)
-
-frame 98: corr 0.999965  max abs 0.2734
-    action                   corr 0.999956  max abs   0.0273  mean abs 0.01571   (by error, pooled)
-    desire_pred              corr 0.999915  max abs   0.0781  mean abs 0.03284
-    desire_state             corr 0.999988  max abs   0.2734  mean abs 0.11719   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.2268  mean abs 0.01300
-    lane_lines               corr 0.999953  max abs   0.1113  mean abs 0.01482
-    lane_lines_prob          corr 0.999880  max abs   0.1016  mean abs 0.04564   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.1562  mean abs 0.02120
-    lead_prob                corr 1.000000  max abs   0.1094  mean abs 0.09202   (by error, pooled)
-    meta                     corr 0.999857  max abs   0.1113  mean abs 0.04895
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.0938  mean abs 0.01117
-    pose                     corr 0.999989  max abs   0.0288  mean abs 0.01237   (by error, pooled)
-    road_edges               corr 0.999928  max abs   0.0703  mean abs 0.02029
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00760   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01018   (by error, pooled)
-
-frame 99: corr 0.999963  max abs 0.2969
-    action                   corr 0.999987  max abs   0.0205  mean abs 0.00918   (by error, pooled)
-    desire_pred              corr 0.999938  max abs   0.0840  mean abs 0.03076
-    desire_state             corr 0.999991  max abs   0.2812  mean abs 0.08911   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01180
-    lane_lines               corr 0.999977  max abs   0.0410  mean abs 0.01467
-    lane_lines_prob          corr 0.999966  max abs   0.1289  mean abs 0.05359   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.2969  mean abs 0.02333
-    lead_prob                corr 0.999997  max abs   0.1367  mean abs 0.10441   (by error, pooled)
-    meta                     corr 0.999887  max abs   0.1074  mean abs 0.04481
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00535
-    pose                     corr 0.999995  max abs   0.0210  mean abs 0.00590   (by error, pooled)
-    road_edges               corr 0.999970  max abs   0.0508  mean abs 0.01679
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00702   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00458   (by error, pooled)
-
-frame 100: corr 0.999960  max abs 0.3140
-    action                   corr 0.999999  max abs   0.0068  mean abs 0.00314   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0518  mean abs 0.02459
-    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.03195   (by error, pooled)
-    hidden_state             corr 0.999957  max abs   0.1230  mean abs 0.01118
-    lane_lines               corr 0.999979  max abs   0.0430  mean abs 0.01357
-    lane_lines_prob          corr 0.999985  max abs   0.1094  mean abs 0.05763   (by error, pooled)
-    lead                     corr 0.999643  max abs   0.3140  mean abs 0.02712
-    lead_prob                corr 0.999987  max abs   0.1484  mean abs 0.10547   (by error, pooled)
-    meta                     corr 0.999940  max abs   0.1025  mean abs 0.04166
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00346
-    pose                     corr 0.999996  max abs   0.0202  mean abs 0.00544   (by error, pooled)
-    road_edges               corr 0.999976  max abs   0.0586  mean abs 0.01420
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00505   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0176  mean abs 0.00522   (by error, pooled)
-
-frame 101: corr 0.999937  max abs 0.6641
-    action                   corr 0.999995  max abs   0.0117  mean abs 0.00354   (by error, pooled)
-    desire_pred              corr 0.999969  max abs   0.0518  mean abs 0.02815
-    desire_state             corr 0.999997  max abs   0.2031  mean abs 0.10266   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1328  mean abs 0.01220
-    lane_lines               corr 0.999969  max abs   0.0879  mean abs 0.01564
-    lane_lines_prob          corr 0.999955  max abs   0.1211  mean abs 0.05682   (by error, pooled)
-    lead                     corr 0.999883  max abs   0.6641  mean abs 0.05588
-    lead_prob                corr 0.999992  max abs   0.1055  mean abs 0.09163   (by error, pooled)
-    meta                     corr 0.999959  max abs   0.0684  mean abs 0.02910
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00550
-    pose                     corr 0.999996  max abs   0.0234  mean abs 0.00685   (by error, pooled)
-    road_edges               corr 0.999976  max abs   0.0977  mean abs 0.01863
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00360   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00559   (by error, pooled)
-
-frame 102: corr 0.999960  max abs 0.4375
-    action                   corr 0.999981  max abs   0.0176  mean abs 0.01045   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0625  mean abs 0.02755
-    desire_state             corr 0.999986  max abs   0.2500  mean abs 0.08447   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2061  mean abs 0.01456
-    lane_lines               corr 0.999943  max abs   0.0977  mean abs 0.01675
-    lane_lines_prob          corr 0.999863  max abs   0.1328  mean abs 0.04132   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.4375  mean abs 0.03030
-    lead_prob                corr 0.999967  max abs   0.1816  mean abs 0.15218   (by error, pooled)
-    meta                     corr 0.999813  max abs   0.1104  mean abs 0.03652
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1406  mean abs 0.00664
-    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00640   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.1016  mean abs 0.01384
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00606   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00754   (by error, pooled)
-
-frame 103: corr 0.999953  max abs 0.3125
-    action                   corr 0.999974  max abs   0.0312  mean abs 0.01668   (by error, pooled)
-    desire_pred              corr 0.999972  max abs   0.0547  mean abs 0.01977
-    desire_state             corr 0.999959  max abs   0.3125  mean abs 0.14893   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2480  mean abs 0.01366
-    lane_lines               corr 0.999964  max abs   0.0508  mean abs 0.01451
-    lane_lines_prob          corr 0.999887  max abs   0.0898  mean abs 0.03701   (by error, pooled)
-    lead                     corr 0.999976  max abs   0.1875  mean abs 0.02543
-    lead_prob                corr 0.999992  max abs   0.1816  mean abs 0.14639   (by error, pooled)
-    meta                     corr 0.999946  max abs   0.0645  mean abs 0.02294
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999969  max abs   0.1719  mean abs 0.01478
-    pose                     corr 0.999950  max abs   0.0918  mean abs 0.01696   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0703  mean abs 0.01472
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00523   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00459   (by error, pooled)
-
-frame 104: corr 0.999931  max abs 0.4531
-    action                   corr 0.999925  max abs   0.0488  mean abs 0.02509   (by error, pooled)
-    desire_pred              corr 0.999900  max abs   0.1133  mean abs 0.03461
-    desire_state             corr 0.999958  max abs   0.4531  mean abs 0.17236   (by error, pooled)
-    hidden_state             corr 0.999937  max abs   0.3125  mean abs 0.01452
-    lane_lines               corr 0.999932  max abs   0.1484  mean abs 0.01686
-    lane_lines_prob          corr 0.999916  max abs   0.0781  mean abs 0.03748   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.4219  mean abs 0.05753
-    lead_prob                corr 0.999988  max abs   0.1245  mean abs 0.10400   (by error, pooled)
-    meta                     corr 0.999924  max abs   0.0684  mean abs 0.02939
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999922  max abs   0.3203  mean abs 0.01911
-    pose                     corr 0.999917  max abs   0.1250  mean abs 0.02585   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1367  mean abs 0.01656
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00823   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00626   (by error, pooled)
-
-frame 105: corr 0.999974  max abs 0.5000
-    action                   corr 0.999913  max abs   0.0165  mean abs 0.00865   (by error, pooled)
-    desire_pred              corr 0.999969  max abs   0.0625  mean abs 0.02130
-    desire_state             corr 0.999995  max abs   0.1875  mean abs 0.10400   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01515
-    lane_lines               corr 0.999951  max abs   0.0859  mean abs 0.01761
-    lane_lines_prob          corr 0.999951  max abs   0.1211  mean abs 0.04994   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5000  mean abs 0.04795
-    lead_prob                corr 0.999998  max abs   0.0432  mean abs 0.03849   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0713  mean abs 0.02498
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2188  mean abs 0.00823
-    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01456   (by error, pooled)
-    road_edges               corr 0.999936  max abs   0.1016  mean abs 0.02360
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00979   (by error, pooled)
-    wide_from_device_euler   corr 0.999979  max abs   0.0586  mean abs 0.01897   (by error, pooled)
-
-frame 106: corr 0.999980  max abs 0.2812
-    action                   corr 0.999940  max abs   0.0161  mean abs 0.00698   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03064
-    desire_state             corr 0.999992  max abs   0.2812  mean abs 0.12402   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2051  mean abs 0.01456
-    lane_lines               corr 0.999937  max abs   0.0898  mean abs 0.01915
-    lane_lines_prob          corr 0.999958  max abs   0.1367  mean abs 0.04807   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02541
-    lead_prob                corr 0.999987  max abs   0.0225  mean abs 0.01662   (by error, pooled)
-    meta                     corr 0.999880  max abs   0.0974  mean abs 0.04307
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2188  mean abs 0.00707
-    pose                     corr 0.999998  max abs   0.0371  mean abs 0.01430   (by error, pooled)
-    road_edges               corr 0.999895  max abs   0.0840  mean abs 0.02671
-    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00865   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00527   (by error, pooled)
-
-frame 107: corr 0.999963  max abs 0.2578
-    action                   corr 0.999936  max abs   0.0254  mean abs 0.01272   (by error, pooled)
-    desire_pred              corr 0.999894  max abs   0.0859  mean abs 0.04031
-    desire_state             corr 0.999993  max abs   0.2344  mean abs 0.13184   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2578  mean abs 0.01329
-    lane_lines               corr 0.999950  max abs   0.0684  mean abs 0.01641
-    lane_lines_prob          corr 0.999886  max abs   0.1328  mean abs 0.04726   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2188  mean abs 0.02691
-    lead_prob                corr 0.999999  max abs   0.0918  mean abs 0.08065   (by error, pooled)
-    meta                     corr 0.999884  max abs   0.0938  mean abs 0.04264
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1250  mean abs 0.00996
-    pose                     corr 0.999991  max abs   0.0273  mean abs 0.01014   (by error, pooled)
-    road_edges               corr 0.999945  max abs   0.0547  mean abs 0.01736
-    road_transform           corr 0.999999  max abs   0.0352  mean abs 0.01168   (by error, pooled)
-    wide_from_device_euler   corr 0.999990  max abs   0.0547  mean abs 0.01050   (by error, pooled)
-
-frame 108: corr 0.999953  max abs 0.4531
-    action                   corr 0.999987  max abs   0.0195  mean abs 0.00795   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02743
-    desire_state             corr 0.999997  max abs   0.1406  mean abs 0.09192   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01158
-    lane_lines               corr 0.999943  max abs   0.1113  mean abs 0.01750
-    lane_lines_prob          corr 0.999988  max abs   0.0781  mean abs 0.03223   (by error, pooled)
-    lead                     corr 0.999908  max abs   0.4531  mean abs 0.03446
-    lead_prob                corr 0.999998  max abs   0.1406  mean abs 0.11532   (by error, pooled)
-    meta                     corr 0.999873  max abs   0.1250  mean abs 0.05239
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.0938  mean abs 0.00566
-    pose                     corr 0.999994  max abs   0.0244  mean abs 0.00634   (by error, pooled)
-    road_edges               corr 0.999941  max abs   0.1289  mean abs 0.01927
-    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.00839   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00524   (by error, pooled)
-
-frame 109: corr 0.999954  max abs 0.4180
-    action                   corr 0.999988  max abs   0.0176  mean abs 0.00489   (by error, pooled)
-    desire_pred              corr 0.999974  max abs   0.0513  mean abs 0.02330
-    desire_state             corr 0.999998  max abs   0.1250  mean abs 0.07495   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1328  mean abs 0.01146
-    lane_lines               corr 0.999977  max abs   0.0391  mean abs 0.01328
-    lane_lines_prob          corr 0.999983  max abs   0.0840  mean abs 0.05257   (by error, pooled)
-    lead                     corr 0.999588  max abs   0.4180  mean abs 0.03676
-    lead_prob                corr 0.999994  max abs   0.1133  mean abs 0.08333   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0938  mean abs 0.03899
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0547  mean abs 0.00356
-    pose                     corr 0.999997  max abs   0.0146  mean abs 0.00483   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0664  mean abs 0.01521
-    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00294   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00524   (by error, pooled)
-
-frame 110: corr 0.999944  max abs 0.6172
-    action                   corr 0.999995  max abs   0.0103  mean abs 0.00399   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0469  mean abs 0.02397
-    desire_state             corr 0.999998  max abs   0.1562  mean abs 0.09961   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1367  mean abs 0.01232
-    lane_lines               corr 0.999978  max abs   0.0430  mean abs 0.01240
-    lane_lines_prob          corr 0.999844  max abs   0.1562  mean abs 0.06067   (by error, pooled)
-    lead                     corr 0.999893  max abs   0.6172  mean abs 0.05073
-    lead_prob                corr 1.000000  max abs   0.1172  mean abs 0.09749   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0791  mean abs 0.03100
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00384
-    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00671   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0508  mean abs 0.01545
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00384   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00461   (by error, pooled)
-
-frame 111: corr 0.999959  max abs 0.5312
-    action                   corr 0.999960  max abs   0.0195  mean abs 0.01176   (by error, pooled)
-    desire_pred              corr 0.999920  max abs   0.0840  mean abs 0.03464
-    desire_state             corr 0.999993  max abs   0.2812  mean abs 0.11523   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2031  mean abs 0.01398
-    lane_lines               corr 0.999968  max abs   0.1172  mean abs 0.01418
-    lane_lines_prob          corr 0.999807  max abs   0.1562  mean abs 0.05011   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.5312  mean abs 0.03607
-    lead_prob                corr 0.999997  max abs   0.1406  mean abs 0.12394   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.0845  mean abs 0.03692
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1094  mean abs 0.00736
-    pose                     corr 0.999982  max abs   0.0488  mean abs 0.01071   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.1064  mean abs 0.01599
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00743   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01372   (by error, pooled)
-
-frame 112: corr 0.999948  max abs 0.6094
-    action                   corr 0.999985  max abs   0.0215  mean abs 0.01196   (by error, pooled)
-    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03555
-    desire_state             corr 0.999985  max abs   0.2812  mean abs 0.10107   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1875  mean abs 0.01316
-    lane_lines               corr 0.999961  max abs   0.1016  mean abs 0.01541
-    lane_lines_prob          corr 0.999942  max abs   0.1289  mean abs 0.05780   (by error, pooled)
-    lead                     corr 0.999869  max abs   0.6094  mean abs 0.04577
-    lead_prob                corr 0.999958  max abs   0.1523  mean abs 0.13216   (by error, pooled)
-    meta                     corr 0.999923  max abs   0.0830  mean abs 0.03416
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999989  max abs   0.1406  mean abs 0.00782
-    pose                     corr 0.999979  max abs   0.0488  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999963  max abs   0.1367  mean abs 0.01753
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01037   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0273  mean abs 0.01014   (by error, pooled)
-
-frame 113: corr 0.999945  max abs 0.3906
-    action                   corr 0.999976  max abs   0.0215  mean abs 0.01273   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0742  mean abs 0.02438
-    desire_state             corr 0.999966  max abs   0.3906  mean abs 0.18146   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2207  mean abs 0.01415
-    lane_lines               corr 0.999949  max abs   0.0703  mean abs 0.01507
-    lane_lines_prob          corr 0.999955  max abs   0.1836  mean abs 0.08813   (by error, pooled)
-    lead                     corr 0.999950  max abs   0.3594  mean abs 0.03518
-    lead_prob                corr 0.999997  max abs   0.1204  mean abs 0.10881   (by error, pooled)
-    meta                     corr 0.999959  max abs   0.0859  mean abs 0.02720
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999968  max abs   0.2500  mean abs 0.01138
-    pose                     corr 0.999973  max abs   0.0742  mean abs 0.01349   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0732  mean abs 0.01426
-    road_transform           corr 0.999997  max abs   0.0469  mean abs 0.01157   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0352  mean abs 0.00819   (by error, pooled)
-
-frame 114: corr 0.999977  max abs 0.2500
-    action                   corr 0.999948  max abs   0.0137  mean abs 0.00829   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0723  mean abs 0.02789
-    desire_state             corr 0.999999  max abs   0.0938  mean abs 0.04590   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.2266  mean abs 0.01504
-    lane_lines               corr 0.999955  max abs   0.0742  mean abs 0.01699
-    lane_lines_prob          corr 0.999911  max abs   0.1016  mean abs 0.04504   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02027
-    lead_prob                corr 1.000000  max abs   0.0273  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999923  max abs   0.0771  mean abs 0.02855
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1250  mean abs 0.00655
-    pose                     corr 0.999997  max abs   0.0391  mean abs 0.01290   (by error, pooled)
-    road_edges               corr 0.999938  max abs   0.1055  mean abs 0.02351
-    road_transform           corr 0.999994  max abs   0.0391  mean abs 0.01192   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0312  mean abs 0.01053   (by error, pooled)
-
-frame 115: corr 0.999975  max abs 0.1973
-    action                   corr 0.999970  max abs   0.0099  mean abs 0.00616   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0703  mean abs 0.02835
-    desire_state             corr 0.999996  max abs   0.1875  mean abs 0.05118   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1973  mean abs 0.01474
-    lane_lines               corr 0.999930  max abs   0.0828  mean abs 0.01965
-    lane_lines_prob          corr 0.999954  max abs   0.1484  mean abs 0.05995   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1875  mean abs 0.02071
-    lead_prob                corr 1.000000  max abs   0.0078  mean abs 0.00602   (by error, pooled)
-    meta                     corr 0.999873  max abs   0.0957  mean abs 0.04756
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1406  mean abs 0.00567
-    pose                     corr 0.999997  max abs   0.0312  mean abs 0.01022   (by error, pooled)
-    road_edges               corr 0.999918  max abs   0.0801  mean abs 0.02640
-    road_transform           corr 0.999991  max abs   0.0430  mean abs 0.01060   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00495   (by error, pooled)
-
-frame 116: corr 0.999961  max abs 0.2969
-    action                   corr 0.999985  max abs   0.0215  mean abs 0.01168   (by error, pooled)
-    desire_pred              corr 0.999968  max abs   0.0664  mean abs 0.02393
-    desire_state             corr 0.999998  max abs   0.1094  mean abs 0.04852   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2087  mean abs 0.01298
-    lane_lines               corr 0.999968  max abs   0.0566  mean abs 0.01403
-    lane_lines_prob          corr 0.999986  max abs   0.0347  mean abs 0.01764   (by error, pooled)
-    lead                     corr 0.999980  max abs   0.2969  mean abs 0.02488
-    lead_prob                corr 0.999984  max abs   0.1191  mean abs 0.10319   (by error, pooled)
-    meta                     corr 0.999928  max abs   0.0771  mean abs 0.02890
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00775
-    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00745   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0508  mean abs 0.01542
-    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00904   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00690   (by error, pooled)
-
-frame 117: corr 0.999954  max abs 0.3789
-    action                   corr 0.999992  max abs   0.0166  mean abs 0.00689   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0645  mean abs 0.02583
-    desire_state             corr 0.999997  max abs   0.1445  mean abs 0.05884   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1064  mean abs 0.01166
-    lane_lines               corr 0.999947  max abs   0.0957  mean abs 0.01594
-    lane_lines_prob          corr 0.999974  max abs   0.0898  mean abs 0.03943   (by error, pooled)
-    lead                     corr 0.999884  max abs   0.3789  mean abs 0.02770
-    lead_prob                corr 0.999992  max abs   0.1133  mean abs 0.09017   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0957  mean abs 0.03598
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00442
-    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00573   (by error, pooled)
-    road_edges               corr 0.999919  max abs   0.1562  mean abs 0.02071
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00465   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00556   (by error, pooled)
-
-frame 118: corr 0.999960  max abs 0.2109
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00535   (by error, pooled)
-    desire_pred              corr 0.999964  max abs   0.0527  mean abs 0.02887
-    desire_state             corr 0.999994  max abs   0.1719  mean abs 0.07617   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1348  mean abs 0.01152
-    lane_lines               corr 0.999978  max abs   0.0469  mean abs 0.01234
-    lane_lines_prob          corr 0.999978  max abs   0.1016  mean abs 0.04746   (by error, pooled)
-    lead                     corr 0.999812  max abs   0.2109  mean abs 0.02105
-    lead_prob                corr 1.000000  max abs   0.0488  mean abs 0.03874   (by error, pooled)
-    meta                     corr 0.999942  max abs   0.0977  mean abs 0.03279
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00391
-    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00621   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0586  mean abs 0.01422
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00684   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0195  mean abs 0.00588   (by error, pooled)
-
-frame 119: corr 0.999951  max abs 0.4375
-    action                   corr 0.999996  max abs   0.0098  mean abs 0.00417   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0938  mean abs 0.03431
-    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1328  mean abs 0.01282
-    lane_lines               corr 0.999970  max abs   0.0703  mean abs 0.01402
-    lane_lines_prob          corr 0.999878  max abs   0.1172  mean abs 0.05511   (by error, pooled)
-    lead                     corr 0.999853  max abs   0.4375  mean abs 0.03405
-    lead_prob                corr 0.999991  max abs   0.0811  mean abs 0.06934   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0942  mean abs 0.02893
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00401
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00472   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.0898  mean abs 0.01303
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00474   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00657   (by error, pooled)
-
-frame 120: corr 0.999960  max abs 0.4062
-    action                   corr 0.999989  max abs   0.0176  mean abs 0.00978   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0586  mean abs 0.02430
-    desire_state             corr 0.999991  max abs   0.4062  mean abs 0.12085   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.2031  mean abs 0.01419
-    lane_lines               corr 0.999974  max abs   0.0508  mean abs 0.01306
-    lane_lines_prob          corr 0.999733  max abs   0.1191  mean abs 0.06177   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.2031  mean abs 0.01690
-    lead_prob                corr 0.999973  max abs   0.1289  mean abs 0.10352   (by error, pooled)
-    meta                     corr 0.999857  max abs   0.1025  mean abs 0.03659
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00584
-    pose                     corr 0.999994  max abs   0.0225  mean abs 0.00426   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.1094  mean abs 0.01329
-    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00621   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0215  mean abs 0.00591   (by error, pooled)
-
-frame 121: corr 0.999962  max abs 0.2500
-    action                   corr 0.999990  max abs   0.0156  mean abs 0.00754   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0703  mean abs 0.02387
-    desire_state             corr 0.999997  max abs   0.1250  mean abs 0.07739   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1891  mean abs 0.01339
-    lane_lines               corr 0.999962  max abs   0.0781  mean abs 0.01564
-    lane_lines_prob          corr 0.999968  max abs   0.1016  mean abs 0.03210   (by error, pooled)
-    lead                     corr 0.999974  max abs   0.2500  mean abs 0.02315
-    lead_prob                corr 0.999928  max abs   0.1523  mean abs 0.11491   (by error, pooled)
-    meta                     corr 0.999944  max abs   0.0645  mean abs 0.02519
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0625  mean abs 0.00574
-    pose                     corr 0.999988  max abs   0.0312  mean abs 0.00842   (by error, pooled)
-    road_edges               corr 0.999974  max abs   0.0469  mean abs 0.01429
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00516   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00232   (by error, pooled)
-
-frame 122: corr 0.999948  max abs 0.2969
-    action                   corr 0.999968  max abs   0.0312  mean abs 0.01652   (by error, pooled)
-    desire_pred              corr 0.999927  max abs   0.0703  mean abs 0.03409
-    desire_state             corr 0.999990  max abs   0.1875  mean abs 0.08521   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01412
-    lane_lines               corr 0.999949  max abs   0.1113  mean abs 0.01569
-    lane_lines_prob          corr 0.999798  max abs   0.1562  mean abs 0.05511   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.2500  mean abs 0.03205
-    lead_prob                corr 1.000000  max abs   0.1250  mean abs 0.10596   (by error, pooled)
-    meta                     corr 0.999950  max abs   0.0674  mean abs 0.02443
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999974  max abs   0.2969  mean abs 0.01309
-    pose                     corr 0.999968  max abs   0.0723  mean abs 0.01480   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0664  mean abs 0.01521
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00962   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.01079   (by error, pooled)
-
-frame 123: corr 0.999976  max abs 0.2344
-    action                   corr 0.999952  max abs   0.0132  mean abs 0.00711   (by error, pooled)
-    desire_pred              corr 0.999922  max abs   0.0938  mean abs 0.03134
-    desire_state             corr 0.999997  max abs   0.2344  mean abs 0.12500   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2227  mean abs 0.01535
-    lane_lines               corr 0.999956  max abs   0.1992  mean abs 0.01691
-    lane_lines_prob          corr 0.999977  max abs   0.0742  mean abs 0.03278   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.0938  mean abs 0.01147
-    lead_prob                corr 0.999993  max abs   0.0801  mean abs 0.06852   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0820  mean abs 0.02964
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0938  mean abs 0.00542
-    pose                     corr 0.999996  max abs   0.0391  mean abs 0.01335   (by error, pooled)
-    road_edges               corr 0.999917  max abs   0.1191  mean abs 0.02572
-    road_transform           corr 0.999998  max abs   0.0508  mean abs 0.01346   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0664  mean abs 0.01964   (by error, pooled)
-
-frame 124: corr 0.999980  max abs 0.4375
-    action                   corr 0.999969  max abs   0.0110  mean abs 0.00586   (by error, pooled)
-    desire_pred              corr 0.999933  max abs   0.0781  mean abs 0.02951
-    desire_state             corr 0.999995  max abs   0.2188  mean abs 0.07031   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1875  mean abs 0.01447
-    lane_lines               corr 0.999927  max abs   0.0819  mean abs 0.02048
-    lane_lines_prob          corr 0.999910  max abs   0.1133  mean abs 0.04207   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.4375  mean abs 0.03287
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06250   (by error, pooled)
-    meta                     corr 0.999785  max abs   0.1270  mean abs 0.05262
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00628
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01204   (by error, pooled)
-    road_edges               corr 0.999824  max abs   0.0977  mean abs 0.03520
-    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00906   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00298   (by error, pooled)
-
-frame 125: corr 0.999957  max abs 0.3438
-    action                   corr 0.999962  max abs   0.0244  mean abs 0.01410   (by error, pooled)
-    desire_pred              corr 0.999950  max abs   0.0586  mean abs 0.02645
-    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.09778   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2255  mean abs 0.01294
-    lane_lines               corr 0.999959  max abs   0.0918  mean abs 0.01333
-    lane_lines_prob          corr 0.999903  max abs   0.0923  mean abs 0.05426   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03918
-    lead_prob                corr 0.999986  max abs   0.2031  mean abs 0.16895   (by error, pooled)
-    meta                     corr 0.999932  max abs   0.0703  mean abs 0.03028
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999988  max abs   0.1953  mean abs 0.01131
-    pose                     corr 0.999985  max abs   0.0342  mean abs 0.01261   (by error, pooled)
-    road_edges               corr 0.999922  max abs   0.0938  mean abs 0.02053
-    road_transform           corr 1.000000  max abs   0.0117  mean abs 0.00393   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.00853   (by error, pooled)
-
-frame 126: corr 0.999960  max abs 0.2578
-    action                   corr 0.999991  max abs   0.0156  mean abs 0.00438   (by error, pooled)
-    desire_pred              corr 0.999962  max abs   0.0547  mean abs 0.02731
-    desire_state             corr 0.999994  max abs   0.2188  mean abs 0.07812   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1113  mean abs 0.01155
-    lane_lines               corr 0.999968  max abs   0.0684  mean abs 0.01624
-    lane_lines_prob          corr 0.999971  max abs   0.1133  mean abs 0.04700   (by error, pooled)
-    lead                     corr 0.999937  max abs   0.2578  mean abs 0.02101
-    lead_prob                corr 0.999975  max abs   0.1094  mean abs 0.07161   (by error, pooled)
-    meta                     corr 0.999894  max abs   0.1211  mean abs 0.04689
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00547
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00515   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.1035  mean abs 0.01622
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00253   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0195  mean abs 0.00555   (by error, pooled)
-
-frame 127: corr 0.999965  max abs 0.1562
-    action                   corr 0.999996  max abs   0.0098  mean abs 0.00293   (by error, pooled)
-    desire_pred              corr 0.999952  max abs   0.0625  mean abs 0.03529
-    desire_state             corr 0.999996  max abs   0.1562  mean abs 0.06836   (by error, pooled)
-    hidden_state             corr 0.999957  max abs   0.1289  mean abs 0.01113
-    lane_lines               corr 0.999977  max abs   0.0527  mean abs 0.01463
-    lane_lines_prob          corr 0.999979  max abs   0.1328  mean abs 0.07121   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.0410  mean abs 0.00503
-    lead_prob                corr 1.000000  max abs   0.0938  mean abs 0.08236   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.1123  mean abs 0.03691
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00458
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00642   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0801  mean abs 0.01637
-    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00351   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00623   (by error, pooled)
-
-pooled over 128 frames, per slice and per column:
-    action                   corr 0.999979  by error, max abs 0.04883 <= 0.5352     max abs   0.0488  mean abs 0.00918
-    desire_pred              corr 0.999945  (compared whole)                        max abs   0.1211  mean abs 0.02895
-    desire_state             corr 0.999975  by error, max abs 0.4531 <= 5.253       max abs   0.4531  mean abs 0.08140
-    hidden_state             corr 0.999949  (compared whole)                        max abs   0.3125  mean abs 0.01328
-    lane_lines               corr 0.999954  worst col 0.999855 mu[1]                    max abs   0.2227  mean abs 0.01569
-    lane_lines_prob          corr 0.999883  by error, max abs 0.25 <= 0.7902        max abs   0.2500  mean abs 0.04763
-    lead                     corr 0.999978  worst col 0.999952 mu[0]    (4 by error)    max abs   1.9375  mean abs 0.03572
-    lead_prob                corr 0.999930  by error, max abs 0.2383 <= 0.9055      max abs   0.2383  mean abs 0.07485
-    meta                     corr 0.999907  (compared whole)                        max abs   0.1426  mean abs 0.03486
-    pad                      corr 1.000000  by error, max abs 0 <= 0                max abs   0.0000  mean abs 0.00000
-    plan                     corr 0.999987  worst col 0.999864 std[5]   (10 by error)   max abs   0.5625  mean abs 0.00823
-    pose                     corr 0.999988  no column correlated        (12 by error)   max abs   0.1484  mean abs 0.01025
-    road_edges               corr 0.999947  worst col 0.999837 mu[1]                    max abs   0.1812  mean abs 0.01831
-    road_transform           corr 0.999995  no column correlated        (12 by error)   max abs   0.0586  mean abs 0.00786
-    wide_from_device_euler   corr 0.999993  no column correlated        (6 by error)    max abs   0.0664  mean abs 0.00767
-
-OK: every slice and every column at or above corr 0.999, or within 10% of its largest value where too small or too quiet to correlate, per frame and pooled over all 128 frames
diff --git a/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt b/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
deleted file mode 100644
index 4f1c806c..00000000
--- a/docs/evidence/sm8750-causal-prefill/accuracy-preheat.txt
+++ /dev/null
@@ -1,2195 +0,0 @@
-
-frame 0: corr 0.999958  max abs 0.5625
-    action                   corr 0.999995  max abs   0.0254  mean abs 0.00935   (by error, pooled)
-    desire_pred              corr 0.999935  max abs   0.0742  mean abs 0.03164
-    desire_state             corr 0.999999  max abs   0.0352  mean abs 0.01514   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1760  mean abs 0.01292
-    lane_lines               corr 0.999849  max abs   0.1744  mean abs 0.02085
-    lane_lines_prob          corr 0.999929  max abs   0.0820  mean abs 0.03079   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.5625  mean abs 0.06143
-    lead_prob                corr 0.999970  max abs   0.0259  mean abs 0.01986   (by error, pooled)
-    meta                     corr 0.999946  max abs   0.0781  mean abs 0.03238
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.3125  mean abs 0.00838
-    pose                     corr 0.999991  max abs   0.0263  mean abs 0.00968   (by error, pooled)
-    road_edges               corr 0.999897  max abs   0.1812  mean abs 0.02426
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00774   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00722   (by error, pooled)
-
-frame 1: corr 0.999965  max abs 0.5625
-    action                   corr 0.999995  max abs   0.0195  mean abs 0.00592   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0586  mean abs 0.02458
-    desire_state             corr 0.999998  max abs   0.0703  mean abs 0.02783   (by error, pooled)
-    hidden_state             corr 0.999959  max abs   0.1367  mean abs 0.01146
-    lane_lines               corr 0.999973  max abs   0.0723  mean abs 0.01279
-    lane_lines_prob          corr 0.999843  max abs   0.1172  mean abs 0.04391   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.05298
-    lead_prob                corr 0.999970  max abs   0.0149  mean abs 0.01196   (by error, pooled)
-    meta                     corr 0.999965  max abs   0.0723  mean abs 0.03016
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.3125  mean abs 0.00710
-    pose                     corr 0.999990  max abs   0.0325  mean abs 0.00972   (by error, pooled)
-    road_edges               corr 0.999977  max abs   0.0586  mean abs 0.01384
-    road_transform           corr 0.999988  max abs   0.0508  mean abs 0.00994   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00493   (by error, pooled)
-
-frame 2: corr 0.999959  max abs 0.6250
-    action                   corr 0.999999  max abs   0.0078  mean abs 0.00211   (by error, pooled)
-    desire_pred              corr 0.999968  max abs   0.0605  mean abs 0.02356
-    desire_state             corr 0.999993  max abs   0.1016  mean abs 0.03271   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1260  mean abs 0.01132
-    lane_lines               corr 0.999958  max abs   0.0918  mean abs 0.01606
-    lane_lines_prob          corr 0.999901  max abs   0.1445  mean abs 0.05713   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.6250  mean abs 0.06016
-    lead_prob                corr 0.999952  max abs   0.0151  mean abs 0.00798   (by error, pooled)
-    meta                     corr 0.999933  max abs   0.0742  mean abs 0.03206
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.2812  mean abs 0.00562
-    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00661   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0664  mean abs 0.01870
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00669   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00395   (by error, pooled)
-
-frame 3: corr 0.999948  max abs 0.9375
-    action                   corr 0.999999  max abs   0.0137  mean abs 0.00553   (by error, pooled)
-    desire_pred              corr 0.999983  max abs   0.0430  mean abs 0.01556
-    desire_state             corr 0.999982  max abs   0.1562  mean abs 0.04858   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1719  mean abs 0.01187
-    lane_lines               corr 0.999931  max abs   0.1543  mean abs 0.01625
-    lane_lines_prob          corr 0.999935  max abs   0.1602  mean abs 0.07416   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.9375  mean abs 0.09328
-    lead_prob                corr 0.999958  max abs   0.0251  mean abs 0.01619   (by error, pooled)
-    meta                     corr 0.999968  max abs   0.0586  mean abs 0.02109
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999990  max abs   0.3750  mean abs 0.00852
-    pose                     corr 0.999984  max abs   0.0356  mean abs 0.01209   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1445  mean abs 0.01664
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00841   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0293  mean abs 0.00949   (by error, pooled)
-
-frame 4: corr 0.999936  max abs 1.1250
-    action                   corr 0.999990  max abs   0.0293  mean abs 0.01129   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0889  mean abs 0.02840
-    desire_state             corr 0.999994  max abs   0.0781  mean abs 0.02625   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01377
-    lane_lines               corr 0.999962  max abs   0.1016  mean abs 0.01430
-    lane_lines_prob          corr 0.999939  max abs   0.0781  mean abs 0.03470   (by error, pooled)
-    lead                     corr 0.999992  max abs   1.1250  mean abs 0.12237
-    lead_prob                corr 0.998717  max abs   0.0957  mean abs 0.06934   (by error, pooled)
-    meta                     corr 0.999845  max abs   0.1270  mean abs 0.04110
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2500  mean abs 0.00861
-    pose                     corr 0.999979  max abs   0.0527  mean abs 0.01070   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.0781  mean abs 0.01325
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01077   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01534   (by error, pooled)
-
-frame 5: corr 0.999922  max abs 1.2500
-    action                   corr 0.999986  max abs   0.0352  mean abs 0.01266   (by error, pooled)
-    desire_pred              corr 0.999942  max abs   0.0859  mean abs 0.02830
-    desire_state             corr 0.999986  max abs   0.0938  mean abs 0.04843   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1680  mean abs 0.01347
-    lane_lines               corr 0.999954  max abs   0.1211  mean abs 0.01651
-    lane_lines_prob          corr 0.999963  max abs   0.1445  mean abs 0.06146   (by error, pooled)
-    lead                     corr 0.999991  max abs   1.2500  mean abs 0.14001
-    lead_prob                corr 0.998733  max abs   0.0557  mean abs 0.04069   (by error, pooled)
-    meta                     corr 0.999961  max abs   0.0762  mean abs 0.02302
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2188  mean abs 0.00735
-    pose                     corr 0.999984  max abs   0.0352  mean abs 0.01015   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.0703  mean abs 0.02004
-    road_transform           corr 0.999994  max abs   0.0430  mean abs 0.01166   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0254  mean abs 0.00882   (by error, pooled)
-
-frame 6: corr 0.999956  max abs 1.9375
-    action                   corr 0.999984  max abs   0.0303  mean abs 0.01663   (by error, pooled)
-    desire_pred              corr 0.999923  max abs   0.0723  mean abs 0.03256
-    desire_state             corr 0.999981  max abs   0.1797  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999937  max abs   0.2617  mean abs 0.01539
-    lane_lines               corr 0.999922  max abs   0.1406  mean abs 0.01865
-    lane_lines_prob          corr 0.999917  max abs   0.1484  mean abs 0.04865   (by error, pooled)
-    lead                     corr 0.999999  max abs   1.9375  mean abs 0.20451
-    lead_prob                corr 1.000000  max abs   0.0293  mean abs 0.02539   (by error, pooled)
-    meta                     corr 0.999912  max abs   0.0898  mean abs 0.03182
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.5625  mean abs 0.01942
-    pose                     corr 0.999977  max abs   0.1484  mean abs 0.02388   (by error, pooled)
-    road_edges               corr 0.999917  max abs   0.1367  mean abs 0.02554
-    road_transform           corr 0.999996  max abs   0.0547  mean abs 0.01525   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0469  mean abs 0.01279   (by error, pooled)
-
-frame 7: corr 0.999989  max abs 0.3750
-    action                   corr 0.999992  max abs   0.0117  mean abs 0.00634   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0645  mean abs 0.02985
-    desire_state             corr 0.999963  max abs   0.2266  mean abs 0.08472   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2041  mean abs 0.01477
-    lane_lines               corr 0.999930  max abs   0.0663  mean abs 0.01972
-    lane_lines_prob          corr 0.999946  max abs   0.1445  mean abs 0.05638   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.3750  mean abs 0.03846
-    lead_prob                corr 0.998477  max abs   0.0254  mean abs 0.01107   (by error, pooled)
-    meta                     corr 0.999903  max abs   0.0898  mean abs 0.03162
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.1875  mean abs 0.00468
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.01124   (by error, pooled)
-    road_edges               corr 0.999918  max abs   0.0898  mean abs 0.02571
-    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00873   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00268   (by error, pooled)
-
-frame 8: corr 0.999981  max abs 0.5625
-    action                   corr 0.999987  max abs   0.0225  mean abs 0.00929   (by error, pooled)
-    desire_pred              corr 0.999943  max abs   0.0762  mean abs 0.02660
-    desire_state             corr 0.999995  max abs   0.0938  mean abs 0.04443   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2560  mean abs 0.01368
-    lane_lines               corr 0.999960  max abs   0.0439  mean abs 0.01421
-    lane_lines_prob          corr 0.999889  max abs   0.1523  mean abs 0.04752   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06036
-    lead_prob                corr 0.999987  max abs   0.0576  mean abs 0.05111   (by error, pooled)
-    meta                     corr 0.999894  max abs   0.0879  mean abs 0.03913
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0625  mean abs 0.00604
-    pose                     corr 0.999994  max abs   0.0273  mean abs 0.00865   (by error, pooled)
-    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02148
-    road_transform           corr 0.999996  max abs   0.0469  mean abs 0.01174   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0625  mean abs 0.01505   (by error, pooled)
-
-frame 9: corr 0.999973  max abs 0.5625
-    action                   corr 0.999999  max abs   0.0195  mean abs 0.00897   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0586  mean abs 0.02765
-    desire_state             corr 0.999996  max abs   0.1094  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1299  mean abs 0.01198
-    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01406
-    lane_lines_prob          corr 0.999991  max abs   0.0703  mean abs 0.03381   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5625  mean abs 0.06239
-    lead_prob                corr 0.999959  max abs   0.0474  mean abs 0.03698   (by error, pooled)
-    meta                     corr 0.999940  max abs   0.0859  mean abs 0.03474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.3750  mean abs 0.00992
-    pose                     corr 0.999994  max abs   0.0220  mean abs 0.00801   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0938  mean abs 0.01654
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00441   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0156  mean abs 0.00653   (by error, pooled)
-
-frame 10: corr 0.999978  max abs 0.2500
-    action                   corr 1.000000  max abs   0.0117  mean abs 0.00580   (by error, pooled)
-    desire_pred              corr 0.999956  max abs   0.0601  mean abs 0.03251
-    desire_state             corr 0.999998  max abs   0.0508  mean abs 0.03198   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.0996  mean abs 0.01128
-    lane_lines               corr 0.999972  max abs   0.0586  mean abs 0.01554
-    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03271   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.2500  mean abs 0.02018
-    lead_prob                corr 0.999886  max abs   0.0420  mean abs 0.03019   (by error, pooled)
-    meta                     corr 0.999935  max abs   0.1050  mean abs 0.03611
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00385
-    pose                     corr 0.999996  max abs   0.0172  mean abs 0.00643   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0586  mean abs 0.01438
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00417   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00426   (by error, pooled)
-
-frame 11: corr 0.999976  max abs 0.2500
-    action                   corr 1.000000  max abs   0.0020  mean abs 0.00052   (by error, pooled)
-    desire_pred              corr 0.999966  max abs   0.0625  mean abs 0.02907
-    desire_state             corr 0.999999  max abs   0.0625  mean abs 0.03687   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1348  mean abs 0.01212
-    lane_lines               corr 0.999965  max abs   0.0859  mean abs 0.01512
-    lane_lines_prob          corr 0.999983  max abs   0.0547  mean abs 0.03186   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.2500  mean abs 0.02342
-    lead_prob                corr 0.999887  max abs   0.0355  mean abs 0.02243   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0869  mean abs 0.03073
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00297
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00640   (by error, pooled)
-    road_edges               corr 0.999965  max abs   0.0801  mean abs 0.01600
-    road_transform           corr 0.999994  max abs   0.0273  mean abs 0.00709   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00430   (by error, pooled)
-
-frame 12: corr 0.999975  max abs 0.4375
-    action                   corr 0.999999  max abs   0.0098  mean abs 0.00491   (by error, pooled)
-    desire_pred              corr 0.999981  max abs   0.0625  mean abs 0.02130
-    desire_state             corr 0.999993  max abs   0.1406  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1543  mean abs 0.01343
-    lane_lines               corr 0.999969  max abs   0.1172  mean abs 0.01423
-    lane_lines_prob          corr 0.999945  max abs   0.0820  mean abs 0.03003   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.4375  mean abs 0.04305
-    lead_prob                corr 0.999977  max abs   0.0791  mean abs 0.06405   (by error, pooled)
-    meta                     corr 0.999881  max abs   0.0850  mean abs 0.03032
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00616
-    pose                     corr 0.999994  max abs   0.0239  mean abs 0.00555   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.1094  mean abs 0.01357
-    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00775   (by error, pooled)
-    wide_from_device_euler   corr 0.999986  max abs   0.0410  mean abs 0.00981   (by error, pooled)
-
-frame 13: corr 0.999963  max abs 0.7500
-    action                   corr 0.999979  max abs   0.0293  mean abs 0.01082   (by error, pooled)
-    desire_pred              corr 0.999881  max abs   0.0918  mean abs 0.04098
-    desire_state             corr 0.999992  max abs   0.1328  mean abs 0.06201   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2285  mean abs 0.01348
-    lane_lines               corr 0.999945  max abs   0.1289  mean abs 0.01795
-    lane_lines_prob          corr 0.999691  max abs   0.1641  mean abs 0.06439   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.7500  mean abs 0.06569
-    lead_prob                corr 0.999548  max abs   0.0918  mean abs 0.07259   (by error, pooled)
-    meta                     corr 0.999852  max abs   0.0889  mean abs 0.03951
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999985  max abs   0.3750  mean abs 0.01534
-    pose                     corr 0.999964  max abs   0.0781  mean abs 0.01469   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.1172  mean abs 0.01816
-    road_transform           corr 0.999999  max abs   0.0391  mean abs 0.01190   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.01145   (by error, pooled)
-
-frame 14: corr 0.999945  max abs 0.9375
-    action                   corr 0.999982  max abs   0.0391  mean abs 0.01599   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03196
-    desire_state             corr 0.999988  max abs   0.2031  mean abs 0.09033   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2109  mean abs 0.01363
-    lane_lines               corr 0.999974  max abs   0.0859  mean abs 0.01198
-    lane_lines_prob          corr 0.999923  max abs   0.1289  mean abs 0.04303   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.9375  mean abs 0.08604
-    lead_prob                corr 0.998518  max abs   0.0938  mean abs 0.07617   (by error, pooled)
-    meta                     corr 0.999948  max abs   0.0625  mean abs 0.02685
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999971  max abs   0.5000  mean abs 0.01917
-    pose                     corr 0.999960  max abs   0.0742  mean abs 0.01417   (by error, pooled)
-    road_edges               corr 0.999941  max abs   0.0781  mean abs 0.01981
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00857   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0312  mean abs 0.00654   (by error, pooled)
-
-frame 15: corr 0.999964  max abs 1.2500
-    action                   corr 0.999983  max abs   0.0176  mean abs 0.00940   (by error, pooled)
-    desire_pred              corr 0.999929  max abs   0.0625  mean abs 0.03351
-    desire_state             corr 0.999991  max abs   0.1641  mean abs 0.10449   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2324  mean abs 0.01531
-    lane_lines               corr 0.999947  max abs   0.1406  mean abs 0.01695
-    lane_lines_prob          corr 0.999976  max abs   0.1367  mean abs 0.06481   (by error, pooled)
-    lead                     corr 0.999999  max abs   1.2500  mean abs 0.12303
-    lead_prob                corr 0.999926  max abs   0.0635  mean abs 0.05813   (by error, pooled)
-    meta                     corr 0.999902  max abs   0.0928  mean abs 0.03267
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2188  mean abs 0.01202
-    pose                     corr 0.999990  max abs   0.1172  mean abs 0.01868   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.1094  mean abs 0.01495
-    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.01289   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0391  mean abs 0.01213   (by error, pooled)
-
-frame 16: corr 0.999982  max abs 0.6250
-    action                   corr 0.999956  max abs   0.0127  mean abs 0.00645   (by error, pooled)
-    desire_pred              corr 0.999934  max abs   0.0723  mean abs 0.03220
-    desire_state             corr 0.999984  max abs   0.1367  mean abs 0.06238   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2305  mean abs 0.01469
-    lane_lines               corr 0.999920  max abs   0.0703  mean abs 0.02025
-    lane_lines_prob          corr 0.999967  max abs   0.1289  mean abs 0.04867   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.6250  mean abs 0.04697
-    lead_prob                corr 0.999966  max abs   0.0566  mean abs 0.03809   (by error, pooled)
-    meta                     corr 0.999876  max abs   0.0957  mean abs 0.03783
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.1250  mean abs 0.00539
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01058   (by error, pooled)
-    road_edges               corr 0.999919  max abs   0.0859  mean abs 0.02313
-    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00425   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00884   (by error, pooled)
-
-frame 17: corr 0.999974  max abs 0.3438
-    action                   corr 0.999987  max abs   0.0176  mean abs 0.00995   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0730  mean abs 0.02846
-    desire_state             corr 0.999996  max abs   0.0781  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2465  mean abs 0.01365
-    lane_lines               corr 0.999956  max abs   0.0781  mean abs 0.01486
-    lane_lines_prob          corr 0.999933  max abs   0.0977  mean abs 0.03257   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01697
-    lead_prob                corr 0.999995  max abs   0.0449  mean abs 0.03735   (by error, pooled)
-    meta                     corr 0.999928  max abs   0.0703  mean abs 0.02939
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999986  max abs   0.3438  mean abs 0.01366
-    pose                     corr 0.999992  max abs   0.0273  mean abs 0.01085   (by error, pooled)
-    road_edges               corr 0.999927  max abs   0.0664  mean abs 0.02052
-    road_transform           corr 0.999998  max abs   0.0469  mean abs 0.01369   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0430  mean abs 0.01115   (by error, pooled)
-
-frame 18: corr 0.999965  max abs 0.5000
-    action                   corr 0.999996  max abs   0.0215  mean abs 0.00996   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0859  mean abs 0.02974
-    desire_state             corr 0.999984  max abs   0.1562  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1289  mean abs 0.01180
-    lane_lines               corr 0.999970  max abs   0.0488  mean abs 0.01406
-    lane_lines_prob          corr 0.999973  max abs   0.0742  mean abs 0.02954   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.5000  mean abs 0.04836
-    lead_prob                corr 0.998951  max abs   0.0811  mean abs 0.06120   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0781  mean abs 0.03228
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.3125  mean abs 0.01052
-    pose                     corr 0.999993  max abs   0.0273  mean abs 0.00879   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0527  mean abs 0.01554
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00458   (by error, pooled)
-
-frame 19: corr 0.999975  max abs 0.1250
-    action                   corr 0.999999  max abs   0.0078  mean abs 0.00311   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0552  mean abs 0.03011
-    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.04626   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.0938  mean abs 0.01092
-    lane_lines               corr 0.999966  max abs   0.0752  mean abs 0.01557
-    lane_lines_prob          corr 0.999992  max abs   0.0586  mean abs 0.03101   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1250  mean abs 0.01557
-    lead_prob                corr 0.999727  max abs   0.0410  mean abs 0.03109   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.1123  mean abs 0.03805
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0781  mean abs 0.00426
-    pose                     corr 0.999996  max abs   0.0176  mean abs 0.00608   (by error, pooled)
-    road_edges               corr 0.999955  max abs   0.1152  mean abs 0.01849
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00466   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0195  mean abs 0.00459   (by error, pooled)
-
-frame 20: corr 0.999975  max abs 0.2812
-    action                   corr 0.999998  max abs   0.0098  mean abs 0.00377   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0547  mean abs 0.02860
-    desire_state             corr 0.999990  max abs   0.1484  mean abs 0.06494   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1543  mean abs 0.01206
-    lane_lines               corr 0.999976  max abs   0.0605  mean abs 0.01370
-    lane_lines_prob          corr 0.999979  max abs   0.0742  mean abs 0.03647   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2812  mean abs 0.02069
-    lead_prob                corr 0.999753  max abs   0.0480  mean abs 0.04075   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0811  mean abs 0.03298
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0410  mean abs 0.00367
-    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00504   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0820  mean abs 0.01513
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00507   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0273  mean abs 0.00690   (by error, pooled)
-
-frame 21: corr 0.999971  max abs 0.5625
-    action                   corr 0.999993  max abs   0.0176  mean abs 0.00978   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0518  mean abs 0.02562
-    desire_state             corr 0.999990  max abs   0.0703  mean abs 0.04370   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1807  mean abs 0.01358
-    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01265
-    lane_lines_prob          corr 0.999970  max abs   0.0513  mean abs 0.02728   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5625  mean abs 0.04740
-    lead_prob                corr 0.999391  max abs   0.1055  mean abs 0.08830   (by error, pooled)
-    meta                     corr 0.999906  max abs   0.0745  mean abs 0.02863
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.2500  mean abs 0.01053
-    pose                     corr 0.999985  max abs   0.0352  mean abs 0.01017   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.1050  mean abs 0.01557
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00575   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00983   (by error, pooled)
-
-frame 22: corr 0.999969  max abs 0.4268
-    action                   corr 0.999983  max abs   0.0195  mean abs 0.01143   (by error, pooled)
-    desire_pred              corr 0.999962  max abs   0.0459  mean abs 0.02286
-    desire_state             corr 0.999980  max abs   0.1250  mean abs 0.06152   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2227  mean abs 0.01495
-    lane_lines               corr 0.999953  max abs   0.1172  mean abs 0.01816
-    lane_lines_prob          corr 0.999918  max abs   0.0859  mean abs 0.04413   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1875  mean abs 0.02029
-    lead_prob                corr 0.999892  max abs   0.1221  mean abs 0.11019   (by error, pooled)
-    meta                     corr 0.999892  max abs   0.0825  mean abs 0.03034
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.4268  mean abs 0.01207
-    pose                     corr 0.999986  max abs   0.0625  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1484  mean abs 0.02380
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00580   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00493   (by error, pooled)
-
-frame 23: corr 0.999967  max abs 0.3125
-    action                   corr 0.999976  max abs   0.0293  mean abs 0.01263   (by error, pooled)
-    desire_pred              corr 0.999899  max abs   0.1211  mean abs 0.03755
-    desire_state             corr 0.999985  max abs   0.1211  mean abs 0.05103   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1680  mean abs 0.01385
-    lane_lines               corr 0.999970  max abs   0.0898  mean abs 0.01397
-    lane_lines_prob          corr 0.999913  max abs   0.1094  mean abs 0.03763   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.3125  mean abs 0.04054
-    lead_prob                corr 0.999069  max abs   0.0996  mean abs 0.08008   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0625  mean abs 0.02667
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1875  mean abs 0.01065
-    pose                     corr 0.999981  max abs   0.0430  mean abs 0.01038   (by error, pooled)
-    road_edges               corr 0.999970  max abs   0.0664  mean abs 0.01592
-    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.01101   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00721   (by error, pooled)
-
-frame 24: corr 0.999969  max abs 0.6875
-    action                   corr 0.999922  max abs   0.0151  mean abs 0.00975   (by error, pooled)
-    desire_pred              corr 0.999961  max abs   0.0625  mean abs 0.02347
-    desire_state             corr 0.999981  max abs   0.2344  mean abs 0.10645   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2109  mean abs 0.01523
-    lane_lines               corr 0.999950  max abs   0.1641  mean abs 0.01631
-    lane_lines_prob          corr 0.999966  max abs   0.1016  mean abs 0.05735   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.6875  mean abs 0.06699
-    lead_prob                corr 0.996577  max abs   0.0117  mean abs 0.00781   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0645  mean abs 0.02625
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.2188  mean abs 0.00971
-    pose                     corr 0.999992  max abs   0.0859  mean abs 0.01700   (by error, pooled)
-    road_edges               corr 0.999942  max abs   0.1230  mean abs 0.01850
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.01053   (by error, pooled)
-    wide_from_device_euler   corr 0.999989  max abs   0.0312  mean abs 0.01248   (by error, pooled)
-
-frame 25: corr 0.999982  max abs 0.2500
-    action                   corr 0.999981  max abs   0.0068  mean abs 0.00417   (by error, pooled)
-    desire_pred              corr 0.999944  max abs   0.0781  mean abs 0.02817
-    desire_state             corr 0.999991  max abs   0.0859  mean abs 0.05078   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2109  mean abs 0.01473
-    lane_lines               corr 0.999940  max abs   0.0820  mean abs 0.01846
-    lane_lines_prob          corr 0.999904  max abs   0.1289  mean abs 0.05077   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1875  mean abs 0.01383
-    lead_prob                corr 0.998654  max abs   0.0273  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999831  max abs   0.1279  mean abs 0.04345
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2500  mean abs 0.00592
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00996   (by error, pooled)
-    road_edges               corr 0.999938  max abs   0.0957  mean abs 0.02302
-    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.01206   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00624   (by error, pooled)
-
-frame 26: corr 0.999971  max abs 0.3379
-    action                   corr 0.999962  max abs   0.0234  mean abs 0.01273   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0762  mean abs 0.02478
-    desire_state             corr 0.999988  max abs   0.0781  mean abs 0.04614   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2463  mean abs 0.01360
-    lane_lines               corr 0.999934  max abs   0.1152  mean abs 0.01807
-    lane_lines_prob          corr 0.999944  max abs   0.1055  mean abs 0.03624   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.1172  mean abs 0.01570
-    lead_prob                corr 0.999976  max abs   0.0762  mean abs 0.07357   (by error, pooled)
-    meta                     corr 0.999915  max abs   0.0938  mean abs 0.03423
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.3379  mean abs 0.01435
-    pose                     corr 0.999992  max abs   0.0293  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999920  max abs   0.0957  mean abs 0.01895
-    road_transform           corr 0.999989  max abs   0.0586  mean abs 0.01320   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0508  mean abs 0.01084   (by error, pooled)
-
-frame 27: corr 0.999974  max abs 0.2344
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00674   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0840  mean abs 0.02877
-    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.12048   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1123  mean abs 0.01212
-    lane_lines               corr 0.999966  max abs   0.0664  mean abs 0.01772
-    lane_lines_prob          corr 0.999944  max abs   0.1211  mean abs 0.05255   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01196
-    lead_prob                corr 0.998386  max abs   0.1042  mean abs 0.08252   (by error, pooled)
-    meta                     corr 0.999922  max abs   0.0938  mean abs 0.03512
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1562  mean abs 0.00559
-    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00537   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0977  mean abs 0.01668
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00343   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0117  mean abs 0.00427   (by error, pooled)
-
-frame 28: corr 0.999975  max abs 0.3125
-    action                   corr 0.999993  max abs   0.0166  mean abs 0.00888   (by error, pooled)
-    desire_pred              corr 0.999975  max abs   0.0547  mean abs 0.02318
-    desire_state             corr 0.999988  max abs   0.1133  mean abs 0.07367   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1133  mean abs 0.01113
-    lane_lines               corr 0.999960  max abs   0.0977  mean abs 0.01409
-    lane_lines_prob          corr 0.999996  max abs   0.0430  mean abs 0.02063   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3125  mean abs 0.02101
-    lead_prob                corr 0.996397  max abs   0.0938  mean abs 0.07812   (by error, pooled)
-    meta                     corr 0.999967  max abs   0.0801  mean abs 0.02487
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1172  mean abs 0.00626
-    pose                     corr 0.999997  max abs   0.0166  mean abs 0.00535   (by error, pooled)
-    road_edges               corr 0.999956  max abs   0.1523  mean abs 0.01539
-    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.00521   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00262   (by error, pooled)
-
-frame 29: corr 0.999973  max abs 0.2188
-    action                   corr 0.999996  max abs   0.0127  mean abs 0.00696   (by error, pooled)
-    desire_pred              corr 0.999959  max abs   0.0586  mean abs 0.03296
-    desire_state             corr 0.999995  max abs   0.1562  mean abs 0.07239   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01184
-    lane_lines               corr 0.999973  max abs   0.0449  mean abs 0.01383
-    lane_lines_prob          corr 0.999993  max abs   0.1133  mean abs 0.07458   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2188  mean abs 0.01581
-    lead_prob                corr 0.993557  max abs   0.0977  mean abs 0.07812   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0840  mean abs 0.02687
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00604
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00598   (by error, pooled)
-    road_edges               corr 0.999954  max abs   0.1016  mean abs 0.01897
-    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00655   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00886   (by error, pooled)
-
-frame 30: corr 0.999970  max abs 0.2500
-    action                   corr 0.999992  max abs   0.0127  mean abs 0.00661   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02797
-    desire_state             corr 0.999989  max abs   0.1484  mean abs 0.08813   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1660  mean abs 0.01359
-    lane_lines               corr 0.999958  max abs   0.1328  mean abs 0.01609
-    lane_lines_prob          corr 0.999952  max abs   0.0869  mean abs 0.03772   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02438
-    lead_prob                corr 0.999354  max abs   0.1243  mean abs 0.10343   (by error, pooled)
-    meta                     corr 0.999791  max abs   0.1304  mean abs 0.04929
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00752
-    pose                     corr 0.999992  max abs   0.0234  mean abs 0.00691   (by error, pooled)
-    road_edges               corr 0.999963  max abs   0.1719  mean abs 0.01888
-    road_transform           corr 0.999992  max abs   0.0273  mean abs 0.00793   (by error, pooled)
-    wide_from_device_euler   corr 0.999985  max abs   0.0371  mean abs 0.00851   (by error, pooled)
-
-frame 31: corr 0.999970  max abs 0.2188
-    action                   corr 0.999980  max abs   0.0225  mean abs 0.01251   (by error, pooled)
-    desire_pred              corr 0.999933  max abs   0.0664  mean abs 0.02856
-    desire_state             corr 0.999975  max abs   0.1094  mean abs 0.07178   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.2129  mean abs 0.01353
-    lane_lines               corr 0.999958  max abs   0.0820  mean abs 0.01609
-    lane_lines_prob          corr 0.999901  max abs   0.1523  mean abs 0.05202   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.2188  mean abs 0.02764
-    lead_prob                corr 0.998387  max abs   0.1116  mean abs 0.09253   (by error, pooled)
-    meta                     corr 0.999832  max abs   0.1172  mean abs 0.04155
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1250  mean abs 0.00817
-    pose                     corr 0.999979  max abs   0.0547  mean abs 0.01210   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0940  mean abs 0.01712
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00768   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0273  mean abs 0.01210   (by error, pooled)
-
-frame 32: corr 0.999958  max abs 0.1445
-    action                   corr 0.999989  max abs   0.0215  mean abs 0.01032   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0742  mean abs 0.03190
-    desire_state             corr 0.999968  max abs   0.1250  mean abs 0.05859   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1445  mean abs 0.01330
-    lane_lines               corr 0.999972  max abs   0.0664  mean abs 0.01441
-    lane_lines_prob          corr 0.999905  max abs   0.1367  mean abs 0.09381   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.1094  mean abs 0.01503
-    lead_prob                corr 0.999998  max abs   0.0508  mean abs 0.03385   (by error, pooled)
-    meta                     corr 0.999972  max abs   0.0547  mean abs 0.02026
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1406  mean abs 0.00554
-    pose                     corr 0.999985  max abs   0.0352  mean abs 0.00878   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0547  mean abs 0.01838
-    road_transform           corr 0.999994  max abs   0.0234  mean abs 0.00694   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00592   (by error, pooled)
-
-frame 33: corr 0.999962  max abs 0.8750
-    action                   corr 0.999959  max abs   0.0176  mean abs 0.00947   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0703  mean abs 0.01862
-    desire_state             corr 0.999979  max abs   0.1562  mean abs 0.05762   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2500  mean abs 0.01529
-    lane_lines               corr 0.999955  max abs   0.1133  mean abs 0.01632
-    lane_lines_prob          corr 0.999931  max abs   0.1055  mean abs 0.04333   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.8750  mean abs 0.06872
-    lead_prob                corr 0.999956  max abs   0.0391  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999934  max abs   0.0752  mean abs 0.02529
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.2969  mean abs 0.01298
-    pose                     corr 0.999994  max abs   0.0625  mean abs 0.01658   (by error, pooled)
-    road_edges               corr 0.999960  max abs   0.1016  mean abs 0.01799
-    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00815   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01118   (by error, pooled)
-
-frame 34: corr 0.999979  max abs 0.1963
-    action                   corr 0.999977  max abs   0.0098  mean abs 0.00539   (by error, pooled)
-    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03787
-    desire_state             corr 0.999991  max abs   0.1133  mean abs 0.03394   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1963  mean abs 0.01470
-    lane_lines               corr 0.999939  max abs   0.0742  mean abs 0.01944
-    lane_lines_prob          corr 0.999938  max abs   0.1875  mean abs 0.07463   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01449
-    lead_prob                corr 0.999656  max abs   0.0391  mean abs 0.02604   (by error, pooled)
-    meta                     corr 0.999890  max abs   0.0820  mean abs 0.03731
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1875  mean abs 0.00495
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00991   (by error, pooled)
-    road_edges               corr 0.999935  max abs   0.0654  mean abs 0.02561
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00750   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00332   (by error, pooled)
-
-frame 35: corr 0.999960  max abs 0.3438
-    action                   corr 0.999962  max abs   0.0225  mean abs 0.01250   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0605  mean abs 0.02122
-    desire_state             corr 0.999907  max abs   0.2266  mean abs 0.08117   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2641  mean abs 0.01373
-    lane_lines               corr 0.999954  max abs   0.0684  mean abs 0.01481
-    lane_lines_prob          corr 0.999964  max abs   0.0586  mean abs 0.03961   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03551
-    lead_prob                corr 0.999775  max abs   0.1289  mean abs 0.11133   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.0820  mean abs 0.02702
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.2656  mean abs 0.01050
-    pose                     corr 0.999989  max abs   0.0430  mean abs 0.01239   (by error, pooled)
-    road_edges               corr 0.999960  max abs   0.0547  mean abs 0.01449
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00890   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0586  mean abs 0.01375   (by error, pooled)
-
-frame 36: corr 0.999964  max abs 0.1562
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00779   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.02402
-    desire_state             corr 0.999954  max abs   0.1445  mean abs 0.05359   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01207
-    lane_lines               corr 0.999970  max abs   0.0820  mean abs 0.01368
-    lane_lines_prob          corr 0.999960  max abs   0.0703  mean abs 0.02673   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.1406  mean abs 0.01257
-    lead_prob                corr 0.999999  max abs   0.1211  mean abs 0.10026   (by error, pooled)
-    meta                     corr 0.999919  max abs   0.1055  mean abs 0.03351
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1562  mean abs 0.00708
-    pose                     corr 0.999995  max abs   0.0229  mean abs 0.00659   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.1152  mean abs 0.01726
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00571   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00621   (by error, pooled)
-
-frame 37: corr 0.999957  max abs 0.3496
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00745   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0566  mean abs 0.02777
-    desire_state             corr 0.999970  max abs   0.1680  mean abs 0.06909   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1162  mean abs 0.01122
-    lane_lines               corr 0.999969  max abs   0.0703  mean abs 0.01477
-    lane_lines_prob          corr 0.999990  max abs   0.0977  mean abs 0.04390   (by error, pooled)
-    lead                     corr 0.999850  max abs   0.3496  mean abs 0.02815
-    lead_prob                corr 0.999963  max abs   0.0664  mean abs 0.05339   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.1074  mean abs 0.03950
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00420
-    pose                     corr 0.999995  max abs   0.0195  mean abs 0.00651   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0742  mean abs 0.01435
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00619   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00489   (by error, pooled)
-
-frame 38: corr 0.999958  max abs 0.2031
-    action                   corr 0.999996  max abs   0.0107  mean abs 0.00541   (by error, pooled)
-    desire_pred              corr 0.999972  max abs   0.0508  mean abs 0.02396
-    desire_state             corr 0.999985  max abs   0.1172  mean abs 0.05750   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1406  mean abs 0.01202
-    lane_lines               corr 0.999966  max abs   0.0898  mean abs 0.01373
-    lane_lines_prob          corr 0.999834  max abs   0.1016  mean abs 0.05020   (by error, pooled)
-    lead                     corr 0.999981  max abs   0.2031  mean abs 0.01509
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06576   (by error, pooled)
-    meta                     corr 0.999912  max abs   0.0977  mean abs 0.04185
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00351
-    pose                     corr 0.999999  max abs   0.0156  mean abs 0.00536   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0977  mean abs 0.01437
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00442   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00266   (by error, pooled)
-
-frame 39: corr 0.999960  max abs 0.6250
-    action                   corr 0.999991  max abs   0.0132  mean abs 0.00716   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.1094  mean abs 0.02056
-    desire_state             corr 0.999984  max abs   0.0996  mean abs 0.02930   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1465  mean abs 0.01390
-    lane_lines               corr 0.999971  max abs   0.0938  mean abs 0.01416
-    lane_lines_prob          corr 0.999846  max abs   0.1211  mean abs 0.04431   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.6250  mean abs 0.04044
-    lead_prob                corr 0.999763  max abs   0.1094  mean abs 0.07975   (by error, pooled)
-    meta                     corr 0.999865  max abs   0.1030  mean abs 0.04137
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999999  max abs   0.0312  mean abs 0.00369
-    pose                     corr 0.999994  max abs   0.0186  mean abs 0.00503   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.1250  mean abs 0.01266
-    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00752   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0234  mean abs 0.00624   (by error, pooled)
-
-frame 40: corr 0.999953  max abs 0.3906
-    action                   corr 0.999974  max abs   0.0332  mean abs 0.01743   (by error, pooled)
-    desire_pred              corr 0.999906  max abs   0.0859  mean abs 0.03478
-    desire_state             corr 0.999907  max abs   0.3196  mean abs 0.13505   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2617  mean abs 0.01366
-    lane_lines               corr 0.999937  max abs   0.1445  mean abs 0.01839
-    lane_lines_prob          corr 0.999892  max abs   0.0820  mean abs 0.04476   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.1641  mean abs 0.01987
-    lead_prob                corr 0.999859  max abs   0.1113  mean abs 0.09342   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.0957  mean abs 0.04024
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999964  max abs   0.3906  mean abs 0.01614
-    pose                     corr 0.999949  max abs   0.0918  mean abs 0.01791   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.1250  mean abs 0.01758
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00533   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0156  mean abs 0.00559   (by error, pooled)
-
-frame 41: corr 0.999952  max abs 0.2649
-    action                   corr 0.999977  max abs   0.0273  mean abs 0.01492   (by error, pooled)
-    desire_pred              corr 0.999943  max abs   0.0664  mean abs 0.02870
-    desire_state             corr 0.999941  max abs   0.2649  mean abs 0.12741   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1953  mean abs 0.01348
-    lane_lines               corr 0.999967  max abs   0.0664  mean abs 0.01465
-    lane_lines_prob          corr 0.999892  max abs   0.1211  mean abs 0.05054   (by error, pooled)
-    lead                     corr 0.999983  max abs   0.2500  mean abs 0.01946
-    lead_prob                corr 0.999977  max abs   0.0664  mean abs 0.05632   (by error, pooled)
-    meta                     corr 0.999961  max abs   0.0586  mean abs 0.02646
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999978  max abs   0.2188  mean abs 0.01064
-    pose                     corr 0.999968  max abs   0.0664  mean abs 0.01268   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0664  mean abs 0.01754
-    road_transform           corr 0.999993  max abs   0.0586  mean abs 0.01044   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00557   (by error, pooled)
-
-frame 42: corr 0.999964  max abs 1.0000
-    action                   corr 0.999953  max abs   0.0176  mean abs 0.00957   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0742  mean abs 0.02237
-    desire_state             corr 0.999991  max abs   0.1719  mean abs 0.06738   (by error, pooled)
-    hidden_state             corr 0.999939  max abs   0.2227  mean abs 0.01551
-    lane_lines               corr 0.999949  max abs   0.1641  mean abs 0.01721
-    lane_lines_prob          corr 0.999959  max abs   0.0938  mean abs 0.05408   (by error, pooled)
-    lead                     corr 0.999998  max abs   1.0000  mean abs 0.08374
-    lead_prob                corr 0.999980  max abs   0.0469  mean abs 0.03320   (by error, pooled)
-    meta                     corr 0.999960  max abs   0.0586  mean abs 0.02051
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999990  max abs   0.3750  mean abs 0.01489
-    pose                     corr 0.999992  max abs   0.0938  mean abs 0.01833   (by error, pooled)
-    road_edges               corr 0.999953  max abs   0.0762  mean abs 0.01858
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00704   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0469  mean abs 0.01246   (by error, pooled)
-
-frame 43: corr 0.999981  max abs 0.1992
-    action                   corr 0.999961  max abs   0.0125  mean abs 0.00572   (by error, pooled)
-    desire_pred              corr 0.999924  max abs   0.0879  mean abs 0.03424
-    desire_state             corr 0.999996  max abs   0.1328  mean abs 0.06543   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1992  mean abs 0.01496
-    lane_lines               corr 0.999933  max abs   0.0671  mean abs 0.01937
-    lane_lines_prob          corr 0.999934  max abs   0.1328  mean abs 0.04815   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01052
-    lead_prob                corr 0.999974  max abs   0.0508  mean abs 0.03483   (by error, pooled)
-    meta                     corr 0.999854  max abs   0.1182  mean abs 0.04098
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00588
-    pose                     corr 0.999997  max abs   0.0352  mean abs 0.01159   (by error, pooled)
-    road_edges               corr 0.999912  max abs   0.1035  mean abs 0.02590
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.01020   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0059  mean abs 0.00200   (by error, pooled)
-
-frame 44: corr 0.999961  max abs 0.3125
-    action                   corr 0.999956  max abs   0.0234  mean abs 0.01290   (by error, pooled)
-    desire_pred              corr 0.999867  max abs   0.0938  mean abs 0.04165
-    desire_state             corr 0.999985  max abs   0.2422  mean abs 0.05908   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2340  mean abs 0.01324
-    lane_lines               corr 0.999964  max abs   0.0625  mean abs 0.01566
-    lane_lines_prob          corr 0.999985  max abs   0.0859  mean abs 0.04950   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.3125  mean abs 0.02699
-    lead_prob                corr 0.999996  max abs   0.0879  mean abs 0.08333   (by error, pooled)
-    meta                     corr 0.999895  max abs   0.0820  mean abs 0.03589
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999979  max abs   0.2891  mean abs 0.01164
-    pose                     corr 0.999988  max abs   0.0312  mean abs 0.01193   (by error, pooled)
-    road_edges               corr 0.999947  max abs   0.0664  mean abs 0.01609
-    road_transform           corr 0.999998  max abs   0.0430  mean abs 0.01035   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0391  mean abs 0.01245   (by error, pooled)
-
-frame 45: corr 0.999960  max abs 0.2188
-    action                   corr 0.999986  max abs   0.0215  mean abs 0.01061   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0684  mean abs 0.02888
-    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.08240   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1289  mean abs 0.01152
-    lane_lines               corr 0.999971  max abs   0.0386  mean abs 0.01310
-    lane_lines_prob          corr 0.999984  max abs   0.1055  mean abs 0.03467   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0625  mean abs 0.00760
-    lead_prob                corr 0.999935  max abs   0.1196  mean abs 0.10030   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.1250  mean abs 0.04695
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999980  max abs   0.2188  mean abs 0.00956
-    pose                     corr 0.999992  max abs   0.0259  mean abs 0.00762   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.0547  mean abs 0.01518
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00335   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0098  mean abs 0.00296   (by error, pooled)
-
-frame 46: corr 0.999949  max abs 0.5820
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00638   (by error, pooled)
-    desire_pred              corr 0.999979  max abs   0.0488  mean abs 0.02080
-    desire_state             corr 0.999981  max abs   0.1047  mean abs 0.04221   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1211  mean abs 0.01127
-    lane_lines               corr 0.999982  max abs   0.0371  mean abs 0.01206
-    lane_lines_prob          corr 0.999974  max abs   0.0977  mean abs 0.03348   (by error, pooled)
-    lead                     corr 0.999142  max abs   0.5820  mean abs 0.03989
-    lead_prob                corr 0.999995  max abs   0.1250  mean abs 0.10645   (by error, pooled)
-    meta                     corr 0.999931  max abs   0.0957  mean abs 0.03604
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00399
-    pose                     corr 0.999996  max abs   0.0186  mean abs 0.00574   (by error, pooled)
-    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01141
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00580   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00620   (by error, pooled)
-
-frame 47: corr 0.999940  max abs 0.6406
-    action                   corr 0.999993  max abs   0.0137  mean abs 0.00554   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0625  mean abs 0.03202
-    desire_state             corr 0.999962  max abs   0.2131  mean abs 0.06779   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1309  mean abs 0.01206
-    lane_lines               corr 0.999979  max abs   0.0762  mean abs 0.01445
-    lane_lines_prob          corr 0.999939  max abs   0.1367  mean abs 0.07001   (by error, pooled)
-    lead                     corr 0.999672  max abs   0.6406  mean abs 0.04770
-    lead_prob                corr 0.999975  max abs   0.0820  mean abs 0.06803   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0898  mean abs 0.03575
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0225  mean abs 0.00445
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00622   (by error, pooled)
-    road_edges               corr 0.999949  max abs   0.0781  mean abs 0.01724
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00491   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0234  mean abs 0.00885   (by error, pooled)
-
-frame 48: corr 0.999957  max abs 0.6250
-    action                   corr 0.999982  max abs   0.0195  mean abs 0.01069   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.0625  mean abs 0.02208
-    desire_state             corr 0.999986  max abs   0.1328  mean abs 0.05737   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1494  mean abs 0.01378
-    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01422
-    lane_lines_prob          corr 0.999956  max abs   0.0977  mean abs 0.04120   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.6250  mean abs 0.04285
-    lead_prob                corr 0.999936  max abs   0.1133  mean abs 0.09619   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.0902  mean abs 0.03599
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.1875  mean abs 0.00748
-    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00550   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.1250  mean abs 0.01621
-    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00393   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00656   (by error, pooled)
-
-frame 49: corr 0.999953  max abs 0.4375
-    action                   corr 0.999980  max abs   0.0293  mean abs 0.01551   (by error, pooled)
-    desire_pred              corr 0.999976  max abs   0.0508  mean abs 0.01759
-    desire_state             corr 0.999958  max abs   0.2617  mean abs 0.10352   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2109  mean abs 0.01310
-    lane_lines               corr 0.999950  max abs   0.0977  mean abs 0.01608
-    lane_lines_prob          corr 0.999894  max abs   0.1172  mean abs 0.04683   (by error, pooled)
-    lead                     corr 0.999969  max abs   0.4375  mean abs 0.03150
-    lead_prob                corr 0.999853  max abs   0.0996  mean abs 0.07861   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0859  mean abs 0.02841
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999973  max abs   0.1660  mean abs 0.01430
-    pose                     corr 0.999979  max abs   0.0410  mean abs 0.01245   (by error, pooled)
-    road_edges               corr 0.999964  max abs   0.1055  mean abs 0.01792
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00677   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0234  mean abs 0.00919   (by error, pooled)
-
-frame 50: corr 0.999943  max abs 0.5234
-    action                   corr 0.999964  max abs   0.0322  mean abs 0.01672   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03007
-    desire_state             corr 0.999955  max abs   0.2969  mean abs 0.10749   (by error, pooled)
-    hidden_state             corr 0.999946  max abs   0.1875  mean abs 0.01355
-    lane_lines               corr 0.999968  max abs   0.0898  mean abs 0.01383
-    lane_lines_prob          corr 0.999863  max abs   0.1758  mean abs 0.06085   (by error, pooled)
-    lead                     corr 0.999869  max abs   0.5234  mean abs 0.03819
-    lead_prob                corr 0.999837  max abs   0.1289  mean abs 0.10059   (by error, pooled)
-    meta                     corr 0.999929  max abs   0.0820  mean abs 0.03109
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999969  max abs   0.1680  mean abs 0.01198
-    pose                     corr 0.999969  max abs   0.0645  mean abs 0.01497   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.0762  mean abs 0.01593
-    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00938   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0098  mean abs 0.00296   (by error, pooled)
-
-frame 51: corr 0.999965  max abs 1.0000
-    action                   corr 0.999955  max abs   0.0171  mean abs 0.00784   (by error, pooled)
-    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02560
-    desire_state             corr 0.999986  max abs   0.2344  mean abs 0.11670   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2461  mean abs 0.01509
-    lane_lines               corr 0.999951  max abs   0.0938  mean abs 0.01672
-    lane_lines_prob          corr 0.999965  max abs   0.0923  mean abs 0.04596   (by error, pooled)
-    lead                     corr 0.999997  max abs   1.0000  mean abs 0.07913
-    lead_prob                corr 0.999973  max abs   0.0742  mean abs 0.04818   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0635  mean abs 0.02527
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2812  mean abs 0.01103
-    pose                     corr 0.999996  max abs   0.0625  mean abs 0.01496   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0859  mean abs 0.01813
-    road_transform           corr 0.999997  max abs   0.0391  mean abs 0.00987   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0352  mean abs 0.00953   (by error, pooled)
-
-frame 52: corr 0.999978  max abs 0.2012
-    action                   corr 0.999939  max abs   0.0176  mean abs 0.00873   (by error, pooled)
-    desire_pred              corr 0.999917  max abs   0.0859  mean abs 0.03464
-    desire_state             corr 0.999988  max abs   0.1250  mean abs 0.07446   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2012  mean abs 0.01484
-    lane_lines               corr 0.999930  max abs   0.0728  mean abs 0.01964
-    lane_lines_prob          corr 0.999950  max abs   0.0859  mean abs 0.04348   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01256
-    lead_prob                corr 0.999933  max abs   0.0420  mean abs 0.02441   (by error, pooled)
-    meta                     corr 0.999891  max abs   0.0859  mean abs 0.04246
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1094  mean abs 0.00555
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00976   (by error, pooled)
-    road_edges               corr 0.999877  max abs   0.1211  mean abs 0.03057
-    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00986   (by error, pooled)
-    wide_from_device_euler   corr 0.999987  max abs   0.0293  mean abs 0.00785   (by error, pooled)
-
-frame 53: corr 0.999953  max abs 0.3594
-    action                   corr 0.999955  max abs   0.0264  mean abs 0.01454   (by error, pooled)
-    desire_pred              corr 0.999863  max abs   0.0909  mean abs 0.04372
-    desire_state             corr 0.999980  max abs   0.1289  mean abs 0.09619   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.2233  mean abs 0.01320
-    lane_lines               corr 0.999966  max abs   0.0430  mean abs 0.01369
-    lane_lines_prob          corr 0.999981  max abs   0.0898  mean abs 0.04086   (by error, pooled)
-    lead                     corr 0.999975  max abs   0.3594  mean abs 0.03772
-    lead_prob                corr 1.000000  max abs   0.1113  mean abs 0.10026   (by error, pooled)
-    meta                     corr 0.999829  max abs   0.1133  mean abs 0.04773
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999965  max abs   0.3359  mean abs 0.01300
-    pose                     corr 0.999988  max abs   0.0337  mean abs 0.01259   (by error, pooled)
-    road_edges               corr 0.999928  max abs   0.0664  mean abs 0.02024
-    road_transform           corr 0.999998  max abs   0.0391  mean abs 0.00905   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0664  mean abs 0.01831   (by error, pooled)
-
-frame 54: corr 0.999957  max abs 0.2812
-    action                   corr 0.999996  max abs   0.0107  mean abs 0.00582   (by error, pooled)
-    desire_pred              corr 0.999951  max abs   0.0625  mean abs 0.03176
-    desire_state             corr 0.999988  max abs   0.0859  mean abs 0.04181   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1094  mean abs 0.01179
-    lane_lines               corr 0.999965  max abs   0.0625  mean abs 0.01655
-    lane_lines_prob          corr 0.999982  max abs   0.1602  mean abs 0.07764   (by error, pooled)
-    lead                     corr 0.999964  max abs   0.2812  mean abs 0.02281
-    lead_prob                corr 0.999936  max abs   0.1270  mean abs 0.10685   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0977  mean abs 0.04134
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0508  mean abs 0.00573
-    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00550   (by error, pooled)
-    road_edges               corr 0.999951  max abs   0.0938  mean abs 0.01782
-    road_transform           corr 0.999994  max abs   0.0352  mean abs 0.00506   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0117  mean abs 0.00426   (by error, pooled)
-
-frame 55: corr 0.999957  max abs 0.3438
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00665   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0664  mean abs 0.02021
-    desire_state             corr 0.999981  max abs   0.0703  mean abs 0.04671   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1152  mean abs 0.01115
-    lane_lines               corr 0.999975  max abs   0.0664  mean abs 0.01440
-    lane_lines_prob          corr 0.999967  max abs   0.1172  mean abs 0.04901   (by error, pooled)
-    lead                     corr 0.999812  max abs   0.3438  mean abs 0.02753
-    lead_prob                corr 0.999817  max abs   0.1270  mean abs 0.09538   (by error, pooled)
-    meta                     corr 0.999947  max abs   0.0879  mean abs 0.03769
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00460
-    pose                     corr 0.999997  max abs   0.0137  mean abs 0.00518   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0742  mean abs 0.01324
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00457   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0137  mean abs 0.00523   (by error, pooled)
-
-frame 56: corr 0.999956  max abs 0.2725
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00525   (by error, pooled)
-    desire_pred              corr 0.999973  max abs   0.0547  mean abs 0.02641
-    desire_state             corr 0.999997  max abs   0.0781  mean abs 0.03787   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1406  mean abs 0.01219
-    lane_lines               corr 0.999980  max abs   0.0566  mean abs 0.01184
-    lane_lines_prob          corr 0.999868  max abs   0.0801  mean abs 0.04492   (by error, pooled)
-    lead                     corr 0.999601  max abs   0.2725  mean abs 0.02176
-    lead_prob                corr 0.999846  max abs   0.1016  mean abs 0.07747   (by error, pooled)
-    meta                     corr 0.999915  max abs   0.0918  mean abs 0.03517
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0645  mean abs 0.00431
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00586   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0820  mean abs 0.01239
-    road_transform           corr 0.999995  max abs   0.0273  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0312  mean abs 0.01176   (by error, pooled)
-
-frame 57: corr 0.999956  max abs 0.3750
-    action                   corr 0.999985  max abs   0.0181  mean abs 0.00963   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0840  mean abs 0.03075
-    desire_state             corr 0.999990  max abs   0.1641  mean abs 0.07544   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1709  mean abs 0.01410
-    lane_lines               corr 0.999959  max abs   0.1250  mean abs 0.01614
-    lane_lines_prob          corr 0.999859  max abs   0.1719  mean abs 0.06293   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.3750  mean abs 0.02853
-    lead_prob                corr 0.999945  max abs   0.0859  mean abs 0.07056   (by error, pooled)
-    meta                     corr 0.999730  max abs   0.1221  mean abs 0.04862
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0625  mean abs 0.00455
-    pose                     corr 0.999991  max abs   0.0264  mean abs 0.00733   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.1484  mean abs 0.01666
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00581   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0254  mean abs 0.00560   (by error, pooled)
-
-frame 58: corr 0.999957  max abs 0.2344
-    action                   corr 0.999990  max abs   0.0176  mean abs 0.00778   (by error, pooled)
-    desire_pred              corr 0.999951  max abs   0.0820  mean abs 0.02925
-    desire_state             corr 0.999976  max abs   0.2344  mean abs 0.08923   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1797  mean abs 0.01294
-    lane_lines               corr 0.999962  max abs   0.0898  mean abs 0.01531
-    lane_lines_prob          corr 0.999956  max abs   0.1406  mean abs 0.04791   (by error, pooled)
-    lead                     corr 0.999965  max abs   0.2266  mean abs 0.01826
-    lead_prob                corr 0.999449  max abs   0.1094  mean abs 0.08789   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0840  mean abs 0.02789
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999989  max abs   0.1172  mean abs 0.00709
-    pose                     corr 0.999986  max abs   0.0332  mean abs 0.00896   (by error, pooled)
-    road_edges               corr 0.999958  max abs   0.0762  mean abs 0.01881
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00638   (by error, pooled)
-    wide_from_device_euler   corr 0.999990  max abs   0.0273  mean abs 0.00886   (by error, pooled)
-
-frame 59: corr 0.999930  max abs 0.4062
-    action                   corr 0.999972  max abs   0.0303  mean abs 0.01643   (by error, pooled)
-    desire_pred              corr 0.999927  max abs   0.0918  mean abs 0.03131
-    desire_state             corr 0.999944  max abs   0.3750  mean abs 0.15173   (by error, pooled)
-    hidden_state             corr 0.999942  max abs   0.2227  mean abs 0.01407
-    lane_lines               corr 0.999958  max abs   0.1094  mean abs 0.01538
-    lane_lines_prob          corr 0.999842  max abs   0.1602  mean abs 0.06467   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.4062  mean abs 0.05356
-    lead_prob                corr 0.999797  max abs   0.0723  mean abs 0.05273   (by error, pooled)
-    meta                     corr 0.999951  max abs   0.0879  mean abs 0.02836
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999951  max abs   0.2422  mean abs 0.01267
-    pose                     corr 0.999965  max abs   0.0664  mean abs 0.01563   (by error, pooled)
-    road_edges               corr 0.999949  max abs   0.0859  mean abs 0.01721
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00628   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00719   (by error, pooled)
-
-frame 60: corr 0.999953  max abs 1.0000
-    action                   corr 0.999916  max abs   0.0254  mean abs 0.01387   (by error, pooled)
-    desire_pred              corr 0.999965  max abs   0.0684  mean abs 0.02454
-    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.05286   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2129  mean abs 0.01532
-    lane_lines               corr 0.999956  max abs   0.0664  mean abs 0.01584
-    lane_lines_prob          corr 0.999989  max abs   0.1016  mean abs 0.04890   (by error, pooled)
-    lead                     corr 0.999992  max abs   1.0000  mean abs 0.07129
-    lead_prob                corr 0.999970  max abs   0.0234  mean abs 0.01530   (by error, pooled)
-    meta                     corr 0.999944  max abs   0.0752  mean abs 0.02185
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999975  max abs   0.3750  mean abs 0.01604
-    pose                     corr 0.999991  max abs   0.0859  mean abs 0.01885   (by error, pooled)
-    road_edges               corr 0.999929  max abs   0.0938  mean abs 0.02242
-    road_transform           corr 0.999997  max abs   0.0508  mean abs 0.01206   (by error, pooled)
-    wide_from_device_euler   corr 0.999986  max abs   0.0449  mean abs 0.01542   (by error, pooled)
-
-frame 61: corr 0.999977  max abs 0.1719
-    action                   corr 0.999976  max abs   0.0110  mean abs 0.00571   (by error, pooled)
-    desire_pred              corr 0.999891  max abs   0.0957  mean abs 0.03925
-    desire_state             corr 0.999997  max abs   0.1094  mean abs 0.04929   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1719  mean abs 0.01461
-    lane_lines               corr 0.999884  max abs   0.1038  mean abs 0.02350
-    lane_lines_prob          corr 0.999950  max abs   0.1133  mean abs 0.05789   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.0625  mean abs 0.00837
-    lead_prob                corr 0.999996  max abs   0.0300  mean abs 0.01326   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.0898  mean abs 0.04400
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1328  mean abs 0.00503
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00992   (by error, pooled)
-    road_edges               corr 0.999869  max abs   0.1055  mean abs 0.03016
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01394   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00525   (by error, pooled)
-
-frame 62: corr 0.999960  max abs 0.3125
-    action                   corr 0.999978  max abs   0.0215  mean abs 0.01225   (by error, pooled)
-    desire_pred              corr 0.999932  max abs   0.0781  mean abs 0.02914
-    desire_state             corr 0.999993  max abs   0.1836  mean abs 0.09161   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2567  mean abs 0.01361
-    lane_lines               corr 0.999948  max abs   0.0547  mean abs 0.01539
-    lane_lines_prob          corr 0.999908  max abs   0.1406  mean abs 0.04785   (by error, pooled)
-    lead                     corr 0.999991  max abs   0.2812  mean abs 0.02750
-    lead_prob                corr 0.999994  max abs   0.1069  mean abs 0.08285   (by error, pooled)
-    meta                     corr 0.999832  max abs   0.1113  mean abs 0.04802
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999967  max abs   0.3125  mean abs 0.01284
-    pose                     corr 0.999995  max abs   0.0234  mean abs 0.00736   (by error, pooled)
-    road_edges               corr 0.999888  max abs   0.0762  mean abs 0.02576
-    road_transform           corr 0.999996  max abs   0.0586  mean abs 0.01589   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0625  mean abs 0.01701   (by error, pooled)
-
-frame 63: corr 0.999957  max abs 0.2812
-    action                   corr 0.999994  max abs   0.0146  mean abs 0.00650   (by error, pooled)
-    desire_pred              corr 0.999947  max abs   0.0625  mean abs 0.03246
-    desire_state             corr 0.999977  max abs   0.2812  mean abs 0.15918   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1172  mean abs 0.01182
-    lane_lines               corr 0.999977  max abs   0.0488  mean abs 0.01284
-    lane_lines_prob          corr 0.999981  max abs   0.0742  mean abs 0.03076   (by error, pooled)
-    lead                     corr 0.999970  max abs   0.2188  mean abs 0.01843
-    lead_prob                corr 0.999815  max abs   0.1631  mean abs 0.13082   (by error, pooled)
-    meta                     corr 0.999893  max abs   0.1172  mean abs 0.04738
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0781  mean abs 0.00548
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00508   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0703  mean abs 0.01408
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00530   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00687   (by error, pooled)
-
-frame 64: corr 0.999965  max abs 0.1797
-    action                   corr 0.999996  max abs   0.0137  mean abs 0.00573   (by error, pooled)
-    desire_pred              corr 0.999971  max abs   0.0586  mean abs 0.02530
-    desire_state             corr 0.999986  max abs   0.1797  mean abs 0.10046   (by error, pooled)
-    hidden_state             corr 0.999958  max abs   0.1094  mean abs 0.01099
-    lane_lines               corr 0.999959  max abs   0.0820  mean abs 0.01630
-    lane_lines_prob          corr 0.999910  max abs   0.1094  mean abs 0.04137   (by error, pooled)
-    lead                     corr 0.999964  max abs   0.1328  mean abs 0.00961
-    lead_prob                corr 0.999999  max abs   0.0703  mean abs 0.06543   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0908  mean abs 0.03479
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00662
-    pose                     corr 0.999996  max abs   0.0166  mean abs 0.00592   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.1016  mean abs 0.01671
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00400   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0234  mean abs 0.00458   (by error, pooled)
-
-frame 65: corr 0.999955  max abs 0.3066
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00378   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0820  mean abs 0.03578
-    desire_state             corr 0.999981  max abs   0.2109  mean abs 0.08820   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1289  mean abs 0.01225
-    lane_lines               corr 0.999969  max abs   0.0742  mean abs 0.01382
-    lane_lines_prob          corr 0.999911  max abs   0.0781  mean abs 0.03632   (by error, pooled)
-    lead                     corr 0.999721  max abs   0.3066  mean abs 0.02560
-    lead_prob                corr 0.999990  max abs   0.0859  mean abs 0.06999   (by error, pooled)
-    meta                     corr 0.999897  max abs   0.1035  mean abs 0.04263
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0278  mean abs 0.00595
-    pose                     corr 0.999997  max abs   0.0195  mean abs 0.00621   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0918  mean abs 0.01782
-    road_transform           corr 0.999998  max abs   0.0234  mean abs 0.00547   (by error, pooled)
-    wide_from_device_euler   corr 0.999987  max abs   0.0391  mean abs 0.01046   (by error, pooled)
-
-frame 66: corr 0.999963  max abs 0.2500
-    action                   corr 0.999981  max abs   0.0215  mean abs 0.01265   (by error, pooled)
-    desire_pred              corr 0.999946  max abs   0.0625  mean abs 0.02707
-    desire_state             corr 0.999988  max abs   0.2500  mean abs 0.10840   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.2002  mean abs 0.01356
-    lane_lines               corr 0.999966  max abs   0.1387  mean abs 0.01399
-    lane_lines_prob          corr 0.999910  max abs   0.0793  mean abs 0.04556   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.1328  mean abs 0.01790
-    lead_prob                corr 0.999748  max abs   0.1641  mean abs 0.10872   (by error, pooled)
-    meta                     corr 0.999933  max abs   0.0657  mean abs 0.02508
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.0625  mean abs 0.00973
-    pose                     corr 0.999984  max abs   0.0410  mean abs 0.01082   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.1250  mean abs 0.01564
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00556   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00655   (by error, pooled)
-
-frame 67: corr 0.999957  max abs 0.2344
-    action                   corr 0.999978  max abs   0.0273  mean abs 0.01236   (by error, pooled)
-    desire_pred              corr 0.999907  max abs   0.0820  mean abs 0.03851
-    desire_state             corr 0.999987  max abs   0.1875  mean abs 0.09302   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1855  mean abs 0.01315
-    lane_lines               corr 0.999942  max abs   0.1328  mean abs 0.01776
-    lane_lines_prob          corr 0.999937  max abs   0.1094  mean abs 0.02963   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.1875  mean abs 0.02484
-    lead_prob                corr 0.999982  max abs   0.1445  mean abs 0.12012   (by error, pooled)
-    meta                     corr 0.999887  max abs   0.0977  mean abs 0.03546
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999984  max abs   0.2344  mean abs 0.01087
-    pose                     corr 0.999981  max abs   0.0391  mean abs 0.01217   (by error, pooled)
-    road_edges               corr 0.999946  max abs   0.1016  mean abs 0.01812
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00768   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0293  mean abs 0.00722   (by error, pooled)
-
-frame 68: corr 0.999950  max abs 0.2148
-    action                   corr 0.999973  max abs   0.0332  mean abs 0.01659   (by error, pooled)
-    desire_pred              corr 0.999921  max abs   0.0742  mean abs 0.03478
-    desire_state             corr 0.999979  max abs   0.2109  mean abs 0.10840   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.2148  mean abs 0.01354
-    lane_lines               corr 0.999962  max abs   0.0566  mean abs 0.01385
-    lane_lines_prob          corr 0.999875  max abs   0.1016  mean abs 0.04523   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.2031  mean abs 0.02641
-    lead_prob                corr 0.999954  max abs   0.1250  mean abs 0.09928   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0547  mean abs 0.02170
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999975  max abs   0.1641  mean abs 0.01313
-    pose                     corr 0.999970  max abs   0.0566  mean abs 0.01544   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0781  mean abs 0.01303
-    road_transform           corr 0.999993  max abs   0.0430  mean abs 0.00872   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0176  mean abs 0.00362   (by error, pooled)
-
-frame 69: corr 0.999968  max abs 0.5625
-    action                   corr 0.999962  max abs   0.0151  mean abs 0.00745   (by error, pooled)
-    desire_pred              corr 0.999940  max abs   0.0938  mean abs 0.02908
-    desire_state             corr 0.999984  max abs   0.1719  mean abs 0.09521   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.1953  mean abs 0.01517
-    lane_lines               corr 0.999940  max abs   0.0938  mean abs 0.01824
-    lane_lines_prob          corr 0.999938  max abs   0.1445  mean abs 0.05496   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5625  mean abs 0.05521
-    lead_prob                corr 0.999977  max abs   0.0684  mean abs 0.05176   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0840  mean abs 0.02844
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2031  mean abs 0.00985
-    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01493   (by error, pooled)
-    road_edges               corr 0.999904  max abs   0.1094  mean abs 0.02694
-    road_transform           corr 0.999997  max abs   0.0430  mean abs 0.00889   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0352  mean abs 0.01180   (by error, pooled)
-
-frame 70: corr 0.999977  max abs 0.3125
-    action                   corr 0.999972  max abs   0.0129  mean abs 0.00566   (by error, pooled)
-    desire_pred              corr 0.999886  max abs   0.1113  mean abs 0.04156
-    desire_state             corr 0.999998  max abs   0.1016  mean abs 0.05786   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1758  mean abs 0.01456
-    lane_lines               corr 0.999905  max abs   0.0802  mean abs 0.02389
-    lane_lines_prob          corr 0.999826  max abs   0.2500  mean abs 0.09526   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02130
-    lead_prob                corr 0.999998  max abs   0.0811  mean abs 0.07210   (by error, pooled)
-    meta                     corr 0.999866  max abs   0.1133  mean abs 0.04726
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999993  max abs   0.3125  mean abs 0.00817
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.00944   (by error, pooled)
-    road_edges               corr 0.999890  max abs   0.0894  mean abs 0.02809
-    road_transform           corr 0.999991  max abs   0.0312  mean abs 0.01126   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00299   (by error, pooled)
-
-frame 71: corr 0.999950  max abs 0.3438
-    action                   corr 0.999978  max abs   0.0215  mean abs 0.01211   (by error, pooled)
-    desire_pred              corr 0.999920  max abs   0.0807  mean abs 0.03205
-    desire_state             corr 0.999996  max abs   0.2188  mean abs 0.09253   (by error, pooled)
-    hidden_state             corr 0.999947  max abs   0.2341  mean abs 0.01328
-    lane_lines               corr 0.999953  max abs   0.0898  mean abs 0.01493
-    lane_lines_prob          corr 0.999982  max abs   0.0508  mean abs 0.02563   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.04068
-    lead_prob                corr 0.999966  max abs   0.1367  mean abs 0.10775   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.1094  mean abs 0.05435
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999981  max abs   0.2344  mean abs 0.01384
-    pose                     corr 0.999987  max abs   0.0312  mean abs 0.01272   (by error, pooled)
-    road_edges               corr 0.999932  max abs   0.0820  mean abs 0.02025
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00433   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0273  mean abs 0.00757   (by error, pooled)
-
-frame 72: corr 0.999965  max abs 0.1211
-    action                   corr 0.999994  max abs   0.0137  mean abs 0.00534   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0664  mean abs 0.03443
-    desire_state             corr 0.999995  max abs   0.0781  mean abs 0.03052   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1211  mean abs 0.01144
-    lane_lines               corr 0.999965  max abs   0.0703  mean abs 0.01386
-    lane_lines_prob          corr 0.999937  max abs   0.1211  mean abs 0.04553   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.0938  mean abs 0.00948
-    lead_prob                corr 0.999937  max abs   0.1016  mean abs 0.06445   (by error, pooled)
-    meta                     corr 0.999926  max abs   0.1016  mean abs 0.03933
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1016  mean abs 0.00674
-    pose                     corr 0.999995  max abs   0.0244  mean abs 0.00696   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01637
-    road_transform           corr 0.999996  max abs   0.0312  mean abs 0.00678   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0156  mean abs 0.00522   (by error, pooled)
-
-frame 73: corr 0.999964  max abs 0.2422
-    action                   corr 0.999992  max abs   0.0156  mean abs 0.00574   (by error, pooled)
-    desire_pred              corr 0.999945  max abs   0.0605  mean abs 0.03956
-    desire_state             corr 0.999969  max abs   0.2422  mean abs 0.08496   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1230  mean abs 0.01152
-    lane_lines               corr 0.999980  max abs   0.0430  mean abs 0.01133
-    lane_lines_prob          corr 0.999959  max abs   0.1133  mean abs 0.05399   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0469  mean abs 0.00878
-    lead_prob                corr 0.999995  max abs   0.0898  mean abs 0.07878   (by error, pooled)
-    meta                     corr 0.999917  max abs   0.1191  mean abs 0.03578
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00729
-    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00591   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0781  mean abs 0.01458
-    road_transform           corr 0.999997  max abs   0.0234  mean abs 0.00506   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
-
-frame 74: corr 0.999962  max abs 0.1289
-    action                   corr 0.999998  max abs   0.0088  mean abs 0.00378   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0547  mean abs 0.02530
-    desire_state             corr 0.999978  max abs   0.1250  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1289  mean abs 0.01225
-    lane_lines               corr 0.999983  max abs   0.0488  mean abs 0.01069
-    lane_lines_prob          corr 0.999953  max abs   0.0820  mean abs 0.04108   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.0216  mean abs 0.00366
-    lead_prob                corr 0.999999  max abs   0.0508  mean abs 0.04525   (by error, pooled)
-    meta                     corr 0.999931  max abs   0.0977  mean abs 0.03667
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0938  mean abs 0.00628
-    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00738   (by error, pooled)
-    road_edges               corr 0.999982  max abs   0.0762  mean abs 0.01163
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00798   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0273  mean abs 0.00852   (by error, pooled)
-
-frame 75: corr 0.999965  max abs 0.1802
-    action                   corr 0.999983  max abs   0.0181  mean abs 0.01035   (by error, pooled)
-    desire_pred              corr 0.999947  max abs   0.0645  mean abs 0.02671
-    desire_state             corr 0.999994  max abs   0.1367  mean abs 0.05273   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1802  mean abs 0.01418
-    lane_lines               corr 0.999977  max abs   0.0938  mean abs 0.01250
-    lane_lines_prob          corr 0.999884  max abs   0.0957  mean abs 0.03717   (by error, pooled)
-    lead                     corr 0.999997  max abs   0.1094  mean abs 0.01454
-    lead_prob                corr 0.999984  max abs   0.1094  mean abs 0.08919   (by error, pooled)
-    meta                     corr 0.999863  max abs   0.0909  mean abs 0.03252
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1406  mean abs 0.00598
-    pose                     corr 0.999991  max abs   0.0312  mean abs 0.00796   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0935  mean abs 0.01715
-    road_transform           corr 0.999994  max abs   0.0293  mean abs 0.00751   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0137  mean abs 0.00364   (by error, pooled)
-
-frame 76: corr 0.999955  max abs 0.2588
-    action                   corr 0.999980  max abs   0.0273  mean abs 0.01375   (by error, pooled)
-    desire_pred              corr 0.999935  max abs   0.0820  mean abs 0.02995
-    desire_state             corr 0.999972  max abs   0.2588  mean abs 0.14471   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2383  mean abs 0.01328
-    lane_lines               corr 0.999969  max abs   0.0898  mean abs 0.01368
-    lane_lines_prob          corr 0.999914  max abs   0.0938  mean abs 0.03456   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.1250  mean abs 0.01952
-    lead_prob                corr 0.999992  max abs   0.0938  mean abs 0.08008   (by error, pooled)
-    meta                     corr 0.999916  max abs   0.0840  mean abs 0.03474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999982  max abs   0.1875  mean abs 0.01056
-    pose                     corr 0.999962  max abs   0.0625  mean abs 0.01739   (by error, pooled)
-    road_edges               corr 0.999984  max abs   0.0664  mean abs 0.01294
-    road_transform           corr 1.000000  max abs   0.0234  mean abs 0.00646   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00525   (by error, pooled)
-
-frame 77: corr 0.999951  max abs 0.3906
-    action                   corr 0.999970  max abs   0.0322  mean abs 0.01698   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0684  mean abs 0.01995
-    desire_state             corr 0.999907  max abs   0.3906  mean abs 0.19397   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.1758  mean abs 0.01404
-    lane_lines               corr 0.999972  max abs   0.1133  mean abs 0.01270
-    lane_lines_prob          corr 0.999942  max abs   0.0859  mean abs 0.03262   (by error, pooled)
-    lead                     corr 0.999989  max abs   0.1562  mean abs 0.02014
-    lead_prob                corr 0.999992  max abs   0.1465  mean abs 0.12314   (by error, pooled)
-    meta                     corr 0.999966  max abs   0.0723  mean abs 0.02376
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999984  max abs   0.2031  mean abs 0.01073
-    pose                     corr 0.999977  max abs   0.0547  mean abs 0.01181   (by error, pooled)
-    road_edges               corr 0.999977  max abs   0.0781  mean abs 0.01255
-    road_transform           corr 0.999997  max abs   0.0273  mean abs 0.00620   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0312  mean abs 0.01147   (by error, pooled)
-
-frame 78: corr 0.999968  max abs 0.8125
-    action                   corr 0.999945  max abs   0.0176  mean abs 0.00992   (by error, pooled)
-    desire_pred              corr 0.999977  max abs   0.0586  mean abs 0.01959
-    desire_state             corr 0.999985  max abs   0.1729  mean abs 0.07568   (by error, pooled)
-    hidden_state             corr 0.999940  max abs   0.2227  mean abs 0.01550
-    lane_lines               corr 0.999957  max abs   0.1406  mean abs 0.01580
-    lane_lines_prob          corr 0.999853  max abs   0.1797  mean abs 0.05075   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.8125  mean abs 0.07051
-    lead_prob                corr 0.999988  max abs   0.1138  mean abs 0.10042   (by error, pooled)
-    meta                     corr 0.999930  max abs   0.0693  mean abs 0.02624
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1875  mean abs 0.01092
-    pose                     corr 0.999994  max abs   0.0703  mean abs 0.01583   (by error, pooled)
-    road_edges               corr 0.999944  max abs   0.0996  mean abs 0.02373
-    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01103   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.01083   (by error, pooled)
-
-frame 79: corr 0.999981  max abs 0.1953
-    action                   corr 0.999993  max abs   0.0068  mean abs 0.00330   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03223
-    desire_state             corr 0.999988  max abs   0.1230  mean abs 0.05566   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1953  mean abs 0.01466
-    lane_lines               corr 0.999930  max abs   0.0938  mean abs 0.02010
-    lane_lines_prob          corr 0.999953  max abs   0.1172  mean abs 0.06225   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1250  mean abs 0.01362
-    lead_prob                corr 0.999989  max abs   0.0771  mean abs 0.06576   (by error, pooled)
-    meta                     corr 0.999859  max abs   0.1152  mean abs 0.04403
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1875  mean abs 0.00592
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01025   (by error, pooled)
-    road_edges               corr 0.999916  max abs   0.0781  mean abs 0.02472
-    road_transform           corr 0.999992  max abs   0.0508  mean abs 0.01150   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.00590   (by error, pooled)
-
-frame 80: corr 0.999966  max abs 0.2447
-    action                   corr 0.999955  max abs   0.0244  mean abs 0.01292   (by error, pooled)
-    desire_pred              corr 0.999948  max abs   0.0703  mean abs 0.02839
-    desire_state             corr 0.999985  max abs   0.1719  mean abs 0.06842   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2447  mean abs 0.01320
-    lane_lines               corr 0.999966  max abs   0.0469  mean abs 0.01316
-    lane_lines_prob          corr 0.999978  max abs   0.0685  mean abs 0.03523   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.1562  mean abs 0.02241
-    lead_prob                corr 0.999989  max abs   0.1465  mean abs 0.12874   (by error, pooled)
-    meta                     corr 0.999904  max abs   0.0859  mean abs 0.03536
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00775
-    pose                     corr 0.999993  max abs   0.0273  mean abs 0.01102   (by error, pooled)
-    road_edges               corr 0.999933  max abs   0.0762  mean abs 0.01956
-    road_transform           corr 0.999995  max abs   0.0469  mean abs 0.01118   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0391  mean abs 0.01375   (by error, pooled)
-
-frame 81: corr 0.999958  max abs 0.1680
-    action                   corr 0.999988  max abs   0.0205  mean abs 0.00917   (by error, pooled)
-    desire_pred              corr 0.999936  max abs   0.0688  mean abs 0.03357
-    desire_state             corr 0.999965  max abs   0.1289  mean abs 0.07713   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01147
-    lane_lines               corr 0.999936  max abs   0.1211  mean abs 0.01838
-    lane_lines_prob          corr 0.999911  max abs   0.1055  mean abs 0.03925   (by error, pooled)
-    lead                     corr 0.999996  max abs   0.0508  mean abs 0.00909
-    lead_prob                corr 0.999975  max abs   0.1523  mean abs 0.12354   (by error, pooled)
-    meta                     corr 0.999839  max abs   0.1426  mean abs 0.05474
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.0625  mean abs 0.00678
-    pose                     corr 0.999993  max abs   0.0283  mean abs 0.00774   (by error, pooled)
-    road_edges               corr 0.999924  max abs   0.1680  mean abs 0.02038
-    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00653   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0078  mean abs 0.00264   (by error, pooled)
-
-frame 82: corr 0.999961  max abs 0.1594
-    action                   corr 0.999997  max abs   0.0088  mean abs 0.00259   (by error, pooled)
-    desire_pred              corr 0.999950  max abs   0.0781  mean abs 0.03089
-    desire_state             corr 0.999990  max abs   0.1172  mean abs 0.07062   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1289  mean abs 0.01148
-    lane_lines               corr 0.999967  max abs   0.0625  mean abs 0.01310
-    lane_lines_prob          corr 0.999949  max abs   0.0840  mean abs 0.04501   (by error, pooled)
-    lead                     corr 0.999844  max abs   0.1594  mean abs 0.01475
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.07214   (by error, pooled)
-    meta                     corr 0.999943  max abs   0.0762  mean abs 0.03255
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00434
-    pose                     corr 0.999997  max abs   0.0156  mean abs 0.00594   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0586  mean abs 0.01416
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00416   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0137  mean abs 0.00295   (by error, pooled)
-
-frame 83: corr 0.999955  max abs 0.2578
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00385   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0742  mean abs 0.02845
-    desire_state             corr 0.999985  max abs   0.1309  mean abs 0.03833   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1328  mean abs 0.01242
-    lane_lines               corr 0.999976  max abs   0.0703  mean abs 0.01571
-    lane_lines_prob          corr 0.999971  max abs   0.1211  mean abs 0.05807   (by error, pooled)
-    lead                     corr 0.999982  max abs   0.2578  mean abs 0.02209
-    lead_prob                corr 0.999999  max abs   0.0977  mean abs 0.08310   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.0898  mean abs 0.03797
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00380
-    pose                     corr 0.999997  max abs   0.0273  mean abs 0.00770   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.0781  mean abs 0.01535
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00790   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00981   (by error, pooled)
-
-frame 84: corr 0.999958  max abs 0.3125
-    action                   corr 0.999986  max abs   0.0161  mean abs 0.00913   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0586  mean abs 0.02159
-    desire_state             corr 0.999929  max abs   0.1484  mean abs 0.08228   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1641  mean abs 0.01399
-    lane_lines               corr 0.999933  max abs   0.2227  mean abs 0.01733
-    lane_lines_prob          corr 0.999822  max abs   0.0898  mean abs 0.05341   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.3125  mean abs 0.02349
-    lead_prob                corr 0.999966  max abs   0.1680  mean abs 0.14006   (by error, pooled)
-    meta                     corr 0.999860  max abs   0.0996  mean abs 0.03439
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00519
-    pose                     corr 0.999989  max abs   0.0264  mean abs 0.00699   (by error, pooled)
-    road_edges               corr 0.999965  max abs   0.1250  mean abs 0.01487
-    road_transform           corr 0.999992  max abs   0.0312  mean abs 0.00808   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
-
-frame 85: corr 0.999955  max abs 0.3750
-    action                   corr 0.999969  max abs   0.0234  mean abs 0.01309   (by error, pooled)
-    desire_pred              corr 0.999931  max abs   0.0625  mean abs 0.02937
-    desire_state             corr 0.999725  max abs   0.3613  mean abs 0.19666   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.2188  mean abs 0.01400
-    lane_lines               corr 0.999966  max abs   0.1133  mean abs 0.01702
-    lane_lines_prob          corr 0.999995  max abs   0.0762  mean abs 0.04250   (by error, pooled)
-    lead                     corr 0.999957  max abs   0.3750  mean abs 0.03565
-    lead_prob                corr 0.999985  max abs   0.2383  mean abs 0.19333   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.0762  mean abs 0.02420
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999987  max abs   0.1875  mean abs 0.00896
-    pose                     corr 0.999974  max abs   0.0781  mean abs 0.01537   (by error, pooled)
-    road_edges               corr 0.999981  max abs   0.0625  mean abs 0.01499
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00857   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0215  mean abs 0.00817   (by error, pooled)
-
-frame 86: corr 0.999929  max abs 0.4688
-    action                   corr 0.999969  max abs   0.0332  mean abs 0.01874   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0625  mean abs 0.03150
-    desire_state             corr 0.999726  max abs   0.3828  mean abs 0.18327   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2188  mean abs 0.01377
-    lane_lines               corr 0.999964  max abs   0.0977  mean abs 0.01412
-    lane_lines_prob          corr 0.999902  max abs   0.1211  mean abs 0.04495   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.4688  mean abs 0.05692
-    lead_prob                corr 0.999998  max abs   0.1328  mean abs 0.10693   (by error, pooled)
-    meta                     corr 0.999945  max abs   0.0742  mean abs 0.02528
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999959  max abs   0.2422  mean abs 0.01130
-    pose                     corr 0.999958  max abs   0.0762  mean abs 0.01647   (by error, pooled)
-    road_edges               corr 0.999942  max abs   0.0664  mean abs 0.02047
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00914   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00462   (by error, pooled)
-
-frame 87: corr 0.999969  max abs 0.8125
-    action                   corr 0.999944  max abs   0.0159  mean abs 0.00849   (by error, pooled)
-    desire_pred              corr 0.999961  max abs   0.0547  mean abs 0.02374
-    desire_state             corr 0.999984  max abs   0.1875  mean abs 0.09924   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2227  mean abs 0.01549
-    lane_lines               corr 0.999949  max abs   0.1328  mean abs 0.01768
-    lane_lines_prob          corr 0.999975  max abs   0.1562  mean abs 0.05096   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.8125  mean abs 0.06905
-    lead_prob                corr 0.999998  max abs   0.0582  mean abs 0.04545   (by error, pooled)
-    meta                     corr 0.999914  max abs   0.0977  mean abs 0.03504
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00920
-    pose                     corr 0.999995  max abs   0.0547  mean abs 0.01569   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0820  mean abs 0.02022
-    road_transform           corr 0.999999  max abs   0.0273  mean abs 0.00987   (by error, pooled)
-    wide_from_device_euler   corr 0.999989  max abs   0.0371  mean abs 0.01217   (by error, pooled)
-
-frame 88: corr 0.999980  max abs 0.2500
-    action                   corr 0.999933  max abs   0.0154  mean abs 0.00757   (by error, pooled)
-    desire_pred              corr 0.999926  max abs   0.0781  mean abs 0.03278
-    desire_state             corr 0.999973  max abs   0.2344  mean abs 0.09424   (by error, pooled)
-    hidden_state             corr 0.999948  max abs   0.1973  mean abs 0.01472
-    lane_lines               corr 0.999923  max abs   0.1016  mean abs 0.02050
-    lane_lines_prob          corr 0.999851  max abs   0.1992  mean abs 0.06371   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02078
-    lead_prob                corr 1.000000  max abs   0.0381  mean abs 0.03597   (by error, pooled)
-    meta                     corr 0.999879  max abs   0.1069  mean abs 0.03890
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.1562  mean abs 0.00626
-    pose                     corr 0.999997  max abs   0.0332  mean abs 0.01122   (by error, pooled)
-    road_edges               corr 0.999909  max abs   0.0762  mean abs 0.02562
-    road_transform           corr 0.999995  max abs   0.0391  mean abs 0.01119   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0273  mean abs 0.01143   (by error, pooled)
-
-frame 89: corr 0.999968  max abs 0.2764
-    action                   corr 0.999955  max abs   0.0205  mean abs 0.01051   (by error, pooled)
-    desire_pred              corr 0.999926  max abs   0.0820  mean abs 0.03086
-    desire_state             corr 0.999993  max abs   0.1523  mean abs 0.05615   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2764  mean abs 0.01343
-    lane_lines               corr 0.999954  max abs   0.0723  mean abs 0.01570
-    lane_lines_prob          corr 0.999981  max abs   0.0487  mean abs 0.02660   (by error, pooled)
-    lead                     corr 0.999998  max abs   0.1250  mean abs 0.01621
-    lead_prob                corr 0.999996  max abs   0.1006  mean abs 0.08167   (by error, pooled)
-    meta                     corr 0.999892  max abs   0.0879  mean abs 0.03854
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0781  mean abs 0.00805
-    pose                     corr 0.999994  max abs   0.0254  mean abs 0.00778   (by error, pooled)
-    road_edges               corr 0.999943  max abs   0.0547  mean abs 0.01786
-    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.01035   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0234  mean abs 0.00754   (by error, pooled)
-
-frame 90: corr 0.999954  max abs 0.4531
-    action                   corr 0.999991  max abs   0.0195  mean abs 0.00842   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0898  mean abs 0.02631
-    desire_state             corr 0.999939  max abs   0.1797  mean abs 0.09821   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1084  mean abs 0.01168
-    lane_lines               corr 0.999973  max abs   0.0566  mean abs 0.01503
-    lane_lines_prob          corr 0.999935  max abs   0.1055  mean abs 0.03369   (by error, pooled)
-    lead                     corr 0.999975  max abs   0.4531  mean abs 0.03565
-    lead_prob                corr 0.999992  max abs   0.1172  mean abs 0.09489   (by error, pooled)
-    meta                     corr 0.999906  max abs   0.1152  mean abs 0.04144
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0312  mean abs 0.00543
-    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00641   (by error, pooled)
-    road_edges               corr 0.999968  max abs   0.0820  mean abs 0.01678
-    road_transform           corr 0.999995  max abs   0.0234  mean abs 0.00587   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00654   (by error, pooled)
-
-frame 91: corr 0.999962  max abs 0.1289
-    action                   corr 0.999997  max abs   0.0098  mean abs 0.00372   (by error, pooled)
-    desire_pred              corr 0.999940  max abs   0.0664  mean abs 0.03883
-    desire_state             corr 0.999991  max abs   0.1084  mean abs 0.05154   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1172  mean abs 0.01148
-    lane_lines               corr 0.999970  max abs   0.0684  mean abs 0.01578
-    lane_lines_prob          corr 0.999932  max abs   0.1289  mean abs 0.06403   (by error, pooled)
-    lead                     corr 0.999987  max abs   0.1172  mean abs 0.01015
-    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05021   (by error, pooled)
-    meta                     corr 0.999922  max abs   0.1211  mean abs 0.04145
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00476
-    pose                     corr 0.999998  max abs   0.0156  mean abs 0.00593   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0781  mean abs 0.01442
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00554   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00230   (by error, pooled)
-
-frame 92: corr 0.999957  max abs 0.2812
-    action                   corr 0.999995  max abs   0.0117  mean abs 0.00358   (by error, pooled)
-    desire_pred              corr 0.999967  max abs   0.0625  mean abs 0.02961
-    desire_state             corr 0.999972  max abs   0.1562  mean abs 0.07922   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1406  mean abs 0.01247
-    lane_lines               corr 0.999979  max abs   0.0508  mean abs 0.01284
-    lane_lines_prob          corr 0.999871  max abs   0.1016  mean abs 0.04956   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.2812  mean abs 0.02249
-    lead_prob                corr 0.999993  max abs   0.1270  mean abs 0.11068   (by error, pooled)
-    meta                     corr 0.999877  max abs   0.1221  mean abs 0.04130
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00477
-    pose                     corr 0.999996  max abs   0.0273  mean abs 0.00755   (by error, pooled)
-    road_edges               corr 0.999983  max abs   0.0547  mean abs 0.01250
-    road_transform           corr 0.999995  max abs   0.0312  mean abs 0.00717   (by error, pooled)
-    wide_from_device_euler   corr 0.999993  max abs   0.0312  mean abs 0.00916   (by error, pooled)
-
-frame 93: corr 0.999964  max abs 0.2656
-    action                   corr 0.999981  max abs   0.0215  mean abs 0.01099   (by error, pooled)
-    desire_pred              corr 0.999945  max abs   0.0742  mean abs 0.02887
-    desire_state             corr 0.999988  max abs   0.2656  mean abs 0.13892   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1895  mean abs 0.01406
-    lane_lines               corr 0.999968  max abs   0.1484  mean abs 0.01591
-    lane_lines_prob          corr 0.999764  max abs   0.1172  mean abs 0.05365   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.2500  mean abs 0.01816
-    lead_prob                corr 0.999967  max abs   0.1289  mean abs 0.10742   (by error, pooled)
-    meta                     corr 0.999924  max abs   0.0586  mean abs 0.02599
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0938  mean abs 0.00600
-    pose                     corr 0.999987  max abs   0.0391  mean abs 0.00918   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.1562  mean abs 0.01684
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00882   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0195  mean abs 0.00754   (by error, pooled)
-
-frame 94: corr 0.999953  max abs 0.3281
-    action                   corr 0.999966  max abs   0.0332  mean abs 0.01728   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0576  mean abs 0.02705
-    desire_state             corr 0.999938  max abs   0.3281  mean abs 0.16232   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2441  mean abs 0.01358
-    lane_lines               corr 0.999950  max abs   0.1250  mean abs 0.01747
-    lane_lines_prob          corr 0.999927  max abs   0.1055  mean abs 0.03625   (by error, pooled)
-    lead                     corr 0.999990  max abs   0.2188  mean abs 0.03006
-    lead_prob                corr 0.999986  max abs   0.1157  mean abs 0.08781   (by error, pooled)
-    meta                     corr 0.999953  max abs   0.0781  mean abs 0.03182
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999970  max abs   0.2656  mean abs 0.01275
-    pose                     corr 0.999957  max abs   0.0762  mean abs 0.01822   (by error, pooled)
-    road_edges               corr 0.999952  max abs   0.0898  mean abs 0.01856
-    road_transform           corr 0.999997  max abs   0.0352  mean abs 0.00948   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0254  mean abs 0.00721   (by error, pooled)
-
-frame 95: corr 0.999938  max abs 0.4082
-    action                   corr 0.999969  max abs   0.0303  mean abs 0.01691   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0879  mean abs 0.02904
-    desire_state             corr 0.999939  max abs   0.4082  mean abs 0.19031   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2344  mean abs 0.01422
-    lane_lines               corr 0.999959  max abs   0.0547  mean abs 0.01523
-    lane_lines_prob          corr 0.999916  max abs   0.1211  mean abs 0.05078   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.3750  mean abs 0.05143
-    lead_prob                corr 0.999944  max abs   0.0874  mean abs 0.06909   (by error, pooled)
-    meta                     corr 0.999956  max abs   0.0586  mean abs 0.02371
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999955  max abs   0.3125  mean abs 0.01530
-    pose                     corr 0.999956  max abs   0.0820  mean abs 0.01721   (by error, pooled)
-    road_edges               corr 0.999957  max abs   0.0703  mean abs 0.01671
-    road_transform           corr 0.999996  max abs   0.0391  mean abs 0.00905   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0117  mean abs 0.00428   (by error, pooled)
-
-frame 96: corr 0.999974  max abs 0.6875
-    action                   corr 0.999935  max abs   0.0173  mean abs 0.00852   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0781  mean abs 0.02634
-    desire_state             corr 0.999994  max abs   0.1562  mean abs 0.06445   (by error, pooled)
-    hidden_state             corr 0.999941  max abs   0.2266  mean abs 0.01531
-    lane_lines               corr 0.999951  max abs   0.1055  mean abs 0.01672
-    lane_lines_prob          corr 0.999990  max abs   0.0669  mean abs 0.04776   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.6875  mean abs 0.05516
-    lead_prob                corr 0.999996  max abs   0.0723  mean abs 0.06380   (by error, pooled)
-    meta                     corr 0.999932  max abs   0.0693  mean abs 0.02632
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1875  mean abs 0.00871
-    pose                     corr 0.999994  max abs   0.0469  mean abs 0.01649   (by error, pooled)
-    road_edges               corr 0.999946  max abs   0.0938  mean abs 0.02024
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01207   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0273  mean abs 0.00922   (by error, pooled)
-
-frame 97: corr 0.999982  max abs 0.4688
-    action                   corr 0.999967  max abs   0.0128  mean abs 0.00407   (by error, pooled)
-    desire_pred              corr 0.999949  max abs   0.0645  mean abs 0.02573
-    desire_state             corr 0.999995  max abs   0.1406  mean abs 0.06787   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1719  mean abs 0.01441
-    lane_lines               corr 0.999932  max abs   0.0606  mean abs 0.01968
-    lane_lines_prob          corr 0.999916  max abs   0.1445  mean abs 0.05452   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.4375  mean abs 0.02955
-    lead_prob                corr 0.999999  max abs   0.0566  mean abs 0.05046   (by error, pooled)
-    meta                     corr 0.999821  max abs   0.1304  mean abs 0.04943
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.4688  mean abs 0.00954
-    pose                     corr 0.999998  max abs   0.0332  mean abs 0.00943   (by error, pooled)
-    road_edges               corr 0.999859  max abs   0.1133  mean abs 0.03283
-    road_transform           corr 0.999993  max abs   0.0391  mean abs 0.01045   (by error, pooled)
-    wide_from_device_euler   corr 0.999992  max abs   0.0234  mean abs 0.00787   (by error, pooled)
-
-frame 98: corr 0.999965  max abs 0.2734
-    action                   corr 0.999956  max abs   0.0273  mean abs 0.01571   (by error, pooled)
-    desire_pred              corr 0.999915  max abs   0.0781  mean abs 0.03284
-    desire_state             corr 0.999988  max abs   0.2734  mean abs 0.11719   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.2268  mean abs 0.01300
-    lane_lines               corr 0.999953  max abs   0.1113  mean abs 0.01482
-    lane_lines_prob          corr 0.999880  max abs   0.1016  mean abs 0.04564   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.1562  mean abs 0.02120
-    lead_prob                corr 1.000000  max abs   0.1094  mean abs 0.09202   (by error, pooled)
-    meta                     corr 0.999857  max abs   0.1113  mean abs 0.04895
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999991  max abs   0.0938  mean abs 0.01117
-    pose                     corr 0.999989  max abs   0.0288  mean abs 0.01237   (by error, pooled)
-    road_edges               corr 0.999928  max abs   0.0703  mean abs 0.02029
-    road_transform           corr 0.999998  max abs   0.0312  mean abs 0.00760   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0352  mean abs 0.01018   (by error, pooled)
-
-frame 99: corr 0.999963  max abs 0.2969
-    action                   corr 0.999987  max abs   0.0205  mean abs 0.00918   (by error, pooled)
-    desire_pred              corr 0.999938  max abs   0.0840  mean abs 0.03076
-    desire_state             corr 0.999991  max abs   0.2812  mean abs 0.08911   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01180
-    lane_lines               corr 0.999977  max abs   0.0410  mean abs 0.01467
-    lane_lines_prob          corr 0.999966  max abs   0.1289  mean abs 0.05359   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.2969  mean abs 0.02333
-    lead_prob                corr 0.999997  max abs   0.1367  mean abs 0.10441   (by error, pooled)
-    meta                     corr 0.999887  max abs   0.1074  mean abs 0.04481
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00535
-    pose                     corr 0.999995  max abs   0.0210  mean abs 0.00590   (by error, pooled)
-    road_edges               corr 0.999970  max abs   0.0508  mean abs 0.01679
-    road_transform           corr 0.999999  max abs   0.0312  mean abs 0.00702   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0137  mean abs 0.00458   (by error, pooled)
-
-frame 100: corr 0.999960  max abs 0.3140
-    action                   corr 0.999999  max abs   0.0068  mean abs 0.00314   (by error, pooled)
-    desire_pred              corr 0.999970  max abs   0.0518  mean abs 0.02459
-    desire_state             corr 0.999997  max abs   0.0938  mean abs 0.03195   (by error, pooled)
-    hidden_state             corr 0.999957  max abs   0.1230  mean abs 0.01118
-    lane_lines               corr 0.999979  max abs   0.0430  mean abs 0.01357
-    lane_lines_prob          corr 0.999985  max abs   0.1094  mean abs 0.05763   (by error, pooled)
-    lead                     corr 0.999643  max abs   0.3140  mean abs 0.02712
-    lead_prob                corr 0.999987  max abs   0.1484  mean abs 0.10547   (by error, pooled)
-    meta                     corr 0.999940  max abs   0.1025  mean abs 0.04166
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00346
-    pose                     corr 0.999996  max abs   0.0202  mean abs 0.00544   (by error, pooled)
-    road_edges               corr 0.999976  max abs   0.0586  mean abs 0.01420
-    road_transform           corr 0.999996  max abs   0.0195  mean abs 0.00505   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0176  mean abs 0.00522   (by error, pooled)
-
-frame 101: corr 0.999937  max abs 0.6641
-    action                   corr 0.999995  max abs   0.0117  mean abs 0.00354   (by error, pooled)
-    desire_pred              corr 0.999969  max abs   0.0518  mean abs 0.02815
-    desire_state             corr 0.999997  max abs   0.2031  mean abs 0.10266   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1328  mean abs 0.01220
-    lane_lines               corr 0.999969  max abs   0.0879  mean abs 0.01564
-    lane_lines_prob          corr 0.999955  max abs   0.1211  mean abs 0.05682   (by error, pooled)
-    lead                     corr 0.999883  max abs   0.6641  mean abs 0.05588
-    lead_prob                corr 0.999992  max abs   0.1055  mean abs 0.09163   (by error, pooled)
-    meta                     corr 0.999959  max abs   0.0684  mean abs 0.02910
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0469  mean abs 0.00550
-    pose                     corr 0.999996  max abs   0.0234  mean abs 0.00685   (by error, pooled)
-    road_edges               corr 0.999976  max abs   0.0977  mean abs 0.01863
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00360   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00559   (by error, pooled)
-
-frame 102: corr 0.999960  max abs 0.4375
-    action                   corr 0.999981  max abs   0.0176  mean abs 0.01045   (by error, pooled)
-    desire_pred              corr 0.999954  max abs   0.0625  mean abs 0.02755
-    desire_state             corr 0.999986  max abs   0.2500  mean abs 0.08447   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2061  mean abs 0.01456
-    lane_lines               corr 0.999943  max abs   0.0977  mean abs 0.01675
-    lane_lines_prob          corr 0.999863  max abs   0.1328  mean abs 0.04132   (by error, pooled)
-    lead                     corr 0.999993  max abs   0.4375  mean abs 0.03030
-    lead_prob                corr 0.999967  max abs   0.1816  mean abs 0.15218   (by error, pooled)
-    meta                     corr 0.999813  max abs   0.1104  mean abs 0.03652
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1406  mean abs 0.00664
-    pose                     corr 0.999993  max abs   0.0225  mean abs 0.00640   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.1016  mean abs 0.01384
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00606   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0176  mean abs 0.00754   (by error, pooled)
-
-frame 103: corr 0.999953  max abs 0.3125
-    action                   corr 0.999974  max abs   0.0312  mean abs 0.01668   (by error, pooled)
-    desire_pred              corr 0.999972  max abs   0.0547  mean abs 0.01977
-    desire_state             corr 0.999959  max abs   0.3125  mean abs 0.14893   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2480  mean abs 0.01366
-    lane_lines               corr 0.999964  max abs   0.0508  mean abs 0.01451
-    lane_lines_prob          corr 0.999887  max abs   0.0898  mean abs 0.03701   (by error, pooled)
-    lead                     corr 0.999976  max abs   0.1875  mean abs 0.02543
-    lead_prob                corr 0.999992  max abs   0.1816  mean abs 0.14639   (by error, pooled)
-    meta                     corr 0.999946  max abs   0.0645  mean abs 0.02294
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999969  max abs   0.1719  mean abs 0.01478
-    pose                     corr 0.999950  max abs   0.0918  mean abs 0.01696   (by error, pooled)
-    road_edges               corr 0.999969  max abs   0.0703  mean abs 0.01472
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00523   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0098  mean abs 0.00459   (by error, pooled)
-
-frame 104: corr 0.999931  max abs 0.4531
-    action                   corr 0.999925  max abs   0.0488  mean abs 0.02509   (by error, pooled)
-    desire_pred              corr 0.999900  max abs   0.1133  mean abs 0.03461
-    desire_state             corr 0.999958  max abs   0.4531  mean abs 0.17236   (by error, pooled)
-    hidden_state             corr 0.999937  max abs   0.3125  mean abs 0.01452
-    lane_lines               corr 0.999932  max abs   0.1484  mean abs 0.01686
-    lane_lines_prob          corr 0.999916  max abs   0.0781  mean abs 0.03748   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.4219  mean abs 0.05753
-    lead_prob                corr 0.999988  max abs   0.1245  mean abs 0.10400   (by error, pooled)
-    meta                     corr 0.999924  max abs   0.0684  mean abs 0.02939
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999922  max abs   0.3203  mean abs 0.01911
-    pose                     corr 0.999917  max abs   0.1250  mean abs 0.02585   (by error, pooled)
-    road_edges               corr 0.999948  max abs   0.1367  mean abs 0.01656
-    road_transform           corr 0.999996  max abs   0.0273  mean abs 0.00823   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0156  mean abs 0.00626   (by error, pooled)
-
-frame 105: corr 0.999974  max abs 0.5000
-    action                   corr 0.999913  max abs   0.0165  mean abs 0.00865   (by error, pooled)
-    desire_pred              corr 0.999969  max abs   0.0625  mean abs 0.02130
-    desire_state             corr 0.999995  max abs   0.1875  mean abs 0.10400   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01515
-    lane_lines               corr 0.999951  max abs   0.0859  mean abs 0.01761
-    lane_lines_prob          corr 0.999951  max abs   0.1211  mean abs 0.04994   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.5000  mean abs 0.04795
-    lead_prob                corr 0.999998  max abs   0.0432  mean abs 0.03849   (by error, pooled)
-    meta                     corr 0.999937  max abs   0.0713  mean abs 0.02498
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.2188  mean abs 0.00823
-    pose                     corr 0.999995  max abs   0.0625  mean abs 0.01456   (by error, pooled)
-    road_edges               corr 0.999936  max abs   0.1016  mean abs 0.02360
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00979   (by error, pooled)
-    wide_from_device_euler   corr 0.999979  max abs   0.0586  mean abs 0.01897   (by error, pooled)
-
-frame 106: corr 0.999980  max abs 0.2812
-    action                   corr 0.999940  max abs   0.0161  mean abs 0.00698   (by error, pooled)
-    desire_pred              corr 0.999941  max abs   0.0664  mean abs 0.03064
-    desire_state             corr 0.999992  max abs   0.2812  mean abs 0.12402   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2051  mean abs 0.01456
-    lane_lines               corr 0.999937  max abs   0.0898  mean abs 0.01915
-    lane_lines_prob          corr 0.999958  max abs   0.1367  mean abs 0.04807   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.2500  mean abs 0.02541
-    lead_prob                corr 0.999987  max abs   0.0225  mean abs 0.01662   (by error, pooled)
-    meta                     corr 0.999880  max abs   0.0974  mean abs 0.04307
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.2188  mean abs 0.00707
-    pose                     corr 0.999998  max abs   0.0371  mean abs 0.01430   (by error, pooled)
-    road_edges               corr 0.999895  max abs   0.0840  mean abs 0.02671
-    road_transform           corr 0.999997  max abs   0.0312  mean abs 0.00865   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0234  mean abs 0.00527   (by error, pooled)
-
-frame 107: corr 0.999963  max abs 0.2578
-    action                   corr 0.999936  max abs   0.0254  mean abs 0.01272   (by error, pooled)
-    desire_pred              corr 0.999894  max abs   0.0859  mean abs 0.04031
-    desire_state             corr 0.999993  max abs   0.2344  mean abs 0.13184   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.2578  mean abs 0.01329
-    lane_lines               corr 0.999950  max abs   0.0684  mean abs 0.01641
-    lane_lines_prob          corr 0.999886  max abs   0.1328  mean abs 0.04726   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2188  mean abs 0.02691
-    lead_prob                corr 0.999999  max abs   0.0918  mean abs 0.08065   (by error, pooled)
-    meta                     corr 0.999884  max abs   0.0938  mean abs 0.04264
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999992  max abs   0.1250  mean abs 0.00996
-    pose                     corr 0.999991  max abs   0.0273  mean abs 0.01014   (by error, pooled)
-    road_edges               corr 0.999945  max abs   0.0547  mean abs 0.01736
-    road_transform           corr 0.999999  max abs   0.0352  mean abs 0.01168   (by error, pooled)
-    wide_from_device_euler   corr 0.999990  max abs   0.0547  mean abs 0.01050   (by error, pooled)
-
-frame 108: corr 0.999953  max abs 0.4531
-    action                   corr 0.999987  max abs   0.0195  mean abs 0.00795   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0625  mean abs 0.02743
-    desire_state             corr 0.999997  max abs   0.1406  mean abs 0.09192   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1133  mean abs 0.01158
-    lane_lines               corr 0.999943  max abs   0.1113  mean abs 0.01750
-    lane_lines_prob          corr 0.999988  max abs   0.0781  mean abs 0.03223   (by error, pooled)
-    lead                     corr 0.999908  max abs   0.4531  mean abs 0.03446
-    lead_prob                corr 0.999998  max abs   0.1406  mean abs 0.11532   (by error, pooled)
-    meta                     corr 0.999873  max abs   0.1250  mean abs 0.05239
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.0938  mean abs 0.00566
-    pose                     corr 0.999994  max abs   0.0244  mean abs 0.00634   (by error, pooled)
-    road_edges               corr 0.999941  max abs   0.1289  mean abs 0.01927
-    road_transform           corr 0.999996  max abs   0.0352  mean abs 0.00839   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00524   (by error, pooled)
-
-frame 109: corr 0.999954  max abs 0.4180
-    action                   corr 0.999988  max abs   0.0176  mean abs 0.00489   (by error, pooled)
-    desire_pred              corr 0.999974  max abs   0.0513  mean abs 0.02330
-    desire_state             corr 0.999998  max abs   0.1250  mean abs 0.07495   (by error, pooled)
-    hidden_state             corr 0.999956  max abs   0.1328  mean abs 0.01146
-    lane_lines               corr 0.999977  max abs   0.0391  mean abs 0.01328
-    lane_lines_prob          corr 0.999983  max abs   0.0840  mean abs 0.05257   (by error, pooled)
-    lead                     corr 0.999588  max abs   0.4180  mean abs 0.03676
-    lead_prob                corr 0.999994  max abs   0.1133  mean abs 0.08333   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0938  mean abs 0.03899
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0547  mean abs 0.00356
-    pose                     corr 0.999997  max abs   0.0146  mean abs 0.00483   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0664  mean abs 0.01521
-    road_transform           corr 0.999999  max abs   0.0117  mean abs 0.00294   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0156  mean abs 0.00524   (by error, pooled)
-
-frame 110: corr 0.999944  max abs 0.6172
-    action                   corr 0.999995  max abs   0.0103  mean abs 0.00399   (by error, pooled)
-    desire_pred              corr 0.999978  max abs   0.0469  mean abs 0.02397
-    desire_state             corr 0.999998  max abs   0.1562  mean abs 0.09961   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.1367  mean abs 0.01232
-    lane_lines               corr 0.999978  max abs   0.0430  mean abs 0.01240
-    lane_lines_prob          corr 0.999844  max abs   0.1562  mean abs 0.06067   (by error, pooled)
-    lead                     corr 0.999893  max abs   0.6172  mean abs 0.05073
-    lead_prob                corr 1.000000  max abs   0.1172  mean abs 0.09749   (by error, pooled)
-    meta                     corr 0.999939  max abs   0.0791  mean abs 0.03100
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00384
-    pose                     corr 0.999997  max abs   0.0234  mean abs 0.00671   (by error, pooled)
-    road_edges               corr 0.999972  max abs   0.0508  mean abs 0.01545
-    road_transform           corr 0.999998  max abs   0.0156  mean abs 0.00384   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00461   (by error, pooled)
-
-frame 111: corr 0.999959  max abs 0.5312
-    action                   corr 0.999960  max abs   0.0195  mean abs 0.01176   (by error, pooled)
-    desire_pred              corr 0.999920  max abs   0.0840  mean abs 0.03464
-    desire_state             corr 0.999993  max abs   0.2812  mean abs 0.11523   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.2031  mean abs 0.01398
-    lane_lines               corr 0.999968  max abs   0.1172  mean abs 0.01418
-    lane_lines_prob          corr 0.999807  max abs   0.1562  mean abs 0.05011   (by error, pooled)
-    lead                     corr 0.999984  max abs   0.5312  mean abs 0.03607
-    lead_prob                corr 0.999997  max abs   0.1406  mean abs 0.12394   (by error, pooled)
-    meta                     corr 0.999862  max abs   0.0845  mean abs 0.03692
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999995  max abs   0.1094  mean abs 0.00736
-    pose                     corr 0.999982  max abs   0.0488  mean abs 0.01071   (by error, pooled)
-    road_edges               corr 0.999967  max abs   0.1064  mean abs 0.01599
-    road_transform           corr 0.999999  max abs   0.0195  mean abs 0.00743   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0312  mean abs 0.01372   (by error, pooled)
-
-frame 112: corr 0.999948  max abs 0.6094
-    action                   corr 0.999985  max abs   0.0215  mean abs 0.01196   (by error, pooled)
-    desire_pred              corr 0.999904  max abs   0.0977  mean abs 0.03555
-    desire_state             corr 0.999985  max abs   0.2812  mean abs 0.10107   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1875  mean abs 0.01316
-    lane_lines               corr 0.999961  max abs   0.1016  mean abs 0.01541
-    lane_lines_prob          corr 0.999942  max abs   0.1289  mean abs 0.05780   (by error, pooled)
-    lead                     corr 0.999869  max abs   0.6094  mean abs 0.04577
-    lead_prob                corr 0.999958  max abs   0.1523  mean abs 0.13216   (by error, pooled)
-    meta                     corr 0.999923  max abs   0.0830  mean abs 0.03416
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999989  max abs   0.1406  mean abs 0.00782
-    pose                     corr 0.999979  max abs   0.0488  mean abs 0.01189   (by error, pooled)
-    road_edges               corr 0.999963  max abs   0.1367  mean abs 0.01753
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.01037   (by error, pooled)
-    wide_from_device_euler   corr 1.000000  max abs   0.0273  mean abs 0.01014   (by error, pooled)
-
-frame 113: corr 0.999945  max abs 0.3906
-    action                   corr 0.999976  max abs   0.0215  mean abs 0.01273   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0742  mean abs 0.02438
-    desire_state             corr 0.999966  max abs   0.3906  mean abs 0.18146   (by error, pooled)
-    hidden_state             corr 0.999944  max abs   0.2207  mean abs 0.01415
-    lane_lines               corr 0.999949  max abs   0.0703  mean abs 0.01507
-    lane_lines_prob          corr 0.999955  max abs   0.1836  mean abs 0.08813   (by error, pooled)
-    lead                     corr 0.999950  max abs   0.3594  mean abs 0.03518
-    lead_prob                corr 0.999997  max abs   0.1204  mean abs 0.10881   (by error, pooled)
-    meta                     corr 0.999959  max abs   0.0859  mean abs 0.02720
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999968  max abs   0.2500  mean abs 0.01138
-    pose                     corr 0.999973  max abs   0.0742  mean abs 0.01349   (by error, pooled)
-    road_edges               corr 0.999962  max abs   0.0732  mean abs 0.01426
-    road_transform           corr 0.999997  max abs   0.0469  mean abs 0.01157   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0352  mean abs 0.00819   (by error, pooled)
-
-frame 114: corr 0.999977  max abs 0.2500
-    action                   corr 0.999948  max abs   0.0137  mean abs 0.00829   (by error, pooled)
-    desire_pred              corr 0.999957  max abs   0.0723  mean abs 0.02789
-    desire_state             corr 0.999999  max abs   0.0938  mean abs 0.04590   (by error, pooled)
-    hidden_state             corr 0.999945  max abs   0.2266  mean abs 0.01504
-    lane_lines               corr 0.999955  max abs   0.0742  mean abs 0.01699
-    lane_lines_prob          corr 0.999911  max abs   0.1016  mean abs 0.04504   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.2500  mean abs 0.02027
-    lead_prob                corr 1.000000  max abs   0.0273  mean abs 0.02344   (by error, pooled)
-    meta                     corr 0.999923  max abs   0.0771  mean abs 0.02855
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1250  mean abs 0.00655
-    pose                     corr 0.999997  max abs   0.0391  mean abs 0.01290   (by error, pooled)
-    road_edges               corr 0.999938  max abs   0.1055  mean abs 0.02351
-    road_transform           corr 0.999994  max abs   0.0391  mean abs 0.01192   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0312  mean abs 0.01053   (by error, pooled)
-
-frame 115: corr 0.999975  max abs 0.1973
-    action                   corr 0.999970  max abs   0.0099  mean abs 0.00616   (by error, pooled)
-    desire_pred              corr 0.999939  max abs   0.0703  mean abs 0.02835
-    desire_state             corr 0.999996  max abs   0.1875  mean abs 0.05118   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.1973  mean abs 0.01474
-    lane_lines               corr 0.999930  max abs   0.0828  mean abs 0.01965
-    lane_lines_prob          corr 0.999954  max abs   0.1484  mean abs 0.05995   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.1875  mean abs 0.02071
-    lead_prob                corr 1.000000  max abs   0.0078  mean abs 0.00602   (by error, pooled)
-    meta                     corr 0.999873  max abs   0.0957  mean abs 0.04756
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1406  mean abs 0.00567
-    pose                     corr 0.999997  max abs   0.0312  mean abs 0.01022   (by error, pooled)
-    road_edges               corr 0.999918  max abs   0.0801  mean abs 0.02640
-    road_transform           corr 0.999991  max abs   0.0430  mean abs 0.01060   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0195  mean abs 0.00495   (by error, pooled)
-
-frame 116: corr 0.999961  max abs 0.2969
-    action                   corr 0.999985  max abs   0.0215  mean abs 0.01168   (by error, pooled)
-    desire_pred              corr 0.999968  max abs   0.0664  mean abs 0.02393
-    desire_state             corr 0.999998  max abs   0.1094  mean abs 0.04852   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2087  mean abs 0.01298
-    lane_lines               corr 0.999968  max abs   0.0566  mean abs 0.01403
-    lane_lines_prob          corr 0.999986  max abs   0.0347  mean abs 0.01764   (by error, pooled)
-    lead                     corr 0.999980  max abs   0.2969  mean abs 0.02488
-    lead_prob                corr 0.999984  max abs   0.1191  mean abs 0.10319   (by error, pooled)
-    meta                     corr 0.999928  max abs   0.0771  mean abs 0.02890
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999994  max abs   0.1094  mean abs 0.00775
-    pose                     corr 0.999994  max abs   0.0234  mean abs 0.00745   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0508  mean abs 0.01542
-    road_transform           corr 0.999995  max abs   0.0352  mean abs 0.00904   (by error, pooled)
-    wide_from_device_euler   corr 0.999998  max abs   0.0195  mean abs 0.00690   (by error, pooled)
-
-frame 117: corr 0.999954  max abs 0.3789
-    action                   corr 0.999992  max abs   0.0166  mean abs 0.00689   (by error, pooled)
-    desire_pred              corr 0.999963  max abs   0.0645  mean abs 0.02583
-    desire_state             corr 0.999997  max abs   0.1445  mean abs 0.05884   (by error, pooled)
-    hidden_state             corr 0.999954  max abs   0.1064  mean abs 0.01166
-    lane_lines               corr 0.999947  max abs   0.0957  mean abs 0.01594
-    lane_lines_prob          corr 0.999974  max abs   0.0898  mean abs 0.03943   (by error, pooled)
-    lead                     corr 0.999884  max abs   0.3789  mean abs 0.02770
-    lead_prob                corr 0.999992  max abs   0.1133  mean abs 0.09017   (by error, pooled)
-    meta                     corr 0.999927  max abs   0.0957  mean abs 0.03598
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999997  max abs   0.0625  mean abs 0.00442
-    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00573   (by error, pooled)
-    road_edges               corr 0.999919  max abs   0.1562  mean abs 0.02071
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00465   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0273  mean abs 0.00556   (by error, pooled)
-
-frame 118: corr 0.999960  max abs 0.2109
-    action                   corr 0.999993  max abs   0.0146  mean abs 0.00535   (by error, pooled)
-    desire_pred              corr 0.999964  max abs   0.0527  mean abs 0.02887
-    desire_state             corr 0.999994  max abs   0.1719  mean abs 0.07617   (by error, pooled)
-    hidden_state             corr 0.999955  max abs   0.1348  mean abs 0.01152
-    lane_lines               corr 0.999978  max abs   0.0469  mean abs 0.01234
-    lane_lines_prob          corr 0.999978  max abs   0.1016  mean abs 0.04746   (by error, pooled)
-    lead                     corr 0.999812  max abs   0.2109  mean abs 0.02105
-    lead_prob                corr 1.000000  max abs   0.0488  mean abs 0.03874   (by error, pooled)
-    meta                     corr 0.999942  max abs   0.0977  mean abs 0.03279
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0469  mean abs 0.00391
-    pose                     corr 0.999996  max abs   0.0156  mean abs 0.00621   (by error, pooled)
-    road_edges               corr 0.999973  max abs   0.0586  mean abs 0.01422
-    road_transform           corr 0.999996  max abs   0.0234  mean abs 0.00684   (by error, pooled)
-    wide_from_device_euler   corr 0.999996  max abs   0.0195  mean abs 0.00588   (by error, pooled)
-
-frame 119: corr 0.999951  max abs 0.4375
-    action                   corr 0.999996  max abs   0.0098  mean abs 0.00417   (by error, pooled)
-    desire_pred              corr 0.999960  max abs   0.0938  mean abs 0.03431
-    desire_state             corr 0.999997  max abs   0.0898  mean abs 0.04102   (by error, pooled)
-    hidden_state             corr 0.999950  max abs   0.1328  mean abs 0.01282
-    lane_lines               corr 0.999970  max abs   0.0703  mean abs 0.01402
-    lane_lines_prob          corr 0.999878  max abs   0.1172  mean abs 0.05511   (by error, pooled)
-    lead                     corr 0.999853  max abs   0.4375  mean abs 0.03405
-    lead_prob                corr 0.999991  max abs   0.0811  mean abs 0.06934   (by error, pooled)
-    meta                     corr 0.999936  max abs   0.0942  mean abs 0.02893
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1094  mean abs 0.00401
-    pose                     corr 0.999998  max abs   0.0195  mean abs 0.00472   (by error, pooled)
-    road_edges               corr 0.999975  max abs   0.0898  mean abs 0.01303
-    road_transform           corr 0.999997  max abs   0.0195  mean abs 0.00474   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0215  mean abs 0.00657   (by error, pooled)
-
-frame 120: corr 0.999960  max abs 0.4062
-    action                   corr 0.999989  max abs   0.0176  mean abs 0.00978   (by error, pooled)
-    desire_pred              corr 0.999958  max abs   0.0586  mean abs 0.02430
-    desire_state             corr 0.999991  max abs   0.4062  mean abs 0.12085   (by error, pooled)
-    hidden_state             corr 0.999951  max abs   0.2031  mean abs 0.01419
-    lane_lines               corr 0.999974  max abs   0.0508  mean abs 0.01306
-    lane_lines_prob          corr 0.999733  max abs   0.1191  mean abs 0.06177   (by error, pooled)
-    lead                     corr 0.999994  max abs   0.2031  mean abs 0.01690
-    lead_prob                corr 0.999973  max abs   0.1289  mean abs 0.10352   (by error, pooled)
-    meta                     corr 0.999857  max abs   0.1025  mean abs 0.03659
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.1406  mean abs 0.00584
-    pose                     corr 0.999994  max abs   0.0225  mean abs 0.00426   (by error, pooled)
-    road_edges               corr 0.999980  max abs   0.1094  mean abs 0.01329
-    road_transform           corr 0.999993  max abs   0.0352  mean abs 0.00621   (by error, pooled)
-    wide_from_device_euler   corr 0.999995  max abs   0.0215  mean abs 0.00591   (by error, pooled)
-
-frame 121: corr 0.999962  max abs 0.2500
-    action                   corr 0.999990  max abs   0.0156  mean abs 0.00754   (by error, pooled)
-    desire_pred              corr 0.999955  max abs   0.0703  mean abs 0.02387
-    desire_state             corr 0.999997  max abs   0.1250  mean abs 0.07739   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1891  mean abs 0.01339
-    lane_lines               corr 0.999962  max abs   0.0781  mean abs 0.01564
-    lane_lines_prob          corr 0.999968  max abs   0.1016  mean abs 0.03210   (by error, pooled)
-    lead                     corr 0.999974  max abs   0.2500  mean abs 0.02315
-    lead_prob                corr 0.999928  max abs   0.1523  mean abs 0.11491   (by error, pooled)
-    meta                     corr 0.999944  max abs   0.0645  mean abs 0.02519
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0625  mean abs 0.00574
-    pose                     corr 0.999988  max abs   0.0312  mean abs 0.00842   (by error, pooled)
-    road_edges               corr 0.999974  max abs   0.0469  mean abs 0.01429
-    road_transform           corr 0.999998  max abs   0.0273  mean abs 0.00516   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0117  mean abs 0.00232   (by error, pooled)
-
-frame 122: corr 0.999948  max abs 0.2969
-    action                   corr 0.999968  max abs   0.0312  mean abs 0.01652   (by error, pooled)
-    desire_pred              corr 0.999927  max abs   0.0703  mean abs 0.03409
-    desire_state             corr 0.999990  max abs   0.1875  mean abs 0.08521   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2148  mean abs 0.01412
-    lane_lines               corr 0.999949  max abs   0.1113  mean abs 0.01569
-    lane_lines_prob          corr 0.999798  max abs   0.1562  mean abs 0.05511   (by error, pooled)
-    lead                     corr 0.999995  max abs   0.2500  mean abs 0.03205
-    lead_prob                corr 1.000000  max abs   0.1250  mean abs 0.10596   (by error, pooled)
-    meta                     corr 0.999950  max abs   0.0674  mean abs 0.02443
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999974  max abs   0.2969  mean abs 0.01309
-    pose                     corr 0.999968  max abs   0.0723  mean abs 0.01480   (by error, pooled)
-    road_edges               corr 0.999959  max abs   0.0664  mean abs 0.01521
-    road_transform           corr 0.999998  max abs   0.0352  mean abs 0.00962   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.01079   (by error, pooled)
-
-frame 123: corr 0.999976  max abs 0.2344
-    action                   corr 0.999952  max abs   0.0132  mean abs 0.00711   (by error, pooled)
-    desire_pred              corr 0.999922  max abs   0.0938  mean abs 0.03134
-    desire_state             corr 0.999997  max abs   0.2344  mean abs 0.12500   (by error, pooled)
-    hidden_state             corr 0.999943  max abs   0.2227  mean abs 0.01535
-    lane_lines               corr 0.999956  max abs   0.1992  mean abs 0.01691
-    lane_lines_prob          corr 0.999977  max abs   0.0742  mean abs 0.03278   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.0938  mean abs 0.01147
-    lead_prob                corr 0.999993  max abs   0.0801  mean abs 0.06852   (by error, pooled)
-    meta                     corr 0.999941  max abs   0.0820  mean abs 0.02964
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0938  mean abs 0.00542
-    pose                     corr 0.999996  max abs   0.0391  mean abs 0.01335   (by error, pooled)
-    road_edges               corr 0.999917  max abs   0.1191  mean abs 0.02572
-    road_transform           corr 0.999998  max abs   0.0508  mean abs 0.01346   (by error, pooled)
-    wide_from_device_euler   corr 0.999994  max abs   0.0664  mean abs 0.01964   (by error, pooled)
-
-frame 124: corr 0.999980  max abs 0.4375
-    action                   corr 0.999969  max abs   0.0110  mean abs 0.00586   (by error, pooled)
-    desire_pred              corr 0.999933  max abs   0.0781  mean abs 0.02951
-    desire_state             corr 0.999995  max abs   0.2188  mean abs 0.07031   (by error, pooled)
-    hidden_state             corr 0.999952  max abs   0.1875  mean abs 0.01447
-    lane_lines               corr 0.999927  max abs   0.0819  mean abs 0.02048
-    lane_lines_prob          corr 0.999910  max abs   0.1133  mean abs 0.04207   (by error, pooled)
-    lead                     corr 1.000000  max abs   0.4375  mean abs 0.03287
-    lead_prob                corr 1.000000  max abs   0.0859  mean abs 0.06250   (by error, pooled)
-    meta                     corr 0.999785  max abs   0.1270  mean abs 0.05262
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.1562  mean abs 0.00628
-    pose                     corr 0.999998  max abs   0.0312  mean abs 0.01204   (by error, pooled)
-    road_edges               corr 0.999824  max abs   0.0977  mean abs 0.03520
-    road_transform           corr 0.999993  max abs   0.0273  mean abs 0.00906   (by error, pooled)
-    wide_from_device_euler   corr 0.999999  max abs   0.0078  mean abs 0.00298   (by error, pooled)
-
-frame 125: corr 0.999957  max abs 0.3438
-    action                   corr 0.999962  max abs   0.0244  mean abs 0.01410   (by error, pooled)
-    desire_pred              corr 0.999950  max abs   0.0586  mean abs 0.02645
-    desire_state             corr 0.999989  max abs   0.2188  mean abs 0.09778   (by error, pooled)
-    hidden_state             corr 0.999949  max abs   0.2255  mean abs 0.01294
-    lane_lines               corr 0.999959  max abs   0.0918  mean abs 0.01333
-    lane_lines_prob          corr 0.999903  max abs   0.0923  mean abs 0.05426   (by error, pooled)
-    lead                     corr 0.999999  max abs   0.3438  mean abs 0.03918
-    lead_prob                corr 0.999986  max abs   0.2031  mean abs 0.16895   (by error, pooled)
-    meta                     corr 0.999932  max abs   0.0703  mean abs 0.03028
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999988  max abs   0.1953  mean abs 0.01131
-    pose                     corr 0.999985  max abs   0.0342  mean abs 0.01261   (by error, pooled)
-    road_edges               corr 0.999922  max abs   0.0938  mean abs 0.02053
-    road_transform           corr 1.000000  max abs   0.0117  mean abs 0.00393   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0352  mean abs 0.00853   (by error, pooled)
-
-frame 126: corr 0.999960  max abs 0.2578
-    action                   corr 0.999991  max abs   0.0156  mean abs 0.00438   (by error, pooled)
-    desire_pred              corr 0.999962  max abs   0.0547  mean abs 0.02731
-    desire_state             corr 0.999994  max abs   0.2188  mean abs 0.07812   (by error, pooled)
-    hidden_state             corr 0.999953  max abs   0.1113  mean abs 0.01155
-    lane_lines               corr 0.999968  max abs   0.0684  mean abs 0.01624
-    lane_lines_prob          corr 0.999971  max abs   0.1133  mean abs 0.04700   (by error, pooled)
-    lead                     corr 0.999937  max abs   0.2578  mean abs 0.02101
-    lead_prob                corr 0.999975  max abs   0.1094  mean abs 0.07161   (by error, pooled)
-    meta                     corr 0.999894  max abs   0.1211  mean abs 0.04689
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999996  max abs   0.0781  mean abs 0.00547
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00515   (by error, pooled)
-    road_edges               corr 0.999966  max abs   0.1035  mean abs 0.01622
-    road_transform           corr 0.999998  max abs   0.0195  mean abs 0.00253   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0195  mean abs 0.00555   (by error, pooled)
-
-frame 127: corr 0.999965  max abs 0.1562
-    action                   corr 0.999996  max abs   0.0098  mean abs 0.00293   (by error, pooled)
-    desire_pred              corr 0.999952  max abs   0.0625  mean abs 0.03529
-    desire_state             corr 0.999996  max abs   0.1562  mean abs 0.06836   (by error, pooled)
-    hidden_state             corr 0.999957  max abs   0.1289  mean abs 0.01113
-    lane_lines               corr 0.999977  max abs   0.0527  mean abs 0.01463
-    lane_lines_prob          corr 0.999979  max abs   0.1328  mean abs 0.07121   (by error, pooled)
-    lead                     corr 0.999992  max abs   0.0410  mean abs 0.00503
-    lead_prob                corr 1.000000  max abs   0.0938  mean abs 0.08236   (by error, pooled)
-    meta                     corr 0.999921  max abs   0.1123  mean abs 0.03691
-    pad                      corr 1.000000  max abs   0.0000  mean abs 0.00000   (by error, pooled)
-    plan                     corr 0.999998  max abs   0.0312  mean abs 0.00458
-    pose                     corr 0.999996  max abs   0.0195  mean abs 0.00642   (by error, pooled)
-    road_edges               corr 0.999961  max abs   0.0801  mean abs 0.01637
-    road_transform           corr 0.999999  max abs   0.0156  mean abs 0.00351   (by error, pooled)
-    wide_from_device_euler   corr 0.999997  max abs   0.0215  mean abs 0.00623   (by error, pooled)
-
-pooled over 128 frames, per slice and per column:
-    action                   corr 0.999979  by error, max abs 0.04883 <= 0.5352     max abs   0.0488  mean abs 0.00918
-    desire_pred              corr 0.999945  (compared whole)                        max abs   0.1211  mean abs 0.02895
-    desire_state             corr 0.999975  by error, max abs 0.4531 <= 5.253       max abs   0.4531  mean abs 0.08140
-    hidden_state             corr 0.999949  (compared whole)                        max abs   0.3125  mean abs 0.01328
-    lane_lines               corr 0.999954  worst col 0.999855 mu[1]                    max abs   0.2227  mean abs 0.01569
-    lane_lines_prob          corr 0.999883  by error, max abs 0.25 <= 0.7902        max abs   0.2500  mean abs 0.04763
-    lead                     corr 0.999978  worst col 0.999952 mu[0]    (4 by error)    max abs   1.9375  mean abs 0.03572
-    lead_prob                corr 0.999930  by error, max abs 0.2383 <= 0.9055      max abs   0.2383  mean abs 0.07485
-    meta                     corr 0.999907  (compared whole)                        max abs   0.1426  mean abs 0.03486
-    pad                      corr 1.000000  by error, max abs 0 <= 0                max abs   0.0000  mean abs 0.00000
-    plan                     corr 0.999987  worst col 0.999864 std[5]   (10 by error)   max abs   0.5625  mean abs 0.00823
-    pose                     corr 0.999988  no column correlated        (12 by error)   max abs   0.1484  mean abs 0.01025
-    road_edges               corr 0.999947  worst col 0.999837 mu[1]                    max abs   0.1812  mean abs 0.01831
-    road_transform           corr 0.999995  no column correlated        (12 by error)   max abs   0.0586  mean abs 0.00786
-    wide_from_device_euler   corr 0.999993  no column correlated        (6 by error)    max abs   0.0664  mean abs 0.00767
-
-OK: every slice and every column at or above corr 0.999, or within 10% of its largest value where too small or too quiet to correlate, per frame and pooled over all 128 frames
diff --git a/docs/evidence/sm8750-causal-prefill/results.json b/docs/evidence/sm8750-causal-prefill/results.json
deleted file mode 100644
index f8d1a159..00000000
--- a/docs/evidence/sm8750-causal-prefill/results.json
+++ /dev/null
@@ -1,124 +0,0 @@
-{
-  "recorded_utc": "2026-10-19T21:26:39.479789+00:00",
-  "device": {
-    "model": "Xiaomi 15",
-    "soc": "SM8750",
-    "htp_arch": 79,
-    "android": 17,
-    "ram_gb": 12
-  },
-  "prototype_version": "0.8.7-xiaomi-parallel3",
-  "prototype_apk_sha256": "9d3d6ab5b8b50b4c3861cc9314e15a9c805f4f836ddc1e67befefa1f94a6d173",
-  "model_sha256": "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4",
-  "runtime": {
-    "ort": "1.29.0",
-    "qairt": "2.47.0.260601",
-    "htp_fp16": true,
-    "strict_cpu_fallback_disabled": true
-  },
-  "ten_minute": {
-    "mean_ms": 27.2,
-    "p99_ms": 29.5,
-    "max_ms": 36.2,
-    "verdict": "Fast Enough"
-  },
-  "frames": 12001,
-  "over_50_ms": 0,
-  "over_35_ms": 2,
-  "model_mean_ms": 26.8,
-  "conditions": {
-    "airplane_mode": true,
-    "wifi": false,
-    "bluetooth": false,
-    "pc_usb_power": true,
-    "mounted_in_car": false
-  },
-  "heat_and_power": {
-    "battery_start_celsius": 36.6,
-    "battery_end_celsius": 45.4,
-    "battery_start_percent": 62,
-    "battery_end_percent": 55,
-    "android_thermal_status_samples": [
-      0
-    ],
-    "all_61_window_labels": "Normal",
-    "pc_usb_maintained_charge": false
-  },
-  "accuracy": {
-    "preheat": {
-      "frames": 128,
-      "same_inputs": true,
-      "original_cpu_model_unchanged": true,
-      "own_recurrent_state_on_both": true,
-      "thresholds_changed": false,
-      "all_pass": true,
-      "compare_exit": 0,
-      "synthetic_frames": true
-    },
-    "postheat": {
-      "frames": 128,
-      "same_inputs": true,
-      "original_cpu_model_unchanged": true,
-      "own_recurrent_state_on_both": true,
-      "thresholds_changed": false,
-      "all_pass": true,
-      "compare_exit": 0,
-      "synthetic_frames": true
-    }
-  },
-  "api_stage_summary": {
-    "device": "htp-parallel-SM8750-fused4-qairt247-no-fusion-sharedio-causal-prefill-v1-5a159599-parallel",
-    "layers": [
-      [
-        0,
-        1
-      ],
-      [
-        2
-      ],
-      [
-        3
-      ]
-    ],
-    "mean_provider_call_overlap_ms": 22.06991302423647,
-    "parallel": true,
-    "providers": [
-      "QNN(htp)",
-      "QNN(gpu)",
-      "QNN(htp)",
-      "CPU"
-    ],
-    "runs_since_load": 12213,
-    "scope": "Synchronous provider API spans; not accelerator occupancy percentages. Includes warmup and correctness runs since load.",
-    "stage_mean_ms": [
-      22.202267282813395,
-      22.66791940817162,
-      2.0565780671415705,
-      1.8389383253090967
-    ]
-  },
-  "one_minute_controls": {
-    "npu_only": {
-      "mean_ms": 33.8,
-      "p99_ms": 34.7
-    },
-    "same_graphs_serial_shared": {
-      "mean_ms": 45.2,
-      "p99_ms": 47.2
-    },
-    "parallel_heap": {
-      "mean_ms": 27.6,
-      "p99_ms": 30.5
-    },
-    "parallel_shared": {
-      "mean_ms": 26.8,
-      "p99_ms": 29.0
-    }
-  },
-  "limits": [
-    "Synthetic benchmark, not a car or driving validation.",
-    "Sequential controls; temperature and clocks were not fixed or randomized.",
-    "Provider-call overlap is not hardware occupancy or proof of 100 percent NPU utilization.",
-    "Screenshot and hardware measurements are from the prototype; the upstream port is independently build/test checked."
-  ]
-}
diff --git a/docs/evidence/sm8750-causal-prefill/ten-minute.png b/docs/evidence/sm8750-causal-prefill/ten-minute.png
deleted file mode 100644
index 280c11fb275b5789651dceb9518b58c702b94a2c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 238348
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

diff --git a/docs/evidence/sm8750-causal-prefill/windows.json b/docs/evidence/sm8750-causal-prefill/windows.json
deleted file mode 100644
index 5ac166f6..00000000
--- a/docs/evidence/sm8750-causal-prefill/windows.json
+++ /dev/null
@@ -1,312 +0,0 @@
-{
-  "windows": [
-    {
-      "start_second": 0,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 10,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 20,
-      "p99_ms": 29.8,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 30,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 40,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 50,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 60,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 70,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 80,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 90,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 100,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 110,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 120,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 130,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 140,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 150,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 160,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 170,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 180,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 190,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 200,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 210,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 220,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 230,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 240,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 250,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 260,
-      "p99_ms": 30.8,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 270,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 280,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 290,
-      "p99_ms": 29.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 300,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 310,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 320,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 330,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 340,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 350,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 360,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 370,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 380,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 390,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 400,
-      "p99_ms": 29.9,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 410,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 420,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 430,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 440,
-      "p99_ms": 29.9,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 450,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 460,
-      "p99_ms": 29.3,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 470,
-      "p99_ms": 29.1,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 480,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 490,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 500,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 510,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 520,
-      "p99_ms": 29.6,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 530,
-      "p99_ms": 30.0,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 540,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 550,
-      "p99_ms": 29.2,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 560,
-      "p99_ms": 29.5,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 570,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 580,
-      "p99_ms": 29.4,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 590,
-      "p99_ms": 29.7,
-      "thermal": "Normal"
-    },
-    {
-      "start_second": 600,
-      "p99_ms": 27.1,
-      "thermal": "Normal"
-    }
-  ],
-  "all_normal": true,
-  "min_window_p99_ms": 27.1,
-  "max_window_p99_ms": 30.8
-}
\ No newline at end of file

From e3e8964d66d5d7436c3796498f248e2f64ef453f Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:53:28 +0200
Subject: [PATCH 22/35] Android: portable causal DAG with explicit QNN policy

---
 JetlinkKit/Sources/JetlinkORT/Ort.swift       |   5 +-
 .../Sources/JetlinkORT/OrtBackend.swift       | 140 ++++++++++++------
 JetlinkKit/Sources/JetlinkORT/OrtEngine.swift |  77 +++-------
 JetlinkKit/Sources/JetlinkORT/QnnPolicy.swift |  66 +++++++++
 .../Sources/JetlinkORT/SessionDAG.swift       |  25 +---
 5 files changed, 178 insertions(+), 135 deletions(-)
 create mode 100644 JetlinkKit/Sources/JetlinkORT/QnnPolicy.swift

diff --git a/JetlinkKit/Sources/JetlinkORT/Ort.swift b/JetlinkKit/Sources/JetlinkORT/Ort.swift
index e0d7e92a..1021f6d5 100644
--- a/JetlinkKit/Sources/JetlinkORT/Ort.swift
+++ b/JetlinkKit/Sources/JetlinkORT/Ort.swift
@@ -150,10 +150,7 @@ final class OrtBinding {
   private let pointer: OpaquePointer
   private let sharedAllocator: OrtSharedAllocator?
 
-  init(
-    session: OrtSession, inputs: [(TensorSpec, UnsafeMutableRawPointer)], outputs: [(TensorSpec, UnsafeMutableRawPointer)],
-    sharedAllocator: OrtSharedAllocator? = nil
-  ) throws {
+  init(session: OrtSession, inputs: [(TensorSpec, UnsafeMutableRawPointer)], outputs: [(TensorSpec, UnsafeMutableRawPointer)], sharedAllocator: OrtSharedAllocator? = nil) throws {
     self.sharedAllocator = sharedAllocator
     var names: [UnsafeMutablePointer<CChar>?] = []
     var dims: [UnsafeMutablePointer<Int64>] = []
diff --git a/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift b/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
index fb10656d..ea34377a 100644
--- a/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
+++ b/JetlinkKit/Sources/JetlinkORT/OrtBackend.swift
@@ -25,7 +25,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
   /// fp16 whatever the graph says, so its fp32 heads are fp16 there too, and
   /// only the parity check can say whether that is close enough.
   case htpWhole = "htp-whole"
-  /// Experimental same-frame (HTP vision || GPU history) -> HTP decode -> CPU join.
+  /// Same-frame causal work: HTP vision and GPU history, then HTP decode.
   case htpParallel = "htp-parallel"
   /// The whole graph on the Adreno GPU.
   case gpu
@@ -67,7 +67,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
     switch self {
     case .ane, .htp: .split
     case .aneWhole, .htpWhole: .aneWhole
-    case .htpParallel: .qnnPrefillBase  // loaded from the verified offline bundle
+    case .htpParallel: .qnnPrefillBase
     case .coreml, .gpu: .whole
     case .cpu:
       #if os(Android)
@@ -81,7 +81,7 @@ public enum OrtProfile: String, CaseIterable, Sendable {
   /// What a build writes: 5 is every graph split on `ane` and Expand as Tile
   /// on both, 6 the plain graph. An artifact prepared under another rebuilds.
   public var prepareVersion: Int {
-    self == .htpParallel ? 10 : (layout == .plain ? 6 : 5)
+    self == .htpParallel ? 11 : (layout == .plain ? 6 : 5)
   }
 
   var usesCoreML: Bool {
@@ -126,8 +126,8 @@ enum OrtUnit: Equatable {
 /// and their manifest (OrtArtifact), CoreML's compiled models or QNN's EP
 /// context beside them.
 ///
-/// The causal-prefill profile has been measured on SM8750 with Cinque V3;
-/// other QNN profiles and hardware keep their existing behavior.
+/// The causal profile uses a model-specific contract and generic QNN provider
+/// discovery. A phone/runtime still needs accuracy and sustained qualification.
 public final class OrtBackend: EngineBackend {
   /// A first NPU compile with no earlier build to go by. The QNN graph
   /// finalization of a big model is minutes on a phone (unmeasured).
@@ -142,29 +142,35 @@ public final class OrtBackend: EngineBackend {
   public let keepAlive: Bool
   /// Keep a CPU core warm while the Neural Engine or the NPU runs a frame.
   public let keepCPUWarm: Bool
+  public let qnn: QnnPolicy
   private let preparer: any ModelPreparer
   private let chip: String
+  private let causalBundle: URL?
   private let log = ServerLog(category: "ort")
 
   /// `chip` names what the artifacts are valid for: on Android the SoC's
   /// model, "SM8650" (Build.SOC_MODEL), which a QNN context is compiled for.
   /// Nil is the Apple chip on Apple platforms and "cpu" elsewhere.
-  public init(profile: OrtProfile, preparer: any ModelPreparer, keepAlive: Bool = true, keepCPUWarm: Bool = true, chip: String? = nil) {
+  public init(
+    profile: OrtProfile, preparer: any ModelPreparer, keepAlive: Bool = true, keepCPUWarm: Bool = true,
+    chip: String? = nil, qnn: QnnPolicy = .init(), causalBundle: URL? = nil
+  ) {
     self.profile = profile
     self.preparer = preparer
     self.keepAlive = keepAlive
     self.keepCPUWarm = keepCPUWarm
     self.chip = HostChip.resolve(chip)
+    self.qnn = profile == .htpParallel ? QnnPolicy(
+      sharedIO: qnn.sharedIO, strict: true, disableAdvancedActivationFusion: qnn.disableAdvancedActivationFusion,
+      libraryDirectory: qnn.libraryDirectory, runtimeIdentity: qnn.runtimeIdentity) : qnn
+    self.causalBundle = causalBundle
   }
 
   public var runtimeVersion: String { OrtRuntime.version }
 
   public func deviceTag() -> String {
-    if profile == .htpParallel {
-      let mode = ProcessInfo.processInfo.environment["JETLINK_PARALLEL_SERIAL"] == "1" ? "serial" : "parallel"
-      return sanitize("htp-parallel-\(chip)-fused4-qairt247-no-fusion-sharedio-\(CausalPrefillBundle.identity)-\(mode)")
-    }
-    return sanitize("\(profile.rawValue)-\(chip)")
+    let contract = profile == .htpParallel ? "-\(CausalPrefillBundle.identity)" : ""
+    return sanitize("\(profile.rawValue)-\(chip)\(contract)\(profile.sessions.contains(where: { $0.unit == .htp }) ? qnn.cacheSuffix : "")")
   }
 
   public func deriveSpec(model: URL, sha256: String, nbytes: Int64, frameSkip: Int) throws -> ModelSpec {
@@ -173,19 +179,9 @@ public final class OrtBackend: EngineBackend {
 
   /// QNN's options for a unit, as onnxruntime 1.29 names them.
   func providerOptions(_ unit: OrtUnit) -> [String: String] {
-    if profile == .htpParallel && unit == .htp {
-      return [
-        "backend_path": (ProcessInfo.processInfo.environment["JETLINK_QNN_LIBRARY_DIR"].map { "\($0)/" } ?? "") + "libJetlinkQnnHtp.so",
-        "soc_model": "69", "htp_arch": "79",
-        "htp_performance_mode": keepAlive ? "burst" : "sustained_high_performance",
-        "htp_graph_finalization_optimization_mode": "3", "enable_htp_fp16_precision": "1",
-        "qnn_context_priority": "high", "enable_htp_shared_memory_allocator": "1",
-      ]
-    }
-    return switch unit {
+    switch unit {
     case .htp:
-      [
-        "backend_type": "htp",
+      var options = qnn.htpBackend.merging([
         // burst holds the clocks up between frames, the counterpart of the
         // Mac's GPU keep-alive; sustained trades speed for less heat.
         "htp_performance_mode": keepAlive ? "burst" : "sustained_high_performance",
@@ -193,9 +189,11 @@ public final class OrtBackend: EngineBackend {
         "htp_graph_finalization_optimization_mode": "3",
         "enable_htp_fp16_precision": "1",
         "qnn_context_priority": "high",
-      ]
-    case .qnnGPU: ["backend_type": "gpu"]
-    case .coreML, .cpu: [:]
+      ]) { _, value in value }
+      if qnn.sharedIO { options["enable_htp_shared_memory_allocator"] = "1" }
+      return options
+    case .qnnGPU: return ["backend_type": "gpu"]
+    case .coreML, .cpu: return [:]
     }
   }
 
@@ -204,8 +202,12 @@ public final class OrtBackend: EngineBackend {
   func plan(_ unit: OrtUnit, model: URL, cache: URL?) -> SessionPlan {
     switch unit {
     case .coreML(let units): SessionPlan(model: model, computeUnits: units, cacheDirectory: cache)
-    case .htp: SessionPlan(model: model, provider: "QNN", options: providerOptions(unit), label: "QNN(htp)", usesNeuralEngine: true)
-    case .qnnGPU: SessionPlan(model: model, provider: "QNN", options: providerOptions(unit), label: "QNN(gpu)", usesGPU: true)
+    case .htp: SessionPlan(
+      model: model, provider: "QNN", options: providerOptions(unit), config: qnn.sessionConfig,
+      label: "QNN(htp)", usesNeuralEngine: true)
+    case .qnnGPU: SessionPlan(
+      model: model, provider: "QNN", options: providerOptions(unit),
+      config: profile == .htpParallel ? qnn.sessionConfig : [:], label: "QNN(gpu)", usesGPU: true)
     case .cpu: SessionPlan(model: model, provider: nil, threads: HostChip.cpuThreads, label: "CPU")
     }
   }
@@ -218,36 +220,55 @@ public final class OrtBackend: EngineBackend {
     }
   }
 
-  /// Fail before compiling or loading on unvalidated hardware/runtime stacks.
-  private func validateParallel() throws {
-    guard profile == .htpParallel else { return }
-    guard chip == "SM8750", OrtRuntime.version == "1.29.0",
-      ProcessInfo.processInfo.environment["JETLINK_QNN_TUNING"] == "no-fusion",
-      ProcessInfo.processInfo.environment["JETLINK_QNN_STRICT"] == "1"
-    else {
-      throw HostError.invalid("causal-prefill requires the opt-in SM8750 / ORT 1.29 / QAIRT 2.47 build; see docs/android-causal-prefill.md")
-    }
+  /// Choose before preparation, not after an arbitrary inference error.
+  func effectiveProfile(for sha256: String) -> OrtProfile {
+    profile == .htpParallel && sha256 != CausalPrefillBundle.sourceSHA ? .htpWhole : profile
+  }
+
+  private func wholeFallback() -> OrtBackend {
+    OrtBackend(profile: .htpWhole, preparer: preparer, keepAlive: keepAlive, keepCPUWarm: keepCPUWarm, chip: chip, qnn: qnn)
+  }
+
+  /// The configured cache remains isolated; the sidecar and engine report the
+  /// route actually used for this model. Unknown/old route metadata rebuilds.
+  func artifactProfile(_ meta: [String: Any]) throws -> OrtProfile {
+    guard let source = meta["causal_prefill_source"] as? String, CacheLayout.isSHA256(source),
+      let route = (meta["causal_prefill_route"] as? String).flatMap(OrtProfile.init(rawValue:)),
+      route == effectiveProfile(for: source)
+    else { throw ArtifactInvalid("causal-prefill artifact has no matching source and execution route") }
+    return route
   }
 
   private func engine(_ artifact: URL, _ manifest: [[String: Any]], keepAlive: Bool, keepCPUWarm: Bool) throws -> OrtEngine {
     try OrtEngine(
       plans: plans(artifact, manifest), device: deviceTag(), keepAlive: keepAlive, keepCPUWarm: keepCPUWarm,
       dataflow: profile == .htpParallel,
-      parallel: ProcessInfo.processInfo.environment["JETLINK_PARALLEL_SERIAL"] != "1")
+      accelerator: profile == .htpParallel ? "NPU + GPU" : (profile == .htpWhole ? "NPU" : ""))
   }
 
   // MARK: build
 
   public func build(model: URL, artifact: URL, report: @escaping ProgressFn, metaExtra: [String: Any]) throws {
-    try validateParallel()
+    try qnn.validate()
+    var extra = metaExtra
+    if profile == .htpParallel {
+      let source = try Registry.hashFile(model).0
+      let route = effectiveProfile(for: source)
+      extra["causal_prefill_source"] = source
+      extra["causal_prefill_route"] = route.rawValue
+      if route == .htpWhole {
+        log.info("this model has no causal split; preparing the existing whole-NPU route")
+        return try wholeFallback().build(model: model, artifact: artifact, report: report, metaExtra: extra)
+      }
+    }
     let started = Date()
     let expect = Artifact.sidecar(artifact)
-    try Artifact.build(artifact, metaExtra: metaExtra, report: report) { staged in
+    try Artifact.build(artifact, metaExtra: extra, report: report) { staged in
       try FileManager.default.createDirectory(at: staged, withIntermediateDirectories: true)
       report("patch", 0, profile.usesCoreML ? "preparing the model for CoreML" : "preparing the model")
       let prepared: PreparedModel
       if profile == .htpParallel {
-        prepared = try CausalPrefillBundle.prepare(model: model, into: staged)
+        prepared = try CausalPrefillBundle.prepare(model: model, into: staged, bundle: causalBundle)
       } else {
         prepared = try preparer.prepare(model: model, into: staged, layout: profile.layout) {
           CoreMLPreparation.cacheKey(stem: artifact.deletingPathExtension().lastPathComponent, part: $0)
@@ -308,12 +329,7 @@ public final class OrtBackend: EngineBackend {
     let context = staged.appending(path: "\(session)_ctx.onnx")
     report("compile", 0, "compiling \(session) for the NPU")
     try Ticker.during(interval: 2, Ticker.paced("compile", "compiling \(session) for the NPU", took: took, report: report)) {
-      let config = [
-        "ep.context_enable": "1",
-        "ep.context_file_path": context.path,
-        // the context binary in a file of its own beside the model, not base64 inside it
-        "ep.context_embed_mode": "0",
-      ]
+      let config = contextConfiguration(context: context)
       _ = try OrtSession(model: source, provider: "QNN", options: providerOptions(.htp), config: config)
     }
     guard FileManager.default.fileExists(atPath: context.path) else {
@@ -324,6 +340,16 @@ public final class OrtBackend: EngineBackend {
     return context.lastPathComponent
   }
 
+  /// The same strict provider contract applies during compilation and reload.
+  func contextConfiguration(context: URL) -> [String: String] {
+    qnn.sessionConfig.merging([
+        "ep.context_enable": "1",
+        "ep.context_file_path": context.path,
+        // the context binary in a file of its own beside the model, not base64 inside it
+        "ep.context_embed_mode": "0",
+    ]) { _, value in value }
+  }
+
   /// A CoreML build's first session creation is the conversion and CoreML's
   /// compile, so its progress is read off the cache directories as they fill.
   private func checkCoreML(
@@ -367,7 +393,15 @@ public final class OrtBackend: EngineBackend {
   // MARK: load
 
   public func load(artifact: URL, report: @escaping ProgressFn) throws -> any Engine {
-    try validateParallel()
+    try qnn.validate()
+    if profile == .htpParallel, try artifactProfile(Artifact.sidecar(artifact)) == .htpWhole {
+      let (manifest, _) = try OrtArtifact.open(artifact, version: OrtProfile.htpWhole.prepareVersion)
+      guard manifest.count == 1, OrtUnit(entry: manifest[0]) == .htp,
+        ["model.onnx", "model_ctx.onnx"].contains(manifest[0]["model"] as? String ?? "") else {
+        throw ArtifactInvalid("causal-prefill fallback artifact is not the whole-NPU route")
+      }
+      return try wholeFallback().load(artifact: artifact, report: report)
+    }
     let (manifest, meta) = try OrtArtifact.open(artifact, version: profile.prepareVersion) { entry in
       guard let unit = OrtUnit(entry: entry) else { return "a session names no unit" }
       // Without its compile, onnxruntime would recompile under a "loading"
@@ -378,6 +412,16 @@ public final class OrtBackend: EngineBackend {
       let contents = (try? FileManager.default.contentsOfDirectory(atPath: artifact.appending(path: cache, directoryHint: .isDirectory).path)) ?? []
       return contents.isEmpty ? "the CoreML cache for \(entry["model"] as? String ?? cache) is empty" : nil
     }
+    if profile == .htpParallel {
+      guard manifest.count == 4,
+        manifest.compactMap(OrtUnit.init(entry:)) == [.htp, .qnnGPU, .htp, .cpu],
+        zip(manifest, ["vision", "history", "decode", "join"]).allSatisfy({ entry, name in
+          let file = entry["model"] as? String
+          return file == "\(name).onnx" || ((name == "vision" || name == "decode") && file == "\(name)_ctx.onnx")
+        })
+      else { throw ArtifactInvalid("causal-prefill artifact has a different session contract") }
+      try CausalPrefillBundle.verifyRetainedParts(in: artifact)
+    }
     let what = profile.usesCoreML ? "the CoreML model" : "the model"
     let (engine, seconds) = try Artifact.load(artifact, meta: meta, what: what, report: report) {
       try self.engine(artifact, manifest, keepAlive: keepAlive, keepCPUWarm: keepCPUWarm)
diff --git a/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift b/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
index dc6cceed..42ad55b0 100644
--- a/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
+++ b/JetlinkKit/Sources/JetlinkORT/OrtEngine.swift
@@ -9,6 +9,8 @@ public struct SessionPlan: Sendable, Equatable {
   /// provider alone.
   public let provider: String?
   public let options: [String: String]
+  /// Per-session configuration, including an explicit fallback contract.
+  public let config: [String: String]
   /// The CPU provider's intra-op pool: 1 where an accelerator does the work.
   public let threads: Int
   /// The session as the log and the hello name it: "CoreML(CPUAndGPU)",
@@ -20,12 +22,13 @@ public struct SessionPlan: Sendable, Equatable {
   public let usesNeuralEngine: Bool
 
   public init(
-    model: URL, provider: String?, options: [String: String] = [:], threads: Int = 1, label: String,
+    model: URL, provider: String?, options: [String: String] = [:], config: [String: String] = [:], threads: Int = 1, label: String,
     usesGPU: Bool = false, usesNeuralEngine: Bool = false
   ) {
     self.model = model
     self.provider = provider
     self.options = options
+    self.config = config
     self.threads = threads
     self.label = label
     self.usesGPU = usesGPU
@@ -72,8 +75,9 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
   public var keepsCPUWarm: Bool { keepWarm != nil || hint != nil }
   public override var notes: String {
     "CPU keep-warm \(keepsCPUWarm ? "on" : "off"); QNN shared I/O \(sharedAllocator == nil ? "off" : "on")"
-      + (schedule == nil ? "" : "; session DAG \(parallelExecution ? "parallel" : "serial control")")
+      + (schedule == nil ? "" : "; session DAG \(parallelExecution ? "parallel" : "serial")")
   }
+  public override var accelerator: String { executedAccelerator }
   public override var coolsWhenIdle: Bool { usesNeuralEngine }
 
   private let chain: [OrtSession]
@@ -86,31 +90,28 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
   private let usesNeuralEngine: Bool
   private let schedule: SessionDAG?
   private let parallelExecution: Bool
-  private var measuredFrames = 0
-  private var stageTotals: [UInt64] = []
-  private var overlapTotal: UInt64 = 0
-  private var trace: [[StageStamp]] = []
+  private let executedAccelerator: String
 
   /// `keepAlive` keeps the GPU clocked up between frames, `keepCPUWarm` the
   /// CPU; each only where a plan runs on that unit.
   public init(
     plans: [SessionPlan], device: String, keepAlive: Bool = true, keepCPUWarm: Bool = true,
-    dataflow: Bool = false, parallel: Bool = true
+    dataflow: Bool = false, parallel: Bool = true, accelerator: String = ""
   ) throws {
     self.device = device
+    self.executedAccelerator = accelerator
     var chain: [OrtSession] = []
     for plan in plans {
-      chain.append(try OrtSession(model: plan.model, provider: plan.provider, options: plan.options, threads: plan.threads))
+      chain.append(try OrtSession(model: plan.model, provider: plan.provider, options: plan.options, config: plan.config, threads: plan.threads))
     }
     self.chain = chain
     self.providers = plans.map(\.label)
     self.schedule = dataflow ? try SessionDAG(inputs: chain.map { $0.inputs.map(\.name) }, outputs: chain.map { $0.outputs.map(\.name) }) : nil
     self.parallelExecution = parallel
-    self.stageTotals = Array(repeating: 0, count: chain.count)
     let sharedSessions = plans.map { $0.options["enable_htp_shared_memory_allocator"] == "1" }
     for (index, enabled) in sharedSessions.enumerated() where enabled {
       guard plans[index].provider == "QNN", plans[index].usesNeuralEngine, !plans[index].usesGPU else {
-        throw OrtError("only verified QNN HTP sessions may bind QNN shared memory")
+        throw OrtError("only QNN HTP sessions may bind QNN shared memory")
       }
     }
     let shared = try sharedSessions.firstIndex(of: true).map { try OrtSharedAllocator(session: chain[$0]) }
@@ -149,7 +150,7 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
     var tensorTypes: [String: TensorSpec] = [:]
     for session in chain {
       for spec in session.inputs + session.outputs {
-        if let previous = tensorTypes[spec.name], previous != spec {
+        if dataflow, let previous = tensorTypes[spec.name], previous != spec {
           throw OrtError("incompatible session tensor \(spec.name)")
         }
         tensorTypes[spec.name] = spec
@@ -193,13 +194,11 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
           // writes the buffer the state_ input reads next run
           return (spec, buffer(input, parity: p ^ 1)!)
         }
-        // RPC buffers are host-accessible. GPU and CPU sessions use ordinary
-        // CPU tensor metadata over those pointers; only HTP contexts register
-        // them as QnnHtpShared. Every context stays alive until all buffers free.
-        set.append(
-          try OrtBinding(
-            session: session, inputs: ins, outputs: outs,
-            sharedAllocator: sharedSessions[index] ? sharedAllocator : nil))
+        // These allocations remain host-accessible. Only HTP sessions label
+        // their bindings QnnHtpShared; CPU/GPU sessions use CPU memory metadata.
+        set.append(try OrtBinding(
+          session: session, inputs: ins, outputs: outs,
+          sharedAllocator: sharedSessions[index] ? sharedAllocator : nil))
       }
       sets.append(set)
     }
@@ -220,22 +219,9 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
 
   public override func execute() throws {
     if let schedule {
-      let times = StageTimings(count: chain.count)
       try schedule.run(parallel: parallelExecution) { index in
-        let start = DispatchTime.now().uptimeNanoseconds
-        defer { times.record(index, start: start, end: DispatchTime.now().uptimeNanoseconds) }
         try self.bindings[self.parity][index].run()
       }
-      let stamps = times.snapshot()
-      measuredFrames += 1
-      for (index, stamp) in stamps.enumerated() { stageTotals[index] += stamp.end - stamp.start }
-      for layer in schedule.layers where layer.count > 1 {
-        let group = layer.map { stamps[$0] }
-        let total = group.reduce(UInt64(0)) { $0 + $1.end - $1.start }
-        let span = group.map(\.end).max()! - group.map(\.start).min()!
-        if total > span { overlapTotal += total - span }
-      }
-      if trace.count < 128 { trace.append(stamps) }
       return
     }
     for binding in bindings[parity] {
@@ -251,37 +237,8 @@ public final class OrtEngine: EngineCore, @unchecked Sendable {
     return "onnxruntime \(OrtRuntime.version) on \(device) in process, sessions \(providers.joined(separator: " then "))\(shared)"
   }
 
-  public override func flushTiming() {
-    guard let schedule, measuredFrames > 0 else { return }
-    let ms = stageTotals.map { Double($0) / Double(measuredFrames) / 1e6 }
-    let overlap = Double(overlapTotal) / Double(measuredFrames) / 1e6
-    ServerLog(category: "parallel").info(
-      "session DAG \(parallelExecution ? "parallel" : "serial"): \(measuredFrames) runs, provider stage means \(ms) ms, mean provider-call overlap \(overlap) ms"
-    )
-    guard let path = ProcessInfo.processInfo.environment["JETLINK_PARALLEL_TRACE"], !path.isEmpty else { return }
-    let payload: [String: Any] = [
-      "device": device, "parallel": parallelExecution, "layers": schedule.layers, "providers": providers,
-      "runs_since_load": measuredFrames, "stage_mean_ms": ms, "mean_provider_call_overlap_ms": overlap,
-      "scope": "Synchronous provider API spans; not accelerator occupancy percentages. Includes warmup and correctness runs since load.",
-      "trace": trace.enumerated().map { frame, stamps in
-        [
-          "frame": frame,
-          "stages": stamps.enumerated().map { index, stamp in
-            ["index": index, "start_ns": stamp.start, "end_ns": stamp.end] as [String: Any]
-          },
-        ] as [String: Any]
-      },
-    ]
-    do {
-      let target = URL(fileURLWithPath: path)
-      try FileManager.default.createDirectory(at: target.deletingLastPathComponent(), withIntermediateDirectories: true)
-      try JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted, .sortedKeys]).write(to: target, options: .atomic)
-    } catch { ServerLog(category: "parallel").warning("could not save stage trace: \(error)") }
-  }
-
   public override func close() {
     guard !isClosed else { return }
-    flushTiming()
     keepAlive?.close()
     keepWarm?.close()
     hint?.close()
diff --git a/JetlinkKit/Sources/JetlinkORT/QnnPolicy.swift b/JetlinkKit/Sources/JetlinkORT/QnnPolicy.swift
new file mode 100644
index 00000000..5917e0f6
--- /dev/null
+++ b/JetlinkKit/Sources/JetlinkORT/QnnPolicy.swift
@@ -0,0 +1,66 @@
+import CoreFoundation
+import Foundation
+import JetlinkServer
+
+/// Optional QNN HTP behavior. Defaults preserve the existing provider and caches.
+/// Shared I/O changes host allocation; strict mode changes fallback admission;
+/// disabling activation fusion is a separate numerical-correctness workaround.
+public struct QnnPolicy: Sendable, Equatable {
+  public let sharedIO: Bool
+  public let strict: Bool
+  public let disableAdvancedActivationFusion: Bool
+  public let libraryDirectory: String?
+  public let runtimeIdentity: String?
+
+  public init(
+    sharedIO: Bool = false, strict: Bool = false, disableAdvancedActivationFusion: Bool = false,
+    libraryDirectory: String? = nil, runtimeIdentity: String? = nil
+  ) {
+    self.sharedIO = sharedIO
+    self.strict = strict
+    self.disableAdvancedActivationFusion = disableAdvancedActivationFusion
+    self.libraryDirectory = libraryDirectory
+    self.runtimeIdentity = runtimeIdentity
+  }
+
+  /// App configuration accepts JSON Booleans, not strings or numeric lookalikes.
+  public init(configuration: [String: Any]) throws {
+    func flag(_ key: String) throws -> Bool {
+      guard let value = configuration[key] else { return false }
+      guard let number = value as? NSNumber, CFGetTypeID(number) == CFBooleanGetTypeID() else {
+        throw HostError.invalid("\(key) must be a Boolean")
+      }
+      return number.boolValue
+    }
+    self.init(
+      sharedIO: try flag("qnn_shared_io"), strict: try flag("qnn_strict"),
+      disableAdvancedActivationFusion: try flag("qnn_no_activation_fusion"),
+      libraryDirectory: configuration["native_library_dir"] as? String,
+      runtimeIdentity: configuration["qnn_runtime_identity"] as? String)
+    try validate()
+  }
+
+  var sessionConfig: [String: String] { strict ? ["session.disable_cpu_ep_fallback": "1"] : [:] }
+
+  var cacheSuffix: String {
+    guard sharedIO || strict || disableAdvancedActivationFusion else { return "" }
+    let sdk = disableAdvancedActivationFusion ? "-sdk\(runtimeIdentity ?? "missing")" : ""
+    return "-qnn-v1-shared\(sharedIO ? 1 : 0)-strict\(strict ? 1 : 0)-nofusion\(disableAdvancedActivationFusion ? 1 : 0)\(sdk)"
+  }
+
+  func validate() throws {
+    guard disableAdvancedActivationFusion else { return }
+    guard let libraryDirectory, libraryDirectory.hasPrefix("/"), !libraryDirectory.contains("\0"),
+      let runtimeIdentity, runtimeIdentity.count == 64,
+      runtimeIdentity.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) }) else {
+      throw HostError.invalid("the no-fusion adapter requires a matching SDK directory and runtime identity")
+    }
+  }
+
+  var htpBackend: [String: String] {
+    guard disableAdvancedActivationFusion else { return ["backend_type": "htp"] }
+    let directory = libraryDirectory.map { URL(fileURLWithPath: $0, isDirectory: true) }
+    let path = directory?.appendingPathComponent("libJetlinkQnnHtpNoFusion.so").path ?? "libJetlinkQnnHtpNoFusion.so"
+    return ["backend_path": path]
+  }
+}
diff --git a/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift b/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift
index 980c54f1..cdf347af 100644
--- a/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift
+++ b/JetlinkKit/Sources/JetlinkORT/SessionDAG.swift
@@ -31,8 +31,8 @@ struct SessionDAG: Sendable {
     for layer in layers {
       if parallel && layer.count > 1 {
         let failure = FirstFailure()
-        // concurrentPerform returns only after every branch has completed,
-        // including when one failed. No tensor can be freed or reused early.
+        // Join every branch, including after failure, before state can advance
+        // or any shared tensor can be freed or reused.
         DispatchQueue.concurrentPerform(iterations: layer.count) { offset in
           do { try stage(layer[offset]) } catch { failure.store(error) }
         }
@@ -58,24 +58,3 @@ private final class FirstFailure: @unchecked Sendable {
     return value
   }
 }
-
-struct StageStamp: Sendable {
-  let start: UInt64
-  let end: UInt64
-}
-
-final class StageTimings: @unchecked Sendable {
-  private let lock = NSLock()
-  private var values: [StageStamp?]
-  init(count: Int) { values = Array(repeating: nil, count: count) }
-  func record(_ index: Int, start: UInt64, end: UInt64) {
-    lock.lock()
-    values[index] = StageStamp(start: start, end: end)
-    lock.unlock()
-  }
-  func snapshot() -> [StageStamp] {
-    lock.lock()
-    defer { lock.unlock() }
-    return values.compactMap { $0 }
-  }
-}

From 4fa227c7e2001baa09823e0bfc5f45f9c504d9c7 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:58:05 +0200
Subject: [PATCH 23/35] Android: validate QNN shared allocations and strict
 sessions

---
 JetlinkKit/Sources/COrt/jl_ort.c | 32 --------------------------------
 1 file changed, 32 deletions(-)

diff --git a/JetlinkKit/Sources/COrt/jl_ort.c b/JetlinkKit/Sources/COrt/jl_ort.c
index ba4dc5ba..c48b6e65 100644
--- a/JetlinkKit/Sources/COrt/jl_ort.c
+++ b/JetlinkKit/Sources/COrt/jl_ort.c
@@ -16,7 +16,6 @@ struct jl_env {
 
 struct jl_session {
   OrtSession *session;
-  int profiling;
 };
 
 struct jl_binding {
@@ -166,23 +165,6 @@ char *jl_session_create(jl_env *env, const char *model_path, const char *provide
   for (size_t i = 0; error == NULL && i < n_config; i++) {
     error = take(api()->AddSessionConfigEntry(so, config[i].key, config[i].value));
   }
-  const char *profile = getenv("JETLINK_ORT_PROFILE");
-  if (error == NULL && profile != NULL && profile[0] != '\0') {
-    char path[4096];
-    snprintf(path, sizeof(path), "%s-ort-%p", profile, (void *)so);
-    error = take(api()->EnableProfiling(so, path));
-  }
-  if (error == NULL && provider != NULL && strcmp(provider, "QNN") == 0 && getenv("JETLINK_QNN_STRICT") != NULL) {
-    for (size_t i = 0; i < n_options; i++) {
-      if ((strcmp(options[i].key, "backend_type") == 0 &&
-           (strcmp(options[i].value, "htp") == 0 || strcmp(options[i].value, "gpu") == 0)) ||
-          (strcmp(options[i].key, "backend_path") == 0 && strstr(options[i].value, "libJetlinkQnnHtp.so") != NULL)) {
-        // A heterogeneous test must fail if either accelerator leaves compute on the CPU.
-        error = take(api()->AddSessionConfigEntry(so, "session.disable_cpu_ep_fallback", "1"));
-        break;
-      }
-    }
-  }
   if (error == NULL && provider != NULL) {
     const char **keys = calloc(n_options + 1, sizeof(char *));
     const char **values = calloc(n_options + 1, sizeof(char *));
@@ -207,7 +189,6 @@ char *jl_session_create(jl_env *env, const char *model_path, const char *provide
   }
   if (error == NULL) {
     error = take(api()->CreateSession(env->env, model_path, so, &session->session));
-    session->profiling = profile != NULL && profile[0] != '\0';
   }
   api()->ReleaseSessionOptions(so);
   if (error != NULL) {
@@ -222,19 +203,6 @@ void jl_session_release(jl_session *session) {
   if (session == NULL) {
     return;
   }
-  if (session->profiling) {
-    OrtAllocator *allocator = NULL;
-    char *filename = NULL;
-    OrtStatus *status = api()->GetAllocatorWithDefaultOptions(&allocator);
-    if (status == NULL) {
-      free(take(api()->SessionEndProfiling(session->session, allocator, &filename)));
-      if (filename != NULL) {
-        free(take(api()->AllocatorFree(allocator, filename)));
-      }
-    } else {
-      free(take(status));
-    }
-  }
   api()->ReleaseSession(session->session);
   free(session);
 }

From 8cc9fa4c22825680434cd44e36d6115bd7fe05a0 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:58:36 +0200
Subject: [PATCH 24/35] Android: apply portable QNN policy at the native bridge

---
 .../Sources/JetlinkAndroid/Bridge.swift       | 21 +++----------------
 1 file changed, 3 insertions(+), 18 deletions(-)

diff --git a/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift b/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
index a545f061..3bf6f190 100644
--- a/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
+++ b/JetlinkKit/Sources/JetlinkAndroid/Bridge.swift
@@ -174,23 +174,6 @@
       guard let cache = config["cache"] as? String, !cache.isEmpty else {
         throw HostFailure("no cache directory")
       }
-      let parallel = config["device"] as? String == "htp-parallel"
-      setenv("JETLINK_QNN_TUNING", parallel ? "no-fusion" : "stock", 1)
-      if parallel { setenv("JETLINK_QNN_STRICT", "1", 1) } else { unsetenv("JETLINK_QNN_STRICT") }
-      setenv("JETLINK_PARALLEL_SERIAL", (config["parallel_serial"] as? Bool) == true ? "1" : "0", 1)
-      if let path = config["parallel_bundle"] as? String, parallel {
-        setenv("JETLINK_PREFILL_BUNDLE", path, 1)
-      } else {
-        unsetenv("JETLINK_PREFILL_BUNDLE")
-      }
-      if let path = config["parallel_trace_path"] as? String, parallel {
-        setenv("JETLINK_PARALLEL_TRACE", path, 1)
-      } else {
-        unsetenv("JETLINK_PARALLEL_TRACE")
-      }
-      if let dir = config["native_library_dir"] as? String {
-        setenv("JETLINK_QNN_LIBRARY_DIR", dir, 1)
-      }
       let backend = try Host.backend(config)
       let configuration = Server.Configuration(
         port: UInt16(clamping: (config["port"] as? NSNumber)?.intValue ?? Int(Wire.defaultPort)),
@@ -249,7 +232,9 @@
         }
         return OrtBackend(
           profile: profile, preparer: ONNXPreparer(), keepAlive: (config["keep_alive"] as? Bool) ?? true,
-          keepCPUWarm: (config["keep_cpu_warm"] as? Bool) ?? false, chip: chip)
+          keepCPUWarm: (config["keep_cpu_warm"] as? Bool) ?? false, chip: chip,
+            qnn: try QnnPolicy(configuration: config),
+            causalBundle: (config["parallel_bundle"] as? String).map { URL(fileURLWithPath: $0, isDirectory: true) })
       case let other:
         throw HostFailure("unknown backend \(other)")
       }

From a0ab0468a8fd9b36f47dab46877d94fb8c193a3c Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:59:03 +0200
Subject: [PATCH 25/35] Android: validate causal bundles before model
 preparation

---
 .../JetlinkServer/CausalPrefillBundle.swift   | 40 +++++++++++--------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift b/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift
index 15030f7f..5cd876a6 100644
--- a/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift
+++ b/JetlinkKit/Sources/JetlinkServer/CausalPrefillBundle.swift
@@ -1,13 +1,12 @@
 import Foundation
 import JetlinkRegistry
 
-/// An offline-compiled, hash-bound research graph bundle for this exact model.
-/// The same model's weights and recurrent contract are preserved. This is not a
-/// generic compiler: another model must receive its own validated bundle.
+/// A source-only, hash-bound split of one model's same-frame causal work.
+/// Another architecture needs its own independently validated contract.
 package enum CausalPrefillBundle {
   package static let identity = "causal-prefill-v1-5a159599"
+  package static let sourceSHA = "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4"
   private static let manifestSHA = "5a159599f57ce154026baf967825cc4890e2e93ebca00adda1819b1c5354b7a3"
-  private static let sourceSHA = "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4"
 
   private struct Manifest: Decodable {
     let format: Int
@@ -31,11 +30,8 @@ package enum CausalPrefillBundle {
     }
   }
 
-  package static func prepare(model: URL, into directory: URL) throws -> PreparedModel {
-    guard let path = ProcessInfo.processInfo.environment["JETLINK_PREFILL_BUNDLE"], !path.isEmpty else {
-      throw HostError.invalid("the validated causal-prefill model bundle is missing")
-    }
-    let bundle = URL(fileURLWithPath: path, isDirectory: true)
+  package static func prepare(model: URL, into directory: URL, bundle: URL?) throws -> PreparedModel {
+    guard let bundle else { throw HostError.invalid("the causal-prefill model bundle is missing") }
     let manifestURL = bundle.appendingPathComponent("manifest.json")
     guard try Registry.hashFile(manifestURL).0 == manifestSHA else {
       throw HostError.invalid("causal-prefill manifest does not match this engine")
@@ -46,14 +42,10 @@ package enum CausalPrefillBundle {
       manifest.parts.map(\.name) == ["vision", "history", "decode", "join"],
       manifest.parts.map(\.unit) == ["htp", "gpu", "htp", "cpu"],
       try Registry.hashFile(model).0 == sourceSHA
-    else {
-      throw HostError.invalid("causal-prefill supports only the validated Cinque Terre V3 model")
-    }
+    else { throw HostError.invalid("causal-prefill requires the exact Cinque Terre V3 export") }
     var parts: [PreparedModel.Part] = []
     for part in manifest.parts {
-      guard part.file == "\(part.name).onnx", part.weightBytes >= 0,
-        CacheLayout.isSHA256(part.sha256)
-      else {
+      guard part.file == "\(part.name).onnx", part.weightBytes >= 0, CacheLayout.isSHA256(part.sha256) else {
         throw HostError.invalid("invalid causal-prefill part identity")
       }
       let source = bundle.appendingPathComponent(part.file)
@@ -63,6 +55,22 @@ package enum CausalPrefillBundle {
       try FileManager.default.copyItem(at: source, to: directory.appendingPathComponent(part.file))
       parts.append(.init(name: part.name, file: part.file, weightBytes: part.weightBytes))
     }
-    return PreparedModel(parts: parts, summary: "hash-verified causal past/current split; original weights and same-frame feedback")
+    try FileManager.default.copyItem(at: manifestURL, to: directory.appendingPathComponent("causal-prefill.json"))
+    return PreparedModel(parts: parts, summary: "hash-verified causal split; original weights and same-frame feedback")
+  }
+
+  /// HTP parts become device-compiled contexts. The GPU graph and CPU assembly
+  /// remain source ONNX and must still match the pinned contract at reload.
+  package static func verifyRetainedParts(in directory: URL) throws {
+    let file = directory.appendingPathComponent("causal-prefill.json")
+    guard (try? Registry.hashFile(file).0) == manifestSHA else {
+      throw ArtifactInvalid("causal-prefill retained manifest differs")
+    }
+    let manifest = try JSONDecoder().decode(Manifest.self, from: Data(contentsOf: file))
+    for part in manifest.parts where part.unit != "htp" {
+      guard (try? Registry.hashFile(directory.appendingPathComponent(part.file)).0) == part.sha256 else {
+        throw ArtifactInvalid("causal-prefill retained part \(part.name) differs")
+      }
+    }
   }
 }

From 4f45d6e36f9a97e34be1c38eb7bf08d250372150 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 14:59:33 +0200
Subject: [PATCH 26/35] Test causal QNN preparation preserves the supported
 graph

---
 .../QnnPreparationTests.swift                 | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 JetlinkKit/Tests/JetlinkONNXTests/QnnPreparationTests.swift

diff --git a/JetlinkKit/Tests/JetlinkONNXTests/QnnPreparationTests.swift b/JetlinkKit/Tests/JetlinkONNXTests/QnnPreparationTests.swift
new file mode 100644
index 00000000..bf2706c5
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkONNXTests/QnnPreparationTests.swift
@@ -0,0 +1,41 @@
+import Testing
+
+@testable import JetlinkONNX
+
+@Suite struct QnnPreparationTests {
+  @Test("Prescaling retains a native normalization and its original learned parameters")
+  func nativeNormalization() throws {
+    var builder = OnnxGraphBuilder()
+    builder.input("x", DataType.float16, [1, 2])
+    builder.fp16("scale", [2], [1, 2])
+    builder.fp16("bias", [2], [0.25, -0.5])
+    builder.node("LayerNormalization", ["x", "scale", "bias"], ["y"], [.float("epsilon", 1e-4)])
+    builder.output("y", DataType.float16, [1, 2])
+    let weights = builder.graph.initializers
+    var graph = builder.graph
+    #expect(try QnnPreparation.fusedLayerNorms(&graph) == 1)
+    #expect(graph.nodes.map(\.op) == ["Mul", "LayerNormalization"])
+    #expect(graph.nodes[1].inputs.dropFirst() == ["scale", "bias"])
+    #expect(graph.nodes[1].outputs == ["y"])
+    #expect(graph.nodes[1].attribute("epsilon")?.f == Float(1e-4) / 16)
+    #expect(graph.initializers.prefix(weights.count).map(\.key) == weights.map(\.key))
+    let raw: (Tensor) -> [UInt8]? = { tensor in
+      guard case .owned(let bytes)? = tensor.raw else { return nil }
+      return bytes
+    }
+    #expect(graph.initializers.prefix(weights.count).map(raw) == weights.map(raw))
+    #expect(graph.initializers.last?.key == "__qnn_fused_norm_scale4")
+    // A second transformation must not silently apply another factor of four.
+    #expect(throws: OnnxError.self) { _ = try QnnPreparation.fusedLayerNorms(&graph) }
+  }
+
+  @Test("Optional normalization statistics are rejected rather than changing their meaning")
+  func optionalStatistics() {
+    var builder = OnnxGraphBuilder()
+    builder.input("x", DataType.float16, [1, 2])
+    builder.node("LayerNormalization", ["x", "scale"], ["y", "mean"])
+    var graph = builder.graph
+    #expect(throws: OnnxError.self) { _ = try QnnPreparation.fusedLayerNorms(&graph) }
+    #expect(graph.nodes.map(\.op) == ["LayerNormalization"])
+  }
+}

From e4a0001ca2e0cc21a7bcb6635ad42cb904636008 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:00:00 +0200
Subject: [PATCH 27/35] Test portable QNN policy, shared I/O and causal routing

---
 .../CausalPrefillBundleTests.swift            | 18 +---
 .../CausalSessionEngineTests.swift            | 63 ++++++++++--
 .../JetlinkServerTests/OrtBackendTests.swift  | 14 ---
 .../OrtSharedMemoryTests.swift                |  9 +-
 .../JetlinkServerTests/QnnPolicyTests.swift   | 98 +++++++++++++++++++
 5 files changed, 164 insertions(+), 38 deletions(-)
 create mode 100644 JetlinkKit/Tests/JetlinkServerTests/QnnPolicyTests.swift

diff --git a/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift b/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
index a9d4725a..9b2ec7e2 100644
--- a/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
+++ b/JetlinkKit/Tests/JetlinkServerTests/CausalPrefillBundleTests.swift
@@ -6,27 +6,19 @@ import Testing
 
 @Suite("Hash-bound causal bundle", .serialized)
 struct CausalPrefillBundleTests {
-  @Test("The real manifest decodes, but an unvalidated source cannot be substituted")
+  @Test("Missing bundles and substituted sources fail before any part is copied")
   func sourceIdentity() throws {
     let temporary = try TemporaryDirectory()
     let bundle = temporary.url.appending(path: "bundle")
     let staged = temporary.url.appending(path: "staged")
     try FileManager.default.createDirectory(at: bundle, withIntermediateDirectories: true)
     try FileManager.default.createDirectory(at: staged, withIntermediateDirectories: true)
+    let source = Fixture.url("tiny_stateful.onnx")
+    #expect(throws: HostError.self) { _ = try CausalPrefillBundle.prepare(model: source, into: staged, bundle: nil) }
     try FileManager.default.copyItem(at: Fixture.url("causal_prefill_manifest.json"), to: bundle.appending(path: "manifest.json"))
-    let previous = ProcessInfo.processInfo.environment["JETLINK_PREFILL_BUNDLE"]
-    setenv("JETLINK_PREFILL_BUNDLE", bundle.path, 1)
-    defer {
-      if let previous { setenv("JETLINK_PREFILL_BUNDLE", previous, 1) } else { unsetenv("JETLINK_PREFILL_BUNDLE") }
-    }
-    #expect(throws: HostError.self) {
-      _ = try CausalPrefillBundle.prepare(model: Fixture.url("tiny_stateful.onnx"), into: staged)
-    }
+    #expect(throws: HostError.self) { _ = try CausalPrefillBundle.prepare(model: source, into: staged, bundle: bundle) }
     #expect(try FileManager.default.contentsOfDirectory(atPath: staged.path).isEmpty)
-    // A valid model cannot make an altered manifest acceptable either.
     try Data("{}".utf8).write(to: bundle.appending(path: "manifest.json"))
-    #expect(throws: HostError.self) {
-      _ = try CausalPrefillBundle.prepare(model: Fixture.url("tiny_stateful.onnx"), into: staged)
-    }
+    #expect(throws: HostError.self) { _ = try CausalPrefillBundle.prepare(model: source, into: staged, bundle: bundle) }
   }
 }
diff --git a/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift b/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
index bb909b04..539956bd 100644
--- a/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
+++ b/JetlinkKit/Tests/JetlinkServerTests/CausalSessionEngineTests.swift
@@ -1,4 +1,7 @@
 import Foundation
+import JetlinkONNX
+import JetlinkRegistry
+import JetlinkTestSupport
 import Testing
 
 @testable import JetlinkORT
@@ -6,10 +9,10 @@ import Testing
 
 @Suite("Same-frame recurrent session DAG", .serialized)
 struct CausalSessionEngineTests {
-  @Test("Real ORT bindings follow dependencies and loop the same state in either schedule", arguments: [false, true])
+  @Test("Real ORT bindings follow graph dependencies and preserve recurrent state", arguments: [false, true])
   func statefulBindings(parallel: Bool) throws {
-    // Deliberately not topological: graph I/O, rather than array position,
-    // identifies host tensors and orders the completion barriers.
+    // Deliberately not topological: graph I/O determines the host interface
+    // and barriers, independently of the array's order.
     let plans = ["join", "decode", "history", "vision"].map {
       SessionPlan(model: Fixture.url("parallel_\($0).onnx"), provider: nil, label: "CPU")
     }
@@ -32,14 +35,54 @@ struct CausalSessionEngineTests {
     #expect(output.load(as: Float.self) == 5)
   }
 
-  @Test("Unsupported hardware is rejected before model preparation or loading")
-  func unsupportedHardware() throws {
-    let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer(), chip: "SM8650")
-    #expect(throws: HostError.self) {
-      try backend.build(model: Fixture.url("tiny_stateful.onnx"), artifact: URL(fileURLWithPath: "/unused"), report: { _, _, _ in }, metaExtra: [:])
+  @Test("Generic provider discovery keeps strict accelerator admission without a chip whitelist")
+  func portablePolicy() {
+    for chip in ["SM8450", "SM8650", "SM8750", "future-qualcomm"] {
+      let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer(), chip: chip)
+      let model = URL(fileURLWithPath: "/unused.onnx")
+      #expect(backend.qnn.strict)
+      #expect(backend.deviceTag().contains(CausalPrefillBundle.identity))
+      #expect(backend.deviceTag() != OrtBackend(profile: .htpWhole, preparer: ONNXPreparer(), chip: chip).deviceTag())
+      #expect(backend.providerOptions(.htp)["backend_type"] == "htp")
+      #expect(backend.providerOptions(.htp)["soc_model"] == nil)
+      #expect(backend.providerOptions(.htp)["htp_arch"] == nil)
+      for unit in [OrtUnit.htp, .qnnGPU] {
+        #expect(backend.plan(unit, model: model, cache: nil).config["session.disable_cpu_ep_fallback"] == "1")
+      }
+      #expect(backend.contextConfiguration(context: model)["session.disable_cpu_ep_fallback"] == "1")
     }
-    #expect(throws: HostError.self) {
-      _ = try backend.load(artifact: URL(fileURLWithPath: "/unused"), report: { _, _, _ in })
+  }
+
+  @Test("Unknown models choose whole NPU before bundle preparation, not after an inference error")
+  func unknownModelFallback() throws {
+    let backend = OrtBackend(profile: .htpParallel, preparer: FallbackPreparer())
+    #expect(backend.effectiveProfile(for: CausalPrefillBundle.sourceSHA) == .htpParallel)
+    #expect(backend.effectiveProfile(for: String(repeating: "a", count: 64)) == .htpWhole)
+    let temporary = try TemporaryDirectory()
+    #expect(throws: Intercept.whole) {
+      try backend.build(
+        model: Fixture.url("tiny_stateful.onnx"), artifact: temporary.url.appending(path: "model.ortcache"),
+        report: { _, _, _ in }, metaExtra: [:])
+    }
+  }
+
+  @Test("A cached fallback cannot be relabelled as parallel, and old route metadata rebuilds")
+  func cachedRoute() throws {
+    let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer())
+    let unknown = String(repeating: "a", count: 64)
+    #expect(try backend.artifactProfile(["causal_prefill_source": unknown, "causal_prefill_route": "htp-whole"]) == .htpWhole)
+    #expect(try backend.artifactProfile(["causal_prefill_source": CausalPrefillBundle.sourceSHA, "causal_prefill_route": "htp-parallel"]) == .htpParallel)
+    #expect(throws: ArtifactInvalid.self) {
+      _ = try backend.artifactProfile(["causal_prefill_source": unknown, "causal_prefill_route": "htp-parallel"])
     }
+    #expect(throws: ArtifactInvalid.self) { _ = try backend.artifactProfile([:]) }
+  }
+}
+
+private enum Intercept: Error, Equatable { case whole, unexpected }
+private struct FallbackPreparer: ModelPreparer {
+  func readSpec(model: URL, sha256: String, nbytes: Int64, frameSkip: Int) throws -> ModelSpec { throw Intercept.unexpected }
+  func prepare(model: URL, into directory: URL, layout: CoreMLPreparation.Layout, cacheKey: @escaping (String) -> String) throws -> PreparedModel {
+    throw layout == .aneWhole ? Intercept.whole : Intercept.unexpected
   }
 }
diff --git a/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift b/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
index a359b6a0..9eee1e0f 100644
--- a/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
+++ b/JetlinkKit/Tests/JetlinkServerTests/OrtBackendTests.swift
@@ -44,20 +44,6 @@ struct OrtBackendTests {
     #endif
   }
 
-  @Test("Only the new profile requests the validated HTP shared-memory stack")
-  func parallelOptions() {
-    let backend = OrtBackend(profile: .htpParallel, preparer: ONNXPreparer(), chip: "SM8750")
-    let options = backend.providerOptions(.htp)
-    #expect(options["backend_path"]?.hasSuffix("libJetlinkQnnHtp.so") == true)
-    #expect(options["soc_model"] == "69" && options["htp_arch"] == "79")
-    #expect(options["enable_htp_shared_memory_allocator"] == "1")
-    #expect(backend.deviceTag().contains(CausalPrefillBundle.identity))
-    #expect(OrtProfile.htpParallel.prepareVersion == 10)
-    let legacy = OrtBackend(profile: .htp, preparer: ONNXPreparer(), chip: "SM8750")
-    #expect(legacy.providerOptions(.htp)["enable_htp_shared_memory_allocator"] == nil)
-    #expect(legacy.deviceTag() == "htp-SM8750")
-  }
-
   @Test("Each unit's session plan and provider options")
   func plans() {
     let backend = OrtBackend(profile: .htp, preparer: ONNXPreparer())
diff --git a/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift b/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
index e0182cb0..bc015571 100644
--- a/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
+++ b/JetlinkKit/Tests/JetlinkServerTests/OrtSharedMemoryTests.swift
@@ -8,8 +8,15 @@ struct OrtSharedMemoryTests {
   @Test("A CPU session cannot silently substitute heap memory for QNN RPC memory")
   func cpuDoesNotPretendToShare() throws {
     let session = try OrtSession(model: Golden("tiny_stateful").model, provider: nil)
+    #expect(throws: OrtError.self) { _ = try OrtSharedAllocator(session: session) }
+  }
+
+  @Test("CPU plans cannot request HTP shared bindings")
+  func wrongProvider() throws {
+    let plan = SessionPlan(model: try Golden("tiny_stateful").model, provider: nil,
+      options: ["enable_htp_shared_memory_allocator": "1"], label: "CPU")
     #expect(throws: OrtError.self) {
-      _ = try OrtSharedAllocator(session: session)
+      _ = try OrtEngine(plans: [plan], device: "cpu", keepAlive: false, keepCPUWarm: false)
     }
   }
 }
diff --git a/JetlinkKit/Tests/JetlinkServerTests/QnnPolicyTests.swift b/JetlinkKit/Tests/JetlinkServerTests/QnnPolicyTests.swift
new file mode 100644
index 00000000..e5d16634
--- /dev/null
+++ b/JetlinkKit/Tests/JetlinkServerTests/QnnPolicyTests.swift
@@ -0,0 +1,98 @@
+import Foundation
+import JetlinkKit
+import JetlinkServer
+import Testing
+
+@testable import JetlinkORT
+
+@Suite("QNN policy", .serialized)
+struct QnnPolicyTests {
+  private let model = URL(fileURLWithPath: "/tmp/model.onnx")
+  private let runtime = String(repeating: "a", count: 64)
+
+  @Test("Default policy preserves existing providers, session configs and cache tags")
+  func defaults() throws {
+    let policy = try QnnPolicy(configuration: [:])
+    #expect(policy == QnnPolicy())
+    for profile in OrtProfile.allCases where profile != .htpParallel {
+      let backend = OrtBackend(profile: profile, preparer: ONNXPreparer(), chip: "example", qnn: policy)
+      #expect(backend.deviceTag() == "\(profile.rawValue)-example")
+      #expect(backend.providerOptions(.htp)["backend_type"] == "htp")
+      #expect(backend.providerOptions(.htp)["backend_path"] == nil)
+      #expect(backend.providerOptions(.htp)["enable_htp_shared_memory_allocator"] == nil)
+      #expect(backend.plan(.htp, model: model, cache: nil).config.isEmpty)
+    }
+  }
+
+  @Test("Strict configuration reaches the compilation and reload session plans")
+  func strictBothPhases() {
+    let backend = OrtBackend(profile: .htpWhole, preparer: ONNXPreparer(), qnn: QnnPolicy(strict: true))
+    let key = "session.disable_cpu_ep_fallback"
+    let context = URL(fileURLWithPath: "/tmp/model_ctx.onnx")
+    #expect(backend.contextConfiguration(context: context)[key] == "1")
+    #expect(backend.contextConfiguration(context: context)["ep.context_enable"] == "1")
+    #expect(backend.contextConfiguration(context: context)["ep.context_file_path"] == context.path)
+    #expect(backend.plan(.htp, model: model, cache: nil).config == [key: "1"])
+    #expect(backend.plan(.qnnGPU, model: model, cache: nil).config.isEmpty)
+    #expect(backend.plan(.cpu, model: model, cache: nil).config.isEmpty)
+  }
+
+  @Test("Shared I/O belongs only to HTP, independent of the numerical workaround")
+  func sharedOptions() {
+    let backend = OrtBackend(profile: .htpWhole, preparer: ONNXPreparer(), qnn: QnnPolicy(sharedIO: true))
+    #expect(backend.providerOptions(.htp)["enable_htp_shared_memory_allocator"] == "1")
+    #expect(backend.providerOptions(.htp)["backend_type"] == "htp")
+    #expect(backend.providerOptions(.qnnGPU) == ["backend_type": "gpu"])
+    #expect(backend.providerOptions(.cpu).isEmpty)
+    #expect(backend.providerOptions(.coreML("ALL")).isEmpty)
+    #expect(backend.plan(.htp, model: model, cache: nil).config.isEmpty)
+  }
+
+  @Test("The adapter replaces backend discovery and requires matching-runtime metadata")
+  func adapter() throws {
+    let policy = QnnPolicy(disableAdvancedActivationFusion: true, libraryDirectory: "/app/native", runtimeIdentity: runtime)
+    try policy.validate()
+    let backend = OrtBackend(profile: .htpWhole, preparer: ONNXPreparer(), qnn: policy)
+    #expect(backend.providerOptions(.htp)["backend_type"] == nil)
+    #expect(backend.providerOptions(.htp)["backend_path"] == "/app/native/libJetlinkQnnHtpNoFusion.so")
+    #expect(throws: HostError.self) { try QnnPolicy(disableAdvancedActivationFusion: true).validate() }
+    #expect(throws: HostError.self) {
+      try QnnPolicy(disableAdvancedActivationFusion: true, libraryDirectory: "relative", runtimeIdentity: runtime).validate()
+    }
+    #expect(throws: HostError.self) {
+      try QnnPolicy(disableAdvancedActivationFusion: true, libraryDirectory: "/native", runtimeIdentity: "unknown").validate()
+    }
+  }
+
+  @Test("All option combinations and SDK bytes have distinct HTP cache namespaces")
+  func caches() {
+    var tags = Set<String>()
+    for shared in [false, true] {
+      for strict in [false, true] {
+        for fusion in [false, true] {
+          let policy = QnnPolicy(sharedIO: shared, strict: strict, disableAdvancedActivationFusion: fusion,
+            libraryDirectory: "/native", runtimeIdentity: runtime)
+          let backend = OrtBackend(profile: .htpWhole, preparer: ONNXPreparer(), chip: "example", qnn: policy)
+          tags.insert(backend.deviceTag())
+          #expect(OrtBackend(profile: .cpu, preparer: ONNXPreparer(), chip: "example", qnn: policy).deviceTag() == "cpu-example")
+        }
+      }
+    }
+    #expect(tags.count == 8)
+    let first = QnnPolicy(disableAdvancedActivationFusion: true, libraryDirectory: "/native", runtimeIdentity: runtime)
+    let second = QnnPolicy(disableAdvancedActivationFusion: true, libraryDirectory: "/native", runtimeIdentity: String(repeating: "b", count: 64))
+    #expect(first.cacheSuffix != second.cacheSuffix)
+  }
+
+  @Test("JSON accepts actual Booleans and rejects strings and numeric lookalikes")
+  func typedConfiguration() throws {
+    let object = try JSONSerialization.jsonObject(with: Data("{\"qnn_shared_io\":true,\"qnn_strict\":false}".utf8)) as! [String: Any]
+    #expect(try QnnPolicy(configuration: object).sharedIO)
+    let invalid: [Any] = ["true", "false", 1, 0, NSNull()]
+    for key in ["qnn_shared_io", "qnn_strict", "qnn_no_activation_fusion"] {
+      for value in invalid {
+        #expect(throws: HostError.self) { _ = try QnnPolicy(configuration: [key: value]) }
+      }
+    }
+  }
+}

From 485922a5805017576d02f87e68b2aa69439c5598 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:00:24 +0200
Subject: [PATCH 28/35] Android: keep accelerator features opt-in and
 fingerprint SDK bytes

---
 android/app/build.gradle.kts | 62 +++++++++++++++++++++++++-----------
 1 file changed, 44 insertions(+), 18 deletions(-)

diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts
index 5193714c..e53dc47c 100644
--- a/android/app/build.gradle.kts
+++ b/android/app/build.gradle.kts
@@ -22,24 +22,46 @@ val jetlinkVersionCode: Int =
     jetlinkVersion.split(".").map { it.takeWhile(Char::isDigit).toIntOrNull() ?: 0 }
         .let { (it.getOrElse(0) { 0 } * 10000) + (it.getOrElse(1) { 0 } * 100) + it.getOrElse(2) { 0 } }
 
-// Explicit build opt-in: standard releases still package the Maven QNN runtime.
-val causalPrefill = providers.gradleProperty("jetlink.causalPrefill").orNull == "true"
-val qairtJniDir = providers.gradleProperty("jetlink.qairtJniDir").orNull
-if (causalPrefill) {
-    check(qairtJniDir != null) { "causal-prefill needs the matched QAIRT 2.47 jniLibs; see docs/android-causal-prefill.md" }
-    @Suppress("UNCHECKED_CAST")
-    val matched = groovy.json.JsonSlurper().parse(rootDir.resolve("qnn/qairt-2.47-sha256.json")) as Map<String, String>
-    for ((name, expected) in matched) {
-        val library = File(qairtJniDir, "arm64-v8a/$name")
-        check(library.isFile) { "missing QAIRT 2.47 library: $name" }
-        val actual = MessageDigest.getInstance("SHA-256").digest(library.readBytes()).joinToString("") { "%02x".format(it) }
-        check(actual == expected) { "$name differs from the validated QAIRT 2.47 stack" }
-    }
-    for (name in listOf("libJetlinkQnnHtp.so", "libQnnHtp.so", "libQnnGpu.so", "libQnnHtpV79Stub.so", "libQnnHtpV79Skel.so")) {
-        check(File(qairtJniDir, "arm64-v8a/$name").isFile) { "missing matched library: $name" }
+// All options are build-time opt-ins; ordinary releases retain the Maven runtime.
+fun qnnFlag(name: String): Boolean = providers.gradleProperty(name).orNull?.let {
+    it.toBooleanStrictOrNull() ?: error("$name must be true or false")
+} ?: false
+val qnnSharedIO = qnnFlag("jetlink.qnnSharedIO")
+val causalPrefill = qnnFlag("jetlink.causalPrefill")
+val qnnStrict = qnnFlag("jetlink.qnnStrict")
+val qnnNoActivationFusion = qnnFlag("jetlink.qnnNoActivationFusion")
+val qnnJniDir = providers.gradleProperty("jetlink.qnnJniDir").orNull
+val qnnJniRoot = qnnJniDir?.let { file(it) }
+val qnnRuntimeIdentity = if (qnnNoActivationFusion) {
+    check(qnnJniDir != null) { "no-fusion requires one matching SDK; see docs/android-qnn-npu.md" }
+    val directory = File(qnnJniRoot!!, "arm64-v8a")
+    val libraries = directory.listFiles()?.filter { it.isFile && it.extension == "so" }?.sortedBy { it.name }.orEmpty()
+    val names = libraries.map { it.name }.toSet()
+    check(names.containsAll(listOf("libJetlinkQnnHtpNoFusion.so", "libQnnHtp.so", "libQnnGpu.so", "libQnnSystem.so",
+        "libQnnHtpPrepare.so", "libQnnIr.so", "libQnnSaver.so"))) { "incomplete SDK jniLibs directory: $directory" }
+    val stub = names.filter { it.matches(Regex("libQnnHtpV\\d+Stub\\.so")) }.map { it.removeSuffix("Stub.so") }.toSet()
+    val skel = names.filter { it.matches(Regex("libQnnHtpV\\d+Skel\\.so")) }.map { it.removeSuffix("Skel.so") }.toSet()
+    check(stub.isNotEmpty() && stub == skel) { "matching HTP stub/skel pairs are required" }
+    // Actual runtime bytes form a cache namespace, not a preselected SDK/SoC pin.
+    val identity = MessageDigest.getInstance("SHA-256")
+    for (library in libraries) {
+        val digest = MessageDigest.getInstance("SHA-256")
+        library.inputStream().use { stream ->
+            val buffer = ByteArray(1024 * 1024)
+            while (true) {
+                val count = stream.read(buffer)
+                if (count < 0) break
+                digest.update(buffer, 0, count)
+            }
+        }
+        identity.update(library.name.toByteArray(Charsets.UTF_8))
+        identity.update(0.toByte())
+        identity.update(digest.digest())
     }
+    identity.digest().joinToString("") { "%02x".format(it) }
 } else {
-    check(qairtJniDir == null) { "jetlink.qairtJniDir is only supported with jetlink.causalPrefill=true" }
+    check(qnnJniDir == null) { "jetlink.qnnJniDir requires jetlink.qnnNoActivationFusion=true" }
+    ""
 }
 
 android {
@@ -57,6 +79,10 @@ android {
         versionCode = jetlinkVersionCode
         versionName = jetlinkVersion
         buildConfigField("boolean", "EXPERIMENTAL_CAUSAL_PREFILL", causalPrefill.toString())
+        buildConfigField("boolean", "QNN_SHARED_IO", qnnSharedIO.toString())
+        buildConfigField("boolean", "QNN_STRICT", qnnStrict.toString())
+        buildConfigField("boolean", "QNN_NO_ACTIVATION_FUSION", qnnNoActivationFusion.toString())
+        buildConfigField("String", "QNN_RUNTIME_IDENTITY", "\"$qnnRuntimeIdentity\"")
         // The QNN runtime is arm64 only, and so is every Snapdragon with an NPU
         // worth driving on. The emulator on an Apple silicon Mac is arm64 too.
         ndk { abiFilters += "arm64-v8a" }
@@ -105,7 +131,7 @@ android {
         }
     }
 
-    if (causalPrefill) sourceSets.getByName("main").jniLibs.srcDir(qairtJniDir!!)
+    if (qnnNoActivationFusion) sourceSets.getByName("main").jniLibs.srcDir(qnnJniRoot!!)
 
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
@@ -156,7 +182,7 @@ dependencies {
     implementation(libs.kotlinx.serialization.json)
     // libonnxruntime.so with the QNN provider, and the QNN runtime's libraries
     implementation(libs.onnxruntime.qnn) {
-        if (causalPrefill) exclude(group = "com.qualcomm.qti", module = "qnn-runtime")
+        if (qnnNoActivationFusion) exclude(group = "com.qualcomm.qti", module = "qnn-runtime")
     }
     debugImplementation(libs.compose.ui.tooling)
 

From 3c09e0edf53fc8ab43a99a28e1bd50543fba2467 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:00:52 +0200
Subject: [PATCH 29/35] Android: select supported model route before
 preparation

---
 .../zoompilot/jetlink/server/ServerController.kt  | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt b/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
index 86bfcfc7..1ca0d3f5 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/server/ServerController.kt
@@ -4,6 +4,7 @@ import android.content.Context
 import android.net.Uri
 import android.os.Build
 import android.util.Log
+import io.zoompilot.jetlink.BuildConfig
 import io.zoompilot.jetlink.settings.Chip
 import io.zoompilot.jetlink.settings.Processor
 import io.zoompilot.jetlink.settings.SettingsValues
@@ -64,6 +65,11 @@ class ServerController(private val context: Context, private val scope: Coroutin
 
     /** Starts the server with [settings], restarting one that runs. */
     suspend fun start(settings: SettingsValues) = lifecycle.withLock {
+        if (settings.processor.resolved() == Processor.NpuGpuParallel && !BuildConfig.EXPERIMENTAL_CAUSAL_PREFILL) {
+            withContext(Dispatchers.IO) { Native.stop() }
+            run.value = RunState.Failed("This build does not enable the causal-prefill experiment.")
+            return@withLock
+        }
         run.value = RunState.Starting
         // the server stops one that runs first
         val error = withContext(Dispatchers.IO) { Native.start(config(settings).toString()) }
@@ -100,10 +106,13 @@ class ServerController(private val context: Context, private val scope: Coroutin
         // a model compiled for the NPU is good for this system build alone
         put("firmware", Build.FINGERPRINT)
         put("native_library_dir", context.applicationInfo.nativeLibraryDir)
+        put("qnn_shared_io", BuildConfig.QNN_SHARED_IO)
+        put("qnn_strict", BuildConfig.QNN_STRICT)
+        put("qnn_no_activation_fusion", BuildConfig.QNN_NO_ACTIVATION_FUSION)
+        put("qnn_runtime_identity", BuildConfig.QNN_RUNTIME_IDENTITY)
         if (processor == Processor.NpuGpuParallel) {
-            context.getExternalFilesDir(null)?.let { directory ->
-                put("parallel_bundle", File(directory, "causal-prefill-v1").absolutePath)
-                if (settings.developer) put("parallel_trace_path", File(directory, "parallel-stages.json").absolutePath)
+            context.getExternalFilesDir(null)?.let {
+                put("parallel_bundle", File(it, "causal-prefill-v1").absolutePath)
             }
         }
     }

From cc248b795a0d0b0ee68c0ba769e32f41de8fdbcc Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:01:22 +0200
Subject: [PATCH 30/35] Android: expose opt-in parallel mode on compatible
 Qualcomm devices

---
 .../main/java/io/zoompilot/jetlink/settings/Chip.kt    |  4 ++--
 .../java/io/zoompilot/jetlink/settings/Settings.kt     | 10 +++++++---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt b/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
index 28b35e41..2cc7319e 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/settings/Chip.kt
@@ -29,8 +29,8 @@ object Chip {
     fun tensorGeneration(model: String): Int? = tensorModel.find(model.trim())?.groupValues?.get(1)?.toIntOrNull()
 
     /** What this phone's Settings offer. */
-    fun processors(current: Processor): List<Processor> = Processor.choices(isQualcomm, hasTensorNpu, isEmulator, current,
-        parallel = BuildConfig.EXPERIMENTAL_CAUSAL_PREFILL && model == "SM8750")
+    fun processors(current: Processor): List<Processor> = Processor.choices(
+        isQualcomm, hasTensorNpu, isEmulator, current, parallel = BuildConfig.EXPERIMENTAL_CAUSAL_PREFILL)
 
     /** What Automatic runs on here. */
     val automatic: Processor by lazy { Processor.automatic(hasTensorNpu, isEmulator) }
diff --git a/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt b/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
index 23fae898..3e38e0c1 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/settings/Settings.kt
@@ -44,7 +44,7 @@ enum class Processor(val backend: Backend, val device: String, val title: String
      */
     NpuGpu(Backend.Ort, "htp", "NPU + GPU"),
 
-    /** Same-frame history/vision overlap; only in the explicitly enabled SM8750 build. */
+    /** Same-frame causal work in parallel; exact model contracts only, otherwise whole NPU. */
     NpuGpuParallel(Backend.Ort, "htp-parallel", "NPU + GPU (experimental)"),
 
     /** The CPU: the emulator and tests. Seconds a frame with a real model. */
@@ -61,7 +61,11 @@ enum class Processor(val backend: Backend, val device: String, val title: String
      * NPU: the NPU took no model. [accelerator] is the ready engine's.
      */
     fun fellBack(accelerator: String?, automatic: Processor = Chip.automatic): Boolean =
-        resolved(automatic) == TensorNpu && hardwareOf(accelerator).let { it != null && it != "NPU" }
+        when (resolved(automatic)) {
+            TensorNpu -> hardwareOf(accelerator).let { it != null && it != "NPU" }
+            NpuGpuParallel -> hardwareOf(accelerator) == "NPU"
+            else -> false
+        }
 
     /** What the Processor row says: the choice, and with Automatic what it runs on. */
     fun summary(accelerator: String?, automatic: Processor = Chip.automatic): String {
@@ -92,7 +96,7 @@ enum class Processor(val backend: Backend, val device: String, val title: String
          * everything, for testing.
          */
         fun choices(qualcomm: Boolean, tensorNpu: Boolean, emulator: Boolean, current: Processor, parallel: Boolean = false): List<Processor> = when {
-            emulator -> entries
+            emulator -> entries.filter { it != NpuGpuParallel || parallel }
             qualcomm -> entries.filter { it != TensorNpu && (it != Cpu || current == Cpu) && (it != NpuGpuParallel || parallel) }
             tensorNpu -> listOf(Auto, TensorNpu, Gpu, Cpu)
             else -> listOf(Auto, Gpu, Cpu)

From 2fd2698a327e70f5badbbc60b313c789e67abfde Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:01:52 +0200
Subject: [PATCH 31/35] Android: describe supported parallel model and actual
 fallback

---
 .../java/io/zoompilot/jetlink/ui/settings/SettingsScreen.kt   | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/android/app/src/main/java/io/zoompilot/jetlink/ui/settings/SettingsScreen.kt b/android/app/src/main/java/io/zoompilot/jetlink/ui/settings/SettingsScreen.kt
index e92e7182..3470ca07 100644
--- a/android/app/src/main/java/io/zoompilot/jetlink/ui/settings/SettingsScreen.kt
+++ b/android/app/src/main/java/io/zoompilot/jetlink/ui/settings/SettingsScreen.kt
@@ -263,6 +263,10 @@ private fun Performance(values: SettingsValues, info: SettingsInfo, actions: Set
     var choosing by remember { mutableStateOf(false) }
     val choices = info.processors
     val footer = when {
+        values.processor.resolved(info.automatic) == Processor.NpuGpuParallel &&
+            values.processor.fellBack(info.accelerator, info.automatic) ->
+            "This model has no validated causal split, so it runs on the whole NPU. " +
+                "Run Benchmark and check accuracy on this phone before use."
         values.processor.fellBack(info.accelerator, info.automatic) ->
             "The NPU did not take this model, so it runs on the GPU. Logs (in Help) say why. " +
                 "Changing the processor prepares models again."

From 15de7d4f813c65090e30d030af5c7a3435959234 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:02:22 +0200
Subject: [PATCH 32/35] Test Qualcomm parallel availability and whole-NPU
 fallback

---
 .../jetlink/settings/ProcessorTest.kt         | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt b/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
index e6fa4cca..4480f01c 100644
--- a/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
+++ b/android/app/src/test/java/io/zoompilot/jetlink/settings/ProcessorTest.kt
@@ -20,15 +20,6 @@ class ProcessorTest {
         )
     }
 
-    @Test
-    fun parallelNeedsExplicitOptIn() {
-        assertFalse(Processor.NpuGpuParallel in Processor.choices(true, false, false, Processor.Auto))
-        assertTrue(Processor.NpuGpuParallel in Processor.choices(true, false, false, Processor.Auto, parallel = true))
-        assertFalse(Processor.NpuGpuParallel in Processor.choices(false, true, false, Processor.Auto, parallel = true))
-        assertEquals(Processor.NpuGpuParallel, Processor.of("htp-parallel"))
-        assertEquals(Processor.NpuGpu, Processor.of("htp"))
-    }
-
     @Test
     fun aGoogleTensorOffersItsNpu() {
         assertEquals(
@@ -87,7 +78,8 @@ class ProcessorTest {
 
     @Test
     fun theEmulatorOffersEverything() {
-        assertEquals(Processor.entries, Processor.choices(qualcomm = false, tensorNpu = false, emulator = true, current = Processor.Cpu))
+        assertEquals(Processor.entries.filter { it != Processor.NpuGpuParallel }, Processor.choices(false, false, true, Processor.Cpu))
+        assertEquals(Processor.entries, Processor.choices(false, false, true, Processor.Cpu, parallel = true))
     }
 
     @Test
@@ -119,4 +111,15 @@ class ProcessorTest {
         assertEquals(null, Chip.tensorGeneration("SM8650"))
         assertEquals(null, Chip.tensorGeneration("Tensor"))
     }
+
+    @Test
+    fun theParallelExperimentIsBuildOptInForQualcommAndReportsItsFallback() {
+        assertFalse(Processor.choices(true, false, false, Processor.Npu).contains(Processor.NpuGpuParallel))
+        assertTrue(Processor.choices(true, false, false, Processor.Npu, parallel = true).contains(Processor.NpuGpuParallel))
+        assertFalse(Processor.choices(false, true, false, Processor.TensorNpu, parallel = true).contains(Processor.NpuGpuParallel))
+        assertEquals(Processor.NpuGpuParallel, Processor.of("htp-parallel"))
+        assertTrue(Processor.NpuGpuParallel.fellBack("NPU", automatic = Processor.Gpu))
+        assertFalse(Processor.NpuGpuParallel.fellBack("NPU + GPU", automatic = Processor.Gpu))
+        assertEquals("NPU + GPU (experimental) (NPU)", Processor.NpuGpuParallel.summary("NPU", automatic = Processor.Gpu))
+    }
 }

From 166207b9dceb405d20cb8511a1c1137880f5c76c Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:02:49 +0200
Subject: [PATCH 33/35] Android: reduce QNN adapter to the tested
 activation-fusion workaround

---
 android/qnn/build.sh                        |  56 +++++++++
 android/qnn/htp_no_activation_fusion.c      | 124 ++++++++++++++++++++
 android/qnn/test.sh                         |  14 +++
 android/qnn/test_htp_no_activation_fusion.c |  79 +++++++++++++
 4 files changed, 273 insertions(+)
 create mode 100644 android/qnn/build.sh
 create mode 100644 android/qnn/htp_no_activation_fusion.c
 create mode 100644 android/qnn/test.sh
 create mode 100644 android/qnn/test_htp_no_activation_fusion.c

diff --git a/android/qnn/build.sh b/android/qnn/build.sh
new file mode 100644
index 00000000..62aa1572
--- /dev/null
+++ b/android/qnn/build.sh
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# Use one locally obtained SDK for headers AND every packaged QNN library.
+# No vendor code or model is downloaded or stored in this repository.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+: "${QNN_SDK_ROOT:?set QNN_SDK_ROOT to the matching SDK}"
+: "${ANDROID_NDK_HOME:?set ANDROID_NDK_HOME to the Android NDK}"
+OUT=${1:?usage: android/qnn/build.sh NEW_OUTPUT_JNILIBS_DIRECTORY}
+[[ ! -e "$OUT" ]] || { echo "Output must not exist: $OUT" >&2; exit 1; }
+bash "$HERE/test.sh"
+INCLUDE="$QNN_SDK_ROOT/include/QNN"
+[[ -d "$INCLUDE" ]] || INCLUDE="$QNN_SDK_ROOT/include"
+TOOLCHAIN="$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin"
+mkdir -p "$OUT/arm64-v8a"
+"$TOOLCHAIN/aarch64-linux-android31-clang" -std=gnu11 -Wall -Wextra -Werror \
+  -I "$INCLUDE" -fPIC -shared "$HERE/htp_no_activation_fusion.c" \
+  -ldl -pthread -Wl,-z,relro,-z,now -o "$OUT/arm64-v8a/libJetlinkQnnHtpNoFusion.so"
+python3 - "$QNN_SDK_ROOT" "$OUT/arm64-v8a" <<'PY'
+import hashlib
+from pathlib import Path
+import re
+import shutil
+import sys
+sdk, out = map(Path, sys.argv[1:])
+core = {'libQnnHtp.so', 'libQnnGpu.so', 'libQnnSystem.so', 'libQnnHtpPrepare.so', 'libQnnIr.so', 'libQnnSaver.so'}
+found = {}
+for path in sdk.rglob('libQnn*.so'):
+    name = path.name
+    skel = re.fullmatch(r'libQnnHtpV\d+Skel\.so', name)
+    stub = re.fullmatch(r'libQnnHtpV\d+Stub\.so', name)
+    if name not in core and not skel and not stub:
+        continue
+    if skel:
+        if 'unsigned' not in path.parts:
+            continue
+    elif 'aarch64-android' not in path.parts:
+        continue
+    with path.open('rb') as stream:
+        header = stream.read(20)
+    machine = 164 if skel else 183
+    if header[:4] != b'\x7fELF' or header[5] != 1 or int.from_bytes(header[18:20], 'little') != machine:
+        continue
+    with path.open('rb') as stream:
+        digest = hashlib.file_digest(stream, 'sha256').hexdigest()
+    if name in found and found[name][0] != digest:
+        raise SystemExit(f'Ambiguous SDK library: {name}; choose one SDK root')
+    found[name] = (digest, path)
+missing = core - found.keys()
+stubs = {name.removesuffix('Stub.so') for name in found if name.endswith('Stub.so')}
+skels = {name.removesuffix('Skel.so') for name in found if name.endswith('Skel.so')}
+if missing or not stubs or stubs != skels:
+    raise SystemExit(f'Incomplete matching SDK: missing={sorted(missing)}, stubs={sorted(stubs)}, skels={sorted(skels)}')
+for _, path in found.values():
+    shutil.copyfile(path, out / path.name)
+print(f'Staged adapter and {len(found)} libraries from one SDK; Gradle fingerprints their actual bytes for cache identity.')
+PY
diff --git a/android/qnn/htp_no_activation_fusion.c b/android/qnn/htp_no_activation_fusion.c
new file mode 100644
index 00000000..fb0a5cfb
--- /dev/null
+++ b/android/qnn/htp_no_activation_fusion.c
@@ -0,0 +1,124 @@
+// Public QNN API adapter; build against the same SDK as the packaged backend.
+// This is a numerical workaround, independent of shared I/O and scheduling.
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "QnnInterface.h"
+#include "HTP/QnnHtpCommon.h"
+#include "HTP/QnnHtpGraph.h"
+
+static pthread_once_t initialized = PTHREAD_ONCE_INIT;
+static void *backend;
+static QnnInterface_t wrapped;
+static const QnnInterface_t *providers[] = {&wrapped};
+static QnnGraph_CreateFn_t real_create;
+static QnnContext_FreeFn_t real_context_free;
+static Qnn_ErrorHandle_t init_status = QNN_COMMON_ERROR_GENERAL;
+
+// Some backends consume graph configuration during finalization. Keep both
+// the list and the custom configuration alive until contextFree succeeds.
+typedef struct ConfigStorage {
+  struct ConfigStorage *next;
+  Qnn_ContextHandle_t context;
+  QnnHtpGraph_CustomConfig_t custom;
+  QnnGraph_Config_t config;
+  const QnnGraph_Config_t *all[];
+} ConfigStorage;
+static ConfigStorage *retained;
+static pthread_mutex_t retained_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static Qnn_ErrorHandle_t context_free(Qnn_ContextHandle_t context, Qnn_ProfileHandle_t profile) {
+  Qnn_ErrorHandle_t status = real_context_free(context, profile);
+  if (status != QNN_SUCCESS) return status;
+  pthread_mutex_lock(&retained_mutex);
+  ConfigStorage **link = &retained;
+  while (*link != NULL) {
+    ConfigStorage *entry = *link;
+    if (entry->context == context) {
+      *link = entry->next;
+      free(entry);
+    } else {
+      link = &entry->next;
+    }
+  }
+  pthread_mutex_unlock(&retained_mutex);
+  return status;
+}
+
+static Qnn_ErrorHandle_t graph_create(Qnn_ContextHandle_t context, const char *name,
+    const QnnGraph_Config_t **original, Qnn_GraphHandle_t *graph) {
+  size_t count = 0;
+  if (original != NULL) {
+    while (count < 128 && original[count] != NULL) ++count;
+    if (count == 128) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
+  }
+  ConfigStorage *storage = calloc(1, sizeof(*storage) + (count + 2) * sizeof(*storage->all));
+  if (storage == NULL) return QNN_COMMON_ERROR_MEM_ALLOC;
+  storage->context = context;
+  storage->custom.option = QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION;
+  storage->custom.advancedActivationFusion = false;
+  storage->config.option = QNN_GRAPH_CONFIG_OPTION_CUSTOM;
+  storage->config.customConfig = &storage->custom;
+  for (size_t i = 0; i < count; ++i) storage->all[i] = original[i];
+  storage->all[count] = &storage->config;
+  Qnn_ErrorHandle_t status = real_create(context, name, storage->all, graph);
+  if (status == QNN_SUCCESS) {
+    pthread_mutex_lock(&retained_mutex);
+    storage->next = retained;
+    retained = storage;
+    pthread_mutex_unlock(&retained_mutex);
+  } else {
+    free(storage);
+  }
+  return status;
+}
+
+static void initialize(void) {
+  Dl_info location;
+  if (dladdr((void *)&initialize, &location) == 0 || location.dli_fname == NULL) return;
+  const char *slash = strrchr(location.dli_fname, '/');
+  if (slash == NULL) return;
+  char path[4096];
+  if (snprintf(path, sizeof(path), "%.*s/libQnnHtp.so", (int)(slash - location.dli_fname), location.dli_fname) >= (int)sizeof(path)) return;
+  backend = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+  if (backend == NULL) {
+    fprintf(stderr, "QNN no-fusion adapter: cannot open the sibling HTP backend: %s\n", dlerror());
+    return;
+  }
+  typedef Qnn_ErrorHandle_t (*GetProviders)(const QnnInterface_t ***, uint32_t *);
+  GetProviders get = (GetProviders)dlsym(backend, "QnnInterface_getProviders");
+  if (get == NULL) return;
+  const QnnInterface_t **list = NULL;
+  uint32_t count = 0;
+  if (get(&list, &count) != QNN_SUCCESS || list == NULL) return;
+  for (uint32_t i = 0; i < count; ++i) {
+    const QnnInterface_t *p = list[i];
+    if (p == NULL || p->backendId != QNN_BACKEND_ID_HTP ||
+        p->apiVersion.coreApiVersion.major != QNN_API_VERSION_MAJOR ||
+        p->apiVersion.coreApiVersion.minor < QNN_API_VERSION_MINOR) continue;
+    wrapped = *p;
+    real_create = p->QNN_INTERFACE_VER_NAME.graphCreate;
+    real_context_free = p->QNN_INTERFACE_VER_NAME.contextFree;
+    if (real_create == NULL || real_context_free == NULL) return;
+    wrapped.QNN_INTERFACE_VER_NAME.graphCreate = graph_create;
+    wrapped.QNN_INTERFACE_VER_NAME.contextFree = context_free;
+    init_status = QNN_SUCCESS;
+    return;
+  }
+}
+
+Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***out, uint32_t *count) {
+  if (out == NULL || count == NULL) return QNN_COMMON_ERROR_INVALID_ARGUMENT;
+  *out = NULL;
+  *count = 0;
+  pthread_once(&initialized, initialize);
+  if (init_status != QNN_SUCCESS) return init_status;
+  *out = providers;
+  *count = 1;
+  return QNN_SUCCESS;
+}
diff --git a/android/qnn/test.sh b/android/qnn/test.sh
new file mode 100644
index 00000000..6beb3d37
--- /dev/null
+++ b/android/qnn/test.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Host-only public-API forwarding/lifetime test; no accelerator execution.
+set -euo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+: "${QNN_SDK_ROOT:?set QNN_SDK_ROOT to the matching SDK}"
+INCLUDE="$QNN_SDK_ROOT/include/QNN"
+[[ -d "$INCLUDE" ]] || INCLUDE="$QNN_SDK_ROOT/include"
+BUILD=$(mktemp -d)
+trap 'rm -rf "$BUILD"' EXIT
+FLAGS=(-std=gnu11 -Wall -Wextra -Werror -I "$INCLUDE")
+cc "${FLAGS[@]}" -fPIC -shared "$HERE/test_htp_no_activation_fusion.c" -DFAKE_BACKEND -o "$BUILD/libQnnHtp.so"
+cc "${FLAGS[@]}" -fPIC -shared "$HERE/htp_no_activation_fusion.c" -ldl -pthread -o "$BUILD/libJetlinkQnnHtpNoFusion.so"
+cc "${FLAGS[@]}" "$HERE/test_htp_no_activation_fusion.c" -ldl -o "$BUILD/test-no-fusion"
+"$BUILD/test-no-fusion" "$BUILD/libJetlinkQnnHtpNoFusion.so"
diff --git a/android/qnn/test_htp_no_activation_fusion.c b/android/qnn/test_htp_no_activation_fusion.c
new file mode 100644
index 00000000..9a7cc672
--- /dev/null
+++ b/android/qnn/test_htp_no_activation_fusion.c
@@ -0,0 +1,79 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include "QnnInterface.h"
+#include "HTP/QnnHtpCommon.h"
+#include "HTP/QnnHtpGraph.h"
+
+#ifdef FAKE_BACKEND
+static const QnnGraph_Config_t **saved[4];
+static Qnn_ContextHandle_t contexts[4];
+static size_t saved_count;
+static bool first_free = true;
+static void check(const QnnGraph_Config_t **configs) {
+  assert(configs && configs[0] && configs[1] && !configs[2]);
+  assert(configs[0]->option == QNN_GRAPH_CONFIG_OPTION_PRIORITY);
+  assert(configs[1]->option == QNN_GRAPH_CONFIG_OPTION_CUSTOM);
+  const QnnHtpGraph_CustomConfig_t *c = configs[1]->customConfig;
+  assert(c->option == QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION);
+  assert(!c->advancedActivationFusion);
+}
+static Qnn_ErrorHandle_t create(Qnn_ContextHandle_t context, const char *name,
+    const QnnGraph_Config_t **configs, Qnn_GraphHandle_t *graph) {
+  check(configs);
+  if (strcmp(name, "fail") == 0) return QNN_COMMON_ERROR_GENERAL;
+  assert(saved_count < 4);
+  saved[saved_count] = configs;
+  contexts[saved_count++] = context;
+  *graph = (void *)0x1;
+  return QNN_SUCCESS;
+}
+static Qnn_ErrorHandle_t free_context(Qnn_ContextHandle_t context, Qnn_ProfileHandle_t profile) {
+  (void)profile;
+  // Inspect configuration after graphCreate has returned, across contexts and
+  // after a failed contextFree. The wrapper may release only after success.
+  for (size_t i = 0; i < saved_count; ++i) if (saved[i]) check(saved[i]);
+  if (first_free) { first_free = false; return QNN_COMMON_ERROR_GENERAL; }
+  for (size_t i = 0; i < saved_count; ++i) if (contexts[i] == context) saved[i] = NULL;
+  return QNN_SUCCESS;
+}
+Qnn_ErrorHandle_t QnnInterface_getProviders(const QnnInterface_t ***list, uint32_t *count) {
+  static QnnInterface_t p = QNN_INTERFACE_INIT;
+  static const QnnInterface_t *ps[] = {&p};
+  p.backendId = QNN_BACKEND_ID_HTP;
+  p.apiVersion.coreApiVersion.major = QNN_API_VERSION_MAJOR;
+  p.apiVersion.coreApiVersion.minor = QNN_API_VERSION_MINOR;
+  p.QNN_INTERFACE_VER_NAME.graphCreate = create;
+  p.QNN_INTERFACE_VER_NAME.contextFree = free_context;
+  *list = ps; *count = 1;
+  return QNN_SUCCESS;
+}
+#else
+#include <dlfcn.h>
+int main(int argc, char **argv) {
+  assert(argc == 2);
+  void *lib = dlopen(argv[1], RTLD_NOW | RTLD_LOCAL);
+  if (!lib) { puts(dlerror()); return 1; }
+  typedef Qnn_ErrorHandle_t (*Get)(const QnnInterface_t ***, uint32_t *);
+  Get get = (Get)dlsym(lib, "QnnInterface_getProviders");
+  assert(get && get(NULL, NULL) == QNN_COMMON_ERROR_INVALID_ARGUMENT);
+  const QnnInterface_t **p; uint32_t n;
+  assert(get(&p, &n) == QNN_SUCCESS && n == 1);
+  QnnGraph_Config_t priority = QNN_GRAPH_CONFIG_INIT;
+  priority.option = QNN_GRAPH_CONFIG_OPTION_PRIORITY;
+  const QnnGraph_Config_t *configs[] = {&priority, NULL};
+  Qnn_GraphHandle_t graph = NULL;
+  Qnn_ContextHandle_t a = (void *)0x10, b = (void *)0x20;
+  assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(a, "first", configs, &graph) == QNN_SUCCESS);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(a, "second", configs, &graph) == QNN_SUCCESS);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(b, "third", configs, &graph) == QNN_SUCCESS);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.graphCreate(a, "fail", configs, &graph) == QNN_COMMON_ERROR_GENERAL);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.contextFree(a, NULL) == QNN_COMMON_ERROR_GENERAL);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.contextFree(a, NULL) == QNN_SUCCESS);
+  assert(p[0]->QNN_INTERFACE_VER_NAME.contextFree(b, NULL) == QNN_SUCCESS);
+  puts("configuration forwarding, graph failure and context lifetime passed");
+  return 0;
+}
+#endif

From 084705464931f0c849736a2eb72c0ac1def8a250 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:04:21 +0200
Subject: [PATCH 34/35] Document opt-in QNN paths and measured qualification
 limits

---
 docs/android-causal-prefill.md | 230 ++++++++++++---------------------
 docs/android-qnn-npu.md        |  77 +++++++++++
 2 files changed, 157 insertions(+), 150 deletions(-)
 create mode 100644 docs/android-qnn-npu.md

diff --git a/docs/android-causal-prefill.md b/docs/android-causal-prefill.md
index e19c6d14..02839f06 100644
--- a/docs/android-causal-prefill.md
+++ b/docs/android-causal-prefill.md
@@ -1,180 +1,110 @@
-# Android: experimental same-frame Snapdragon causal prefill
-
-This opt-in profile runs Cinque Terre V3 on the SM8750's Hexagon NPU and
-Adreno GPU in parallel. It does not replace Automatic, NPU, or the existing
-sequential NPU + GPU setting. It is limited to one validated model export and
-one matched runtime stack; unsupported inputs fail with an error.
-
-The Xiaomi 15 prototype completed a ten-minute, 20 Hz synthetic benchmark:
-**27.2 ms mean, 29.5 ms P99, 36.2 ms max, 12,001 frames, zero over 50 ms**.
-The original CPU accuracy gates passed on 128 identical synthetic frames before
-and after the sustained run. [Screenshot, accuracy logs and machine-readable
-results](evidence/sm8750-causal-prefill/README.md) distinguish the measured
-prototype from the upstream port. Physical comma USB, car charging and road
-behavior have not been validated by these results.
-
-## Why this can overlap without adding a frame of delay
-
-The model's eight attention masks are causal. Historical queries cannot read
-the current image tokens, so the GPU can compute the 256 historical tokens
-while the NPU computes the current image's vision features. The NPU then runs
-the 32 current queries against **all 288 original keys and values**. Nothing is
-reused from an earlier image to substitute for current-frame work.
-
-```mermaid
-flowchart LR
-  I[Current image and image history] --> V[NPU: vision]
-  H[Feature and desire history] --> P[GPU: historical tokens and K/V]
-  V --> D[NPU: current queries against past and current K/V]
-  P --> D
-  D --> J[CPU: original output and queue assembly]
-  V --> J
-  J --> O[Same-frame output and next recurrent state]
-```
+# Experimental Android causal prefill
+
+This build-time opt-in overlaps Cinque Terre V3's current-image vision work on
+HTP with its historical-token work on the QNN GPU. HTP decode waits for both,
+then a small CPU graph assembles the original outputs and next queues. Current
+queries still attend to all 288 original keys and values; no previous-frame
+answer replaces current-frame computation.
 
-`SessionDAG` derives completion barriers from graph I/O, rejects cycles and
-multiple writers, and joins every worker before returning an error. The engine
-double-buffers recurrent state and binds HTP sessions to host-accessible RPC
-allocations. GPU and CPU sessions use ordinary CPU tensor metadata over those
-pointers. They do not claim to be QNN shared allocators.
+The scheduler and provider discovery are generic. The graph split is deliberately
+limited to the exact CTV3 export below. Other models select the existing whole-NPU
+route **before preparation**; the sidecar records that route and Settings reports
+NPU. A missing or altered CTV3 bundle, unsupported operator/provider, allocation
+failure or inference error fails explicitly. Such errors do not trigger a silent
+CPU fallback or a different graph.
 
-The existing fp16 normalization expression is prescaled by 1/4, with epsilon
-divided by 16, to keep intermediates in range without expanding each native
-LayerNormalization into many slower operations. This preserves the real-valued
-formula, not bitwise floating-point results. Original CPU output gates remain
-the acceptance criterion. The HTP graph adapter disables advanced activation
-fusion; it forwards the other backend functions and retains custom graph
-configuration until context destruction.
+There is no SM8750, manufacturer, HTP architecture or ORT-version whitelist.
+The normal QNN backend discovers hardware using the runtime/DSP libraries the
+build ships. This does not establish numerical correctness or speed on every
+Snapdragon. Run original-model accuracy checks and sustained tests on each
+device/runtime/firmware before relying on it. Existing Automatic and processor
+defaults remain unchanged.
 
-## Reproduce the exact model bundle
+## Generate the source-only bundle
 
-Tested tools: Swift 6.4, Python 3.12, ONNX 1.23.2, NumPy 2.5.4, ORT 1.29.0,
-NDK r30, Android API 31 native target, QAIRT 2.47.0.260601 and HTP v79.
-Use the original catalog export with SHA-256:
+Use the normal Android/Swift build prerequisites and the original catalog ONNX:
 
 ```
-404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4
+SHA-256: 404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4
+Size: 766354845 bytes
 ```
 
-From a Linux checkout with the [Android build prerequisites](../android/README.md):
-
 ```bash
 python3 -m venv .venv-prefill
 .venv-prefill/bin/python -m pip install -r scripts/android/requirements-causal-prefill.txt
 swift build --package-path JetlinkKit --product jetlink-prefill-base
 BASE_TOOL="$(swift build --package-path JetlinkKit --show-bin-path)/jetlink-prefill-base"
 .venv-prefill/bin/python scripts/android/compile_causal_prefill.py \
-  --model /path/to/404a18cfd86d2963.onnx \
-  --base-tool "$BASE_TOOL" --out /path/to/causal-prefill-v1
+  --model /path/to/original.onnx --base-tool "$BASE_TOOL" \
+  --out /path/to/NEW-causal-prefill-v1
 ```
 
-The output directory must be empty. The compiler checks the original model
-hash, the intermediate graph hash, all four final graph hashes, and the exact
-manifest bytes against the phone-tested bundle. The app independently verifies
-the source model, manifest and each part before copying into its private cache.
-This is deliberately a model-specific compiler, not a general ONNX optimizer.
-No weights, output slices, correlation thresholds or feedback contract are changed.
+The compiler checks the full source, prepared-base, four-part and manifest
+identities, and rejects Python `-O`. It preserves original learned weights,
+precision, output slices and recurrent contract. The legacy metadata cache-key
+string in the base helper is retained solely to reproduce the historical graph
+bytes; it is not a hardware selector. Model weights and compiled contexts are
+not distributed in the source tree.
 
-## Build the opt-in Android app
-
-Obtain QAIRT 2.47.0.260601 through Qualcomm's normal SDK distribution. Vendor
-headers, libraries and model weights are not redistributed in this repository.
-Use the complete matching HTP, GPU, prepare, system, IR, saver and v79 stub/skel
-set: mixing an older Maven runtime with newer DSP libraries does not work.
+## Build and stage
 
 ```bash
-export QNN_SDK_ROOT=/path/to/qairt/2.47.0.260601
-export ANDROID_NDK_HOME=/path/to/android-ndk-r30
-bash android/qnn/build.sh /path/to/qairt-jni
 cd android
 ./gradlew :app:assembleRelease :app:testDebugUnitTest \
-  -Pjetlink.causalPrefill=true -Pjetlink.qairtJniDir=/path/to/qairt-jni
+  -Pjetlink.causalPrefill=true -Pjetlink.qnnSharedIO=true
 ```
 
-The helper builds and tests the small graph adapter, then locates the eight
-vendor libraries by their pinned byte hashes. Gradle verifies those same
-hashes, requires the adapter and replaces the Maven QNN runtime only for this
-opt-in build. Ordinary builds require no new SDK or property.
-
-Install with the project's existing signing/install workflow. An APK signed
-with a different key cannot update the official APK in place; preserve app
-data and the previous APK before changing a locally signed installation.
-
-Stage only the four ONNX files and manifest generated above into the app's
-external files directory. For a USB-debugging development device:
+Ordinary builds hide and reject the experimental choice. The experimental
+profile always disables CPU EP fallback in its HTP and GPU sessions, including
+HTP context compilation and reload. Shared I/O is optional: only actual HTP
+allocators label tensors `QnnHtpShared`; GPU and CPU bindings use host metadata.
+The engine retains allocations, sessions and bindings in the required order.
+
+The historical Xiaomi experiment required disabling advanced HTP activation
+fusion to pass its original accuracy gates. To reproduce that numerical path,
+build the optional adapter and **one complete matching SDK runtime** as described
+in [Android QNN policy](android-qnn-npu.md), adding
+`-Pjetlink.qnnNoActivationFusion=true -Pjetlink.qnnJniDir=/path/to/NEW-qnn-jni`
+to the command above. No fixed SDK binary hashes or SoC settings are imposed.
+Actual SDK library bytes identify its separate cache namespace. The generic
+stock-runtime path still needs independent numerical qualification.
+
+Stage only generated `vision.onnx`, `history.onnx`, `decode.onnx`, `join.onnx`
+and `manifest.json` into the app's external files directory, using the project's
+normal signing/install workflow. For an unlocked development device:
 
 ```bash
 BUNDLE=/sdcard/Android/data/io.zoompilot.jetlink.android/files/causal-prefill-v1
 adb shell mkdir -p "$BUNDLE"
-adb push /path/to/causal-prefill-v1/. "$BUNDLE/"
+adb push /path/to/NEW-causal-prefill-v1/. "$BUNDLE/"
 adb shell chmod 755 "$BUNDLE"
-adb shell chmod 644 "$BUNDLE/vision.onnx" "$BUNDLE/history.onnx" \
-  "$BUNDLE/decode.onnx" "$BUNDLE/join.onnx" "$BUNDLE/manifest.json"
+adb shell chmod 644 "$BUNDLE"/*.onnx "$BUNDLE/manifest.json"
 ```
 
-The directory must be traversable by the app; an ADB-created shell-only 770
-directory prevents loading. Select **NPU + GPU (experimental)** on an SM8750.
-The existing NPU + GPU choice remains the original sequential profile. Keep
-the original Cinque Terre V3 model downloaded/imported in Jetlink as usual.
-Enable Keep NPU awake, Keep CPU awake and Keep screen on to reproduce the
-measured configuration. Initial HTP compilation can take several minutes. Missing or different bundles
-produce an error; there is no silent substitution of another model or CPU work.
-
-## Validation and limits
-
-The measured prototype used shared I/O, burst mode, CPU performance hints and
-the screen awake. Airplane mode with Wi-Fi and Bluetooth off stabilized the
-test conditions. It was not counted as an inference optimization.
-
-| Run | Duration | Mean | P99 |
-| --- | --- | --- | --- |
-| Range-safe NPU-only control | 1 minute | 33.8 ms | 34.7 ms |
-| Same four graphs, shared buffers, serial control | 1 minute | 45.2 ms | 47.2 ms |
-| Causal parallel, ordinary heap buffers | 1 minute | 27.6 ms | 30.5 ms |
-| Causal parallel, shared buffers | 1 minute | 26.8 ms | 29.0 ms |
-| Normal USB-capable prototype, causal parallel/shared | 10 minutes | 27.2 ms | 29.5 ms |
-
-These were sequential runs on one phone, without randomized order or fixed
-temperature/clocks. Provider API spans overlap by about 22.1 ms in the sustained
-run; this and the identical-graphs serial control demonstrate useful concurrent
-execution. They do **not** establish an NPU/GPU busy percentage. Available QNN
-profiling events did not provide comparable hardware timestamps, so there is no
-claim of 100% accelerator utilization. See [ORT's QNN provider documentation](https://onnxruntime.ai/docs/execution-providers/QNN-ExecutionProvider.html)
-for shared memory and fallback configuration.
-
-The phone's battery temperature rose from 36.6°C to 45.4°C and battery charge
-fell from 62% to 55% despite PC USB power. Every recorded Android thermal status
-and all 61 benchmark windows remained Normal. That status does not mean the
-phone was cool or that a car adapter can sustain charging. Test the actual
-mount, cable, power adapter and comma connection while parked before any use.
-
-The prototype's two 128-frame checks use the unchanged original CPU model,
-identical inputs and independent recurrent state on both sides. The checked-in
-logs include per-slice/per-column results and the original 0.999-correlation or
-existing quiet-output error fallback. Synthetic correctness is not a driving
-validation or a guarantee for every input, temperature or firmware update.
-
-For another phone accuracy capture, use the existing `scripts/verify_parity.py`
-without changing its comparison thresholds. With the original model already
-cached, the new profile loaded, and Developer mode enabled, a parked development
-device can be checked over an ADB TCP forward:
-
-```bash
-adb forward tcp:15599 tcp:5599
-python scripts/verify_parity.py capture --host 127.0.0.1 --port 15599 \
-  --sha256 404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4 \
-  --nbytes 766354845 --n 128 --dir parity-prefill
-python scripts/verify_parity.py reference --onnx /path/to/404a18cfd86d2963.onnx --dir parity-prefill
-python scripts/verify_parity.py compare --dir parity-prefill
-adb forward --remove tcp:15599
-```
-
-For a developer serial control, set `parallel_serial: true` in the native start
-configuration, keeping the same graphs and shared buffers. Its artifact tag is
-separate. With Developer mode enabled, `parallel-stages.json` records synchronous
-provider-call timing spans in the external files directory. Disable Developer
-mode after collecting a test; the comma does not need the TCP listener.
-
-To stop using the experiment, choose an existing processor setting. Automatic
-and existing profiles retain their original options and caches. Reinstalling a
-previous APK signed with the same key is a separate local rollback option.
+Keep the original CTV3 model available in Jetlink and select **NPU + GPU
+(experimental)**. The app verifies source/manifest/part hashes before copying;
+reload verifies the exact session contract and retained GPU/assembly graphs.
+Contexts compile locally for the device. Do not transfer another phone's
+compiled contexts; rebuild and recheck accuracy after firmware/runtime changes.
+
+## Validation and evidence
+
+`SessionDAG` derives barriers from typed graph I/O and rejects cycles/multiple
+writers. All branches join before an error escapes. Recurrent parity advances
+only after a successful frame. Focused tests exercise reordered sessions,
+serial/parallel recurrent equivalence, reset, worker failure, generic provider
+options, model routing and invalid bundle/cache metadata.
+
+A historical Xiaomi 15 prototype measured **27.2 ms mean / 29.5 ms P99** across
+12,001 synthetic frames at 20 Hz, with original 128-frame accuracy checks before
+and after. Its exact four graphs measured **45.2 / 47.2 ms serial** versus
+**26.8 / 29.0 ms parallel** in shorter sequential runs. These are historical
+prototype measurements, not measurements of this portable port or another phone.
+[Immutable prototype evidence](https://github.com/joe-sama/jetlink/blob/e681e507b5e83384f3316da1d25b4cce823e5ea9/docs/evidence/sm8750-causal-prefill/README.md)
+retains the logs, screenshot, identities and thermal limitations.
+
+Use the existing `scripts/verify_parity.py` capture/reference/compare flow with
+the original model, 128 identical inputs and unchanged gates, including recurrent
+resets. Compare the same graphs serially and in parallel, then run a sustained
+benchmark and cold reload. Hardware occupancy, a universal speedup and vehicle
+readiness are not established by the host tests or provider-call concurrency.
diff --git a/docs/android-qnn-npu.md b/docs/android-qnn-npu.md
new file mode 100644
index 00000000..ae0e92c2
--- /dev/null
+++ b/docs/android-qnn-npu.md
@@ -0,0 +1,77 @@
+# Optional Android QNN HTP policy
+
+Ordinary builds retain the existing profiles, QNN runtime, provider options and
+cache names. Three independent build-time options are available:
+
+| Gradle property | Effect |
+| --- | --- |
+| `jetlink.qnnSharedIO=true` | Allocate host tensors through ORT's actual QNN HTP shared allocator and bind them with the matching memory information. |
+| `jetlink.qnnStrict=true` | Disable CPU execution-provider fallback in HTP sessions during both compilation and reload. Unsupported graphs fail instead of silently leaving compute on CPU. |
+| `jetlink.qnnNoActivationFusion=true` | Use the optional matching-SDK adapter to disable advanced HTP activation fusion, a numerical workaround. |
+
+All default to false. The policy is typed; JSON configuration accepts Booleans,
+not strings or numeric substitutes. GPU and CPU sessions do not register their
+bindings as HTP shared memory. These policy options leave original models and
+preparation unchanged; the optional causal profile is documented separately in
+[android-causal-prefill.md](android-causal-prefill.md).
+
+For shared I/O and strict HTP admission using the normal runtime:
+
+```bash
+cd android
+./gradlew :app:assembleRelease :app:testDebugUnitTest \
+  -Pjetlink.qnnSharedIO=true -Pjetlink.qnnStrict=true
+```
+
+The optional adapter requires locally obtained headers and libraries from one
+matching Qualcomm SDK. Vendor headers, libraries and models are not included or
+downloaded. Use the project's normal Android/Swift build prerequisites, then:
+
+```bash
+export QNN_SDK_ROOT=/path/to/one/qairt-sdk
+export ANDROID_NDK_HOME=/path/to/android-ndk
+bash android/qnn/build.sh /path/to/NEW-qnn-jni
+cd android
+./gradlew :app:assembleRelease :app:testDebugUnitTest \
+  -Pjetlink.qnnSharedIO=true -Pjetlink.qnnStrict=true \
+  -Pjetlink.qnnNoActivationFusion=true -Pjetlink.qnnJniDir=/path/to/NEW-qnn-jni
+```
+
+The helper runs a host forwarding/lifetime test, builds the adapter and stages
+Android libraries plus available matched HTP stub/skel pairs from that same SDK.
+The SDK must expose `QNN_HTP_GRAPH_CONFIG_OPTION_ADVANCED_ACTIVATION_FUSION`.
+The adapter forwards the public backend interface and disables only this option.
+It retains custom configuration through successful `contextFree`, including when
+the backend consumes configuration after graph creation. API incompatibility,
+missing libraries, missing allocators or unsupported graphs produce errors.
+
+Gradle replaces the transitive Maven QNN runtime only in this explicit adapter
+build, avoiding a mixture of runtimes. It fingerprints the actual staged library
+bytes for the cache namespace; these are not fixed vendor-binary or SoC pins.
+The runtime directory and identity flow through `QnnPolicy`, without global
+tuning variables. Each changed policy has a different HTP cache namespace.
+
+## Evidence and limits
+
+On one Xiaomi 15 / Snapdragon 8 Elite, a historical whole-NPU CTV3 test using
+ORT 1.29 and QAIRT 2.47 compared the same range-safe prepared graph with stock
+advanced activation fusion versus fusion disabled. The stock capture failed
+**six output slices** despite finite values; the disabled-fusion capture passed
+all original gates across **32 identical input frames**. This establishes a
+numerical workaround for that tested stack, not a universal cause or speedup.
+The preparation used in that experiment is not added or changed here.
+
+A separate sequential one-minute comparison of the same whole-NPU engine
+reported ordinary memory **42.9 ms mean / 45.2 ms P99**, versus shared I/O
+**40.5 ms mean / 42.2 ms P99**. The mean reduction was about 5.6%. Order,
+temperature and clocks were not fully controlled, so this is indicative evidence,
+not a general performance guarantee. Strict fallback prevention is a correctness
+contract rather than a speed optimization. None of these measurements establishes
+50% improvement, 100% NPU occupancy or vehicle readiness.
+
+Before promoting an option on another graph/runtime/device, retain original
+precision and use the unchanged original-model parity gates on identical inputs
+with independent recurrent state, including reset tests. Compare alternating
+heap/shared runs under similar temperatures, then perform sustained and cold-load
+tests. Record exact runtime/options, package/native identities and mean/P99/max.
+The current patch's host tests do not qualify an HTP device or a car connection.

From 41cc554f2a85505452ff7e5f236e8f9fe5295c38 Mon Sep 17 00:00:00 2001
From: joe-sama <56972578+joe-sama@users.noreply.github.com>
Date: Sat, 24 Oct 2026 15:04:48 +0200
Subject: [PATCH 35/35] Android: compile pinned causal bundle without
 device-specific gates

---
 scripts/android/compile_causal_prefill.py | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/scripts/android/compile_causal_prefill.py b/scripts/android/compile_causal_prefill.py
index cae4d41b..7ca5ac90 100644
--- a/scripts/android/compile_causal_prefill.py
+++ b/scripts/android/compile_causal_prefill.py
@@ -23,9 +23,21 @@
 parser.add_argument("--out", type=Path, required=True)
 parser.add_argument("--base-tool", type=Path, required=True, help="built jetlink-prefill-base executable")
 args = parser.parse_args()
+if not __debug__:
+  parser.error("Python -O disables the model-contract assertions; run without -O")
+
+
+def sha256(path):
+  digest = hashlib.sha256()
+  with path.open('rb') as stream:
+    for block in iter(lambda: stream.read(8 * 1024 * 1024), b''):
+      digest.update(block)
+  return digest.hexdigest()
+
+
 assert onnx.__version__ == "1.23.2", "reproduction is pinned to onnx==1.23.2"
 assert np.__version__ == "2.5.4", "reproduction is pinned to numpy==2.5.4"
-assert hashlib.sha256(args.model.read_bytes()).hexdigest() == "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4", (
+assert sha256(args.model) == "404a18cfd86d29637d20c697dfde245bb47c666ae016730ab674c65f4d1e1aa4", (
   "only the validated Cinque V3 export is supported"
 )
 OUT = args.out.resolve()
@@ -34,7 +46,7 @@
 temporary = tempfile.TemporaryDirectory(prefix="jetlink-prefill-base-")
 source = Path(temporary.name) / "model.onnx"
 subprocess.run([str(args.base_tool.resolve()), str(args.model.resolve()), temporary.name], check=True)
-assert hashlib.sha256(source.read_bytes()).hexdigest() == "4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166", (
+assert sha256(source) == "4ef3b6f248bf8d3ae0e1f76cfd0d5fcc4f079b6d910f735bd4cc22172b0d0166", (
   "base graph differs from the phone-validated graph"
 )
 m = onnx.load(source)
@@ -251,11 +263,10 @@ def constant(name, arr):
     'weight_bytes': sum(len(t.raw_data) for t in part.graph.initializer),
     'inputs': [v.name for v in part.graph.input],
     'outputs': [v.name for v in part.graph.output],
-    'sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
+    'sha256': sha256(path),
   }
   records.append(record)
   print(json.dumps(record), flush=True)
-(OUT / 'plan.json').write_text(json.dumps(records, indent=2))
 (OUT / 'manifest.json').write_text(
   json.dumps(
     {
@@ -270,7 +281,6 @@ def constant(name, arr):
 )
 print('Saved exact same-frame (vision || history) -> decode -> join.', flush=True)
 
-expected = json.loads(Path(__file__).with_name("causal-prefill-manifest.json").read_text())
 assert (OUT / "manifest.json").read_bytes() == Path(__file__).with_name("causal-prefill-manifest.json").read_bytes(), (
   "generated bundle differs from the validated bundle"
 )