oracle-ads 2.13.8__py3-none-any.whl → 2.13.9rc0__py3-none-any.whl

ads/templates/score-pkl.jinja2

@@ -1,173 +0,0 @@
-# score.py {{SCORE_VERSION}} generated by ADS {{ADS_VERSION}} on {{time_created}}
-import json
-import os
-import cloudpickle
-import pandas as pd
-import numpy as np
-from functools import lru_cache
-{% for import in misc_imports %}
-import {{import}}
-{% endfor %}
-
-model_name = '{{model_file_name}}'
-
-
-"""
-   Inference script. This script is used for prediction by scoring server when schema is known.
-"""
-
-
-@lru_cache(maxsize=10)
-def load_model(model_file_name=model_name):
-    """
-    Loads model from the serialized format
-
-    Returns
-    -------
-    model:  a model instance on which predict API can be invoked
-    """
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    contents = os.listdir(model_dir)
-    if model_file_name in contents:
-        print(f'Start loading {model_file_name} from model directory {model_dir} ...')
-        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), model_file_name), "rb") as file:
-            loaded_model = cloudpickle.load(file)
-
-        print("Model is successfully loaded.")
-        return loaded_model
-    else:
-        raise Exception(f'{model_file_name} is not found in model directory {model_dir}')
-
-@lru_cache(maxsize=1)
-def fetch_data_type_from_schema(input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
-    """
-    Returns data type information fetch from input_schema.json.
-
-    Parameters
-    ----------
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data_type: data type fetch from input_schema.json.
-
-    """
-    data_type = {}
-    if os.path.exists(input_schema_path):
-        schema = json.load(open(input_schema_path))
-        for col in schema['schema']:
-            data_type[col['name']] = col['dtype']
-    else:
-        print("input_schema has to be passed in in order to recover the same data type. pass `X_sample` in `ads.model.framework.sklearn_model.SklearnModel.prepare` function to generate the input_schema. Otherwise, the data type might be changed after serialization/deserialization.")
-    return data_type
-
-def deserialize(data, input_schema_path):
-    """
-    Deserialize json serialization data to data in original type when sent to predict.
-
-    Parameters
-    ----------
-    data: serialized input data.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data: deserialized input data.
-
-    """
-{% if data_deserializer == "json" %}
-    import base64
-    from io import BytesIO
-    if isinstance(data, bytes):
-        return data
-
-    data_type = data.get('data_type', '') if isinstance(data, dict) else ''
-    json_data = data.get('data', data) if isinstance(data, dict) else data
-
-    if "numpy.ndarray" in data_type:
-        load_bytes = BytesIO(base64.b64decode(json_data.encode('utf-8')))
-        return np.load(load_bytes, allow_pickle=True)
-    if "pandas.core.series.Series" in data_type:
-        return pd.Series(json_data)
-    if "pandas.core.frame.DataFrame" in data_type or isinstance(json_data, str):
-        return pd.read_json(json_data, dtype=fetch_data_type_from_schema(input_schema_path))
-    if isinstance(json_data, dict):
-        return pd.DataFrame.from_dict(json_data)
-
-    return json_data
-
-{% elif data_deserializer == "cloudpickle" %}
-    from pickle import UnpicklingError
-    deserialized_data = data
-    try:
-        deserialized_data = cloudpickle.loads(data)
-    except TypeError:
-        pass
-    except UnpicklingError:
-        logger.warning(
-            "bytes are passed directly to the model. If the model expects a specific data format, you need to write the conversion logic in `deserialize()` yourself."
-        )
-
-    return deserialized_data
-
-{% else %}
-    # Add further data deserialization if needed
-    return data
-{% endif %}
-
-def pre_inference(data, input_schema_path):
-    """
-    Preprocess data
-
-    Parameters
-    ----------
-    data: Data format as expected by the predict API of the core estimator.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    data: Data format after any processing.
-
-    """
-    return deserialize(data, input_schema_path)
-
-def post_inference(yhat):
-    """
-    Post-process the model results
-
-    Parameters
-    ----------
-    yhat: Data format after calling model.predict.
-
-    Returns
-    -------
-    yhat: Data format after any processing.
-
-    """
-    if isinstance(yhat, pd.core.frame.DataFrame):
-        yhat = yhat.values
-    if isinstance(yhat, np.ndarray):
-        yhat = yhat.tolist()
-    return yhat
-
-def predict(data, model=load_model(), input_schema_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "input_schema.json")):
-    """
-    Returns prediction given the model and data to predict
-
-    Parameters
-    ----------
-    model: Model instance returned by load_model API.
-    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Pandas DataFrame.
-    input_schema_path: path of input schema.
-
-    Returns
-    -------
-    predictions: Output from scoring server
-        Format: {'prediction': output from model.predict method}
-
-    """
-    features = pre_inference(data, input_schema_path)
-    yhat = post_inference(
-        model.predict(features)
-    )
-    return {'prediction': yhat}

ads/templates/score.jinja2

@@ -1,322 +0,0 @@
-import json
-import numpy as np
-import logging
-import onnxruntime as rt
-import os
-import sys
-import pandas as pd
-from functools import lru_cache
-from scipy.sparse.csr import csr_matrix
-from typing import Union, Dict
-
-
-model_name = '{{model_file_name}}'
-transformer_name = 'onnx_data_transformer.json'
-
-
-"""
-   Inference script. This script is used for prediction by scoring server when schema is known.
-"""
-
-
-@lru_cache(maxsize=10)
-def load_model(model_file_name=model_name):
-    """
-    Loads model from the serialized format
-
-    Returns
-    -------
-    model:  an onnxruntime session instance
-    """
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    if model_dir not in sys.path:
-        sys.path.insert(0, model_dir)
-    contents = os.listdir(model_dir)
-    if model_file_name in contents:
-        print(f'Start loading {model_file_name} from model directory {model_dir} ...')
-        loaded_model = rt.InferenceSession(os.path.join(model_dir, model_file_name))
-
-        print("Model is successfully loaded.")
-        return loaded_model
-    else:
-        raise Exception(f'{model_file_name} is not found in model directory {model_dir}')
-
-
-def predict(data, model=load_model()):
-    """
-    Returns prediction given the model and data to predict
-
-    Parameters
-    ----------
-    model: Model session instance returned by load_model API
-    data: Data format as expected by the onnxruntime API
-
-    Returns
-    -------
-    predictions: Output from scoring server
-        Format: {'prediction':output from model.predict method}
-
-    """
-    from pandas import read_json, DataFrame
-    from io import StringIO
-    X = read_json(StringIO(data)) if isinstance(data, str) else DataFrame.from_dict(data)
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    contents = os.listdir(model_dir)
-    # Note: User may need to edit this
-    if transformer_name in contents:
-        onnx_data_transformer = ONNXTransformer.load(os.path.join(model_dir, transformer_name))
-        X = onnx_data_transformer.transform(X)
-    else:
-        onnx_data_transformer = None
-    onnx_transformed_rows = []
-    for name, row in X.iterrows():
-        onnx_transformed_rows.append(list(row))
-    input_data = {model.get_inputs()[0].name: onnx_transformed_rows}
-    pred = model.run(None, input_data)
-    return {'prediction':pred[0].tolist()}
-
-
-class ONNXTransformer(object):
-    """
-    This is a transformer to convert X [pandas.Dataframe, equivalent] data into Onnx
-    readable dtypes and formats. It is Serializable, so it can be reloaded at another time.
-
-
-    Examples
-    --------
-    >>> from ads.model.transformer.onnx_transformer import ONNXTransformer
-    >>> onnx_data_transformer = ONNXTransformer()
-    >>> train_transformed = onnx_data_transformer.fit_transform(train.X, {"column_name1": "impute_value1", "column_name2": "impute_value2"}})
-    >>> test_transformed = onnx_data_transformer.transform(test.X)
-    """
-
-    def __init__(self):
-        self.impute_values = {}
-        self.dtypes = None
-        self._fitted = False
-
-    @staticmethod
-    def _handle_dtypes(X: Union[pd.DataFrame, pd.Series]):
-        """handle the dtypes for pandas dataframe and pandas Series.
-
-        Parameters
-        ----------
-        X : Union[pd.DataFrame, pd.Series]
-            The Dataframe for the training data
-
-        Returns
-        -------
-        Union[pd.DataFrame, pd.Series]
-            The transformed(numerical values are cast to float32) X data
-        """
-        # Data type cast could be expensive doing it in a for loop
-        # Especially with wide datasets
-        # So cast the numerical columns first, without loop
-        # Then impute missing values
-        if isinstance(X, pd.Series):
-            series_name = X.name if X.name else 0
-            _X = X.to_frame()
-            _X = ONNXTransformer._handle_dtypes_dataframe(_X)[series_name]
-        elif isinstance(X, pd.DataFrame):
-            _X = ONNXTransformer._handle_dtypes_dataframe(X)
-        else:
-            raise NotImplemented(f"{type(X)} is not supported.")
-        return _X
-
-    @staticmethod
-    def _handle_dtypes_dataframe(X: pd.DataFrame):
-        """handle the dtypes for pandas dataframe.
-
-        Parameters
-        ----------
-        X : pandas.DataFrame
-            The Dataframe for the training data
-
-        Returns
-        -------
-        pandas.DataFrame
-            The transformed X data
-        """
-        dict_astype = {}
-        for k, v in zip(X.columns, X.dtypes):
-            if "int" in str(v) or "float" in str(v):
-                dict_astype[k] = "float32"
-        _X = X.astype(dict_astype)
-        return _X
-
-    def fit(self, X: Union[pd.DataFrame, pd.Series], impute_values: Dict = {}):
-        """
-        Fits the OnnxTransformer on the dataset
-        Parameters
-        ----------
-        X : Union[pandas.DataFrame, pandas.Series]
-            The Dataframe for the training data
-
-        Returns
-        -------
-        Self: ads.Model
-            The fitted estimator
-        """
-        _X = ONNXTransformer._handle_dtypes(X)
-        self.dtypes = _X.dtypes
-        self.impute_values = impute_values
-        self._fitted = True
-        return self
-
-    def transform(self, X: Union[pd.DataFrame, pd.Series]):
-        """
-        Transforms the data for the OnnxTransformer.
-
-        Parameters
-        ----------
-        X: Union[pandas.DataFrame, pandas.Series]
-            The Dataframe for the training data
-
-        Returns
-        -------
-        Union[pandas.DataFrame, pandas.Series]
-            The transformed X data
-        """
-        assert self._fitted, "Call fit_transform first!"
-        _X = X.astype(self.dtypes)
-        logging.warning("Numerical values in `X` are cast to float32.")
-        _X = ONNXTransformer._handle_missing_value(_X, impute_values=self.impute_values)
-        return _X
-
-    @staticmethod
-    def _handle_missing_value(X: Union[pd.DataFrame, pd.Series], impute_values: Dict):
-        """Impute missing values in X according to impute_values.
-
-        Parameters
-        ----------
-        X: Union[pandas.DataFrame, pandas.Series]
-            The Dataframe for the training data
-
-        Raises
-        ------
-        Exception if X has only one dim, but imputed_values has multiple values.
-        NotImplemented if X has the data type that is not supported.
-
-        Returns
-        -------
-        Union[pandas.DataFrame, pd.Series]
-            The transformed X data
-        """
-        if isinstance(X, pd.DataFrame):
-            X = ONNXTransformer._handle_missing_value_dataframe(
-                X, impute_values=impute_values
-            )
-        elif isinstance(X, pd.Series):
-            X = X.replace(r"^\s*$", np.NaN, regex=True)
-            if len(impute_values.keys()) == 1:
-                for key, val in impute_values.items():
-                    X = X.fillna(val)
-            else:
-                raise Exception(
-                    "Multiple imputed values are provided, but `X` has only one dim."
-                )
-        else:
-            raise NotImplemented(
-                f"{type(X)} is not supported. Supported types includes pd.DataFrame, and pd.Series."
-            )
-        return X
-
-    @staticmethod
-    def _handle_missing_value_dataframe(X: pd.DataFrame, impute_values: Dict):
-        for idx, val in impute_values.items():
-            if isinstance(idx, int):
-                X.iloc[:, idx] = (
-                    X.iloc[:, idx].replace(r"^\s*$", np.NaN, regex=True).fillna(val)
-                )
-            else:
-                X.loc[:, idx] = (
-                    X.loc[:, idx].replace(r"^\s*$", np.NaN, regex=True).fillna(val)
-                )
-        return X
-
-    def fit_transform(
-        self, X: Union[pd.DataFrame, pd.Series], impute_values: Dict = {}
-    ):
-        """
-        Fits, then transforms the data
-        Parameters
-        ----------
-        X: Union[pandas.DataFrame, pandas.Series]
-            The Dataframe for the training data
-
-        Returns
-        -------
-        Union[pandas.DataFrame, pandas.Series]
-            The transformed X data
-        """
-        return self.fit(X, impute_values).transform(X)
-
-    def save(self, filename, **kwargs):
-        """
-        Saves the Onnx model to disk
-        Parameters
-        ----------
-        filename: Str
-            The filename location for where the model should be saved
-
-        Returns
-        -------
-        filename: Str
-            The filename where the model was saved
-        """
-        export_dict = {
-            "impute_values": {
-                "value": self.impute_values,
-                "dtype": str(type(self.impute_values)),
-            },
-            "dtypes": {
-                "value": {
-                    "index": list(self.dtypes.index),
-                    "values": [str(val) for val in self.dtypes.values],
-                }
-                if self.dtypes is not None
-                else {},
-                "dtype": str(type(self.dtypes)),
-            },
-            "_fitted": {"value": self._fitted, "dtype": str(type(self._fitted))},
-        }
-
-        with open(filename, "w") as f:
-            json.dump(export_dict, f, sort_keys=True, indent=4, separators=(",", ": "))
-        return filename
-
-    @staticmethod
-    def load(filename, **kwargs):
-        """
-        Loads the Onnx model to disk
-        Parameters
-        ----------
-        filename: Str
-            The filename location for where the model should be loaded
-
-        Returns
-        -------
-        onnx_transformer: ONNXTransformer
-            The loaded model
-        """
-        # Make sure you have  pandas, numpy, and sklearn imported
-        with open(filename, "r") as f:
-            export_dict = json.load(f)
-
-        onnx_transformer = ONNXTransformer()
-
-        for key in export_dict.keys():
-            if key not in ["impute_values", "dtypes"]:
-                try:
-                    setattr(onnx_transformer, key, export_dict[key]["value"])
-                except Exception as e:
-                    print(
-                        f"Warning: Failed to reload {key} from {filename} to OnnxTransformer."
-                    )
-                    raise e
-        onnx_transformer.dtypes = pd.Series(
-            data=[np.dtype(val) for val in export_dict["dtypes"]["value"]["values"]],
-            index=export_dict["dtypes"]["value"]["index"],
-        )
-        onnx_transformer.impute_values = export_dict["impute_values"]["value"]
-        return onnx_transformer

ads/templates/score_embedding_onnx.jinja2

@@ -1,202 +0,0 @@
-# score.py {{SCORE_VERSION}} generated by ADS {{ADS_VERSION}} on {{time_created}}
-import os
-import sys
-import json
-import subprocess
-from functools import lru_cache
-import onnxruntime as ort
-import jsonschema
-from jsonschema import validate, ValidationError
-from transformers import AutoTokenizer
-import logging
-
-model_name = '{{model_file_name}}'
-openapi_schema = 'openapi.json'
-
-
-"""
-   Inference script. This script is used for prediction by scoring server when schema is known.
-"""
-
-
-@lru_cache(maxsize=10)
-def load_model(model_file_name=model_name):
-    """
-    Loads model from the serialized format
-
-    Returns
-    -------
-    model:  a model instance on which predict API can be invoked
-    """
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    if model_dir not in sys.path:
-        sys.path.insert(0, model_dir)
-    contents = os.listdir(model_dir)
-    if model_file_name in contents:
-        print(f'Start loading {model_file_name} from model directory {model_dir} ...')
-        providers= ['CPUExecutionProvider']
-        if is_gpu_available():
-            providers=['CUDAExecutionProvider','CPUExecutionProvider']
-        model = ort.InferenceSession(os.path.join(model_dir, model_file_name), providers=providers)
-        print("Model is successfully loaded.")
-        return model
-    else:
-        raise Exception(f'{model_file_name} is not found in model directory {model_dir}')
-
-
-def is_gpu_available():
-    """Check if gpu is available on the infrastructure."""
-    try:
-        result = subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        if result.returncode == 0:
-           return True
-    except FileNotFoundError:
-        return False
-
-
-@lru_cache(maxsize=1)
-def load_tokenizer(model_full_name):
-
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    # initialize tokenizer
-    return AutoTokenizer.from_pretrained(model_dir, clean_up_tokenization_spaces=True)
-
-@lru_cache(maxsize=1)
-def load_openapi_schema():
-    """
-    Loads the input schema for the incoming request
-
-    Returns
-    -------
-    schema:  openapi schema as json
-    """
-    model_dir = os.path.dirname(os.path.realpath(__file__))
-    if model_dir not in sys.path:
-        sys.path.insert(0, model_dir)
-    contents = os.listdir(model_dir)
-
-    try:
-        with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), openapi_schema), 'r') as file:
-            return json.load(file)
-    except:
-        raise Exception(f'{openapi_schema} is not found in model directory {model_dir}')
-
-
-def validate_inputs(data):
-
-    api_schema = load_openapi_schema()
-
-    # use a reference resolver for internal $refs
-    resolver = jsonschema.RefResolver.from_schema(api_schema)
-
-    # get the actual schema part to validate against
-    request_schema = api_schema["components"]["schemas"]["OpenAICompatRequest"]
-
-    try:
-        # validate the input JSON
-        validate(instance=data, schema=request_schema, resolver=resolver)
-    except ValidationError as e:
-        example_value = {
-            "input": ["What are activation functions?"],
-            "encoding_format": "float",
-            "model": "sentence-transformers/all-MiniLM-L6-v2",
-            "user": "user"
-        }
-        message = f"JSON is invalid. Error: {e.message}\n An example of the expected format for 'OpenAICompatRequest' looks like: \n {json.dumps(example_value, indent=2)}"
-        raise ValueError(message) from e
-
-
-def pre_inference(data):
-    """
-    Preprocess data
-
-    Parameters
-    ----------
-    data: Data format as expected by the predict API.
-
-    Returns
-    -------
-    onnx_inputs: Data format after any processing
-    total_tokens: total tokens that will be processed by the model
-
-    """
-    validate_inputs(data)
-
-    tokenizer = load_tokenizer(data['model'])
-    inputs = tokenizer(data['input'], return_tensors="np", padding=True)
-
-    padding_token_id = tokenizer.pad_token_id
-    total_tokens = (inputs["input_ids"] != padding_token_id).sum().item()
-    onnx_inputs = {key: [l.tolist()for l in inputs[key] ] for key in inputs}
-
-    return onnx_inputs, total_tokens
-
-def convert_embeddings_to_openapi_format(embeddings, model_name, total_tokens):
-
-    formatted_data = []
-    openai_compat_response = {}
-    for idx, embedding in enumerate(embeddings):
-
-        formatted_embedding = {
-            "object": "embedding",
-            "embedding": embedding,
-            "index": idx
-        }
-        formatted_data.append(formatted_embedding)
-
-    # create the final OpenAICompatResponse format
-    openai_compat_response = {
-        "object": "list",
-        "data": formatted_data,
-        "model": model_name,  # Use the provided model name
-        "usage": {
-            "prompt_tokens": total_tokens,  # represents the token count for just the text input
-            "total_tokens": total_tokens     # total number of tokens involved in the request, same in case of embeddings
-        }
-    }
-
-    return openai_compat_response
-
-
-def post_inference(outputs, model_name, total_tokens):
-    """
-    Post-process the model results
-
-    Parameters
-    ----------
-    outputs: Data format after calling model.run
-    model_name: name of model
-    total_tokens: total tokens that will be processed by the model
-
-    Returns
-    -------
-    outputs: Data format after any processing.
-
-    """
-    results = [embed.tolist() for embed in outputs]
-    response = convert_embeddings_to_openapi_format(results, model_name, total_tokens)
-    return response
-
-def predict(data, model=load_model()):
-    """
-    Returns prediction given the model and data to predict
-
-    Parameters
-    ----------
-    model: Model instance returned by load_model API.
-    data: Data format as expected by the predict API of the core estimator. For eg. in case of sckit models it could be numpy array/List of list/Pandas DataFrame.
-
-    Returns
-    -------
-    predictions: Output from scoring server
-        Format: {'prediction': output from model.predict method}
-
-    """
-    # inputs contains 'input_ids', 'token_type_ids', 'attention_mask' but 'token_type_ids' is optional
-    inputs, total_tokens = pre_inference(data)
-
-    onnx_inputs = [inp.name for inp in model.get_inputs()]
-    embeddings = model.run(None, {key: inputs[key] if key in inputs else None for key in onnx_inputs})[0]
-
-    response = post_inference(embeddings, data['model'], total_tokens)
-    return response