frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/models/init/_logic/template/credit_risk/{{cookiecutter.model_directory}}/main/model.py

@@ -0,0 +1,108 @@
+import os
+
+import frogml
+import numpy as np
+import pandas as pd
+from catboost import CatBoostClassifier, Pool, cv
+from frogml import FrogMlModel
+from frogml.sdk.model.schema import ExplicitFeature, InferenceOutput, ModelSchema
+from sklearn.model_selection import train_test_split
+
+RUNNING_FILE_ABSOLUTE_PATH = os.path.dirname(os.path.abspath(__file__))
+
+
+class CreditRisk(FrogMlModel):
+    """The Model class inherit FrogMlModel base class"""
+
+    def __init__(self):
+        self.params = {
+            "iterations": int(os.getenv("iterations", 1000)),
+            "learning_rate": float(os.getenv("learning_rate", 0.1)),
+            "eval_metric": "Accuracy",
+            "random_seed": int(os.getenv("random_seed", 7)),
+            "logging_level": "Silent",
+            "loss_function": os.getenv("loss_fn", "Logloss"),
+            "use_best_model": True,
+        }
+        self.model = CatBoostClassifier(**self.params)
+
+        frogml.log_param(self.params)
+
+    def build(self):
+        df_credit = pd.read_csv(f"{RUNNING_FILE_ABSOLUTE_PATH}/data.csv", index_col=0)
+
+        # Creating an categorical variable to handle with the Age variable
+        interval = (18, 25, 35, 60, 120)
+        cats = ["Student", "Young", "Adult", "Senior"]
+        df_credit["Age_cat"] = pd.cut(df_credit.Age, interval, labels=cats).astype(
+            object
+        )
+
+        df_credit["Saving accounts"] = df_credit["Saving accounts"].fillna("no_inf")
+        df_credit["Checking account"] = df_credit["Checking account"].fillna("no_inf")
+
+        df_credit = df_credit.merge(
+            pd.get_dummies(df_credit.Risk, prefix="Risk"),
+            left_index=True,
+            right_index=True,
+        )
+
+        # Excluding the missing columns
+        del df_credit["Risk"]
+        del df_credit["Risk_good"]
+
+        df_credit["Credit amount"] = np.log(df_credit["Credit amount"])
+
+        # Creating the X and y variables
+        X = df_credit.drop(["Risk_bad"], axis=1)
+        y = df_credit["Risk_bad"]
+        categorical_features_indices = np.where(X.dtypes == object)[0]
+
+        # Spliting X and y into train and test version
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.25, random_state=self.params["random_seed"]
+        )
+        self.model.fit(
+            X_train,
+            y_train,
+            cat_features=categorical_features_indices,
+            eval_set=(X_test, y_test),
+        )
+
+        # Cross validating the model (5-fold)
+        cv_data = cv(
+            Pool(X_train, y_train, cat_features=categorical_features_indices),
+            self.model.get_params(),
+            fold_count=5,
+        )
+        print(
+            "the best cross validation accuracy is :{}".format(
+                np.max(cv_data["test-Accuracy-mean"])
+            )
+        )
+        frogml.log_metric({"val_accuracy": np.max(cv_data["test-Accuracy-mean"])})
+
+    def schema(self):
+        return ModelSchema(
+            inputs=[
+                ExplicitFeature(name="UserId", type=str),
+                ExplicitFeature(name="Age", type=int),
+                ExplicitFeature(name="Sex", type=str),
+                ExplicitFeature(name="Job", type=int),
+                ExplicitFeature(name="Housing", type=str),
+                ExplicitFeature(name="Saving accounts", type=str),
+                ExplicitFeature(name="Checking account", type=str),
+                ExplicitFeature(name="Credit amount", type=float),
+                ExplicitFeature(name="Duration", type=int),
+                ExplicitFeature(name="Purpose", type=str),
+                ExplicitFeature(name="Age_cat", type=str),
+            ],
+            outputs=[InferenceOutput(name="Default_Probability", type=float)],
+        )
+
+    @frogml.api()
+    def predict(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.drop(["UserId"], axis=1)
+        return pd.DataFrame(
+            self.model.predict_proba(df[self.model.feature_names_])[:, 1], columns=["Default_Probability"]
+        )

frogml_cli/commands/models/init/_logic/template/general/cookiecutter.json

@@ -0,0 +1,6 @@
+{
+    "model_directory": "model",
+    "main_directory": "main",
+    "test_directory": "tests",
+    "model_class_name": "modelPrediction"
+}

frogml_cli/commands/models/init/_logic/template/general/{{cookiecutter.model_directory}}/{{cookiecutter.main_directory}}/__init__.py

@@ -0,0 +1,5 @@
+from .model import {{cookiecutter.model_class_name}}
+
+
+def load_model():
+    return {{cookiecutter.model_class_name}}()

frogml_cli/commands/models/init/_logic/template/general/{{cookiecutter.model_directory}}/{{cookiecutter.main_directory}}/conda.yml

@@ -0,0 +1,8 @@
+name: {{cookiecutter.model_class_name}}
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python=3.8
+  - pip=22.2.2
+  - pandas=1.1.5

frogml_cli/commands/models/init/_logic/template/general/{{cookiecutter.model_directory}}/{{cookiecutter.main_directory}}/model.py

@@ -0,0 +1,66 @@
+import frogml
+import pandas as pd
+from frogml import FrogMlModel
+
+
+class {{cookiecutter.model_class_name}}(FrogMlModel):
+    """ The Model class inherit FrogMlModel base class
+    """
+
+    def __init__(self):
+        pass
+
+    def build(self):
+        """ Responsible for loading the model. This method is invoked during build time (frogml build command)
+
+           Example:
+           >>> def build(self):
+           >>>     ...
+           >>>     train_pool = Pool(X_train, y_train, cat_features=categorical_features_indices)
+           >>>     validate_pool = Pool(X_validation, y_validation, cat_features=categorical_features_indices)
+           >>>     self.catboost.fit(train_pool, eval_set=validate_pool)
+           """
+        pass
+
+    def schema(self):
+        """ Specification of the model inputs and outputs. Optional method
+
+        Example:
+        >>> from frogml.sdk.model.schema import ModelSchema, InferenceOutput, ExplicitFeature
+        >>>
+        >>> def schema(self) -> ModelSchema:
+        >>>     model_schema = ModelSchema(
+        >>>     inputs=[
+        >>>         ExplicitFeature(name="State", type=str),
+        >>>     ],
+        >>>     outputs=[
+        >>>         InferenceOutput(name="score", type=float)
+        >>>     ])
+        >>>     return model_schema
+
+       Returns: a model schema specification
+       """
+        pass
+
+    def initialize_model(self):
+        """
+        Invoked when a model is loaded at serving time. Called once per model instance initialization. Can be used for
+        loading and storing values that should only be available in a serving setting or loading pretrained models. Optional method
+
+        Example usage:
+
+        >>> def initialize_model(self):
+        >>>     with open('model.pkl', 'rb') as infile:
+        >>>         self.model = pickle.load(infile)
+        """
+        pass
+
+    @frogml.api()
+    def predict(self, df: pd.DataFrame) -> pd.DataFrame:
+        """ Invoked on every API inference request.
+        Args:
+            pd (DataFrame): the inference vector, as a pandas dataframe
+
+        Returns: model output (inference results), as a pandas dataframe
+        """
+        pass

frogml_cli/commands/models/init/_logic/template/general/{{cookiecutter.model_directory}}/{{cookiecutter.test_directory}}/test_qwak_model.py

@@ -0,0 +1,5 @@
+def test_model():
+    """
+    Skeleton for a test that will run as part of the build process
+    """
+    assert True

frogml_cli/commands/models/init/_logic/template/titanic/cookiecutter.json

@@ -0,0 +1,3 @@
+{
+    "model_directory": "titanic_survival_classification"
+}

frogml_cli/commands/models/init/_logic/template/titanic/{{cookiecutter.model_directory}}/main/__init__.py

@@ -0,0 +1,5 @@
+from .model import TitanicSurvivalPrediction
+
+
+def load_model():
+    return TitanicSurvivalPrediction()

frogml_cli/commands/models/init/_logic/template/titanic/{{cookiecutter.model_directory}}/main/conda.yml

@@ -0,0 +1,11 @@
+name: titanic-survival-classification
+channels:
+  - defaults
+  - conda-forge
+dependencies:
+  - python=3.9
+  - pip=22.2.2
+  - pandas=1.1.5
+  - scikit-learn=0.24.1
+  - catboost=0.26.1
+  - numpy=1.24.0

frogml_cli/commands/models/init/_logic/template/titanic/{{cookiecutter.model_directory}}/main/model.py

@@ -0,0 +1,98 @@
+import os
+
+import frogml
+import numpy as np
+import pandas as pd
+from catboost import CatBoostClassifier, Pool, cv
+from catboost.datasets import titanic
+from frogml import FrogMlModel
+from frogml.sdk.model.schema import ExplicitFeature, InferenceOutput, ModelSchema
+from sklearn.model_selection import train_test_split
+
+
+class TitanicSurvivalPrediction(FrogMlModel):
+    def __init__(self):
+        loss_function = os.getenv("loss_fn", "Logloss")
+        learning_rate = os.getenv("learning_rate", None)
+        if learning_rate:
+            learning_rate = int(learning_rate)
+        iterations = int(os.getenv("iterations", 1000))
+
+        custom_loss = "Accuracy"
+        self.model = CatBoostClassifier(
+            iterations=iterations,
+            custom_loss=[custom_loss],
+            loss_function=loss_function,
+            learning_rate=learning_rate,
+        )
+
+        frogml.log_param(
+            {
+                "loss_function": loss_function,
+                "learning_rate": learning_rate,
+                "iterations": iterations,
+                "custom_loss": custom_loss,
+            }
+        )
+
+    def build(self):
+        titanic_train, _ = titanic()
+
+        # for the train data ,the age ,fare and embarked has null value,so just make it -999 for it
+        # and the catboost will distinguish it
+        titanic_train.fillna(-999, inplace=True)
+
+        x = titanic_train.drop(["Survived", "PassengerId"], axis=1)
+        y = titanic_train.Survived
+
+        x_train, x_test, y_train, y_test = train_test_split(
+            x, y, train_size=0.85, random_state=42
+        )
+
+        # mark categorical features
+        cate_features_index = np.where(x_train.dtypes != float)[0]
+
+        self.model.fit(
+            x_train,
+            y_train,
+            cat_features=cate_features_index,
+            eval_set=(x_test, y_test),
+        )
+
+        # Cross validating the model (5-fold)
+        cv_data = cv(
+            Pool(x, y, cat_features=cate_features_index),
+            self.model.get_params(),
+            fold_count=5,
+        )
+        print(
+            "the best cross validation accuracy is :{}".format(
+                np.max(cv_data["test-Accuracy-mean"])
+            )
+        )
+        frogml.log_metric({"val_accuracy": np.max(cv_data["test-Accuracy-mean"])})
+
+    def schema(self):
+        return ModelSchema(
+            inputs=[
+                ExplicitFeature(name="PassengerId", type=int),
+                ExplicitFeature(name="Pclass", type=int),
+                ExplicitFeature(name="Name", type=str),
+                ExplicitFeature(name="Sex", type=str),
+                ExplicitFeature(name="Age", type=int),
+                ExplicitFeature(name="SibSp", type=int),
+                ExplicitFeature(name="Parch", type=int),
+                ExplicitFeature(name="Ticket", type=str),
+                ExplicitFeature(name="Fare", type=float),
+                ExplicitFeature(name="Cabin", type=str),
+                ExplicitFeature(name="Embarked", type=str),
+            ],
+            outputs=[InferenceOutput(name="Survived_Probability", type=float)],
+        )
+
+    @frogml.api()
+    def predict(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.drop(["PassengerId"], axis=1)
+        return pd.DataFrame(
+            self.model.predict_proba(df)[:, 1], columns=["Survived_Probability"]
+        )

frogml_cli/commands/models/init/_logic/template/titanic/{{cookiecutter.model_directory}}/tests/it/test_titanic.py

@@ -0,0 +1,24 @@
+import pandas as pd
+from frogml.core.testing.fixtures import real_time_client
+from frogml_inference.realtime_client.client import InferenceOutputFormat
+
+
+def test_realtime_api(real_time_client):
+    feature_vector = [
+        {
+            "PassengerId": 762,
+            "Pclass": 3,
+            "Name": "Nirva, Mr. Iisakki Antino Aijo	",
+            "Sex": "female",
+            "Age": 34,
+            "SibSp": 4,
+            "Parch": 3,
+            "Ticket": "a",
+            "Fare": 1.0,
+            "Cabin": "A",
+            "Embarked": "A",
+        }
+    ]
+
+    survived_probability: pd.DataFrame = real_time_client.predict(feature_vector, output_format=InferenceOutputFormat.PANDAS)
+    assert survived_probability["Survived_Probability"].values[0] > 0

frogml_cli/commands/models/init/_logic/template/titanic_poetry/cookiecutter.json

@@ -0,0 +1,3 @@
+{
+    "model_directory": "titanic_poetry_survival_classification"
+}

frogml_cli/commands/models/init/_logic/template/titanic_poetry/{{cookiecutter.model_directory}}/main/__init__.py

@@ -0,0 +1,5 @@
+from .model import TitanicSurvivalPrediction
+
+
+def load_model():
+    return TitanicSurvivalPrediction()

frogml_cli/commands/models/init/_logic/template/titanic_poetry/{{cookiecutter.model_directory}}/main/model.py

@@ -0,0 +1,98 @@
+import os
+
+import frogml
+import numpy as np
+import pandas as pd
+from catboost import CatBoostClassifier, Pool, cv
+from catboost.datasets import titanic
+from frogml import FrogMlModel
+from frogml.sdk.model.schema import ExplicitFeature, InferenceOutput, ModelSchema
+from sklearn.model_selection import train_test_split
+
+
+class TitanicSurvivalPrediction(FrogMlModel):
+    def __init__(self):
+        loss_function = os.getenv("loss_fn", "Logloss")
+        learning_rate = os.getenv("learning_rate", None)
+        if learning_rate:
+            learning_rate = int(learning_rate)
+        iterations = int(os.getenv("iterations", 1000))
+
+        custom_loss = "Accuracy"
+        self.model = CatBoostClassifier(
+            iterations=iterations,
+            custom_loss=[custom_loss],
+            loss_function=loss_function,
+            learning_rate=learning_rate,
+        )
+
+        frogml.log_param(
+            {
+                "loss_function": loss_function,
+                "learning_rate": learning_rate,
+                "iterations": iterations,
+                "custom_loss": custom_loss,
+            }
+        )
+
+    def build(self):
+        titanic_train, _ = titanic()
+
+        # for the train data ,the age ,fare and embarked has null value,so just make it -999 for it
+        # and the catboost will distinguish it
+        titanic_train.fillna(-999, inplace=True)
+
+        x = titanic_train.drop(["Survived", "PassengerId"], axis=1)
+        y = titanic_train.Survived
+
+        x_train, x_test, y_train, y_test = train_test_split(
+            x, y, train_size=0.85, random_state=42
+        )
+
+        # mark categorical features
+        cate_features_index = np.where(x_train.dtypes != float)[0]
+
+        self.model.fit(
+            x_train,
+            y_train,
+            cat_features=cate_features_index,
+            eval_set=(x_test, y_test),
+        )
+
+        # Cross validating the model (5-fold)
+        cv_data = cv(
+            Pool(x, y, cat_features=cate_features_index),
+            self.model.get_params(),
+            fold_count=5,
+        )
+        print(
+            "the best cross validation accuracy is :{}".format(
+                np.max(cv_data["test-Accuracy-mean"])
+            )
+        )
+        frogml.log_metric({"val_accuracy": np.max(cv_data["test-Accuracy-mean"])})
+
+    def schema(self):
+        return ModelSchema(
+            inputs=[
+                ExplicitFeature(name="PassengerId", type=int),
+                ExplicitFeature(name="Pclass", type=int),
+                ExplicitFeature(name="Name", type=str),
+                ExplicitFeature(name="Sex", type=str),
+                ExplicitFeature(name="Age", type=int),
+                ExplicitFeature(name="SibSp", type=int),
+                ExplicitFeature(name="Parch", type=int),
+                ExplicitFeature(name="Ticket", type=str),
+                ExplicitFeature(name="Fare", type=float),
+                ExplicitFeature(name="Cabin", type=str),
+                ExplicitFeature(name="Embarked", type=str),
+            ],
+            outputs=[InferenceOutput(name="Survived_Probability", type=float)],
+        )
+
+    @frogml.api()
+    def predict(self, df: pd.DataFrame) -> pd.DataFrame:
+        df = df.drop(["PassengerId"], axis=1)
+        return pd.DataFrame(
+            self.model.predict_proba(df)[:, 1], columns=["Survived_Probability"]
+        )

frogml_cli/commands/models/init/_logic/template/titanic_poetry/{{cookiecutter.model_directory}}/main/pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "titanic-poetry-survival-classification"
+version = "0.1.0"
+description = "A model to perdict whether a person survived the titanic crash or not."
+authors = ["JFrog Ltd. <contact@jfrog.com>"]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[tool.poetry.dev-dependencies]
+pip = "22.2.2"
+pandas = "1.1.5"
+scikit-learn = "0.24.1"
+catboost = "0.26.1"
+numpy = "1.23.5"
+setuptools = "70.0.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

frogml_cli/commands/models/init/_logic/template/titanic_poetry/{{cookiecutter.model_directory}}/tests/it/test_titanic.py

@@ -0,0 +1,25 @@
+import pandas as pd
+from frogml.core.testing.fixtures import real_time_client
+from frogml_inference.realtime_client.client import InferenceOutputFormat
+
+
+def test_realtime_api(real_time_client):
+    feature_vector = [
+        {
+            "PassengerId": 762,
+            "Pclass": 3,
+            "Name": "Nirva, Mr. Iisakki Antino Aijo	",
+            "Sex": "female",
+            "Age": 34,
+            "SibSp": 4,
+            "Parch": 3,
+            "Ticket": "a",
+            "Fare": 1.0,
+            "Cabin": "A",
+            "Embarked": "A",
+        }
+    ]
+
+    survived_probability: pd.DataFrame = real_time_client.predict(feature_vector, output_format=InferenceOutputFormat.PANDAS)
+
+    assert survived_probability["Survived_Probability"].values[0] > 0

frogml_cli/commands/models/init/ui.py

@@ -0,0 +1,61 @@
+import click
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.init._logic.initialize_model_structure import (
+    initialize_model_structure,
+)
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+logger = get_frogml_logger()
+
+
+@click.command("init", cls=FrogMLCommand)
+@click.option(
+    "--model-directory", metavar="NAME", required=False, help="folder for model content"
+)
+@click.option(
+    "--model-class-name",
+    metavar="NAME",
+    required=False,
+    help="class name of created model",
+)
+@click.option(
+    "--example",
+    metavar="NAME",
+    required=False,
+    type=click.Choice(
+        ["titanic", "credit_risk", "churn", "titanic_poetry"], case_sensitive=True
+    ),
+    help="""Generate a fully functioning example of a Qwak based model. Options: titanic / credit_risk / churn""",
+)
+@click.argument("uri", metavar="URI", required=True)
+def model_init(
+    uri: str, model_directory: str, model_class_name: str, example: str, **kwargs
+):
+    if example:
+        if model_directory or model_class_name:
+            logger.warning("--example flag detected. Other options will be overridden.")
+
+        template = example
+        template_args = {}
+
+    else:
+        if model_directory is None:
+            model_directory = click.prompt(
+                "Please enter the model directory name", type=str
+            )
+        if model_class_name is None:
+            model_class_name = click.prompt(
+                "Please enter the model class name", type=str
+            )
+
+        template = "general"
+        template_args = {
+            "model_class_name": model_class_name,
+            "model_directory": model_directory,
+        }
+    try:
+        initialize_model_structure(uri, template, logger, **template_args)
+    except Exception as e:
+        logger.error(f"Failed to initialize a Qwak model structure. Error reason:\n{e}")
+        exit(1)

frogml_cli/commands/models/list/_logic.py

@@ -0,0 +1,5 @@
+from frogml.core.clients.project.client import ProjectsManagementClient
+
+
+def execute_models_list(project_key: str):
+    return ProjectsManagementClient().get_project(project_name=project_key)

frogml_cli/commands/models/list/ui.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+
+import click
+from frogml._proto.qwak.projects.projects_pb2 import GetProjectResponse
+
+from frogml_cli.commands.models.list._logic import execute_models_list
+from frogml_cli.commands.ui_tools import output_as_json, output_as_table
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+def parse_model(model):
+    return [
+        model.model_id,
+        model.display_name,
+        datetime.fromtimestamp(
+            model.created_at.seconds + model.created_at.nanos / 1e9
+        ).strftime("%A, %B %d, %Y %I:%M:%S"),
+        datetime.fromtimestamp(
+            model.last_modified_at.seconds + model.last_modified_at.nanos / 1e9
+        ).strftime("%A, %B %d, %Y %I:%M:%S"),
+    ]
+
+
+@click.command("list", cls=FrogMLCommand)
+@click.option("--project-key", metavar="NAME", required=True, help="JFrog project key")
+@click.option(
+    "--format",
+    default="text",
+    show_default=True,
+    type=click.Choice(["text", "json"], case_sensitive=True),
+    metavar="FORMAT",
+    required=False,
+    help="The formatting style for commands output (choose from text, json)",
+)
+def model_list(project_key: str, format, **kwargs):
+    model_list_result: GetProjectResponse = execute_models_list(project_key)
+    columns = ["Model id", "Display name", "Creation date", "Last updated"]
+    if format == "json":
+        output_as_json(model_list_result)
+    elif format == "text":
+        output_as_table(model_list_result.project.models, parse_model, headers=columns)

frogml_cli/commands/models/list_models/_logic.py

@@ -0,0 +1,11 @@
+from frogml._proto.qwak.projects.projects_pb2 import GetProjectResponse
+from frogml.core.clients.model_management.client import ModelsManagementClient
+from frogml.core.clients.project.client import ProjectsManagementClient
+
+
+def list_models(project_key: str):
+    project_response: GetProjectResponse = ProjectsManagementClient().get_project(
+        project_name=project_key
+    )
+    project_id: str = project_response.project.spec.project_id
+    return ModelsManagementClient().list_models(project_id)