Build a Model Factory¶

from time import sleep

from dask import compute, delayed  # For parallelization
import datarobot as dr  # Requires version >2.19
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

sns.set(style="whitegrid")

data_path = "https://docs.datarobot.com/en/docs/api/guide/python/10k-diabetes.csv"

df = pd.read_csv(data_path)

# If the config file is not in the default location described in the API Quickstart guide, '~/.config/datarobot/drconfig.yaml', then you will need to call
# dr.Client(config_path='path-to-drconfig.yaml')

original_proj = dr.Project.start(
    df,  # Pandas dataframe with data
    project_name="Readmissions",  # Name of the project
    target="readmitted",  # Target of the project
    metric="LogLoss",  # Optimization metric (Default is LogLoss)
    worker_count=-1,
)  # Amount of workers to use (-1 means every worker available)

original_proj.wait_for_autopilot(
    verbosity=1
)  # Wait for Autopilot to finish. You can set verbosity to 0 if you do not wish to see progress updates

# Choose the most accurate model
best_model = original_proj.get_models()[0]

print(best_model)  # Print the most accurate model's name
best_model.metrics["LogLoss"]["crossValidation"]  # Print the crossValidation score

def plot_roc_curve(datarobot_model):
    """This function plots a roc curve.
    Input:
        datarobot_model: <Datarobot Model object>
    """
    roc = datarobot_model.get_roc_curve("crossValidation")
    roc_df = pd.DataFrame(roc.roc_points)
    auc_score = datarobot_model.metrics["AUC"]["crossValidation"]
    plt.plot(
        roc_df["false_positive_rate"],
        roc_df["true_positive_rate"],
        "b",
        label="AUC = %0.2f" % auc_score,
    )
    plt.legend(loc="lower right")
    plt.plot([0, 1], [0, 1], "r--")
    plt.xlim([0, 1])
    plt.ylim([0, 1])
    plt.ylabel("True Positive Rate")
    plt.xlabel("False Positive Rate")
    plt.show()


def plot_feature_impact(datarobot_model, title=None):
    """This function plots feature impact
    Input:
        datarobot_model: <Datarobot Model object>
        title : <string> --> title of graph
    """
    # Get feature impact
    feature_impacts = datarobot_model.get_or_request_feature_impact()

    # Sort feature impact based on normalised impact
    feature_impacts.sort(key=lambda x: x["impactNormalized"], reverse=True)

    fi_df = pd.DataFrame(feature_impacts)  # Save feature impact in pandas dataframe
    fig, ax = plt.subplots(figsize=(14, 5))
    b = sns.barplot(x="featureName", y="impactNormalized", data=fi_df[0:5], color="b")
    b.axes.set_title("Feature Impact" if not title else title, fontsize=20)


def wait_for_autopilot(proj, wait=120):
    total_wait = 0
    while proj.get_status()["autopilot_done"] == False:
        sleep(wait)
        total_wait += wait
        total_jobs = len(proj.get_all_jobs())
        print(
            "Autopilot still running! {} jobs running and in queue. Total wait time {}s".format(
                total_jobs, total_wait
            )
        )

def run_dr_factory(segment_num):
    try:
        temp_project = dr.Project.start(
            df.loc[df["admission_type_id"] == segment_num],
            project_name="Readmission_%s" % segment_num,
            target="readmitted",
            metric="LogLoss",
            worker_count=10,
        )
        return temp_project
    except:  # Catching the case when dataset has fewer than 20 rows.
        return f"There was an error in segment {segment_num}."

delayed_dr_projects = []

# Create one project for each customer type
for value in df["admission_type_id"].unique():
    temp = delayed(run_dr_factory)(value)
    delayed_dr_projects.append(temp)

projects = compute(delayed_dr_projects)[0]
# Filter to the projects that did not throw errors
projects_filtered = [project for project in projects if not isinstance(project, str)]

best_models = {}  # To save models
for key, project in enumerate(projects_filtered):
    best_models[key] = projects_filtered[key].get_models()[0]
    print("--------------------------------")
    print("Best model for admission type id: %s" % project)
    print(best_models[key])
    print(best_models[key].metrics["LogLoss"]["crossValidation"])
    print("--------------------------------")

for key, project in enumerate(projects_filtered):
    plot_feature_impact(
        best_models[key], title="Feature Impact for admission type id: %s" % project
    )

prediction_server = dr.PredictionServer.list()[0]

for key in best_models:
    temp_deployment = dr.Deployment.create_from_learning_model(
        best_models[key].id,
        label="Readmissions_admission_type: %s" % key,
        description="Test deployment",
        default_prediction_server_id=prediction_server.id,
    )