Description of Issue:
predict_proba method implemented in scikit-learn Estimators and LGBM usually returns returns the predicted probability for each class for each sample. XClassifier deviates from this behaviour returning only probabilities estimates for class 1.

How to reproduce:

from xplainable.core.models import XClassifier
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000,n_features=4,random_state=42,n_classes=2)
X = pd.DataFrame(X,columns=['Feat_'+str(i) for i in range(4)])
y = pd.Series(y)
print(f'Shape of training data {X.shape}')
print(f'Shape of target {y.shape}')

x_model = XClassifier()
x_model.fit(X, y)
print(x_model.predict_proba(X).shape)

Screenshot

Problem Statement

While using the XClassifier and XRegressor classes, it's straightforward to retrieve the feature importances and profile after training using the model.feature_importances and model.profle attributes. However, the PartitionedClassifier class, which contains multiple model objects, currently lacks this functionality.

Proposed Solution

It would be beneficial if we could list the feature importances of all XClassifier and XRegressor objects contained within a PartitionedClassifier instance. Ideally, we would return the metadata for all partitions in a nested dict.

Easy to understand Linear Forecasting built into main package

Current state

Xplainable has a suite of data transformers aimed at simplifying data preprocessing. These stages are generally added to a Pipeline() object. One of the advantages of using xplainable for modelling is, generally, our models require less complex transformations (no need for class balancing or log transforming), which makes it easier to infer what transformations should be applied given the structure of a feature.

What we want to see

An automated "blueprint" that generates what a transformation pipeline should look like for a given dataset. Essentially, an automated-preprocessing tool. You can then pass the blueprint to a pipeline and it will build it.

Vision

This is a rough vision of what it could look like, but be flexible!

from xplainable.preprocessing.auto import AutoBlueprint
from xplainable.preprocessing.pipeline import Pipeline
import pandas as pd

df = pd.read_csv("path/to/data.csv")

X, y = df.drop(columns=['target']), df['target']

blueprint = AutoBlueprint()
stages = blueprint.fit(X, y)

pipeline = Pipeline(stages=stages)
pipeline.fit(X, y)

df_transformed = pipeline.transform(df)

Summary

We aim to expand the availability of our open-source Python package, currently installable via pip, by making it accessible through Conda. This will enhance the ease of installation and broaden the user base.

Objectives

• Create a Conda package for Xplainable.
• Submit the package to a widely-used Conda channel (e.g., Anaconda, conda-forge).

Tasks

1. Research the requirements and guidelines for creating a Conda package.
2. Adapt the package structure if necessary to meet Conda packaging standards.
3. Create a recipe for building the Conda package.
4. Thoroughly test the Conda package to ensure it installs and works correctly.
5. Submit the package to a Conda channel for review and inclusion.

Considerations

• Ensure compatibility with major platforms (Windows, macOS, Linux).
• Provide clear installation instructions for users.

Potential Challenges

• Handling dependencies that may not be available on Conda.
• Maintaining the package for future updates.

Contributions and suggestions are welcome.

Dependency

#83

What we want to achieve

We would like to integrate xplainable into the MLflow workflow. This involves the following workflows:

• If the model is an xplainable model, the model is logged to MLflow and Xplainable Cloud (with the same experiment_id)
• If the model is NOT an xplainable model, a surrogate model is created and logged to MLflow and Xplainable Cloud

Key considerations

This should be as uninvasive as possible. We don't want people to have to change their workflow drastically, rather just import xplainable and automate the explainer creation and logging.

Flexibility in approach

Please run with your own creative freedom here. We would love to discuss different approaches, as long as the disruption to user workflow is minimal.

Vision 1

This idea involves implementing a manual logging step. Behind the scenes it will train an xplainable surrogate model and log to both MLflow and Xplainable Cloud.

import xplainable as xp
import mlflow

# <- Build any model here

with mlflow.start_run():
    signature = infer_signature(X_train, model.predict(X_train))

    # <- other logging here

    mlflow.log_model(
        model=model,
        signature=signature,
        input_example=X_train,
        registered_model_name="model-with-xplainable"
    )

    # This should log to mlflow and to xplainable cloud (if an api key is active)
    xp.mlflow.log_explanation(model.predict, X)

Vision 2

This is similar to vision 1, but without the need to manually log explainers. It's not clear how this would be achieved, but it is an idea worth fleshing out.

import xplainable as xp
import mlflow

# <- Build any model here

xp.mlflow.auto_logging = True

with mlflow.start_run():
    signature = infer_signature(X_train, model.predict(X_train))

    # <- other logging here

    mlflow.log_model(
        model=model,
        signature=signature,
        input_example=X_train,
        registered_model_name="model-with-xplainable"
    ) # < -- This should auto-log to mlflow and to xplainable cloud (if an api key is active)

Description of Enhancement :
BaseModel during self._fetch_meta() selects categorical based on if the column dtype is 'object'. This is typically acceptable and would cover 95% of use cases but the inbuilt pandas dtype categorical would be missed by this . I propose we add categorical_feature parameter to our fit methods like in LGBM's fit method : categorical_feature (list of str or int, or 'auto', optional (default='auto'))(https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMClassifier.html#lightgbm.LGBMClassifier.fit)

How to reproduce:

from xplainable.core.models import XClassifier
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000,n_features=4,random_state=42,n_classes=2)
X = pd.DataFrame(X,columns=['Feat_'+str(i) for i in range(4)])
y = pd.Series(y)
X['Feat_0'] = X['Feat_0'].astype('category')
print(list(X.select_dtypes('object')))

Screenshot

Proposed Feature

Currently, xplainable has a suite of standalone solid models designed to be inherently explainable. We would also like to implement a new feature that allows xplainable to be used as a surrogate model to explain other complex models.

Vision

from xplainable.surrogates import XClfSurrogate

# Other code here ...

# Some complex model
model = XGBClassifier()
model.fit(X_train, y_train)

surrogate = XClfSurrogate()
explainer = surrogate.fit(model, X_train, y_train)

explainer.explain()

Description of Issue :
XClassifier fails and raises Division By Zero error when training data column contains 100% null values

How to reproduce:

from xplainable.core.models import XClassifier
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000,n_features=4,random_state=42,n_classes=2)
X = pd.DataFrame(X,columns=['Feat_'+str(i) for i in range(4)])
y = pd.Series(y)
print(f'Shape of training data {X.shape}')
print(f'Shape of target {y.shape}')
print(X.isna().sum())
print(X.nunique(dropna=False))

# Case 1 : 100% null values in feature 0

X_case_1 = X.copy(deep=True)
X_case_1['Feat_0'] = np.nan

print(X_case_1.isna().sum())
print(X_case_1.nunique(dropna=False))

x_model = XClassifier()
x_model.fit(X_case_1, y)

Screenshot

Current Implementation

We are currently using ipywidgets to render an in-notebook GUI for data preprocessing.

The issue

ipywidgets brings with it a multitude of bugs:

• The GUI doesn't render in environments like Google Collab and Databricks
• Some ipython dependencies, including tornado, cause kernel crashes when rendering results

Desired Solution

A custom GUI implementation that does not use ipywidgets and will safely render in any notebook environment.

Key considerations

• The current implementation works in a Jupyter Notebook with the required dependencies installed with pip install xplainable[gui]. You should use this environment to understand the desired functionality.

Background

Currently, xplainable is limited to Binary Classification (XClassifier) and Regression (XRegressor) models. We have run testing internally that validates the efficacy of using XClassifier with OVM and OVO to achieve robust performance.

Desired Feature

We want to integrate XMultiClassifier into our suite of models.

Key considerations

• The class must be usable in the same way as XClassifier
• How can we effectively visualise the explainers?
• The metadata must be compatible with XClassifier and the xplainable client

Contact us at [email protected] for more information on this feature.

Multiclass Client

Following the implementation of XMultiClassifier, the ability to persist to the cloud must be implemented.

The output of the .explain() method on partitioned models should include another dropdown that allows you to select which partition to interrogate. Currently, this can be achieved only with the 'partition' parameter

The Issue

Due to our haste to release xplainable, we haven't completed unit testing across the entire package (I know, I know...).

Desired Input

Someone to help us implement proper unit testing across the entire xplainable library

Current implementation

Currently, we are using ipywidgets to render widgets for users to easily load models and preprocessors.

The problem

The widgets don't load in Google Collab, Databricks, and some other notebook environments.

What needs to be done

We would like to implement a custom solution that doesn't use ipywidgets so we can safely render a model selector and a preprocessor selector in any notebook environment

Key considerations

• The properly test this solution, you will need access the the xplainable client. While you can achieve this with a free xplainable account, we will offer the person who wants to solve this problem with a free premium account. Please contact us at [email protected] and mention this issue.

Current Implementation

We are currently using ipywidgets to render an in-notebook GUI for model training.

The issue

ipywidgets brings with it a multitude of bugs:

• The GUI doesn't render in environments like Google Collab and Databricks
• Some ipython dependencies, including tornado, cause kernel crashes when rendering results

Desired Solution

A custom GUI implementation that does not use ipywidgets and will safely render in any notebook environment.

Key considerations

• The current implementation works in a Jupyter Notebook with the required dependencies installed with pip install xplainable[gui]. You should use this environment to understand the desired functionality.

Details

The original API key management implementation relied on the machine keychain (using keyring) to store API keys. This was applied for better useability for users in notebook environments. However, this is not well supported by platforms like Google Collab and Databricks, nor is it smooth for Linux virtual machines.

What we want to change

Update API management to use simple instantiation for uses to pass environment variables instead of being prompted to insert an API key. The goal is to improve usability and reduce friction.

The Issue

The plotting of local explainers for both XClassifier and XRegressor is relatively primitive and buggy.

Desired Result

A better designed and interactive local explainer plot that will render in all common notebook environments

Functions to alter

• _plot_local_explainer() found in xplainable.visualisation.explain
• local_explainer() in the BaseModel class

Key considerations

• When there are many features, we would like to default to showing the Top 10 contributing features with the rest bundled into "other". The user should be able to specify the top N features.