DEV Community: TrustyCore

Interpreting Loan Predictions with TrustyAI: Part 3

Sohini Pattanayak — Wed, 08 Nov 2023 13:56:07 +0000

Implementing Visualizations

Hello again, dear readers! In our previous sessions, we understood LIME explanations in TrustyAI and implemented a simple linear model to explain loan approvals. While seeing the saliency values of each feature is insightful, a graphical representation can offer a clearer understanding of model decisions. Let's delve deeper!

Creating a LIME Feature Impact Visualization

Before we begin, ensure you've gone through Part 2 of our series.

1. Setting Up:

Ensure you've imported the necessary libraries:

import matplotlib.pyplot as plt

2. Generating LIME Explanations:

Using the TrustyAI library, generate the LIME explanations for your model as shown in the previous tutorial.

3. Visualizing Feature Impact:

Each feature's impact can be visualized as a bar in a bar chart. The height (positive or negative) indicates the magnitude of influence, and the color (blue for positive, red for negative, and green for the most influential) signifies the nature of the impact.

# Transform the explanation to a dataframe and sort by saliency
    exp_df = lime_explanation['output-0'].sort_values(by="Saliency")

4. Extract feature names and their saliencies

 y_axis = list(exp_df['Saliency'])
    x_axis = ["Annual Income", "Number of Open Accounts", "Late Payments", "Debt-to-Income Ratio", "Credit Inquiries"]

    # Color-coding bars
    colors = ["green" if value == max(y_axis) else "blue" if value > 0 else "red" for value in y_axis]

    # Plotting
    fig, ax = plt.subplots()
    ax.set_facecolor("#f2f2f2")
    ax.bar(x_axis, y_axis, color=colors)
    plt.title('LIME: Feature Impact on Loan Approval Decision')
    plt.xticks(rotation=45, ha='right')
    plt.axhline(0, color="black")  # x-axis line
    plt.show()

And there you go!

Like the blog? Do hit a Like, send me some unicorns, and don't forget to share it with your friends!

Thank you!

Interpreting Loan Predictions with TrustyAI: Part 2

Sohini Pattanayak — Sat, 28 Oct 2023 10:22:04 +0000

A Developer’s Guide

In the previous blog, we gained a good overview of the use case of TrustyAI and developed an understanding of the goal of our tutorial today. If not, you can go through the previous blog again - Part 1: An Overview

Let’s get started now! 🚀

Once we have our environment ready with our demo.py file open, we’ll first import all the necessary libraries for this tutorial -

import numpy as np
from trustyai.model import Model
from trustyai.explainers import LimeExplainer

In the first three lines, we're importing the necessary libraries:

numpy: A library in Python used for numerical computations. Here, it will help us create and manipulate arrays for our linear model.
Model: This class from TrustyAI wraps our linear model, allowing it to be used with various explainers. TrustyAI library supports any type of model, it is enough to specify the predict function to invoke.
LimeExplainer: The main attraction! LIME (Local Interpretable Model-Agnostic Explanations) is a technique to explain predictions of machine learning models.

You can learn more about LIME from here - How does the LIME Method for Explainable AI work?

Now, we'll define a set of weights for our linear model using the numpy function np.random.uniform(). These weights are randomly chosen between -5 and 5 for our five features. These weights determine the importance of each feature in the creditworthiness decision.

weights = np.random.uniform(low=-5, high=5, size=5)
print(f"Weights for Features: {weights}")

We’ll build the Linear Model now, it’ll represent our predictive model. It will calculate the dot product between the input features x and the weights. This dot product gives a score, representing the creditworthiness of an applicant.

def linear_model(x):
    return np.dot(x, weights)

It’s time to wrap up our linear function, Using TrustyAI's Model class preparing it for explanation.

model = Model(linear_model)

Let us create a random sample of data for an applicant. The data is an array of five random numbers (each representing a feature like annual income, number of open accounts, etc.). We then feed this data to our model to get predicted_credit_score.

applicant_data = np.random.rand(1, 5)
predicted_credit_score = model(applicant_data)

Once this is done, the crucial part comes in. We initialize the LimeExplainer with specific parameters.

lime_explainer = LimeExplainer(samples=1000, normalise_weights=False)
lime_explanation = lime_explainer.explain(
    inputs=applicant_data,
    outputs=predicted_credit_score,
    model=model)

We then use this explainer to explain our model's prediction on the applicant's data. The lime_explanation object holds the results.

And then we display the explanation -

print(lime_explanation.as_dataframe())

Based on the predicted_credit_score, we provide a summary. If the score is positive, it indicates the applicant is likely to be approved, and vice versa.

And finally, we loop through our features and their respective weights, printing them out for clarity.

print("Feature weights:")
for feature, weight in zip(["Annual Income", "Number of Open Accounts", "Number of times Late Payment in the past", "Debt-to-Income Ratio", "Number of Credit Inquiries in the last 6 months"], weights):
  print(f"{feature}: {weight:.2f}")

And that is it! You can now find the complete code below!

import numpy as np
from trustyai.model import Model
from trustyai.explainers import LimeExplainer

# Define weights for the linear model.

weights = np.random.uniform(low=-5, high=5, size=5)
print(f"Weights for Features: {weights}")

# Simple linear model

def linear_model(x):
    return np.dot(x, weights)

model = Model(linear_model)

# Sample data for an applicant

applicant_data = np.random.rand(1, 5)
predicted_credit_score = model(applicant_data)

lime_explainer = LimeExplainer(samples=1000, normalise_weights=False)
lime_explanation = lime_explainer.explain(
    inputs=applicant_data,
    outputs=predicted_credit_score,
    model=model)

print(lime_explanation.as_dataframe())

# Interpretation

print("Summary of the explanation:")
if predicted_credit_score > 0:
  print("The applicant is likely to be approved for a loan.")
else:
  print("The applicant is unlikely to be approved for a loan.")

# Display weights

print("Feature weights:")
features = ["Annual Income", "Number of Open Accounts", "Number of times Late Payment in the past", "Debt-to-Income Ratio", "Number of Credit Inquiries in the last 6 months"]
for feature, weight in zip(features, weights):
  print(f"{feature}: {weight:.2f}")

Interpretation of the Output:

Running the code gives us the following output:

These weights are influential in shaping the model's decision. For instance, the "Annual Income" has a weight of -2.56, suggesting that an increase in the annual income might negatively impact the creditworthiness in this model – a rather unexpected observation, highlighting an area Jane might want to reassess.

Additionally, with the help of the LimeExplainer, we obtain the saliency of each feature. A higher absolute value of saliency indicates a stronger influence of that feature on the decision.

Conclusion:

Through TrustyAI, Jane not only developed a predictive model but also successfully interpreted its decisions, ensuring compliance with financial regulations. This tutorial underscores the importance of interpretability in machine learning models and showcases how developers can harness TrustyAI to bring transparency to their solutions.

Developers keen on adopting TrustyAI should consider its vast range of capabilities that go beyond LIME, offering a comprehensive suite of tools to make AI/ML models trustworthy. As data-driven decisions become ubiquitous, tools like TrustyAI will become indispensable, ensuring a balance between model accuracy and transparency.

Like the blog? Do hit a Like, send me some unicorns, and don't forget to share it with your friends!

Interpreting Loan Predictions with TrustyAI: Part 1

Sohini Pattanayak — Fri, 27 Oct 2023 09:32:22 +0000

An Overview

Introduction

AI/ML predictive models are essential for decision-making, but they need to be both accurate and interpretable, especially in regulated industries. TrustyAI provides the tools to understand and explain model decisions.

Imagine a bank using a machine learning model as part of the logic to approve loans. The model is accurate and has helped the bank make more profitable decisions. However, the bank needs to be able to explain why the model approved or denied a loan to a particular applicant. This is where TrustyAI can help!

TrustyAI can provide the bank with insights into the model's decision-making process, helping to ensure transparency and fairness.

Background

Jane, a data scientist at a bank, is building a model to predict applicant’s loan creditworthiness based on specific features. But there's a catch. Regulatory mandates stipulate that any loan decisions made by the bank must be interpretable. Hence, declining an application isn't enough!

There has to be an explanation behind this decision.

The Predictive Model:

The features Jane considers for her model are:

Annual Income
Number of Open Accounts
Number of times Late Payments in the past
Debt-to-Income ratio
Number of Credit Inquiries in the last 6 months

Jane's initial model is a straightforward linear one, with weights assigned to each feature based on their importance.

Before we get started on the actual code in the next part of this blog, make sure to follow the prerequisites before you plan on executing the code.

Prerequisites

Python: Ensure you have Python version 3.8 or higher. If not, download and install it from the official Python website.

Pip: Pip, the package installer for Python, should be installed by default with Python >=3.8, or we can also use an online platform like Binder or Google Collab

IDE: An Integrated Development Environment (IDE) makes it easier to write and run Python code. Some popular options include PyCharm or VsCode

A virtual environment is a self-contained directory that contains a Python installation for a particular version of Python, plus a number of additional packages, hence please create that.

With your virtual environment activated, it's time to install the trustyAI package: pip install trustyai

You're now ready to proceed with the tutorial.

For this tutorial, I have taken all references from the TrustyAI Python Documentation website - https://trustyai-explainability-python.readthedocs.io/en/latest/, you can follow this to build similar examples.

Follow the next blog to get started with the technical tutorial for this example!