GPUs

To parallelize the classification of a large image over multiple GPUs, the gpus argument must be provided and should be a list of the integer GPU ids for the GPUs to use. Each GPU will be assigned to one split of the input. You can get the GPU ids by running nvidia-smi on your system. Currently only NVIDIA GPUs are supported.

from morpheus_core import morpheus_core

n_classes = 5             # number of classes that are output from the model
batch_size = 16           # number of samples to extract per batch
window_shape = (100, 100) # (height, width) of each sample
gpus = [0, 1, 2]          # GPUs to use
out_dir="."

output_hduls, output_arrays = morpheus_core.predict(
    model,        # your model in a callable from
    model_inputs, # list of numpy arrays or strings that point to fits files
    n_classes,
    batch_size,
    window_shape,
    gpus=gpus,
    out_dir="."
)

The above example will split model_inputs along the first dimenion three ways equally, into three subdirectories within out_dir, called “0”, “1”, “2”. After each subprocesses has finished classifying the image, morpheus_core stiches each of the outputs in the subdirectories into a single large output in out_dir and removes the subdirectories.

CPUs

To parallelize the classification of a large image over multiple CPUs, the cpus argument must be provided and an integer indicating how many processes to use for parallelization. Each process will be assigned to one split of the input.

from morpheus_core import morpheus_core

n_classes = 5             # number of classes that are output from the model
batch_size = 16           # number of samples to extract per batch
window_shape = (100, 100) # (height, width) of each sample
cpus = 3                  # Number of processes to use
out_dir="."

output_hduls, output_arrays = morpheus_core.predict(
    model,        # your model in a callable from
    model_inputs, # list of numpy arrays or strings that point to fits files
    n_classes,
    batch_size,
    window_shape,
    cpus=cpus,
    out_dir="."
)

The above example will split model_inputs along the first dimenion three ways equally, into three subdirectories within out_dir, called “0”, “1”, “2”. After each subprocesses has finished classifying the image, morpheus_core stiches each of the outputs in the subdirectories into a single large output in out_dir and removes the subdirectories.

Non-pickleable functions

For Parallelization Capabilities Only

If you function is non-pickleable then you can write a wrapper class that builds and invokes your model. An example can be seen below:

import tensorflow as tf

class ModelWrapper:

    def __init__(self, model_path):
        self.model_path = model_path
        self.model = None

    def __call__(self, value):

        import tensorflow as tf
        if self.model is None:
            self.model = tf.keras.models.load_model(
                self.model_path,
                custom_objects={"tf":tf},
            )

        return tf.nn.softmax(self.model(value)).numpy()

You then pass the ModelWrapper class as the the model arugment to the morpheus_core, like below:

from morpheus_core import morpheus_core

apply_model = ModelWrapper("/path/to/model/file")

inputs = ["input.fits"]

n_classes = 5
batch_size = 5
window_shape = (40,40)

morpheus_core.predict(
    apply_model,
    inputs,
    n_classes,
    batch_size,
    window_shape,
    stride = (1, 1),
    aggregate_method=morpheus_core.AGGREGATION_METHODS.RANK_VOTE,
    out_dir=".",
    cpus=2
)