API Swift LiteRT-LM

L'API Swift de LiteRT-LM vous permet d'intégrer des grands modèles de langage de manière native dans les applications iOS et macOS. Les fonctionnalités telles que la multimodalité, l'utilisation d'outils et l'accélération GPU (via Metal) sont entièrement compatibles.

Introduction

Voici un exemple d'utilisation de l'API Swift pour initialiser un modèle et envoyer un message :

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)

Premiers pas

Cette section explique comment intégrer l'API Swift LiteRT-LM à votre application.

Swift Package Manager (SPM)

Vous pouvez intégrer LiteRT-LM à votre projet Xcode à l'aide de Swift Package Manager.

  1. Ouvrez votre projet dans Xcode, puis accédez à File > Add Package Dependencies... (Fichier > Ajouter des dépendances de package).
  2. Saisissez l'URL du dépôt de packages : https://github.com/google-ai-edge/LiteRT-LM
  3. Sélectionnez la bibliothèque LiteRTLM pour l'ajouter à la cible de votre application.

Si vous développez un package à l'aide de Package.swift, ajoutez-le à vos dépendances :

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

Guide de l'API principale

Cette section décrit les composants et workflows fondamentaux pour utiliser l'API Swift LiteRT-LM, y compris l'initialisation du moteur, la gestion des conversations et l'envoi de messages.

Initialiser le moteur

Le Engine gère le chargement du modèle, l'allocation des ressources et la gestion du cycle de vie.

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()

Créer une conversation

Une Conversation gère l'historique des discussions, les instructions système et les configurations de l'échantillonneur.

// 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)

Envoyer des messages

Vous pouvez interagir avec le modèle de manière synchrone ou asynchrone (streaming).

Exemple synchrone

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

Exemple asynchrone (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é

Pour utiliser des fonctionnalités de vision ou audio, veillez à configurer les backends spécialisés lors de l'initialisation du moteur.

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()

Image d'entrée (vision)

Fournissez une image sous forme de chemin d'accès ou d'octets bruts :

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)

Entrée audio

Fournissez un chemin d'accès audio :

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)

🔴 Nouveauté : Prédiction de plusieurs jetons (MTP)

La prédiction de plusieurs jetons (MTP) est une optimisation des performances qui accélère considérablement les vitesses de décodage. Elle est universellement recommandée pour toutes les tâches utilisant des backends GPU/Metal.

Pour utiliser la MTP, activez le décodage spéculatif dans les flags expérimentaux avant d'initialiser le moteur.

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()

Définir et utiliser des outils

Vous pouvez définir des structures Swift comme des outils que le modèle peut appeler automatiquement pour exécuter une logique.

  1. Conformez-vous au protocole Tool.
  2. Déclarez les paramètres à l'aide du wrapper de propriété @ToolParam.
  3. Implémentez la méthode 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)