LiteRT-LM Swift API

Mit der Swift API von LiteRT-LM können Sie Large Language Models nativ in iOS- und macOS -Anwendungen einbinden. Funktionen wie Multimodalität, Tool nutzung und GPU-Beschleunigung (über Metal) werden vollständig unterstützt.

Einführung

Hier ein Beispiel für die Verwendung der Swift API zum Initialisieren eines Modells und zum Senden einer Nachricht:

import LiteRTLM

// 1. Initialize the Engine with your model
let config = try EngineConfig(
  modelPath: "path/to/model.litertlm",
  backend: .gpu, // Use .cpu() for CPU execution
  cacheDir: NSTemporaryDirectory()
)
let engine = Engine(engineConfig: config)
try await engine.initialize()

// 2. Start a new Conversation
let conversation = try await engine.createConversation()

// 3. Send a message and print the response
let response = try await conversation.sendMessage(Message("What is the capital of France?"))
print(response.toString)

Erste Schritte

In diesem Abschnitt finden Sie eine Anleitung zum Einbinden der LiteRT-LM Swift API in Ihre Anwendung.

Swift Package Manager (SPM)

Sie können LiteRT-LM mit dem Swift Package Manager in Ihr Xcode-Projekt einbinden.

  1. Öffnen Sie Ihr Projekt in Xcode und wählen Sie File > Add Package Dependencies... aus.
  2. Geben Sie die URL des Paket-Repositorys ein: https://github.com/google-ai-edge/LiteRT-LM
  3. Wählen Sie die Bibliothek LiteRTLM aus, um sie Ihrem Anwendungsziel hinzuzufügen.

Wenn Sie ein Paket mit Package.swift entwickeln, fügen Sie es Ihren Abhängigkeiten hinzu:

dependencies: [
  .package(url: "https://github.com/google-ai-edge/LiteRT-LM", from: "0.12.0")
]

Anleitung zur Core API

In diesem Abschnitt werden die grundlegenden Komponenten und Arbeitsabläufe für die Verwendung der LiteRT-LM Swift API beschrieben, einschließlich der Initialisierung der Engine, der Unterhaltungsverwaltung und des Sendens von Nachrichten.

Engine initialisieren

Die Engine verarbeitet das Laden von Modellen, die Ressourcenzuweisung und die Lebenszyklusverwaltung.

import LiteRTLM

let engineConfig = try EngineConfig(
  modelPath: "path/to/your/model.litertlm",
  backend: .gpu, // Use .gpu for Metal hardware acceleration
  maxNumTokens: 512, // Size of the KV-cache
  cacheDir: NSTemporaryDirectory() // Writable directory for compilation cache
)

let engine = Engine(engineConfig: engineConfig)
try await engine.initialize()

Unterhaltung erstellen

Eine Conversation verwaltet den Chatverlauf, Systemanweisungen und Sampler-Konfigurationen.

// Configure custom sampling parameters
let samplerConfig = try SamplerConfig(
  topK: 40,
  topP: 0.95,
  temperature: 0.7
)

// Create the conversation config with system instructions
let config = ConversationConfig(
  systemMessage: Message("You are a helpful assistant."),
  samplerConfig: samplerConfig
)

let conversation = try await engine.createConversation(with: config)

Nachrichten senden

Sie können synchron oder asynchron (Streaming) mit dem Modell interagieren.

Synchrones Beispiel

let response = try await conversation.sendMessage(Message("Hello!"))
print(response.toString)

Asynchrones Beispiel (Streaming)

let message = Message("Tell me a long story.")

for try await chunk in conversation.sendMessageStream(message) {
  // Output response chunks in real-time
  print(chunk.toString, terminator: "")
}
print()

Multimodalität

Wenn Sie Bild- oder Audiofunktionen verwenden möchten, müssen Sie die speziellen Back-Ends bei der Initialisierung der Engine konfigurieren.

let engineConfig = try EngineConfig(
  modelPath: "path/to/multimodal_model.litertlm",
  backend: .gpu,
  visionBackend: .cpu(), // Enable CPU vision executor
  audioBackend: .cpu(), // Enable CPU audio executor
  cacheDir: NSTemporaryDirectory()
)
let engine = Engine(engineConfig: engineConfig)
try await engine.initialize()

Bildeingabe (Vision)

Geben Sie ein Bild als Pfad oder Rohbyte an:

let imagePath = Bundle.main.path(forResource: "scenery", ofType: "jpg")!

let message = Message(contents: [
  Content.imageFile(imagePath),
  Content.text("Describe this image.")
])

let response = try await conversation.sendMessage(message)
print(response.toString)

Audioeingabe

Geben Sie einen Audiopfad an:

let audioPath = Bundle.main.path(forResource: "recording", ofType: "wav")!

let message = Message(contents: [
  Content.audioFile(audioPath),
  Content.text("Transcribe this recording.")
])

let response = try await conversation.sendMessage(message)
print(response.toString)

🔴 Neu: Multi-Token Prediction (MTP)

Multi-Token Prediction (MTP) ist eine Leistungsoptimierung, die die Decodierungsgeschwindigkeit erheblich beschleunigt. Sie wird für alle Aufgaben empfohlen, die GPU-/Metal-Back-Ends verwenden.

Wenn Sie MTP verwenden möchten, aktivieren Sie die spekulative Decodierung in den experimentellen Flags, bevor Sie die Engine initialisieren.

import LiteRTLM

// Opt into experimental APIs to configure MTP
ExperimentalFlags.optIntoExperimentalAPIs()
ExperimentalFlags.enableSpeculativeDecoding = true

let engineConfig = try EngineConfig(
  modelPath: "path/to/model.litertlm",
  backend: .gpu,
  cacheDir: NSTemporaryDirectory()
)
let engine = Engine(engineConfig: engineConfig)
try await engine.initialize()

Tools definieren und verwenden

Sie können Swift-Strukturen als Tools definieren, die das Modell automatisch aufrufen kann, um Logik auszuführen.

  1. Entsprechen Sie dem Tool-Protokoll.
  2. Deklarieren Sie Parameter mit dem Property-Wrapper @ToolParam.
  3. Implementieren Sie die Methode run().
import LiteRTLM

// 1. Define your custom tool
struct GetCurrentWeatherTool: Tool {
  static let name = "get_current_weather"
  static let description = "Get the current weather for a location."

  @ToolParam(description: "The city and state, e.g. San Francisco, CA")
  var location: String

  @ToolParam(description: "The temperature unit to use (celsius or fahrenheit)")
  var unit: String = "celsius"

  func run() async throws -> Any {
    // Call your weather API here
    return [
      "location": location,
      "temperature": "22",
      "unit": unit,
      "condition": "sunny"
    ]
  }
}

// 2. Register the tool in your conversation configuration
let config = ConversationConfig(
  tools: [GetCurrentWeatherTool()]
)

let conversation = try await engine.createConversation(with: config)

// 3. The model will invoke the tool automatically if needed
let response = try await conversation.sendMessage(Message("What is the weather in Paris right now?"))
print(response.toString)