Implementing the Concept Drift Detection Application of Image Data

Overview

Concept drift of image data is an important data phenomenon in the AI learning field. It is also called out-of-distribution (OOD), which indicates that the image data (real-time distribution) in online inference is inconsistent with the training data (historical distribution). For example, if the neural network model is obtained through training based on the MNIST dataset, but the actual test data is in the CIFAR-10 data environment, the CIFAR-10 dataset is an OOD sample.

This example provides a method for detecting a distribution change of image data. An overall process is as follows:

Load public datasets or use user-defined data.
Load a neural network model.
Initialize the image concept drift parameters.
Obtain an optimal concept drift detection threshold.
Execute the concept drift detection function.
View the execution result.

This example is for CPUs, GPUs, and Ascend 910 AI processors. Currently only supports GRAPH_MODE. You can download the complete sample code at https://gitee.com/mindspore/mindarmour/blob/r2.0/examples/reliability/concept_drift_check_images_lenet.py.

Preparations

Ensure that the MindSpore is correctly installed. If not, install MindSpore by following the Installation Guide.

Preparing a Dataset

The public image datasets MNIST and CIFAR-10 are used in the example.

Dataset download pages: http://yann.lecun.com/exdb/mnist/ and http://www.cs.toronto.edu/~kriz/cifar.html.

Importing the Python Library and Modules

Before start, you need to import the Python library.

import numpy as np
import mindspore as ms
from mindarmour.utils import LogUtil
from mindspore import nn
from mindspore.train import Model
from examples.common.networks.lenet5.lenet5_net_for_fuzzing import LeNet5
from mindarmour.reliability import OodDetectorFeatureCluster

ms.set_context(mode=ms.GRAPH_MODE)

Loading Data

Use the MNIST dataset as the training set ds_train. The ds_train contains only image data and does not contain labels.
Mix MNIST and CIFAR-10 into a dataset as test set ds_test, which contains only image data and does not contain labels.
Use another mixed dataset of MNIST and CIFAR-10 as a validation sample and record it as ds_eval. ds_eval contains only image data and does not contain labels. ds_eval is marked separately. Non-OOD samples are marked as 0, OOD samples are marked as 1, and ds_eval is marked as ood_label.

ds_train = np.load('/dataset/concept_train_lenet.npy')
ds_test = np.load('/dataset/concept_test_lenet2.npy')
ds_eval = np.load('/dataset/concept_test_lenet1.npy')

ds_train(numpy.ndarray): training set, which contains only image data.

ds_test(numpy.ndarray): test set, which contains only image data.

ds_eval(numpy.ndarray): validation set, which contains only image data.

Loading a Neural Network Model

Use the training set ds_train and its classification label to train the neural network LeNet and load the model. Here, we directly import the trained model file.

The label here is different from the ood_label mentioned above. The label indicates the classification label of the sample, and ood_label indicates whether the sample belongs to the OOD label.

ckpt_path = '../../dataset/trained_ckpt_file/checkpoint_lenet-10_1875.ckpt'
net = LeNet5()
load_dict = ms.load_checkpoint(ckpt_path)
ms.load_param_into_net(net, load_dict)
model = Model(net)

ckpt_path(str): model file path.

It should be noted that, to extract feature output of a specific layer by using a neural network, functions of the feature extraction and the naming neural layer need to be added to a neural network construction process. The layer is used to name the neural network layer. You can use the following method to reconstruct the neural network model, name the neural network at each layer, and obtain the feature output value.

Import the TensorSummary module.
Add self.summary = TensorSummary() to the initialization function __init__.
Add self.summary(name, x) after the constructor function of each layer of the neural network.

In this test case, the KMeans function in sklearn is used for feature clustering analysis. Therefore, the input data dimension of KMeans must be two-dimensional. LeNet is used as an example. The features of the fully-connected layer and ReLU layer from the bottom five layers are extracted. The data dimensions meet the KMeans requirements.

The LeNet neural network construction process is as follows:

from mindspore import nn
from mindspore.common.initializer import TruncatedNormal
from mindspore.ops import TensorSummary

def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
    """Wrap conv."""
    weight = weight_variable()
    return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding,
                     weight_init=weight, has_bias=False, pad_mode="valid")

def fc_with_initialize(input_channels, out_channels):
    """Wrap initialize method of full connection layer."""
    weight = weight_variable()
    bias = weight_variable()
    return nn.Dense(input_channels, out_channels, weight, bias)

def weight_variable():
    """Wrap initialize variable."""
    return TruncatedNormal(0.05)

class LeNet5(nn.Cell):
    """
    Lenet network
    """
    def __init__(self):
        super(LeNet5, self).__init__()
        self.conv1 = conv(1, 6, 5)
        self.conv2 = conv(6, 16, 5)
        self.fc1 = fc_with_initialize(16*5*5, 120)
        self.fc2 = fc_with_initialize(120, 84)
        self.fc3 = fc_with_initialize(84, 10)
        self.relu = nn.ReLU()
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
        self.flatten = nn.Flatten()
        self.summary = TensorSummary()

    def construct(self, x):
        """
        construct the network architecture
        Returns:
            x (tensor): network output
        """
        x = self.conv1(x)

        x = self.relu(x)

        x = self.max_pool2d(x)

        x = self.conv2(x)

        x = self.relu(x)

        x = self.max_pool2d(x)

        x = self.flatten(x)

        x = self.fc1(x)
        self.summary('8', x)

        x = self.relu(x)
        self.summary('9', x)

        x = self.fc2(x)
        self.summary('10', x)

        x = self.relu(x)
        self.summary('11', x)

        x = self.fc3(x)
        self.summary('output', x)
        return x

Initializing the Image Concept Drift Detection Module

Import the concept drift detection module and initialize it.

detector = OodDetectorFeatureCluster(model, ds_train, n_cluster=10, layer='output[:Tensor]')

model(Model): neural network model, which is obtained by training the training set ds_train and its classification labels.

ds_train(numpy.ndarray): training set, which contains only image data.

n_cluster(int): number of feature clusters.

layer(str): name of the layer used by the neural network to extract features.

Note that during OodDetectorFeatureCluster initialization, the [:Tensor] suffix needs to be added after the layer parameter. For example, if a neural network layer is named name, then layer='name[:Tensor]'. In the layer='output[:Tensor] instance, the feature output of the last layer of LeNet is used, that is, layer='output[:Tensor]. In addition, the algorithm uses the KMeans function in sklearn to perform feature clustering analysis. The input data dimension of KMeans must be two-dimensional. Therefore, the features extracted by layer must be two-dimensional data, such as the fully-connected layer and ReLU layer in the LeNet example above.

Obtaining an Optimal Concept Drift Detection Threshold

The optimal concept drift detection threshold is obtained based on the validation set ds_eval and its OOD label ood_label.

The validation set ds_eval can be constructed manually. For example, it consists of 50% of the MNIST dataset and 50% of the CIFAR-10 dataset. Therefore, the OOD label ood_label indicates that the label values of the first 50% are 0 and those of the last 50% are 1.

num = int(len(ds_eval) / 2)
ood_label = np.concatenate((np.zeros(num), np.ones(num)), axis=0)  # ID data = 0, OOD data = 1
optimal_threshold = detector.get_optimal_threshold(ood_label, ds_eval)

ds_eval(numpy.ndarray): validation set, which contains only image data. ood_label(numpy.ndarray): OOD label of validation set ds_eval. Non-OOD samples are marked as 0, and OOD samples are marked as 1.

Certainly, if it is difficult for a user to obtain ds_eval and the OOD label ood_label, a value of optimal_threshold may be manually and flexibly set, and the value of optimal_threshold is a floating point number between [0, 1].

Executing the Concept Drift Detection

result = detector.ood_predict(optimal_threshold, ds_test)

ds_test(numpy.ndarray): test set, which contains only image data. optimal_threshold(float): optimal threshold. You can obtain the values by running the detector.get_optimal_threshold(ood_label, ds_eval) command. However, if it is difficult for a user to obtain ds_eval and the OOD label ood_label, a value of optimal_threshold may be manually and flexibly set, and the value of optimal_threshold is a floating point number between [0, 1].

Viewing the Result

print(result)

result(numpy.ndarray): one-dimensional array consisting of elements 0 and 1, corresponding to the OOD detection result of ds_test. For example, if ds_test is a dataset consisting of five MNIST datasets and five CIFAR-10 datasets, the detection result is [0,0,0,0,0,1,1,1,1,1].