diff --git a/.gitignore b/.gitignore index cd7af538..ddc0ccc9 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,5 @@ google-services.json # 양자화본은 그 아래라 그대로 올라간다. git 은 큰 바이너리를 지우지 못해 한 번 들어가면 # 이후 모든 clone 이 비용을 낸다. 릴리스 AAB 는 이 파일이 있는 로컬에서 만든다(docs/RELEASE.md). *.onnx +# LiteRT 모델(NM-628). 정본은 ML DVC — 받는 법은 docs/RELEASE.md, 목록은 app/models.md5. +*.tflite diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 1dcf13d7..db788e36 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -57,44 +57,16 @@ android { namespace = "app.nursemate" /* - * 조건부 전달 모듈 — **퀄컴 기기에만** 내려간다. - * - * `qnn-runtime` 이 arm64 비압축 180MB 인데 Hexagon NPU 가 없는 기기에는 한 바이트도 - * 쓸모가 없다. base 에 넣으면 엑시노스·Dimensity·Tensor 사용자가 쓰지도 않을 180MB 를 - * 받는다. 어느 기기에 내려줄지는 `src/main/device_targeting_configuration.xml` 이 정하고, - * 조건 자체는 `qnn/src/main/AndroidManifest.xml` 의 `` 가 건다. - * - * ⚠️ 이 메커니즘은 **번들(AAB)에만** 산다. `assembleRelease` 로 뽑은 APK 에는 feature - * 모듈이 통째로 들어간다 — 크기를 볼 때는 `bundleRelease` + bundletool 로 본다. + * LiteRT AAR 에 딸려 오는 **퀄컴 NPU 용** `.so` 를 뺀다 — NPU 는 2.1.0 범위 밖이다(NM-628). + * `libLiteRtDispatch_Qualcomm` · `libLiteRtCompilerPlugin_Qualcomm` 합 1.2MB(arm64). 없으면 NPU 를 + * 등록하지 못한다는 경고만 찍고(`npu_registry.cc`) GPU · CPU 는 그대로 돈다. */ - /* - * **`.so` 를 실파일로 푼다** — QNN 이 이것 없이는 조용히 CPU 로 돈다. - * - * AGP 기본값(`extractNativeLibs=false`)은 `.so` 를 APK 안에 비압축으로 두고 링커가 거기서 - * 바로 읽는다. 디스크에 파일이 생기지 않으므로 `applicationInfo.nativeLibraryDir` 이 **빈 - * 디렉터리**다. 2026-10-14 Test Lab(dm1q·SM8550)에서 확인했다 — `libDir 안 0개`. - * - * 그런데 HTP 는 DSP 쪽 skel 을 **FastRPC 로 파일에서** 올린다. ORT 는 그 경로를 - * `backend_path` 의 디렉터리에서 만들어 `ADSP_LIBRARY_PATH` 에 넣는데 - * ([OrtBackend.qnnNativeLibDir]), 그 디렉터리가 비어 있으면 `cannot open - * libQnnHtpV73Skel.so, errno 2` 로 떨어지고 **EP 가 노드를 하나도 안 가져간다.** - * 세션은 열리고 답도 맞아서 겉보기엔 성공이다 — 느린 것만이 증거다. - * - * ⚠️ 대가는 **설치 용량**이다. 압축본(APK 안)과 푼 사본이 둘 다 디스크를 쓴다. 대신 - * 다운로드는 줄어든다 — 비압축 저장이 아니라 압축돼 전송되기 때문이다. - */ - packaging { jniLibs { useLegacyPackaging = true } } - - dynamicFeatures += setOf(":qnn_core", ":qnn_v69", ":qnn_v73", ":qnn_v75", ":qnn_v79", ":qnn_v81") - - /* - * 어느 기기에 `:qnn` 을 내려줄지 — **경로를 명시해야 한다.** - * - * `src/main/device_targeting_configuration.xml` 에 두기만 하면 AGP 가 **조용히 무시한다.** - * 처음에 그렇게 뒀더니 번들은 멀쩡히 빌드되는데 `BUNDLE-METADATA` 에 설정이 안 들어갔고, - * 그러면 조건이 없는 셈이라 **180MB 가 전 기기에 깔린다.** 빌드가 알려 주지 않는다. - */ - bundle.deviceTargetingConfig = file("src/main/device_targeting_configuration.xml") + packaging { + jniLibs { + excludes += + setOf("**/libLiteRtDispatch_Qualcomm.so", "**/libLiteRtCompilerPlugin_Qualcomm.so") + } + } defaultConfig { applicationId = "app.nursemate" @@ -140,7 +112,7 @@ android { kakaoAppKey(secret("KAKAO_APP_KEY_RELEASE")) airbridge(secret("AIRBRIDGE_APP_NAME"), secret("AIRBRIDGE_APP_TOKEN")) - // ⚠️ **네이티브 심볼을 올려야 `libonnxruntime.so` 스택이 함수명으로 보인다.** + // ⚠️ **네이티브 심볼을 올려야 `libLiteRt.so` · GPU 드라이버 스택이 함수명으로 보인다.** // 이게 없으면 주소만 남아, 정확히 이번에 겪은 상황(원격에서 스택을 못 읽음)이 반복된다. // // release 에만 건다 — debug 는 R8 을 안 써서 올릴 매핑이 없고, 네이티브 심볼도 @@ -223,8 +195,6 @@ dependencies { testImplementation(libs.junit) testImplementation(libs.kotlin.test) - // 조건부 feature module 이 실제로 설치됐는지는 **설치된 앱에서만** 볼 수 있다 — - // `QnnModuleProbeTest` 가 `nativeLibraryDir` 과 splitNames 를 찍는다. androidTestImplementation(libs.junit) androidTestImplementation(libs.androidx.test.runner) androidTestImplementation(libs.androidx.test.ext.junit) @@ -233,20 +203,21 @@ dependencies { androidTestImplementation(libs.androidx.compose.ui.test.junit4) } -// R8 이 ONNX Runtime · OpenCV 의 클래스 이름을 바꾸지 않았는지 **매핑으로** 확인한다. +// R8 이 LiteRT · OpenCV 의 클래스 이름을 바꾸지 않았는지 **매핑으로** 확인한다. +// +// `KNOWN-ISSUES.md` ⑩ — 릴리스에서만 알약 식별이 100% SIGABRT 로 죽었다(0.2.1~0.2.3, 그때는 ONNX Runtime). +// 네이티브 쪽이 결과를 JVM 으로 돌려줄 때 클래스를 **이름으로** 찾는데, Java 코드가 그 클래스들을 직접 +// 만들지 않아 R8 이 지우거나 바꿔도 되는 것으로 본다. // -// `KNOWN-ISSUES.md` ⑩ — 릴리스에서만 알약 식별이 100% SIGABRT 로 죽었다(0.2.1~0.2.3). -// ONNX Runtime 의 네이티브 쪽이 추론 **결과를 JVM 으로 돌려줄 때** 클래스를 이름으로 찾는데 -// (`FindClass("ai/onnxruntime/TensorInfo")` → `GetMethodID`), Java 코드가 그 클래스들을 직접 -// 부르지 않아 R8 이 지워도 되는 것으로 본다. 지금은 `proguard-rules.pro` 의 -// `-keep class ai.onnxruntime.** { *; }` 가 막고 있다. +// LiteRT 도 같은 부류다(NM-628). `liblitert_jni.so` 가 `LiteRtException` · `TensorBufferRequirements` · +// `TensorType`(+`ElementType` · `Layout`)을 이름으로 찾는다(문자열로 확인 — 2026-10-19). AAR 에 딸린 R8 규칙은 +// `org.tensorflow.lite` 애노테이션만 지켜서 **이 클래스들은 막아 주지 않는다.** `proguard-rules.pro` 의 +// `-keep class com.google.ai.edge.litert.** { *; }` 가 막는다. // -// ⚠️ **그 keep 이 사라지면 빌드는 멀쩡히 성공하고 사용자만 죽는다.** 컴파일도 단위 테스트도 -// 아무 말을 하지 않는다. 그런데 증거는 매핑 파일에 그대로 남는다 — ⑩ 문서가 적어 둔 형태가 -// 바로 이것이다: +// ⚠️ **그 keep 이 사라지면 빌드는 멀쩡히 성공하고 사용자만 죽는다.** 그런데 증거는 매핑 파일에 남는다: // -// 살아 있을 때: ai.onnxruntime.TensorInfo -> ai.onnxruntime.TensorInfo: -// 깨졌을 때: ai.onnxruntime.TensorInfo -> at4: +// 살아 있을 때: com.google.ai.edge.litert.TensorType -> com.google.ai.edge.litert.TensorType: +// 깨졌을 때: com.google.ai.edge.litert.TensorType -> at4: // // 그래서 매핑을 읽어 대조한다. 에뮬레이터로 실제 추론을 돌려 보는 길도 있었지만, 그러자면 // 계측 테스트를 minify 된 앱에 붙여야 하고 그러면 테스트 하네스가 요구하는 것들을 @@ -261,11 +232,11 @@ dependencies { androidComponents { // JNI 가 이름으로 찾는 것들. 하나라도 리네임되면 그 타입이 나오는 순간 프로세스가 죽는다. val jniLookedUp = listOf( - "ai.onnxruntime.TensorInfo", - "ai.onnxruntime.OnnxTensor", - "ai.onnxruntime.MapInfo", - "ai.onnxruntime.SequenceInfo", - "ai.onnxruntime.OnnxJavaType", + "com.google.ai.edge.litert.LiteRtException", + "com.google.ai.edge.litert.TensorBufferRequirements", + "com.google.ai.edge.litert.TensorType", + "com.google.ai.edge.litert.TensorType${'$'}ElementType", + "com.google.ai.edge.litert.TensorType${'$'}Layout", // OpenCV 도 같은 부류다(NM-485). 네이티브가 이름으로 찾는 값 타입들이다. "org.opencv.core.Mat", "org.opencv.core.Size", @@ -275,7 +246,7 @@ androidComponents { onVariants(selector().withBuildType("release")) { variant -> val mapping = variant.artifacts.get(SingleArtifact.OBFUSCATION_MAPPING_FILE) - val verify = tasks.register("verify${variant.name.replaceFirstChar(Char::uppercase)}OnnxKeep") { + val verify = tasks.register("verify${variant.name.replaceFirstChar(Char::uppercase)}JniKeep") { inputs.file(mapping).withPropertyName("mapping") doLast { val file = mapping.get().asFile @@ -286,7 +257,7 @@ androidComponents { file.useLines { lines -> for (line in lines) { // 클래스 줄만 본다 — 멤버 줄은 들여쓰기가 있다. - // ⚠️ 접두사를 박아 두지 않는다. `"ai.onnxruntime."` 로 하드코딩했다가 + // ⚠️ 접두사를 박아 두지 않는다. `"ai.onnxruntime."` 로 하드코딩했다가(ORT 시절) // OpenCV 를 목록에 더했을 때 그 줄을 통째로 건너뛰어, 멀쩡히 있는 // 클래스를 「매핑에서 찾지 못했다」로 잘못 읽었다(NM-485). if (line.isEmpty() || line[0].isWhitespace() || line[0] == '#') continue @@ -305,7 +276,7 @@ androidComponents { R8 이 네이티브가 이름으로 찾는 클래스를 바꿨습니다 — 릴리스에서 알약 식별이 죽습니다. ${renamed.joinToString("\n")} - `proguard-rules.pro` 의 `-keep class ai.onnxruntime.**` · `org.opencv.**` 를 확인하십시오. + `proguard-rules.pro` 의 `-keep class com.google.ai.edge.litert.**` · `org.opencv.**` 를 확인하십시오. 사정은 docs/KNOWN-ISSUES.md ⑩. """.trimIndent() } @@ -329,7 +300,7 @@ androidComponents { // 릴리스 산출물에 모델이 빠지거나 **정본이 아닌 것이 들어가지 않게** 막는다. // -// 모델은 저장소에 넣지 않으므로(.gitignore 의 *.onnx) 파일이 없어도 빌드는 그냥 성공한다 — +// 모델은 저장소에 넣지 않으므로(.gitignore 의 *.tflite) 파일이 없어도 빌드는 그냥 성공한다 — // 그 AAB 를 올리면 사용자는 식별을 시도할 때마다 '분석 실패'만 본다. // 조용히 깨진 릴리스보다 큰 소리로 실패하는 편이 낫다. // diff --git a/app/models.md5 b/app/models.md5 index 06fda74f..2b1c4fab 100644 --- a/app/models.md5 +++ b/app/models.md5 @@ -4,7 +4,11 @@ # (`s3://nursemate-ml-models/files/md5/<앞2>/<나머지>`), 이 파일 하나로 받는 경로와 검사가 # 동시에 정해진다. Gradle 가드와 CI 가 **같은 파일**을 읽으므로 둘이 갈라질 수 없다. # -# 절차는 docs/RELEASE.md 「검출 모델」. -cb20efc7d45a9104226fd86a1c019885 rfdetr_seg_small.onnx -8e574cd5f9db305414f836ccdf20ee2e reader_ep60_s1.onnx -b87ab569eb08dbcd7ee4823a6254b9d3 mark_species_fp16.onnx +# 절차는 docs/RELEASE.md 「검출 모델」. LiteRT(NM-628) — 각인은 다섯 조각(p1~p5)이 한 모델이다. +f92baeefa1a68129580332e346fe6564 rfdetr_seg_small_f16w.tflite +905774ae81ffcc8f30b054792aa661de mark_m4_f16w.tflite +8f05e999616f01a8a85f33103819df35 p1_loc.tflite +83ae532760f9773b81c1684c3b164cdd p2_tps.tflite +4499aa1eadfc152bcb78c19cd24508be p3_trunk.tflite +eb22da14f217c13aa98a4074c7568a9c p4_frm.tflite +c52617b06e241999daa267353c9cb89d p5_lstm_head.tflite diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro index e05564f5..c1b97013 100644 --- a/app/proguard-rules.pro +++ b/app/proguard-rules.pro @@ -18,24 +18,25 @@ -keep @interface com.kakao.sdk.common.model.Description -keepattributes RuntimeVisibleAnnotations, AnnotationDefault -# ONNX Runtime — onnxruntime-android AAR에 consumer rules가 없다(직접 확인, 2026-09-17). -# 네이티브 쪽이 추론 결과를 JVM으로 돌려줄 때 클래스를 **이름으로** 찾는다 -# (`OrtJniUtil.c` → `FindClass("ai/onnxruntime/TensorInfo")` → `GetMethodID`). -# R8이 그 이름을 바꾸면 FindClass가 null을 주고, 그 null이 GetMethodID로 들어가는 순간 -# ART가 "JNI DETECTED ERROR IN APPLICATION: java_class == null" 로 프로세스를 죽인다. -# Java 코드는 이 클래스들을 직접 부르지 않아 R8 입장에선 지우거나 바꿔도 되는 것으로 보인다. +# LiteRT — 온디바이스 추론 런타임(NM-628). ONNX Runtime 시절 ⑩ 과 **같은 부류의 위험**이다. +# `liblitert_jni.so` 가 결과를 JVM 으로 돌려줄 때 `LiteRtException` · `TensorBufferRequirements` · +# `TensorType`(+`ElementType` · `Layout`)을 **이름으로** 찾는다(`.so` 문자열로 확인, 2026-10-19). +# R8 이 그 이름을 바꾸면 FindClass 가 null 을 주고, 그 null 이 GetMethodID 로 들어가는 순간 ART 가 +# "JNI DETECTED ERROR IN APPLICATION" 으로 프로세스를 죽인다 — 릴리스에서만. # -# 알약 식별을 누르면 릴리스에서만 100% SIGABRT 였다(0.2.1~0.2.3 전부, 실기기·에뮬레이터 확인). -# 검출 자체는 성공하고 **결과를 읽는 단계**에서 죽어, 원인이 추론 엔진처럼 보였다 — -# ONNX 버전을 1.29.0 → 1.22.0 으로 내렸지만 R8 문제라 아무 효과가 없었다. +# AAR 에 딸린 규칙(`proguard.txt`)은 `org.tensorflow.lite.annotations.UsedByReflection` 만 지켜서 +# 위 클래스들을 막아 주지 않는다. 패키지 통째로 남긴다 — Kotlin API 표면이 작아 크기 영향이 없다. +# 같은 일을 `app/build.gradle.kts` 의 매핑 가드가 빌드 때 확인한다. # -# 패키지 통째로 남긴다. JNI가 이름으로 찾는 대상이 TensorInfo 하나가 아니라 -# OnnxTensor·OnnxMap·OnnxSequence·MapInfo·SequenceInfo·OnnxJavaType·OrtException 등 -# 여럿이고, 어느 것이 언제 불리는지는 모델 출력 타입에 따라 달라진다. Java API 표면은 -# 작아서(수십 KB) 남겨도 크기 영향이 없다. --keep class ai.onnxruntime.** { *; } +# ONNX Runtime 시절 사정(0.2.1~0.2.3 릴리스 100% SIGABRT)은 docs/KNOWN-ISSUES.md ⑩. +-keep class com.google.ai.edge.litert.** { *; } -# OpenCV — 각인 OCR 전처리(NM-485). ONNX Runtime 과 **같은 부류의 위험**이다(⑩). +# `core:vision` 이 LiteRT 에서 `play:ai-delivery`(AI Pack 받기, 알파)를 뺐다 — 그게 WorkManager 를 끌고 와 +# 릴리스에서 앱이 시작하자마자 죽었다(사정은 core/vision/build.gradle.kts). 그 패키지를 부르는 것은 +# `com.google.ai.edge.litert.deployment.AiPackModelProvider` 하나이고 우리는 쓰지 않는다 — 빈 참조만 넘긴다. +-dontwarn com.google.android.play.core.aipacks.** + +# OpenCV — 각인 OCR 전처리(NM-485). LiteRT 와 **같은 부류의 위험**이다(⑩). # 네이티브 쪽이 JVM 으로 값을 돌려줄 때 클래스를 이름으로 찾으므로, R8 이 이름을 바꾸면 # 빌드는 멀쩡히 성공하고 릴리스에서만 죽는다. Java API 표면이 작아 남겨도 크기 영향이 없다. -keep class org.opencv.** { *; } diff --git a/app/src/androidTest/kotlin/app/nursemate/QnnModuleProbeTest.kt b/app/src/androidTest/kotlin/app/nursemate/QnnModuleProbeTest.kt deleted file mode 100644 index b6aca891..00000000 --- a/app/src/androidTest/kotlin/app/nursemate/QnnModuleProbeTest.kt +++ /dev/null @@ -1,68 +0,0 @@ -package app.nursemate - -import android.os.Build -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import java.io.File -import org.junit.Test -import org.junit.runner.RunWith - -/** - * **조건부 feature module 이 이 설치본에 실제로 들어왔는가.** - * - * `:qnn_core` 와 세대 모듈은 `device_targeting_configuration.xml` 의 `system-on-chip` 조건으로 - * 전달된다. 그런데 이 길에는 **조용히 틀릴 자리가 두 군데** 있다. - * - * 1. 설치 쪽이 SoC 조건을 안 보면 모듈이 **통째로 빠진다.** 그래도 앱은 뜨고 테스트는 통과한다 — - * QNN 만 안 붙을 뿐이다. Test Lab 의 device spec 에 SoC 가 실리는지가 미확인이라 먼저 본다. - * 2. 모듈이 들어와도 `.so` 가 **압축된 채**면 cDSP 가 skel 을 파일로 못 연다(errno 2). EP 는 - * 노드를 하나도 안 가져가고 **CPU 로 돌면서 성공한다.** - * - * 그래서 단정하지 않고 **전부 찍는다.** 판단은 숫자를 보고 사람이 한다. - */ -@RunWith(AndroidJUnit4::class) -class QnnModuleProbeTest { - - @Test - fun `설치된_스플릿과_네이티브_라이브러리를_기록한다`() { - val context = InstrumentationRegistry.getInstrumentation().targetContext - val info = context.applicationInfo - val lines = mutableListOf() - - lines += "패키지 ${context.packageName}" - lines += "SoC ${Build.SOC_MODEL} · ${Build.HARDWARE} · ${Build.MODEL}" - - val splits = runCatching { - context.packageManager.getPackageInfo(context.packageName, 0).splitNames?.toList() - }.getOrNull() - lines += "splitNames ${splits?.takeIf { it.isNotEmpty() }?.joinToString() ?: "**없음**"}" - lines += "splitDirs ${info.splitSourceDirs?.size ?: 0}개" - info.splitSourceDirs?.forEach { lines += " split $it" } - - // ⚠️ 여기가 핵심이다. `.so` 가 **실파일로** 풀려야 cDSP 가 연다. - val libDir = File(info.nativeLibraryDir) - lines += "libDir ${libDir.path} (존재 ${libDir.isDirectory})" - val libs = libDir.listFiles()?.sortedBy { it.name }.orEmpty() - lines += "libDir 안 ${libs.size}개" - libs.forEach { lines += " so ${it.name} ${it.length()}바이트" } - - val qnn = libs.filter { it.name.startsWith("libQnn") } - lines += "QNN so ${qnn.size}개 ${qnn.joinToString { it.name }.ifEmpty { "**없음**" }}" - - val marker = "ai.onnxruntime.qnnpluginep.QnnPluginEpLibraryKt" - val ep = runCatching { Class.forName(marker) } - .fold({ "로드됨" }, { "**없음** ${it.javaClass.simpleName}" }) - lines += "플러그인EP $ep" - - // `FLAG_EXTRACT_NATIVE_LIBS` 는 공개 상수가 아니라 비트를 직접 본다 — 1 shl 28. - val extract = (info.flags ushr 28) and 1 - lines += "extractNativeLibs $extract (flags 0x${info.flags.toString(16)})" - - lines.forEach { Log.i(TAG, it) } - } - - private companion object { - const val TAG = "NM-QNNMOD" - } -} diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 81f32142..7f577dfb 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -31,6 +31,15 @@ android:name="android.permission.ACCESS_ADSERVICES_ATTRIBUTION" tools:node="remove" /> + + + - - diff --git a/app/src/main/device_targeting_configuration.xml b/app/src/main/device_targeting_configuration.xml deleted file mode 100644 index 7b613eee..00000000 --- a/app/src/main/device_targeting_configuration.xml +++ /dev/null @@ -1,82 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/app/src/main/kotlin/app/nursemate/NurseMateApplication.kt b/app/src/main/kotlin/app/nursemate/NurseMateApplication.kt index 646bf3fc..619f849e 100644 --- a/app/src/main/kotlin/app/nursemate/NurseMateApplication.kt +++ b/app/src/main/kotlin/app/nursemate/NurseMateApplication.kt @@ -8,8 +8,8 @@ import app.nursemate.core.network.di.PlainClient import app.nursemate.core.timer.TimerPresetRepository import app.nursemate.core.timer.TimerReplicaPublisher import app.nursemate.core.timer.TimerRepository -import app.nursemate.pill.QnnDeliveryReporter -import app.nursemate.pill.WebGpuPolicy +import app.nursemate.pill.GpuPolicy +import app.nursemate.pill.OnDeviceBackendReporter import app.nursemate.telemetry.TelemetryIdentity import app.nursemate.timer.alarm.TimerAlarmChannels import app.nursemate.timer.alarm.TimerOngoingNotifier @@ -66,10 +66,10 @@ class NurseMateApplication : lateinit var telemetryIdentity: TelemetryIdentity @Inject - lateinit var webGpuPolicy: WebGpuPolicy + lateinit var gpuPolicy: GpuPolicy @Inject - lateinit var qnnDeliveryReporter: QnnDeliveryReporter + lateinit var onDeviceBackendReporter: OnDeviceBackendReporter private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default) @@ -91,15 +91,14 @@ class NurseMateApplication : // 이유 자체가 그것이라 앞뒤가 맞지 않는다(iOS `AppEnvironment` 주석도 같은 판단). telemetryIdentity.start(applicationScope) - // 어느 모델을 GPU 로 돌릴지 정한다 (NM-574). **온디바이스 추론이 처음 돌기 전**이어야 - // 하므로 여기다 — 늦게 꽂으면 그 사이에 열린 세션이 막아야 할 WebGPU 로 열린다. + // 어느 모델을 GPU 로 돌릴지 정한다 (NM-574 → NM-628). **온디바이스 추론이 처음 돌기 전**이어야 + // 하므로 여기다 — 늦게 꽂으면 그 사이에 열린 모델이 막아야 할 GPU 로 열린다. // - // Adreno 드라이버가 각인 모델을 받다 죽는데, 그 죽음이 예외가 아니라 SIGSEGV 라 - // 어떤 catch 로도 못 막는다. 들어가기 전에 거르는 유일한 자리다. - webGpuPolicy.install() - - // 퀄컴 기기가 QNN 모듈을 받았는지 버전마다 한 번 보고한다 (NM-603). 디스크를 보므로 뒤로 미룬다. - applicationScope.launch(Dispatchers.IO) { qnnDeliveryReporter.reportOnce() } + // 드라이버 크래시는 예외가 아니라 SIGSEGV 라 어떤 catch 로도 못 막는다. 전에 죽은 기기를 + // 들어가기 전에 거르는 유일한 자리다. + gpuPolicy.install() + // 어느 가속기로 열렸는지 모델마다 앱 버전당 한 번 보고한다 (NM-628). 모델이 열리기 전에 꽂는다. + onDeviceBackendReporter.install() // App Check provider 는 **FirebaseApp 초기화 직후 한 번**만 설치한다. // 늦게 설치하면 그 사이에 나간 요청이 토큰 없이 간다. diff --git a/app/src/main/kotlin/app/nursemate/pill/GpuPolicy.kt b/app/src/main/kotlin/app/nursemate/pill/GpuPolicy.kt new file mode 100644 index 00000000..c938ba46 --- /dev/null +++ b/app/src/main/kotlin/app/nursemate/pill/GpuPolicy.kt @@ -0,0 +1,179 @@ +package app.nursemate.pill + +import android.app.ActivityManager +import android.app.ApplicationExitInfo +import android.content.Context +import android.os.Build +import android.util.Log +import app.nursemate.BuildConfig +import app.nursemate.core.vision.VisionBackend +import dagger.hilt.android.qualifiers.ApplicationContext +import java.io.File +import javax.inject.Inject +import javax.inject.Singleton + +/** + * **이 기기에서 모델을 GPU 로 열어도 되는가** — NM-628(LiteRT). NM-574 의 WebGPU 정책을 이어받았다. + * + * ## 허용목록이 없어졌다 + * ORT WebGPU 시절에는 SoC 마다 깨지는 모델이 달라 **재서 된 기기만** 켰다(Exynos 2400 · 2500 · 2600). + * LiteRT OpenCL 은 ML 이 8개 SoC(Exynos 3 · Snapdragon 5)에서 공식 세트로 재 **전부 운영 fp32 와 같은 답**을 + * 냈다(`_handoff/litert-ondevice-migration.md`). 기기별 분기 없이 다 GPU 로 열고, 안 되는 경우만 막는다. + * + * | 겹 | 무엇을 막나 | 대가 | + * |---|---|---| + * | GPU 로 못 열면 CPU | 드라이버가 모델을 거절 | 없음(`LiteRtModel.open` 이 한다) | + * | **크래시 마커**(여기) | GPU 를 쓰다 프로세스째 죽음 | 그 기기에서 **1회** 죽는다 | + * | 모델별 CPU 고정(여기) | 열리기는 하는데 GPU **실행**이 예외를 던짐 — `LiteRtModel.run` 이 CPU 로 대체하며 알린다 | 그 모델만 느리다 | + * + * ⚠️ **조용히 틀린 답은 여기서 못 잡는다.** 앱 안 자가 점검은 하지 않기로 했다(2026-10-19 — 유지보수 비용) — 그건 + * **출시 전 기기별 검증**(ML 공식 세트 · Test Lab 대조 테스트)이 막고, 운영 기기 분포는 `ondevice_backend` 이벤트로 본다. + * + * ## 막은 기록은 (앱 버전 · 기기 빌드) 단위다 + * 드라이버는 OS 업데이트로 바뀐다. 한 번 죽은 기기를 영영 CPU 로 두면 고쳐진 뒤에도 느리다. 그래서 + * 기록을 `versionCode` 와 `Build.FINGERPRINT`(OS · 드라이버를 포함하는 빌드 식별자)에 묶는다 — + * 둘 중 하나가 바뀌면 다시 GPU 를 시도한다. + * + * ⚠️ ORT WebGPU 시절 기록(`webgpu_policy`)은 읽지 않는다. 그때 죽은 것은 WebGPU(Vulkan) 경로였고 + * LiteRT 는 OpenCL 이라 같은 드라이버 코드를 타지 않는다. + * + * ## 왜 예외 폴백만으로는 부족한가 + * 드라이버 크래시는 **예외를 던지지 않고 프로세스가 죽는다**(ORT 시절 Adreno 740 `vulkan.adreno.so` + * SIGSEGV). 잡을 코드가 실행될 프로세스가 없다 — 그래서 다음 실행이 알아채고 열기 전에 막는다. + */ +@Singleton +class GpuPolicy @Inject constructor(@param:ApplicationContext private val context: Context) { + + /** + * ⚠️ DataStore 가 아니라 SharedPreferences 다. [VisionBackend.allowGpu] 는 모델을 여는 + * 스레드에서 **동기로** 불리는데, DataStore 를 읽으려면 `runBlocking` 이 필요하다. + */ + private val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + /** 이 프로세스가 GPU 를 썼다는 흔적. 죽으면 남고, 다음 실행이 읽는다. */ + private val sentinel = File(context.filesDir, SENTINEL) + + /** 지금 앱 · 기기 빌드. 막은 기록이 이 값과 같을 때만 유효하다. */ + private val build = "${BuildConfig.VERSION_CODE}|${Build.FINGERPRINT}" + + @Volatile + private var blockedByCrash = false + + @Volatile + private var cpuModels: Set = emptySet() + + /** + * [VisionBackend] 에 정책을 꽂는다. **온디바이스 추론이 처음 돌기 전에** 불려야 한다 — + * `Application.onCreate` 가 그 자리다. + */ + fun install() { + if (prefs.getString(KEY_BUILD, null) != build) { + // 앱이나 OS 가 바뀌었다 — 예전 판정은 버리고 GPU 를 다시 시도한다. + prefs.edit().clear().putString(KEY_BUILD, build).apply() + } + blockedByCrash = prefs.getBoolean(KEY_BLOCKED, false) || trippedByLastExit() + cpuModels = prefs.getStringSet(KEY_CPU_MODELS, emptySet()).orEmpty() + + VisionBackend.allowGpu = ::allow + VisionBackend.onGpuUse = { gpuUse(+1) } + VisionBackend.onGpuReleased = { gpuUse(-1) } + VisionBackend.onGpuRunFailed = ::pinToCpu + + Log.i( + TAG, + "GPU 정책 — SoC ${soc()} · 크래시차단=$blockedByCrash · " + + "CPU 고정 모델=${cpuModels.joinToString().ifEmpty { "없음" }}" + ) + } + + /** 모델을 열 때 `LiteRtModel.open` 이 묻는다. */ + private fun allow(modelFileName: String): Boolean = !blockedByCrash && modelFileName !in cpuModels + + /** + * 이 모델은 이 기기 · 이 빌드에서 CPU 로만 연다 — GPU 실행이 실패했을 때 `LiteRtModel` 이 알린다. + * 다음에 열 때부터 먹는다(지금 열린 것은 `LiteRtModel` 이 이미 CPU 로 다시 열었다). + */ + private fun pinToCpu(modelFileName: String) { + cpuModels = cpuModels + modelFileName + prefs.edit().putStringSet(KEY_CPU_MODELS, cpuModels).apply() + Log.w(TAG, "$modelFileName 은 이 기기에서 CPU 로 연다") + } + + /** SoC 모델 이름 — 로그용. `SOC_MODEL` 이 API 31 부터라 그 아래는 `HARDWARE` 로 받는다. */ + private fun soc(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) Build.SOC_MODEL else Build.HARDWARE + + /** + * 지금 열린(또는 여는 중인) GPU 모델 수. 하나라도 있으면 흔적을 남기고, 0 이 되면 지운다. + * + * 흔적을 **GPU 를 쓰는 동안만** 두는 이유: 식별을 끝낸 뒤 GPU 와 무관한 네이티브 크래시(OpenCV · SDK 등)가 나도 + * 흔적이 남아 있으면 GPU 크래시로 잘못 읽고, 그 빌드 내내 전 모델이 CPU 로 돈다. 모델은 식별 플로우가 끝나면 닫힌다. + */ + @Synchronized + private fun gpuUse(delta: Int) { + gpuOpen = (gpuOpen + delta).coerceAtLeast(0) + runCatching { + if (gpuOpen > 0) { + if (!sentinel.exists()) sentinel.writeText(MARK) + } else { + sentinel.delete() + } + }.onFailure { Log.w(TAG, "GPU 흔적을 고치지 못했다", it) } + } + + private var gpuOpen = 0 + + /** + * **직전 프로세스가 네이티브로 죽었고, 그때 GPU 를 쓰고 있었는가.** + * + * 흔적 파일만으로는 못 가린다 — 사용자가 작업목록에서 치워도 파일은 남는다. OS 에 왜 + * 죽었는지 직접 묻는다(API 30+). 그 아래 판은 판정하지 않는다. 오탐으로 멀쩡한 기기를 + * 느리게 만드는 쪽이, 1회 죽는 것보다 나쁘다. + */ + private fun trippedByLastExit(): Boolean { + if (!sentinel.exists()) return false + // 판정했으면 지운다. 남겨 두면 다음 크래시가 아닌 종료까지 이 흔적에 걸린다. + val crashed = lastExitWasNativeCrash() + runCatching { sentinel.delete() } + if (crashed) { + prefs.edit().putBoolean(KEY_BLOCKED, true).apply() + Log.w(TAG, "직전 실행이 네이티브로 죽었다 — 이 빌드에서는 CPU 로 돈다") + } + return crashed + } + + private fun lastExitWasNativeCrash(): Boolean { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return false + + val last = runCatching { + context.getSystemService(ActivityManager::class.java) + ?.getHistoricalProcessExitReasons(context.packageName, 0, 1) + ?.firstOrNull() + }.getOrNull() + + if (last != null) { + Log.i(TAG, "직전 종료 사유 ${last.reason} (status ${last.status}) — ${last.description}") + } + return when (last?.reason) { + ApplicationExitInfo.REASON_CRASH_NATIVE -> true + + // 신호로 죽은 것 중 **치명적 결함 신호만** 센다. SIGKILL(9) 은 OS 가 메모리를 + // 거두거나 사용자가 강제 종료한 것이라 우리 탓이 아니다. + ApplicationExitInfo.REASON_SIGNALED -> last.status in FATAL_SIGNALS + + else -> false + } + } + + private companion object { + const val TAG = "GpuPolicy" + const val PREFS = "gpu_policy" + const val KEY_BUILD = "build" + const val KEY_BLOCKED = "blocked_by_native_crash" + const val KEY_CPU_MODELS = "cpu_models" + const val SENTINEL = "gpu_attempt" + const val MARK = "1" + + /** SIGILL · SIGABRT · SIGBUS · SIGSEGV. 드라이버가 죽을 때 나오는 것들이다. */ + val FATAL_SIGNALS = setOf(4, 6, 7, 11) + } +} diff --git a/app/src/main/kotlin/app/nursemate/pill/OnDeviceBackendReporter.kt b/app/src/main/kotlin/app/nursemate/pill/OnDeviceBackendReporter.kt new file mode 100644 index 00000000..b48b88fb --- /dev/null +++ b/app/src/main/kotlin/app/nursemate/pill/OnDeviceBackendReporter.kt @@ -0,0 +1,59 @@ +package app.nursemate.pill + +import android.content.Context +import android.os.Build +import app.nursemate.BuildConfig +import app.nursemate.core.vision.OpenOutcome +import app.nursemate.core.vision.VisionBackend +import app.nursemate.telemetry.AnalyticsEvent +import app.nursemate.telemetry.AppAnalytics +import dagger.hilt.android.qualifiers.ApplicationContext +import javax.inject.Inject +import javax.inject.Singleton + +/** + * 온디바이스 모델이 어느 가속기로 열렸는지 보고한다 — [AnalyticsEvent.OnDeviceBackend] (NM-628). + * + * **(모델 파일 · 결과)마다 앱 버전당 한 번**이다. 모델은 식별 플로우마다 다시 열릴 수 있는데, 매번 보내면 많이 쓰는 + * 사용자가 비율을 끌고 간다. 기기 하나가 한 표다. 결과까지 키에 넣는 이유: 처음엔 GPU(`ok`)로 열렸다가 그 버전에서 + * 죽어 막히면(`gpu_blocked`) · 실행이 실패하면(`gpu_run_failed`) — **바로 그 신호**가 「같은 버전엔 이미 보냈다」로 + * 빠지면 안 된다. + * + * GPU 열기 실패가 늘면 그 칩을 ML 측정 목록에 올린다 — 앱 안 자가 점검 대신 **출시 전 기기별 검증**으로 + * 막기로 했고(2026-10-19 결정), 이 이벤트가 어느 기기를 재야 하는지 알려 준다. + */ +@Singleton +class OnDeviceBackendReporter @Inject constructor( + @param:ApplicationContext private val context: Context, + private val analytics: AppAnalytics +) { + // 주입은 메인 스레드에서 일어난다 — 디스크는 실제로 볼 때 연다. + private val prefs by lazy { context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) } + + /** [VisionBackend] 에 꽂는다. 모델이 처음 열리기 전이어야 한다 — `Application.onCreate`. */ + fun install() { + VisionBackend.onModelOpened = ::report + } + + /** 모델을 여는 스레드에서 불린다 — 가볍게 끝낸다. */ + private fun report(modelFileName: String, outcome: OpenOutcome) { + val key = KEY_PREFIX + modelFileName + "|" + outcome.label + if (prefs.getInt(key, 0) == BuildConfig.VERSION_CODE) return + analytics.track(event(modelFileName, outcome, soc())) + prefs.edit().putInt(key, BuildConfig.VERSION_CODE).apply() + } + + private fun soc(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) Build.SOC_MODEL else Build.HARDWARE + + internal companion object { + const val PREFS = "ondevice_backend" + const val KEY_PREFIX = "reported_" + + fun event(modelFileName: String, outcome: OpenOutcome, socModel: String) = AnalyticsEvent.OnDeviceBackend( + model = modelFileName, + backend = if (outcome.onGpu) "gpu" else "cpu", + cause = outcome.label, + socModel = socModel + ) + } +} diff --git a/app/src/main/kotlin/app/nursemate/pill/PillFaceReader.kt b/app/src/main/kotlin/app/nursemate/pill/PillFaceReader.kt index ea2d39b5..4f4e3507 100644 --- a/app/src/main/kotlin/app/nursemate/pill/PillFaceReader.kt +++ b/app/src/main/kotlin/app/nursemate/pill/PillFaceReader.kt @@ -22,12 +22,13 @@ import kotlinx.coroutines.withContext * 같은 면의 각인을 읽었으면 마크 유무 임계가 0.80, 못 읽었으면 0.60 이다([MarkPresence]). * 순서를 바꾸면 임계가 늘 느슨한 쪽으로 고정돼 **마크 오탐이 하드 필터로 나간다.** * - * ## 알약 하나에 2초가 든다 - * 각인이 144장(1796 ms), 마크가 8장(178 ms)이다 — Galaxy S24 · WebGPU 기준. 셋을 찍으면 - * 6초다. 그래서 **결과 화면을 막지 않는다** — 서버 속성 추출과 나란히 돌고, 늦게 와서 + * ## 알약 하나에 약 0.9초가 든다 + * 각인이 144장(680 ms), 마크가 8장(157 ms)이다 — Galaxy S24 · LiteRT GPU 기준(NM-628). 셋을 찍으면 + * 2.6초다. 그래서 **결과 화면을 막지 않는다** — 서버 속성 추출과 나란히 돌고, 늦게 와서 * 수정 화면에 얹힌다([PillRecognitionViewModel.readFaces]). * - * 저사양 기기 대기 시간은 아직 안 쟀다(NM-485 「정할 것」 1번 · NM-515 DoD). + * 기기별 시간은 ML 실측표(`_handoff/litert-ondevice-migration.md`)에 있다 — 플래그십 8종 각인 0.4~1.2초. + * GPU 를 못 쓰는 기기는 CPU 로 1.4~5.0초다. 중급 · 구형은 ML 이 재는 중이다. */ class PillFaceReader @Inject constructor(private val modelFile: PillModelFile) : Closeable { @@ -62,7 +63,7 @@ class PillFaceReader @Inject constructor(private val modelFile: PillModelFile) : } private suspend fun loadMark(): MarkReader = mark ?: withContext(Dispatchers.IO) { - MarkReader(modelFile.prepare(PillModel.Mark)).also { mark = it } + MarkReader(modelFile.prepare(PillModel.Mark).single()).also { mark = it } } override fun close() { diff --git a/app/src/main/kotlin/app/nursemate/pill/PillModelFile.kt b/app/src/main/kotlin/app/nursemate/pill/PillModelFile.kt index 64924627..5f945a03 100644 --- a/app/src/main/kotlin/app/nursemate/pill/PillModelFile.kt +++ b/app/src/main/kotlin/app/nursemate/pill/PillModelFile.kt @@ -14,26 +14,25 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext /** 앱이 품고 다니는 온디바이스 모델 셋. 파일 이름의 정본은 각 모델을 여는 쪽에 있다. */ -enum class PillModel(val fileName: String) { - /** 알약 검출·분할 (RF-DETR-seg). 119MB 로 셋 중 가장 크다. */ - Detector(PillDetector.MODEL_FILE_NAME), +enum class PillModel(val fileNames: List) { + /** 알약 검출·분할 (RF-DETR-seg). 63MB. */ + Detector(listOf(PillDetector.MODEL_FILE_NAME)), - /** 각인 OCR (CRNN + CTC). */ - Imprint(ImprintReader.MODEL_FILE_NAME), + /** 각인 OCR (CRNN + CTC). LiteRT 에서 다섯 조각이다(NM-628) — 순서대로 흐른다. */ + Imprint(ImprintReader.PART_FILE_NAMES), /** 마크 종·유무·임베딩 (ConvNeXt-Tiny species). */ - Mark(MarkReader.MODEL_FILE_NAME) + Mark(listOf(MarkReader.MODEL_FILE_NAME)) } /** * 온디바이스 모델 파일을 준비한다. * - * ONNX Runtime 은 세션을 만들 때 **파일 경로**를 요구하는데 APK 안의 asset 에는 경로가 없다. - * 그래서 처음 한 번 앱 전용 저장소로 꺼내 두고 그다음부터는 그걸 쓴다. + * 모델은 **파일 경로**로 연다(LiteRT `CompiledModel.create(path)`). APK 안의 asset 에는 경로가 없어서 + * 처음 한 번 앱 전용 저장소로 꺼내 두고 그다음부터는 그걸 쓴다. * - * ## 왜 통째로 메모리에 올리지 않나 - * ORT 는 바이트 배열로도 세션을 만들 수 있지만 셋을 합치면 196MB 다. 힙에 그만큼 올리면 - * 저사양 기기에서 OOM 이 난다. 디스크에 한 번 쓰는 편이 안전하다. + * LiteRT 는 `AssetManager` 로도 열 수 있지만, asset 이 압축돼 있으면 통째로 메모리에 풀어야 한다 — + * 합치면 136MB 다. 디스크에 한 번 쓰는 편이 저사양 기기에서 안전하다(ONNX 시절과 같은 판단). * * ## 저장소를 두 배 쓴다 * APK 안(압축)과 꺼낸 파일 양쪽에 있게 된다. Play Asset Delivery 를 쓰면 꺼내는 단계 없이 @@ -46,29 +45,32 @@ enum class PillModel(val fileName: String) { class PillModelFile @Inject constructor(@param:ApplicationContext private val context: Context) { /** - * @return 바로 열 수 있는 모델 파일 + * @return 바로 열 수 있는 모델 파일 — [PillModel.fileNames] 순서 * @throws IllegalStateException 꺼내지 못한 경우 — 화면은 ⑦ 분석 실패로 간다 */ - suspend fun prepare(model: PillModel = PillModel.Detector): File = withContext(Dispatchers.IO) { - val name = model.fileName - developerOverride(name)?.let { return@withContext it } + suspend fun prepare(model: PillModel = PillModel.Detector): List = withContext(Dispatchers.IO) { + model.fileNames.map { prepareFile(it) } + } + + private fun prepareFile(name: String): File = developerOverride(name) ?: extracted(name) + private fun extracted(name: String): File { // 버전을 경로에 박아 둔다. 앱을 올렸는데 예전 모델을 그대로 쓰는 사고를 막는다. val target = File(context.filesDir, "model/${BuildConfig.VERSION_CODE}/$name") - if (target.isFile && target.length() > 0) return@withContext target - - target.parentFile?.mkdirs() - extract(name, target) - cleanUpOldVersions(target.parentFile) - target + if (!(target.isFile && target.length() > 0)) { + target.parentFile?.mkdirs() + extract(name, target) + cleanUpOldVersions(target.parentFile) + } + return target } /** * 개발용 우회 — 앱 전용 외부 저장소에 파일을 밀어 넣으면 그쪽을 쓴다. * ``` - * adb push rfdetr_seg_small.onnx /sdcard/Android/data/app.nursemate.debug/files/ + * adb push rfdetr_seg_small_f16w.tflite /sdcard/Android/data/app.nursemate.debug/files/ * ``` - * 다른 양자화(int8·fp16)를 실기기에서 비교할 때 앱을 다시 빌드하지 않아도 된다. + * 다른 변환본을 실기기에서 비교할 때 앱을 다시 빌드하지 않아도 된다. 각인은 조각 파일마다 따로 본다. * **디버그 빌드에서만** 본다 — 릴리스에서 외부 파일을 읽으면 남이 바꿔치기할 수 있다. */ private fun developerOverride(name: String): File? { diff --git a/app/src/main/kotlin/app/nursemate/pill/PillRecognitionViewModel.kt b/app/src/main/kotlin/app/nursemate/pill/PillRecognitionViewModel.kt index 1bd6c203..5e39b0a4 100644 --- a/app/src/main/kotlin/app/nursemate/pill/PillRecognitionViewModel.kt +++ b/app/src/main/kotlin/app/nursemate/pill/PillRecognitionViewModel.kt @@ -75,7 +75,7 @@ class PillRecognitionViewModel @Inject constructor( /** 앱 전체가 공유하는 값. 미리보기의 "오늘 남은 횟수"가 이걸 본다. */ val usage = usageHolder.usage - /** ONNX 세션은 로드에 수백 ms가 걸린다. 한 번 만들고 플로우 내내 재사용한다. */ + /** 모델 열기에 1~3초가 걸린다(LiteRT · GPU 셰이더 준비). 한 번 만들고 플로우 내내 재사용한다. */ private var detector: PillDetector? = null /** @@ -302,8 +302,8 @@ class PillRecognitionViewModel @Inject constructor( * 찍힌 면의 각인·마크를 읽어 [PillUiState.faceReadings] 에 쌓는다 — NM-485 · NM-515. * * ## 결과 화면을 막지 않는다 - * 알약 하나에 2초다(각인 144장 1796 ms + 마크 8장 178 ms, S24 · WebGPU). 셋이면 6초인데, - * 서버 속성 추출은 860 ms 다 — 기다리게 하면 **사람이 보는 대기가 두 배 넘게 는다.** + * 알약 하나에 약 0.9초다(각인 144장 680 ms + 마크 8장 157 ms, S24 · LiteRT GPU — NM-628). 셋이면 2.6초이고 + * 서버 속성 추출은 860 ms 다 — 기다리게 하면 **사람이 보는 대기가 그만큼 는다.** * 그래서 별도 코루틴으로 띄우고 한 장씩 들어오는 대로 상태에 넣는다. * * ## 하나씩 넣는다 @@ -352,7 +352,7 @@ class PillRecognitionViewModel @Inject constructor( val history = PillHistorySaving(_state, historyRepository, viewModelScope) private suspend fun loadDetector(): PillDetector = detector ?: withContext(Dispatchers.IO) { - PillDetector(modelFile.prepare()).also { detector = it } + PillDetector(modelFile.prepare().single()).also { detector = it } } override fun onCleared() { diff --git a/app/src/main/kotlin/app/nursemate/pill/QnnDeliveryReporter.kt b/app/src/main/kotlin/app/nursemate/pill/QnnDeliveryReporter.kt deleted file mode 100644 index 654b4113..00000000 --- a/app/src/main/kotlin/app/nursemate/pill/QnnDeliveryReporter.kt +++ /dev/null @@ -1,81 +0,0 @@ -package app.nursemate.pill - -import android.content.Context -import android.os.Build -import android.util.Log -import androidx.annotation.RequiresApi -import app.nursemate.BuildConfig -import app.nursemate.core.vision.QnnDeliveryState -import app.nursemate.telemetry.AnalyticsEvent -import app.nursemate.telemetry.AppAnalytics -import dagger.hilt.android.qualifiers.ApplicationContext -import java.io.File -import javax.inject.Inject -import javax.inject.Singleton - -/** - * 퀄컴 기기가 QNN 모듈을 받았는지 **앱 버전마다 한 번** 보고한다 — NM-603. - * - * ## 왜 버전마다 한 번인가 - * 전달 상태는 설치 때 정해지고 앱이 떠 있는 동안 바뀌지 않는다. 매 실행 보내면 많이 쓰는 - * 사용자가 비율을 끌고 간다 — 세려는 것은 **설치본**이다. 업데이트 때 기기그룹 목록이 바뀌었을 - * 수 있으니 버전이 바뀌면 다시 보낸다. - * - * ## 왜 퀄컴만, Play 설치만인가 - * - QNN 은 Hexagon 에만 있다. 엑시노스·텐서가 `none` 인 것은 정상이라 분모를 흐린다. - * - Android Studio·`adb install` 은 feature module 을 **전부** 깐다. 그 설치본은 기기그룹을 안 - * 탔으니 「Play 가 무엇을 내려줬나」의 답이 아니다. 릴리스 스모크 테스트용 로컬 APK 가 운영 - * Firebase 에 가짜 `core+skel` 을 쌓지 않도록 설치 출처가 Play 인 것만 센다. - * - * ⚠️ 보냈다는 표시는 `track` 이 돌아온 뒤에 남긴다. 전송 실패를 알 길이 없어(`AppAnalytics` 가 - * 삼킨다) 실패한 설치본은 그 버전 동안 빠진다. Firebase 는 오프라인이면 쌓아 두었다 보내므로 - * 실제로 빠지는 것은 SDK 예외뿐이다. - */ -@Singleton -class QnnDeliveryReporter @Inject constructor( - @param:ApplicationContext private val context: Context, - private val analytics: AppAnalytics -) { - // 주입은 메인 스레드에서 일어난다 — 디스크는 실제로 볼 때 연다. - private val prefs by lazy { context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) } - - /** 디스크를 읽으므로 IO 스레드에서 부른다. */ - fun reportOnce() { - // SOC_* 는 API 31+ 다. 그 아래 퀄컴 기기는 어차피 기기그룹(system-on-chip)에 안 맞는다. - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) reportOnceS() - } - - @RequiresApi(Build.VERSION_CODES.S) - private fun reportOnceS() { - val eligible = isQualcomm(Build.SOC_MANUFACTURER) && isFromPlay(installer()) - if (!eligible || prefs.getInt(KEY_LAST_VERSION, 0) == BuildConfig.VERSION_CODE) return - - val state = QnnDeliveryState.of(File(context.applicationInfo.nativeLibraryDir)) - analytics.track(AnalyticsEvent.QnnDelivery(socModel = Build.SOC_MODEL, delivered = state.label)) - prefs.edit().putInt(KEY_LAST_VERSION, BuildConfig.VERSION_CODE).apply() - } - - @RequiresApi(Build.VERSION_CODES.S) - @Suppress("TooGenericExceptionCaught") - private fun installer(): String? = try { - context.packageManager.getInstallSourceInfo(context.packageName).installingPackageName - } catch (e: Exception) { - Log.w(TAG, "설치 출처를 못 읽었다 — 보고하지 않는다", e) - null - } - - internal companion object { - const val TAG = "NM603" - const val PREFS = "qnn_delivery" - - /** 마지막으로 보고한 versionCode 하나만 둔다 — 버전마다 키를 늘리지 않는다. */ - const val KEY_LAST_VERSION = "last_reported_version" - - private const val PLAY_STORE = "com.android.vending" - - /** `Build.SOC_MANUFACTURER` 가 퀄컴이면 `QTI` 다(DeviceProbeTest 가 실기기에서 찍었다). */ - fun isQualcomm(socManufacturer: String): Boolean = socManufacturer == "QTI" - - fun isFromPlay(installer: String?): Boolean = installer == PLAY_STORE - } -} diff --git a/app/src/main/kotlin/app/nursemate/pill/WebGpuPolicy.kt b/app/src/main/kotlin/app/nursemate/pill/WebGpuPolicy.kt deleted file mode 100644 index 04ad9dee..00000000 --- a/app/src/main/kotlin/app/nursemate/pill/WebGpuPolicy.kt +++ /dev/null @@ -1,206 +0,0 @@ -package app.nursemate.pill - -import android.app.ActivityManager -import android.app.ApplicationExitInfo -import android.content.Context -import android.os.Build -import android.util.Log -import app.nursemate.core.vision.PillDetector -import app.nursemate.core.vision.VisionBackend -import app.nursemate.core.vision.imprint.ImprintReader -import app.nursemate.core.vision.mark.MarkReader -import dagger.hilt.android.qualifiers.ApplicationContext -import java.io.File -import javax.inject.Inject -import javax.inject.Singleton - -/** - * **이 기기에서 WebGPU 를 써도 되는가** — NM-574. - * - * 두 겹이다. 서로 다른 실패를 막으므로 둘 다 필요하다. - * - * | | 무엇을 막나 | 대가 | - * |---|---|---| - * | **허용목록** | 실기기에서 재서 **된다고 확인한 것만** 켠다 | 못 재 본 기기는 느리다 | - * | **크래시 마커** | 허용했는데 나중에 죽는 경우 | 그 기기에서 **1회** 죽는다 | - * - * ## 왜 차단목록이 아니라 허용목록인가 - * 처음에는 「퀄컴이면 각인만 CPU」로 짰는데 **범위가 틀렸다.** 2026-10-13 실기기 전수 측정이 - * 보여 준 것은 이렇다(엑시노스 2500·2600 두 줄은 2026-10-14 RTL 실측으로 따로다 — 아래). - * - * | 기기 | 검출 | 각인 | 마크 | - * |---|---|---|---| - * | Xclipse 940 (Exynos 2400) | **1.95배** | **2.03배** | **3.2배** | - * | Xclipse 950 (Exynos 2500) | **2.1배** | **1.9배** | **2.7배** | - * | Xclipse 960 (Exynos 2600) | 1.1배 | **1.8배** ⚠️ | **7.8배** | - * | Adreno 740 (SM8550) | 1.53배 | **프로세스 사망** | 2.1배 | - * | Adreno 750 (SM8650) | **프로세스 사망** | 예외 | 2.1배 | - * | Mali (Tensor G4) | 예외 | 예외 | 예외 | - * - * **같은 Adreno 안에서도 세대마다 깨지는 모델이 다르다.** 740 은 검출이 되는데 750 은 죽고, - * 둘 다 각인은 안 된다. 드라이버 빌드가 다르기 때문이다(`dc3d4da3a2` 대 `c81b28e1a5`). - * 무엇이 깨질지 미리 알 수 없으니 **되는 것만 켜는** 쪽이 맞다 — 모르면 CPU 다. - * - * 2500·2600 줄은 2026-10-14 Samsung RTL 실측이다(NM-601). 2500 은 세 모델을 3회씩 돌려 값과 답이 - * 모두 같았고, 2600 은 검출 6회·마크 39회가 무결했다. - * - * ⚠️ **2600 각인은 「안전」이 아니라 「확률을 낮춘」 상태로 켠다.** 배치 144 에서 225회 중 30회 - * 예외 없이 빈 답(한 번은 `EE · 0.609` 처럼 계산이 망가진 값)이 나왔고, 배치를 72 로 내려 - * 718회 무결이 됐다(NM-602 — 배치 36 의 675회는 따로다). 원인을 막은 것은 아니다 — - * 망가진 값의 점수가 우연히 0.949 를 넘으면 틀린 각인을 채택한다. 운영에서 「각인 못 읽음」 - * 비율이 2600 에서만 튀면 여기서 각인을 빼는 것이 첫 조치다. - * ⚠️ **그 비율을 볼 지표가 아직 없다.** 분석 이벤트에 각인 실패·SoC·EP 차원이 없어서 지금은 - * 사용자 문의나 다른 경로로만 알 수 있다. 관측을 붙이기 전까지는 이 위험을 알고 켠 것이다. - * - * ## 왜 Adreno 의 마크·검출까지 끄나 - * Adreno 740 은 검출·마크가 통과했고 2배 가까이 빠르다. 그런데 **한 번 통과한 것으로는 - * 모자란다.** 드라이버 크래시는 확률적이다 — 운영 크래시 ① 에서 각인이 알약 서너 개까지 - * 버티다 죽었다. 740 의 검출도 한 판 통과했을 뿐 다음 판에 죽지 않는다는 보장이 없다. - * - * 핫픽스가 할 일은 **죽는 것을 멈추는 것**이지 마지막 한 방울까지 짜내는 것이 아니다. - * Adreno 를 CPU 로 돌리면 식별 한 번에 검출 +0.6초, 알약당 마크 +0.37초가 붙는다. 지금은 - * 그 기기들이 **앱째로 죽고 있다.** - * - * 더 촘촘한 매핑(740 은 검출·마크 허용 등)은 [ALLOWED] 에 줄을 더하면 된다. 다만 그 전에 - * **같은 기기를 여러 번 돌려** 확률적으로도 안전한지 봐야 한다. - * - * ## 왜 예외 폴백만으로는 부족한가 - * Adreno 740 의 각인과 750 의 검출은 **예외를 던지지 않고 프로세스가 죽는다** - * (`vulkan.adreno.so` · `libllvm-qgl.so` SIGSEGV). 잡을 코드가 실행될 프로세스가 없다. - */ -@Singleton -class WebGpuPolicy @Inject constructor(@param:ApplicationContext private val context: Context) { - - /** - * ⚠️ DataStore 가 아니라 SharedPreferences 다. [VisionBackend.allowWebGpu] 는 세션을 여는 - * 스레드에서 **동기로** 불리는데, DataStore 를 읽으려면 `runBlocking` 이 필요하다. - */ - private val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - - /** 이 프로세스가 WebGPU 를 썼다는 흔적. 죽으면 남고, 다음 실행이 읽는다. */ - private val sentinel = File(context.filesDir, SENTINEL) - - /** 한 번 막히면 이 설치본에서는 다시 안 켠다. 매번 디스크를 읽지 않도록 들고 있는다. */ - @Volatile - private var blockedByCrash = false - - /** - * [VisionBackend] 에 정책을 꽂는다. **온디바이스 추론이 처음 돌기 전에** 불려야 한다 — - * `Application.onCreate` 가 그 자리다. - */ - fun install() { - blockedByCrash = prefs.getBoolean(KEY_BLOCKED, false) || trippedByLastExit() - - VisionBackend.allowWebGpu = ::allow - VisionBackend.onWebGpuSessionOpened = { markAttempt() } - - Log.i( - TAG, - "WebGPU 정책 — SoC ${soc()} · 크래시차단=$blockedByCrash · " + - "허용모델=${allowedModels().joinToString().ifEmpty { "없음(CPU 전용)" }}" - ) - } - - /** 세션을 열 때 [OrtBackend][app.nursemate.core.vision.OrtBackend] 가 묻는다. */ - private fun allow(modelFileName: String): Boolean = !blockedByCrash && modelFileName in allowedModels() - - private fun allowedModels(): Set = ALLOWED[soc()].orEmpty() - - /** - * SoC 모델 이름. `SOC_MODEL` 이 API 31 부터라 그 아래는 `HARDWARE` 로 받는다 — 실기기에서 - * 둘이 같은 값(`s5e9945`)을 내는 것을 확인했다. - * - * GL 렌더러 문자열(`Xclipse 940`)로도 가릴 수 있지만 EGL 컨텍스트를 띄워야 해서, 앱이 뜨는 - * 길목에 두기엔 무겁다. - */ - private fun soc(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) Build.SOC_MODEL else Build.HARDWARE - - /** 이 프로세스가 WebGPU 세션을 열었다고 적어 둔다. 이미 있으면 건드리지 않는다. */ - private fun markAttempt() { - runCatching { if (!sentinel.exists()) sentinel.writeText(MARK) } - .onFailure { Log.w(TAG, "WebGPU 흔적을 남기지 못했다", it) } - } - - /** - * **직전 프로세스가 네이티브로 죽었고, 그때 WebGPU 를 쓰고 있었는가.** - * - * 흔적 파일만으로는 못 가린다 — 사용자가 작업목록에서 치워도 파일은 남는다. OS 에 왜 - * 죽었는지 직접 묻는다(API 30+). 그 아래 판은 판정하지 않는다. 오탐으로 멀쩡한 기기를 - * 영구히 느리게 만드는 쪽이, 1회 죽는 것보다 나쁘다. - */ - private fun trippedByLastExit(): Boolean { - if (!sentinel.exists()) return false - // 판정했으면 지운다. 남겨 두면 다음 크래시가 아닌 종료까지 이 흔적에 걸린다. - val crashed = lastExitWasNativeCrash() - runCatching { sentinel.delete() } - if (crashed) { - prefs.edit().putBoolean(KEY_BLOCKED, true).apply() - Log.w(TAG, "직전 실행이 네이티브로 죽었다 — 이 기기는 이제 CPU 로 돈다") - } - return crashed - } - - private fun lastExitWasNativeCrash(): Boolean { - if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return false - - val last = runCatching { - context.getSystemService(ActivityManager::class.java) - ?.getHistoricalProcessExitReasons(context.packageName, 0, 1) - ?.firstOrNull() - }.getOrNull() - - if (last != null) { - Log.i(TAG, "직전 종료 사유 ${last.reason} (status ${last.status}) — ${last.description}") - } - return when (last?.reason) { - ApplicationExitInfo.REASON_CRASH_NATIVE -> true - - // 신호로 죽은 것 중 **치명적 결함 신호만** 센다. SIGKILL(9) 은 OS 가 메모리를 - // 거두거나 사용자가 강제 종료한 것이라 우리 탓이 아니다. - ApplicationExitInfo.REASON_SIGNALED -> last.status in FATAL_SIGNALS - - else -> false - } - } - - private companion object { - const val TAG = "NM574" - const val PREFS = "webgpu_policy" - const val KEY_BLOCKED = "blocked_by_native_crash" - const val SENTINEL = "webgpu_attempt" - const val MARK = "1" - - /** SIGILL · SIGABRT · SIGBUS · SIGSEGV. 드라이버가 죽을 때 나오는 것들이다. */ - val FATAL_SIGNALS = setOf(4, 6, 7, 11) - - /** - * **SoC 모델 → WebGPU 로 열어도 되는 모델 파일.** - * - * ⚠️ **실기기에서 재서 통과한 것만 적는다.** 추측으로 줄을 늘리면 그 기기 사용자가 - * 앱째로 죽는다. 늘릴 때는 같은 기기를 **여러 번** 돌려 확률적으로도 안전한지 본다. - * - * - `s5e9945` = Exynos 2400 · Xclipse 940 (Galaxy S24/S24+ 국내·유럽판). - * 검출·각인·마크 셋 다 CPU 와 답이 같고(최대차 1e-7) 1.95~3.2배 빠르다. - * - `s5e9955` = Exynos 2500 · Xclipse 950 (Galaxy Z Flip7). 셋 다 3회 재현, 1.9~2.7배. - * - `s5e9965` = Exynos 2600 · Xclipse 960 (Galaxy S26/S26+ 국내판). 각인은 위 KDoc 의 ⚠️ 를 볼 것. - */ - val ALLOWED: Map> = mapOf( - "s5e9945" to setOf( - PillDetector.MODEL_FILE_NAME, - ImprintReader.MODEL_FILE_NAME, - MarkReader.MODEL_FILE_NAME - ), - "s5e9955" to setOf( - PillDetector.MODEL_FILE_NAME, - ImprintReader.MODEL_FILE_NAME, - MarkReader.MODEL_FILE_NAME - ), - // 기기마다 따로 적는다 — 각인만 빼는 핫픽스가 이 줄 하나로 끝나야 한다. - "s5e9965" to setOf( - PillDetector.MODEL_FILE_NAME, - ImprintReader.MODEL_FILE_NAME, - MarkReader.MODEL_FILE_NAME - ) - ) - } -} diff --git a/app/src/main/kotlin/app/nursemate/telemetry/AnalyticsEvent.kt b/app/src/main/kotlin/app/nursemate/telemetry/AnalyticsEvent.kt index 8fdfdb6c..c119f4f8 100644 --- a/app/src/main/kotlin/app/nursemate/telemetry/AnalyticsEvent.kt +++ b/app/src/main/kotlin/app/nursemate/telemetry/AnalyticsEvent.kt @@ -251,26 +251,29 @@ sealed interface AnalyticsEvent { // 일도 없다. 새로 넣을 때는 [ANDROID_ONLY] 에도 적는다 — 대조 테스트가 이것만 빼고 비교한다. /** - * QNN 조건부 전달 결과 — **퀄컴 기기에서만, 앱 버전마다 한 번** 보낸다 (NM-603). + * 온디바이스 모델이 **어느 가속기로 열렸는지** — 모델 파일마다 **앱 버전당 한 번** 보낸다 (NM-628). * - * 기기그룹은 우리가 적어 둔 `SOC_MODEL` 만 맞춘다. 목록에 없는 칩은 조용히 base 만 받고 - * WebGPU/CPU 로 정상 동작해서 **느린 것 말고는 증상이 없다.** 그 비율과 칩 이름을 본다. - * 받은 기기도 보내야 비율의 분모가 생긴다. + * LiteRT 는 GPU 로 못 열면 조용히 CPU 로 돈다. 사용자에게는 느린 것 말고 증상이 없어서, 기기별로 GPU 가 + * 실제로 붙는 비율과 안 붙는 칩을 여기서 본다. ML 이 재지 못한 중급 · 구형 기기를 가려내는 자리다. * - * 기기 식별자·사용자 정보는 넣지 않는다 — 칩 이름과 전달 상태뿐이다. + * 기기 식별자 · 사용자 정보는 넣지 않는다 — 칩 이름과 모델 · 가속기뿐이다. * - * @param socModel `Build.SOC_MODEL` (예: `SM8650`) - * @param delivered `core+skel` · `core_only` · `skel_only` · `none` — `QnnDeliveryState` 참조 + * @param model 모델 파일 이름 (예: `p3_trunk.tflite`) — 각인은 조각마다 따로 온다 + * @param backend `gpu` · `cpu` + * @param cause `ok` · `planned_cpu` · `gpu_open_failed` · `gpu_blocked` — `OpenOutcome` 참조 + * @param socModel `Build.SOC_MODEL` (API 31 아래는 `Build.HARDWARE`) */ - data class QnnDelivery(val socModel: String, val delivered: String) : AnalyticsEvent { - override val name = "qnn_delivery" - override val params get() = mapOf("soc_model" to socModel, "delivered" to delivered) + data class OnDeviceBackend(val model: String, val backend: String, val cause: String, val socModel: String) : + AnalyticsEvent { + override val name = "ondevice_backend" + override val params + get() = mapOf("model" to model, "backend" to backend, "cause" to cause, "soc_model" to socModel) } companion object { /** iOS 카탈로그에 없는 이벤트 이름. 대조 테스트가 이 집합을 빼고 비교한다. */ - val ANDROID_ONLY: Set = setOf("qnn_delivery") + val ANDROID_ONLY: Set = setOf("ondevice_backend") private fun presetParams(label: String, category: String, durationSec: Int) = mapOf( "preset_label" to label, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 50ed2f8c..04e60028 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -10,8 +10,4 @@ 처치 타이머 시작 프리셋 하나를 지정해 두고 눌러서 바로 시작합니다. - - NPU 가속 diff --git a/app/src/test/kotlin/app/nursemate/pill/OnDeviceBackendReporterTest.kt b/app/src/test/kotlin/app/nursemate/pill/OnDeviceBackendReporterTest.kt new file mode 100644 index 00000000..6ddd35a0 --- /dev/null +++ b/app/src/test/kotlin/app/nursemate/pill/OnDeviceBackendReporterTest.kt @@ -0,0 +1,24 @@ +package app.nursemate.pill + +import app.nursemate.core.vision.OpenOutcome +import org.junit.Assert.assertEquals +import org.junit.Test + +class OnDeviceBackendReporterTest { + + @Test + fun `GPU 로 열리면 gpu · ok`() { + val e = OnDeviceBackendReporter.event("p3_trunk.tflite", OpenOutcome.GPU, "s5e9945") + assertEquals( + mapOf("model" to "p3_trunk.tflite", "backend" to "gpu", "cause" to "ok", "soc_model" to "s5e9945"), + e.params + ) + } + + @Test + fun `CPU 로 대체되면 cpu 와 그 까닭`() { + assertEquals("gpu_open_failed", OnDeviceBackendReporter.event("m", OpenOutcome.GPU_OPEN_FAILED, "x").cause) + assertEquals("cpu", OnDeviceBackendReporter.event("m", OpenOutcome.GPU_BLOCKED, "x").backend) + assertEquals("planned_cpu", OnDeviceBackendReporter.event("m", OpenOutcome.PLANNED_CPU, "x").cause) + } +} diff --git a/app/src/test/kotlin/app/nursemate/pill/QnnDeliveryReporterTest.kt b/app/src/test/kotlin/app/nursemate/pill/QnnDeliveryReporterTest.kt deleted file mode 100644 index fe8516f5..00000000 --- a/app/src/test/kotlin/app/nursemate/pill/QnnDeliveryReporterTest.kt +++ /dev/null @@ -1,27 +0,0 @@ -package app.nursemate.pill - -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Test - -class QnnDeliveryReporterTest { - - @Test - fun `퀄컴만 보고한다`() { - assertTrue(QnnDeliveryReporter.isQualcomm("QTI")) - // 엑시노스·텐서·미디어텍은 QNN 이 없어 none 이 정상이다 — 분모를 흐리지 않게 뺀다. - assertFalse(QnnDeliveryReporter.isQualcomm("Samsung")) - assertFalse(QnnDeliveryReporter.isQualcomm("Google")) - assertFalse(QnnDeliveryReporter.isQualcomm("Mediatek")) - assertFalse(QnnDeliveryReporter.isQualcomm("")) - } - - @Test - fun `Play 설치만 센다`() { - assertTrue(QnnDeliveryReporter.isFromPlay("com.android.vending")) - // adb·Android Studio 설치는 feature module 을 전부 깔아 기기그룹을 안 탔다. - assertFalse(QnnDeliveryReporter.isFromPlay(null)) - assertFalse(QnnDeliveryReporter.isFromPlay("com.android.shell")) - assertFalse(QnnDeliveryReporter.isFromPlay("com.sec.android.app.samsungapps")) - } -} diff --git a/app/src/test/kotlin/app/nursemate/telemetry/AnalyticsEventTest.kt b/app/src/test/kotlin/app/nursemate/telemetry/AnalyticsEventTest.kt index f80ca907..ba03cb4a 100644 --- a/app/src/test/kotlin/app/nursemate/telemetry/AnalyticsEventTest.kt +++ b/app/src/test/kotlin/app/nursemate/telemetry/AnalyticsEventTest.kt @@ -68,7 +68,7 @@ class AnalyticsEventTest { AnalyticsEvent.PresetCreate(label = "항생제", category = "투약", durationSec = 1_800), AnalyticsEvent.PresetEdit(label = "항생제", category = "투약", durationSec = 1_800), AnalyticsEvent.PresetDelete(label = "항생제", category = "투약", durationSec = 1_800), - AnalyticsEvent.QnnDelivery(socModel = "SM8650", delivered = "core+skel") + AnalyticsEvent.OnDeviceBackend(model = "p3_trunk.tflite", backend = "gpu", cause = "ok", socModel = "s5e9945") ) // ─────────────────────────── GA4 규격 ─────────────────────────── diff --git a/build-logic/convention/build.gradle.kts b/build-logic/convention/build.gradle.kts index 57b93a4d..12ad7300 100644 --- a/build-logic/convention/build.gradle.kts +++ b/build-logic/convention/build.gradle.kts @@ -45,10 +45,6 @@ gradlePlugin { id = libs.plugins.nursemate.jvm.library.get().pluginId implementationClass = "JvmLibraryConventionPlugin" } - register("qnnFeature") { - id = libs.plugins.nursemate.qnn.feature.get().pluginId - implementationClass = "QnnFeatureConventionPlugin" - } register("hilt") { id = libs.plugins.nursemate.hilt.get().pluginId implementationClass = "HiltConventionPlugin" diff --git a/build-logic/convention/src/main/kotlin/QnnFeatureConventionPlugin.kt b/build-logic/convention/src/main/kotlin/QnnFeatureConventionPlugin.kt deleted file mode 100644 index bb400418..00000000 --- a/build-logic/convention/src/main/kotlin/QnnFeatureConventionPlugin.kt +++ /dev/null @@ -1,216 +0,0 @@ -import app.nursemate.buildlogic.libs -import com.android.build.api.dsl.DynamicFeatureExtension -import com.android.build.api.variant.DynamicFeatureAndroidComponentsExtension -import java.io.File -import java.util.zip.ZipFile -import org.gradle.api.DefaultTask -import org.gradle.api.Plugin -import org.gradle.api.Project -import org.gradle.api.file.ConfigurableFileCollection -import org.gradle.api.file.DirectoryProperty -import org.gradle.api.provider.SetProperty -import org.gradle.api.tasks.Input -import org.gradle.api.tasks.InputFiles -import org.gradle.api.tasks.OutputDirectory -import org.gradle.api.tasks.PathSensitive -import org.gradle.api.tasks.PathSensitivity -import org.gradle.api.tasks.TaskAction -import org.gradle.kotlin.dsl.apply -import org.gradle.kotlin.dsl.configure -import org.gradle.kotlin.dsl.dependencies -import org.gradle.kotlin.dsl.register - -/** - * QNN 조건부 전달 모듈을 만든다 — `qnn_core` 하나와 세대별 `qnn_v69` · `qnn_v73` · `qnn_v75` · `qnn_v79` · `qnn_v81`. - * - * ## 왜 세대마다 모듈을 따로 두나 - * QNN 백엔드에서 덩치는 **세대별 Skel** 이다(세대당 16MB). 기기는 자기 세대 하나만 쓰는데 - * 한 모듈에 다 넣으면 전부 받는다 — 48MB 가 그냥 버려진다. - * - * `.so` 는 기기그룹별 변형을 만들 수 없다. 에셋은 `#group_` 접미사로 한 팩 안에서 갈리지만 - * `jniLibs` 에는 그런 길이 없고, 조건은 **모듈 단위로만** 걸린다. 그래서 모듈을 쪼갠다. - * - * | 모듈 | 담는 것 | 크기 | 설치 조건 | - * |---|---|---|---| - * | `qnn_core` | EP 번역기 + `libQnnHtp` · `libQnnSystem` | 9.2MB | 퀄컴 그룹 **전부** | - * | `qnn_v##` | 그 세대 `Skel`(16MB) · `Stub` | 16.6MB | 그 세대 그룹만 | - * - * ## 왜 Maven 의존성을 안 물고 `.so` 를 꺼내 쓰나 - * 세 모듈이 `qnn-runtime` 을 각자 물면 AGP 가 **「여러 APK 가 같은 라이브러리를 패키징한다」** - * 로 빌드를 막는다 — 파일을 서로 다르게 걸러 담아도 artifact 단위로 본다. - * - * 그래서 artifact 는 **풀기만** 하고(`qnnRuntimeAar` 설정) 필요한 파일만 generated jniLibs 로 - * 옮긴다. 덤으로 **제외목록이 허용목록이 된다** — 전에는 「안 쓰는 세대를 전부 적어서 빼는」 - * 방식이라 artifact 에 새 세대가 생기면 조용히 모든 모듈에 딸려 들어갔다. 지금은 적은 것만 - * 들어간다. - * - * ## 무엇을 버리나 - * - **`libQnnHtpPrepare.so` (80MB)** — 기기에서 모델을 컴파일하는 **컴파일러**. EPContext 를 - * 미리 구워 실으므로 필요 없다 - * - 다른 세대 `Skel`/`Stub` · `libQnnGpu.so` · `libQnnDsp*.so` - * - * ⚠️ **`HtpPrepare` 를 뺐으므로 기기에서 컴파일할 수 없다.** QNN 으로 여는 모델은 반드시 - * 미리 구운 EPContext 여야 한다. 원본 ONNX 를 QNN 으로 열면 세션 생성에서 실패한다. - * - * ⚠️ **지금 운영 경로는 QNN 을 부르지 않는다.** `OrtBackend.openSession` 은 WebGPU 아니면 CPU 이고, - * QNN 은 계측 테스트의 `forcedEp` 로만 열린다. 미리 구운 EPContext 도 아직 싣지 않는다. 그러니 - * 이 모듈은 지금 퀄컴 기기에 **내려가기만 하고 쓰이지 않는다.** 운영에 넣을 때 EPContext 와 - * 「QNN 세션 실패 → 원본을 WebGPU/CPU 로」 폴백을 같이 만든다(NM-599). - */ -abstract class QnnFeatureConventionPlugin : Plugin { - override fun apply(target: Project) { - with(target) { - val wanted = wantedLibs(name) - - // Kotlin 은 AGP 9 에 내장이라 따로 적용하지 않는다(루트 CLAUDE.md). - apply(plugin = "com.android.dynamic-feature") - - extensions.configure { - namespace = "app.nursemate." + name.replace('-', '_') - // convention 플러그인(`nursemate.android.*`)이 쓰는 값과 같은 숫자다. 이 모듈에는 - // 코드가 한 줄도 없어서 그쪽 Hilt·테스트 구성은 전부 군더더기다. - compileSdk = 37 - // base 는 26 인데 여기만 27 이다 — 플러그인 artifact 가 27 을 요구한다. - // `system-on-chip` 조건 자체가 API 31+ 라 실질적으로는 더 높아도 상관없다. - defaultConfig.minSdk = 27 - - // base 와 **같아야** 한다 — `extractNativeLibs` 가 모듈마다 갈리면 어떤 split 은 - // 풀리고 어떤 split 은 안 풀린다. QNN 은 skel 이 실파일이어야 도므로 여기도 켠다. - // 사정은 app/build.gradle.kts 의 같은 설정 주석 참고. - packaging.jniLibs.useLegacyPackaging = true - } - - // 풀어 쓰기만 하는 설정 — `implementation` 이 아니라서 AGP 가 패키징하지 않는다. - val aars = configurations.create("qnnRuntimeAar") { - isCanBeConsumed = false - isTransitive = false - } - dependencies { add(aars.name, libs.findLibrary("qnn.runtime").get()) } - - val jniLibs = tasks.register("generateQnnJniLibs") { - sourceAars.from(aars) - libNames.set(wanted) - outputDir.set(layout.buildDirectory.dir("generated/qnnJniLibs")) - } - extensions.configure { - onVariants { variant -> - variant.sources.jniLibs?.addGeneratedSourceDirectory(jniLibs, QnnJniLibsTask::outputDir) - } - } - - dependencies { - "implementation"(project(":app")) - if (name == CORE_MODULE) { - // EP 번역기. **여기 한 곳에서만** 문다 — 클래스(`QnnPluginEpLibraryKt`)가 - // 들어 있어서 두 모듈에 들어가면 중복 패키징이 된다. base 의 core:vision 은 - // 이 클래스들을 `compileOnly` 로 컴파일만 하고 런타임에 이 모듈을 쓴다. - "implementation"(libs.findLibrary("onnxruntime.qnn.plugin").get()) - } - // ⚠️ 세대 모듈이 `qnn_core` 를 **의존으로 걸 수 없다.** bundletool 이 막는다 — - // 「조건부 모듈은 설치 시점이 아닌 모듈에 의존할 수 없다」. 조건부끼리는 - // 서로 의존이 안 된다는 뜻이다. - // - // 걸 필요도 없다. `qnn_core` 는 퀄컴 그룹 전부에, 세대 모듈은 그중 자기 - // 그룹에 걸려 있어서 **둘은 언제나 함께 깔린다.** 다만 그래서 그룹 목록이 - // 어긋나면 조용히 토대만 빠진다 — 세대를 더할 때 `qnn_core` 매니페스트에 - // 그룹을 같이 추가해야 하는 이유다. - } - } - } - - private companion object { - const val CORE_MODULE = "qnn_core" - - /** 세션·메모리·직렬화. 세대와 무관해서 한 번만 싣는다. */ - val CORE_LIBS = setOf("libQnnHtp.so", "libQnnSystem.so") - - fun wantedLibs(moduleName: String): Set { - if (moduleName == CORE_MODULE) return CORE_LIBS - val generation = moduleName.substringAfterLast("_v") - require(generation.toIntOrNull() != null) { - "QNN feature 모듈 이름은 `$CORE_MODULE` 이거나 `qnn_v<세대>` 꼴이어야 한다 (받은 것: $moduleName)" - } - // Skel 은 **DSP 위에서** 도는 연산 커널, Stub 은 앱 CPU 쪽 FastRPC 창구다. 한 쌍이다. - return setOf("libQnnHtpV${generation}Skel.so", "libQnnHtpV${generation}Stub.so") - } - } -} - -/** - * `qnn-runtime` AAR 에서 **적어 준 `.so` 만** 꺼내고, 다른 ABI 용 **빈 `.so`** 를 만든다. - * - * ## 왜 빈 파일이 필요한가 - * bundletool 이 「네이티브를 가진 모듈은 ABI 집합이 같아야 한다」고 막는다. base 는 넷 - * (arm64-v8a · armeabi-v7a · x86 · x86_64)인데 QNN artifact 는 **arm64 하나뿐**이다 — - * Hexagon 이 arm64 스냅드래곤에만 있어서 다른 판이 아예 존재하지 않는다. - * - * 이 빈 파일들은 **아무도 받지 않는다.** 그 ABI 기기가 퀄컴 기기그룹에 맞을 리 없어서 - * 조각이 만들어지기만 하고 전달되지 않는다. 저장소에 가짜 바이너리를 커밋하지 않으려고 - * 빌드 때 만든다. - */ -abstract class QnnJniLibsTask : DefaultTask() { - - @get:InputFiles - @get:PathSensitive(PathSensitivity.NAME_ONLY) - abstract val sourceAars: ConfigurableFileCollection - - @get:Input - abstract val libNames: SetProperty - - @get:OutputDirectory - abstract val outputDir: DirectoryProperty - - @TaskAction - fun generate() { - val root = outputDir.get().asFile - root.deleteRecursively() - - val wanted = libNames.get() - val found = mutableSetOf() - val arm64 = File(root, ABI).apply { mkdirs() } - - for (aar in sourceAars) { - found += extractInto(aar, arm64, wanted) - } - - // 조용히 비는 것을 막는다 — `.so` 가 빠지면 세션 생성이 실패하는 게 아니라 QNN 이 - // 노드를 하나도 안 가져가 **CPU 로 돌면서 테스트가 통과한다.** 여기서 끊는다. - check(found == wanted) { - "qnn-runtime AAR 에서 못 찾은 라이브러리: ${wanted - found} (찾은 것: $found)" - } - - for (abi in PLACEHOLDER_ABIS) { - File(root, abi).apply { mkdirs() } - .resolve("libqnn_abi_placeholder.so") - .writeBytes(ByteArray(0)) - } - } - - /** - * `aar` 안에서 [wanted] 에 적힌 `.so` 만 [dest] 로 옮긴다. - * - * @return 실제로 옮긴 이름들. 부르는 쪽이 [wanted] 와 대조해 **조용히 비는 것**을 막는다. - */ - private fun extractInto(aar: File, dest: File, wanted: Set): Set { - val copied = mutableSetOf() - ZipFile(aar).use { zip -> - zip.entries().asSequence() - .filterNot { it.isDirectory } - .filter { it.name.substringAfterLast('/') in wanted } - .filter { it.name.contains("/$ABI/") } - .forEach { entry -> - val name = entry.name.substringAfterLast('/') - zip.getInputStream(entry).use { input -> - File(dest, name).outputStream().use(input::copyTo) - } - copied += name - } - } - return copied - } - - private companion object { - const val ABI = "arm64-v8a" - val PLACEHOLDER_ABIS = listOf("armeabi-v7a", "x86", "x86_64") - } -} diff --git a/core/vision/build.gradle.kts b/core/vision/build.gradle.kts index 0e2f5217..f51d2202 100644 --- a/core/vision/build.gradle.kts +++ b/core/vision/build.gradle.kts @@ -9,7 +9,7 @@ android { /* * 계측 테스트 APK 의 ABI 를 하나로 줄이는 탈출구 — **Firebase Test Lab 에 올릴 때만** 쓴다. * - * OpenCV 와 ONNX Runtime 이 ABI 4개분 네이티브를 싣고 와서 테스트 APK 가 267MB 다. + * OpenCV 와 LiteRT 가 ABI 4개분 네이티브를 싣고 와서 테스트 APK 가 크다. * 올리는 데만 한참 걸리는데 Test Lab 실기기는 전부 arm64 다. * * ``` @@ -26,56 +26,13 @@ android { * 테스트 메서드마다 프로세스를 새로 띄운다 (NM-577). * * 두 가지를 막는다. - * - **세그폴트가 나머지를 날리는 것.** Adreno 에서 각인이 죽으면 그 뒤 EP 를 하나도 못 쟀다. - * - **테스트끼리 메모리를 물려받는 것.** 한 프로세스에서 119MB 검출 모델을 EP 마다 열면 + * - **세그폴트가 나머지를 날리는 것.** GPU 드라이버가 죽으면 그 뒤 테스트를 하나도 못 잰다(ORT 시절 Adreno 각인). + * - **테스트끼리 메모리를 물려받는 것.** 한 프로세스에서 큰 검출 모델을 여러 번 열면 * 뒤쪽 테스트가 압박을 받아 메시지도 없이 죽는다(2026-10-13 실측). * * Test Lab 은 `--use-orchestrator`, 로컬은 이 설정이 같은 일을 한다. */ testOptions.execution = "ANDROIDX_TEST_ORCHESTRATOR" - - /* - * QNN 런타임에서 **쓰지 않는 것**을 덜어낸다 — NM-577. - * - * `qnn-runtime` 이 arm64 비압축 214MB 다. 그중 실제로 필요한 것은 넷뿐이다. - * - `libQnnHtp.so` · `libQnnSystem.so` — 백엔드와 그래프 직렬화 - * - `libQnnHtpPrepare.so`(84MB) — **기기에서 ONNX 그래프를 컴파일**할 때만 쓴다. - * `ep.context_file_path` 로 컴파일 결과를 캐시하면 둘째 실행부터는 안 들어가고, - * 미리 컴파일한 EPContext 모델을 싣는다면 아예 빼도 된다. - * - `libQnnHtpV##Skel/Stub.so` — HTP 세대별. Skel 은 DSP 쪽에서 돌고 앱이 실어 줘야 한다. - * - * 덜어내는 것: - * - `libQnnGpu.so`(11.8MB) — QNN 의 OpenCL 백엔드. 우리 GPU 길은 ORT WebGPU 다. - * - `libQnnDsp*.so`(4.3MB) — Hexagon **DSP(v66)**, 스냅드래곤 855 세대. 대상에 없다. - * - `V68` skel — 888 세대. HTP 가 부동소수 연산을 못 받아 우리 모델이 안 돈다(S21 실측). - * - * 남기는 세대: **V69**(8 Gen 1 · S22) · **V73**(8 Gen 2 · S23) · **V75**(8 Gen 3 · S24) · - * **V79**(8 Elite · S25) · **V81**(8 Elite Gen 5 · S26). 기기의 `htp_arch` 와 안 맞으면 세션 - * 생성부터 실패하므로 넉넉히 둔다. - */ - /* - * `.so` 를 APK **밖으로 풀어** 설치한다 — QNN 이 그걸 요구한다(NM-577). - * - * AGP 기본은 `useLegacyPackaging=false` 다. 그래도 `dlopen` 은 되는데(ORT 가 그렇게 돈다) - * HTP 는 다르다. DSP 쪽 skel(`libQnnHtpV73Skel.so`)은 **cDSP 데몬이 파일 경로로** 연다 — - * `base.apk!/lib/arm64-v8a/...` 를 열 수 없어 `errno 2` 로 실패하고, 그러면 QNN EP 가 - * 노드를 하나도 안 가져가 **전부 CPU 로 돌면서 테스트는 통과한다.** - * - * ⚠️ **라이브러리 모듈의 packaging 은 이 모듈의 계측 테스트 APK 에만 먹는다.** 운영 AAB 의 - * QNN 구성은 `app` 의 같은 설정과 세대별 feature module(`QnnFeatureConventionPlugin` 허용목록)이 - * 정한다. 운영 용량을 줄이려고 아래 excludes 를 고쳐도 아무것도 안 바뀐다. - */ - packaging.jniLibs.useLegacyPackaging = true - - // 테스트 APK 용 — 쓰지 않는 백엔드와 옛 세대를 덜어 Test Lab 업로드를 줄인다. - packaging.jniLibs.excludes += setOf( - "**/libQnnGpu.so", - "**/libQnnDsp.so", - "**/libQnnDspV66Skel.so", - "**/libQnnDspV66Stub.so", - "**/libQnnHtpV68Skel.so", - "**/libQnnHtpV68Stub.so" - ) } /* @@ -113,22 +70,22 @@ configurations.configureEach { } dependencies { - // 온디바이스 추론 — 검출·각인·마크 셋 다 이 런타임으로 돈다. + // 온디바이스 추론 — 검출 · 각인 · 마크 셋 다 LiteRT `CompiledModel` 로 돈다(NM-628). // - // 프리빌트 Maven 배포본에 **CPU · WebGPU · NNAPI · XNNPACK** 이 들어 있다. NM-396 스파이크 - // 때는 WebGPU 를 쓰려면 소스 빌드가 필요했는데 그 뒤 프리빌트에 들어왔다 — 지금은 WebGPU 가 - // 운영 경로다(`OrtBackend`). EP 별 실측은 같은 KDoc 의 비교표. - implementation(libs.onnxruntime.android) - - // 퀄컴 Hexagon NPU(HTP) — **컴파일만 한다.** 실제 `.so` 와 클래스는 조건부 전달 모듈 - // `:qnn` 이 들고 있고, Play 가 퀄컴 기기에만 설치한다. + // 전 기기 같은 모델 파일 · 기기별 분기 없음. GPU(OpenCL) 가 안 되면 같은 파일을 CPU 로 연다. + // 앱에 싣는다(Play 서비스 판이 아니다) — ML 이 이 판(2.3.0 CompiledModel)으로 정확도를 쟀고, + // 버전이 우리 모르게 바뀌지 않아야 기기별 출력 차이를 추적할 수 있다. arm64 약 8.9MB. + // NPU 런타임(`litert-npu-*`)은 넣지 않는다 — 2.1.0 범위 밖. // - // 위 표준 배포본을 그대로 두고 **덧붙는 플러그인 EP** 라서(카탈로그 주석에 근거) base 의 - // ORT 를 건드리지 않는다 — 그래서 모듈 하나를 더하고 빼는 것으로 갈라진다. - // - // ⚠️ `compileOnly` 다. 런타임에 없을 수 있으므로 **부르기 전에 [QNN_BUNDLED] 를 본다.** - // 그냥 부르면 NoClassDefFoundError 다. - compileOnly(libs.onnxruntime.qnn.plugin) + // ⚠️ **`play:ai-delivery` 를 뺀다.** `litert-api` 가 Play for On-device AI 의 AI Pack 받기(알파)를 끌고 오고, + // 그게 `asset-delivery` → `work-runtime` 을 끌고 온다. 그러면 WorkManager 가 androidx.startup 으로 프로세스 + // 시작 때 돌다 **release(R8)에서 `WorkDatabase` 생성에 실패해 앱이 바로 죽는다** — PR #21(Glance)과 같은 + // 결함이다(2026-10-19 에뮬레이터 릴리스 스모크). 덤으로 `FOREGROUND_SERVICE_DATA_SYNC` 권한과 서비스 · 리시버 + // 여럿이 병합돼 Play 에 포그라운드 서비스 신고까지 요구된다. + // 우리는 모델을 assets 에서 파일로 연다 — AI Pack 을 쓰는 클래스는 `deployment.AiPackModelProvider` 하나뿐이고 + // 부르지 않는다(남는 빈 참조는 `proguard-rules.pro` 의 `-dontwarn`). Play AI Pack 으로 옮길 때 되살린다. + implementation(libs.litert) { exclude(group = "com.google.android.play", module = "ai-delivery") } + implementation(libs.litert.gpu) { exclude(group = "com.google.android.play", module = "ai-delivery") } // 각인 OCR 전처리(NM-485) — CLAHE(clip 3.0, 8×8) · morphologyEx(CLOSE) · // connectedComponents · floodFill · warpAffine · resize(INTER_AREA). @@ -158,19 +115,7 @@ dependencies { androidTestImplementation(libs.androidx.test.runner) androidTestImplementation(libs.androidx.test.ext.junit) - // 측정 하네스는 QNN 을 **실제로** 돌려야 한다. 운영 경로는 `:qnn` 모듈이 받지만 이 - // 테스트 APK 는 그 모듈을 못 쓰므로(계측 테스트는 base 만 본다) 여기서 직접 문다. - // 운영 APK 에는 들어가지 않는다 — androidTest 구성이다. - androidTestImplementation(libs.onnxruntime.qnn.plugin) - androidTestImplementation(libs.qnn.runtime) - - // 메서드마다 프로세스를 새로 띄운다 — Adreno 에서 세그폴트가 나도 나머지 EP 를 끝까지 잰다. + // 메서드마다 프로세스를 새로 띄운다 — GPU 드라이버가 세그폴트를 내도 나머지 테스트를 끝까지 돈다. // Test Lab 은 --use-orchestrator, 로컬은 android.testInstrumentationRunnerArguments.clearPackageData 와 함께. androidTestUtil(libs.androidx.test.orchestrator) - - // LiteRT — **계측 테스트에만** 넣는다. 운영 APK 에는 안 들어간다. - // ONNX Runtime 을 대체하려는 것이 아니라, WebGPU 가 못 가는 기기(Mali 전멸, - // Adreno 각인·검출 사망)에서 OpenCL GPU 델리게이트가 대안이 되는지 재는 용도다. - androidTestImplementation(libs.litert) - androidTestImplementation(libs.litert.gpu) } diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorEpTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorEpTest.kt deleted file mode 100644 index c4c7cd28..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorEpTest.kt +++ /dev/null @@ -1,172 +0,0 @@ -package app.nursemate.core.vision - -import android.net.Uri -import android.os.Build -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import java.io.File -import kotlin.math.abs -import kotlinx.coroutines.runBlocking -import org.junit.After -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Assume.assumeTrue -import org.junit.Before -import org.junit.Test -import org.junit.runner.RunWith - -/** - * **검출 모델(RF-DETR-Seg)을 EP 별로 잰다** — NM-577. - * - * ## 왜 필요한가 - * 각인은 전 기기에서 CPU 가 최선이고 마크는 Adreno 에서 WebGPU 가 2배 빠른데, **검출만 EP 를 - * 재 본 적이 없다.** 기록에 남은 것은 Xclipse 한 대의 `CPU 1572 → WebGPU 813 ms` 뿐이다. - * 검출은 식별할 때마다 반드시 도는 모델이라 여기서 EP 가 갈리면 영향이 가장 크다. - * - * ## 사진은 저장소에 없다 - * 약포 사진은 PII 라 커밋하지 않는다. 기기에 밀어 넣은 것을 읽고, 없으면 **건너뛴다** - * (`assumeTrue` — 통과가 아니라 skipped 로 남는다). - * - * ``` - * adb push pills-1.jpg /sdcard/Android/data/app.nursemate.core.vision.test/files/ - * ``` - * - * ⚠️ **하위 디렉터리를 쓰지 않는다.** `adb shell mkdir` 로 만든 디렉터리는 `shell` 소유에 - * `drwxrws---` 라 앱이 목록을 못 읽는다 — 테스트가 조용히 skipped 로 넘어간다(2026-10-13 에 - * 실제로 겪었다). `files/` 바로 아래 파일은 `-rw-rw-rw-` 로 들어와 읽힌다. - * - * ## CPU 를 기준으로 **같은 프로세스에서** 맞댄다 - * 기기가 다르면 CPU 끼리도 미세하게 갈려 EP 차이와 섞인다. 한 테스트 안에서 CPU 를 먼저 - * 돌려 기준을 만들고, 그다음 재려는 EP 로 같은 사진을 돌린다. - * - * ⚠️ **개수만 보지 않는다.** 임계가 0.5 라 점수 0.51 이 0.49 로 밀리면 개수가 바뀌지만, - * 0.51 이 0.50 으로 밀린 것은 개수로 안 보이면서 **다음 사진에서 뒤집힐** 상태다. 그래서 - * 점수와 박스를 원소별로 맞댄다. - * - * 결과는 logcat `NM-DETEP`. - */ -@RunWith(AndroidJUnit4::class) -class DetectorEpTest { - - private lateinit var model: File - private lateinit var photos: List - - @Before - fun setUp() { - val context = InstrumentationRegistry.getInstrumentation().context - val dir = context.getExternalFilesDir(null) - model = File(dir, PillDetector.MODEL_FILE_NAME) - assumeTrue("검출 모델이 없어 건너뛴다", model.isFile && model.length() > 0) - - photos = dir?.listFiles() - ?.filter { it.name.startsWith(PHOTO_PREFIX) && it.extension.lowercase() in IMAGES } - ?.sortedBy { it.name }.orEmpty() - assumeTrue("검출용 사진이 없어 건너뛴다 — files/ 에 $PHOTO_PREFIX*.jpg 를 밀어 넣어야 한다", photos.isNotEmpty()) - - // [Ep.QNN_CACHED] 가 컴파일 결과를 쓸 곳. 모델이 놓인 자리는 adb 가 밀어 넣은 데라 - // 앱에 쓰기 권한이 없을 수 있어 앱 캐시로 보낸다. - OrtBackend.contextCacheDir = InstrumentationRegistry.getInstrumentation().targetContext.cacheDir - // HTP 가 DSP skel 을 찾는 자리. 여기를 안 주면 EP 가 노드를 하나도 안 가져가고 - // **CPU 로 돌면서 성공한다** — [OrtBackend.qnnNativeLibDir] KDoc 참조. - OrtBackend.qnnNativeLibDir = - File(InstrumentationRegistry.getInstrumentation().targetContext.applicationInfo.nativeLibraryDir) - } - - @After - fun tearDown() { - OrtBackend.forcedEp = null - OrtBackend.contextCacheDir = null - OrtBackend.qnnNativeLibDir = null - } - - @Test fun `검출_CPU`() = measure(Ep.CPU) - - @Test fun `검출_WEBGPU`() = measure(Ep.WEBGPU) - - @Test fun `검출_NNAPI`() = measure(Ep.NNAPI) - - @Test fun `검출_XNNPACK`() = measure(Ep.XNNPACK) - - @Test fun `검출_QNN`() = measure(Ep.QNN) - - @Test fun `검출_QNN_FP32`() = measure(Ep.QNN_FP32) - - @Test fun `검출_QNN_CACHED`() = measure(Ep.QNN_CACHED) - - private fun measure(ep: Ep) = runBlocking { - val bitmaps = photos.map { file -> - val context = InstrumentationRegistry.getInstrumentation().context - file.name to ImageLoader.load(context, Uri.fromFile(file)) - } - - val reference = if (ep == Ep.CPU) null else detectAll(Ep.CPU, bitmaps) - val actual = detectAll(ep, bitmaps) - - actual.forEach { (name, pills) -> - val scores = pills.joinToString { "%.3f".format(it.score) } - Log.i(TAG, "검출 | $ep | $name | ${pills.size}개 | $scores | ${Build.MODEL} ${soc()}") - } - - if (reference == null) return@runBlocking - - for ((name, expected) in reference) { - val got = actual.getValue(name) - assertEquals("[$ep] $name 검출 개수", expected.size, got.size) - - var worstScore = 0f - var worstBox = 0f - for (i in expected.indices) { - worstScore = maxOf(worstScore, abs(expected[i].score - got[i].score)) - worstBox = maxOf( - worstBox, - maxOf( - abs(expected[i].x - got[i].x), - abs(expected[i].y - got[i].y), - abs(expected[i].width - got[i].width), - abs(expected[i].height - got[i].height) - ) - ) - } - Log.i(TAG, "검출 | $ep | $name | CPU 대비 점수차 $worstScore · 박스차 $worstBox") - - assertTrue("[$ep] $name 점수가 CPU 와 $worstScore 벌어졌다", worstScore < SCORE_TOLERANCE) - assertTrue("[$ep] $name 박스가 CPU 와 $worstBox 벌어졌다", worstBox < BOX_TOLERANCE) - } - } - - private suspend fun detectAll(ep: Ep, bitmaps: List>) = buildMap { - OrtBackend.forcedEp = ep - PillDetector(model).use { detector -> - // ⚠️ **첫 실행은 버린다.** WebGPU 는 여기서 셰이더를 컴파일하는데, 그걸 포함해 재면 - // 실제보다 몇 배 느리게 나온다 — S24 에서 각인이 기록 1796ms 대 측정 5812ms 로 - // 벌어진 것이 이 때문이었다(2026-10-13). CPU 는 예열 비용이 거의 없어, 예열 없이 - // 재면 WebGPU 만 일방적으로 손해를 본다. - bitmaps.firstOrNull()?.let { (_, warmup) -> detector.detect(warmup) } - - for ((name, bitmap) in bitmaps) { - val result = detector.detect(bitmap) - Log.i(TAG, "검출 | $ep | $name | 추론 ${result.timings.inferenceMs}ms") - put(name, result.pills.map { it.detection }.sortedBy { it.query }) - } - } - } - - private fun soc(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { - "${Build.SOC_MANUFACTURER} ${Build.SOC_MODEL}" - } else { - Build.HARDWARE - } - - private companion object { - const val TAG = "NM-DETEP" - const val PHOTO_PREFIX = "pills-" - val IMAGES = setOf("jpg", "jpeg", "png") - - /** 임계가 0.5 다. 0.02 면 그 경계에서 뒤집히기 한참 전에 걸린다. */ - const val SCORE_TOLERANCE = 2e-2f - - /** 0~1 정규화 좌표. 5e-3 이면 2048px 기준 10px 로, 크롭 테두리가 눈에 띄게 어긋나기 전이다. */ - const val BOX_TOLERANCE = 5e-3f - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorParityTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorParityTest.kt new file mode 100644 index 00000000..1047306a --- /dev/null +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DetectorParityTest.kt @@ -0,0 +1,93 @@ +package app.nursemate.core.vision + +import android.graphics.BitmapFactory +import android.util.Log +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import java.io.File +import kotlinx.coroutines.runBlocking +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Assume.assumeTrue +import org.junit.Test +import org.junit.runner.RunWith + +/** + * 검출기(RF-DETR-Seg, LiteRT)가 **같은 기기에서 GPU 와 CPU 로 같은 답**을 내는지 본다 — NM-628. + * + * 각인 · 마크는 기준 구현 값과 맞대는 대조 테스트가 있는데 검출은 없었다(ORT 시절 `DetectorEpTest` 는 EP 측정용). + * 여기서는 CPU(fp32)를 기준으로 GPU(FP32 계약)가 개수 · 상자 · 점수 · 마스크 크롭까지 같은지 본다. + * CPU 결과가 맞는 배치인지(NHWC · 마스크 쿼리 마지막 축)는 검출 개수와 크롭 크기가 말해 준다 — + * 배치가 틀리면 0개이거나 크롭이 엉뚱한 크기로 나온다. + * + * ## 모델 · 사진이 없으면 건너뛴다 + * 둘 다 저장소에 넣지 않는다. 사진은 ML 레포 예제(환자 정보 없음)다. + * ``` + * D=/sdcard/Android/data/app.nursemate.core.vision.test/files + * adb push app/src/main/assets/rfdetr_seg_small_f16w.tflite $D/ + * adb push ../ML/models/seg/20260610-rfdetr-seg-small/sample_pouch.jpg $D/ + * ``` + */ +@RunWith(AndroidJUnit4::class) +class DetectorParityTest { + + @After + fun restore() { + VisionBackend.allowGpu = { true } + } + + @Test + fun `GPU_와_CPU_의_검출이_같다`() { + val dir = InstrumentationRegistry.getInstrumentation().context.getExternalFilesDir(null) + val model = File(dir, PillDetector.MODEL_FILE_NAME) + val photo = File(dir, PHOTO) + assumeTrue("모델 · 사진이 없어 건너뛴다", model.isFile && photo.isFile) + val bitmap = requireNotNull(BitmapFactory.decodeFile(photo.path)) { "사진을 못 읽었다" } + + VisionBackend.allowGpu = { true } + val gpu = runBlocking { + PillDetector(model).use { + // GPU 로 못 열려 CPU 로 대체됐으면 CPU 끼리 맞댄 셈이 된다 — 그건 통과가 아니다. + assertTrue("GPU 로 열리지 않았다(대체됨) — logcat 「LiteRt」", it.onGpu) + it.detect(bitmap) + } + } + VisionBackend.allowGpu = { false } + val cpu = runBlocking { PillDetector(model).use { it.detect(bitmap) } } + + Log.i( + TAG, + "${bitmap.width}×${bitmap.height} · CPU ${cpu.pills.size}개 ${cpu.timings.inferenceMs}ms · " + + "GPU ${gpu.pills.size}개 ${gpu.timings.inferenceMs}ms" + ) + assertTrue("CPU 가 하나도 못 찾았다 — 입출력 배치를 의심한다", cpu.pills.isNotEmpty()) + assertEquals("검출 개수", cpu.pills.size, gpu.pills.size) + + for (c in cpu.pills) { + val g = gpu.pills.maxBy { it.detection.iou(c.detection) } + val iou = g.detection.iou(c.detection) + Log.i( + TAG, + "q${c.detection.query} 점수 ${c.detection.score} / ${g.detection.score} · IoU $iou · " + + "크롭 ${c.crop.width}×${c.crop.height} / ${g.crop.width}×${g.crop.height}" + ) + assertTrue("상자 IoU $iou", iou >= MIN_IOU) + assertEquals("점수", c.detection.score, g.detection.score, SCORE_TOLERANCE) + assertEquals("크롭 폭", c.crop.width.toFloat(), g.crop.width.toFloat(), c.crop.width * CROP_TOLERANCE) + assertEquals("크롭 높이", c.crop.height.toFloat(), g.crop.height.toFloat(), c.crop.height * CROP_TOLERANCE) + } + } + + private companion object { + const val TAG = "DetectorParity" + const val PHOTO = "sample_pouch.jpg" + + /** ML 공식 세트에서 fp32 대비 상자 IoU 0.998 이었다 — 같은 기기 CPU 대비는 그보다 가까워야 한다. */ + const val MIN_IOU = 0.98f + const val SCORE_TOLERANCE = 0.02f + + /** 마스크 경계가 한 칸(144 격자) 움직이면 크롭이 몇 % 바뀐다. */ + const val CROP_TOLERANCE = 0.05f + } +} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DeviceProbeTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DeviceProbeTest.kt deleted file mode 100644 index 60c890fd..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/DeviceProbeTest.kt +++ /dev/null @@ -1,194 +0,0 @@ -package app.nursemate.core.vision - -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.qnnpluginep.getEpName as qnnEpName -import ai.onnxruntime.qnnpluginep.getLibraryPath as qnnLibraryPath -import android.content.pm.PackageManager -import android.opengl.EGL14 -import android.opengl.EGLConfig -import android.opengl.EGLDisplay -import android.opengl.GLES20 -import android.os.Build -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import org.junit.Test -import org.junit.runner.RunWith - -/** - * 이 기기가 **무엇인지** 한 줄로 남긴다 — GPU · 실행 공급자 · Vulkan 판. - * - * ## 왜 있나 - * 성능·정확도 근거가 전부 Galaxy S24(SM-S921N · Exynos 2400 · Xclipse 940) 한 대에서 나왔다. - * 다른 기기에서 돌릴 때마다 **무슨 GPU 위에서 잰 값인지**가 기록에 남아야, 숫자가 갈릴 때 - * 기기 탓인지 코드 탓인지 가린다. [EpOverride] 가 고른 경로도 함께 찍는다. - * - * 아무것도 단정하지 않는다 — 통과 여부가 아니라 **로그가 산출물**이다. logcat 에서 - * `NM-PROBE` 로 찾는다. - */ -@RunWith(AndroidJUnit4::class) -class DeviceProbeTest { - - @Test - fun `기기와_실행공급자를_기록한다`() { - val path = EpOverride.apply() - val context = InstrumentationRegistry.getInstrumentation().context - - val lines = buildList { - add("기기 ${Build.MANUFACTURER} ${Build.MODEL} (${Build.DEVICE} · ${Build.HARDWARE})") - add("안드로이드 ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})") - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { - add("SoC ${Build.SOC_MANUFACTURER} ${Build.SOC_MODEL}") - } - add("ABI ${Build.SUPPORTED_ABIS.joinToString()}") - add("요청 경로 $path") - val providers = runCatching { OrtEnvironment.getAvailableProviders().joinToString() } - add("ORT EP ${providers.getOrElse { "조회 실패: $it" }}") - add("Vulkan ${vulkanVersion(context.packageManager)}") - addAll(glStrings()) - addAll(qnnLines()) - addAll(modelLines(context)) - } - - // 한 줄씩 찍는다 — logcat 이 긴 줄을 잘라서 묶어 찍으면 GPU 이름이 날아간다. - lines.forEach { Log.i(TAG, it) } - } - - /** - * **모델이 실제로 어디에 있는지** 찍는다. - * - * 모델은 저장소에 없어서(119MB) 기기로 밀어 넣는데, 경로가 한 칸만 어긋나도 테스트가 - * `assumeTrue` 에서 **조용히 skipped** 된다 — 통과처럼 보인다. Test Lab 은 실기기 할당량이 - * 하루 5회뿐이라 그렇게 한 번을 날리면 비싸다. 그래서 디렉터리를 그대로 남긴다. - */ - private fun modelLines(context: android.content.Context): List = buildList { - val dir = context.getExternalFilesDir(null) - add("모델 경로 $dir") - val files = dir?.listFiles() - when { - files == null -> add("모델 디렉터리를 못 읽었다") - - files.isEmpty() -> add("모델 **비어 있다** — 밀어 넣는 경로가 위와 같은지 보라") - - else -> files.sortedBy { it.name } - .forEach { add("모델 ${it.name} ${it.length() / 1024 / 1024}MB") } - } - } - - /** - * **QNN 플러그인이 꽂히는가** — 그리고 꽂은 뒤에도 WebGPU 가 남아 있는가(NM-577). - * - * ## 왜 이 두 줄이 같이 필요한가 - * `com.microsoft.onnxruntime:onnxruntime-android-qnn` 은 ORT 를 **갈아 끼우는** 배포본이라 - * 기기에서 재 보니 EP 가 `CPU, QNN` 둘뿐이었다 — WebGPU 를 버려야 QNN 을 얻는 거래였다. - * 지금 붙인 `com.qualcomm.qti:onnxruntime-android-qnn` 은 표준 배포본에 **덧붙는 플러그인** - * 이라고 되어 있다. 그 말이 맞으면 위 `ORT EP` 줄에 WebGPU 가 그대로 있고, 아래 줄에 - * QNN 디바이스가 함께 나온다. **둘이 같이 나오는 것이 증거다.** - * - * ## 플러그인 EP 는 `getAvailableProviders()` 에 안 나온다 - * 그쪽은 ORT 안에 박힌 EP 목록이다. 플러그인은 `registerExecutionProviderLibrary` 로 - * 환경에 올려야 비로소 `getEpDevices()` 에 나타난다. - * - * 단정하지 않는다 — 엑시노스에는 HTP 가 없어 **없는 것이 정상**이다. 기록만 남긴다. - */ - private fun qnnLines(): List = buildList { - val env = runCatching { OrtEnvironment.getEnvironment() }.getOrElse { - add("QNN 환경을 못 얻었다: $it") - return@buildList - } - - add("QNN 라이브러리 ${qnnLibraryPath()} · EP 이름 ${qnnEpName()}") - - runCatching { env.registerExecutionProviderLibrary(qnnEpName(), qnnLibraryPath()) } - .onFailure { - // 등록 실패가 곧 기록이다. `.so` 가 APK 에 안 들어갔거나, 기기의 vendor - // 라이브러리(`libcdsprpc.so` 등)를 못 찾은 경우가 여기로 온다. - add("QNN 등록 실패 — ${it.message}") - return@buildList - } - - val devices = runCatching { env.epDevices }.getOrElse { - add("QNN 디바이스 조회 실패 — ${it.message}") - return@buildList - } - add("EP 디바이스 ${devices.joinToString { "${it.epName}/${it.device.type}" }}") - for (device in devices.filter { it.epName == qnnEpName() }) { - add("QNN 디바이스 ${device.device.type} · 벤더 ${device.epVendor} · 메타 ${device.epMetadata}") - } - } - - /** - * `GL_RENDERER` 가 GPU 이름을 그대로 준다 — `Adreno (TM) 740` · `Mali-G715` · `Xclipse 940`. - * - * WebGPU 는 Vulkan 으로 내려가지만 Vulkan 에는 이렇게 손쉽게 이름을 묻는 길이 없다. GPU 를 - * 가리는 데는 GL 쪽 문자열로 충분하고, 같은 칩이면 두 드라이버가 같은 하드웨어를 가리킨다. - */ - private fun glStrings(): List { - val display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY) - if (display == EGL14.EGL_NO_DISPLAY) return listOf("$GL EGL 디스플레이를 못 얻었다") - - // 어디서 걸렸는지 남긴다. 조회가 통째로 비면 「GPU 를 못 읽었다」와 「GL 이 없다」가 섞인다. - var failure = "eglInitialize 실패" - var strings = emptyList() - val configs = arrayOfNulls(1) - val chosen = IntArray(1) - - if (EGL14.eglInitialize(display, IntArray(2), 0, IntArray(2), 1)) { - failure = "eglChooseConfig 실패" - val ok = EGL14.eglChooseConfig(display, CONFIG_SPEC, 0, configs, 0, 1, chosen, 0) - if (ok && chosen[0] > 0) { - failure = "eglMakeCurrent 실패" - strings = readStrings(display, configs[0]!!) - } - EGL14.eglTerminate(display) - } - - return strings.ifEmpty { listOf("$GL $failure") } - } - - /** 1×1 오프스크린이면 된다 — 문자열을 읽으려면 컨텍스트가 current 여야 할 뿐이다. */ - private fun readStrings(display: EGLDisplay, config: EGLConfig): List { - val surface = EGL14.eglCreatePbufferSurface(display, config, PBUFFER_SPEC, 0) - val context = EGL14.eglCreateContext(display, config, EGL14.EGL_NO_CONTEXT, CONTEXT_SPEC, 0) - if (!EGL14.eglMakeCurrent(display, surface, surface, context)) return emptyList() - - val strings = listOf( - "GL 벤더 ${GLES20.glGetString(GLES20.GL_VENDOR)}", - "GL 렌더러 ${GLES20.glGetString(GLES20.GL_RENDERER)}", - "GL 판 ${GLES20.glGetString(GLES20.GL_VERSION)}" - ) - - EGL14.eglMakeCurrent(display, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT) - EGL14.eglDestroySurface(display, surface) - EGL14.eglDestroyContext(display, context) - return strings - } - - /** 기기가 내거는 Vulkan 판. `0x400003` 형태의 정수라 사람이 읽게 풀어 준다. */ - private fun vulkanVersion(packages: PackageManager): String { - val feature = packages.systemAvailableFeatures - .firstOrNull { it.name == PackageManager.FEATURE_VULKAN_HARDWARE_VERSION } - ?: return "없음" - val v = feature.version - return "${v shr 22}.${(v shr 12) and 0x3FF}.${v and 0xFFF}" - } - - private companion object { - const val TAG = "NM-PROBE" - - /** 로그 줄의 머리. 실패 줄도 같은 폭으로 맞춰 둬야 눈으로 훑어진다. */ - const val GL = "GL " - - val CONFIG_SPEC = intArrayOf( - EGL14.EGL_RENDERABLE_TYPE, - EGL14.EGL_OPENGL_ES2_BIT, - EGL14.EGL_SURFACE_TYPE, - EGL14.EGL_PBUFFER_BIT, - EGL14.EGL_NONE - ) - - val PBUFFER_SPEC = intArrayOf(EGL14.EGL_WIDTH, 1, EGL14.EGL_HEIGHT, 1, EGL14.EGL_NONE) - - val CONTEXT_SPEC = intArrayOf(EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE) - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpMatrixTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpMatrixTest.kt deleted file mode 100644 index 2ec13493..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpMatrixTest.kt +++ /dev/null @@ -1,348 +0,0 @@ -package app.nursemate.core.vision - -import ai.onnxruntime.OrtEnvironment -import android.graphics.Bitmap -import android.os.Build -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import app.nursemate.core.vision.imprint.ImprintDecoding -import app.nursemate.core.vision.imprint.ImprintPreprocess -import app.nursemate.core.vision.imprint.ImprintReader -import app.nursemate.core.vision.mark.MarkPreprocess -import app.nursemate.core.vision.mark.MarkReader -import java.io.File -import java.nio.ByteBuffer -import kotlin.math.abs -import org.json.JSONObject -import org.junit.After -import org.junit.Assert.assertEquals -import org.junit.Assert.assertTrue -import org.junit.Assume.assumeTrue -import org.junit.Before -import org.junit.Test -import org.junit.runner.RunWith -import org.opencv.android.OpenCVLoader -import org.opencv.core.CvType -import org.opencv.core.Mat - -/** - * **EP × 모델을 이 기기에서 전부 재고, 답이 맞는지까지 본다** — NM-577. - * - * ## 왜 - * 지금의 EP 비교표(`OrtBackend` KDoc)가 **Galaxy S24(Exynos 2400 · Xclipse 940) 한 대**에서 - * 나왔다. 그 한 대로 「NNAPI 실패」·「XNNPACK 더 느림」을 정하고 WebGPU 를 골랐는데, - * 2026-10-13 Adreno 에서 각인이 깨지면서 그 표의 적용 범위가 드러났다. 퀄컴 NNAPI 는 - * Hexagon NPU 로 내려가는 **다른 구현**이고, 재 본 적이 없다. - * - * ## 메서드를 EP × 모델로 가른다 - * 한 메서드에서 순회하면 하나가 세그폴트할 때 나머지를 못 본다. Test Lab `--use-orchestrator` - * 가 **메서드마다 프로세스를 새로 띄우므로** 갈라 두면 죽어도 끝까지 돈다 — 기기당 1실행으로 - * 전수 조사가 된다(실기기 할당량이 하루 5회뿐이다). - * - * ## ⚠️ 속도만 보지 않는다 - * 빠른 EP 를 찾는 것이 아니라 **빠르면서 답이 맞는** EP 를 찾는 것이다. NNAPI 는 fp16 으로 - * 떨어뜨리는 경우가 많고, 각인은 0.949 채택 임계가 있어 확률이 조금만 흔들려도 **글자가 - * 뒤집힌다.** 그래서 기준값 대조를 그대로 건다. - * - * 결과는 logcat `NM-EPMATRIX` 한 줄씩이다. - */ -@RunWith(AndroidJUnit4::class) -class EpMatrixTest { - - private lateinit var imprintModel: File - private lateinit var markModel: File - private lateinit var gray: Mat - private lateinit var fixtures: JSONObject - private lateinit var answers: JSONObject - - @Before - fun setUp() { - check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } - val context = InstrumentationRegistry.getInstrumentation().context - val dir = context.getExternalFilesDir(null) - - imprintModel = File(dir, ImprintReader.MODEL_FILE_NAME) - markModel = File(dir, MarkReader.MODEL_FILE_NAME) - assumeTrue("모델이 없어 건너뛴다", imprintModel.isFile && markModel.isFile) - - val bytes = context.assets.open("imprint/input_gray.bin").use { it.readBytes() } - gray = Mat(ImprintPreprocess.SIDE, ImprintPreprocess.SIDE, CvType.CV_8UC1) - .also { it.put(0, 0, bytes) } - - fixtures = JSONObject(context.assets.open("mark/fixtures.json").use { it.readBytes().decodeToString() }) - answers = JSONObject(context.assets.open("mark/answers.json").use { it.readBytes().decodeToString() }) - - // EPContext 캐시는 **앱이 쓸 수 있는 곳**이어야 한다. 모델이 놓인 외부 저장소는 - // adb 로 밀어 넣은 자리라 쓰기 권한이 없을 수 있다. - OrtBackend.contextCacheDir = InstrumentationRegistry.getInstrumentation().targetContext.cacheDir - // HTP 가 DSP skel 을 찾는 자리. 여기를 안 주면 EP 가 노드를 하나도 안 가져가고 - // **CPU 로 돌면서 성공한다** — [OrtBackend.qnnNativeLibDir] KDoc 참조. - OrtBackend.qnnNativeLibDir = - File(InstrumentationRegistry.getInstrumentation().targetContext.applicationInfo.nativeLibraryDir) - - val eps = runCatching { OrtEnvironment.getAvailableProviders().joinToString() }.getOrElse { "조회 실패" } - Log.i(TAG, "기기 ${Build.MODEL} · SoC ${soc()} · 가용 EP $eps") - } - - @After - fun tearDown() { - OrtBackend.forcedEp = null - OrtBackend.contextCacheDir = null - OrtBackend.qnnNativeLibDir = null - if (::gray.isInitialized) gray.release() - } - - // ── 각인 ───────────────────────────────────────────────────────── - - @Test fun `각인_CPU`() = imprint(Ep.CPU) - - @Test fun `각인_WEBGPU`() = imprint(Ep.WEBGPU) - - @Test fun `각인_NNAPI`() = imprint(Ep.NNAPI) - - @Test fun `각인_XNNPACK`() = imprint(Ep.XNNPACK) - - @Test fun `각인_NNAPI_NO_CPU`() = imprint(Ep.NNAPI_NO_CPU) - - @Test fun `각인_NNAPI_SPLIT`() = imprint(Ep.NNAPI_SPLIT) - - @Test fun `각인_XNNPACK_TUNED`() = imprint(Ep.XNNPACK_TUNED) - - @Test fun `각인_QNN`() = imprint(Ep.QNN) - - @Test fun `각인_QNN_FP32`() = imprint(Ep.QNN_FP32) - - @Test fun `각인_QNN_FP16`() = imprint(Ep.QNN_FP16) - - @Test fun `각인_QNN_RNN_CPU`() = imprint(Ep.QNN_RNN_CPU) - - @Test fun `각인_QNN_STN_CPU`() = imprint(Ep.QNN_STN_CPU) - - /* - * **TPS 격자만 fp32 로 남긴 변형** — 각인이 QNN 에서 채택 임계를 못 넘는 것을 겨눈다. - * - * 기준 모델은 QNN 에서 pair 를 YS 로 맞게 고르고도 점수가 **0.9436** 으로 - * [ImprintDecoding.ADOPT_THRESHOLD] 0.949 에 **0.0054 모자랐다**. AI Hub 가 같은 모델을 - * 87.3% 일치로 쟀고, 이 변형은 **99.6%** 였다 — 격자가 저정밀도에 민감했다는 뜻이다. - * - * 변형은 드롭인이다: 입출력 이름·dtype 과 심볼릭 `batch` 가 같고 가중치만 fp16 47개 + - * **fp32 2개**(격자)다. 그래서 [ImprintReader] 를 그대로 쓴다. - * - * CPU 도 같이 잰다 — 변형 자체가 기준보다 점수가 낮을 수도 있어서, **그 기기의 CPU 값**이 - * 있어야 「QNN 때문에 떨어진 것」과 「변형 때문에 떨어진 것」을 가린다. - */ - @Test fun `각인변형_CPU`() = imprintVariant(Ep.CPU) - - @Test fun `각인변형_QNN`() = imprintVariant(Ep.QNN) - - private fun imprintVariant(ep: Ep) = - imprint(ep, model = File(imprintModel.parentFile, VARIANT_TPS32), label = "각인변형", expectedScore = null) - - @Test fun `각인_QNN_CACHED`() = imprint(Ep.QNN_CACHED) - - // ── 마크 ───────────────────────────────────────────────────────── - - @Test fun `마크_CPU`() = mark(Ep.CPU) - - @Test fun `마크_WEBGPU`() = mark(Ep.WEBGPU) - - @Test fun `마크_NNAPI`() = mark(Ep.NNAPI) - - @Test fun `마크_XNNPACK`() = mark(Ep.XNNPACK) - - @Test fun `마크_NNAPI_NO_CPU`() = mark(Ep.NNAPI_NO_CPU) - - @Test fun `마크_NNAPI_SPLIT`() = mark(Ep.NNAPI_SPLIT) - - @Test fun `마크_XNNPACK_TUNED`() = mark(Ep.XNNPACK_TUNED) - - @Test fun `마크_QNN`() = mark(Ep.QNN) - - @Test fun `마크_QNN_FP32`() = mark(Ep.QNN_FP32) - - @Test fun `마크_QNN_FP16`() = mark(Ep.QNN_FP16) - - @Test fun `마크_QNN_RNN_CPU`() = mark(Ep.QNN_RNN_CPU) - - @Test fun `마크_QNN_CACHED`() = mark(Ep.QNN_CACHED) - - // ── 거들기 ─────────────────────────────────────────────────────── - - /** - * 기준값은 `ImprintReaderParityTest` 와 같다 — `sample_crop` → `YS`, 0.969883. - * - * 언제나 **best_pair 가 YS** 인지(읽기)와 **답이 점수와 맞는지**(점수가 채택 임계 이상이면 `YS`, - * 아래면 `null`)를 본다. 그 위에 EP 에 따라 하나를 더 본다. - * - * | EP | 더 보는 것 | - * |---|---| - * | QNN 이 아닌 EP · 기준 모델 | 점수가 [expectedScore] ± 1e-4 — 즉 채택돼 `YS` | - * | [QNN_MEASURED] · 기준 모델 | 점수가 [QNN_IMPRINT_FLOOR] 이상 — 무너지는 쪽만 잡는다 | - * | 그 밖(QNN fp16 · 변형 모델) | 없음 — 실측한 적이 없어 기댈 값이 없다 | - * - * ## 왜 QNN 은 채택을 단정하지 않나 - * HTP 는 이 한 장을 0.944 로 읽어 임계 0.949 아래로 떨어뜨린다 — V69 0.9441 · V73 0.9436 · - * V75 0.9438 로 세대와 무관하다. 그런데 감사셋 331면 전수에서는 CPU 와 차이가 없었다 - * ([OrtBackend] KDoc 「QNN 도 같은 331면으로 쟀다」). 이 한 장이 하필 임계 바로 위라 뒤집힌 - * 것이다. 채택을 단정하면 QNN 측정마다 빨갛게 떠서 진짜 회귀를 가린다. 하한만 두므로 `cpu(/stn/)` - * 같은 개선으로 채택되면 그대로 통과한다. - * - * @param model 돌릴 각인 모델. 기본은 운영과 같은 것이고, 변형을 댈 때만 바꾼다. - * @param expectedScore 기준 모델의 기록값. 변형은 수치가 달라도 되므로 `null` 로 끈다. - */ - private fun imprint(ep: Ep, model: File = imprintModel, label: String = "각인", expectedScore: Float? = 0.969883f) { - assumeTrue("${model.name} 이 없어 건너뛴다", model.isFile && model.length() > 0) - OrtBackend.forcedEp = ep - warmCache(ep) { ImprintReader(model).close() } - val opened = System.nanoTime() - ImprintReader(model).use { reader -> - val ready = System.nanoTime() - // ⚠️ **첫 실행은 버린다.** WebGPU 가 여기서 셰이더를 컴파일한다 — 포함해 재면 - // 몇 배 느리게 나온다(S24 각인: 기록 1796ms 대 예열 없는 측정 5812ms). - reader.readGray(gray) - val result = reader.readGray(gray) - // ⚠️ **단정보다 먼저 찍는다.** 읽은 답까지 같이 — 틀렸을 때 「null」만 남으면 - // 얼마나 틀렸는지 모른다. QNN 이 각인을 잃은 것을 이 줄 없이 쫓느라 한 번 더 돌렸다. - report( - label, - ep, - openMs = ms(opened, ready), - runMs = result.timings.totalMs, - answer = "${result.imprint} · pair ${result.pair} · 점수 ${"%.4f".format(result.score)}" - ) - - // best_pair 를 먼저 본다 — **읽기가 맞았는지**와 **채택이 됐는지**는 다른 문제다. - // QNN 이 pair YS 를 맞게 고르고도 점수 0.9436 으로 채택에서 떨어진 자리다. - assertEquals("[$ep] $label best_pair", "YS", result.pair) - val adopted = result.score >= ImprintDecoding.ADOPT_THRESHOLD - assertEquals("[$ep] $label 답이 점수와 맞는다", if (adopted) "YS" else null, result.imprint) - when { - expectedScore == null -> Unit - - ep in QNN_EPS -> if (ep in QNN_MEASURED) { - assertTrue( - "[$ep] $label 점수 ${result.score} 가 HTP 하한 $QNN_IMPRINT_FLOOR 아래로 무너졌다", - result.score >= QNN_IMPRINT_FLOOR - ) - } - - else -> assertEquals("[$ep] $label 점수", expectedScore, result.score, 1e-4f) - } - } - } - - /** - * 기준값은 `MarkReaderParityTest` 와 같다 — 종 일치, 유무 ±5e-3. */ - private fun mark(ep: Ep) { - OrtBackend.forcedEp = ep - warmCache(ep) { MarkReader(markModel).close() } - val opened = System.nanoTime() - MarkReader(markModel).use { reader -> - val ready = System.nanoTime() - // 각인과 같은 이유로 예열한다. 마크는 케이스가 여섯이라 영향이 작지만 기준을 맞춘다. - MarkPreprocess.toGrayOnWhite( - loadCrop(WARMUP_CASE, fixtures.getJSONObject("cases").getJSONObject(WARMUP_CASE)) - ) - .also { - reader.readGray(it) - it.release() - } - var total = 0L - val cases = fixtures.getJSONObject("cases") - // 케이스를 다 돌고 **보고한 뒤** 단정한다 — 한 케이스가 틀리면 나머지 시간도 같이 - // 날아가던 자리다. - val wrong = mutableListOf() - val seen = mutableListOf() - for (name in cases.keys()) { - val case = cases.getJSONObject(name) - val crop = MarkPreprocess.toGrayOnWhite(loadCrop(name, case)) - val actual = reader.readGray(crop).also { crop.release() } - total += actual.timings.totalMs - seen += "$name=${actual.species}/${"%.3f".format(actual.presence)}" - - val expected = answers.getJSONObject(name) - if (expected.getInt("species") != actual.species) { - wrong += "$name 종 기준 ${expected.getInt("species")} · 실제 ${actual.species}" - } - if (abs(expected.getDouble("presence").toFloat() - actual.presence) >= PRESENCE_TOLERANCE) { - wrong += "$name 유무 기준 ${expected.getDouble("presence")} · 실제 ${actual.presence}" - } - } - report("마크", ep, openMs = ms(opened, ready), runMs = total, answer = seen.joinToString(" ")) - assertTrue("[$ep] ${wrong.joinToString(" | ")}", wrong.isEmpty()) - } - } - - private fun loadCrop(name: String, case: JSONObject): Bitmap { - val bytes = InstrumentationRegistry.getInstrumentation().context.assets - .open("mark/$name.rgba").use { it.readBytes() } - return Bitmap.createBitmap(case.getInt("width"), case.getInt("height"), Bitmap.Config.ARGB_8888) - .apply { - setPremultiplied(false) - copyPixelsFromBuffer(ByteBuffer.wrap(bytes)) - } - } - - /** 세션 생성과 추론을 **갈라서** 적는다. 모델을 여는 값은 한 번만 드는데 섞으면 알약마다 든다고 잘못 읽힌다. - * - * [Ep.QNN_CACHED] 일 때만 **세션을 한 번 버리고 연다** — 그래야 캐시 적중을 재는 것이 된다. - * - * `ep.context_enable` 은 첫 세션에서 컴파일 결과를 쓴다. 한 번만 열면 재는 값이 **쓰기 - * 경로**라 컴파일 시간이 그대로 들어간다 — 2026-10-13 Adreno 740 에서 각인 세션 생성이 - * **84초**였다. 알고 싶은 것은 그다음, 즉 「파일이 있을 때 얼마나 걸리나」다. - * - * 버리는 쪽 시간도 남긴다 — 운영에서 **첫 실행 한 번은 그 값을 치러야** 하므로 그것도 수치다. - */ - private fun warmCache(ep: Ep, open: () -> Unit) { - if (ep != Ep.QNN_CACHED) return - val started = System.nanoTime() - open() - // 디렉터리를 그대로 찍는다 — ORT 가 쓴 **파일 이름이 기대와 다르면** 다음 열기가 - // 적중하지 않고, 그 차이를 이 줄 없이는 못 본다. - val made = OrtBackend.contextCacheDir?.listFiles()?.joinToString { "${it.name}(${it.length() / 1024}KB)" } - Log.i(TAG, "캐시 생성 | $ep | ${ms(started, System.nanoTime())}ms | 생긴 파일 $made | ${Build.MODEL} ${soc()}") - } - - private fun report(model: String, ep: Ep, openMs: Long, runMs: Long, answer: String) = - Log.i(TAG, "$model | $ep | 세션생성 ${openMs}ms | 추론 ${runMs}ms | 답 $answer | ${Build.MODEL} ${soc()}") - - private fun ms(from: Long, to: Long) = (to - from) / 1_000_000 - - private fun soc(): String = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { - "${Build.SOC_MANUFACTURER} ${Build.SOC_MODEL}" - } else { - Build.HARDWARE - } - - private companion object { - const val TAG = "NM-EPMATRIX" - - /** TPS 격자만 fp32 로 남긴 각인 변형. 저장소에 없다 — 기기로 밀어 넣는다. */ - const val VARIANT_TPS32 = "imprint_fp16_tps32.onnx" - - /** 예열에 쓸 케이스. 어느 것이든 되지만 고정해야 측정이 재현된다. */ - const val WARMUP_CASE = "mark_set-084_p1_back" - - /** `MarkReaderParityTest` 와 같은 값. 실측 최대 1.29e-3 에 4배 여유다. */ - const val PRESENCE_TOLERANCE = 5e-3f - - /** QNN(HTP) 계열 EP. [OrtBackend] 가 `applyQnnEp` 로 보내는 것들이다. */ - val QNN_EPS = setOf(Ep.QNN, Ep.QNN_FP32, Ep.QNN_FP16, Ep.QNN_STN_CPU, Ep.QNN_RNN_CPU, Ep.QNN_CACHED) - - /** - * 이 고정물 점수를 실측한 QNN 설정 — 모두 `enable_htp_fp16_precision=0` 이다([Ep.QNN] 기본이 - * 그렇게 고정돼 있다). [Ep.QNN_FP16] 은 잰 적이 없어 뺐다 — 기기 밖 재현은 0.9202 였다. - * [Ep.QNN_STN_CPU] 는 지금 [Ep.QNN] 과 같은 그래프다(층 배정이 플러그인 EP 에 안 먹는다). - */ - val QNN_MEASURED = setOf(Ep.QNN, Ep.QNN_FP32, Ep.QNN_STN_CPU, Ep.QNN_RNN_CPU, Ep.QNN_CACHED) - - /** - * QNN 실측 점수의 하한. V69 0.9441 · V73 0.9436 · V75 0.9438(2026-10-13~15) 아래로 0.005. - * - * **무너지는 것만 잡는다** — 서브그래프가 통째로 CPU 로 빠지거나 SDK 가 GridSample 을 크게 - * 바꾸는 정도다. 0.003 쯤 움직이는 작은 변화는 못 잡는다. 위로는 막지 않는다(개선이면 채택된다). - */ - const val QNN_IMPRINT_FLOOR = 0.9388f - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpOverride.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpOverride.kt deleted file mode 100644 index ee84c478..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/EpOverride.kt +++ /dev/null @@ -1,42 +0,0 @@ -package app.nursemate.core.vision - -import androidx.test.platform.app.InstrumentationRegistry - -/** - * 계측 인자로 실행 공급자를 고른다 — 같은 기기에서 **CPU 와 WebGPU 의 답을 맞대 보려고** 둔다. - * - * ``` - * ./gradlew :core:vision:connectedDebugAndroidTest # 기본 — 기기가 되면 WebGPU - * ./gradlew :core:vision:connectedDebugAndroidTest \ - * -Pandroid.testInstrumentationRunnerArguments.nm_webgpu=false # CPU 강제 - * ``` - * - * Firebase Test Lab 은 `--environment-variables nm_webgpu=false` 가 같은 자리로 들어간다. - * - * ## 왜 필요했나 - * WebGPU 를 쓰기로 한 근거(NM-396 · NM-528)가 전부 **Galaxy S24 한 대**에서 나왔다. 그 기기의 - * GPU 는 Xclipse 940(AMD RDNA 계열)이라 Adreno · Mali 와 드라이버가 통째로 다르다. 2026-10-13 - * 에 Adreno 740(SM-S916N)에서 `vulkan.adreno.so` 세그폴트가 올라오면서, 안 죽는 기기에서도 - * **답이 같은지**를 확인한 적이 없다는 것이 드러났다. - * - * 한 기기에서 두 번 돌려 답이 갈리면 그 GPU 의 WebGPU 는 믿을 수 없다. 세그폴트와 달리 이쪽은 - * 조용해서, 보려고 하지 않으면 보이지 않는다. - */ -internal object EpOverride { - - /** 계측 인자 이름. Test Lab 의 `--environment-variables` 키와 같아야 한다. */ - private const val ARG = "nm_webgpu" - - /** - * 인자를 읽어 [OrtBackend] 에 반영한다. 테스트의 `@Before` 에서 **세션을 만들기 전에** 부른다. - * - * 인자가 없으면 운영과 같은 기본값(켜짐)이다. - * - * @return 로그·실패 메시지에 붙일 이름 - */ - fun apply(): String { - val requested = InstrumentationRegistry.getArguments().getString(ARG)?.toBooleanStrictOrNull() ?: true - OrtBackend.webGpuEnabled = requested - return if (requested) "WebGPU(가능하면)" else "CPU 강제" - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/GpuOverride.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/GpuOverride.kt new file mode 100644 index 00000000..519370dd --- /dev/null +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/GpuOverride.kt @@ -0,0 +1,39 @@ +package app.nursemate.core.vision + +import androidx.test.platform.app.InstrumentationRegistry + +/** + * 계측 인자로 GPU 를 끈다 — 같은 기기에서 **CPU 와 GPU 의 답을 맞대 보려고** 둔다. + * + * ``` + * ./gradlew :core:vision:connectedDebugAndroidTest # 기본 — 운영과 같이 GPU(안 되면 CPU) + * ./gradlew :core:vision:connectedDebugAndroidTest \ + * -Pandroid.testInstrumentationRunnerArguments.nm_gpu=false # CPU 강제 + * ``` + * + * Firebase Test Lab 은 `--environment-variables nm_gpu=false` 가 같은 자리로 들어간다. + * + * ## 왜 필요한가 + * GPU 는 기기마다 드라이버가 통째로 다르다. 세그폴트와 달리 **조용히 다른 답**은 보려고 하지 않으면 + * 보이지 않는다 — LiteRT 에서도 8 Elite FP16 이 그랬다(ML 실측, 실행마다 다르게 틀림). + */ +internal object GpuOverride { + + /** 계측 인자 이름. Test Lab 의 `--environment-variables` 키와 같아야 한다. */ + private const val ARG = "nm_gpu" + + /** GPU 를 허용했는가. 기준값 허용 오차를 고를 때 쓴다 — 계약상 FP16 으로 도는 조각이 있다. */ + val gpu: Boolean + get() = InstrumentationRegistry.getArguments().getString(ARG)?.toBooleanStrictOrNull() ?: true + + /** + * 인자를 읽어 [VisionBackend] 에 반영한다. 테스트의 `@Before` 에서 **모델을 열기 전에** 부른다. + * + * @return 로그 · 실패 메시지에 붙일 이름 + */ + fun apply(): String { + val gpu = gpu + VisionBackend.allowGpu = { gpu } + return if (gpu) "GPU(가능하면)" else "CPU 강제" + } +} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderBenchmark.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderBenchmark.kt index ab3a39df..72d94080 100644 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderBenchmark.kt +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderBenchmark.kt @@ -19,11 +19,15 @@ import org.opencv.core.Mat * * | 구간 | 성격 | * |---|---| - * | 세션 생성 | 21MB 모델을 여는 비용. **한 번만** 든다 | + * | 모델 열기 | 조각 다섯을 여는 비용(GPU 셰이더 준비 포함). **한 번만** 든다 | * | 전처리 | TTA 144장. 지배적이면 장수를 줄이는 것이 답 | * | 추론 | 144장 한 배치. 지배적이면 스레드·배치를 손봐야 한다 | * - * ## 실측 (Galaxy S24 · SM-S921N · Exynos 2400 · 4스레드 · TTA 144장) + * ## LiteRT G5 (NM-628) + * 추론은 조각 다섯이 묶음 6개를 파이프라인으로 흘린다. ML 벤치 실측은 면당 0.4~1.2초(Exynos 2600 ~ + * SD 8 Gen 1, `_handoff/litert-ondevice-migration.md`). 이 테스트로 **앱 코드가 그 수준인지** 본다. + * + * ## 옛 실측 — ORT (Galaxy S24 · SM-S921N · Exynos 2400 · 4스레드 · TTA 144장) * * NM-534 로 [ImprintReader] 가 WebGPU + `cpu(/rnn/)` 로 열린다. 그 전후를 같이 적는다. * ``` @@ -45,14 +49,11 @@ import org.opencv.core.Mat * 깎을 여지가 없고, `rnn` 은 1796 ms 중 135 ms 라 손볼 대상이 아니다. 장수는 iOS·서버와 답을 * 맞추는 문제라 144 로 두고 서버 연동 때 다시 본다(NM-528 결정 1). * - * ⚠️ **에뮬레이터 값은 믿지 말 것.** 에뮬레이터는 데스크톱 CPU 위에서 돌아 실기기보다 - * 빠르다. 위 숫자가 실기기 값이고, **저사양 기기는 이보다 느리다** — DoD 가 요구하는 그 - * 값은 아직 없다(armeabi-v7a 기기에서 세션 생성이 `SIGBUS` 로 죽는 건이 먼저다. - * [OrtSessionOpenTest] 참조). + * ⚠️ **에뮬레이터 값은 믿지 말 것.** 에뮬레이터는 데스크톱 CPU 위에서 돌아 실기기와 다르고 GPU(OpenCL)가 없다. * * ## 모델이 없으면 건너뛴다 * ``` - * adb push reader_ep60_s1.onnx /sdcard/Android/data/app.nursemate.core.vision.test/files/ + * adb push app/src/main/assets/p?_*.tflite /sdcard/Android/data/app.nursemate.core.vision.test/files/ * ``` */ @RunWith(AndroidJUnit4::class) @@ -63,15 +64,15 @@ class ImprintReaderBenchmark { check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } val context = InstrumentationRegistry.getInstrumentation().context - val model = File(context.getExternalFilesDir(null), ImprintReader.MODEL_FILE_NAME) - assumeTrue("모델이 없어 건너뛴다", model.isFile && model.length() > 0) + val parts = ImprintReader.PART_FILE_NAMES.map { File(context.getExternalFilesDir(null), it) } + assumeTrue("조각이 없어 건너뛴다", parts.all { it.isFile && it.length() > 0 }) val bytes = context.assets.open("imprint/input_gray.bin").use { it.readBytes() } val gray = Mat(ImprintPreprocess.SIDE, ImprintPreprocess.SIDE, CvType.CV_8UC1) .also { it.put(0, 0, bytes) } val openStart = System.nanoTime() - val reader = ImprintReader(model) + val reader = ImprintReader(parts) val openMs = (System.nanoTime() - openStart) / 1_000_000 try { @@ -84,7 +85,7 @@ class ImprintReaderBenchmark { val dec = runs.map { it.decodeMs } val tot = runs.map { it.totalMs } - Log.i(TAG, "세션 생성 ${openMs}ms (한 번만)") + Log.i(TAG, "모델 열기 ${openMs}ms (한 번만)") Log.i(TAG, "전처리 중앙값 ${pre.median()}ms 최소 ${pre.min()} 최대 ${pre.max()}") Log.i(TAG, "추론 중앙값 ${inf.median()}ms 최소 ${inf.min()} 최대 ${inf.max()}") Log.i(TAG, "디코딩 중앙값 ${dec.median()}ms 최소 ${dec.min()} 최대 ${dec.max()}") @@ -95,45 +96,6 @@ class ImprintReaderBenchmark { } } - /** - * 스레드 수를 쓸어 본다. - * - * Mac(ORT CPU)에서 1→2→4→8 이 3212 → 1757 → 963 → 648ms 로 **거의 선형**이라, 기기에서도 - * 스레드를 늘리면 줄어들 것으로 봤다. **실기기는 달랐다.** - * - * ``` - * Galaxy S24 추론 중앙값 1스레드 13345 · 2스레드 6765 · 4스레드 4124 · 6스레드 6939 · 8스레드 8059 ms - * ``` - * 4에서 최소이고 6·8 에서 **되레 느려진다.** big.LITTLE 이라 스레드를 늘리면 느린 코어가 - * 섞여 배리어를 끌고, Mac 의 동질 코어에서 본 선형은 그대로 옮겨오지 않는다. - * - * ⚠️ 기본 4 는 원래 **검출 모델 기준**이었는데(`PillDetector.DEFAULT_THREADS` — seg 도 6·8 에서 - * 느려졌다), 각인은 CRNN+CTC 로 모양이 다르므로 물려받을 근거가 없어 따로 쟀다. **같은 4가 답이다.** - */ - @Test - fun `스레드_수를_쓸어_본다`() { - check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } - val context = InstrumentationRegistry.getInstrumentation().context - val model = File(context.getExternalFilesDir(null), ImprintReader.MODEL_FILE_NAME) - assumeTrue("모델이 없어 건너뛴다", model.isFile && model.length() > 0) - - val bytes = context.assets.open("imprint/input_gray.bin").use { it.readBytes() } - val gray = Mat(ImprintPreprocess.SIDE, ImprintPreprocess.SIDE, CvType.CV_8UC1) - .also { it.put(0, 0, bytes) } - - Log.i(TAG, "코어 ${Runtime.getRuntime().availableProcessors()}개") - for (threads in intArrayOf(1, 2, 4, 6, 8)) { - ImprintReader(model, threads).use { reader -> - reader.readGray(gray) - val runs = (1..SWEEP_ROUNDS).map { reader.readGray(gray).inferenceMsOf() } - Log.i(TAG, "${threads}스레드 추론 중앙값 ${runs.median()}ms 최소 ${runs.min()} 최대 ${runs.max()}") - } - } - gray.release() - } - - private fun ImprintReader.Result.inferenceMsOf() = timings.inferenceMs - private fun List.median(): Long = sorted().let { if (it.size % 2 == 1) it[it.size / 2] else (it[it.size / 2 - 1] + it[it.size / 2]) / 2 } @@ -141,6 +103,5 @@ class ImprintReaderBenchmark { private companion object { const val TAG = "NM485" const val ROUNDS = 7 - const val SWEEP_ROUNDS = 5 } } diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderParityTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderParityTest.kt index bbd4abef..50cdc218 100644 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderParityTest.kt +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintReaderParityTest.kt @@ -2,7 +2,7 @@ package app.nursemate.core.vision.imprint import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry -import app.nursemate.core.vision.EpOverride +import app.nursemate.core.vision.GpuOverride import java.io.File import org.junit.Assert.assertEquals import org.junit.Assume.assumeTrue @@ -19,9 +19,9 @@ import org.opencv.core.Mat * 모델을 태워 **같은 답이 나오는지**까지 본다. * * ## 모델을 저장소에 넣지 않는다 - * 21MB 다. `*.onnx` 는 `.gitignore` 대상이기도 하다. 기기에 밀어 넣고 읽는다: + * 조각 다섯(p1~p5, 합 23MB)은 `.gitignore` 대상이다. 기기에 밀어 넣고 읽는다: * ``` - * adb push reader_ep60_s1.onnx /sdcard/Android/data/app.nursemate.core.vision.test/files/ + * adb push app/src/main/assets/p?_*.tflite /sdcard/Android/data/app.nursemate.core.vision.test/files/ * ``` * * ⚠️ **모델이 없으면 건너뛴다 — 통과가 아니다.** `assumeTrue` 는 리포트에 skipped 로 남는다. @@ -29,7 +29,7 @@ import org.opencv.core.Mat * * ## 기준값 * `sample_crop.png` → `YS`, best_pair 점수 0.969883, 회전 90°, 배율 1.0. - * `INFO.md` 의 「결과 `YS` 0.970」과 같다. + * `INFO.md` 의 「결과 `YS` 0.970」과 같다. LiteRT G5(NM-628)도 이 값에 맞아야 한다 — 허용 오차는 아래. */ @RunWith(AndroidJUnit4::class) class ImprintReaderParityTest { @@ -37,26 +37,38 @@ class ImprintReaderParityTest { @Test fun `sample_crop_의_답이_기준과_같다`() { check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } - // 세션을 만들기 전이어야 한다 — 만든 뒤에 바꾸면 이미 열린 EP 로 돈다. - val path = EpOverride.apply() + // 모델을 열기 전이어야 한다 — 연 뒤에 바꾸면 이미 열린 가속기로 돈다. + val path = GpuOverride.apply() val context = InstrumentationRegistry.getInstrumentation().context - val model = File(context.getExternalFilesDir(null), ImprintReader.MODEL_FILE_NAME) + val parts = ImprintReader.PART_FILE_NAMES.map { File(context.getExternalFilesDir(null), it) } assumeTrue( - "모델이 없어 건너뛴다 — adb push ${ImprintReader.MODEL_FILE_NAME} " + - "${context.getExternalFilesDir(null)}/", - model.isFile && model.length() > 0 + "조각이 없어 건너뛴다 — adb push p?_*.tflite ${context.getExternalFilesDir(null)}/", + parts.all { it.isFile && it.length() > 0 } ) val bytes = context.assets.open("imprint/input_gray.bin").use { it.readBytes() } val gray = Mat(ImprintPreprocess.SIDE, ImprintPreprocess.SIDE, CvType.CV_8UC1) .also { it.put(0, 0, bytes) } - val result = ImprintReader(model).use { it.readGray(gray) } + val result = ImprintReader(parts).use { it.readGray(gray) } gray.release() assertEquals("[$path] 확신 글자", "YS", result.imprint) assertEquals("[$path] best_pair", "YS", result.pair) - assertEquals("[$path] best_pair 점수", 0.969883f, result.score, 1e-4f) + val tolerance = if (GpuOverride.gpu) GPU_TOLERANCE else CPU_TOLERANCE + assertEquals("[$path] best_pair 점수", 0.969883f, result.score, tolerance) + } + + private companion object { + /** CPU 는 fp32 라 기준 구현(ONNX CPU)과 소수 넷째 자리까지 같다 — S24 실측 통과. */ + const val CPU_TOLERANCE = 1e-4f + + /** + * GPU 는 계약상 p1 · p4 가 **FP16** 이라 점수가 조금 흔들린다 — S24(Exynos 2400) 실측 0.9723(+0.0024). + * 답과 pair 는 같다. ML 이 같은 계약으로 공식 세트 550면 응답 · 정답 · 오답이 fp32 와 같음을 확인했으므로 + * 점수 한 장의 흔들림은 이 정도면 정상이다. 0.005 를 넘으면 정밀도 계약이 깨졌는지 본다. + */ + const val GPU_TOLERANCE = 5e-3f } } diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintVariantTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintVariantTest.kt deleted file mode 100644 index 57836dd7..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/ImprintVariantTest.kt +++ /dev/null @@ -1,173 +0,0 @@ -package app.nursemate.core.vision.imprint - -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import app.nursemate.core.vision.OrtBackend -import java.io.File -import org.junit.Assert.assertEquals -import org.junit.Assume.assumeTrue -import org.junit.Before -import org.junit.Test -import org.junit.runner.RunWith -import org.opencv.android.OpenCVLoader -import org.opencv.core.CvType -import org.opencv.core.Mat - -/** - * **각인이 Adreno 에서 왜 실패하는지**를 가린다 — NM-577. - * - * 실패는 계산이 틀린 것이 아니라 ORT 내부에서 없는 키를 찾는 것이다: - * - * ``` - * Non-zero status code returned while running Conv node. - * Name:'/cnn/cnn.1/cnn.1.0/Conv_token_37' - * Status Message: absl::container_internal::raw_hash_map<>::at - * ``` - * - * `absl::flat_hash_map::at()` 은 **키가 없을 때** 터진다. 그리고 `_token_37` 은 모델에 없는 - * 이름이다(`strings` 로 확인) — ORT 가 **그래프를 쪼개면서** 붙인 것이다. - * - * ## 각인만 다른 점 셋 - * 마크는 같은 WebGPU 로 Adreno 740 · 750 양쪽에서 **답까지 정확히** 나온다. 각인만 깨지므로 - * 둘의 차이에 답이 있다. - * - * | | 각인 | 마크 | - * |---|---|---| - * | 그래프 분할 | **`cpu(/rnn/)`** | 없음 | - * | 배치 | **144** | 8 | - * | 입력 채널 | **1** (회색조) | 3 | - * - * ## 변형을 메서드로 가른다 - * 한 메서드 안에서 순회하면 하나가 세그폴트할 때 나머지를 못 본다. Test Lab 은 - * `--use-orchestrator` 로 **메서드마다 프로세스를 새로 띄우므로**, 갈라 두면 죽어도 나머지가 돈다. - * - * ⚠️ **답을 같이 본다.** 안 죽는 설정을 찾는 것이 목적이 아니라, **안 죽으면서 답이 맞는** - * 설정을 찾는 것이다. 각인은 0.949 채택 임계가 있어 확률이 조금만 흔들려도 글자가 뒤집힌다. - */ -@RunWith(AndroidJUnit4::class) -class ImprintVariantTest { - - private lateinit var model: File - private lateinit var gray: Mat - - @Before - fun setUp() { - check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } - val context = InstrumentationRegistry.getInstrumentation().context - model = File(context.getExternalFilesDir(null), ImprintReader.MODEL_FILE_NAME) - assumeTrue("모델이 없어 건너뛴다", model.isFile && model.length() > 0) - - val bytes = context.assets.open("imprint/input_gray.bin").use { it.readBytes() } - gray = Mat(ImprintPreprocess.SIDE, ImprintPreprocess.SIDE, CvType.CV_8UC1) - .also { it.put(0, 0, bytes) } - } - - /** 기준선. 여기서 틀리면 기기나 픽스처가 문제지 EP 문제가 아니다. */ - @Test - fun `A_CPU`() { - OrtBackend.webGpuEnabled = false - read("CPU") - } - - /** 지금 운영 설정. Adreno 740·750 에서 이것이 깨진다. */ - @Test - fun `B_WebGPU_현재설정`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · cpu(/rnn/)") - } - - /** - * 분할을 빼 본다 — `_token_` 이 분할의 표식이므로 제일 유력한 가설이다. - * - * 통과해도 **그대로 쓸 수는 없다**: 분할 없는 각인은 S24 에서 9943 ms 로 CPU(3472 ms)보다 - * 느리다. 원인을 좁히는 데 쓴다. - */ - @Test - fun `C_WebGPU_분할없이`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · 분할 없음", cpuNodes = null) - } - - /** - * WebGPU EP 는 기본이 NHWC 다. 채널이 1개뿐인 입력에서 레이아웃 관련 Conv 버그가 보고된 - * 적이 있고(`preferredLayout=NCHW` 로 피한 사례), 각인 입력이 정확히 1채널이다. - */ - @Test - fun `D_WebGPU_NCHW`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · NCHW", options = mapOf("preferredLayout" to "NCHW")) - } - - /** 둘 다 걸어 본다. 하나로 안 되면 조합이 답일 수 있다. */ - @Test - fun `E_WebGPU_NCHW_분할없이`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · NCHW · 분할 없음", cpuNodes = null, options = mapOf("preferredLayout" to "NCHW")) - } - - /** - * **배치를 쪼갠다** — 엑시노스 2600 에서 나온 빈 답을 겨눈다 (2026-10-14). - * - * `s5e9965` WebGPU 가 39회 중 3회 **답 null · 점수 0.0000** 을 냈다. 예외도 크래시도 로그도 - * 없다. 실패한 세 번은 전부 추론이 가장 느린 구간(3804·3884·3888 ms)이었는데, 같은 느린 - * 구간의 3412~3590 ms 는 통과했으므로 **느린 것 자체가 원인은 아니다.** - * - * 각인만 깨지고 마크·검출은 한 번도 안 깨진 것이 단서다. - * - * | | 검출 | 마크 | 각인 | - * |---|---|---|---| - * | 배치 | 1 | 8 | **144** | - * | 실패 | 0/6 | 0/39 | **3/39** | - * - * 144 는 `ROTATIONS(24) × ZOOMS(6)` TTA 다. 쪼개도 **후보 144개를 다 쓰므로 답이 같아야 - * 한다** — 그래서 다른 변형과 똑같이 0.969883 을 단정한다. 빈 답이 사라지면 배치가 원인이다. - * - * ⚠️ **이 테스트는 고쳐졌는지를 증명하지 않는다** — 한 번 읽고 끝이다. 실패가 확률적이라 - * (배치 144 에서 225회 중 30회) 한 번 통과는 아무것도 말하지 않는다. 여기서 보는 것은 - * **쪼개 돌린 뒤 이어 붙인 답이 같은가**뿐이다. 빈 답이 사라졌다는 근거는 반복 측정이다 — - * 배치 72 를 718회, 36 을 675회 돌려 실패 0 ([ImprintReader] 의 `batch` KDoc). - */ - @Test - fun `F_WebGPU_배치36`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · 배치 36", batch = 36) - } - - /** 36 과 144 사이. 실패율이 배치에 비례하는지 본다 — 가르는 선이 어디인지도 알고 싶다. */ - @Test - fun `G_WebGPU_배치72`() { - OrtBackend.webGpuEnabled = true - read("WebGPU · 배치 72", batch = 72) - } - - /** 쪼개기 자체가 답을 바꾸지 않는다는 대조 — 여기서 틀리면 병합 코드가 틀린 것이다. */ - @Test - fun `H_CPU_배치36`() { - OrtBackend.webGpuEnabled = false - read("CPU · 배치 36", batch = 36) - } - - private fun read( - label: String, - cpuNodes: String? = ImprintReader.RNN_ON_CPU, - options: Map = emptyMap(), - // 운영값으로 잰다. 144 는 엑시노스 2600 WebGPU 에서 빈 답을 내는 설정이다(NM-602). - batch: Int = ImprintReader.DEFAULT_BATCH - ) { - val started = System.nanoTime() - val result = ImprintReader(model, cpuNodes = cpuNodes, webGpuOptions = options, batch = batch) - .use { it.readGray(gray) } - val elapsed = (System.nanoTime() - started) / 1_000_000 - - Log.i(TAG, "[$label] 각인=${result.imprint} pair=${result.pair} 점수=${result.score} ${elapsed}ms") - - assertEquals("[$label] 확신 글자", "YS", result.imprint) - assertEquals("[$label] best_pair", "YS", result.pair) - assertEquals("[$label] best_pair 점수", 0.969883f, result.score, 1e-4f) - } - - private companion object { - const val TAG = "NM-VARIANT" - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/OrtSessionOpenTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/OrtSessionOpenTest.kt deleted file mode 100644 index e0d89d69..00000000 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/imprint/OrtSessionOpenTest.kt +++ /dev/null @@ -1,54 +0,0 @@ -package app.nursemate.core.vision.imprint - -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.OrtSession -import android.os.Build -import android.util.Log -import androidx.test.ext.junit.runners.AndroidJUnit4 -import androidx.test.platform.app.InstrumentationRegistry -import java.io.File -import org.junit.Assume.assumeTrue -import org.junit.Test -import org.junit.runner.RunWith - -/** - * ONNX Runtime 이 이 기기에서 **모델을 열 수 있는지**만 본다. - * - * ## 왜 따로 두나 - * 세션 생성이 네이티브에서 죽으면 프로세스가 통째로 사라져 다른 테스트의 결과까지 잃는다. - * 그리고 「어느 모델이 문제인가」를 갈라야 원인이 좁혀진다 — 32비트 ARM 전반의 문제인지 - * 특정 모델의 문제인지는 둘을 따로 열어 봐야 안다. - * - * SM-L305N(armeabi-v7a 전용)에서 각인 모델이 `SIGBUS`/`BUS_ADRALN` 로 죽는 것을 보고 만들었다. - * - * ``` - * adb push <모델>.onnx /sdcard/Android/data/app.nursemate.core.vision.test/files/ - * ``` - */ -@RunWith(AndroidJUnit4::class) -class OrtSessionOpenTest { - - @Test - fun `검출_모델을_열_수_있다`() = openOrSkip("rfdetr_seg_small.onnx") - - @Test - fun `각인_모델을_열_수_있다`() = openOrSkip(ImprintReader.MODEL_FILE_NAME) - - private fun openOrSkip(name: String) { - val context = InstrumentationRegistry.getInstrumentation().context - val model = File(context.getExternalFilesDir(null), name) - assumeTrue("$name 이 없어 건너뛴다", model.isFile && model.length() > 0) - - Log.i(TAG, "여는 중: $name (${model.length() / 1024 / 1024}MB) · ABI ${Build.SUPPORTED_ABIS.joinToString()}") - val env = OrtEnvironment.getEnvironment() - val started = System.nanoTime() - env.createSession(model.absolutePath, OrtSession.SessionOptions()).use { session -> - val ms = (System.nanoTime() - started) / 1_000_000 - Log.i(TAG, "열림: $name · ${ms}ms · 입력 ${session.inputNames} 출력 ${session.outputNames}") - } - } - - private companion object { - const val TAG = "NM485" - } -} diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderBenchmark.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderBenchmark.kt index d3c32c41..fdcb202c 100644 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderBenchmark.kt +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderBenchmark.kt @@ -16,8 +16,17 @@ import org.opencv.android.OpenCVLoader /** * 마크 판독 소요 측정 — NM-515 「앱 용량과 저사양 기기 추론 시간을 측정하고 허용치를 정했다」. * - * ## 실측 (Galaxy S24 · SM-S921N · Exynos 2400 · 4스레드 · 8방향) - * ORT 1.30 + WebGPU (NM-534). fp16 모델이다. + * ## 실측 — LiteRT GPU+CPU FP32 (NM-628, Galaxy S24 · Exynos 2400, 2026-10-19) + * ``` + * 모델 열기 2212 ms (한 번만 · GPU 셰이더 준비 포함) + * 전처리 33 ms + * 추론 157 ms + * 디코딩 2 ms + * ───────────────────────── + * 한 면 192 ms + * ``` + * + * ## 옛 실측 — ORT 1.30 + WebGPU (NM-534). fp16 모델. * ``` * 세션 생성 약 150 ms (한 번만) * 전처리 약 80 ms @@ -39,7 +48,7 @@ import org.opencv.android.OpenCVLoader * * ## 모델이 없으면 건너뛴다 * ``` - * adb push mark_species_fp16.onnx /sdcard/Android/data/app.nursemate.core.vision.test/files/ + * adb push app/src/main/assets/mark_m4_f16w.tflite /sdcard/Android/data/app.nursemate.core.vision.test/files/ * ``` */ @RunWith(AndroidJUnit4::class) diff --git a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderParityTest.kt b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderParityTest.kt index 95c793a2..71d8650a 100644 --- a/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderParityTest.kt +++ b/core/vision/src/androidTest/kotlin/app/nursemate/core/vision/mark/MarkReaderParityTest.kt @@ -3,7 +3,7 @@ package app.nursemate.core.vision.mark import android.graphics.Bitmap import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry -import app.nursemate.core.vision.EpOverride +import app.nursemate.core.vision.GpuOverride import java.io.File import java.nio.ByteBuffer import java.nio.ByteOrder @@ -27,13 +27,14 @@ import org.opencv.android.OpenCVLoader * ## 임베딩이 제일 예민하다 * 서버가 카탈로그 48,883장과 코사인으로 후보를 재정렬하는 값이라, 조금만 틀어져도 **예외가 * 아니라 순서로만** 드러난다. DoD 가 코사인 0.99 이상을 요구하는데 실제로는 훨씬 높게 나와야 - * 정상이다 — 전처리가 바이트 단위로 같으니 남는 차이는 실행 공급자(WebGPU)의 fp16 누적뿐이다. + * 정상이다 — 전처리가 바이트 단위로 같으니 남는 차이는 가속기 연산 순서뿐이다(아래 허용치는 ORT WebGPU 시절 실측, + * LiteRT GPU FP32 · CPU 는 S24 에서 모두 그 안에 들었다 — NM-628). * * ## 모델이 없으면 건너뛴다 * ``` - * adb push mark_species_fp16.onnx /sdcard/Android/data/app.nursemate.core.vision.test/files/ + * adb push mark_m4_f16w.tflite /sdcard/Android/data/app.nursemate.core.vision.test/files/ * ``` - * 53MB 를 저장소에 둘 수 없어 계측 테스트는 밀어 넣은 파일을 쓴다. 릴리스는 `app/models.md5` + * 57MB 를 저장소에 둘 수 없어 계측 테스트는 밀어 넣은 파일을 쓴다. 릴리스는 `app/models.md5` * 가 정한 경로로 받는다(`docs/RELEASE.md`). */ @RunWith(AndroidJUnit4::class) @@ -46,8 +47,8 @@ class MarkReaderParityTest { @Before fun setUp() { check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } - // 리더를 만들기 전이어야 한다 — 만든 뒤에 바꾸면 이미 열린 EP 로 돈다. - EpOverride.apply() + // 리더를 만들기 전이어야 한다 — 만든 뒤에 바꾸면 이미 열린 가속기로 돈다. + GpuOverride.apply() val assets = InstrumentationRegistry.getInstrumentation().context.assets fixtures = JSONObject(assets.open("mark/fixtures.json").use { it.readBytes().decodeToString() }) answers = JSONObject(assets.open("mark/answers.json").use { it.readBytes().decodeToString() }) diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/LiteRtModel.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/LiteRtModel.kt new file mode 100644 index 00000000..d7365e53 --- /dev/null +++ b/core/vision/src/main/kotlin/app/nursemate/core/vision/LiteRtModel.kt @@ -0,0 +1,202 @@ +package app.nursemate.core.vision + +import android.util.Log +import com.google.ai.edge.litert.Accelerator +import com.google.ai.edge.litert.CompiledModel +import com.google.ai.edge.litert.LiteRtException +import com.google.ai.edge.litert.TensorBuffer +import java.io.Closeable +import java.io.File + +/** 모델(또는 각인 조각)을 어디서 돌리나. */ +internal enum class Placement { + CPU, + GPU, + + /** GPU 가 못 받는 연산은 CPU 로 넘긴다. 각인 p4 는 GPU 만으로 열면 Exynos 에서 컴파일이 실패한다. */ + GPU_CPU +} + +/** GPU 에서 돌 때의 정밀도. CPU 는 늘 fp32 다. */ +internal enum class GpuPrecision { FP16, FP32 } + +/** + * 실행 계획 하나 — **ML 이 정한 실행 정밀도 계약**을 그대로 옮긴다(`_handoff/litert-ondevice-migration.md`). + * 바꾸면 정확도 보장이 없다. 예: 각인 p3 · 마크 · 세그를 FP16 으로 두면 8 Elite(Adreno 830)에서 + * 실행마다 다르게 틀리고, 세그는 Exynos 2500 에서 개수 일치가 93.3% 로 떨어진다. + */ +internal data class RunPlan(val placement: Placement, val precision: GpuPrecision = GpuPrecision.FP32) + +/** + * LiteRT `CompiledModel` 하나 — 입출력 버퍼를 한 번 만들어 재사용한다. + * + * ## GPU 가 안 되면 CPU 로 — 열 때도, 돌릴 때도 + * 계획이 GPU 라도 [VisionBackend.allowGpu] 가 막거나 GPU 로 열다(버퍼 할당까지) 실패하면 **같은 파일을 CPU 로** 연다. + * 열린 뒤 GPU 실행이 예외를 던지면 그 자리에서 CPU 로 다시 열어 한 번 더 돌리고, [VisionBackend.onGpuRunFailed] 로 + * 알려 이 기기에서 그 모델을 CPU 에 고정한다 — 컴파일은 받고 실행에서 거절하는 드라이버가 있어도 식별이 이어진다. + * 느려도 도는 쪽이 판독을 통째로 포기하는 것보다 낫다. CPU 로 돌아도 판정은 fp32 와 같다(ML 실측). + * + * ## GPU 흔적은 열기 **전에** 남긴다 + * 드라이버는 셰이더를 준비하는 `create` 안에서도 프로세스째 죽을 수 있다. 연 뒤에 남기면 그 죽음이 흔적 없이 지나가 + * 다음 실행이 못 막는다. 그래서 GPU 를 쓰기 직전 [VisionBackend.onGpuUse], 그 GPU 모델을 닫을 때 + * [VisionBackend.onGpuReleased] 를 부른다(꽂은 쪽이 열린 수를 세어 0 이면 흔적을 지운다). + * + * ⚠️ **한 인스턴스를 두 스레드가 동시에 [run] 하면 안 된다.** 버퍼를 공유한다. 리더가 잠그거나 + * (세그 · 마크), 조각마다 전용 스레드를 둔다(각인). + */ +internal class LiteRtModel private constructor( + private val file: File, + private val threads: Int, + private var engine: Engine +) : Closeable { + + val name: String get() = file.name + + /** 지금 GPU 로 돌고 있는가. 계획이 GPU 여도 대체됐으면 false 다. */ + val onGpu: Boolean get() = engine.onGpu + + /** 입력을 index 순서대로 받아 돌리고, 출력을 index 순서대로 돌려준다. */ + fun run(vararg xs: FloatArray): List = try { + engine.run(xs) + } catch (e: LiteRtException) { + if (!engine.onGpu) throw e + Log.w(TAG, "$name GPU 실행 실패 — CPU 로 다시 연다: ${e.message}") + engine.close() + VisionBackend.onGpuReleased(name) + runCatching { VisionBackend.onGpuRunFailed(name) } + engine = Engine.cpu(file, threads) + report(name, OpenOutcome.GPU_RUN_FAILED) + engine.run(xs) + } + + override fun close() { + engine.close() + if (engine.onGpu) VisionBackend.onGpuReleased(name) + } + + /** 컴파일된 모델과 그 입출력 버퍼. 만들다 실패하면 이미 연 것을 닫고 던진다 — 반쯤 열린 채 새지 않게. */ + private class Engine private constructor(private val compiled: CompiledModel, val onGpu: Boolean) : Closeable { + private val inputs: List + private val outputs: List + + init { + var done = false + try { + inputs = compiled.createInputBuffers() + outputs = compiled.createOutputBuffers() + done = true + } finally { + if (!done) compiled.close() + } + } + + fun run(xs: Array): List { + require(xs.size == inputs.size) { "입력은 ${inputs.size}개인데 ${xs.size}개를 받았다" } + xs.forEachIndexed { i, x -> inputs[i].writeFloat(x) } + compiled.run(inputs, outputs) + return outputs.map { it.readFloat() } + } + + override fun close() { + inputs.forEach { it.close() } + outputs.forEach { it.close() } + compiled.close() + } + + companion object { + fun cpu(file: File, threads: Int) = + Engine(CompiledModel.create(file.absolutePath, cpuOptions(threads)), onGpu = false) + + fun gpu(file: File, plan: RunPlan, threads: Int) = + Engine(CompiledModel.create(file.absolutePath, gpuOptions(plan, threads)), onGpu = true) + } + } + + companion object { + /** + * [file] 을 [plan] 대로 연다. GPU 가 막혔거나 실패하면 CPU 로 연다. + * + * 열기는 0.8~3.3초 걸린다(ML 실측, 셰이더 준비 포함) — 플로우 동안 한 번만 열고 재사용한다. + */ + fun open(file: File, plan: RunPlan, threads: Int = CPU_THREADS): LiteRtModel { + val name = file.name + val outcome = when { + plan.placement == Placement.CPU -> OpenOutcome.PLANNED_CPU + + !VisionBackend.allowGpu(name) -> OpenOutcome.GPU_BLOCKED + + else -> openOnGpu(file, plan, threads)?.let { + report(name, OpenOutcome.GPU) + return LiteRtModel(file, threads, it) + } ?: OpenOutcome.GPU_OPEN_FAILED + } + if (outcome == OpenOutcome.GPU_BLOCKED) Log.i(TAG, "$name GPU 막힘 — CPU 로 연다") + val cpu = Engine.cpu(file, threads) + Log.i(TAG, "$name CPU($threads 스레드)") + report(name, outcome) + return LiteRtModel(file, threads, cpu) + } + + /** GPU 로 열어 본다(버퍼 할당까지). 실패하면 null — 호출부가 CPU 로 연다. */ + private fun openOnGpu(file: File, plan: RunPlan, threads: Int): Engine? { + val name = file.name + // ⚠️ 열기 **전에** 알린다 — 셰이더 준비 중에 드라이버가 죽어도 다음 실행이 알게(클래스 KDoc). + VisionBackend.onGpuUse(name) + return runCatching { Engine.gpu(file, plan, threads) } + .onSuccess { Log.i(TAG, "$name GPU(${plan.placement} · ${plan.precision})") } + .onFailure { + Log.w(TAG, "$name GPU 로 못 열었다 — CPU 로 연다: ${it.message}") + VisionBackend.onGpuReleased(name) + } + .getOrNull() + } + + private fun report(name: String, outcome: OpenOutcome) { + // 보고가 실패해도 모델 열기는 멈추지 않는다 — 관측일 뿐이다. + runCatching { VisionBackend.onModelOpened(name, outcome) } + .onFailure { Log.w(TAG, "$name 열림 보고 실패", it) } + } + + private fun cpuOptions(threads: Int) = CompiledModel.Options(Accelerator.CPU).apply { + cpuOptions = CompiledModel.CpuOptions(numThreads = threads) + } + + private fun gpuOptions(plan: RunPlan, threads: Int): CompiledModel.Options { + val accelerators = when (plan.placement) { + Placement.GPU_CPU -> setOf(Accelerator.GPU, Accelerator.CPU) + else -> setOf(Accelerator.GPU) + } + return CompiledModel.Options(accelerators).apply { + cpuOptions = CompiledModel.CpuOptions(numThreads = threads) + gpuOptions = CompiledModel.GpuOptions( + // ML 이 잰 경로가 OpenCL 이다. 다른 백엔드는 계약 밖이다. + backend = CompiledModel.GpuOptions.Backend.OPENCL, + precision = when (plan.precision) { + GpuPrecision.FP16 -> CompiledModel.GpuOptions.Precision.FP16 + GpuPrecision.FP32 -> CompiledModel.GpuOptions.Precision.FP32 + } + ) + } + } + + /** + * 실측에서 4스레드가 최적이었다(ORT 시절 1 · 2 · 4 · 6 · 8 을 쟀다 — 6 · 8 은 리틀코어로 넘쳐 느려졌다). + * ML 벤치도 CPU 4스레드다. + */ + const val CPU_THREADS = 4 + + private const val TAG = "LiteRt" + } +} + +/** NCHW → NHWC. [plane] 은 H·W. 전처리는 NCHW 로 쓰고(ONNX 시절 그대로 · 테스트가 받치는 형식) 넣기 직전에 돌린다. */ +internal fun nchwToNhwc(src: FloatArray, dst: FloatArray, n: Int, c: Int, plane: Int): FloatArray { + for (b in 0 until n) { + val base = b * c * plane + for (ch in 0 until c) { + val from = base + ch * plane + for (p in 0 until plane) dst[base + p * c + ch] = src[from + p] + } + } + return dst +} diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/OrtBackend.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/OrtBackend.kt deleted file mode 100644 index a6a0d71d..00000000 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/OrtBackend.kt +++ /dev/null @@ -1,766 +0,0 @@ -package app.nursemate.core.vision - -// `ai.onnxruntime.qnnpluginep.*` 는 플러그인 artifact 가 들고 있는 이름이다. 손으로 적지 -// 않는다 — artifact 를 올렸을 때 이름이 바뀌면 컴파일이 깨져 알게 된다. -// -// ⚠️ `compileOnly` 로 문다 — 이 클래스들은 feature module `qnn_core` 에 있고, 설치본에 따라 -// 런타임에 없을 수 있다([QNN_BUNDLED]). - -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.OrtProvider -import ai.onnxruntime.OrtSession -import ai.onnxruntime.providers.NNAPIFlags -import ai.onnxruntime.qnnpluginep.getEpName as qnnEpName -import ai.onnxruntime.qnnpluginep.getLibraryPath as qnnLibraryPath -import android.util.Log -import java.io.File -import java.util.EnumSet - -/** - * 세션을 **WebGPU 로 열고, 안 되면 CPU 로 되돌아간다**. - * - * ## 어느 EP 를 쓰는가 — **기기가 정한다** - * 2026-10-13 실기기 전수 측정(NM-577). 사진 3장(알약 3·7·4정) · 예열 후 · 답 대조 포함. - * - * | | 검출 | 각인 | 마크(1장) | - * |---|---|---|---| - * | **Xclipse 940** (Exynos 2400) | 1575 → **810 ms** | 4376 → **2157 ms** | 650 → **206 ms** | - * | Adreno 740 (SM8550) | 1700 → 1110 ms | **프로세스 사망** | 704 → 337 ms | - * | Adreno 750 (SM8650) | **프로세스 사망** | 예외 | 560 → 262 ms | - * | Mali (Tensor G4) | 예외 | 예외 | 예외 | - * - * WebGPU 가 되는 곳에서는 **답이 CPU 와 같다**(검출 박스·점수 최대차 1e-7). 다만 **같은 - * Adreno 안에서도 세대마다 깨지는 모델이 다르다** — 무엇이 깨질지 미리 알 수 없으므로 - * **되는 것만 켠다**(`WebGpuPolicy` 허용목록). 모르면 CPU 다. - * - * ## 다른 EP 는 재 보고 접었다 - * 옛 주석은 「Galaxy S24 에서 전부 재 봤다」였는데 그 한 대의 결과였다. 네 기기로 다시 쟀다. - * - * | 경로 | 결과 | - * |---|---| - * | NNAPI | **검출이 전 기기에서 `ANEURALNETWORKS_OP_FAILED`**. 각인·마크는 돌지만 CPU 보다 느리다. Android 15 에서 deprecated | - * | XNNPACK | 전부 CPU 보다 1.5~2.5배 느리고, **마크는 네 기기 전부 오답**(종 7 → 65) | - * | Exynos NNC | 컴파일 전체 실패 (Xclipse) | - * | int8 | 세그는 트랜스포머 활성 이상치에 무너진다 | - * | QNN | 접은 것이 **배포본 선택**이었다 — 아래 참조. 플러그인으로 다시 열렸다(NM-577) | - * - * 즉 **지금 운영의** 선택지는 CPU 와 WebGPU 둘뿐이다. - * - * ## QNN 은 「거래」가 아니었다 — 배포본을 잘못 봤다 (2026-10-13) - * 옛 주석은 「프리빌트 `onnxruntime-android-qnn` 에 Dawn 이 없으니 QNN 을 쓰려면 WebGPU 를 - * 버려야 한다」였다. 그 **artifact** 에 대해서는 맞다(`com.microsoft.onnxruntime` 쪽은 ORT 를 - * 통째로 갈아 끼워 기기에서 EP 가 `CPU, QNN` 둘만 보인다). 틀린 것은 **그것이 유일한 길이라고 - * 본 것**이다. - * - * `com.qualcomm.qti:onnxruntime-android-qnn` 은 **플러그인 EP** 다. `libonnxruntime.so` 를 품지 - * 않고 ORT API 를 팩토리 ABI 로 넘겨받아서, 표준 배포본 옆에 그냥 얹힌다. 같은 프로세스에서 - * `registerExecutionProviderLibrary` 로 올리고 나서도 `getAvailableProviders()` 가 - * **`CPU, NNAPI, XNNPACK, WEBGPU` 를 그대로 내놓는 것**을 기기에서 확인했다(SM-S921N). - * - * 즉 **WebGPU 와 QNN 은 양립한다.** 기기에 따라 둘 중 되는 쪽을 고르는 선택이 가능하다 — - * 엑시노스는 WebGPU, 스냅드래곤은 QNN. [Ep.QNN] 계열이 그 측정 경로다. - * - * ## QNN 실측 — Adreno 740 (SM8550 · HTP V73), 2026-10-13 - * 같은 기기에서 같은 입력으로 CPU 와 맞댄 값이다. 정답 대조 포함. - * - * | | 세션 생성 | 추론 | 답 | - * |---|---|---|---| - * | 각인 CPU | 297ms | 4206ms | YS · 점수 **0.9699** | - * | 각인 QNN | 84.0초 | **418ms** (10.1배) | `null` · pair YS · 점수 **0.9436** | - * | 각인 QNN fp32 강제 | 88.4초 | 435ms | 같음 (0.9436) | - * | 각인 QNN + `cpu(/rnn/)` | 91.1초 | 447ms | 같음 (0.9436) | - * | 마크 CPU | 222ms | 3743ms | 정답 | - * | 마크 QNN | 8.4초 | **253ms** (14.8배) | **정답** | - * - * ### 각인은 「틀린」 것이 아니다 — **임계에서 0.0054 모자란다** - * QNN 도 best_pair 를 **YS 로 맞게** 고른다. 점수가 0.9436 이고 - * [ImprintDecoding.ADOPT_THRESHOLD] 가 **0.949** 라서 채택이 안 될 뿐이다. - * `ImprintPreprocess` KDoc 이 이 실패를 그대로 적어 뒀다 — 「미세하게 달라지면 글자 확률이 - * 흔들려 0.949 채택 임계가 뒤집힌다」. 그때는 CLAHE 얘기였고 이번엔 HTP 수치다. - * - ### 왜 다르게 나오는지 — **QNN 이 글자 확신도를 떨어뜨린다** (off-device 재현) - * AI Hub 실기기 S23(SM8550, Test Lab `dm1q` 와 같은 칩)과 로컬 ORT CPU 에 **같은 입력**을 넣고 - * `ImprintDecoding` 을 그대로 다시 계산해 맞댔다. 기기에서 본 일이 그대로 재현된다. - * - * ``` - * CPU 점수 0.9774 · pair 'YS' · 확신글자 'YS' · 채택 'YS' - * QNN 점수 0.9202 · pair 'YS' · 확신글자 'S' · 채택 null - * ``` - * - * | 지표 | 값 | - * |---|---| - * | 로짓 | 최대차 1.75 · 평균차 0.28 · **PSNR 37.9 dB** | - * | **argmax 불일치** | **0.000%** — 글자를 다르게 읽는 일은 없다 | - * | argmax 자리 확률차 | 평균 0.0050 · 95분위 0.0203 · **최대 0.1506** | - * - * **평균은 0.005 인데 꼬리가 0.15 다.** [ImprintDecoding.bestPair] 가 인접 두 글자 확률의 - * **낮은 쪽**(`min`)을 쓰므로, 한 글자만 꼬리에 맞아도 점수가 주저앉는다. 위 예가 정확히 - * 그렇다 — CPU 는 `Y`·`S` 둘 다 [ImprintDecoding.SURE_THRESHOLD] 를 넘겨 `YS` 인데, QNN 은 - * `Y` 가 그 아래로 내려가 `S` 만 남았다. - * - * ### 「같은 변환인데 왜 각인만」 — 지표가 아니라 **모델**이다 - * 마크를 **같은 방식으로** 재서 가렸다(`scratchpad/qnn_metric.py`). - * - * | | 로짓 PSNR | 최대차 | argmax 일치 | 최대확률 차 | - * |---|---|---|---|---| - * | 마크 | **67.50 dB** | 0.0234 | 100% | 0.0007 | - * | 각인 | **37.92 dB** | 1.7542 | 100% | **0.1506** | - * - * **30dB 차 = 오차 에너지 약 1000배.** 「오차는 비슷한데 지표가 민감해서」가 아니다 — - * 마크의 0.0234 는 fp16 반올림 수준이고 각인은 자릿수가 다르다. 각인 구조가 오차를 키운다. - * - * 각인에만 있는 증폭기가 둘이다. - * 1. **STN(TPS 격자)** — 기하 재샘플링이다. 격자 좌표가 틀리면 **샘플링 위치가 옮겨져** 뒤쪽이 - * 「살짝 어긋난 활성」이 아니라 **다른 그림**을 받는다. 오차가 더해지지 않고 곱해진다 - * 2. **양방향 LSTM** — 32 시점을 순환하며 누적된다 - * - * **둘 중 어느 쪽인지도 이미 가려졌다.** [Ep.QNN_RNN_CPU] 로 LSTM 을 CPU 에 고정했을 때 점수가 - * **0.9436 그대로**였다. LSTM 에서 오차가 난다면 고쳐졌어야 한다 — 즉 오차는 **RNN 에 들어가기 - * 전에 이미 있다(STN/CNN 앞단).** 다음에 잴 것은 `cpu(/stn/)` 다. - * - * ⚠️ 절대값은 기기값과 다르다(CPU 0.9774 대 기기 0.9699). 고정물에 회전 90° CLAHE 패치가 - * 없어서 r0 을 90° 돌려 만들고, 144장 대신 5변형으로 채웠다. **같은 입력에서의 CPU↔QNN 차이**는 - * 그래도 유효하다 — 그것이 재는 대상이다. - * - * ### 이 재현이 Test Lab 을 대신한다 - * 각인 수치 문제는 이제 **실기기 할당량 없이** 돌릴 수 있다(`scratchpad/qnn_score.py`). - * 하루 5회 제약에 묶이지 않는다. - * - * ### 가른 것과 못 가른 것 — 기기 측정 - * 네 설정의 점수가 **0.9436 으로 소수점 넷째 자리까지 같다.** 그중 의미가 있는 것만 적는다. - * - **LSTM 은 아니다** — WebGPU 를 살린 `cpu(/rnn/)` 를 걸어도 같다. 마크가 QNN 에서 정답인 것도 - * LSTM 쪽을 가리켰는데 아니었다 - * - **TPS 격자만 fp32 로 남긴 변형**(AI Hub 일치율 99.6%)을 대도 같다. 그 변형은 노드 360개 - * (기준 350)에 가중치가 fp16 47 + fp32 2인 **다른 모델**이고 CPU 에서는 0.9750 으로 - * 기준(0.9699)보다 **높다**. 그런데 QNN 에서는 기준과 같다 - * - * ⚠️ **fp16 은 아직 안 갈랐다.** 「기본」과 「`enable_htp_fp16_precision=0`」을 비교했는데, - * 이 플러그인 저장소(`onnxruntime-qnn`) 문서가 **기본값을 0** 이라고 적는다(ORT 본가 문서는 1로 - * 적어 서로 다르다). 그러면 두 번 다 같은 설정을 잰 것이고, 시간이 418 대 435ms 로 안 움직인 - * 것도 그래서다. [Ep.QNN_FP16] 이 그 축이다 — **그걸 재기 전에는 정밀도를 배제할 수 없다.** - * - * ### 런타임을 나란히 — **감사셋 331면 전수** (`scratchpad/eval_production.py`) - * ML 쪽 감사셋(사람이 면·정답을 확정한 실사진 331면)을 **생산 경로 그대로** 돌렸다 — - * `infer.py` 의 전처리·TTA(24방향 × 6배율 = 144장)·디코딩을 그대로 쓰고 **런타임만** 갈아 끼웠다. - * 모델은 출시본 단일 시드 `reader_ep60_s1.onnx` 다. - * - * | 런타임 | 채택 면 | 정답 | 정밀도 | 평균점수 | 331면 소요 | - * |---|---|---|---|---|---| - * | ONNX · CPU EP (기준) | 229 | 212 | 92.6% | 0.9021 | 255s | - * | **Core ML · ANE+CPU** | **229** | **212** | **92.6%** | 0.9021 | **43s** | - * | Core ML · CPU only | 229 | 212 | 92.6% | 0.9021 | 152s | - * - * 하네스가 기준과 맞는다 — `INFO.md` 의 단일 시드 값이 「정밀도 90%에서 240면/150알약」인데 - * 고정 임계 0.949 로 **229면 · 정밀도 92.6%** 가 나왔다(정밀도가 높은 지점이라 면수가 적다). - * 같은 문서가 적은 **시드 노이즈 ±15면**이 유의성 기준이다 — EP 를 바꿔 그 안이면 차이 없음이다. - * - * **「NPU 는 원래 수치가 다르다」가 아니다.** 애플 뉴럴엔진은 331면에서 채택·정답·정밀도가 - * CPU 와 **완전히 같고 6배 빠르다.** 각인 한 장만 봐도 상대오차 0.001%(115dB)인데 QNN 은 - * 9.931%(37.9dB) 다 — 78dB 차이다. 9.9% 는 **HTP 고유 문제**이고 단계별 측정이 `GridSample` 을 - * 지목한 것과 맞물린다. 비교 기준을 CPU 하나로 보면 이걸 NPU 일반의 한계로 잘못 읽는다. - * - * ### QNN 도 같은 331면으로 쟀다 — **각인은 쓸 수 있다** (Adreno 740 · SM8550) - * [app.nursemate.core.vision.imprint.ImprintEvalSetTest] 로 실기기에서 전수로 돌렸다. - * 기기 쪽은 앱의 전처리·TTA·디코딩을 **그대로** 쓰고, 정답 대조만 호스트에서 한다. - * - * | | 면 | 채택 | 정답 | 정밀도 | 평균점수 | 면당 | - * |---|---|---|---|---|---|---| - * | **QNN(HTP)** | 331 | **235** | **215** | **91.5%** | 0.8964 | **427ms** | - * | ONNX CPU(맥 기준선) | 331 | 229 | 212 | 92.6% | 0.9021 | — | - * - * **채택이 6면 늘고 정답이 3면 늘었다. 정밀도만 1.1%p 낮다**(오답 17 → 20건). 시드 노이즈가 - * ±15면이므로 **차이 없음 구간**이다. - * - * ### ⚠️ 한 장으로 본 결론은 틀렸다 - * 고정물 한 장(`sample_crop.png`)에서 QNN 이 0.9436 으로 채택에 떨어진 것을 보고 「각인이 - * QNN 에서 깨진다」고 적었다. **전수에서는 그렇지 않다.** 그 한 장이 하필 임계 바로 위 - * (CPU 0.9774)라 뒤집힌 것이고, 331면에서는 내려가는 면과 올라가는 면이 상쇄된다. - * 임계 하나를 넘나드는 지표는 **표본 한 개로 방향조차 정할 수 없다.** - * - * ⚠️ CPU 기준선은 **맥에서 낸 값**이다(ORT CPU EP·`infer.py` 전처리). 전처리 동등성은 - * `ImprintPreprocessParityTest` 가 받치지만, **같은 기기 CPU 로 재지는 않았다** — 정밀도 - * 1.1%p 는 그만큼 느슨하게 읽어야 한다. - * - * ### 다른 EP 와의 관계 — 비교한 것과 못 한 것 - * | 상대 | 결과 | - * |---|---| - * | **CPU** (같은 기기·같은 입력) | 0.9699 대 **0.9436 — 다르다** | - * | **ML 기준 구현** | 0.969883 (`ImprintReaderParityTest` · `INFO.md` 「YS 0.970」) = CPU 와 같다 | - * | **WebGPU** | **이 기기에서는 비교 못 한다** — Adreno 740 에서 각인 모델로 프로세스가 죽는다(NM-574). | - * | | 엑시노스에서는 돌고, 그때 `각인_WEBGPU` 가 **0.969883 ± 1e-4 단정을 통과**했다 | - * | **Core ML(mlpackage)** | **쟀다 — CPU 와 같다**(상대오차 0.001%). 바로 위 표 | - * - * 즉 **잰 범위에서는 QNN 만 다르다.** WebGPU 는 도는 기기에서 CPU·기준과 같았다. - * - * ⚠️ **ONNX(fp32)→QNN 의 출력 충실도는 아직 잰 적이 없다.** 돌아다니는 「각인 87.3%」는 - * **fp16 각인 모델의 최종 답 일치율**이고 ML 쪽이 **CPU 에서** 잰 값이다(같은 측정에서 마크 - * 코사인 1.0000 · 검출 IoU 0.995/0.999). QNN 수치와 무관한 숫자라 근거로 쓰면 안 된다. - * - * ### 임계 쪽도 열려 있다 - * 읽기는 **네 번 다 맞았다**(pair YS). 점수만 [ImprintDecoding.ADOPT_THRESHOLD] 0.949 에 - * 0.0054 모자란다. 그 값은 **CPU 수치의 감사셋에서 정밀도 90% 지점**으로 잡은 것이라, - * QNN 경로를 쓰려면 그 경로로 다시 잡아야 한다. ⚠️ 이 저장소 각인 고정물은 **한 장** - * (`imprint/input_gray.bin`)이어서 분포가 어떻게 움직이는지는 여기서 증명할 수 없다 — - * 재보정은 감사셋을 가진 쪽의 일이다. - * - * ### 변형은 CPU 로는 못 쓴다 - * 각인변형 CPU 추론이 **22735ms** 였다(기준 4206ms). fp16 가중치가 CPU 에서 Cast 를 불러 - * **5.4배 느리다.** 변형을 쓰려면 QNN 전용으로 따로 실어야 한다 — 기기별로 다른 모델을 - * 주는 길(Play 기기 타깃팅)이 필요해지는 지점이다. - * - * ### 세션 생성 84초는 **캐시가 없앤다** — 126배 - * QNN 은 ONNX 그래프를 기기에서 HTP 명령으로 컴파일한다(`libQnnHtpPrepare.so`, 84MB). - * [Ep.QNN_CACHED] 가 그 결과를 EPContext 모델로 써 두고 **다음부터 건너뛴다.** - * - * | | 컴파일(첫 세션) | 캐시 적중 | 컴파일 결과 크기 | - * |---|---|---|---| - * | 각인 | 84.1초 | **0.67초** | 27.9MB | - * | 마크 | 10.1초 | **0.46초** | 58.6MB | - * - * **이것이 운영 경로를 정한다.** 기기에서 한 번 치르고 캐시하는 길도 있지만(각인 84초를 첫 - * 실행에 한 번), 컴파일 결과는 **HTP 세대마다 다르다** — 그래서 세대별로 **미리 컴파일해 - * 실으면** 컴파일이 아예 없고 84MB `libQnnHtpPrepare.so` 도 빠진다. Play 기기 타깃팅의 - * `system-on-chip` 선택자가 `Build.SOC_MODEL` 로 거르므로 세대와 1:1로 맞는다. - * - * ⚠️ 쓰는 법에 함정이 둘 있다. 둘 다 **조용히** 틀린다. - * 1. `ep.context_*` 는 **세션 설정**이다(`addConfigEntry`). EP 제공자 옵션으로 넘기면 무시되고 - * 캐시가 아예 안 생긴다 — 둘째 세션도 88초였다 - * 2. **생성을 켜는 것은 캐시가 없을 때만**이다. 이미 컨텍스트 모델을 열면서 또 켜면 ORT 가 - * 거절한다(`Failed to generate EP context model since the file … exists already`) - * - * ### 쓰려면 셋이 필요하다 — 하나만 빠져도 조용히 CPU 로 돈다 - * 전부 실측으로 걸렀다. 공통점은 **세션이 열리고 답도 맞아서 겉보기엔 성공**이라는 것이다. - * 1. **배치 차원 고정** — `setSymbolicDimensionValue("batch", N)`. 없으면 HTP 가 모양을 못 - * 구해(`Cannot get shape`) 노드를 거의 안 받는다 - * 2. **`backend_path`** — `backend_type` 만으로는 `ADSP_LIBRARY_PATH` 가 비어 DSP 가 skel 을 - * 못 찾는다([qnnNativeLibDir]) - * 3. **`.so` 를 APK 밖으로** — `useLegacyPackaging = true`. cDSP 는 `apk!/lib/...` 를 못 연다 - * - * 셋 중 하나라도 빠진 상태의 측정값이 **각인 4349ms · 마크 4611ms** 였다 — CPU 와 구별되지 않는다. - * - * ## 프리빌트에 들어 있다 — 소스 빌드가 아니다 - * 2026-09 에는 「프리빌트 Maven 배포본에 EP 가 없어 소스 빌드가 필요하다」가 맞았고, 그래서 - * 11MB 커스텀 AAR 과 minSdk 28 을 받아들여야 했다. **공식 `onnxruntime-android` 1.30.0 부터는 - * 들어 있다**(ABI 4개 전부 · minSdk 24). 저장소가 1.22.0 에 머물러 있었을 뿐이다. - * - * ## 되돌아갈 길이 필요한 이유 - * WebGPU 는 Dawn 을 통해 Vulkan 으로 내려간다. 드라이버가 못 받는 기기가 있어서, 세션 생성이 - * 실패하면 잡아서 CPU 로 다시 연다. 답은 같다(감사셋 대조 완료, NM-528). - * - * ⚠️ **아래 `runCatching` 은 세션 생성 실패만 잡는다.** 예전 주석은 「드라이버가 못 받으면 - * 세션 생성 실패로 나온다」를 전제했는데 **그 전제가 틀렸다**(NM-574, 2026-10-13 Test Lab 실측). - * 실제로 터지는 자리는 [OrtSession.run][ai.onnxruntime.OrtSession.run] 안이고, 양상이 둘이다: - * - * | 기기 | 무엇이 일어나나 | 잡히나 | - * |---|---|---| - * | SM-S916N · Adreno 740 | `vulkan.adreno.so` `vkCmdPipelineBarrier` 에서 **SIGSEGV** | **못 잡는다** — OS 가 프로세스를 끝낸다 | - * | SM-S928N · Adreno 750 | Conv 노드 `OrtException`, 이어서 WebGPU 디바이스 사망 | 잡히지만 그 프로세스의 WebGPU 는 죽은 뒤다 | - * - * 그래서 **들어가기 전에 막는 길**을 [VisionBackend] 로 따로 냈다. 이 폴백은 그대로 두되, - * 이것만으로 충분하다고 읽히면 안 된다. - */ -internal object OrtBackend { - - /** - * WebGPU 를 쓸지 — **계측 테스트만 끈다**(`-e nm_webgpu false`). - * - * 같은 기기에서 CPU 와 WebGPU 의 답을 맞대 보려면 한쪽을 강제로 끌 수 있어야 한다. - * 운영 코드에는 이 값을 바꾸는 자리가 없고, 기본값은 늘 켜짐이다. - * - * 왜 필요했나: 2026-10-13 Adreno(SM-S916N)에서 `vulkan.adreno.so` 세그폴트가 올라왔는데, - * WebGPU 성능·정확도 근거가 전부 Xclipse(S24 · Exynos 2400) 한 대에서 나온 것이었다. - * 다른 GPU 에서 **답이 같은지**를 재려면 같은 기기에서 두 경로를 다 돌려야 한다. - */ - internal var webGpuEnabled: Boolean = true - - /** - * 실행 공급자를 하나로 **못박는다** — 계측 테스트 전용(`-e nm_ep nnapi`). - * - * ## 왜 필요한가 - * 지금의 EP 비교표([OrtBackend] KDoc)가 **Galaxy S24(Exynos 2400 · Xclipse 940) 한 대** - * 에서 나왔다. 「NNAPI 실패」는 엑시노스 드라이버 얘기지 퀄컴 NNAPI(Hexagon NPU 로 - * 내려간다)에 대한 것이 아니고, 「XNNPACK 더 느림」도 그 CPU 에서의 값이다. - * 2026-10-13 Adreno 에서 각인이 깨지는 것이 드러나면서 **그 표를 다시 깔아야** 한다. - * - * `null` 이면 운영과 같다 — WebGPU 가 되면 WebGPU, 안 되면 CPU. - */ - internal var forcedEp: Ep? = null - - /** - * 노드별 트레이스를 남길 파일 경로의 **접두어** — 계측 테스트 전용. - * - * ORT 가 Chrome 트레이싱 JSON 을 쓴다. 항목마다 `provider` 와 `dur` 가 붙어 **어느 노드가 - * 어느 EP 로 갔고 누가 시간을 먹는지**가 그대로 나온다. `null` 이면 끄는 것이고 운영은 늘 꺼져 있다. - */ - internal var profilePrefix: String? = null - - /** 이 기기가 WebGPU EP 를 갖고 있는가. 런타임 한 번만 묻는다. */ - private val hasWebGpu: Boolean by lazy { - OrtEnvironment.getAvailableProviders().contains(OrtProvider.WEBGPU).also { - Log.i(TAG, "사용 가능 EP: ${OrtEnvironment.getAvailableProviders()} · WebGPU=$it") - } - } - - /** - * @param cpuNodeNames WebGPU 로 열 때 **CPU 에 남겨 둘 노드**의 이름 조각. - * 각인처럼 일부 연산이 GPU 에서 오히려 느린 모델이 쓴다 — [ImprintReader] KDoc 참조. - * CPU 로 되돌아갈 때는 의미가 없으므로 무시된다. - * @param webGpuOptions WebGPU EP 제공자 옵션(`preferredLayout` 등). 기본은 비어 있다 — - * **무엇이 Adreno 를 살리는지 재는 데 쓴다**(NM-577). - * @param contextTag [Ep.QNN_CACHED] 컨텍스트 캐시 이름에 붙일 꼬리표. **세션 모양을 바꾸는 - * 설정**(못박은 배치 등)을 넣는다 — 안 넣으면 배치 144 로 컴파일한 그래프를 - * 배치 72 세션이 집어 든다. - * @param configure CPU·WebGPU 양쪽에 공통으로 줄 설정 - */ - @Suppress("LongParameterList") // 호출부가 이름 붙여 넘긴다. 묶음 클래스를 만들면 세 리더가 모두 바뀐다. - fun openSession( - env: OrtEnvironment, - modelFile: File, - cpuNodeNames: String? = null, - webGpuOptions: Map = emptyMap(), - contextTag: String = "", - configure: OrtSession.SessionOptions.() -> Unit = {} - ): OrtSession { - forcedEp?.let { ep -> - // [Ep.QNN_CACHED] 는 **만들어진 컨텍스트 모델을 연다**. 없으면 원본을 열고, 그때 - // `ep.context_enable` 이 이 경로에 써 둔다 — 다음 열기가 적중이다. - val cache = contextCacheFile(modelFile, contextTag) - val source = contextModelOrNull(ep, cache) ?: modelFile - Log.i(TAG, "${modelFile.name} EP 고정 → $ep${if (source !== modelFile) " · 캐시 적중 ${source.name}" else ""}") - return env.createSession( - source.absolutePath, - OrtSession.SessionOptions().apply { - configure() - applyEp(env, ep, cache, cpuNodeNames, webGpuOptions) - profilePrefix?.let { - val trace = "$it-$ep-${modelFile.name.substringBeforeLast('.')}" - Log.i(TAG, "프로파일 → $trace") - enableProfiling(trace) - } - } - ) - } - - // 바깥이 막는 모델은 아예 시도하지 않는다 — 이 기기에서 터지는 것이 이미 알려진 조합이거나, - // 전에 네이티브로 죽은 적이 있는 기기다(NM-574). - val allowed = VisionBackend.allowWebGpu(modelFile.name) - if (!allowed) Log.i(TAG, "${modelFile.name} WebGPU 차단됨 — CPU 로 연다") - - val onWebGpu = if (allowed && webGpuEnabled && hasWebGpu) { - runCatching { - env.createSession( - modelFile.absolutePath, - OrtSession.SessionOptions().apply { - configure() - addWebGPU(webGpuOptions) - cpuNodeNames?.let { addConfigEntry(LAYER_ASSIGNMENT, "cpu($it)") } - } - ) - }.onSuccess { - // 열렸다는 것만 알린다. **추론은 아직 안 돌았다** — 터지는 것은 그다음이라, - // 기록하는 쪽이 「이 프로세스는 WebGPU 를 썼다」를 미리 남겨 둬야 죽고 나서 안다. - VisionBackend.onWebGpuSessionOpened(modelFile.name) - }.onFailure { - // 기기에 따라 드라이버가 못 받을 수 있다. 판독을 통째로 포기하는 것보다 느려도 도는 쪽이 낫다. - Log.w(TAG, "${modelFile.name} WebGPU 세션 실패 — CPU 로 연다: ${it.message}") - }.getOrNull() - } else { - null - } - - return onWebGpu ?: env.createSession( - modelFile.absolutePath, - OrtSession.SessionOptions().apply(configure) - ) - } - - /** [forcedEp] 가 정한 EP 하나만 건다 — 계측 테스트 경로다. 폴백이 없어야 그 EP 를 잰 값이 된다. */ - private fun OrtSession.SessionOptions.applyEp( - env: OrtEnvironment, - ep: Ep, - cache: File, - cpuNodeNames: String?, - webGpuOptions: Map - ) = when (ep) { - Ep.CPU -> Unit - - Ep.WEBGPU -> { - addWebGPU(webGpuOptions) - cpuNodeNames?.let { addConfigEntry(LAYER_ASSIGNMENT, "cpu($it)") } - } - - // 기본 플래그. CPU 폴백이 **허용**돼 있어, 느리게 나오면 NNAPI 의 자체 CPU 구현 - // (`nnapi-reference`)으로 떨어진 것일 수 있다 — 그걸 가리는 것이 [Ep.NNAPI_NO_CPU] 다. - Ep.NNAPI -> addNnapi() - - // CPU 폴백을 막는다. 그래도 돌면 진짜 NPU/GPU 에서 돈 것이고, 실패하면 위가 CPU 였다는 뜻이다. - Ep.NNAPI_NO_CPU -> addNnapi(EnumSet.of(NNAPIFlags.CPU_DISABLED)) - - /* - * **NNAPI 가 잘하는 것만 준다** — 가속기가 못 받는 덩어리를 손으로 CPU 에 고정한다. - * - * ORT 는 자동으로도 쪼갠다(`NnapiExecutionProvider_Nnapi_..._156_76` 같은 노드 이름이 - * 그 흔적이다). 그런데 자동 분할이 잘게 쪼개지면 **경계마다 복사**가 붙어 CPU 단독보다 - * 느려진다 — 각인이 NNAPI 4817ms 대 CPU 4376ms 로 그 꼴이다. - * - * 각인은 CNN(Conv·ReLU·MaxPool) → RNN(LSTM) → out 구조다. LSTM 을 통째로 CPU 에 - * 고정하면 남는 그래프가 **conv 뿐**이라 NNAPI 가 한 덩이로 가져갈 수 있다. - * WebGPU 에서 같은 수법이 9943 → 1796ms 를 만들었다([ImprintReader] KDoc). - */ - Ep.NNAPI_SPLIT -> { - addNnapi() - cpuNodeNames?.let { addConfigEntry(LAYER_ASSIGNMENT, "cpu($it)") } - } - - // ⚠️ 권장 설정이 **아니다**. 바깥 `configure()` 가 ORT 풀에 4스레드를 거는데 XNNPACK 은 - // 자기 풀이 따로라 경합한다. 비교 기준으로만 둔다 — 제대로 건 것은 [Ep.XNNPACK_TUNED]. - Ep.XNNPACK -> addXnnpack(emptyMap()) - - // ORT 문서 권장: ORT 풀은 1, XNNPACK 풀에 코어 수, intra-op 스핀 끄기. - // 「XNNPACK has a separate internal threadpool which can lead to contention with - // the ORT intra-op threadpool」 - Ep.XNNPACK_TUNED -> { - setIntraOpNumThreads(1) - addConfigEntry(INTRA_OP_SPINNING, "0") - addXnnpack(mapOf("intra_op_num_threads" to XNNPACK_THREADS.toString())) - } - - // 퀄컴 HTP 계열. 분기가 여섯이고 KDoc 이 길어 따로 뺐다 — 여기서 복잡도가 샜다. - else -> applyQnnEp(env, ep, cache, cpuNodeNames) - } - - /** - * 퀄컴 HTP 계열 분기. [applyEp] 에서 떼어냈다 — 여섯 갈래에 각각 긴 사정이 붙어 - * 한 함수에 두면 읽기도 어렵고 복잡도 한계도 넘는다. - */ - private fun OrtSession.SessionOptions.applyQnnEp(env: OrtEnvironment, ep: Ep, cache: File, cpuNodeNames: String?) = - when (ep) { - // 퀄컴 HTP. 기본 설정만 — 옵션은 [qnnBaseOptions] 가 공통으로 깐다. - Ep.QNN -> addQnn(env, emptyMap()) - - /* - * **HTP 를 fp32 로 묶는다** — 각인이 QNN 에서 틀리는 이유를 가르는 대조군이다. - * - * ⚠️ **지금은 [Ep.QNN] 과 같은 설정이다.** 기본값에 기대지 않으려고 [qnnBaseOptions] 가 - * `0` 을 명시하게 바꿨기 때문이다. fp16 대조는 [Ep.QNN_FP16] 과 해야 한다. - * - * 아래 표는 바꾸기 전, [Ep.QNN] 이 기본값(문서상 `1`)으로 돌던 2026-10-13 Adreno 740 측정이다. - * - * | | CPU | QNN | - * |---|---|---| - * | 각인 | 4206ms · **YS** | 418ms · **null** | - * | 마크 | 3743ms · 정답 | 253ms · 정답 | - * - * 즉 **빠르지만 각인만 답을 잃는다.** AI Hub 에서 같은 모델이 87.3% 일치였고, TPS - * 격자만 fp32 로 남긴 변형이 99.6% 로 올라갔다 — 격자가 fp16 에 민감한 것이다. - * 여기서 fp32 로 묶어 **그 설명이 맞는지**, 그리고 묶고도 CPU 보다 빠른지를 본다. - */ - Ep.QNN_FP32 -> addQnn(env, mapOf("enable_htp_fp16_precision" to "0")) - - /* - * **fp16 을 명시로 켠다.** [Ep.QNN_FP32] 의 반대쪽이고, 둘 중 하나는 기본값과 같다. - * - * ⚠️ 기본값이 문서에 따라 갈린다 — ORT 본가 문서는 `1`, 이 플러그인의 저장소 - * (`onnxruntime-qnn`) 문서는 `0` 이라고 적는다. 그래서 **양쪽을 다 명시로** 재야 - * 기본값이 무엇인지와 fp16 이 점수에 영향을 주는지를 같이 가린다. - * - * 2026-10-13 에 이 축을 빼고 「기본」과 「=0」만 재서 **같은 설정을 두 번 재고 - * 「fp16 은 원인이 아니다」로 잘못 결론**했다. - */ - Ep.QNN_FP16 -> addQnn(env, mapOf("enable_htp_fp16_precision" to "1")) - - /* - * **STN 만 CPU 에 남기고 나머지를 HTP 에 준다** — 각인 오차의 **발원지**를 피한다. - * - * 단계별 측정이 자리를 찍어 줬다(`scratchpad/qnn_stage.py`, Adreno 740 계열 SM8550). - * - * | 단계 | CPU 대비 상대오차 | - * |---|---| - * | ① STN 격자(GridSample 좌표) | 2.5% | - * | ② **STN 출력(재샘플링 이미지)** | **18.2%** ← 한 연산에서 7배 | - * | ③ CNN 특징 | 21.4% | - * | ④ 어텐션 출력(LSTM 입력) | 21.2% | - * - * 좌표는 2.5% 만 틀리는데 **재샘플링 결과가 18.2%** 다. CLAHE 를 거친 각인 패치는 - * 글자 경계가 날카로워서 샘플링 좌표가 조금 밀리면 픽셀값이 크게 바뀐다 — 오차가 - * 더해지지 않고 **곱해지는** 자리다. 그 뒤로는 안 자란다(18.2 → 21.4 → 21.2%). - * - * 그래서 [Ep.QNN_RNN_CPU] 가 아무 효과도 없었다 — LSTM 은 증폭기가 아니었다. - * `/stn/` 은 350 노드 중 74개다. - * - * 기기 없이 검증했다(앞 74노드는 로컬 CPU, 뒤 276노드는 AI Hub 실기기 QNN). - * - * | | 점수 | 채택 | 로짓 PSNR | 상대오차 | - * |---|---|---|---|---| - * | 전부 CPU(기준) | 0.9774 | `YS` | — | — | - * | **STN 만 CPU** | 0.9769 | **`YS`** | **64.34dB** | **0.474%** | - * | 전부 QNN | 0.9202 | `null` | 37.92dB | 9.931% | - * - * ## ⚠️ 이 표로 「안전하다」고 말할 수 없다 — **표본이 한 장이다** - * 두 열의 근거가 다르다. 섞어 읽으면 안 된다. - * - **PSNR·상대오차는 n=1 이 아니다.** 한 번의 순전파에서 나온 로짓 - * 144×32×37 = **170,496 개**를 원소별로 맞댄 값이다. 「오차가 어디서 나고 - * `cpu(/stn/)` 이 그걸 21배 줄인다」는 이 열이 받친다 - * - **점수·채택은 n=1 이다.** 알약 한 개, 각인 하나(`YS`), 임계 한 번 넘기다. - * 「QNN 으로 바꿔도 채택률이 안 떨어진다」는 **전혀 재지 않았다** - * - * 하필 이 표본은 **경계에서 멀다** — CPU 점수 0.9774 로 임계 0.949 보다 0.028 위다. - * 정작 위험한 것은 CPU 가 0.9495 쯤인 알약이고, 거기서는 0.474% 잔차로도 뒤집힌다. - * 그 비율은 모른다. - * - * 이 저장소 각인 고정물은 `sample_crop.png` **한 장뿐**이라(나머지 `.bin` 은 같은 - * 알약의 중간 단계다) 여기서 더 할 수 있는 것이 없다. **0.949 를 「감사셋 정밀도 90% - * 지점」으로 잡은 그 감사셋**을 CPU · QNN · QNN+`cpu(/stn/)` 세 경로로 돌려 - * 채택률과 정밀도를 비교해야 한다 — ML 쪽 일이고, 돌릴 하네스는 - * `scratchpad/qnn_stn_cpu.py` 에 있다. - */ - // ⚠️ **지금 이 분기는 [Ep.QNN] 과 같다.** 331면 전수에서 점수가 **331/331 동일**하게 - // 나왔다 — `session.name_based_layer_assignment` 가 플러그인 EP(`addExecutionProvider`) - // 경로에는 적용되지 않는 것으로 보인다. WebGPU·NNAPI 는 ORT 안에 박힌 EP 라 먹는다. - // 각인이 전수에서 쓸 만하게 나왔으므로(위 표) 급한 축은 아니다. 고치려면 QNN - // 제공자 옵션 쪽(`qnn_subgraphs` 등)을 봐야 한다. - Ep.QNN_STN_CPU -> { - addQnn(env, emptyMap()) - addConfigEntry(LAYER_ASSIGNMENT, "cpu($STN_PREFIX)") - } - - /* - * **LSTM 을 CPU 에 남기고 conv 만 HTP 에 준다** — 각인이 QNN 에서 답을 잃는 이유의 - * 두 번째 가설이다. - * - * 첫 가설은 fp16 이었고 **틀렸다** — `enable_htp_fp16_precision=0` 으로 묶어도 답이 - * 그대로 `null` 이고 시간도 418 → 435ms 로 거의 안 변했다(2026-10-13 Adreno 740). - * - * 남은 용의자가 양방향 LSTM 이다. 근거가 둘 있다. - * - **LiteRT 는 이 모델을 아예 못 열었다** — CPU 포함 전 백엔드 `Failed to load - * model from file`. 마크·검출은 열렸다. LSTM 이 변환기를 막는다는 뜻이다 - * - WebGPU 도 통째로는 9943ms 였고 **LSTM 을 CPU 에 고정해서 1796ms** 가 됐다 - * ([ImprintReader] KDoc). 같은 경계가 QNN 에도 있을 수 있다 - * - * 마크가 QNN 에서 **정답**인 것이 이 가설을 받친다 — 마크엔 LSTM 이 없다. - * - * ⚠️ **기각됐다.** 단계별 측정에서 오차의 발원지는 STN 재샘플링이었고 이 분기는 효과가 - * 없었다 — 위 [Ep.QNN_STN_CPU] 표 참고. 비교용으로만 남긴다. - */ - Ep.QNN_RNN_CPU -> { - addQnn(env, emptyMap()) - cpuNodeNames?.let { addConfigEntry(LAYER_ASSIGNMENT, "cpu($it)") } - } - - /* - * **컴파일 결과를 캐시한다** — 84MB `libQnnHtpPrepare.so` 를 운영에서 뺄 수 있는지가 - * 여기에 달려 있다. - * - * QNN 은 ONNX 그래프를 HTP 명령으로 **기기에서 컴파일**한다(그 일을 하는 것이 - * `HtpPrepare` 다). `ep.context_enable` 을 켜면 그 결과를 `ep.context_file_path` 에 - * EPContext 모델로 써 두고 다음부터 **컴파일을 건너뛴다.** - * - * ⚠️ **생성과 사용이 다른 호출이다.** `ep.context_enable` 은 **쓰기만** 한다. 적중을 - * 받으려면 그렇게 만들어진 컨텍스트 모델을 **파일로 직접 열어야** 한다 — - * [contextCacheFile] 이 그 경로고, 파일이 이미 있으면 [openSession] 이 그쪽을 연다. - * 2026-10-13 첫 측정에서 원본 ONNX 를 다시 열어 둘째 세션도 86초였다. - */ - Ep.QNN_CACHED -> { - // ⚠️ **생성을 켜는 것은 캐시가 없을 때만이다.** 이미 컨텍스트 모델을 열면서 - // 또 켜면 ORT 가 거절한다 — `Failed to generate EP context model since the - // file … exists already`(2026-10-13 실측). - if (contextModelOrNull(ep, cache) == null) { - // ⚠️ **세션 설정이다, EP 제공자 옵션이 아니다.** `addExecutionProvider` 에 - // 넘기면 조용히 무시된다 — 그래서 한 번은 캐시가 아예 안 생겼다. - addConfigEntry(EP_CONTEXT_ENABLE, "1") - // 컴파일 바이너리를 ONNX 안에 품지 않고 옆 파일로 뺀다. 각인 것이 27.9MB 다. - addConfigEntry(EP_CONTEXT_EMBED_MODE, "0") - // ⚠️ **모델마다 다른 파일**이어야 한다. 하나로 두면 먼저 돈 모델의 컴파일 - // 결과를 다음 모델이 읽는다 — orchestrator 가 프로세스는 새로 띄우지만 - // `cacheDir` 은 그대로라 파일이 남는다. - addConfigEntry(EP_CONTEXT_FILE_PATH, cache.absolutePath) - } - addQnn(env, emptyMap()) - } - - // [applyEp] 가 QNN 계열만 넘긴다. 나머지는 거기서 이미 갈렸다. - else -> error("QNN 계열이 아닌 EP 가 넘어왔다: $ep") - } - - /** - * QNN 플러그인 EP 를 세션에 건다. - * - * 다른 EP 와 거는 방식이 다르다. `addNnapi()` 처럼 ORT 안에 박힌 EP 가 아니라 **따로 배포되는 - * `.so`** 라서, 먼저 환경에 라이브러리를 등록하고([ensureQnnRegistered]) 그렇게 생긴 - * **EP 디바이스 목록**을 세션에 넘긴다. - * - * 디바이스가 비면 **던진다**. 이 경로는 측정용이고, 조용히 CPU 로 돌면 「QNN 234ms」 같은 - * 값을 CPU 숫자로 적게 된다 — 엑시노스에서 NNAPI 가 실제로 그렇게 속였다(최대차 0.0 · 배율 1.00). - */ - private fun OrtSession.SessionOptions.addQnn(env: OrtEnvironment, options: Map) { - ensureQnnRegistered(env) - val devices = env.epDevices.filter { it.epName == qnnEpName() } - require(devices.isNotEmpty()) { - "QNN EP 디바이스가 없다 — 이 기기에 HTP 가 없거나 백엔드 .so 를 못 찾았다. " + - "보이는 EP 디바이스: ${env.epDevices.map { "${it.epName}/${it.device.type}" }}" - } - Log.i(TAG, "QNN 디바이스 ${devices.map { it.device.type }} · 옵션 ${options.keys}") - addExecutionProvider(devices, qnnBaseOptions() + options) - } - - /** - * 환경에 플러그인 `.so` 를 등록한다 — **환경당 한 번만** 된다(두 번째는 던진다). - * - * [OrtEnvironment] 는 프로세스에 하나라, orchestrator 가 메서드마다 프로세스를 새로 띄우는 - * 지금 구조에서는 사실상 테스트당 한 번이다. - */ - @Synchronized - private fun ensureQnnRegistered(env: OrtEnvironment) { - // 이 설치본에 `:qnn` feature module 이 없으면 여기서 끊어 **무엇이 없는지** 말한다 — - // 그냥 두면 NoClassDefFoundError 가 한 칸 더 안쪽에서 터져 읽기 어렵다. - check(QNN_BUNDLED) { - "QNN feature module 이 이 설치본에 없다 — Play 기기그룹에 안 맞는 기기이거나 base 만 설치됐다" - } - if (qnnRegistered) return - env.registerExecutionProviderLibrary(qnnEpName(), qnnLibraryPath()) - qnnRegistered = true - Log.i(TAG, "QNN 플러그인 등록 — ${qnnLibraryPath()} · EP 디바이스 ${env.epDevices.size}개") - } - - /** 두 번 등록하면 ORT 가 던진다. 검출·각인·마크가 동시에 열 수 있어 [ensureQnnRegistered] 를 잠근다. */ - @Volatile - private var qnnRegistered = false - - /** - * [Ep.QNN_CACHED] 가 EPContext 모델을 둘 **디렉터리**. 테스트가 쓰기 가능한 곳으로 채운다 — - * `null` 이면 ORT 가 모델 옆에 쓰려 하는데, adb 로 밀어 넣은 자리는 앱에 쓰기 권한이 없을 수 있다. - */ - internal var contextCacheDir: File? = null - - /** - * [Ep.QNN_CACHED] 이고 컨텍스트 모델이 **이미 있으면** 그 파일. 그 밖에는 `null`. - * - * 컨텍스트 모델은 원본과 같은 입출력을 갖는 ONNX 인데 그래프 자리에 **컴파일된 HTP - * 바이너리를 참조하는 노드 하나**가 들어 있다. 그래서 원본 대신 이것을 열면 컴파일을 건너뛴다. - */ - private fun contextModelOrNull(ep: Ep, cache: File): File? { - if (ep != Ep.QNN_CACHED) return null - return cache.takeIf { it.isFile && it.length() > 0 } - } - - /** EPContext 생성을 켜는 **세션 설정** 키. ORT 의 `kOrtSessionOptionEpContextEnable`. */ - private const val EP_CONTEXT_ENABLE = "ep.context_enable" - - /** `0` 이면 컴파일 바이너리를 ONNX 안에 품지 않고 옆 파일로 뺀다. */ - private const val EP_CONTEXT_EMBED_MODE = "ep.context_embed_mode" - - /** 생성될 컨텍스트 모델의 경로. 이 경로를 **다음에 직접 열어야** 적중이다. */ - private const val EP_CONTEXT_FILE_PATH = "ep.context_file_path" - - /** - * 모델 하나당 캐시 파일 하나. 디렉터리를 안 주면 모델 옆이다(ORT 기본과 같다). - * - * 이름에 **원본의 크기·수정 시각**을 넣는다 — 같은 파일명으로 모델을 바꿔 끼우면 옛 HTP - * 그래프를 그대로 집어 들어 이전 모델을 잰다. 생성이 중간에 끊겨 남은 반쪽 파일은 여전히 - * 거르지 못한다(크기 > 0 만 본다) — 그때는 캐시 디렉터리를 비운다. - */ - private fun contextCacheFile(modelFile: File, tag: String): File { - val stamp = "${modelFile.length()}-${modelFile.lastModified()}" + if (tag.isEmpty()) "" else "-$tag" - val name = "${modelFile.name.substringBeforeLast('.')}.$stamp.ctx.onnx" - return File(contextCacheDir ?: modelFile.parentFile, name) - } - - /** - * `libQnnHtp.so` 가 **실파일로** 놓인 디렉터리 — 보통 `applicationInfo.nativeLibraryDir`. - * - * ## 왜 경로를 받아야 하나 — `backend_type` 만으로는 안 된다 - * 2026-10-13 Adreno 740·750 에서 첫 측정이 **CPU 와 같은 값**을 냈다(각인 4349ms, AI Hub 는 - * 234ms). logcat 이 이유를 그대로 말했다. - * - * ``` - * W qnn_backend_manager.cc:332 Setting ADSP_LIBRARY_PATH = ← 비어 있다 - * E cannot open libQnnHtpV73Skel.so, errno 2 (no such file or dir) - * E QNN SetupBackend failed … QNN_DEVICE_ERROR_INVALID_CONFIG - * ``` - * - * HTP 는 **DSP 쪽에서 도는 skel** 을 FastRPC 로 올린다. 그 skel 을 찾는 환경변수가 - * `ADSP_LIBRARY_PATH` 인데, ORT 는 그 값을 **`backend_path` 의 디렉터리에서 만든다.** - * `backend_type=htp` 만 주면 경로가 없어 빈 문자열이 되고, DSP 는 아무것도 못 찾는다. - * 그러면 `GetCapability` 가 실패해 EP 가 **노드를 하나도 안 가져가고** 전부 CPU 로 돈다 — - * 세션은 열리고 답도 맞아서 **겉보기엔 성공**이다. 느린 것만이 증거였다. - */ - internal var qnnNativeLibDir: File? = null - - /** - * 모든 QNN 세션에 공통으로 거는 것. - * - * `burst` 는 추론 동안 DVFS 를 최대로 묶는다 — 우리 추론은 짧고 띄엄띄엄 들어와서, 묶지 - * 않으면 클럭이 올라오기 전에 끝난다. - */ - private fun qnnBaseOptions(): Map { - val dir = requireNotNull(qnnNativeLibDir) { "qnnNativeLibDir 을 안 줬다 — applicationInfo.nativeLibraryDir" } - val backend = File(dir, "libQnnHtp.so") - // ⚠️ **실파일이어야 한다.** `useLegacyPackaging=false` 면 `.so` 가 APK 안에만 있어서 - // dlopen 은 되지만 cDSP 는 `apk!/lib/...` 를 열 수 없다. 그 경우 여기서 걸린다. - require(backend.isFile) { "libQnnHtp.so 가 실파일로 없다: $backend — useLegacyPackaging 을 보라" } - return mapOf( - "backend_path" to backend.absolutePath, - "htp_performance_mode" to "burst", - // ⚠️ **기본값에 기대지 않는다.** 이 키의 기본값을 ORT 본가 문서는 `1`, 이 플러그인 - // 저장소(`onnxruntime-qnn`)는 `0` 으로 적어 **서로 다르다.** 비워 두면 어느 정밀도로 - // 잰 값인지 기록이 못 된다 — 2026-10-13 에 「기본」과 「=0」을 비교해 놓고 - // 같은 설정을 두 번 잰 적이 있다. [Ep.QNN_FP16] 이 이 값을 덮는다. - "enable_htp_fp16_precision" to "0" - ) - } - - /** - * 노드 이름 조각으로 배정을 강제하는 **공식 설정 키**. - * - * WebGPU EP 전용 옵션 `ep.webgpuexecutionprovider.forceCpuNodeNames` 도 있는데 **안 먹는다** - * (각인에서 11715 ms — 고정이 아예 안 됐다). 그쪽은 정확한 노드 이름 목록을 받는 것으로 보이고, - * 이 키가 부분 문자열로 맞춘다. - */ - private const val LAYER_ASSIGNMENT = "session.name_based_layer_assignment" - - /** - * 모델 입력의 **배치 차원 심볼 이름**. 각인·마크가 같은 내보내기 스크립트에서 나와 둘 다 이 이름이다 - * (`image: [batch, …]`). 검출은 `[1,3,576,576]` 로 고정이라 해당 없다. - * - * 세션을 열 때 `setSymbolicDimensionValue(BATCH_DIM, N)` 으로 못박아야 QNN 이 그래프를 받는다 — - * 이유는 [ImprintReader] 의 그 호출 자리에 적어 뒀다. - */ - internal const val BATCH_DIM = "batch" - - /** 공간 변환기(STN) 노드 이름의 접두어. [Ep.QNN_STN_CPU] 가 이걸로 CPU 에 고정한다. */ - private const val STN_PREFIX = "/stn/" - - private const val TAG = "NM534" - - /** ORT intra-op 풀의 스핀 대기를 끄는 공식 설정 키. XNNPACK 권장 설정의 한 축이다. */ - private const val INTRA_OP_SPINNING = "session.intra_op.allow_spinning" - - /** - * XNNPACK 자기 풀의 스레드 수. 문서는 「물리 코어 수」를 권하는데, 이 저장소는 이미 4가 - * 최적임을 쟀다(`ImprintReaderBenchmark`: 1스레드 13345 · 2스레드 6765 · **4스레드 4124** · - * 6스레드 6939 · 8스레드 8059 ms). CPU 기준선과 같은 값이라 비교도 공정하다. - */ - private const val XNNPACK_THREADS = 4 -} - -/** - * 계측 테스트가 못박을 수 있는 실행 공급자. - * - * 앞 일곱은 프리빌트 `onnxruntime-android` 에 들어 있고, `QNN*` 셋은 **따로 배포되는 플러그인** - * (`com.qualcomm.qti:onnxruntime-android-qnn`)이 더해 주는 것이다 — 스냅드래곤에서만 성립한다. - */ -internal enum class Ep { - CPU, - WEBGPU, - NNAPI, - NNAPI_NO_CPU, - NNAPI_SPLIT, - XNNPACK, - XNNPACK_TUNED, - QNN, - QNN_FP32, - QNN_FP16, - QNN_STN_CPU, - QNN_RNN_CPU, - QNN_CACHED -} diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/PillDetector.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/PillDetector.kt index 495e9d33..ef21dea2 100644 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/PillDetector.kt +++ b/core/vision/src/main/kotlin/app/nursemate/core/vision/PillDetector.kt @@ -1,13 +1,8 @@ package app.nursemate.core.vision -import ai.onnxruntime.OnnxTensor -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.OrtLoggingLevel -import ai.onnxruntime.OrtSession import android.graphics.Bitmap import java.io.Closeable import java.io.File -import java.nio.FloatBuffer import kotlin.math.ceil import kotlin.math.floor import kotlin.math.roundToInt @@ -21,7 +16,7 @@ data class Timings( val decodeImageMs: Long, val preprocessMs: Long, val inferenceMs: Long, - /** 출력 읽기 + 디코딩 + 크롭. ONNX 출력을 JVM으로 가져오는 비용이 여기 포함된다. */ + /** 디코딩 + 크롭. */ val postprocessMs: Long ) { val totalMs: Long get() = decodeImageMs + preprocessMs + inferenceMs + postprocessMs @@ -45,48 +40,36 @@ data class DetectionResult( ) /** - * RF-DETR-Seg 온디바이스 검출기 (ONNX Runtime). + * RF-DETR-Seg 온디바이스 검출기 (LiteRT, NM-628). * - * 모델은 iOS가 쓰는 CoreML(`.mlpackage`)을 만든 **바로 그 원본 그래프**다. 입출력 이름이 - * CoreML과 동일하고(`image` / `pred_logits` / `pred_boxes` / `pred_masks`), - * CoreML 결과와 박스 IoU 1.0000으로 일치한다. + * 모델은 iOS 가 쓰는 CoreML(`.mlpackage`)을 만든 원본 그래프를 LiteRT 로 옮긴 것이다(가중치 fp16 저장 · + * `rfdetr_seg_small_f16w.tflite`). ONNX 시절과 입출력 **배치가 다르다**. * - * 세션 로드가 수백 ms 걸리므로 한 번만 만들고 재사용한다. + * | | ONNX(이전) | LiteRT | + * |---|---|---| + * | 입력 | [1,3,576,576] NCHW | [1,576,576,3] **NHWC** | + * | 마스크 | [1,100,144,144] 쿼리가 앞 | [1,144,144,100] **쿼리가 마지막 축** | * - * ## 실행 백엔드는 WebGPU, 없으면 CPU (NM-534) - * NM-396에서 가속 경로를 전부 재 봤다(Galaxy S24 / Exynos 2400, fp32). - * ``` - * CPU 1550 ms - * XNNPACK 3410 ms (오히려 느림) - * NNAPI 실패 (Android 15에서 deprecated된 API이기도 하다) - * WebGPU 845 ms - * ``` - * 이 모델이 Conv 1.4% · MatMul 13%인 Transformer라 가속기 이득이 구조적으로 제한되는데, - * 그런데도 WebGPU가 유일하게 살아남은 경로다. + * 전처리는 NCHW 로 써 두고([RfDetrPreprocess] · 그 단위 테스트 그대로) 넣기 직전에 돌린다. * - * ⚠️ **당시에는 채택하지 않았다** — 프리빌트 Maven 배포본에 EP가 없어 11 MB 커스텀 AAR을 - * 저장소에 넣고 minSdk를 28로 올려야 했다. **공식 `onnxruntime-android` 1.30.0부터는 들어 - * 있다**(ABI 4개 전부 · minSdk 24). 저장소가 1.22.0에 머물러 있었을 뿐이다. - * ORT 1.30 재측정은 CPU 1572 ms / WebGPU 813 ms다. 세션 여는 일은 [OrtBackend]가 한다. + * ## 실행: GPU FP32, 안 되면 CPU + * ML 계약. FP16 은 Exynos 2500 에서 개수 일치 93.3% 로 탈락했고 2400 · 2600 도 여유가 1~2장뿐이었다. + * FP32 로 공식 세트 60장 개수 일치 **98.3%**(가중치 fp16 저장 탓 1장), 466~942ms/장(Exynos 2600 ~ SD 8 Gen 1). + * + * 모델 열기가 수백 ms~수 초 걸리므로 한 번만 열고 재사용한다. */ -class PillDetector(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { - - private val env: OrtEnvironment = OrtEnvironment.getEnvironment() +class PillDetector(modelFile: File) : Closeable { - private val session: OrtSession = OrtBackend.openSession(env, modelFile) { - setIntraOpNumThreads(threads) - setOptimizationLevel(OrtSession.SessionOptions.OptLevel.ALL_OPT) - // ⚠️ VERBOSE는 디스패치마다 로그를 찍어 성능을 크게 왜곡한다. 측정할 일이 있어 - // 노드 배정을 봐야 한다면 그때만 올리고, 그때 잰 시간은 믿지 말 것. - setSessionLogLevel(OrtLoggingLevel.ORT_LOGGING_LEVEL_WARNING) - } + private val model = LiteRtModel.open(modelFile, PLAN) - private val inputName: String = session.inputNames.first() + /** 실제로 GPU 로 열렸는가 — 대체로 CPU 가 됐는지 테스트 · 진단이 본다. */ + internal val onGpu: Boolean get() = model.onGpu - /** 전처리 출력 버퍼(4 MB). 매 추론마다 재할당하지 않는다. */ - private val inputBuffer = FloatArray(3 * RfDetrSpec.INPUT_SIZE * RfDetrSpec.INPUT_SIZE) + /** 전처리 출력(NCHW) · 모델 입력(NHWC). 4 MB 씩, 매 추론마다 재할당하지 않는다. */ + private val nchw = FloatArray(3 * RfDetrSpec.INPUT_SIZE * RfDetrSpec.INPUT_SIZE) + private val nhwc = FloatArray(nchw.size) - /** [inputBuffer]를 공유하므로 동시 호출을 직렬화한다. */ + /** 버퍼와 모델을 공유하므로 동시 호출을 직렬화한다. */ private val lock = Mutex() /** @@ -102,29 +85,19 @@ class PillDetector(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable val height = bitmap.height val t0 = System.nanoTime() - RfDetrPreprocess.toInputTensor(bitmap.toRgb888(), width, height, inputBuffer) + RfDetrPreprocess.toInputTensor(bitmap.toRgb888(), width, height, nchw) + val side = RfDetrSpec.INPUT_SIZE + nchwToNhwc(nchw, nhwc, n = 1, c = 3, plane = side * side) val t1 = System.nanoTime() - val shape = longArrayOf( - 1, - 3, - RfDetrSpec.INPUT_SIZE.toLong(), - RfDetrSpec.INPUT_SIZE.toLong() - ) - - var inferenceEnd: Long - val pills: List - OnnxTensor.createTensor(env, FloatBuffer.wrap(inputBuffer), shape).use { input -> - session.run(mapOf(inputName to input)).use { result -> - inferenceEnd = System.nanoTime() - - val logits = result.readFloats(RfDetrSpec.OUTPUT_LOGITS, RfDetrSpec.QUERY_COUNT * 2) - val boxes = result.readFloats(RfDetrSpec.OUTPUT_BOXES, RfDetrSpec.QUERY_COUNT * 4) - val detections = RfDetrPostprocess.decode(logits, boxes) + val outputs = model.run(nhwc) + val inferenceEnd = System.nanoTime() - pills = cropDetections(bitmap, detections, result) - } - } + // 출력은 크기로 가른다 — 셋이 서로 다르고, 이름보다 변환 도구에 덜 흔들린다. + val logits = outputs.first { it.size == RfDetrSpec.QUERY_COUNT * 2 } + val boxes = outputs.first { it.size == RfDetrSpec.QUERY_COUNT * 4 } + val masks = outputs.first { it.size == RfDetrSpec.QUERY_COUNT * MASK_PLANE } + val pills = cropDetections(bitmap, RfDetrPostprocess.decode(logits, boxes), masks) val postprocessEnd = System.nanoTime() return DetectionResult( @@ -141,27 +114,14 @@ class PillDetector(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable } /** - * 검출별로 마스크를 꺼내 낱알을 오려낸다. - * - * ⚠️ **`pred_masks`는 반드시 [OnnxTensor.getFloatBuffer]로 읽어야 한다.** - * `[1,100,144,144]` = 207만 float인데, `OnnxValue.getValue()`로 꺼내면 중첩 배열로 박싱되어 - * **1.2초**가 든다(스파이크에서 이걸 추론 시간으로 오인한 적이 있다). 버퍼로 읽고 - * **임계값을 통과한 쿼리의 슬라이스만** 복사하면 검출 개수에 비례하는 비용만 낸다. + * 검출별로 마스크를 꺼내 낱알을 오려낸다. 마스크는 `[144,144,100]` — 한 화소에 쿼리 100개가 붙어 있어 + * 쿼리 q 의 평면은 `(y·144 + x)·100 + q` 를 건너뛰며 모은다. 검출된 쿼리만 모으므로 비용은 검출 개수에 비례한다. */ - private fun cropDetections( - source: Bitmap, - detections: List, - result: OrtSession.Result - ): List { + private fun cropDetections(source: Bitmap, detections: List, masks: FloatArray): List { if (detections.isEmpty()) return emptyList() - - val masks = result.tensor(RfDetrSpec.OUTPUT_MASKS).floatBuffer - val plane = RfDetrSpec.MASK_SIZE * RfDetrSpec.MASK_SIZE - val slice = FloatArray(plane) - + val slice = FloatArray(MASK_PLANE) return detections.mapNotNull { detection -> - masks.position(detection.query * plane) - masks.get(slice) + querySlice(masks, detection.query, slice) val bounds = RfDetrPostprocess.maskBounds(slice) ?: return@mapNotNull null val crop = cropWithMask(source, slice, bounds) ?: return@mapNotNull null DetectedPill(detection, crop) @@ -216,28 +176,33 @@ class PillDetector(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable } override fun close() { - session.close() + model.close() } companion object { + /** 가중치 fp16 저장 · 63MB. 목록과 해시는 `app/models.md5`. */ + const val MODEL_FILE_NAME = "rfdetr_seg_small_f16w.tflite" + /** - * 실측에서 4스레드가 최적이었다 — 1스레드 6968 ms · 2스레드 3615 ms · 4스레드 2083 ms. - * 6·8스레드는 오히려 느려졌다(big.LITTLE에서 리틀코어로 넘치는 비용). + * ML 실행 정밀도 계약 — GPU FP32. FP16 은 Exynos 2500 에서 탈락했다. + * + * ⚠️ **GPU 만이 아니라 GPU+CPU 로 연다.** GPU 만으로는 S24(Exynos 2400)에서 `Failed to compile model` + * 로 열리지 않았다(2026-10-19). ML 벤치도 단일 파일 모델을 GPU+CPU(`gpucpu32`)로 열어 잰 것이다. */ - const val DEFAULT_THREADS = 4 + private val PLAN = RunPlan(Placement.GPU_CPU, GpuPrecision.FP32) - /** fp32. 119 MB라 APK에 넣지 않는다 — 배포 방식은 별도 결정 사항이다. */ - const val MODEL_FILE_NAME = "rfdetr_seg_small.onnx" + private const val MASK_PLANE = RfDetrSpec.MASK_SIZE * RfDetrSpec.MASK_SIZE } } -private fun OrtSession.Result.tensor(name: String): OnnxTensor = - get(name).orElseThrow { IllegalStateException("모델 출력 '$name' 을 찾지 못했습니다") } as OnnxTensor - -private fun OrtSession.Result.readFloats(name: String, size: Int): FloatArray { - val out = FloatArray(size) - tensor(name).floatBuffer.get(out) - return out +/** `[H·W, Q]` 로 놓인 마스크에서 쿼리 [query] 의 평면 `[H·W]` 를 [out] 에 모은다. */ +internal fun querySlice(masks: FloatArray, query: Int, out: FloatArray) { + val queries = RfDetrSpec.QUERY_COUNT + var i = query + for (p in out.indices) { + out[p] = masks[i] + i += queries + } } /** ARGB_8888 비트맵 → RGB888 연속 바이트. [RfDetrPreprocess]가 요구하는 형식. */ diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/QnnPluginEp.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/QnnPluginEp.kt deleted file mode 100644 index 489f3e56..00000000 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/QnnPluginEp.kt +++ /dev/null @@ -1,86 +0,0 @@ -package app.nursemate.core.vision - -import java.io.File - -/** - * QNN 플러그인 EP 가 **지금 이 설치본에 들어 있는지.** - * - * ## 왜 런타임에 묻나 - * QNN 런타임은 base 가 아니라 **조건부 전달 feature module(`:qnn`)** 에 있다. arm64 비압축 - * 180MB 라 전 기기에 내려보낼 수 없고, Hexagon NPU 가 없는 기기에는 한 바이트도 쓸모가 없다. - * Play 가 `system-on-chip` 기기그룹을 보고 **맞는 기기에만** 설치한다. - * - * 그래서 base 코드에서는 클래스가 있을 수도 없을 수도 있다. `core:vision` 은 플러그인을 - * `compileOnly` 로 물어 컴파일만 하고, 실제 존재 여부는 여기서 한 번 확인한다. - * - * ## 왜 `SplitInstallManager` 가 아닌가 - * 설치 시점 조건부 전달이라 앱이 뜬 뒤에 받아 올 일이 없다 — 있으면 처음부터 있고, 없으면 - * 영영 없다. 클래스가 로드되는지 보는 쪽이 Play Core 의존성 없이 같은 답을 준다. - * - * ⚠️ **없을 때 조용히 CPU 로 되돌리지 않는다.** 그러면 「QNN 418ms」 같은 값을 CPU 숫자로 - * 적게 된다 — 엑시노스에서 NNAPI 가 실제로 그렇게 속였다(최대차 0.0 · 배율 1.00). - * 쓸지 말지는 부르는 쪽이 이 값을 보고 **미리** 정한다. - */ -internal val QNN_BUNDLED: Boolean by lazy { - runCatching { Class.forName(QNN_PLUGIN_MARKER_CLASS) }.isSuccess -} - -/** - * 플러그인 artifact 가 들고 있는 유일한 클래스. `getEpName()`·`getLibraryPath()` 가 여기 있다. - * - * ⚠️ 문자열로 적는 자리라 artifact 를 올려 이름이 바뀌어도 컴파일이 안 깨진다. 올릴 때는 - * `DeviceProbeTest` 의 QNN 줄이 「등록 실패」로 바뀌는지 본다. - */ -private const val QNN_PLUGIN_MARKER_CLASS = "ai.onnxruntime.qnnpluginep.QnnPluginEpLibraryKt" - -/** - * 이 설치본에 QNN 이 **어디까지** 내려왔는가 — NM-603 관측용. - * - * QNN 은 모듈 둘이 짝이다. `qnn_core`(플러그인 클래스 + 토대 `.so`)는 퀄컴 그룹 전부에, 세대 - * 모듈(`qnn_v##`, 그 세대 Skel)은 자기 그룹에만 간다. 둘 중 하나만 있으면 QNN 은 못 뜬다. - * - * | 값 | 뜻 | - * |---|---| - * | `core+skel` | 정상 — 기기그룹에 맞았다 | - * | `core_only` | 토대만 왔다 — 세대 모듈 그룹 목록이 `qnn_core` 와 어긋났다 | - * | `skel_only` | 세대만 왔다 — 같은 어긋남의 반대쪽 | - * | `none` | 아무 그룹에도 안 맞았다 — **이 칩을 목록에 안 적었다** | - * - * 「토대가 있다」는 **플러그인 클래스가 로드되고 `libQnnHtp.so` 가 실파일로 있다**는 뜻이다. 둘 중 - * 하나만 보면 패키징이 `.so` 를 떨궜을 때 QNN 이 못 뜨는데도 정상으로 센다. - * - * 퀄컴 기기에서 `none` 이 나오면 그 `SOC_MODEL` 을 `device_targeting_configuration.xml` 에 - * 더할 후보다. - */ -enum class QnnDeliveryState(val label: String) { - CORE_AND_SKEL("core+skel"), - CORE_ONLY("core_only"), - SKEL_ONLY("skel_only"), - NONE("none"); - - companion object { - /** - * @param nativeLibDir `applicationInfo.nativeLibraryDir`. `useLegacyPackaging` 이라 split 의 - * `.so` 도 여기에 실파일로 풀린다(NM-598). - */ - fun of(nativeLibDir: File): QnnDeliveryState = of(nativeLibDir, QNN_BUNDLED) - - /** [QNN_BUNDLED] 를 받는 판정 본체 — JVM 테스트가 클래스 로드 없이 두 경우를 다 본다. */ - internal fun of(nativeLibDir: File, pluginLoaded: Boolean): QnnDeliveryState { - val names = nativeLibDir.list()?.toSet().orEmpty() - val core = pluginLoaded && CORE_LIB in names - val skel = names.any { SKEL_NAME.matches(it) } - return when { - core && skel -> CORE_AND_SKEL - core -> CORE_ONLY - skel -> SKEL_ONLY - else -> NONE - } - } - - private const val CORE_LIB = "libQnnHtp.so" - - /** 세대 Skel — `libQnnHtpV73Skel.so` 꼴. `QnnFeatureConventionPlugin.wantedLibs` 와 같은 이름이다. */ - private val SKEL_NAME = Regex("libQnnHtpV\\d+Skel\\.so") - } -} diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/VisionBackend.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/VisionBackend.kt index 8268b53b..70af6bbb 100644 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/VisionBackend.kt +++ b/core/vision/src/main/kotlin/app/nursemate/core/vision/VisionBackend.kt @@ -1,46 +1,73 @@ package app.nursemate.core.vision /** - * **어느 모델을 WebGPU 로 열지**를 바깥에서 정하게 하는 구멍 — NM-574. + * **어느 모델을 GPU 로 열지**를 바깥에서 정하게 하는 구멍 — NM-574 에서 시작해 NM-628(LiteRT)로 넘어왔다. * * ## 왜 `core:vision` 이 직접 정하지 않나 - * 판단에 필요한 것이 이 모듈 밖에 있다. 기기가 전에 죽은 적이 있는지(DataStore), 어떤 SoC - * 인지, 원격으로 내려온 차단 목록이 있는지 — 전부 `app` 쪽 사정이다. 비전 모듈은 **묻기만** - * 하고 답은 [allowWebGpu] 를 꽂은 쪽이 한다. + * 판단에 필요한 것이 이 모듈 밖에 있다. 기기가 전에 죽은 적이 있는지, 자가 점검에서 틀린 적이 + * 있는지, 어떤 SoC · 드라이버인지 — 전부 `app` 쪽 사정이다. 비전 모듈은 **묻기만** 하고 답은 + * [allowGpu] 를 꽂은 쪽이 한다. * * 꽂지 않으면 늘 허용이다. 계측 테스트와 `core:vision` 단독 사용이 그대로 돈다. * - * ## 왜 이것이 필요한가 — 2026-10-13 - * Adreno 드라이버가 각인 모델을 받다 죽는다. Firebase Test Lab 실기기에서 재현했다. - * - * | 기기 | 결과 | - * |---|---| - * | SM-S916N · Adreno 740 | `vulkan.adreno.so` `vkCmdPipelineBarrier` 에서 **SIGSEGV** | - * | SM-S928N · Adreno 750 | Conv 노드에서 `OrtException`, 이어서 **WebGPU 디바이스 사망** | - * - * 둘 다 [OrtSession.run][ai.onnxruntime.OrtSession.run] 안에서 일어난다. 세션 생성이 아니다 — - * [OrtBackend] 의 `runCatching` 폴백이 **원리적으로 못 잡는 자리**이고, 세그폴트는 예외가 - * 아니라 OS 가 프로세스를 끝내는 것이라 어떤 `catch` 로도 못 막는다. - * - * 그래서 **들어가기 전에 막는 수밖에 없다.** + * ## 왜 들어가기 전에 막나 + * GPU 드라이버가 모델을 받다 **프로세스째 죽는** 기기가 있다(ORT WebGPU 시절 Adreno 740 SIGSEGV — + * 2026-10-13 Test Lab). 세그폴트는 예외가 아니라 OS 가 프로세스를 끝내는 것이라 어떤 `catch` 로도 + * 못 막는다. 그래서 전에 죽은 기기는 다음부터 열기 전에 막는다. */ object VisionBackend { /** - * 이 모델을 WebGPU 로 열어도 되는가. 인자는 모델 **파일 이름**이다 - * (`reader_ep60_s1.onnx` 등 — 각 모델의 `MODEL_FILE_NAME`). + * 이 모델을 GPU 로 열어도 되는가. 인자는 모델 **파일 이름**이다(각인은 조각 파일 이름 — `p3_trunk.tflite` 등). * - * 세션을 **열 때** 묻는다. 세션 하나가 플로우 내내 재사용되므로 추론마다 묻지 않는다. + * 모델을 **열 때** 묻는다. 한 번 연 모델이 플로우 내내 재사용되므로 추론마다 묻지 않는다. */ @Volatile - var allowWebGpu: (modelFileName: String) -> Boolean = { true } + var allowGpu: (modelFileName: String) -> Boolean = { true } /** - * WebGPU 세션이 **실제로 열렸을 때** 불린다. 꽂은 쪽이 디스크에 흔적을 남겨, 이 프로세스가 - * 네이티브로 죽으면 다음 실행에서 알아채게 한다. + * 모델을 GPU 로 **열기 직전**에 불린다. 꽂은 쪽이 디스크에 흔적을 남겨, 이 프로세스가 네이티브로 죽으면 다음 + * 실행에서 알아채게 한다. 열기 전에 부르는 이유는 드라이버가 셰이더 준비(`create`) 중에도 죽기 때문이다. * - * ⚠️ **여기서 오래 걸리면 안 된다.** 세션 생성 경로 한가운데다. + * ⚠️ **여기서 오래 걸리면 안 된다.** 모델 여는 경로 한가운데다. + */ + @Volatile + var onGpuUse: (modelFileName: String) -> Unit = {} + + /** [onGpuUse] 로 알린 GPU 모델을 닫았다(또는 열기 실패 · CPU 대체). 열린 GPU 모델이 없으면 흔적을 지울 수 있다. */ + @Volatile + var onGpuReleased: (modelFileName: String) -> Unit = {} + + /** + * GPU 로 열린 모델이 **실행에서** 실패해 CPU 로 대체했다. 꽂은 쪽이 이 기기 · 이 빌드에서 그 모델을 CPU 에 고정해 + * 다음에 열 때부터 GPU 를 시도하지 않게 한다. */ @Volatile - var onWebGpuSessionOpened: (modelFileName: String) -> Unit = {} + var onGpuRunFailed: (modelFileName: String) -> Unit = {} + + /** + * 모델이 **어느 가속기로** 열렸는지 — 열 때마다 불린다. 운영에서 기기별로 GPU 가 실제로 붙는지 보려는 + * 분석 이벤트가 쓴다(NM-628). [onGpuUse] 와 달리 크래시 판정과 무관하다. GPU 실행 실패로 CPU 로 바뀌었을 때도 한 번 더 + * 불린다([OpenOutcome.GPU_RUN_FAILED]). + */ + @Volatile + var onModelOpened: (modelFileName: String, outcome: OpenOutcome) -> Unit = { _, _ -> } +} + +/** 모델이 실제로 어디서 열렸고, CPU 라면 왜인가. 이름(`label`)은 분석 이벤트 값이다 — 바꾸지 않는다. */ +enum class OpenOutcome(val label: String, val onGpu: Boolean) { + /** 계획대로 GPU. */ + GPU("ok", onGpu = true), + + /** 실행 정밀도 계약이 CPU 다(각인 p2 · p5). */ + PLANNED_CPU("planned_cpu", onGpu = false), + + /** GPU 로 열다 실패해 CPU 로 대체했다 — 드라이버가 모델을 거절했다. */ + GPU_OPEN_FAILED("gpu_open_failed", onGpu = false), + + /** [VisionBackend.allowGpu] 가 막았다 — 전에 네이티브로 죽은 기기 · GPU 실행이 실패해 CPU 에 고정된 모델. */ + GPU_BLOCKED("gpu_blocked", onGpu = false), + + /** GPU 로 열렸는데 실행에서 실패해 CPU 로 다시 열었다. */ + GPU_RUN_FAILED("gpu_run_failed", onGpu = false) } diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/imprint/ImprintReader.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/imprint/ImprintReader.kt index 2a0432bd..73e6e0cc 100644 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/imprint/ImprintReader.kt +++ b/core/vision/src/main/kotlin/app/nursemate/core/vision/imprint/ImprintReader.kt @@ -1,15 +1,17 @@ package app.nursemate.core.vision.imprint -import ai.onnxruntime.OnnxTensor -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.OrtSession import android.graphics.Bitmap -import app.nursemate.core.vision.OrtBackend +import app.nursemate.core.vision.GpuPrecision +import app.nursemate.core.vision.LiteRtModel +import app.nursemate.core.vision.Placement +import app.nursemate.core.vision.RunPlan import java.io.Closeable import java.io.File -import java.nio.ByteBuffer -import java.nio.ByteOrder -import java.nio.FloatBuffer +import java.util.concurrent.CompletableFuture +import java.util.concurrent.ExecutionException +import java.util.concurrent.ExecutorService +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock @@ -30,130 +32,63 @@ import org.opencv.imgproc.Imgproc * 둘을 잇고 추론만 한다. * * ## 후보 144장을 읽는다 - * 회전 24 × 배율 6 이다. `session.run` 은 [batch] 장씩 나눠 부른다(기본 72 — 사정은 그 매개변수). 방향 추정기는 기각됐다 — 여러 방향을 읽고 모델이 스스로 매긴 확률로 - * 고르는 편이 낫고, 자체 모델이라 그 확률이 보정돼 있다. 회전을 한 배치로 묶으므로 방향 수를 - * 늘려도 비용이 거의 안 는다. + * 회전 24 × 배율 6 이다. 방향 추정기는 기각됐다 — 여러 방향을 읽고 모델이 스스로 매긴 확률로 + * 고르는 편이 낫고, 자체 모델이라 그 확률이 보정돼 있다. * - * ⚠️ **알약 하나당 144회다.** 셋을 찍으면 432회이고 저사양 기기의 대기 시간은 재봐야 한다 - * (NM-485 「정할 것」 1번). + * ## 모델이 다섯 조각이다 — G5 (LiteRT, NM-628) + * 한 판(ONNX `reader_ep60_s1.onnx`)을 ML 이 다섯 조각으로 나눴다. 조각마다 잘 도는 가속기가 달라서다. * - * ## `rnn` 만 CPU 에 남긴다 (NM-534) - * WebGPU 로 그냥 열면 **3배 느려진다** — Galaxy S24 에서 CPU 3472 ms 대 WebGPU 9943 ms 다. - * EP 가 나쁜 게 아니라 `LstmCell` 셰이더가 **타임스텝마다 디스패치를 하나씩** 내기 때문이다 - * (양방향 × 2층 × 32스텝 = 실행당 128회). 그 한 덩어리가 전체의 84%를 먹는다. + * | 조각 | 하는 일 | 실행(ML 계약) | 왜 | + * |---|---|---|---| + * | `p1_loc` | TPS 제어점 추정 | GPU FP16 | | + * | `p2_tps` | 제어점대로 크롭을 편다 | **CPU** | GPU 판보다 CPU 가 빨랐다 | + * | `p3_trunk` | CNN 몸통 | GPU **FP32** | 8 Elite 에서 FP16 이면 실행마다 다르게 틀렸다 | + * | `p4_frm` | 특징 재배열 | **GPU+CPU** FP16 | GPU 만으로 열면 Exynos 에서 컴파일 실패 | + * | `p5_lstm_head` | 양방향 LSTM + 글자 확률 | **CPU** | GPU 판보다 CPU 가 빨랐다 | * - * 같은 EP 에서 Conv·attention 은 2배 빠르므로, `rnn` 만 CPU 로 돌려 둘을 다 챙긴다. + * 공식 세트 550면에서 **전 기기 응답 · 정답 · 오답이 운영 fp32 와 같다**(233/207/26). 면당 0.4~1.2초 + * (ONNX 시절 1.4~5.0초). * - * | | 각인 144장 | - * |---|---| - * | CPU 만 | 3472 ms | - * | WebGPU 만 | 9943 ms | - * | **WebGPU + `cpu(/rnn/)`** | **1796 ms** | - * - * `/out/` 까지 묶으면 1880 ms 로 오히려 느려서 `rnn` 하나만 고정한다. + * ## 묶음이 조각을 차례로 흐른다 + * 144장을 **24장 묶음 6개**로 나눈다. 조각마다 **전용 스레드 하나**를 두고 묶음이 p1 → p5 를 흘러가게 해서, + * 묶음 k 가 p3 에 있을 때 묶음 k+1 이 p1 을 돈다. 순차로 돌리면 약 2배 느리다(Exynos 2600 715 → 377ms). + * 조각 하나를 두 스레드가 동시에 부르지 않는다 — [LiteRtModel] 이 버퍼를 공유하기 때문이다. * * ## 못 읽으면 null 이다 * 빈 문자열이 아니다. 계약에서 `imprint: ""` 는 「각인이 없는 알약만」이라는 하드 조건이라, * 못 읽은 것을 그렇게 보내면 각인이 있는 정답이 전부 탈락한다. + * + * @param parts [PART_FILE_NAMES] 순서의 조각 파일 다섯 */ -class ImprintReader( - modelFile: File, - threads: Int = DEFAULT_THREADS, - cpuNodes: String? = RNN_ON_CPU, - webGpuOptions: Map = emptyMap(), - /** - * `session.run` 한 번에 넣는 장수. **144 를 한 번에 넣으면 WebGPU 가 빈 답을 낸다.** - * - * ## 왜 72 인가 - * 엑시노스 2600 에서 배치 144 가 **225회 중 30회**(13.3%) `각인=null · 점수 0.0` 을 냈다. - * 예외도 크래시도 logcat 오류도 없다 — 앱은 「못 읽었다」로 처리하고 넘어간다. 한 번은 - * `pair=EE · 0.609` 로 **계산이 망가진 값**이 나왔다. 채택 임계 0.949 를 못 넘어 null 이 - * 됐을 뿐, 넘었으면 틀린 각인을 그대로 채택했을 것이다. - * - * 세 모델의 배치와 실패율이 같은 순서였다 — 검출 1→0/6, 마크 8→0/39, 각인 **144→3/39**. - * - * | 배치 | 결과 | - * |---|---| - * | 144 | 225회 중 30 실패 · 기기가 43°C 넘으면 6~8% → **16~20%** | - * | **72** | **718회 중 0** · 55분 연속 부하에서 온도가 45.9 → 42.9°C 로 **하강** | - * | 36 | 675회 중 0 | - * - * 한 번에 GPU 로 가는 양이 절반이라 피크 부하도 절반이다. 정확도와 발열에 같은 방향으로 - * 듣는다. - * - * ## 답은 바뀌지 않는다 - * 쪼개도 **후보 144개를 다 쓴다** — 출력 `[32, 144, 37]` 의 N 축으로 이어 붙인다. 점수가 - * 끝자리까지 같은 것을 확인했다(WebGPU 0.96988875). - * - * 대가는 `session.run` 횟수다. 배치 36 이 기준보다 11% 느렸다(2366 대 2134ms). - * - * ⚠️ [ImprintPreprocess.SAMPLES] 의 약수여야 한다 — 세션이 배치를 못박고 열리므로 - * 나머지 청크를 다른 모양으로 넣을 수 없다. - */ - private val batch: Int = DEFAULT_BATCH -) : Closeable { +class ImprintReader(parts: List) : Closeable { init { - // 세션을 열기 **전에** 거른다 — 연 뒤에 던지면 생성자가 끝나지 않아 아무도 close() 를 - // 못 부르고 네이티브 세션(QNN 이면 컴파일 결과까지)이 샌다. - require(batch > 0 && ImprintPreprocess.SAMPLES % batch == 0) { - "batch 는 ${ImprintPreprocess.SAMPLES} 의 양의 약수여야 한다 — 받은 값 $batch" + // 모델을 열기 **전에** 거른다 — 연 뒤에 던지면 생성자가 끝나지 않아 아무도 close() 를 못 부른다. + require(parts.map { it.name } == PART_FILE_NAMES) { + "각인 조각은 ${PART_FILE_NAMES.joinToString()} 순서여야 한다 — 받은 것 ${parts.map { it.name }}" } // 네이티브 로딩은 여기서 한 번만 한다. 앱 시작에 걸면 각인을 쓰지 않는 사용자도 비용을 낸다. check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } } - private val env: OrtEnvironment = OrtEnvironment.getEnvironment() - - private val session: OrtSession = OrtBackend.openSession( - env, - modelFile, - cpuNodeNames = cpuNodes, - webGpuOptions = webGpuOptions, - contextTag = "b$batch" - ) { - setIntraOpNumThreads(threads) - - /* - * **배치 차원을 못박는다** — QNN 이 이것 없이는 그래프를 거의 못 받는다 (NM-577). - * - * 모델 입력이 `image: [batch, 1, 128, 128]` 로 **`batch` 가 심볼릭**이다. 그런데 이 - * 리더는 늘 [batch] 장씩 넣는다 — 세션이 열린 뒤에는 바뀔 여지가 없다. - * - * 심볼릭으로 두면 HTP 가 이렇게 거절한다(2026-10-13 Adreno 740 logcat). - * ``` - * W [GeluFusion] ValidateOnQnn failed … : Cannot get shape - * W Unable to get producer node for OrtValueInfo '/rnn/Shape_output_0' - * ``` - * 그러면 QNN EP 가 노드를 거의 안 가져가고 **CPU 로 돌면서 세션은 열리고 답도 맞는다.** - * 느린 것만이 증거다(각인 5368ms — AI Hub 가 같은 칩에서 배치 144 로 잰 값은 234ms). - * - * CPU·WebGPU 에도 해롭지 않다 — 모양이 확정되면 ORT 가 추론·상수접기를 더 할 수 있다. - */ - setSymbolicDimensionValue(OrtBackend.BATCH_DIM, batch.toLong()) + private val models: List = openAll(parts) + + /** 조각마다 전용 스레드 — 한 조각을 두 스레드가 부르지 않게 한다. */ + private val lanes: List = models.map { model -> + Executors.newSingleThreadExecutor { runnable -> + Thread(runnable, "imprint-${model.name}").apply { + isDaemon = + true + } + } } - /** 144장 × 1채널 × 128 × 128. 매 호출 재할당하지 않는다(9.4MB). */ private val input = FloatArray(ImprintPreprocess.SAMPLES * PLANE) - /** - * [input] 을 한 번에 옮겨 둘 **direct** 버퍼. 힙 배열을 `FloatBuffer.wrap` 으로 넘기면 ORT 가 - * 청크마다 direct 버퍼를 새로 잡고 복사한다 — 알약 셋이면 4.7MB 를 여섯 번이다. 하나를 두고 - * 청크는 그 조각만 넘긴다. - */ - private val inputDirect: FloatBuffer = ByteBuffer - .allocateDirect(input.size * Float.SIZE_BYTES) - .order(ByteOrder.nativeOrder()) - .asFloatBuffer() - - /** [input] 을 공유하므로 동시 호출을 직렬화한다. */ + /** [input] 과 조각들을 공유하므로 동시 호출을 직렬화한다. */ private val lock = Mutex() - /** - * @param crop 마스크로 오려낸 낱알 한 면. 배경이 투명한 `ARGB_8888` 을 받는다 - * (`PillDetector` 의 `DetectedPill.crop`). - * @return 확신 글자, 또는 채택 임계에 못 미치면 null - */ + /** @param crop 검출기가 오려낸 투명 배경 낱알 이미지 */ suspend fun read(crop: Bitmap): Result = lock.withLock { withContext(Dispatchers.Default) { readBlocking(crop) } } @@ -164,10 +99,8 @@ class ImprintReader( } /** - * 회색조 한 장에서 바로 읽는다 — 비트맵 디코딩을 건너뛰는 자리. - * - * 대조 테스트가 쓴다. 픽스처를 PNG 로 두면 파이썬과 Android 의 **디코더 차이가 섞여** - * 전처리가 아닌 것을 재게 되므로, 기준값은 숫자 배열로 두고 여기로 들어온다. + * 흑백 크롭에서 바로 읽는다. 대조 테스트가 기준 구현과 **같은 입력**을 넣으려고 쓴다 — 비트맵을 + * 거치면 알파 합성 · 흑백 변환이 끼어 정본 `.npy` 와 화소 단위로 맞출 수 없다. */ internal fun readGray(gray: Mat): Result { val t0 = System.nanoTime() @@ -190,7 +123,7 @@ class ImprintReader( squared.release() val t1 = System.nanoTime() - val logits = runSession() + val logits = runPipeline() val t2 = System.nanoTime() val result = decode(logits) val t3 = System.nanoTime() @@ -205,35 +138,51 @@ class ImprintReader( } /** - * @return 로짓 [T][N][C] — 시간축이 먼저다(모델 출력 그대로). N 은 늘 - * [ImprintPreprocess.SAMPLES] 다. [batch] 가 그보다 작으면 나눠 돌린 뒤 **N 축으로 - * 이어 붙인다** — 디코딩은 후보가 몇 번에 나눠 왔는지 알 필요가 없다. + * 묶음 6개를 p1 → p5 로 흘린다. 채널이 1 이라 NCHW 와 NHWC 가 같은 배열이다 — 그대로 넣는다. + * + * @return `[시간][후보][글자]` — ONNX 시절과 같은 시간축 먼저. p5 출력 `[T,24,37]` 을 후보 자리에 꽂는다. */ - private fun runSession(): Array> { - val shape = longArrayOf(batch.toLong(), 1, SIDE_L, SIDE_L) - inputDirect.clear() - inputDirect.put(input).flip() - val chunks = ArrayList>>(ImprintPreprocess.SAMPLES / batch) - for (start in 0 until ImprintPreprocess.SAMPLES step batch) { - val slice = inputDirect.duplicate().apply { - position(start * PLANE) - limit((start + batch) * PLANE) - }.slice() - OnnxTensor.createTensor(env, slice, shape) - .use { tensor -> - session.run(mapOf(INPUT_NAME to tensor)).use { result -> - @Suppress("UNCHECKED_CAST") - chunks += result[0].value as Array> - } - } + private fun runPipeline(): Array> { + val outs = if (models.any { it.onGpu }) runOnLanes() else runInOrder() + val steps = outs[0].size / (CHUNK * CLASSES) + return Array(steps) { t -> + Array(ImprintPreprocess.SAMPLES) { n -> + val from = (t * CHUNK + n % CHUNK) * CLASSES + outs[n / CHUNK].copyOfRange(from, from + CLASSES) + } } - if (chunks.size == 1) return chunks[0] - // 시간축 T 는 청크마다 같다 — 배치와 무관한 모델 상수다. - return Array(chunks[0].size) { t -> - Array(ImprintPreprocess.SAMPLES) { n -> chunks[n / batch][t][n % batch] } + } + + /** 묶음이 조각 전용 스레드를 차례로 흐른다(클래스 KDoc). p2 만 입력이 둘(크롭 · 제어점)이다. */ + private fun runOnLanes(): List { + val chunks = (0 until ImprintPreprocess.SAMPLES / CHUNK).map { c -> + val image = chunkOf(c) + var flow = CompletableFuture.supplyAsync({ models[0].run(image)[0] }, lanes[0]) + .thenApplyAsync({ points -> models[1].run(image, points)[0] }, lanes[1]) + for (i in 2 until models.size) { + flow = flow.thenApplyAsync({ x -> models[i].run(x)[0] }, lanes[i]) + } + flow } + // ⚠️ 하나가 실패해도 **나머지가 다 끝날 때까지** 기다린 뒤 던진다. 먼저 던지면 남은 묶음이 조각 스레드에서 + // 계속 돌아, 다음 판독 · close() 와 겹쳐 같은 모델을 건드린다. + chunks.forEach { it.handle { _, _ -> }.join() } + return chunks.map { it.awaitUnwrapped() } } + /** + * 다섯 조각이 **모두 CPU** 면 겹쳐 돌리지 않고 이 스레드에서 차례로 돈다 — 조각마다 4스레드라 겹치면 최대 20개가 + * 코어를 나눠 써 리틀코어로 넘친다(GPU 가 막힌 기기의 경로다). + */ + private fun runInOrder(): List = (0 until ImprintPreprocess.SAMPLES / CHUNK).map { c -> + val image = chunkOf(c) + var x = models[1].run(image, models[0].run(image)[0])[0] + for (i in 2 until models.size) x = models[i].run(x)[0] + x + } + + private fun chunkOf(c: Int): FloatArray = input.copyOfRange(c * CHUNK * PLANE, (c + 1) * CHUNK * PLANE) + /** * 후보 144개를 각각 풀어 `best_pair` 점수가 가장 높은 것을 고른다. * @@ -265,8 +214,19 @@ class ImprintReader( ) } + /** + * 조각 스레드가 멈출 때까지 기다린 뒤 모델을 닫는다 — 아직 도는 묶음이 닫힌 네이티브 모델을 건드리면 SIGSEGV 고, + * 그 프로세스는 GPU 를 열었으니 GPU 크래시로 잘못 판정된다. + * + * 기다림은 **별도 스레드**에서 한다. 이 메서드는 화면을 떠날 때 메인 스레드(`onCleared`)에서 불려, 판독 중이면 + * 몇 초를 막아 ANR 이 날 수 있다. + */ override fun close() { - session.close() + lanes.forEach { it.shutdown() } + Thread({ + lanes.forEach { it.awaitTermination(CLOSE_TIMEOUT_S, TimeUnit.SECONDS) } + models.forEach { it.close() } + }, "imprint-close").apply { isDaemon = true }.start() } /** @@ -281,41 +241,68 @@ class ImprintReader( /** * 단계별 소요. **어디가 비싼지 알아야 줄일 곳을 정한다.** * - * 전처리가 지배적이면 TTA 장수를 줄이는 것이 답이고, 추론이 지배적이면 스레드나 배치를 - * 손봐야 한다. 합계만 보면 둘을 구분할 수 없다. + * 전처리가 지배적이면 TTA 장수를 줄이는 것이 답이고, 추론이 지배적이면 실행 계획을 손봐야 한다. + * 합계만 보면 둘을 구분할 수 없다. * - * ⚠️ **세션 생성은 여기 없다.** 21MB 모델을 여는 비용은 한 번만 드는데 여기 섞으면 - * 알약마다 그만큼 든다고 잘못 읽힌다. 그건 호출부가 따로 잰다. + * ⚠️ **모델 열기는 여기 없다.** 한 번만 드는 비용인데 여기 섞으면 알약마다 그만큼 든다고 잘못 읽힌다. */ data class Timings(val preprocessMs: Long = 0, val inferenceMs: Long = 0, val decodeMs: Long = 0) { val totalMs: Long get() = preprocessMs + inferenceMs + decodeMs } companion object { - /** - * `rnn` 을 CPU 에 고정하는 노드 이름 조각 — 부분 문자열로 맞는다. - * - * WebGPU EP 전용 옵션 `forceCpuNodeNames` 로도 해 봤는데 **안 먹는다**(11715 ms). - * 그쪽은 정확한 노드 이름 목록을 받는 것으로 보인다. - */ - internal const val RNN_ON_CPU = "/rnn/" + /** 조각 파일 — 이 순서로 흐른다. 목록과 해시는 `app/models.md5`. */ + val PART_FILE_NAMES = listOf( + "p1_loc.tflite", + "p2_tps.tflite", + "p3_trunk.tflite", + "p4_frm.tflite", + "p5_lstm_head.tflite" + ) - /** 검출기와 같은 값. 실측 근거는 `PillDetector.DEFAULT_THREADS`. */ - const val DEFAULT_THREADS = 4 + /** [PART_FILE_NAMES] 와 같은 순서의 ML 실행 정밀도 계약. 바꾸면 정확도 보장이 없다(클래스 KDoc 표). */ + private val PLANS = listOf( + RunPlan(Placement.GPU, GpuPrecision.FP16), + RunPlan(Placement.CPU), + RunPlan(Placement.GPU, GpuPrecision.FP32), + RunPlan(Placement.GPU_CPU, GpuPrecision.FP16), + RunPlan(Placement.CPU) + ) - /** `session.run` 한 번에 넣는 기본 장수 — 144 는 WebGPU 에서 깨진다. 사정은 생성자 KDoc. */ - const val DEFAULT_BATCH = 72 + /** 조각 모델의 묶음 크기 — 변환 때 박혔다. 144 의 약수여야 한다. */ + private const val CHUNK = 24 - /** CRNN + CTC, 5.97M 파라미터. 21MB. */ - const val MODEL_FILE_NAME = "reader_ep60_s1.onnx" + /** 글자 37종(CTC 빈칸 포함). */ + private const val CLASSES = 37 - private const val INPUT_NAME = "image" private const val PLANE = ImprintPreprocess.SIDE * ImprintPreprocess.SIDE - private const val SIDE_L = ImprintPreprocess.SIDE.toLong() private const val NANOS_PER_MS = 1_000_000L + + /** 한 면 판독이 CPU 로도 5초 안팎이다. 그보다 넉넉히 기다린다. */ + private const val CLOSE_TIMEOUT_S = 15L + + /** 하나라도 못 열면 이미 연 것을 닫고 던진다 — 반쯤 열린 채 새지 않게. */ + private fun openAll(parts: List): List { + val opened = ArrayList(parts.size) + var done = false + try { + parts.zip(PLANS).forEach { (file, plan) -> opened += LiteRtModel.open(file, plan) } + done = true + } finally { + if (!done) opened.forEach { it.close() } + } + return opened + } } } +/** 조각 실패는 [ExecutionException] 으로 싸여 온다 — 원래 예외를 꺼내 던진다. */ +private fun CompletableFuture.awaitUnwrapped(): T = try { + get() +} catch (e: ExecutionException) { + throw e.cause ?: e +} + /** * 투명 배경 크롭 → 흰 배경 흑백. * diff --git a/core/vision/src/main/kotlin/app/nursemate/core/vision/mark/MarkReader.kt b/core/vision/src/main/kotlin/app/nursemate/core/vision/mark/MarkReader.kt index 0089caeb..2c7748d8 100644 --- a/core/vision/src/main/kotlin/app/nursemate/core/vision/mark/MarkReader.kt +++ b/core/vision/src/main/kotlin/app/nursemate/core/vision/mark/MarkReader.kt @@ -1,13 +1,13 @@ package app.nursemate.core.vision.mark -import ai.onnxruntime.OnnxTensor -import ai.onnxruntime.OrtEnvironment -import ai.onnxruntime.OrtSession import android.graphics.Bitmap -import app.nursemate.core.vision.OrtBackend +import app.nursemate.core.vision.GpuPrecision +import app.nursemate.core.vision.LiteRtModel +import app.nursemate.core.vision.Placement +import app.nursemate.core.vision.RunPlan +import app.nursemate.core.vision.nchwToNhwc import java.io.Closeable import java.io.File -import java.nio.FloatBuffer import kotlin.math.exp import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.sync.Mutex @@ -43,40 +43,25 @@ import org.opencv.core.Mat * * ## L2 정규화를 다시 하지 않는다 * 모델이 이미 한 값이다(`torch.nn.functional.normalize`). 앱에서 또 걸면 값이 달라진다. + * + * ## LiteRT · M4 (NM-628) + * 파일은 `mark_m4_f16w.tflite`(가중치 fp16 저장). 입력이 **NHWC** `[8,224,224,3]` 이라 전처리가 쓴 NCHW 를 + * 넣기 직전에 돌린다. M4 는 Xclipse(Exynos GPU)가 틀리는 7×7 depthwise 를 피한 판이고, 공식 세트 564면에서 + * 유무 · 종 100% · 임베딩 cos 최소 1.0000 이라 **임베딩 공간이 같다** — 서버에 보내는 [MODEL_VERSION] 은 그대로다. + * + * 실행은 GPU **FP32**(ML 계약). 8 Elite 에서 FP16 이면 회전 13~19% 의 임베딩이 실행마다 틀어졌다(cos 0.20~0.46). */ -class MarkReader(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { +class MarkReader(modelFile: File) : Closeable { init { // 네이티브 로딩은 여기서 한 번만. 앱 시작에 걸면 마크를 쓰지 않는 사용자도 비용을 낸다. check(OpenCVLoader.initLocal()) { "OpenCV 네이티브를 초기화하지 못했습니다" } } - private val env: OrtEnvironment = OrtEnvironment.getEnvironment() + private val model = LiteRtModel.open(modelFile, PLAN) - private val session: OrtSession = OrtBackend.openSession(env, modelFile) { - setIntraOpNumThreads(threads) - - /* - * **배치 차원을 못박는다** — QNN 이 이것 없이는 그래프를 거의 못 받는다 (NM-577). - * - * 모델 입력이 `image: [batch, 3, 224, 224]` 로 **`batch` 가 심볼릭**이다. 그런데 이 - * 리더는 늘 8장을 넣는다 — 바뀔 여지가 없다. - * - * 심볼릭으로 두면 HTP 가 이렇게 거절한다(2026-10-13 Adreno 740 logcat). - * ``` - * W [GeluFusion] ValidateOnQnn failed … : Cannot get shape - * W Unable to get producer node for OrtValueInfo '/frm/attn/Shape_2_output_0' - * ``` - * 그러면 QNN EP 가 노드를 거의 안 가져가고 **CPU 로 돌면서 세션은 열리고 답도 맞는다.** - * 느린 것만이 증거다(각인 5368ms — AI Hub 가 같은 칩에서 잰 값은 234ms). - * - * CPU·WebGPU 에도 해롭지 않다 — 모양이 확정되면 ORT 가 추론·상수접기를 더 할 수 있다. - */ - setSymbolicDimensionValue(OrtBackend.BATCH_DIM, MarkPreprocess.ROTATIONS.toLong()) - } - - /** 8장 × 3채널 × 224 × 224 = 4.8MB. 매 호출 재할당하지 않는다. */ private val input = FloatArray(MarkPreprocess.BATCH) + private val nhwc = FloatArray(MarkPreprocess.BATCH) /** [input] 을 공유하므로 동시 호출을 직렬화한다. */ private val lock = Mutex() @@ -135,24 +120,15 @@ class MarkReader(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { /** @return `logits` [8][104] 와 `embedding` 을 8×768 로 평탄화한 것(회전이 바깥). */ private fun runSession(): Pair, FloatArray> { - val shape = longArrayOf( - MarkPreprocess.ROTATIONS.toLong(), - 3, - MarkPreprocess.SIDE.toLong(), - MarkPreprocess.SIDE.toLong() - ) - OnnxTensor.createTensor(env, FloatBuffer.wrap(input), shape).use { tensor -> - session.run(mapOf(INPUT_NAME to tensor)).use { result -> - @Suppress("UNCHECKED_CAST") - val logits = result[0].value as Array - - @Suppress("UNCHECKED_CAST") - val rows = result[1].value as Array - val flat = FloatArray(MarkPreprocess.ROTATIONS * EMBEDDING_DIM) - for (i in rows.indices) rows[i].copyInto(flat, i * EMBEDDING_DIM) - return logits to flat - } - } + val n = MarkPreprocess.ROTATIONS + val side = MarkPreprocess.SIDE + val outputs = model.run(nchwToNhwc(input, nhwc, n = n, c = 3, plane = side * side)) + // 출력은 크기로 가른다 — 8×104 와 8×768 이라 겹치지 않는다. + val flat = outputs.first { it.size != n * EMBEDDING_DIM } + val embedding = outputs.first { it.size == n * EMBEDDING_DIM } + val classes = flat.size / n + val logits = Array(n) { flat.copyOfRange(it * classes, (it + 1) * classes) } + return logits to embedding } /** @@ -174,7 +150,7 @@ class MarkReader(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { } override fun close() { - session.close() + model.close() } /** @@ -219,11 +195,11 @@ class MarkReader(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { } companion object { - /** 각인과 같은 이유로 4다 — big.LITTLE 에서 6·8은 오히려 느리다(NM-485). */ - const val DEFAULT_THREADS = 4 + /** assets · DVC 에서 이 이름으로 온다. 가중치 fp16 저장 · 57MB. 목록과 해시는 `app/models.md5`. */ + const val MODEL_FILE_NAME = "mark_m4_f16w.tflite" - /** assets·DVC 에서 이 이름으로 온다. **fp16 판이다** — 53MB 이고 fp32(106MB)와 답이 같다(NM-526). */ - const val MODEL_FILE_NAME = "mark_species_fp16.onnx" + /** ML 실행 정밀도 계약 — GPU FP32. 검출과 같이 GPU+CPU 로 연다(ML 벤치가 그렇게 쟀다 · `PillDetector.PLAN`). */ + private val PLAN = RunPlan(Placement.GPU_CPU, GpuPrecision.FP32) /** * 임베딩을 뽑은 모델 버전 — **ML 레포 모델 폴더 이름 그대로**다. @@ -234,14 +210,15 @@ class MarkReader(modelFile: File, threads: Int = DEFAULT_THREADS) : Closeable { * * ⚠️ **모델 파일을 바꾸면 이 값도 같이 바꾼다.** 파일 이름에는 날짜가 없어 둘이 * 조용히 갈릴 수 있다 — 갈리면 서버가 엉뚱한 카탈로그와 견준다. + * + * LiteRT M4(NM-628)로 파일은 바뀌었지만 **값은 그대로 둔다.** 같은 학습 가중치를 옮긴 것이고 공식 + * 세트 564면 임베딩 cos 최소 1.0000 이라 카탈로그와 같은 공간이다. 재학습이면 그때 바꾼다. */ const val MODEL_VERSION = "20260925-convnext-species" - /** 임베딩 차원. fp16 판은 그래프에 768 로 박혀 있다(fp32 판은 동적이다). */ + /** 임베딩 차원. */ const val EMBEDDING_DIM = 768 - private const val INPUT_NAME = "image" - /** 클래스 0 = 「마크 없음」. `species_map.json` 의 `none`. */ private const val NONE_CLASS = 0 diff --git a/core/vision/src/test/kotlin/app/nursemate/core/vision/QnnDeliveryStateTest.kt b/core/vision/src/test/kotlin/app/nursemate/core/vision/QnnDeliveryStateTest.kt deleted file mode 100644 index 9606af55..00000000 --- a/core/vision/src/test/kotlin/app/nursemate/core/vision/QnnDeliveryStateTest.kt +++ /dev/null @@ -1,36 +0,0 @@ -package app.nursemate.core.vision - -import java.io.File -import java.nio.file.Files -import org.junit.Assert.assertEquals -import org.junit.Test - -class QnnDeliveryStateTest { - - private fun libDir(vararg names: String): File = - Files.createTempDirectory("lib").toFile().apply { names.forEach { File(this, it).writeBytes(ByteArray(0)) } } - - @Test - fun `토대와 세대가 다 있으면 정상`() { - val dir = libDir("libQnnHtp.so", "libQnnSystem.so", "libQnnHtpV75Skel.so", "libQnnHtpV75Stub.so") - assertEquals(QnnDeliveryState.CORE_AND_SKEL, QnnDeliveryState.of(dir, pluginLoaded = true)) - } - - @Test - fun `플러그인 클래스만 있고 토대 so 가 없으면 토대로 치지 않는다`() { - val dir = libDir("libQnnHtpV75Skel.so") - assertEquals(QnnDeliveryState.SKEL_ONLY, QnnDeliveryState.of(dir, pluginLoaded = true)) - } - - @Test - fun `토대만 있으면 core_only`() { - val dir = libDir("libQnnHtp.so", "libQnnSystem.so") - assertEquals(QnnDeliveryState.CORE_ONLY, QnnDeliveryState.of(dir, pluginLoaded = true)) - } - - @Test - fun `아무 것도 없으면 none — 그리고 비슷한 이름에 속지 않는다`() { - val dir = libDir("libonnxruntime.so", "libQnnHtpPrepare.so", "libQnnHtpV75Stub.so") - assertEquals(QnnDeliveryState.NONE, QnnDeliveryState.of(dir, pluginLoaded = false)) - } -} diff --git a/core/vision/src/test/kotlin/app/nursemate/core/vision/TensorLayoutTest.kt b/core/vision/src/test/kotlin/app/nursemate/core/vision/TensorLayoutTest.kt new file mode 100644 index 00000000..7107379a --- /dev/null +++ b/core/vision/src/test/kotlin/app/nursemate/core/vision/TensorLayoutTest.kt @@ -0,0 +1,39 @@ +package app.nursemate.core.vision + +import org.junit.Assert.assertArrayEquals +import org.junit.Test + +/** + * LiteRT 로 넘어오며 바뀐 텐서 배치(NM-628). 틀리면 예외 없이 **답만** 틀어지므로 값을 박아 둔다. + */ +class TensorLayoutTest { + + @Test + fun `NCHW 를 NHWC 로 바꾸면 화소마다 채널이 붙는다`() { + // n=2, c=3, h=1, w=2 — 값 = 배치·채널·화소를 자릿수로 + val nchw = floatArrayOf( + 0f, 1f, 10f, 11f, 20f, 21f, + 100f, 101f, 110f, 111f, 120f, 121f + ) + val nhwc = nchwToNhwc(nchw, FloatArray(nchw.size), n = 2, c = 3, plane = 2) + assertArrayEquals( + floatArrayOf( + 0f, 10f, 20f, 1f, 11f, 21f, + 100f, 110f, 120f, 101f, 111f, 121f + ), + nhwc, + 0f + ) + } + + @Test + fun `쿼리가 마지막 축인 마스크에서 한 쿼리의 평면을 모은다`() { + val queries = RfDetrSpec.QUERY_COUNT + val plane = 3 + // 화소 p 의 쿼리 q 자리에 p * 1000 + q + val masks = FloatArray(plane * queries) { i -> (i / queries) * 1000f + (i % queries) } + val out = FloatArray(plane) + querySlice(masks, query = 7, out = out) + assertArrayEquals(floatArrayOf(7f, 1007f, 2007f), out, 0f) + } +} diff --git a/docs/RELEASE.md b/docs/RELEASE.md index 6ce5b80a..68f8713a 100644 --- a/docs/RELEASE.md +++ b/docs/RELEASE.md @@ -28,35 +28,38 @@ ## 온디바이스 모델 (필수 · 저장소에 없음) -ONNX 모델은 **저장소에 넣지 않는다.** 한 번 커밋하면 이후 모든 clone 이 영구히 그 비용을 -낸다(git 은 큰 파일을 되돌려 지우지 못한다). +모델(LiteRT `.tflite`)은 **저장소에 넣지 않는다.** 한 번 커밋하면 이후 모든 clone 이 영구히 그 비용을 +낸다(git 은 큰 파일을 되돌려 지우지 못한다). `.gitignore` 가 `*.tflite` · `*.onnx` 를 막는다. -**목록과 해시는 `app/models.md5` 한 곳이다.** +**목록과 해시는 `app/models.md5` 한 곳이다.** 2.1.0 부터 런타임이 LiteRT 하나다(NM-628) — 전 기기 같은 파일. | 모델 | 크기 | 쓰는 곳 | |---|---|---| -| `rfdetr_seg_small.onnx` | 119MB | 낱알 검출·마스크 (`PillDetector`) | -| `reader_ep60_s1.onnx` | 21MB | 각인 판독 (`ImprintReader`, NM-485) | -| `mark_species_fp16.onnx` | 53MB | 마크 유무·종·임베딩 (`MarkReader`, NM-515) | +| `rfdetr_seg_small_f16w.tflite` | 63MB | 낱알 검출·마스크 (`PillDetector`) | +| `p1_loc` · `p2_tps` · `p3_trunk` · `p4_frm` · `p5_lstm_head` `.tflite` | 합 23MB | 각인 판독 다섯 조각 (`ImprintReader`) | +| `mark_m4_f16w.tflite` | 57MB | 마크 유무·종·임베딩 (`MarkReader`) | -**정본은 ML 저장소의 DVC** 다(`s3://nursemate-ml-models` · `ap-northeast-2`). -릴리스 빌드 전에 받아 둔다: +**정본은 ML 저장소의 DVC** 다(`s3://nursemate-ml-models` · `ap-northeast-2`). 실행 정밀도 계약 · 기기 실측은 +각 모델 폴더 `INFO.md` 「Android 배포본 (LiteRT)」. 릴리스 빌드 전에 받아 둔다: ```bash # 사전: dvc(brew install dvc) · ML 저장소 SSH 접근 · 버킷 읽기 권한이 있는 AWS 프로필 -AWS_PROFILE=nursemate-dvc dvc get git@github.com:Two-Park-One-Bae/ML.git \ - models/seg/20260610-rfdetr-seg-small/rfdetr_seg_small.onnx -o app/src/main/assets/ -AWS_PROFILE=nursemate-dvc dvc get git@github.com:Two-Park-One-Bae/ML.git \ - models/imprint/20260907-crnn-ep60-s1/reader_ep60_s1.onnx -o app/src/main/assets/ -AWS_PROFILE=nursemate-dvc dvc get git@github.com:Two-Park-One-Bae/ML.git \ - models/mark/20260925-convnext-species/mark_species_fp16.onnx -o app/src/main/assets/ +ML=git@github.com:Two-Park-One-Bae/ML.git +for p in seg/20260610-rfdetr-seg-small/litert/rfdetr_seg_small_f16w.tflite \ + mark/20260925-convnext-species/litert/mark_m4_f16w.tflite \ + imprint/20260907-crnn-ep60-s1/litert/p1_loc.tflite \ + imprint/20260907-crnn-ep60-s1/litert/p2_tps.tflite \ + imprint/20260907-crnn-ep60-s1/litert/p3_trunk.tflite \ + imprint/20260907-crnn-ep60-s1/litert/p4_frm.tflite \ + imprint/20260907-crnn-ep60-s1/litert/p5_lstm_head.tflite; do + AWS_PROFILE=nursemate-dvc dvc get $ML models/$p -o app/src/main/assets/ +done ``` -⚠️ 마크는 **fp16 판**(`mark_species_fp16.onnx`, 53MB)이다. 같은 폴더의 `mark_species.onnx` -(fp32, 106MB)는 **대조용**이라 앱에 싣지 않는다. 답은 같고(NM-526 — 종 top-1 6/6 · 임베딩 -코사인 0.999997) 크기가 절반이며, 그래프에 임베딩 차원이 768 로 박혀 있어 붙이기도 쉽다. +⚠️ 예전 ONNX 3개(`rfdetr_seg_small.onnx` · `reader_ep60_s1.onnx` · `mark_species_fp16.onnx`)가 assets 에 남아 있으면 +**지운다** — 앱은 읽지 않지만 그대로 APK 에 실린다(193MB). -`dvc get` 은 **ML 을 클론해 두지 않아도 된다** — 임시 클론을 만들어 S3 에서 받는다(약 193MB). +`dvc get` 은 **ML 을 클론해 두지 않아도 된다** — 임시 클론을 만들어 S3 에서 받는다(약 136MB). ML 클론이 이미 있으면 `dvc pull` 후 복사하는 쪽이 더 빠르다. - **맞는 파일인지는 빌드가 본다.** `bundleRelease`·`assembleRelease` 가 `app/models.md5` 의 @@ -81,7 +84,7 @@ ML 클론이 이미 있으면 `dvc pull` 후 복사하는 쪽이 더 빠르다. ```bash # 사전: certificates 레포가 Android 레포와 같은 부모 폴더에 클론돼 있고, # secrets.properties에 RELEASE_* 4개 키가 채워져 있어야 한다. -# app/src/main/assets/rfdetr_seg_small.onnx 가 있어야 한다(위 참고). +# app/models.md5 의 모델 7개가 app/src/main/assets/ 에 있어야 한다(위 참고). ./gradlew :app:bundleRelease # 산출물: app/build/outputs/bundle/release/app-release.aab # 서명 확인: jarsigner -verify app/build/outputs/bundle/release/app-release.aab @@ -115,7 +118,7 @@ CI 는 실패했을 때의 테스트 리포트만 남긴다. | 카카오 `*ErrorCause` enum 을 R8 이 리네임 (PR #14) | 프로세스 시작 즉시 · 전 사용자 | ✗ | ○ ¹ | | `glance-appwidget` 이 끌고 온 `WorkManagerInitializer` (PR #21) | 프로세스 시작 즉시 · 전 사용자 | ✗ | ○ | | 워치 릴리스가 미서명 (PR #21, 같은 날) | 설치 불가 · Data Layer 단절 | **○** | ○ | -| R8 이 `ai.onnxruntime.**` 리네임 (⑩ · NM-466) | 「알약 식별」 100% | **○** ² | ○ | +| R8 이 JNI 조회 클래스 리네임 (⑩ · NM-466 · LiteRT 는 NM-628) | 「알약 식별」 100% | **○** ² | ○ | | ONNX Runtime 1.29.0 의 SME 명령 (⑧) | 「이 사진 사용」 직후 | ✗ | ✗ ³ | | App Check 에 SHA-256 미등록 (⑦) | Play 설치본만 | ✗ | ✗ ⁴ | @@ -127,9 +130,9 @@ CI 는 실패했을 때의 테스트 리포트만 남긴다. 키 해시는 필요 없다. 그건 **로그인 요청 때** 카카오 서버가 검증하는 값이고 이 잡은 로그인을 하지 않는다 — 릴리스는 App Check 가 Play Integrity 라 에뮬레이터에서 어차피 막힌다. 2. **에뮬레이터가 필요 없다 — 매핑 파일이 답을 갖고 있다.** ⑩ 은 `-keep class - ai.onnxruntime.** { *; }` 가 사라지면 재발하는데, 그러면 매핑에 그대로 찍힌다: - `ai.onnxruntime.TensorInfo -> at4:`. `app/build.gradle.kts` 의 가드가 - `minifyReleaseWithR8` 뒤에 매핑을 읽어 JNI 가 이름으로 찾는 클래스 다섯이 리네임되지 + com.google.ai.edge.litert.** { *; }`(ORT 시절엔 `ai.onnxruntime.**`)가 사라지면 재발하는데, 그러면 매핑에 + 그대로 찍힌다: `com.google.ai.edge.litert.TensorType -> at4:`. `app/build.gradle.kts` 의 가드가 + `minifyReleaseWithR8` 뒤에 매핑을 읽어 JNI 가 이름으로 찾는 클래스(LiteRT 다섯 · OpenCV 넷)가 리네임되지 않았는지 대조하고, 하나라도 바뀌었으면 빌드를 세운다. **로컬 릴리스 빌드도 같이 막는다.** 에뮬레이터로 실제 추론을 돌리는 길도 시도했으나 접었다. 계측 테스트를 minify 된 앱에 @@ -258,7 +261,7 @@ adb logcat | grep NM467 4. **태그 커밋을 체크아웃해** 최종 AAB 를 만든다(모델 파일 존재 확인 후). ```bash git checkout v - (cd app/src/main && md5 -r assets/*.onnx | sed 's|assets/||') # app/models.md5 와 같아야 한다 + (cd app/src/main && md5 -r assets/*.tflite | sed 's|assets/||') # app/models.md5 와 같아야 한다 # 다르면 위 "온디바이스 모델" 절 참고 ./gradlew :app:bundleRelease :wear:bundleRelease jarsigner -verify app/build/outputs/bundle/release/app-release.aab # "jar verified." diff --git a/gradle.properties b/gradle.properties index 423d14e8..af0d7d84 100644 --- a/gradle.properties +++ b/gradle.properties @@ -7,7 +7,3 @@ org.gradle.configuration-cache.problems=warn android.useAndroidX=true kotlin.code.style=official -# 번들에 기기그룹(`system-on-chip`) 타깃팅을 넣는 API. **아직 베타**라 experimental 이다. -# 이게 없으면 app/src/main/device_targeting_configuration.xml 을 AGP 가 무시하고, -# `:qnn` 모듈이 조건 없이 전 기기에 설치된다 — 180MB 가 그대로 들어간다. -android.experimental.enableDeviceTargetingConfigApi=true diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index c7525d74..30cb8556 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -46,10 +46,6 @@ airbridge = "4.11.3" coil = "3.3.0" # 온디바이스 검출 (core:vision) -onnxruntime = "1.30.0" -# ⚠️ ORT 판 번호와 무관하다 — 퀄컴이 따로 매기는 플러그인 EP 판이다(NM-577). -onnxruntimeQnnPlugin = "2.6.0" -qnnRuntime = "2.51.0" opencv = "4.12.0" androidxExifInterface = "1.4.1" androidxBrowser = "1.10.0" @@ -127,8 +123,8 @@ androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = androidx-test-ext-junit = { group = "androidx.test.ext", name = "junit", version.ref = "androidxTestJunit" } # 테스트 메서드마다 프로세스를 새로 띄운다 — 네이티브 세그폴트가 나머지 테스트를 날리지 않게 (NM-577). androidx-test-orchestrator = { group = "androidx.test", name = "orchestrator", version = "1.6.1" } -# LiteRT(구 TFLite) — **계측 테스트 전용**이다. WebGPU 가 Mali 에서 전멸하고 Adreno 에서 -# 모델마다 갈리므로, OpenCL 기반 GPU 델리게이트가 대안이 되는지 재 본다 (NM-577). +# LiteRT(구 TFLite) — 온디바이스 추론 런타임(NM-628). 검출 · 각인 · 마크 모두 `CompiledModel` 로 돈다. +# ML 이 이 판으로 공식 세트 정확도를 쟀다 — 올릴 때는 그 표(`_handoff/litert-ondevice-migration.md`)를 다시 잰다. litert = { group = "com.google.ai.edge.litert", name = "litert", version.ref = "litert" } litert-gpu = { group = "com.google.ai.edge.litert", name = "litert-gpu", version.ref = "litert" } @@ -145,7 +141,7 @@ firebase-appcheck-playintegrity = { group = "com.google.firebase", name = "fireb firebase-appcheck-debug = { group = "com.google.firebase", name = "firebase-appcheck-debug" } # 크래시·지표 (NM-466). 식별자 계약은 spec `feature/auth/README.md` §지표·크래시 식별자 (NM-461). -# ndk 변형이라야 네이티브 크래시를 심볼과 함께 올린다 — ONNX Runtime 이 죽으면 그쪽에서 죽는다. +# ndk 변형이라야 네이티브 크래시를 심볼과 함께 올린다 — 추론 런타임(LiteRT) · GPU 드라이버가 죽으면 그쪽에서 죽는다. firebase-crashlytics-ndk = { group = "com.google.firebase", name = "firebase-crashlytics-ndk" } firebase-analytics = { group = "com.google.firebase", name = "firebase-analytics" } @@ -169,27 +165,6 @@ airbridge-sdk = { group = "io.airbridge", name = "sdk-android", version.ref = "a coil-compose = { group = "io.coil-kt.coil3", name = "coil-compose", version.ref = "coil" } coil-network-okhttp = { group = "io.coil-kt.coil3", name = "coil-network-okhttp", version.ref = "coil" } -# 온디바이스 추론 런타임. 프리빌트에 **CPU · WebGPU · NNAPI · XNNPACK** 넷이 들어 있다 -# (1.30.0 에서 기기로 확인했다 — 「WebGPU 는 소스 빌드에만」은 옛 NM-396 시절 얘기다). -onnxruntime-android = { group = "com.microsoft.onnxruntime", name = "onnxruntime-android", version.ref = "onnxruntime" } - -# 퀄컴 Hexagon NPU(HTP) — **플러그인 EP** 다. NM-577 측정 전용으로 붙였다. -# -# `com.microsoft.onnxruntime:onnxruntime-android-qnn` 과 혼동하지 말 것. 그쪽은 ORT 를 통째로 -# 갈아 끼우는 배포본이라 **WebGPU·NNAPI·XNNPACK 이 빠지고**(기기 실측: EP 가 CPU·QNN 둘뿐), -# 표준 artifact 와 같이 쓰면 `ai.onnxruntime` 네임스페이스가 겹쳐 빌드가 깨진다. -# -# 이 artifact 는 `libonnxruntime_providers_qnn.so` 하나와 클래스 둘(`QnnPluginEpLibraryKt`)만 -# 들어 있고 `libonnxruntime.so` 를 NEEDED 로 걸지도 않는다 — ORT API 를 팩토리 ABI 로 -# 넘겨받는다. 그래서 **표준 배포본과 공존하고, WebGPU 와 QNN 을 한 프로세스에서 쓸 수 있다.** -onnxruntime-qnn-plugin = { group = "com.qualcomm.qti", name = "onnxruntime-android-qnn", version.ref = "onnxruntimeQnnPlugin" } - -# 위 플러그인이 dlopen 하는 QNN 백엔드 자체(`libQnnHtp` · `libQnnSystem` · `libQnnHtpPrepare`)와 -# HTP 세대별 skel/stub. POM 에 의존성이 없어 **직접 물려야** 한다. -# -# ⚠️ arm64 기준 비압축 **214MB** 다. 운영에는 이 artifact 를 통째로 넣지 않는다 — 세대별 feature -# module 이 필요한 `.so` 만 꺼내 싣는다(`QnnFeatureConventionPlugin`, 허용목록 방식). -qnn-runtime = { group = "com.qualcomm.qti", name = "qnn-runtime", version.ref = "qnnRuntime" } # 각인 OCR 전처리(NM-485). 기준 구현(ML `infer.py`)이 OpenCV 라 같은 라이브러리를 쓴다 — # CLAHE·형태학·연결요소를 손으로 옮기면 수치가 갈려도 조용히 틀린다. opencv = { group = "org.opencv", name = "opencv", version.ref = "opencv" } @@ -198,10 +173,6 @@ androidx-exifinterface = { group = "androidx.exifinterface", name = "exifinterfa [plugins] android-application = { id = "com.android.application", version.ref = "agp" } android-library = { id = "com.android.library", version.ref = "agp" } -# 조건부 전달 모듈(`qnn_core` + 세대별 `qnn_v##`). QNN 런타임을 퀄컴 기기에, 자기 세대 것만 내려보낸다. -# ⚠️ **버전을 적지 않는다** — AGP 는 build-logic 이 이미 classpath 에 올려 둬서, -# 버전을 주면 "already on the classpath with an unknown version" 으로 거절당한다. -android-dynamic-feature = { id = "com.android.dynamic-feature" } kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" } kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } @@ -219,5 +190,3 @@ nursemate-android-library = { id = "nursemate.android.library" } nursemate-android-library-compose = { id = "nursemate.android.library.compose" } nursemate-jvm-library = { id = "nursemate.jvm.library" } nursemate-hilt = { id = "nursemate.hilt" } -# Hexagon 세대 하나짜리 조건부 전달 모듈(`qnn_v73` 등)을 찍어낸다. -nursemate-qnn-feature = { id = "nursemate.qnn.feature" } diff --git a/qnn_core/build.gradle.kts b/qnn_core/build.gradle.kts deleted file mode 100644 index dcdf19cf..00000000 --- a/qnn_core/build.gradle.kts +++ /dev/null @@ -1,7 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// 세대와 무관한 QNN 토대 — EP 번역기 + libQnnHtp · libQnnSystem (9.2MB). -// 세대별 Skel 은 qnn_v69 · qnn_v73 · qnn_v75 · qnn_v79 · qnn_v81 이 따로 들고 온다. -// 자세한 것은 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_core/src/main/AndroidManifest.xml b/qnn_core/src/main/AndroidManifest.xml deleted file mode 100644 index 8c801729..00000000 --- a/qnn_core/src/main/AndroidManifest.xml +++ /dev/null @@ -1,30 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - diff --git a/qnn_v69/build.gradle.kts b/qnn_v69/build.gradle.kts deleted file mode 100644 index c8cd0c1e..00000000 --- a/qnn_v69/build.gradle.kts +++ /dev/null @@ -1,6 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// Hexagon V69 — 8 Gen 1 · 8+ Gen 1 (SM8450 · SM8475). -// 무엇을 싣고 무엇을 버리는지는 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_v69/src/main/AndroidManifest.xml b/qnn_v69/src/main/AndroidManifest.xml deleted file mode 100644 index 963aca14..00000000 --- a/qnn_v69/src/main/AndroidManifest.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/qnn_v73/build.gradle.kts b/qnn_v73/build.gradle.kts deleted file mode 100644 index fea19767..00000000 --- a/qnn_v73/build.gradle.kts +++ /dev/null @@ -1,6 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// Hexagon V73 — 8 Gen 2 (SM8550). -// 무엇을 싣고 무엇을 버리는지는 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_v73/src/main/AndroidManifest.xml b/qnn_v73/src/main/AndroidManifest.xml deleted file mode 100644 index 3d25e3a3..00000000 --- a/qnn_v73/src/main/AndroidManifest.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/qnn_v75/build.gradle.kts b/qnn_v75/build.gradle.kts deleted file mode 100644 index eee8bdda..00000000 --- a/qnn_v75/build.gradle.kts +++ /dev/null @@ -1,6 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// Hexagon V75 — 8 Gen 3 (SM8650). -// 무엇을 싣고 무엇을 버리는지는 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_v75/src/main/AndroidManifest.xml b/qnn_v75/src/main/AndroidManifest.xml deleted file mode 100644 index f429652a..00000000 --- a/qnn_v75/src/main/AndroidManifest.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/qnn_v79/build.gradle.kts b/qnn_v79/build.gradle.kts deleted file mode 100644 index 6617f51a..00000000 --- a/qnn_v79/build.gradle.kts +++ /dev/null @@ -1,6 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// Hexagon V79 — 8 Elite (SM8750). -// 무엇을 싣고 무엇을 버리는지는 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_v79/src/main/AndroidManifest.xml b/qnn_v79/src/main/AndroidManifest.xml deleted file mode 100644 index 216b05ad..00000000 --- a/qnn_v79/src/main/AndroidManifest.xml +++ /dev/null @@ -1,26 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/qnn_v81/build.gradle.kts b/qnn_v81/build.gradle.kts deleted file mode 100644 index 1ae43ace..00000000 --- a/qnn_v81/build.gradle.kts +++ /dev/null @@ -1,6 +0,0 @@ -plugins { - alias(libs.plugins.nursemate.qnn.feature) -} - -// Hexagon V81 — Snapdragon 8 Elite Gen 5 (SM8850). Galaxy S26. -// 무엇을 싣고 무엇을 버리는지는 QnnFeatureConventionPlugin KDoc. diff --git a/qnn_v81/src/main/AndroidManifest.xml b/qnn_v81/src/main/AndroidManifest.xml deleted file mode 100644 index 3d72ec1c..00000000 --- a/qnn_v81/src/main/AndroidManifest.xml +++ /dev/null @@ -1,23 +0,0 @@ - - - - - - - - - - - - - - - - - diff --git a/settings.gradle.kts b/settings.gradle.kts index f388fd73..0f619712 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -42,15 +42,6 @@ enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") include(":app") include(":wear") -// 조건부 전달 — Hexagon 세대마다 하나씩. 기기는 자기 세대 모듈 하나만 받는다. -// 세대를 더할 때는 모듈 디렉터리 · app 의 dynamicFeatures · 기기그룹 셋을 같이 손본다. -// 세대와 무관한 토대. 세대 모듈들이 이걸 문다. -include(":qnn_core") -include(":qnn_v69") -include(":qnn_v73") -include(":qnn_v75") -include(":qnn_v79") -include(":qnn_v81") include(":core:model") include(":core:data") include(":core:timer")