> ## Documentation Index
> Fetch the complete documentation index at: https://docs.vessl.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# RunnerBase

### RunnerBase

```python theme={null}
RunnerBase()
```

Base class for model registering.

This base class introduces 5 static methods as followings:

* `predict`: Make prediction with given data and model. This method must be overridden. The
  data is given from the result of `preprocess_data`, and the return value of this method
  will be passed to `postprocess_data` before service.
* `save_model`: Save the model into a file. Return value of this method will be given to the
  `load_model` method on model loading. If this method is overriden, `load_model` must be
  overriden as well.
* `load_model`: Load the model from a file.
* `preprocess_data`: Preprocess the data before prediction. It converts the API input data to
  the model input data.
* `postprocess_data`: Postprocess the data after prediction. It converts the model output data
  to the API output data.

Check each method's docstring for more information.

**Methods:**

## .load\_model

```python theme={null}
vessl.load_model(
   props: Union[Dict[str, str], None], artifacts: Dict[str, str]
)
```

Load the model instance from file.

`props` is given from the return value of `save_model`, and `artifacts` is
given from the `register_model` method.

If the `save_model` is not overriden, `props` will be None

**Args**

* `props` (dict | None) : Data that was returned by `save_model`. If `save_model` is
  not overriden, this will be None.
* `artifacts` (dict) : Data that is given by `register_model` function.

**Returns**
Model instance.

## .preprocess\_data

```python theme={null}
vessl.preprocess_data(
   data: InputDataType
)
```

Preprocess the given data.

The data processed by this method will be given to the model.

**Args**

* `data`  : Data to be preprocessed.

**Returns**
Preprocessed data that will be given to the model.

## .predict

```python theme={null}
vessl.predict(
   model: ModelType, data: ModelInputDataType
)
```

Make prediction with given data and model.

**Args**

* `model` (model\_instance) : Model instance.
* `data`  : Data to be predicted.

**Returns**
Prediction result.

## .postprocess\_data

```python theme={null}
vessl.postprocess_data(
   data: ModelOutputDataType
)
```

Postprocess the given data.

The data processed by this method will be given to the user.

**Args**

* `data`  : Data to be postprocessed.

**Returns**
Postprocessed data that will be given to the user.

## .save\_model

```python theme={null}
vessl.save_model(
   model: ModelType
)
```

Save the given model instance into file.

Return value of this method will be given to first argument of `load_model` on model loading.

**Args**

* `model` (model\_instance) : Model instance to save.

**Returns**
(dict) Data that will be passed to `load_model` on model loading.
Must be a dictionary with key and value both string.

***

## register\_model

```python theme={null}
vessl.register_model(
   repository_name: str, model_number: Union[int, None], runner_cls: RunnerBase,
   model_instance: Union[ModelType, None] = None, requirements: List[str] = None,
   artifacts: Dict[str, str] = None, **kwargs
)
```

Register the given model for service. If you want to override the
default organization, then pass `organization_name` as `**kwargs`.

**Args**

* `repository_name` (str) : Model repository name.
* `model_number` (int | None) : Model number. If None, new model will be
  created. In such case, `model_instance` must be given.
* `runner_cls` (RunnerBase) : Runner class that includes code for service.
* `model_instance` (ModelType | None) : Model instance. If None, `runner_cls`
  must override `load_model` method. Defaults to None.
* `requirements` (List\[str]) : Python requirements for the model. Defaults to
  \[].
* `artifacts` (Dict\[str, str]) : Artifacts to be uploaded. Key is the path to
  artifact in local filesystem, and value is the path in the model
  volume. Only trailing asterisk(\*) is allowed for glob pattern.
  Defaults to {}.

**Example**

* "model.pt", "checkpoints/*": "checkpoints/*"},

```python theme={null}
register_model(
    repository_name="my-model",
    model_number=1,
    runner_cls=MyRunner,
    model_instance=model_instance,
    requirements=["torch", "torchvision"],
)
```

***

## register\_torch\_model

```python theme={null}
vessl.register_torch_model(
   repository_name: str, model_number: Union[int, None], model_instance: ModelType,
   preprocess_data = None, postprocess_data = None, requirements: List[str] = None,
   **kwargs
)
```

Register the given torch model instance for model service. If you want to
override the default organization, then pass `organization_name` as
`**kwargs`.

**Args**

* `repository_name` (str) : Model repository name.
* `model_number` (int | None) : Model number. If None, new model will be
  created.
* `model_instance` (model\_instance) : Torch model instance.
* `preprocess_data` (callable) : Function that will preprocess data.
  Defaults to identity function.
* `postprocess_data` (callable) : Function that will postprocess data.
  Defaults to identity function.
* `requirements` (list) : List of requirements. Defaults to \[].

**Example**

```python theme={null}
vessl.register_model(
    repository_name="my-model",
    model_number=1,
    model_instance=model_instance,
)
```