@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/CoreML/Evaluation.swift

@@ -0,0 +1,414 @@
+// Evaluating a specification: the math of each supported model type, as Core
+// ML defines it (Model.proto and its siblings in apple/coremltools). A
+// pipeline runs its models in order over one set of named values; every other
+// model reads its declared inputs and writes its declared outputs.
+
+import Foundation
+
+/// A feature value inside the evaluator.
+enum Value: Equatable {
+    case int64(Int64)
+    case double(Double)
+    case string(String)
+    case array([Double], shape: [Int])
+    case stringDictionary([String: Double])
+    case int64Dictionary([Int64: Double])
+
+    init(_ value: MLFeatureValue) throws {
+        switch value.storage {
+        case .undefined(let type): throw MLModelError(.featureType, "An undefined \(type) value cannot be evaluated.")
+        case .int64(let value): self = .int64(value)
+        case .double(let value): self = .double(value)
+        case .string(let value): self = .string(value)
+        case .multiArray(let value): self = .array(value.values, shape: value.shape.map(\.intValue))
+        case .stringDictionary(let value): self = .stringDictionary(value)
+        case .int64Dictionary(let value): self = .int64Dictionary(value)
+        }
+    }
+
+    var featureValue: MLFeatureValue {
+        switch self {
+        case .int64(let value): MLFeatureValue(int64: value)
+        case .double(let value): MLFeatureValue(double: value)
+        case .string(let value): MLFeatureValue(string: value)
+        case .array(let values, let shape): MLFeatureValue(multiArray: MLMultiArray(values: values, shape: shape))
+        case .stringDictionary(let value): MLFeatureValue(_doubles: value)
+        case .int64Dictionary(let value): MLFeatureValue(_doubles: value)
+        }
+    }
+
+    /// The value as numbers: a scalar is one, an array its elements.
+    var numbers: [Double]? {
+        switch self {
+        case .int64(let value): [Double(value)]
+        case .double(let value): [value]
+        case .array(let values, _): values
+        default: nil
+        }
+    }
+
+    /// The value as the type a feature declares: integers and doubles convert
+    /// into each other, a scalar into a one-element array and back.
+    func converted(to feature: Specification.Feature) throws -> Value {
+        switch (feature.featureType, self) {
+        case (.double, .int64(let value)): return .double(Double(value))
+        case (.double, .array(let values, _)) where values.count == 1: return .double(values[0])
+        case (.int64, .double(let value)) where value.isFinite: return .int64(Int64(value.rounded(.towardZero)))
+        case (.int64, .array(let values, _)) where values.count == 1 && values[0].isFinite: return .int64(Int64(values[0].rounded(.towardZero)))
+        case (.multiArray, .double(let value)): return .array([value], shape: [1])
+        case (.multiArray, .int64(let value)): return .array([Double(value)], shape: [1])
+        case (.double, .double), (.int64, .int64), (.string, .string), (.multiArray, .array), (.dictionary, .stringDictionary), (.dictionary, .int64Dictionary):
+            return self
+        default:
+            throw MLModelError(.featureType, "Feature \(feature.name) is a \(feature.featureType), not \(self.typeName).")
+        }
+    }
+
+    var typeName: String {
+        switch self {
+        case .int64: "an Int64"
+        case .double: "a Double"
+        case .string: "a String"
+        case .array: "an MLMultiArray"
+        case .stringDictionary, .int64Dictionary: "a dictionary"
+        }
+    }
+}
+
+extension Specification {
+    /// Runs the model on `inputs` (by name; an optional input may be missing)
+    /// and returns its declared outputs by name.
+    func evaluate(_ inputs: [String: Value]) throws -> [String: Value] {
+        var results: [String: Value] = [:]
+        switch model {
+        case .pipeline(let models):
+            var values = inputs
+            for model in models {
+                let stepInputs = values.filter { name, _ in model.description.inputs.contains { $0.name == name } }
+                values.merge(try model.evaluate(stepInputs)) { _, new in new }
+            }
+            for output in description.outputs {
+                if let value = values[output.name] { results[output.name] = value }
+            }
+            return results
+
+        case .glmRegressor(let weights, let offsets, let transform):
+            let x = try vector(inputs)
+            let y = try weights.indices.map { row in
+                try glmTransform(dot(weights[row], x) + (offsets.indices.contains(row) ? offsets[row] : 0), transform)
+            }
+            return try regression(y)
+
+        case .glmClassifier(let weights, let offsets, let transform, let encoding, let labels):
+            let x = try vector(inputs)
+            let z = weights.indices.map { row in dot(weights[row], x) + (offsets.indices.contains(row) ? offsets[row] : 0) }
+            let probabilities: [Double]
+            if z.count == 1 {
+                // Binary: the second label's probability.
+                let p = try glmTransform(z[0], transform)
+                probabilities = [1 - p, p]
+            } else if encoding == "oneVsRest" {
+                let scores = try z.map { try glmTransform($0, transform) }
+                let total = scores.reduce(0, +)
+                probabilities = scores.map { total > 0 ? $0 / total : 1 / Double(scores.count) }
+            } else {
+                // Reference class: the first label's score is 0.
+                probabilities = softmax([0] + z)
+            }
+            return try classification(probabilities, labels: labels)
+
+        case .treeEnsembleRegressor(let ensemble):
+            var y = try ensemble.raw(try vector(inputs))
+            if ensemble.transform == "logistic" { y = y.map(sigmoid) }
+            return try regression(y)
+
+        case .treeEnsembleClassifier(let ensemble, let labels):
+            let raw = try ensemble.raw(try vector(inputs))
+            let probabilities: [Double]
+            switch ensemble.transform {
+            case "softmax":
+                probabilities = softmax(raw)
+            case "softmaxWithZeroClassReference":
+                probabilities = softmax([0] + raw)
+            case "logistic":
+                probabilities = raw.count == 1 && labels.count == 2 ? [1 - sigmoid(raw[0]), sigmoid(raw[0])] : raw.map(sigmoid)
+            default:
+                probabilities = raw.count == 1 && labels.count == 2 ? [1 - raw[0], raw[0]] : raw
+            }
+            return try classification(probabilities, labels: labels)
+
+        case .featureVectorizer(let columns):
+            var x: [Double] = []
+            for column in columns {
+                guard let value = inputs[column.name] else { throw missing(column.name) }
+                switch value {
+                case .int64Dictionary(let sparse):
+                    // A sparse one-hot encoding: index → value.
+                    var dense = Array(repeating: 0.0, count: column.dimensions)
+                    for (index, number) in sparse where index >= 0 && Int(index) < dense.count { dense[Int(index)] = number }
+                    x += dense
+                default:
+                    guard let numbers = value.numbers else { throw MLModelError(.featureType, "Feature \(column.name) is \(value.typeName); a feature vectorizer takes numbers and arrays.") }
+                    x += numbers
+                }
+            }
+            return try single(.array(x, shape: [x.count]))
+
+        case .oneHotEncoder(let categories, let sparse, let ignoreUnknown):
+            let (name, value) = try onlyInput(inputs)
+            let index = categories.index(of: value)
+            if index == nil && !ignoreUnknown {
+                throw MLModelError(.generic, "\(name) is not one of the categories the one-hot encoder knows.")
+            }
+            if sparse {
+                return try single(.int64Dictionary(index.map { [Int64($0): 1] } ?? [:]))
+            }
+            var x = Array(repeating: 0.0, count: categories.count)
+            if let index { x[index] = 1 }
+            return try single(.array(x, shape: [x.count]))
+
+        case .normalizer(let norm):
+            let (name, value) = try onlyInput(inputs)
+            guard let x = value.numbers else { throw MLModelError(.featureType, "\(name) is \(value.typeName); a normalizer takes numbers.") }
+            let size: Double
+            switch norm {
+            case "l1": size = x.reduce(0) { $0 + abs($1) }
+            case "l2": size = x.reduce(0) { $0 + $1 * $1 }.squareRoot()
+            default: size = x.map(abs).max() ?? 0
+            }
+            let y = size > 0 ? x.map { $0 / size } : x
+            return try single(.array(y, shape: [y.count]))
+
+        case .imputer(let imputed, let replace):
+            let name = description.inputs.first?.name ?? ""
+            return try single(try impute(inputs[name], imputed, replace))
+
+        case .scaler(let shift, let scale):
+            let (name, value) = try onlyInput(inputs)
+            guard let x = value.numbers else { throw MLModelError(.featureType, "\(name) is \(value.typeName); a scaler takes numbers.") }
+            let y = x.indices.map { i in
+                let s = scale.isEmpty ? 1 : scale[scale.count == 1 ? 0 : min(i, scale.count - 1)]
+                let t = shift.isEmpty ? 0 : shift[shift.count == 1 ? 0 : min(i, shift.count - 1)]
+                return s * (x[i] + t)
+            }
+            if case .array = value { return try single(.array(y, shape: [y.count])) }
+            return try single(.double(y[0]))
+
+        case .dictVectorizer(let keys):
+            let (name, value) = try onlyInput(inputs)
+            var x = Array(repeating: 0.0, count: keys.count)
+            switch (keys, value) {
+            case (.strings(let keys), .stringDictionary(let dictionary)):
+                for (index, key) in keys.enumerated() { x[index] = dictionary[key] ?? 0 }
+            case (.int64s(let keys), .int64Dictionary(let dictionary)):
+                for (index, key) in keys.enumerated() { x[index] = dictionary[key] ?? 0 }
+            default:
+                throw MLModelError(.featureType, "\(name) is \(value.typeName), not a dictionary with the vectorizer's key type.")
+            }
+            return try single(.array(x, shape: [x.count]))
+
+        case .arrayFeatureExtractor(let indices):
+            let (name, value) = try onlyInput(inputs)
+            guard let x = value.numbers else { throw MLModelError(.featureType, "\(name) is \(value.typeName); an array feature extractor takes an array.") }
+            guard indices.allSatisfy({ $0 >= 0 && $0 < x.count }) else { throw MLModelError(.generic, "An index of \(indices) is outside \(name), which has \(x.count) elements.") }
+            let y = indices.map { x[$0] }
+            return try single(y.count == 1 && description.outputs.first?.featureType != .multiArray ? .double(y[0]) : .array(y, shape: [y.count]))
+
+        case .categoricalMapping(let mapping):
+            let (name, value) = try onlyInput(inputs)
+            switch value {
+            case .string(let string):
+                guard let map = mapping.stringToInt64 else { throw MLModelError(.featureType, "\(name) is a String; the mapping takes integers.") }
+                guard let mapped = map[string] ?? mapping.defaultInt64 else { throw MLModelError(.generic, "\(string) is not in the categorical mapping.") }
+                return try single(.int64(mapped))
+            default:
+                guard let map = mapping.int64ToString, let integer = value.numbers?.first.flatMap({ Int64(exactly: $0) }) else {
+                    throw MLModelError(.featureType, "\(name) is \(value.typeName); the mapping takes strings.")
+                }
+                guard let mapped = map[String(integer)] ?? mapping.defaultString else { throw MLModelError(.generic, "\(integer) is not in the categorical mapping.") }
+                return try single(.string(mapped))
+            }
+
+        case .identity:
+            for (input, output) in zip(description.inputs, description.outputs) {
+                if let value = inputs[input.name] { results[output.name] = try value.converted(to: output) }
+            }
+            return results
+        }
+    }
+
+    // MARK: Inputs and outputs
+
+    private func missing(_ name: String) -> MLModelError {
+        MLModelError(.featureType, "Feature \(name) is required but not specified.")
+    }
+
+    /// The inputs as one vector of numbers, in the order the model declares them.
+    private func vector(_ inputs: [String: Value]) throws -> [Double] {
+        var x: [Double] = []
+        for feature in description.inputs {
+            guard let value = inputs[feature.name] else { throw missing(feature.name) }
+            guard let numbers = value.numbers else { throw MLModelError(.featureType, "Feature \(feature.name) is \(value.typeName); this model takes numbers.") }
+            x += numbers
+        }
+        return x
+    }
+
+    private func onlyInput(_ inputs: [String: Value]) throws -> (String, Value) {
+        guard let name = description.inputs.first?.name else { throw MLModelError(.generic, "The model declares no input.") }
+        guard let value = inputs[name] else { throw missing(name) }
+        return (name, value)
+    }
+
+    /// A transform's one output, under the name (and type) the model declares.
+    private func single(_ value: Value) throws -> [String: Value] {
+        guard let output = description.outputs.first else { return [:] }
+        return [output.name: try value.converted(to: output)]
+    }
+
+    private func regression(_ y: [Double]) throws -> [String: Value] {
+        let name = description.predictedFeatureName ?? description.outputs.first?.name ?? ""
+        guard let output = description.outputs.first(where: { $0.name == name }) else { return [:] }
+        let value: Value = y.count == 1 && output.featureType != .multiArray ? .double(y[0]) : .array(y, shape: [y.count])
+        return [name: try value.converted(to: output)]
+    }
+
+    /// The most probable label and, when the model declares it, every label's probability.
+    private func classification(_ probabilities: [Double], labels: Labels) throws -> [String: Value] {
+        guard probabilities.count == labels.count else {
+            throw MLModelError(.generic, "The model computed \(probabilities.count) class probabilities for \(labels.count) labels.")
+        }
+        var best = 0
+        for index in probabilities.indices where probabilities[index] > probabilities[best] { best = index }
+        var results: [String: Value] = [:]
+        let labelName = description.predictedFeatureName
+            ?? description.outputs.first(where: { $0.featureType == .string || $0.featureType == .int64 })?.name
+        if let labelName { results[labelName] = labels.value(at: best) }
+        let probabilitiesName = description.predictedProbabilitiesName
+            ?? description.outputs.first(where: { $0.featureType == .dictionary })?.name
+        if let probabilitiesName, description.outputs.contains(where: { $0.name == probabilitiesName }) {
+            switch labels {
+            case .strings(let labels):
+                results[probabilitiesName] = .stringDictionary(Dictionary(zip(labels, probabilities), uniquingKeysWith: { first, _ in first }))
+            case .int64s(let labels):
+                results[probabilitiesName] = .int64Dictionary(Dictionary(zip(labels, probabilities), uniquingKeysWith: { first, _ in first }))
+            }
+        }
+        return results
+    }
+
+    // MARK: Imputation
+
+    private func impute(_ value: Value?, _ imputed: Imputed, _ replace: Replace?) throws -> Value {
+        if let double = imputed.double {
+            guard let value else { return .double(double) }
+            guard case .double(let x) = try value.converted(to: Feature(name: "", type: "double")) else { return value }
+            return matches(x, replace?.double) ? .double(double) : .double(x)
+        }
+        if let int64 = imputed.int64 {
+            guard let value else { return .int64(int64) }
+            guard case .int64(let x) = try value.converted(to: Feature(name: "", type: "int64")) else { return value }
+            return replace?.int64 == x ? .int64(int64) : .int64(x)
+        }
+        if let string = imputed.string {
+            guard case .string(let x)? = value else { return .string(string) }
+            return x == (replace?.string ?? "") ? .string(string) : .string(x)
+        }
+        if let doubles = imputed.doubles ?? imputed.int64s?.map(Double.init) {
+            guard let x = value?.numbers else { return .array(doubles, shape: [doubles.count]) }
+            let missing = imputed.doubles == nil ? replace?.int64.map(Double.init) : replace?.double
+            let y = x.indices.map { i in i < doubles.count && matches(x[i], missing) ? doubles[i] : x[i] }
+            return .array(y, shape: [y.count])
+        }
+        if let defaults = imputed.stringDictionary {
+            guard case .stringDictionary(let x)? = value else { return .stringDictionary(defaults) }
+            return .stringDictionary(defaults.merging(x) { _, given in given })
+        }
+        if let defaults = imputed.int64Dictionary {
+            let typed = Dictionary(uniqueKeysWithValues: defaults.compactMap { key, number in Int64(key).map { ($0, number) } })
+            guard case .int64Dictionary(let x)? = value else { return .int64Dictionary(typed) }
+            return .int64Dictionary(typed.merging(x) { _, given in given })
+        }
+        throw MLModelError(.generic, "The imputer has no imputed value.")
+    }
+
+    /// Whether `x` is the value to replace: NaN unless the model names another.
+    private func matches(_ x: Double, _ replace: Double?) -> Bool {
+        guard let replace, !replace.isNaN else { return x.isNaN }
+        return x == replace
+    }
+}
+
+extension Specification.Feature {
+    init(name: String, type: String) {
+        self.name = name
+        self.type = type
+    }
+}
+
+extension Specification.TreeEnsemble {
+    /// The ensemble's raw prediction: the base values plus every tree's leaf values.
+    func raw(_ x: [Double]) throws -> [Double] {
+        var y = base.count == dimensions ? base : Array(repeating: 0, count: dimensions)
+        for tree in trees {
+            var node = 0
+            while true {
+                let behavior = tree.behaviors[node]
+                if behavior == 6 {
+                    for k in tree.leafStarts[node]..<tree.leafStarts[node + 1] { y[tree.leafIndices[k]] += tree.leafValues[k] }
+                    break
+                }
+                let feature = tree.features[node]
+                guard feature < x.count else {
+                    throw MLModelError(.generic, "A tree reads feature \(feature) of an input with \(x.count) values.")
+                }
+                let value = x[feature]
+                let threshold = tree.thresholds[node]
+                let goesTrue: Bool
+                if value.isNaN {
+                    goesTrue = tree.missingTrue[node]
+                } else {
+                    switch behavior {
+                    case 0: goesTrue = value <= threshold
+                    case 1: goesTrue = value < threshold
+                    case 2: goesTrue = value >= threshold
+                    case 3: goesTrue = value > threshold
+                    case 4: goesTrue = value == threshold
+                    default: goesTrue = value != threshold
+                    }
+                }
+                node = goesTrue ? tree.trueChildren[node] : tree.falseChildren[node]
+            }
+        }
+        return y
+    }
+}
+
+// MARK: Math
+
+private func dot(_ w: [Double], _ x: [Double]) -> Double {
+    var sum = 0.0
+    for i in 0..<min(w.count, x.count) { sum += w[i] * x[i] }
+    return sum
+}
+
+func sigmoid(_ z: Double) -> Double { 1 / (1 + exp(-z)) }
+
+/// The standard normal distribution function, Φ.
+func probit(_ z: Double) -> Double { 0.5 * erfc(-z / 2.0.squareRoot()) }
+
+private func glmTransform(_ z: Double, _ transform: String) throws -> Double {
+    switch transform {
+    case "none": z
+    case "logit": sigmoid(z)
+    case "probit": probit(z)
+    default: throw MLModelError(.generic, "Unknown GLM transform \(transform).")
+    }
+}
+
+func softmax(_ z: [Double]) -> [Double] {
+    let top = z.max() ?? 0
+    let e = z.map { exp($0 - top) }
+    let total = e.reduce(0, +)
+    return e.map { $0 / total }
+}

package/Sources/CoreML/FeatureValue.swift

@@ -0,0 +1,266 @@
+// Core ML's feature values and the providers that carry them in and out of a
+// model, as far as tabular models use them: integers, doubles, strings,
+// multiarrays and dictionaries. Images and sequences have no counterpart.
+
+import Foundation
+
+/// The type of a feature, with Core ML's raw values.
+public enum MLFeatureType: Int, Sendable, CustomStringConvertible {
+    case invalid = 0
+    case int64 = 1
+    case double = 2
+    case string = 3
+    case image = 4
+    case multiArray = 5
+    case dictionary = 6
+    case sequence = 7
+    case state = 8
+
+    public var description: String {
+        switch self {
+        case .invalid: "Invalid"
+        case .int64: "Int64"
+        case .double: "Double"
+        case .string: "String"
+        case .image: "Image"
+        case .multiArray: "MultiArray"
+        case .dictionary: "Dictionary"
+        case .sequence: "Sequence"
+        case .state: "State"
+        }
+    }
+}
+
+/// One value of a feature: what a model takes and returns.
+public final class MLFeatureValue: @unchecked Sendable, CustomStringConvertible {
+    enum Storage {
+        case undefined(MLFeatureType)
+        case int64(Int64)
+        case double(Double)
+        case string(String)
+        case multiArray(MLMultiArray)
+        case stringDictionary([String: Double])
+        case int64Dictionary([Int64: Double])
+    }
+
+    let storage: Storage
+
+    init(storage: Storage) { self.storage = storage }
+
+    public convenience init(int64 value: Int64) { self.init(storage: .int64(value)) }
+    public convenience init(double value: Double) { self.init(storage: .double(value)) }
+    public convenience init(string value: String) { self.init(storage: .string(value)) }
+    public convenience init(multiArray value: MLMultiArray) { self.init(storage: .multiArray(value)) }
+    /// A missing value of a type, for an optional input.
+    public convenience init(undefined type: MLFeatureType) { self.init(storage: .undefined(type)) }
+
+    /// A dictionary of `String` or integer keys to numbers.
+    public convenience init(dictionary value: [AnyHashable: NSNumber]) throws {
+        var strings: [String: Double] = [:]
+        var integers: [Int64: Double] = [:]
+        for (key, number) in value {
+            if let key = key.base as? String {
+                strings[key] = number.doubleValue
+            } else if let key = _int64(key.base) {
+                integers[key] = number.doubleValue
+            } else {
+                throw MLModelError(.featureType, "Dictionary keys must be strings or integers, not \(Swift.type(of: key.base)).")
+            }
+        }
+        if !strings.isEmpty && !integers.isEmpty {
+            throw MLModelError(.featureType, "Dictionary keys must be all strings or all integers.")
+        }
+        self.init(storage: integers.isEmpty ? .stringDictionary(strings) : .int64Dictionary(integers))
+    }
+
+    /// The generated model classes' dictionary inputs and outputs (`[String : Double]`, `[Int64 : Double]`).
+    public convenience init<Key: Hashable>(_doubles value: [Key: Double]) {
+        if let strings = value as? [String: Double] {
+            self.init(storage: .stringDictionary(strings))
+        } else {
+            var integers: [Int64: Double] = [:]
+            for (key, number) in value { integers[_int64(key) ?? 0] = number }
+            self.init(storage: .int64Dictionary(integers))
+        }
+    }
+
+    public var type: MLFeatureType {
+        switch storage {
+        case .undefined(let type): type
+        case .int64: .int64
+        case .double: .double
+        case .string: .string
+        case .multiArray: .multiArray
+        case .stringDictionary, .int64Dictionary: .dictionary
+        }
+    }
+
+    public var isUndefined: Bool {
+        if case .undefined = storage { return true }
+        return false
+    }
+
+    /// The value as an integer (0 when it is not a number).
+    public var int64Value: Int64 {
+        switch storage {
+        case .int64(let value): value
+        case .double(let value): value.isFinite ? Int64(value) : 0
+        default: 0
+        }
+    }
+
+    /// The value as a double (0 when it is not a number).
+    public var doubleValue: Double {
+        switch storage {
+        case .double(let value): value
+        case .int64(let value): Double(value)
+        default: 0
+        }
+    }
+
+    /// The value as a string ("" when it is not one).
+    public var stringValue: String {
+        if case .string(let value) = storage { return value }
+        return ""
+    }
+
+    public var multiArrayValue: MLMultiArray? {
+        if case .multiArray(let value) = storage { return value }
+        return nil
+    }
+
+    /// The value as a dictionary of `String` or `Int64` keys to numbers (empty when it is not one).
+    public var dictionaryValue: [AnyHashable: NSNumber] {
+        switch storage {
+        case .stringDictionary(let value):
+            return Dictionary(uniqueKeysWithValues: value.map { (AnyHashable($0.key), NSNumber(value: $0.value)) })
+        case .int64Dictionary(let value):
+            return Dictionary(uniqueKeysWithValues: value.map { (AnyHashable($0.key), NSNumber(value: $0.value)) })
+        default:
+            return [:]
+        }
+    }
+
+    /// The dictionary with typed keys, for the generated model classes' outputs.
+    public func _doubles<Key: Hashable>(keyedBy: Key.Type) -> [Key: Double] {
+        switch storage {
+        case .stringDictionary(let value):
+            return value as? [Key: Double] ?? [:]
+        case .int64Dictionary(let value):
+            return value as? [Key: Double] ?? [:]
+        default:
+            return [:]
+        }
+    }
+
+    public func isEqual(to other: MLFeatureValue) -> Bool {
+        switch (storage, other.storage) {
+        case (.undefined(let a), .undefined(let b)): a == b
+        case (.int64(let a), .int64(let b)): a == b
+        case (.double(let a), .double(let b)): a == b
+        case (.string(let a), .string(let b)): a == b
+        case (.multiArray(let a), .multiArray(let b)): a.shape == b.shape && a.values == b.values
+        case (.stringDictionary(let a), .stringDictionary(let b)): a == b
+        case (.int64Dictionary(let a), .int64Dictionary(let b)): a == b
+        default: false
+        }
+    }
+
+    public var description: String {
+        switch storage {
+        case .undefined(let type): "Undefined \(type)"
+        case .int64(let value): "\(value) : Int64"
+        case .double(let value): "\(value) : Double"
+        case .string(let value): "\(value) : String"
+        case .multiArray(let value): "\(value) : MultiArray"
+        case .stringDictionary(let value): "\(value) : Dictionary"
+        case .int64Dictionary(let value): "\(value) : Dictionary"
+        }
+    }
+}
+
+/// An integer key of any width as `Int64`.
+func _int64(_ value: Any) -> Int64? {
+    switch value {
+    case let value as Int64: value
+    case let value as Int: Int64(value)
+    case let value as Int32: Int64(value)
+    case let value as Int16: Int64(value)
+    case let value as Int8: Int64(value)
+    case let value as UInt: Int64(exactly: value)
+    case let value as UInt32: Int64(value)
+    case let value as NSNumber: value.int64Value
+    default: nil
+    }
+}
+
+/// Named feature values: a model's input or output.
+public protocol MLFeatureProvider: AnyObject {
+    var featureNames: Set<String> { get }
+    func featureValue(for featureName: String) -> MLFeatureValue?
+}
+
+/// A feature provider backed by a dictionary.
+public final class MLDictionaryFeatureProvider: MLFeatureProvider, @unchecked Sendable {
+    public let dictionary: [String: MLFeatureValue]
+
+    /// Values may be `MLFeatureValue`s, numbers, strings, `MLMultiArray`s or dictionaries of numbers.
+    public init(dictionary: [String: Any]) throws {
+        var values: [String: MLFeatureValue] = [:]
+        for (name, value) in dictionary {
+            guard let featureValue = MLDictionaryFeatureProvider.featureValue(value) else {
+                throw MLModelError(.featureType, "The value of \(name) (\(Swift.type(of: value))) cannot be a feature value.")
+            }
+            values[name] = featureValue
+        }
+        self.dictionary = values
+    }
+
+    static func featureValue(_ value: Any) -> MLFeatureValue? {
+        switch value {
+        case let value as MLFeatureValue: value
+        case let value as Double: MLFeatureValue(double: value)
+        case let value as Float: MLFeatureValue(double: Double(value))
+        case let value as String: MLFeatureValue(string: value)
+        case let value as MLMultiArray: MLFeatureValue(multiArray: value)
+        case let value as [String: Double]: MLFeatureValue(_doubles: value)
+        case let value as [Int64: Double]: MLFeatureValue(_doubles: value)
+        case let value as [Int: Double]: MLFeatureValue(_doubles: Dictionary(uniqueKeysWithValues: value.map { (Int64($0.key), $0.value) }))
+        case let value as [AnyHashable: NSNumber]: try? MLFeatureValue(dictionary: value)
+        case let value as NSNumber: MLFeatureValue(double: value.doubleValue)
+        default: _int64(value).map { MLFeatureValue(int64: $0) }
+        }
+    }
+
+    public var featureNames: Set<String> { Set(dictionary.keys) }
+
+    public func featureValue(for featureName: String) -> MLFeatureValue? { dictionary[featureName] }
+
+    public subscript(featureName: String) -> MLFeatureValue? { dictionary[featureName] }
+}
+
+/// Several inputs (or outputs) of a model, for batch predictions.
+public protocol MLBatchProvider: AnyObject {
+    var count: Int { get }
+    func features(at index: Int) -> MLFeatureProvider
+}
+
+public final class MLArrayBatchProvider: MLBatchProvider, @unchecked Sendable {
+    public let array: [MLFeatureProvider]
+
+    public init(array: [MLFeatureProvider]) { self.array = array }
+
+    /// One provider per index of the value lists, which must have the same length.
+    public init(dictionary: [String: [Any]]) throws {
+        let counts = Set(dictionary.values.map(\.count))
+        guard counts.count <= 1 else { throw MLModelError(.generic, "The feature value lists have different lengths.") }
+        let count = counts.first ?? 0
+        array = try (0..<count).map { index in
+            try MLDictionaryFeatureProvider(dictionary: dictionary.mapValues { $0[index] })
+        }
+    }
+
+    public var count: Int { array.count }
+
+    public func features(at index: Int) -> MLFeatureProvider { array[index] }
+}