API Differences in CreateMLComponents in macOS 14.0

It's more difficult than it used to be to find what changed in Apple SDKs. This page is automatically generated and shows what is new in CreateMLComponents in the macOS 14.0 SDK.

Table of Contents

Protocols

RandomTransformer

Classes

UniformRandomIntegerParameter

Structs

AnnotatedPrediction
ApplyEachRandomly
ApplyRandomly
AugmentationBuilder
AugmentationSequence
AugmentationSequence
AsyncIterator
AugmentationSequence
BatchedSequence
AugmentationSequence.BatchedSequence
AsyncIterator
Augmenter
ChooseRandomly
DetectedObject
FullyConnectedNetworkMultiLabelClassifier
FullyConnectedNetworkMultiLabelClassifierModel
ImageBlur
ImageColorTransformer
ImageExposureAdjuster
ImageFlipper
ImageRotator
ModelMetadata
MultiLabelClassificationMetrics
ObjectDetectionAnnotation
ObjectDetectionMetrics
PreprocessingSupervisedTabularEstimator
PreprocessingTabularEstimator
PreprocessingUpdatableSupervisedTabularEstimator
PreprocessingUpdatableTabularEstimator
RandomImageCropper
RandomImageNoiseGenerator
ShuffleRandomly
UniformRandomFloatingPointParameter
UpsampledAugmentationSequence
UpsampledAugmentationSequence
AsyncIterator

Enums

CompatibilityError
ImageFlipper
Orientation
MultiLabelClassificationMetrics
ThresholdSelectionStrategy
OptimizationError
OptimizationStrategy

Typealiases

CodingKeys
public typealias RawValue = Swift.String
CodingKeys
public typealias RawValue = Swift.String
ObjectDetectionAnnotation
public typealias ID = Swift.String

Functions & Methods

AnnotatedFeatureProvider
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.AnnotatedFeatureProvider<Base, UnwrappedInput>.Transformer
AnnotatedFeatureProvider
public func encodeWithOptimizer(_ transformer: CreateMLComponents.AnnotatedFeatureProvider<Base, UnwrappedInput>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
AnnotatedFeatureProvider
public func makeTransformer() -> CreateMLComponents.AnnotatedFeatureProvider<Base, UnwrappedInput>.Transformer
AnnotatedFeatureProvider
public func update(_ transformer: inout CreateMLComponents.AnnotatedFeatureProvider<Base, UnwrappedInput>.Transformer, with input: TabularData.DataFrame, eventHandler: CreateMLComponents.EventHandler? = nil) async throws
AnnotatedPrediction
public static func == (a: CreateMLComponents.AnnotatedPrediction<Prediction, Annotation>, b: CreateMLComponents.AnnotatedPrediction<Prediction, Annotation>) -> Swift.Bool
AnnotatedPrediction
public func encode(to encoder: any Swift.Encoder) throws
AnnotatedPrediction
public func hash(into hasher: inout Swift.Hasher)
AugmentationSequence
public func batches(ofSize size: Swift.Int, dropsLastPartialBatch: Swift.Bool) -> CreateMLComponents.AugmentationSequence<Base, RandomTransformer, RandomNumberGenerator, Annotation>.BatchedSequence
BoostedTreeClassifier
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.TreeClassifierModel<Label>
BoostedTreeClassifier
public func encodeWithOptimizer(_ transformer: CreateMLComponents.TreeClassifierModel<Label>, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
BoostedTreeClassifier
public func makeTransformer() -> CreateMLComponents.TreeClassifierModel<Label>
BoostedTreeClassifier
public func update(_ transformer: inout CreateMLComponents.TreeClassifierModel<Label>, with input: TabularData.DataFrame, eventHandler: CreateMLComponents.EventHandler?) async throws
BoostedTreeRegressor
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.TreeRegressorModel
BoostedTreeRegressor
public func encodeWithOptimizer(_ transformer: CreateMLComponents.TreeRegressorModel, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
BoostedTreeRegressor
public func makeTransformer() -> CreateMLComponents.TreeRegressorModel
BoostedTreeRegressor
public func update(_ transformer: inout CreateMLComponents.TreeRegressorModel, with input: TabularData.DataFrame, eventHandler: CreateMLComponents.EventHandler?) async throws
ClassificationMetrics
public mutating func add(predicted: some Sequence<Label>, groundTruth: some Sequence<Label>)
ClassificationMetrics
public mutating func add(_ pairs: some Sequence<(predicted: Label, label: Label)>)
ClassificationMetrics
public func count(label: Label) -> Swift.Int
ClassificationMetrics
public func count(predicted: Label) -> Swift.Int
ClassificationMetrics
public func count(predicted: Label, label: Label) -> Swift.Int
ClassificationMetrics
public func f1Score(label: Label) -> Swift.Double
ClassificationMetrics
public func falseNegativeCount(of label: Label) -> Swift.Int
ClassificationMetrics
public func falsePositiveCount(of label: Label) -> Swift.Int
ClassificationMetrics
public func mapLabels<T>(_ transform: (Label) throws -> T) rethrows -> CreateMLComponents.ClassificationMetrics<T> where T : Swift.Hashable
ClassificationMetrics
public func trueNegativeCount(of label: Label) -> Swift.Int
ClassificationMetrics
public func truePositiveCount(of label: Label) -> Swift.Int
ColumnSelector
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.ColumnSelector<Estimator, UnwrappedInput>.Transformer
ColumnSelector
public func encodeWithOptimizer(_ transformer: CreateMLComponents.ColumnSelector<Estimator, UnwrappedInput>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
ColumnSelector
public func makeTransformer() -> CreateMLComponents.ColumnSelectorTransformer<Estimator.Transformer, UnwrappedInput>
ColumnSelector
public func update(_ transformer: inout CreateMLComponents.ColumnSelector<Estimator, UnwrappedInput>.Transformer, with input: TabularData.DataFrame, eventHandler: CreateMLComponents.EventHandler? = nil) async throws
DetectedObject
public func encode(to encoder: any Swift.Encoder) throws
FullyConnectedNetworkMultiLabelClassifier
public func decode(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.FullyConnectedNetworkMultiLabelClassifierModel<Scalar, Label>
FullyConnectedNetworkMultiLabelClassifier
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.FullyConnectedNetworkMultiLabelClassifier<Scalar, Label>.Transformer
FullyConnectedNetworkMultiLabelClassifier
public func encodeWithOptimizer(_ transformer: CreateMLComponents.FullyConnectedNetworkMultiLabelClassifier<Scalar, Label>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
FullyConnectedNetworkMultiLabelClassifier
public func makeTransformer() -> CreateMLComponents.FullyConnectedNetworkMultiLabelClassifierModel<Scalar, Label>
FullyConnectedNetworkMultiLabelClassifier
public func update<InputSequence>(_ transformer: inout CreateMLComponents.FullyConnectedNetworkMultiLabelClassifierModel<Scalar, Label>, with input: InputSequence, eventHandler: CreateMLComponents.EventHandler? = nil) async throws where InputSequence : Swift.Sequence, InputSequence.Element == CreateMLComponents.AnnotatedFeature<CoreML.MLShapedArray<Scalar>, Swift.Set<Label>>
FullyConnectedNetworkMultiLabelClassifierModel
public func encode(to encoder: any Swift.Encoder) throws
FullyConnectedNetworkMultiLabelClassifierModel
public func evaluation(on input: some Collection<AnnotatedFeature<Input, Set<Label>>>, confidenceThresholds: [Label : Swift.Float]) throws -> CreateMLComponents.MultiLabelClassificationMetrics<Label>
JointPoint
public static func == (a: CreateMLComponents.JointPoint, b: CreateMLComponents.JointPoint) -> Swift.Bool
LinearRegressor
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.LinearRegressorModel<Scalar>
LinearRegressor
public func encodeWithOptimizer(_ transformer: CreateMLComponents.LinearRegressorModel<Scalar>, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
LinearRegressor
public func makeTransformer() -> CreateMLComponents.LinearRegressorModel<Scalar>
LinearRegressor
public func update<InputSequence>(_ transformer: inout CreateMLComponents.LinearRegressor<Scalar>.Transformer, with input: InputSequence, eventHandler: CreateMLComponents.EventHandler?) async throws where InputSequence : Swift.Sequence, InputSequence.Element == CreateMLComponents.AnnotatedFeature<CoreML.MLShapedArray<Scalar>, Scalar>
LogisticRegressionClassifier
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.LogisticRegressionClassifier<Scalar, Label>.Transformer
LogisticRegressionClassifier
public func encodeWithOptimizer(_ transformer: CreateMLComponents.LogisticRegressionClassifier<Scalar, Label>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
LogisticRegressionClassifier
public func makeTransformer() -> CreateMLComponents.LogisticRegressionClassifier<Scalar, Label>.Transformer
LogisticRegressionClassifier
public func update<InputSequence>(_ transformer: inout CreateMLComponents.LogisticRegressionClassifier<Scalar, Label>.Transformer, with input: InputSequence, eventHandler: CreateMLComponents.EventHandler?) async throws where InputSequence : Swift.Sequence, InputSequence.Element == CreateMLComponents.AnnotatedFeature<CoreML.MLShapedArray<Scalar>, Label>
MultiLabelClassificationMetrics.ThresholdSelectionStrategy
public func encode(to encoder: any Swift.Encoder) throws
MultiLabelClassificationMetrics
public mutating func add(classifications: some Sequence<ClassificationDistribution<Label>>, groundTruth: some Sequence<Set<Label>>)
MultiLabelClassificationMetrics
public mutating func add(_ pairs: some Sequence<(classification: ClassificationDistribution<Label>, labels: Set<Label>)>)
MultiLabelClassificationMetrics
public func count(of label: Label) -> Swift.Int
MultiLabelClassificationMetrics
public func f1Score(for label: Label) -> Swift.Float
MultiLabelClassificationMetrics
public func falseNegativeCount(of label: Label) -> Swift.Int
MultiLabelClassificationMetrics
public func falsePositiveCount(of label: Label) -> Swift.Int
MultiLabelClassificationMetrics
public static func meanAveragePrecisionScore(classifications: some Sequence<ClassificationDistribution<Label>>, groundTruth: some Sequence<Set<Label>>, labels: Swift.Set<Label>) -> Swift.Float
MultiLabelClassificationMetrics
public static func meanAveragePrecisionScore(classifications: some Sequence<ClassificationDistribution<Label>>, groundTruth: some Sequence<Set<Label>>) -> Swift.Float
MultiLabelClassificationMetrics
public static func meanAveragePrecisionScore(_ pairs: some Sequence<(classification: ClassificationDistribution<Label>, labels: Set<Label>)>, labels: Swift.Set<Label>) -> Swift.Float
MultiLabelClassificationMetrics
public static func meanAveragePrecisionScore(_ pairs: some Sequence<(classification: ClassificationDistribution<Label>, labels: Set<Label>)>) -> Swift.Float
MultiLabelClassificationMetrics
public func precisionScore(for label: Label) -> Swift.Float
MultiLabelClassificationMetrics
public func recallScore(for label: Label) -> Swift.Float
MultiLabelClassificationMetrics
public func trueNegativeCount(of label: Label) -> Swift.Int
MultiLabelClassificationMetrics
public func truePositiveCount(of label: Label) -> Swift.Int
NumericImputer
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.NumericImputer<Element>.Transformer
NumericImputer
public func encodeWithOptimizer(_ transformer: CreateMLComponents.NumericImputer<Element>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
NumericImputer
public func makeTransformer() -> CreateMLComponents.NumericImputer<Element>.Transformer
NumericImputer
public func update(_ transformer: inout CreateMLComponents.ImputeTransformer<Element>, with input: some Sequence<Element?>, eventHandler: CreateMLComponents.EventHandler? = nil) throws
OneHotEncoder
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.OneHotEncoder<Category>.Transformer
OneHotEncoder
public func encodeWithOptimizer(_ transformer: CreateMLComponents.OneHotEncoder<Category>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
OneHotEncoder
public func makeTransformer() -> CreateMLComponents.OneHotEncoder<Category>.Transformer
OneHotEncoder
public func update(_ transformer: inout CreateMLComponents.OneHotEncoder<Category>.Transformer, with input: some Sequence<Category?>, eventHandler: CreateMLComponents.EventHandler? = nil) throws
OrdinalEncoder
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.OrdinalEncoder<Category>.Transformer
OrdinalEncoder
public func encodeWithOptimizer(_ transformer: CreateMLComponents.OrdinalEncoder<Category>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
OrdinalEncoder
public func makeTransformer() -> CreateMLComponents.OrdinalEncoder<Category>.Transformer
OrdinalEncoder
public func update(_ transformer: inout CreateMLComponents.OrdinalEncoder<Category>.Transformer, with input: some Sequence<Category?>, eventHandler: CreateMLComponents.EventHandler? = nil) throws
Pose
public static func == (a: CreateMLComponents.Pose, b: CreateMLComponents.Pose) -> Swift.Bool
Pose
public func encode(to encoder: any Swift.Encoder) throws
StandardScaler
public func decodeWithOptimizer(from decoder: inout any CreateMLComponents.EstimatorDecoder) throws -> CreateMLComponents.StandardScaler<Element>.Transformer
StandardScaler
public func encodeWithOptimizer(_ transformer: CreateMLComponents.StandardScaler<Element>.Transformer, to encoder: inout any CreateMLComponents.EstimatorEncoder) throws
StandardScaler
public func makeTransformer() -> CreateMLComponents.StandardScaler<Element>.Transformer
StandardScaler
public func update(_ transformer: inout CreateMLComponents.StandardScaler<Element>.Transformer, with input: some Sequence<Element>, eventHandler: CreateMLComponents.EventHandler? = nil)
SupervisedEstimator
public func fitted<Input>(to input: Input, eventHandler: CreateMLComponents.EventHandler?) async throws -> Self.Transformer where Input : _Concurrency.AsyncSequence, Input.Element == CreateMLComponents.AnnotatedFeature<Self.Transformer.Input, Self.Annotation>
SupervisedEstimator
public func fitted<Input, Validation>(to input: Input, validateOn validation: Validation, eventHandler: CreateMLComponents.EventHandler?) async throws -> Self.Transformer where Input : _Concurrency.AsyncSequence, Validation : Swift.Sequence, Input.Element == CreateMLComponents.AnnotatedFeature<Self.Transformer.Input, Self.Annotation>, Validation.Element == CreateMLComponents.AnnotatedFeature<Self.Transformer.Input, Self.Annotation>
TabularTransformer
public func appending<Other>(_ other: Other) -> CreateMLComponents.PreprocessingUpdatableTabularEstimator<Self, Other> where Other : CreateMLComponents.UpdatableTabularEstimator
TabularTransformer
public func appending<Other>(_ other: Other) -> CreateMLComponents.PreprocessingUpdatableSupervisedTabularEstimator<Self, Other> where Other : CreateMLComponents.UpdatableSupervisedTabularEstimator
TabularTransformer
public func appending<Other>(_ other: Other) -> CreateMLComponents.PreprocessingSupervisedTabularEstimator<Self, Other> where Other : CreateMLComponents.SupervisedTabularEstimator
TabularTransformer
public func appending<Other>(_ other: Other) -> CreateMLComponents.PreprocessingTabularEstimator<Self, Other> where Other : CreateMLComponents.TabularEstimator
TabularTransformer
public func export(to url: Foundation.URL, metadata: CreateMLComponents.ModelMetadata) throws
TemporalTransformer
public func export(to url: Foundation.URL, metadata: CreateMLComponents.ModelMetadata) throws
Transformer
public func adaptedAsAnnotatedFeatureTransformer<Annotation>(annotationType: Annotation.Type = Annotation.self) -> some CreateMLComponents.Transformer<CreateMLComponents.AnnotatedFeature<Self.Input, Annotation>, CreateMLComponents.AnnotatedFeature<Self.Output, Annotation>>
Transformer
public func adaptedAsAnnotatedPredictionTransformer<Annotation>(annotationType: Annotation.Type = Annotation.self) -> some CreateMLComponents.Transformer<CreateMLComponents.AnnotatedPrediction<Self.Input, Annotation>, CreateMLComponents.AnnotatedPrediction<Self.Output, Annotation>>
Transformer
public func adaptedAsRandomTransformer() -> some CreateMLComponents.RandomTransformer<Self.Input, Self.Output>
Transformer
public func appending<Other, Annotation>(_ other: Other) -> some CreateMLComponents.Transformer<CreateMLComponents.AnnotatedFeature<Self.Input, Annotation>, Other.Output> where Other : CreateMLComponents.Transformer, Other.Input == CreateMLComponents.AnnotatedFeature<Self.Output, Annotation>
Transformer
public func appending<Other, Annotation>(_ other: Other) -> some CreateMLComponents.Transformer<Self.Input, CreateMLComponents.AnnotatedFeature<Other.Output, Annotation>> where Other : CreateMLComponents.Transformer, Self.Output == CreateMLComponents.AnnotatedFeature<Other.Input, Annotation>
Transformer
public func appending<Other, Annotation>(_ other: Other) -> some CreateMLComponents.Transformer<CreateMLComponents.AnnotatedPrediction<Self.Input, Annotation>, Other.Output> where Other : CreateMLComponents.Transformer, Other.Input == CreateMLComponents.AnnotatedPrediction<Self.Output, Annotation>
Transformer
public func appending<Other, Annotation>(_ other: Other) -> some CreateMLComponents.Transformer<Self.Input, CreateMLComponents.AnnotatedPrediction<Other.Output, Annotation>> where Other : CreateMLComponents.Transformer, Self.Output == CreateMLComponents.AnnotatedPrediction<Other.Input, Annotation>
Transformer
public func export(to url: Foundation.URL, metadata: CreateMLComponents.ModelMetadata) throws
Transformer
public func prediction<S, Annotation>(from input: S, eventHandler: CreateMLComponents.EventHandler? = nil) async throws -> [CreateMLComponents.AnnotatedPrediction<Self.Output, Annotation>] where S : Swift.Sequence, S.Element == CreateMLComponents.AnnotatedFeature<Self.Input, Annotation>
UpdatableSupervisedEstimator
public func update<Input>(_ transformer: inout Self.Transformer, with input: Input, eventHandler: CreateMLComponents.EventHandler? = nil) async throws where Input : _Concurrency.AsyncSequence, Input.Element == CreateMLComponents.AnnotatedFeature<Self.Transformer.Input, Self.Annotation>
internal func absoluteError<T>(_ annotatedPrediction: CreateMLComponents.AnnotatedPrediction<T, T>) -> T where T : Swift.FloatingPoint
public func maximumAbsoluteError<T>(_ annotatedPredictions: [CreateMLComponents.AnnotatedPrediction<T, T>]) -> T where T : Swift.FloatingPoint
public func meanAbsoluteError<T>(_ annotatedPredictions: [CreateMLComponents.AnnotatedPrediction<T, T>]) -> T where T : Swift.FloatingPoint
public func meanAbsolutePercentageError<T>(_ annotatedPredictions: [CreateMLComponents.AnnotatedPrediction<T, T>]) -> T where T : Swift.FloatingPoint
@backDeployed(before: macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 2.0)public func meanSquaredError<T>(_ annotatedPredictions: [CreateMLComponents.AnnotatedPrediction<T, T>]) -> T where T : Swift.FloatingPoint
public func rootMeanSquaredError<T>(_ annotatedPredictions: [CreateMLComponents.AnnotatedPrediction<T, T>]) -> T where T : Swift.FloatingPoint

Properties & Constants

AnnotatedPrediction
public var hashValue: Swift.Int
BoostedTreeConfiguration
public var learningRate: Swift.Double
BoostedTreeConfiguration
public var parallelTreeCount: Swift.Int
ClassificationMetrics
public var exampleCount: Swift.Int
ClassificationMetrics
public var labels: Swift.Set<Label>
ClassificationMetrics
public var restrictToKnownLabels: Swift.Bool
CompatibilityError
public var debugDescription: Swift.String
FullyConnectedNetworkConfiguration
public var dropoutProbability: Swift.Float
FullyConnectedNetworkConfiguration
public var earlyStopIterationCount: Swift.Int
FullyConnectedNetworkConfiguration
public var learningRate: Swift.Float
FullyConnectedNetworkMultiLabelClassifierModel
public var debugDescription: Swift.String
ImageFeaturePrint
public static let latestRevision: Swift.Int
ImageFeaturePrint
public var revision: Swift.Int
LinearRegressorModel
public var coefficients: [Scalar]
LinearRegressorModel
public var featureCount: Swift.Int
LogisticRegressionClassifierModel
public var coefficients: [Scalar]
LogisticRegressionClassifierModel
public var featureCount: Swift.Int
MetricsKey
public static let trainingMeanAveragePrecision: CreateMLComponents.MetricsKey
MetricsKey
public static let validationMeanAveragePrecision: CreateMLComponents.MetricsKey
ObjectDetectionAnnotation
public var id: Swift.String
OptimizationError
public var debugDescription: Swift.String
TreeClassifierModel
public var classCount: Swift.Int
TreeClassifierModel
public var featureColumnNames: [Swift.String]
TreeClassifierModel
public var predictionColumnName: Swift.String
TreeRegressorModel
public var featureColumnNames: [Swift.String]
TreeRegressorModel
public var predictionColumnName: Swift.String

Conformances

AnnotatedFeatureProvider
CreateMLComponents.UpdatableSupervisedTabularEstimator
AnnotatedPrediction
Swift.Decodable
AnnotatedPrediction
Swift.Encodable
AnnotatedPrediction
Swift.Equatable
AnnotatedPrediction
Swift.Hashable
AnnotatedPrediction
Swift.Sendable
ApplyRandomly
Swift.Sendable
BoostedTreeClassifier
CreateMLComponents.UpdatableSupervisedTabularEstimator
BoostedTreeRegressor
CreateMLComponents.UpdatableSupervisedTabularEstimator
ColumnSelector
CreateMLComponents.UpdatableTabularEstimator
CompatibilityError
Swift.CustomDebugStringConvertible
DetectedObject
Swift.Decodable
DetectedObject
Swift.Encodable
DetectedObject
Swift.Sendable
FullyConnectedNetworkMultiLabelClassifier
CreateMLComponents.UpdatableSupervisedEstimator
FullyConnectedNetworkMultiLabelClassifier
Swift.Sendable
FullyConnectedNetworkMultiLabelClassifierModel
Swift.Codable
FullyConnectedNetworkMultiLabelClassifierModel
Swift.CustomDebugStringConvertible
FullyConnectedNetworkMultiLabelClassifierModel
Swift.Sendable
JointPoint
Swift.Equatable
LinearRegressor
CreateMLComponents.UpdatableSupervisedEstimator
LogisticRegressionClassifier
CreateMLComponents.UpdatableSupervisedEstimator
MultiLabelClassificationMetrics
Swift.Sendable
MultiLabelClassificationMetrics.ThresholdSelectionStrategy
Swift.Decodable
MultiLabelClassificationMetrics.ThresholdSelectionStrategy
Swift.Encodable
MultiLabelClassificationMetrics.ThresholdSelectionStrategy
Swift.Sendable
NumericImputer
CreateMLComponents.UpdatableEstimator
ObjectDetectionAnnotation.Annotation.CodingKeys
Swift.Equatable
ObjectDetectionAnnotation.Annotation.CodingKeys
Swift.Hashable
ObjectDetectionAnnotation.Annotation.CodingKeys
Swift.RawRepresentable
ObjectDetectionAnnotation.Annotation
Swift.Decodable
ObjectDetectionAnnotation.Annotation
Swift.Sendable
ObjectDetectionAnnotation.CodingKeys
Swift.Equatable
ObjectDetectionAnnotation.CodingKeys
Swift.Hashable
ObjectDetectionAnnotation.CodingKeys
Swift.RawRepresentable
ObjectDetectionAnnotation
Swift.Identifiable
ObjectDetectionAnnotation
Swift.Sendable
ObjectDetectionMetrics
Swift.Sendable
OneHotEncoder
CreateMLComponents.UpdatableEstimator
OptimizationError
Swift.CustomDebugStringConvertible
OptimizationError
Swift.Hashable
OrdinalEncoder
CreateMLComponents.UpdatableEstimator
Pose
Swift.Decodable
Pose
Swift.Encodable
Pose
Swift.Equatable
PreprocessingSupervisedTabularEstimator
Swift.Sendable
PreprocessingTabularEstimator
Swift.Sendable
PreprocessingUpdatableSupervisedTabularEstimator
Swift.Sendable
PreprocessingUpdatableTabularEstimator
Swift.Sendable
StandardScaler
CreateMLComponents.UpdatableEstimator

Initializers

AnnotatedPrediction
public init(from decoder: any Swift.Decoder) throws
ClassificationMetrics
public init()
ClassificationMetrics
public init<Predicted, Correct>(predicted: Predicted, groundTruth: Correct, labels: Swift.Set<Label>) where Label == Predicted.Element, Predicted : Swift.Sequence, Correct : Swift.Sequence, Predicted.Element == Correct.Element
ClassificationMetrics
public init(_ pairs: some Sequence<(predicted: Label, label: Label)>, labels: Swift.Set<Label>)
ClassificationMetrics
public init(_ pairs: some Sequence<(predicted: Label, label: Label)>)
DetectedObject
public init(from decoder: any Swift.Decoder) throws
FullyConnectedNetworkMultiLabelClassifierModel
public init(from decoder: any Swift.Decoder) throws
ImageFeaturePrint
public init(revision: Swift.Int, cropAndScale: Vision.VNImageCropAndScaleOption = .centerCrop, context: CoreImage.CIContext = CIContext())
ImageScaler
public init(targetWidth: Swift.Double)
ImageScaler
public init(targetHeight: Swift.Double)
LinearRegressorModel
public init(coefficients: some Sequence<Scalar>)
LogisticRegressionClassifierModel
public init(coefficients: some Sequence<Scalar>, labels: Swift.Set<Label>)
MultiLabelClassificationMetrics.ThresholdSelectionStrategy
public init(from decoder: any Swift.Decoder) throws
MultiLabelClassificationMetrics
public init(confidenceThresholds: [Label : Swift.Float])
ObjectDetectionAnnotation.Annotation
public init(from decoder: any Swift.Decoder) throws
Pose
public init(from decoder: any Swift.Decoder) throws

Enum Cases

ModelCompatibilityError
case incompatibleMetadataKey(name: Swift.String)