Add PlantNet-300K fine-grained plant identification sample (CompiledModel GPU)

PlantNet-300K ResNet18 (cpoisson/plantnet300k-resnet18, Apache-2.0; NeurIPS 2021 plantnet/PlantNet-300K) — fine-grained identification of 1081 plant species, running fully on the LiteRT CompiledModel GPU at ~16 ms/frame on a Pixel 8a.

Plain torchvision ResNet18 (pure CNN) -> fully GPU-compatible (37/37 nodes on the delegate, 1 partition) with one patch: ZeroPadMaxPool (the ResNet stem maxpool's -inf PADV2 is rejected as 'PADV2: src has wrong size', replaced by an explicit 0-pad + unpadded maxpool, exact post-ReLU). CPU-exact vs PyTorch (corr 0.99999999999); device Mali GPU corr 0.99999, top-1 match.

Sample at compiled_model_api/image_classification/plantnet_kotlin_gpu (android app + conversion scripts), with a deterministic bundled plant photo demo.

Author: john-rocky

compiled_model_api/image_classification/plantnet_kotlin_gpu/README.md

@@ -0,0 +1,41 @@
+# PlantNet-300K — Fine-grained plant identification (LiteRT CompiledModel GPU)
+
+Identify **1081 plant species** from a photo, running **fully on the LiteRT
+`CompiledModel` GPU** delegate. A [PlantNet-300K](https://github.com/plantnet/PlantNet-300K)
+(NeurIPS 2021) ResNet18. ~16 ms/frame on a Pixel 8a.
+
+- **Model:** [litert-community/PlantNet-300K-ResNet18-LiteRT](https://huggingface.co/litert-community/PlantNet-300K-ResNet18-LiteRT) · 47 MB
+- **Weights:** [cpoisson/plantnet300k-resnet18](https://huggingface.co/cpoisson/plantnet300k-resnet18) · Apache-2.0
+- **Input:** `[1, 3, 224, 224]` NCHW, RGB, ImageNet-normalized
+- **Output:** `[1, 1081]` species logits (Latin names)
+
+## How it works
+
+Plain torchvision ResNet18 — a pure CNN. It converts to a fully GPU-compatible graph
+(**37/37 nodes on the delegate, 1 partition**; device corr 0.99999, top-1 match) with
+**one patch**: the ResNet stem `MaxPool2d(padding=1)` lowers to a PADV2 with `-inf`
+padding (`PADV2: src has wrong size` on the Mali delegate), replaced by an explicit
+0-pad + unpadded maxpool (exact post-ReLU). CPU-exact vs PyTorch (corr 0.99999999999).
+
+Preprocess: RGB, center-crop → resize 224×224, ImageNet normalize, NCHW. Postprocess:
+softmax + top-k. Class index → species via sorted PlantNet species-id order
+(`PlantNetLabels.kt`).
+
+## Run
+
+```bash
+# 1. Get the model (build with ../conversion or download from Hugging Face)
+cd android
+./install_to_device.sh <dir-with-plantnet.tflite>
+
+# 2. Build & run
+./gradlew :app:installDebug
+```
+
+The sample classifies a bundled plant photo and shows the top-5 species. Adapt
+`MainActivity.kt` to feed live camera frames for a real-time plant-ID demo.
+
+## Convert
+
+See [`conversion/`](conversion/) — `build_plantnet.py` loads the Apache-2.0 ResNet18
+weights and converts with litert-torch.

compiled_model_api/image_classification/plantnet_kotlin_gpu/android/.gitignore

@@ -0,0 +1,12 @@
+*.iml
+.gradle
+/local.properties
+/.idea
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+local.properties
+# model files are pushed to the device, never committed
+*.tflite

compiled_model_api/image_classification/plantnet_kotlin_gpu/android/app/build.gradle.kts

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+  id("com.android.application")
+  id("org.jetbrains.kotlin.android")
+}
+
+android {
+  namespace = "com.google.ai.edge.examples.plantnet"
+  compileSdk = 35
+
+  defaultConfig {
+    applicationId = "com.google.ai.edge.examples.plantnet"
+    minSdk = 26
+    targetSdk = 35
+    versionCode = 1
+    versionName = "1.0"
+    ndk { abiFilters += setOf("arm64-v8a") }
+  }
+
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+  }
+  kotlinOptions { jvmTarget = "17" }
+
+  packaging {
+    jniLibs {
+      pickFirsts += setOf(
+        "**/libc++_shared.so",
+        "**/libtensorflowlite_jni.so",
+        "**/libtensorflowlite_gpu_jni.so",
+      )
+    }
+  }
+
+  androidResources { noCompress += listOf("tflite", "txt", "bin") }
+}
+
+dependencies {
+  implementation("com.google.ai.edge.litert:litert:2.1.5")
+  implementation("androidx.core:core-ktx:1.15.0")
+  implementation("androidx.appcompat:appcompat:1.7.0")
+}

compiled_model_api/image_classification/plantnet_kotlin_gpu/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:label="PlantNet"
+        android:theme="@style/Theme.AppCompat.Light.NoActionBar"
+        android:supportsRtl="true">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:screenOrientation="portrait">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

compiled_model_api/image_classification/plantnet_kotlin_gpu/android/app/src/main/assets/plant.jpg

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.ai.edge.examples.plantnet
+
+import android.graphics.BitmapFactory
+import android.os.Bundle
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import java.io.File
+import java.util.concurrent.Executors
+
+/**
+ * Runs PlantNet-300K on a bundled plant photo and prints the top-5 species — a
+ * deterministic, self-contained demo. The 47 MB model is loaded from the app's
+ * filesDir; push it there first with install_to_device.sh (not bundled in the APK).
+ */
+class MainActivity : AppCompatActivity() {
+
+  private val executor = Executors.newSingleThreadExecutor()
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val status = TextView(this).apply { textSize = 16f; setPadding(28, 40, 28, 20) }
+    val imageView = ImageView(this).apply { adjustViewBounds = true }
+    setContentView(LinearLayout(this).apply {
+      orientation = LinearLayout.VERTICAL
+      addView(status); addView(imageView)
+    })
+
+    executor.execute {
+      val modelFile = File(filesDir, "plantnet.tflite")
+      if (!modelFile.exists()) {
+        runOnUiThread {
+          status.text = "Model not found at:\n${modelFile.absolutePath}\n\n" +
+            "Push it first:  ./install_to_device.sh <dir-with-plantnet.tflite>\n" +
+            "(build with ../conversion or download from\n litert-community/PlantNet-300K-ResNet18-LiteRT)"
+        }
+        return@execute
+      }
+      val input = assets.open("plant.jpg").use { BitmapFactory.decodeStream(it) }
+      PlantClassifier(modelFile.absolutePath).use { clf ->
+        val (preds, ms) = clf.classify(input)
+        val txt = "PlantNet-300K  ·  CompiledModel GPU  ·  ${ms} ms\n\n" +
+          preds.joinToString("\n") { (n, p) -> "%s   %d%%".format(n, (p * 100).toInt()) }
+        runOnUiThread { status.text = txt; imageView.setImageBitmap(input) }
+      }
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    executor.shutdown()
+  }
+}

compiled_model_api/image_classification/plantnet_kotlin_gpu/android/app/src/main/java/com/google/ai/edge/examples/plantnet/MainActivity.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2025 The Google AI Edge Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.ai.edge.examples.plantnet
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.util.Log
+import com.google.ai.edge.litert.Accelerator
+import com.google.ai.edge.litert.CompiledModel
+import com.google.ai.edge.litert.TensorBuffer
+
+/**
+ * PlantNet-300K fine-grained plant species classifier on LiteRT CompiledModel (GPU).
+ *
+ * Input : [1, 3, 224, 224]  NCHW, RGB, ImageNet-normalized.
+ * Output: [1, 1081]         species logits (PlantNet-300K, Latin names).
+ *
+ * A torchvision ResNet18 (pure CNN). One re-authoring patch (baked into the graph,
+ * see conversion/): the ResNet stem MaxPool's -inf-pad PADV2 is replaced with a
+ * 0-pad + unpadded maxpool (exact post-ReLU), which the Mali delegate accepts.
+ */
+class PlantClassifier(modelPath: String) : AutoCloseable {
+
+  companion object {
+    private const val TAG = "PlantNet"
+    const val SIZE = 224
+    private val MEAN = floatArrayOf(0.485f, 0.456f, 0.406f)
+    private val STD = floatArrayOf(0.229f, 0.224f, 0.225f)
+  }
+
+  private val model = CompiledModel.create(modelPath, CompiledModel.Options(Accelerator.GPU), null)
+  private val inBufs: List<TensorBuffer> = model.createInputBuffers()
+  private val outBufs: List<TensorBuffer> = model.createOutputBuffers()
+
+  private val inputFloats = FloatArray(3 * SIZE * SIZE)
+  private val pixels = IntArray(SIZE * SIZE)
+  private val resized = Bitmap.createBitmap(SIZE, SIZE, Bitmap.Config.ARGB_8888)
+  private val matrix = Matrix()
+  private val paint = Paint(Paint.FILTER_BITMAP_FLAG)
+
+  init {
+    Log.i(TAG, "GPU compiled OK — ${inBufs.size} in / ${outBufs.size} out")
+  }
+
+  /** Classify. Returns top-[topK] (species name, probability) + time (ms). */
+  fun classify(bitmap: Bitmap, topK: Int = 5): Pair<List<Pair<String, Float>>, Long> {
+    val t = System.nanoTime()
+    val side = minOf(bitmap.width, bitmap.height)
+    matrix.reset()
+    matrix.postTranslate(-(bitmap.width - side) / 2f, -(bitmap.height - side) / 2f)
+    matrix.postScale(SIZE.toFloat() / side, SIZE.toFloat() / side)
+    Canvas(resized).drawBitmap(bitmap, matrix, paint)
+    resized.getPixels(pixels, 0, SIZE, 0, 0, SIZE, SIZE)
+    val plane = SIZE * SIZE
+    for (i in 0 until plane) {
+      val p = pixels[i]
+      inputFloats[i] = (((p shr 16) and 0xFF) / 255f - MEAN[0]) / STD[0]
+      inputFloats[plane + i] = (((p shr 8) and 0xFF) / 255f - MEAN[1]) / STD[1]
+      inputFloats[2 * plane + i] = ((p and 0xFF) / 255f - MEAN[2]) / STD[2]
+    }
+    inBufs[0].writeFloat(inputFloats)
+    model.run(inBufs, outBufs)
+    val logits = outBufs[0].readFloat()   // [1081]
+
+    val idx = logits.indices.sortedByDescending { logits[it] }.take(topK)
+    val mx = logits[idx.first()]
+    var sum = 0.0
+    for (v in logits) sum += Math.exp((v - mx).toDouble())
+    val preds = idx.map { i ->
+      PlantNetLabels.NAMES[i] to (Math.exp((logits[i] - mx).toDouble()) / sum).toFloat()
+    }
+    return preds to ((System.nanoTime() - t) / 1_000_000)
+  }
+
+  override fun close() {
+    model.close()
+    if (!resized.isRecycled) resized.recycle()
+  }
+}