API de Swift de LiteRT-LM

La API de Swift de LiteRT-LM te permite integrar modelos de lenguaje grandes de forma nativa en aplicaciones para iOS y macOS. Se admiten por completo funciones como la multimodalidad, el uso de herramientas y la aceleración de GPU (a través de Metal).

Introducción

Este es un ejemplo del uso de la API de Swift para inicializar un modelo y enviar un mensaje:

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)

Comenzar

En esta sección, se proporcionan instrucciones para integrar la API de Swift de LiteRT-LM en tu aplicación.

Swift Package Manager (SPM)

Puedes integrar LiteRT-LM en tu proyecto de Xcode con Swift Package Manager.

  1. Abre tu proyecto en Xcode y navega a Archivo > Agregar dependencias de paquetes…
  2. Ingresa la URL del repositorio de paquetes: https://github.com/google-ai-edge/LiteRT-LM
  3. Selecciona la biblioteca LiteRTLM para agregarla al destino de tu aplicación.

Si desarrollas un paquete con Package.swift, agrégalo a tus dependencias:

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

Guía de la API principal

En esta sección, se detallan los componentes y flujos de trabajo fundamentales para usar la API de Swift de LiteRT-LM, incluida la inicialización del motor, la administración de conversaciones y el envío de mensajes.

Inicializa el motor

El Engine controla la carga del modelo, la asignación de recursos y la administración del ciclo de vida.

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

Crea una conversación

Una Conversation administra el historial de chat, las instrucciones del sistema y las configuraciones del muestreador.

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

Envía mensajes

Puedes interactuar con el modelo de forma síncrona o asíncrona (transmisión).

Ejemplo síncrono

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

Ejemplo asíncrono (transmisión)

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

Multimodalidad

Para usar funciones de visión o audio, asegúrate de configurar los backends especializados durante la inicialización del motor.

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

Entrada de imagen (visión)

Proporciona una imagen como una ruta de acceso o bytes sin procesar:

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)

Entrada de audio

Proporciona una ruta de acceso de 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)

🔴 Nuevo: Predicción de varios tokens (MTP)

La predicción de varios tokens (MTP) es una optimización del rendimiento que acelera significativamente las velocidades de decodificación. Se recomienda universalmente para todas las tareas que usan backends de GPU/Metal.

Para usar MTP, habilita la decodificación especulativa en las marcas experimentales antes de inicializar el motor.

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

Define y usa herramientas

Puedes definir estructuras de Swift como herramientas que el modelo puede llamar automáticamente para ejecutar la lógica.

  1. Cumple con el protocolo Tool.
  2. Declara parámetros con el wrapper de propiedad @ToolParam.
  3. Implementa el método 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)