API 参考

import NexaSdk

// 加载模型
let asr = try Asr()
try await asr.load(from: "<path/to/model/dir>")

// 转写音频文件
let result = try await asr.transcribe(options: .init(audioPath: "<your-audio-path>"))
print(result.asrResult)

import NexaSdk

// 加载模型
let asr = try Asr()
try await asr.load(from: "<path/to/model/dir>")

do {
    // 开始录制并流式输出
    let stream = try asr.startRecordingStream()
    for try await content in stream {
        print(content)
    }
    // 停止流
    asr.stopRecordingStream()
} catch {
    asr.stopRecordingStream()
}

/// ASR transcription result
public struct AsrResult: Codable {
    /// Transcribed text
    public let transcript: String
    /// Confidence scores for each unit
    public let confidences: [Float]
    /// Timestamp pairs: [start, end] for each unit
    public let timestamps: [Float]
}

public struct AsrResponse: Codable {
    public let asrResult: AsrResult
    public let profileData: ProfileData?
}

public struct AsrOptions: Codable {
    public let modelPath: String
    public let language: Language
}

public enum Language: String, Codable {
    case en
    case ch
}

public struct ASRStreamConfig {
    // 时间戳模式
    public enum TimestampMode: String {
        case segment
        case word
        case none
    }

    // 语言
    public var language: Language = .en
    // 每个分片时长（默认 4.0 秒）
    public var chunkDuration: Float
    // 分片重叠时长（默认 3.0 秒）
    public var overlapDuration: Float
    // 采样率（默认 16000）
    public var sampleRate: Int32
    // 队列最大分片数（默认 10）
    public var maxQueueSize: Int32
    // 输入缓冲大小（默认 512）
    public var bufferSize: Int32
    // 时间戳模式："none" | "segment" | "word"
    public var timestamps: TimestampMode
    // Beam size（默认 5）
    public var beamSize: Int32
}

import NexaSdk
import Foundation

// 加载 ANE 模型的 Embedder
let repoDir: URL = URL(string: "path/to/model/dir")!
let embedder = try Embedder(from: repoDir, plugin: .ane)

// 针对多段文本生成向量
let texts = ["<your-text1>", "<your-text2>"]
let result = try embedder.embed(texts: texts, config: .init(batchSize: Int32(texts.count)))
for (i, vec) in result.embeddings.enumerated() {
    let head = vec.prefix(10)
    print("[\(i)]", Array(head))
}

public struct EmbeddingConfig {
    /// batch 大小
    public var batchSize: Int32

    /// 归一化方式："l2", "mean"
    /// `nil` 表示不归一化
    public var normalizeMethod: NormalizeMethod?
}

public struct EmbedResult {
    public let embeddings: [[Float]]
    public let profileData: ProfileData
}

import NexaSdk

let llm = try LLM()
// 从 GGUF 路径加载
try await llm.load(.init(modelPath: "<path/to/model/file>"))

let system = "You are a helpful AI assistant"
let userMsgs = [
    "Tell me a long story, about 100 words",
    "How are you"
]
var messages = [ChatMessage]()
messages.append(.init(role: .system, content: system))
for userMsg in userMsgs {
    messages.append(.init(role: .user, content: userMsg))
    // 生成
    let stream = try await llm.generateAsyncStream(messages: messages)
    var response = ""
    for try await token in stream {
        print(token, terminator: "")
        response += token
    }
    messages.append(.init(role: .assistant, content: response))
    print("\n\n")
}

import NexaSdk

let vlm = try VLM()
try await vlm.load(.init(modelPath: "<path/to/model/file>", mmprojPath: "<path/to/mmproj/file>"))

let images = ["<path/to/your/image>"]
var config = GenerationConfig.default
config.imagePaths = images
let message = ChatMessage(role: .user, content: "What do you see in this image", images: images)
let stream = try await vlm.generateAsyncStream(messages: [message], options: .init(config: config))

for try await token in stream {
    print(token, terminator: "")
}
print()

public struct GenerationConfig {
    public var maxTokens: Int32 
    public var stop: [String]  
    public var nPast: Int32           
    public var samplerConfig: SamplerConfig 
    public var imagePaths: [String] 
    public var audioPaths: [String]            
}

public struct SamplerConfig {
    public var temperature: Float
    public var topP: Float
    public var topK: Int32
    public var minP: Float
    public var repetitionPenalty: Float
    public var presencePenalty: Float
    public var frequencyPenalty: Float
    public var seed: Int32
    public var grammarPath: String?
 }

public struct ProfileData: CustomStringConvertible, Codable {
    public let ttft: Int64
    public let promptTime: Int64
    public let decodeTime: Int64
    public let promptTokens: Int64
    public let generatedTokens: Int64
    public let audioDuration: Int64
    public let prefillSpeed: Double
    public let decodingSpeed: Double
    public let realTimeFactor: Double
    public let stopReason: String
}

import NexaSdk
import Foundation

// 加载 CPU/GPU 重排模型
let repoDir = URL(string: "<path/to/model/dir>")!
let reranker = try Reranker(from: repoDir)
let query = "What is machine learning?"
let documents = [
    "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions ",
    "without being explicitly programmed.",
    "Machine learning algorithms build mathematical models based on sample data to make predictions or decisions.",
    "Deep learning is a subset of machine learning that uses neural networks with multiple layers.",
    "Python is a popular programming language for machine learning and data science.",
    "The weather today is sunny and warm."
]
let result = try await reranker.rerank(query, documents: documents)
print(result.scores)

public struct RerankerResult {
    public let scores: [Float]
    public let profileData: ProfileData
}

public struct RerankConfig {
    /// batch 大小
    public var batchSize: Int32

    /// 归一化："softmax" | "min-max" | "l2"；`nil` 表示不归一化
    public var normalizeMethod: NormalizeMethod?

    public enum NormalizeMethod: String, CaseIterable {
        case softmax
        case minMax = "min-max"
        case l2
    }
}

// CPU/GPU embedder - 使用 GGUF 格式模型
let embedder = try Embedder(from: "<path/to/model/dir>", plugin: .cpu_gpu)

// ANE embedder - 使用 CoreML 格式模型
let embedder = try Embedder(from: "<path/to/model/dir>", plugin: .ane)