Struct MLModelAsset

Source

#[repr(C)]
pub struct MLModelAsset { /* private fields */ }

Available on crate feature MLModelAsset only.

Expand description

A compiled model asset.

MLModelAsset is an abstraction of a compiled model, which can be:

.mlmodelc bundle on the file system
In-memory model specification

It provides the unified interface to query the model description and to instantiate MLModel.

// Creates an object.
let modelAsset = MLModelAsset(url: modelURL)

// Query the model description
let description = try await modelAsset.modelDescription

// Query the list of functions in the model asset.
let functionNames = try await modelAsset.functionNames

// Query the model description of a specific function.
let descriptionOfMyFunction = try await modelAsset.modelDescription(of: "MyFunction")

// Instantiate `MLModel` for "MyFunction".
let modelConfiguration = MLModelConfiguration()
modelConfiguration.functionName = "MyFunction"
let model = try await MLModel.load(asset: modelAsset, configuration: modelConfiguration)

Implementations§

Source §

impl MLModelAsset

Source

pub unsafe fn modelAssetWithSpecificationData_error( specification_data: &NSData, ) -> Result<Retained<Self>, Retained<NSError>>

Construct a model asset from the contents of specification data.

Parameters:
specificationData: Contents of .mlmodel as a data blob.
error: When the model asset creation fails error is populated with the reason for failure.

Source

pub unsafe fn modelAssetWithSpecificationData_blobMapping_error( specification_data: &NSData, blob_mapping: &NSDictionary<NSURL, NSData>, ) -> Result<Retained<Self>, Retained<NSError>>

Construct a model asset from an ML Program specification by replacing blob file references with corresponding in-memory blobs.

An ML Program may use BlobFileValue syntax, which stores the blob data in external files and refers them by URL. This factory method enables in-memory workflow for such models by using the specified in-memory blob data in place of the external files.

The format of in-memory blobs must be the same as the external files. The dictionary must contain all the reference URLs used in the specification.

Parameters:
specification: Contents of .mlmodel as a data blob.
blobMapping: A dictionary with blob URL as the key and blob data as the value.
error: When the model asset creation fails error is populated with the reason for failure.

Source

pub unsafe fn modelAssetWithURL_error( compiled_model_url: &NSURL, ) -> Result<Retained<Self>, Retained<NSError>>

Constructs a ModelAsset from a compiled model URL.

Parameters:
compiledModelURL: Location on the disk where the model asset is present.
error: Errors if the model asset is not loadable.
Returns: a model asset or nil if there is an error.

Source

pub unsafe fn modelDescriptionWithCompletionHandler( &self, handler: &DynBlock<dyn Fn(mut MLModelDescription, mut NSError)>, )

Available on crate features MLModelDescription and block2 only.

The default model descripton.

Use this method to get the description of the model such as the feature descriptions, the model author, and other metadata.

For the multi-function model asset, this method vends the description for the default function. Use modelDescription(for:) to get the model description of other functions.

let modelAsset = try MLModelAsset(url: modelURL)
let modelDescription = try await modelAsset.modelDescription()
print(modelDescription)

Source

pub unsafe fn modelDescriptionOfFunctionNamed_completionHandler( &self, function_name: &NSString, handler: &DynBlock<dyn Fn(mut MLModelDescription, mut NSError)>, )

Available on crate features MLModelDescription and block2 only.

The model descripton for a specified function.

Use this method to get the description of the model such as the feature descriptions, the model author, and other metadata.

let modelAsset = try MLModelAsset(url: modelURL)
let modelDescription = try await modelAsset.modelDescription(of: "my_function")
print(modelDescription)

Source

pub unsafe fn functionNamesWithCompletionHandler( &self, handler: &DynBlock<dyn Fn(mut NSArray<NSString>, mut NSError)>, )

Available on crate feature block2 only.

The list of function names in the model asset.

Some model types (e.g. ML Program) supports multiple functions. Use this method to query the function names.

The method vends the empty array when the model doesn’t use the multi-function configuration.

let modelAsset = try MLModelAsset(url: modelURL)
let functionNames = try await modelAsset.functionNames
print(functionNames) // For example, ["my_function1", "my_function2"];

Source

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Source

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = NSObject>§

Source

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>§

Source

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

§Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

§Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

Source

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

§Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

§Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

§Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

§Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

§Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}