Loan default notebook¶

!pip install datarobot umap-learn nbformat hdbscan

import datarobot as dr
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick

light_blue = "#598fd6"
grey_blue = "#5f728b"
orange = "#dd6b3d"

EXISTING_PROJECT_ID = None # If you've already created a project, replace None with the ID here
if EXISTING_PROJECT_ID is None:
    # Create project and pass in data
    project = dr.Project.create(sourcedata = pathfinder_df,
                                project_name = 'Predict loan defaults')

    # Set the project target to the appropriate feature. Use the LogLoss metric to measure performance
    project.set_target(target='is_bad',
                       mode=dr.AUTOPILOT_MODE.QUICK, 
                       worker_count='-1')
else:
    # Fetch the existing project
    project = dr.Project.get(EXISTING_PROJECT_ID)

project.wait_for_autopilot(check_interval=30)
# Uncomment and replace the project ID if the project already exists
# project = dr.Project.get("612cb904ce5d5617d67af394")

# Get the project metric (i.e LogLoss, RMSE, etc...)
metric = project.metric

# Get project URL
project_url = project.get_leaderboard_ui_permalink()

# Get project ID
project_id = project.id

def sorted_by_metric(models, test_set, metric):
    models_with_score = [model for model in models if
                         model.metrics[metric][test_set] is not None]
    
    return sorted(models_with_score,
                  key=lambda model: model.metrics[metric][test_set])

# Set styling
dr_dark_blue = '#08233F'
dr_blue = '#1F77B4'
dr_orange = '#FF7F0E'
dr_red = '#BE3C28'

# Function to build histograms
def rebin_df(raw_df, number_of_bins):
    cols = ['bin', 'actual_mean', 'predicted_mean', 'bin_weight']
    new_df = pd.DataFrame(columns=cols)
    current_prediction_total = 0
    current_actual_total = 0
    current_row_total = 0
    x_index = 1
    bin_size = 60 / number_of_bins
    for rowId, data in raw_df.iterrows():
        current_prediction_total += data['predicted'] * data['bin_weight']
        current_actual_total += data['actual'] * data['bin_weight']
        current_row_total += data['bin_weight']

        if ((rowId + 1) % bin_size == 0):
            x_index += 1
            bin_properties = {
                'bin': ((round(rowId + 1) / 60) * number_of_bins),
                'actual_mean': current_actual_total / current_row_total,
                'predicted_mean': current_prediction_total / current_row_total,
                'bin_weight': current_row_total
            }

            new_df = new_df.append(bin_properties, ignore_index=True)
            current_prediction_total = 0
            current_actual_total = 0
            current_row_total = 0
    return new_df

# Function to build lift charts
def matplotlib_lift(bins_df, bin_count, ax):
    grouped = rebin_df(bins_df, bin_count)
    ax.plot(range(1, len(grouped) + 1), grouped['predicted_mean'],
            marker='+', lw=1, color=dr_blue, label='predicted')
    ax.plot(range(1, len(grouped) + 1), grouped['actual_mean'],
            marker='*', lw=1, color=dr_orange, label='actual')
    ax.set_xlim([0, len(grouped) + 1])
    ax.set_facecolor(dr_dark_blue)
    ax.legend(loc='best')
    ax.set_title('Lift chart {} bins'.format(bin_count))
    ax.set_xlabel('Sorted Prediction')
    ax.set_ylabel('Value')
    return grouped

dr_roc_green = '#03c75f'
white = '#ffffff'
dr_purple = '#65147D'
dr_dense_green = '#018f4f'

threshold = roc.get_best_f1_threshold()
fig = plt.figure(figsize=(8, 8))
axes = fig.add_subplot(1, 1, 1, facecolor=dr_dark_blue)

plt.scatter(roc_df.false_positive_rate, roc_df.true_positive_rate, color=dr_roc_green)
plt.plot(roc_df.false_positive_rate, roc_df.true_positive_rate, color=dr_roc_green)
plt.plot([0, 1], [0, 1], color=white, alpha=0.25)
plt.title('ROC curve')
plt.xlabel('False Positive Rate')
plt.xlim([0, 1])
plt.ylabel('True Positive Rate')
plt.ylim([0, 1])

data_path_scoring = "https://s3.amazonaws.com/datarobot-use-case-datasets/Lending+Club+Dataset+Pred.csv"
scoring_df = pd.read_csv(data_path_scoring, encoding = "ISO-8859-1")
pathfinder_df.rename(columns={'loan_is_bad': 'is_bad'}, inplace=True)

prediction_dataset = project.upload_dataset(scoring_df)
predict_job = model_top.request_predictions(prediction_dataset.id)
prediction_dataset.id

predictions = predict_job.get_result_when_complete()
pd.concat([scoring_df, predictions], axis=1)
predictions.positive_probability.plot(kind='hist',title='Predicted Probabilities')

deployment_id = "YOUR_DEPLOYMENT_ID"

dr.Credential.list()

# Scoring without Prediction Explanations
if False:
    dr.BatchPredictionJob.score(
        deployment_id,
        intake_settings={
            'type': 'localFile',
            'file': 'inputfile.csv' # Provide the filepath, Pandas dataframe, or file-like object here
        },
        output_settings={
            'type': 'localFile',
            'file': 'outputfile.csv'
        }
    )

#Scoring with Prediction Explanations
if False:
    dr.BatchPredictionJob.score(
        deployment_id,
        intake_settings={
            'type': 'localFile',
            'file': 'inputfile.csv' # Provide the filepath, Pandas dataframe, or file-like object here
        },
        output_settings={
            'type': 'localFile',
            'file': 'outputfile.csv'
        },
    
        max_explanations=3 #Compute Prediction Explanations for the amount of features indicated here
    
    )

if False:
    dr.BatchPredictionJob.score(
        deployment_id,
        intake_settings={
            'type': 's3',
            'url': 's3://theos-test-bucket/lending_club_scoring.csv', #Provide the URL of your datastore here
            'credential_id': 'YOUR_CREDENTIAL_ID_FROM_ABOVE', # Provide your credentials here
        },
        output_settings={
            'type': 's3',
            'url': 's3://theos-test-bucket/lending_club_scored2.csv',
            'credential_id': 'YOUR_CREDENTIAL_ID_FROM_ABOVE'
        }
    )

if False:
    dr.BatchPredictionJob.score(
        deployment_id,
    
        intake_settings = {
        'type': 'jdbc',
        'table': 'table_name',
        'schema': 'public',
        'dataStoreId': data_store.id, #Provide the ID of your datastore here
        'credentialId': cred.credential_id # Provide your credentials here
        },
    
        output_settings = {
            'type': 'jdbc',
            'table': 'table_name',
            'schema': 'public',
            'statementType': 'insert',
            'dataStoreId': data_store.id,
            'credentialId': cred.credential_id
        }
    )