Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

4.9 KB
Raw Blame
import Foundation
import Observation
import Uzu

@Observable
final class ClassificationModel {
    // MARK: - Nested Types
    enum ViewState {
        case loading
        case idle
        case generating
        case error(Swift.Error)
    }

    // MARK: - Observable Properties
    var viewState: ViewState = .idle
    var inputText: String = ""
    var resultText: String = ""
    var stats: ReplyStats? = nil

    // MARK: - Private
    private let identifier: String
    private let feature: Feature
    private var session: ChatSession?
    private var loadingTask: Task<Void, Never>?
    private var generationTask: Task<Void, Never>?

    init(identifier: String, feature: Feature) {
        self.identifier = identifier
        self.feature = feature
    }

    // MARK: - Public API
    
    @MainActor
    func loadSession(using engineWrapper: EngineObservableWrapper) {
        guard
            case .idle = viewState,
            let engine = engineWrapper.engine,
            let model = engineWrapper.models.first(where: { $0.identifier == identifier }) else {
            return
        }

        if self.session != nil {
            tearDown()
        }

        self.viewState = .loading

        loadingTask?.cancel()
        loadingTask = Task.detached { [weak self] in
            guard let self else { return }
            let session: ChatSession?
            let newState: ViewState
            do {
                let config = ChatConfig.create()
                session = try await engine.chat(model: model, config: config)
                newState = .idle
            } catch {
                session = nil
                newState = .error(error)
            }
            await MainActor.run { [weak self] in
                guard let self else { return }
                self.session = session
                self.viewState = newState
                self.loadingTask = nil
            }
        }
    }

    func classify() {
        guard case .idle = viewState,
            let session,
            !inputText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
            return
        }

        resultText = ""
        stats = nil
        viewState = .generating
        let text = inputText.trimmingCharacters(in: .whitespacesAndNewlines)
        let values = feature.values.joined(separator: ", ")
        let prompt =
            "Text is: \"\(text)\". Choose \(feature.name) from the list: \(values). Answer with one word. Dont't add dot at the end."

        generationTask?.cancel()
        generationTask = Task.detached { [weak self] in
            guard let self else { return }
            do {
                try await session.reset()
                let stream = await session.replyWithStream(
                    input: [
                        .system().withReasoningEffort(reasoningEffort: .disabled),
                        .user().withText(text: prompt)
                    ],
                    config: .create().withSamplingMethod(samplingMethod: .greedy).withTokenLimit(tokenLimit: 32)
                )
                for try await update in stream.iterator() {
                    if Task.isCancelled {
                        stream.cancelToken().cancel()
                        break
                    }
                    
                    switch update {
                    case .replies(let replies):
                        if let reply = replies.last {
                            Task { @MainActor [weak self] in
                                guard let self else {
                                    return
                                }
                                self.resultText = reply.message.text() ?? ""
                                self.stats = .init(stats: reply.stats)
                            }
                        }
                    case .error(let error):
                        stream.cancelToken().cancel()
                        throw error
                    case .toolResults:
                        break
                    }
                }
                
                Task { @MainActor [weak self] in
                    guard let self  else {
                        return
                    }
                    self.viewState = .idle
                    self.generationTask?.cancel()
                    self.generationTask = nil
                }
            } catch {
                Task { @MainActor [weak self] in
                    guard let self else { return }
                    self.viewState = .error(error)
                    self.generationTask?.cancel()
                    self.generationTask = nil
                }
            }
        }
    }

    func stop() {
        generationTask?.cancel()
        generationTask = nil
        viewState = .idle
    }

    func tearDown() {
        loadingTask?.cancel()
        loadingTask = nil
        generationTask?.cancel()
        generationTask = nil
        session = nil
        viewState = .loading
    }
}