def main(): args, extra = parse_args(sys.argv[1:]) # Pretrained Alibi explainer alibi_model = None if args.storage_uri is not None: alibi_model = os.path.join( kserve.Storage.download(args.storage_uri), EXPLAINER_FILENAME ) with open(alibi_model, "rb") as f: logging.info("Loading Alibi model") alibi_model = dill.load(f) explainer = AlibiExplainer( args.model_name, args.predictor_host, ExplainerMethod(args.command), extra, alibi_model, ) explainer.load() kserve.ModelServer().start(models=[explainer], nest_asyncio=True)
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import kserve import argparse from .bert_transformer import BertTransformer DEFAULT_MODEL_NAME = "model" parser = argparse.ArgumentParser(parents=[kserve.model_server.parser]) parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, help='The name that the model is served under.') parser.add_argument('--predictor_host', help='The URL for the model predict function', required=True) args, _ = parser.parse_known_args() if __name__ == "__main__": transformer = BertTransformer(args.model_name, predictor_host=args.predictor_host) server = kserve.ModelServer() server.start(models=[transformer])
# Input follows the Tensorflow V1 HTTP API for binary values # https://www.tensorflow.org/tfx/serving/api_rest#encoding_binary_values data = inputs[0]["image"]["b64"] raw_img_data = base64.b64decode(data) input_image = Image.open(io.BytesIO(raw_img_data)) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) input_tensor = preprocess(input_image) input_batch = input_tensor.unsqueeze(0) output = self.model(input_batch) torch.nn.functional.softmax(output, dim=1)[0] values, top_5 = torch.topk(output, 5) return {"predictions": values.tolist()} if __name__ == "__main__": kserve.ModelServer(workers=1).start({"custom-model": AlexNetModel})
self.name = name self.ready = False def load(self): dataset_orig = load_preproc_data_german(['age']) scale_orig = StandardScaler() X_train = scale_orig.fit_transform(dataset_orig.features) y_train = dataset_orig.labels.ravel() lmod = LogisticRegression() lmod.fit(X_train, y_train, sample_weight=dataset_orig.instance_weights) self.model = lmod self.ready = True def predict(self, request: Dict) -> Dict: inputs = request["instances"] scale_input = StandardScaler() scaled_input = scale_input.fit_transform(inputs) predictions = self.model.predict(scaled_input) return {"predictions": predictions.tolist()} if __name__ == "__main__": model = KServeSampleModel("german-credit") model.load() kserve.ModelServer(workers=1).start([model])
DEFAULT_MODEL_NAME = "default" DEFAULT_LOCAL_MODEL_DIR = "/tmp/model" DEFAULT_NTHREAD = 1 parser = argparse.ArgumentParser(parents=[kserve.model_server.parser]) # pylint:disable=c-extension-no-member parser.add_argument('--model_dir', required=True, help='A URI pointer to the model directory') parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, help='The name that the model is served under.') parser.add_argument('--nthread', default=DEFAULT_NTHREAD, help='Number of threads to use by LightGBM.') args, _ = parser.parse_known_args() if __name__ == "__main__": model = LightGBMModel(args.model_name, args.model_dir, args.nthread) try: model.load() except ModelMissingError: logging.error( f"fail to load model {args.model_name} from dir {args.model_dir}," f"trying to load from model repository.") model_repository = LightGBMModelRepository(args.model_dir, args.nthread) # LightGBM doesn't support multi-process, so the number of http server workers should be 1. kfserver = kserve.ModelServer(workers=1, registered_models=model_repository) # pylint:disable=c-extension-no-member kfserver.start([model] if model.ready else [])
default=DEFAULT_MIN_WEIGHT, help= 'The minimum weight needed by a pixel to be considered useful as an explanation.' ) parser.add_argument( '--positive_only', default=DEFAULT_POSITIVE_ONLY, help= 'Whether or not to show only the explanations that positively indicate a classification.' ) parser.add_argument('--explainer_type', default=DEFAULT_EXPLAINER_TYPE, help='What type of model explainer to use.') parser.add_argument('--predictor_host', help='The host for the predictor.', required=True) args, _ = parser.parse_known_args() if __name__ == "__main__": model = AIXModel(name=args.model_name, predictor_host=args.predictor_host, segm_alg=args.segmentation_algorithm, num_samples=args.num_samples, top_labels=args.top_labels, min_weight=args.min_weight, positive_only=args.positive_only, explainer_type=args.explainer_type) model.load() kserve.ModelServer().start([model], nest_asyncio=True)
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import kserve import argparse from pytorchserver import PyTorchModel DEFAULT_MODEL_NAME = "model" DEFAULT_LOCAL_MODEL_DIR = "/tmp/model" DEFAULT_MODEL_CLASS_NAME = "PyTorchModel" parser = argparse.ArgumentParser(parents=[kserve.model_server.parser]) parser.add_argument('--model_dir', required=True, help='A URI pointer to the model directory') parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, help='The name that the model is served under.') parser.add_argument('--model_class_name', default=DEFAULT_MODEL_CLASS_NAME, help='The class name for the model.') args, _ = parser.parse_known_args() if __name__ == "__main__": model = PyTorchModel(args.model_name, args.model_class_name, args.model_dir) model.load() kserve.ModelServer().start([model])
import logging import kserve from kserve.model import ModelMissingError from xgbserver import XGBoostModel, XGBoostModelRepository DEFAULT_MODEL_NAME = "default" DEFAULT_LOCAL_MODEL_DIR = "/tmp/model" DEFAULT_NTHREAD = 1 parser = argparse.ArgumentParser(parents=[kserve.model_server.parser]) # pylint:disable=c-extension-no-member parser.add_argument('--model_dir', required=True, help='A URI pointer to the model directory') parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, help='The name that the model is served under.') parser.add_argument('--nthread', default=DEFAULT_NTHREAD, help='Number of threads to use by XGBoost.') args, _ = parser.parse_known_args() if __name__ == "__main__": model = XGBoostModel(args.model_name, args.model_dir, args.nthread) try: model.load() except ModelMissingError: logging.error(f"fail to locate model file for model {args.model_name} under dir {args.model_dir}," f"trying loading from model repository.") kserve.ModelServer(registered_models=XGBoostModelRepository(args.model_dir, args.nthread))\ .start([model] if model.ready else [])
# Find the name and value by splitting the string name, value = line.split(separator, 1) # Assign key value pair to dict # strip() removes white space from the ends of strings keys[name.strip()] = value.strip() keys["model_snapshot"] = json.loads(keys["model_snapshot"]) models = keys["model_snapshot"]["models"] model_names = [] # Get all the model_names for model, value in models.items(): model_names.append(model) if not model_names: model_names = [DEFAULT_MODEL_NAME] print(f"Wrapper : Model names {model_names}") return model_names if __name__ == "__main__": model_names = parse_config() models = [] for model_name in model_names: transformer = ImageTransformer(model_name, predictor_host=args.predictor_host) models.append(transformer) kserve.ModelServer( registered_models=TransformerModelRepository(args.predictor_host) ).start(models=models)
# See the License for the specific language governing permissions and # limitations under the License. import argparse import logging import kserve from sklearnserver import SKLearnModel, SKLearnModelRepository from kserve.model import ModelMissingError DEFAULT_MODEL_NAME = "model" DEFAULT_LOCAL_MODEL_DIR = "/tmp/model" parser = argparse.ArgumentParser(parents=[kserve.model_server.parser]) parser.add_argument('--model_dir', required=True, help='A URI pointer to the model binary') parser.add_argument('--model_name', default=DEFAULT_MODEL_NAME, help='The name that the model is served under.') args, _ = parser.parse_known_args() if __name__ == "__main__": model = SKLearnModel(args.model_name, args.model_dir) try: model.load() except ModelMissingError: logging.error(f"fail to locate model file for model {args.model_name} under dir {args.model_dir}," f"trying loading from model repository.") kserve.ModelServer(registered_models=SKLearnModelRepository(args.model_dir)).start([model] if model.ready else [])