Erste Schritte mit LiteRT-LM unter Android

Die Kotlin API von LiteRT-LM für Android und JVM (Linux, MacOS, Windows) mit Funktionen wie GPU- und NPU-Beschleunigung, Multimodalität und Verwendung von Tools.

Einführung

Hier ist eine Beispiel-Terminal-Chat-App, die mit der Kotlin API erstellt wurde:

import com.google.ai.edge.litertlm.*

suspend fun main() {
  Engine.setNativeMinLogSeverity(LogSeverity.ERROR) // Hide log for TUI app

  val engineConfig = EngineConfig(modelPath = "/path/to/model.litertlm")
  Engine(engineConfig).use { engine ->
    engine.initialize()

    engine.createConversation().use { conversation ->
      while (true) {
        print("\n>>> ")
        conversation.sendMessageAsync(readln()).collect { print(it) }
      }
    }
  }
}

Demo für den Kotlin-Beispielcode

Wenn Sie das obige Beispiel ausprobieren möchten, klonen Sie das Repository und führen Sie es mit example/Main.kt aus:

bazel run -c opt //kotlin/java/com/google/ai/edge/litertlm/example:main -- <abs_model_path>

Verfügbare .litertlm-Modelle finden Sie in der Hugging Face LiteRT-Community. Für die obige Animation wurde Gemma3-1B-IT verwendet.

Ein Android-Beispiel finden Sie in der Google AI Edge-Galerie App.

Erste Schritte mit Gradle

LiteRT-LM wird mit Bazel entwickelt, aber wir stellen die Maven-Pakete für Gradle-/Maven-Nutzer bereit.

1. Gradle-Abhängigkeit hinzufügen

dependencies {
    // For Android
    implementation("com.google.ai.edge.litertlm:litertlm-android:latest.release")

    // For JVM (Linux, MacOS, Windows)
    implementation("com.google.ai.edge.litertlm:litertlm-jvm:latest.release")
}

Die verfügbaren Versionen finden Sie in Google Maven unter litertlm-android und litertlm-jvm.

Mit latest.release können Sie das aktuelle Release abrufen.

2. Engine initialisieren

Engine ist der Einstiegspunkt zur API. Initialisieren Sie sie mit dem Modellpfad und der Konfiguration. Denken Sie daran, die Engine zu schließen, um Ressourcen freizugeben.

Hinweis:Das Laden des Modells mit der Methode engine.initialize() kann viel Zeit in Anspruch nehmen (z.B. bis zu 10 Sekunden). Es wird dringend empfohlen, diese Funktion in einem Hintergrundthread oder einer Coroutine aufzurufen, um den UI-Thread nicht zu blockieren.

import com.google.ai.edge.litertlm.Backend
import com.google.ai.edge.litertlm.Engine
import com.google.ai.edge.litertlm.EngineConfig

val engineConfig = EngineConfig(
    modelPath = "/path/to/your/model.litertlm", // Replace with your model path
    backend = Backend.GPU(), // Or Backend.NPU(nativeLibraryDir = "...")
    // Optional: Pick a writable dir. This can improve 2nd load time.
    // cacheDir = "/tmp/" or context.cacheDir.path (for Android)
)

val engine = Engine(engineConfig)
engine.initialize()
// ... Use the engine to create a conversation ...

// Close the engine when done
engine.close()

Wenn Sie das GPU-Backend unter Android verwenden möchten, muss die App die entsprechenden nativen Bibliotheken explizit anfordern. Fügen Sie dazu Folgendes in AndroidManifest.xml innerhalb des <application>-Tags ein:

  <application>
    <uses-native-library android:name="libvndksupport.so" android:required="false"/>
    <uses-native-library android:name="libOpenCL.so" android:required="false"/>
  </application>

Wenn Sie das NPU-Backend verwenden möchten, müssen Sie möglicherweise das Verzeichnis angeben, das die NPU-Bibliotheken enthält. Wenn die Bibliotheken unter Android mit Ihrer App gebündelt sind, legen Sie den Wert auf context.applicationInfo.nativeLibraryDir fest. Weitere Informationen zu den NPU-nativen Bibliotheken finden Sie unter LiteRT-LM NPU.

val engineConfig = EngineConfig(
    modelPath = modelPath,
    backend = Backend.NPU(nativeLibraryDir = context.applicationInfo.nativeLibraryDir)
)

3. Unterhaltung erstellen

Erstellen Sie nach der Initialisierung der Engine eine Conversation-Instanz. Sie können einen ConversationConfig angeben, um das Verhalten anzupassen.

import com.google.ai.edge.litertlm.ConversationConfig
import com.google.ai.edge.litertlm.Message
import com.google.ai.edge.litertlm.SamplerConfig

// Optional: Configure the system instruction, initial messages, sampling
// parameters, etc.
val conversationConfig = ConversationConfig(
    systemInstruction = Contents.of("You are a helpful assistant."),
    initialMessages = listOf(
        Message.user("What is the capital city of the United States?"),
        Message.model("Washington, D.C."),
    ),
    samplerConfig = SamplerConfig(topK = 10, topP = 0.95, temperature = 0.8),
)

val conversation = engine.createConversation(conversationConfig)
// Or with default config:
// val conversation = engine.createConversation()

// ... Use the conversation ...

// Close the conversation when done
conversation.close()

Conversation implementiert AutoCloseable. Sie können den use-Block also für die automatische Ressourcenverwaltung für einmalige oder kurzlebige Unterhaltungen verwenden:

engine.createConversation(conversationConfig).use { conversation ->
    // Interact with the conversation
}

4. Nachrichten senden

Es gibt drei Möglichkeiten, Nachrichten zu senden:

  • sendMessage(contents): Message: Synchroner Aufruf, der blockiert wird, bis das Modell eine vollständige Antwort zurückgibt. Das ist einfacher für grundlegende Anfrage-/Antwort-Interaktionen.
  • sendMessageAsync(contents, callback): Asynchroner Aufruf für Streamingantworten. Das ist besser für Anfragen, die lange dauern, oder wenn Sie die Antwort anzeigen möchten, während sie generiert wird.
  • sendMessageAsync(contents): Flow<Message>: Asynchroner Aufruf, der einen Kotlin-Flow für Streaming-Antworten zurückgibt. Dies ist der empfohlene Ansatz für Nutzer von Coroutines.

Synchrones Beispiel:

import com.google.ai.edge.litertlm.Content
import com.google.ai.edge.litertlm.Message

print(conversation.sendMessage("What is the capital of France?"))

Asynchrones Beispiel mit Callback:

Mit sendMessageAsync können Sie eine Nachricht an das Modell senden und Antworten über einen Callback erhalten.

import com.google.ai.edge.litertlm.Content
import com.google.ai.edge.litertlm.Message
import com.google.ai.edge.litertlm.MessageCallback
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

val callback = object : MessageCallback {
    override fun onMessage(message: Message) {
        print(message)
    }

    override fun onDone() {
        // Streaming completed
    }

    override fun onError(throwable: Throwable) {
        // Error during streaming
    }
}

conversation.sendMessageAsync("What is the capital of France?", callback)

Asynchrones Beispiel mit Flow:

Verwenden Sie sendMessageAsync (ohne das Callback-Argument), um eine Nachricht an das Modell zu senden und Antworten über einen Kotlin-Flow zu empfangen.

import com.google.ai.edge.litertlm.Content
import com.google.ai.edge.litertlm.Message
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.launch

// Within a coroutine scope
conversation.sendMessageAsync("What is the capital of France?")
    .catch { ... } // Error during streaming
    .collect { print(it.toString()) }

5. Multimodalität

Message-Objekte können verschiedene Arten von Content enthalten, darunter Text, ImageBytes, ImageFile, AudioBytes und AudioFile.

// Initialize the `visionBackend` and/or the `audioBackend`
val engineConfig = EngineConfig(
    modelPath = "/path/to/your/model.litertlm", // Replace with your model path
    backend = Backend.CPU(), // Or Backend.GPU() or Backend.NPU(...)
    visionBackend = Backend.GPU(), // Or Backend.NPU(...)
    audioBackend = Backend.CPU(), // Or Backend.NPU(...)
)

// Sends a message with multi-modality.
// See the Content class for other variants.
conversation.sendMessage(Contents.of(
    Content.ImageFile("/path/to/image"),
    Content.AudioBytes(audioBytes), // ByteArray of the audio
    Content.Text("Describe this image and audio."),
))

6. Tools definieren und verwenden

Es gibt zwei Möglichkeiten, Tools zu definieren:

  1. Mit Kotlin-Funktionen (in den meisten Fällen empfohlen)
  2. Mit OpenAPI-Spezifikation (volle Kontrolle über die Tool-Spezifikation und -Ausführung)

Tools mit Kotlin-Funktionen definieren

Sie können benutzerdefinierte Kotlin-Funktionen als Tools definieren, die das Modell aufrufen kann, um Aktionen auszuführen oder Informationen abzurufen.

Erstellen Sie eine Klasse, die ToolSet implementiert, und versehen Sie Methoden mit @Tool und Parameter mit @ToolParam.

import com.google.ai.edge.litertlm.Tool
import com.google.ai.edge.litertlm.ToolParam

class SampleToolSet: ToolSet {
    @Tool(description = "Get the current weather for a city")
    fun getCurrentWeather(
        @ToolParam(description = "The city name, e.g., San Francisco") city: String,
        @ToolParam(description = "Optional country code, e.g., US") country: String? = null,
        @ToolParam(description = "Temperature unit (celsius or fahrenheit). Default: celsius") unit: String = "celsius"
    ): Map<String, Any> {
        // In a real application, you would call a weather API here
        return mapOf("temperature" to 25, "unit" to  unit, "condition" to "Sunny")
    }

    @Tool(description = "Get the sum of a list of numbers.")
    fun sum(
        @ToolParam(description = "The numbers, could be floating point.") numbers: List<Double>,
    ): Double {
        return numbers.sum()
    }
}

Im Hintergrund werden diese Anmerkungen und die Funktionssignatur von der API geprüft, um ein Schema im OpenAPI-Stil zu generieren. Dieses Schema beschreibt die Funktionalität, die Parameter (einschließlich ihrer Typen und Beschreibungen aus @ToolParam) und den Rückgabetyp des Tools für das Sprachmodell.

Parametertypen

Die Typen für Parameter, die mit @ToolParam annotiert sind, können String, Int, Boolean, Float, Double oder eine List dieser Typen sein (z.B. List<String>). Verwenden Sie Nullable-Typen (z.B. String?), um Parameter anzugeben, die Nullwerte zulassen. Legen Sie einen Standardwert fest, um anzugeben, dass der Parameter optional ist, und erwähnen Sie den Standardwert in der Beschreibung in @ToolParam.

Rückgabetyp

Der Rückgabetyp Ihrer Tool-Funktion kann ein beliebiger Kotlin-Typ sein. Das Ergebnis wird in ein JSON-Element umgewandelt, bevor es an das Modell zurückgesendet wird.

  • List-Typen werden in JSON-Arrays konvertiert.
  • Map-Typen werden in JSON-Objekte konvertiert.
  • Primitive Typen (String, Number, Boolean) werden in das entsprechende JSON-Primitiv konvertiert.
  • Andere Typen werden mit der Methode toString() in Strings konvertiert.

Für strukturierte Daten wird empfohlen, Map oder eine Datenklasse zurückzugeben, die in ein JSON-Objekt konvertiert wird.

Tools mit der OpenAPI-Spezifikation definieren

Alternativ können Sie ein Tool definieren, indem Sie die Klasse OpenApiTool implementieren und die Beschreibung des Tools als JSON-String bereitstellen, der der Open API-Spezifikation entspricht. Diese Methode ist nützlich, wenn Sie bereits ein OpenAPI-Schema für Ihr Tool haben oder wenn Sie die Definition des Tools genau steuern müssen.

import com.google.ai.edge.litertlm.OpenApiTool

class SampleOpenApiTool : OpenApiTool {

    override fun getToolDescriptionJsonString(): String {
        return """
        {
          "name": "addition",
          "description": "Add all numbers.",
          "parameters": {
            "type": "object",
            "properties": {
              "numbers": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              },
              "description": "The list of numbers to sum."
            },
            "required": [
              "numbers"
            ]
          }
        }
        """.trimIndent() // Tip: trim to save tokens
    }

    override fun execute(paramsJsonString: String): String {
        // Parse paramsJsonString with your choice of parser/deserializer and
        // execute the tool.

        // Return the result as a JSON string
        return """{"result": 1.4142}"""
    }
}

Tools registrieren

Fügen Sie Instanzen Ihrer Tools in ConversationConfig ein.

val conversation = engine.createConversation(
    ConversationConfig(
        tools = listOf(
            tool(SampleToolSet()),
            tool(SampleOpenApiTool()),
        ),
        // ... other configs
    )
)

// Send messages that might trigger the tool
conversation.sendMessageAsync("What's the weather like in London?", callback)

Das Modell entscheidet anhand der Unterhaltung, wann das Tool aufgerufen werden soll. Die Ergebnisse der Tool-Ausführung werden automatisch an das Modell zurückgesendet, um die endgültige Antwort zu generieren.

Manuelle Toolaufrufe

Standardmäßig werden von LiteRT-LM generierte Tool-Aufrufe automatisch ausgeführt und die Ergebnisse der Tool-Ausführung werden automatisch an das Modell zurückgesendet, um die nächste Antwort zu generieren.

Wenn Sie Tools manuell ausführen und Ergebnisse an das Modell zurücksenden möchten, können Sie automaticToolCalling in ConversationConfig auf false festlegen.

val conversation = engine.createConversation(
    ConversationConfig(
        tools = listOf(
            tool(SampleOpenApiTool()),
        ),
        automaticToolCalling = false,
    )
)

Wenn Sie den automatischen Tool-Aufruf deaktivieren, müssen Sie Tools manuell ausführen und Ergebnisse in Ihrem Anwendungscode an das Modell zurücksenden. Die execute-Methode von OpenApiTool wird nicht automatisch aufgerufen, wenn automaticToolCalling auf false festgelegt ist.

// Send a message that triggers a tool call.
val responseMessage = conversation.sendMessage("What's the weather like in London?")

// The model returns a Message with `toolCalls` populated.
if (responseMessage.toolCalls.isNotEmpty()) {
    val toolResponses = mutableListOf<Content.ToolResponse>()
    // There can be multiple tool calls in a single response.
    for (toolCall in responseMessage.toolCalls) {
        println("Model wants to call: ${toolCall.name} with arguments: ${toolCall.arguments}")

        // Execute the tool manually with your own logic. `executeTool` is just an example here.
        val toolResponseJson = executeTool(toolCall.name, toolCall.arguments)

        // Collect tool responses.
        toolResponses.add(Content.ToolResponse(toolCall.name, toolResponseJson))
    }

    // Use Message.tool to create the tool response message.
    val toolResponseMessage = Message.tool(Contents.of(toolResponses))

    // Send the tool response message to the model.
    val finalMessage = conversation.sendMessage(toolResponseMessage)
    println("Final answer: ${finalMessage.text}") // e.g., "The weather in London is 25c."
}

Beispiel

Wenn Sie die Verwendung von Tools ausprobieren möchten, klonen Sie das Repository und führen Sie es mit example/ToolMain.kt aus:

bazel run -c opt //kotlin/java/com/google/ai/edge/litertlm/example:tool -- <abs_model_path>

Fehlerbehandlung

API-Methoden können LiteRtLmJniException für Fehler aus der nativen Ebene oder Standard-Kotlin-Ausnahmen wie IllegalStateException für Probleme mit dem Lebenszyklus auslösen. Kapseln Sie API-Aufrufe immer in try-catch-Blöcken. Im onError-Callback in MessageCallback werden auch Fehler bei asynchronen Vorgängen gemeldet.