Single-Table Tutorial with the Scikit-learn API

On this tutorial we'll a classifier on a single table dataset.

import pandas as pd
from sklearn import metrics
from sklearn.model_selection import train_test_split
from khiops import core as kh
from khiops.sklearn import KhiopsClassifier

The Iris Dataset

We'll train a classifier for the Iris dataset. This is a classical dataset containing data of different plants belonging to the genus Iris. It contains 150 records, 50 for each of the three Iris's variants: Setosa, Virginica and Versicolor. Each record contains the length and the width of both the petal and the sepal of the plant. The standard task, when using this dataset, is to construct a classifier for the type of the Iris, based on the petal and sepal characteristics.

To train a classifier with Khiops, we only need a dataframe containing the Iris data:

# Method 1: Load data directly from GitHub (recommended for quick tests or small datasets)
url = "https://raw.githubusercontent.com/KhiopsML/khiops-samples/11.0.0/Iris/Iris.txt"
iris_df = pd.read_csv(url, delimiter='\t')

# Method 2: Load data locally after downloading all Khiops samples (best for offline use)
# from khiops.tools import download_datasets
# download_datasets() 
# iris_path = f"{kh.get_samples_dir()}/Iris/Iris.txt"
# iris_df = pd.read_csv(iris_path, sep="\t")

# Display the first 10 records from the dataset
iris_df[:10]

Training the Classifier

Before training the classifier, we split the data into the feature matrix (sepal length, width, etc) and the target vector containing the labels (the Class column).

# Drop the "class" column to create the feature set (X).
X = iris_df.drop("Class", axis=1)

# Extract the "class" column to create the target labels (y).
y = iris_df["Class"]

Then we can construct our final train/test dataset

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=123)

Let's check the contents of the feature matrix and the target vector:

print("Features:")
display(X_train)
print("Labels:")
display(y_train.unique())

We are ready to train the KhiopsClassifier: We use the fit method on the training data. After its execution, the KhiopsClassifier instance is ready to classify new Iris plants:

khc = KhiopsClassifier()
khc.fit(X_train, y_train)

KhiopsClassifier()

KhiopsClassifier()

Displaying the Classifiers’ Training Accuracy and AUC

The fit method calculates evaluation metrics on the training dataset. We access them via the estimator's attribute model_report_ which is an instance of the AnalysisResults class. Let's check this out:

train_performance = khc.model_report_.train_evaluation_report.get_snb_performance()

This object train_performance is of class PredictorPerformance and has accuracy and auc attributes:

print(f"Iris train accuracy: {train_performance.accuracy}")
print(f"Iris train AUC     : {train_performance.auc}")

Iris train accuracy: 0.964286
    Iris train AUC     : 0.99755

The PredictorPerformance object has also a confusion matrix attribute:

confusion_matrix = pd.DataFrame(
    train_performance.confusion_matrix.matrix,
    columns=train_performance.confusion_matrix.values,
    index=train_performance.confusion_matrix.values,
)
print("Iris train confusion matrix:")
confusion_matrix

If you have installed the Khiops Visualization app you may explore the full learning report by executing the code below.

# Uncomment the lines below
# khc.export_report_file("./iris_report.khj")
# kh.visualize_report("./iris_report.khj")

Deploying the Classifier and Displaying Its Test Performance

Now that we have a fitted KhiopsClassifier, we are now going to deploy it on the test split.

This can be done in two different ways:

• to predict a class that can be obtained using its predict.
• to predict class probabilities that can be obtained using its predict_proba.

Let's first predict the Iris labels:

y_pred_test = khc.predict(X_test)
y_probas_test = khc.predict_proba(X_test)
print("Classes:")
display(khc.classes_)
print()
print("Predictions (first 10 values):")
display(y_pred_test[:10])
print()
print("Probabilities (first 10 rows):")
display(y_probas_test[:10,])

Classes:



    array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype='<U15')



    Predictions (first 10 values):



    array(['Iris-versicolor', 'Iris-virginica', 'Iris-virginica',
           'Iris-versicolor', 'Iris-setosa', 'Iris-virginica',
           'Iris-versicolor', 'Iris-setosa', 'Iris-setosa', 'Iris-versicolor'],
          dtype=object)



    Probabilities (first 10 rows):



    array([[0.00152548, 0.80072032, 0.19775421],
           [0.00150198, 0.02233054, 0.97616748],
           [0.00150198, 0.02233054, 0.97616748],
           [0.00170069, 0.96904427, 0.02925505],
           [0.99593086, 0.00241699, 0.00165216],
           [0.00252304, 0.41073845, 0.5867385 ],
           [0.00170069, 0.96904427, 0.02925505],
           [0.99593086, 0.00241699, 0.00165216],
           [0.99593086, 0.00241699, 0.00165216],
           [0.00170069, 0.96904427, 0.02925505]])

From these predictions we compute the test accuracy and AUC (One-vs-Rest) scores using sklearn.metrics

accuracy_test = metrics.accuracy_score(y_test, y_pred_test)
auc_test = metrics.roc_auc_score(y_test, y_probas_test, multi_class="ovr")
print(f"Iris test accuracy: {accuracy_test}")
print(f"Iris test AUC     : {auc_test}")

Iris test accuracy: 0.9473684210526315
    Iris test AUC     : 1.0