def test_duplicated_artifact_name(): with pytest.raises(InvalidArgument) as e: @bentoml.artifacts([PickleArtifact("model"), PickleArtifact("model")]) class ExampleBentoService( # pylint: disable=unused-variable bentoml.BentoService): pass assert "Duplicated artifact name `model` detected" in str(e.value)
def pack_models(path): model = PickleModel() PickleArtifact("model").pack(model).save(path) from sklearn.ensemble import RandomForestRegressor sklearn_model = RandomForestRegressor(n_estimators=2) sklearn_model.fit( [[i] for _ in range(100) for i in range(10)], [i for _ in range(100) for i in range(10)], ) SklearnModelArtifact("sk_model").pack(sklearn_model).save(path)
import bentoml from bentoml.adapters import ( DataframeInput, FileInput, ImageInput, JsonInput, MultiImageInput, ) from bentoml.frameworks.sklearn import SklearnModelArtifact from bentoml.handlers import DataframeHandler # deprecated from bentoml.service.artifacts.pickle import PickleArtifact from bentoml.types import InferenceResult, InferenceTask @bentoml.env(infer_pip_packages=True) @bentoml.artifacts([PickleArtifact("model"), SklearnModelArtifact('sk_model')]) class ExampleService(bentoml.BentoService): """ Example BentoService class made for testing purpose """ @bentoml.api( input=DataframeInput(dtype={"col1": "int"}), mb_max_latency=1000, mb_max_batch_size=2000, batch=True, ) def predict_dataframe(self, df): return self.artifacts.model.predict_dataframe(df) @bentoml.api(DataframeHandler, dtype={"col1": "int"}, batch=True) # deprecated
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") def to_numpy(tensor): return tensor.detach().cpu().clone().numpy( ) if tensor.requires_grad else tensor.cpu().clone().numpy() @env(infer_pip_packages=False, pip_packages=['onnxruntime-gpu'], requirements_txt_file="./requirements.txt", docker_base_image="bentoml/model-server:0.12.1-py38-gpu") @artifacts([ OnnxModelArtifact('model', backend='onnxruntime-gpu'), PickleArtifact('tokenizer'), PickleArtifact('vocab') ]) class OnnxService(BentoService): def __init__(self): super().__init__() self.news_label = { 1: 'World', 2: 'Sports', 3: 'Business', 4: 'Sci/Tec' } def classify_categories(self, sentence): text_pipeline, _ = get_pipeline(self.artifacts.tokenizer, self.artifacts.vocab)
import bentoml from bentoml.adapters import ( # FastaiImageInput, DataframeInput, ImageInput, JsonInput, LegacyImageInput, LegacyJsonInput, ) from bentoml.service.artifacts.pickle import PickleArtifact from bentoml.handlers import DataframeHandler # deprecated @bentoml.artifacts([PickleArtifact("model")]) @bentoml.env(infer_pip_packages=True) class ExampleBentoService(bentoml.BentoService): """ Example BentoService class made for testing purpose """ @bentoml.api(input=DataframeInput(), mb_max_latency=1000, mb_max_batch_size=2000) def predict(self, df): """An API for testing simple bento model service """ return self.artifacts.model.predict(df) @bentoml.api(input=DataframeInput(dtype={"col1": "int"})) def predict_dataframe(self, df): """predict_dataframe expects dataframe as input """ return self.artifacts.model.predict_dataframe(df) @bentoml.api(DataframeHandler, dtype={"col1": "int"}) # deprecated def predict_dataframe_v1(self, df): """predict_dataframe expects dataframe as input
from bentoml import BentoService, api, artifacts, env from bentoml.adapters import JsonInput, JsonOutput from bentoml.frameworks.pytorch import PytorchModelArtifact from bentoml.service.artifacts.pickle import PickleArtifact from train import get_pipeline import torch device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # cuda @env(conda_dependencies=['pytorch', 'torchtext', 'cudatoolkit=11.1'], conda_channels=['pytorch', 'nvidia'], infer_pip_packages=False, requirements_txt_file="./requirements.txt", docker_base_image="aarnphm/model-server:0.13.0-python3.8-slim-runtime") @artifacts([PytorchModelArtifact("model"), PickleArtifact("tokenizer"), PickleArtifact("vocab")]) class PytorchService(BentoService): def __init__(self): super().__init__() self.news_label = {1: 'World', 2: 'Sports', 3: 'Business', 4: 'Sci/Tec'} def classify_categories(self, sentence): text_pipeline, _ = get_pipeline(self.artifacts.tokenizer, self.artifacts.vocab) with torch.no_grad(): text = torch.tensor(text_pipeline(sentence)).to(device) offsets = torch.tensor([0]).to(device) output = self.artifacts.model(text, offsets=offsets) return output.argmax(1).item() + 1 @api(input=JsonInput(), output=JsonOutput())