Гауссовские процессы для дискретных структур данных

В этом примере демонстрируется применение гауссовских процессов для решения задач регрессии и классификации на данных, представленных не в виде векторов признаков фиксированной длины. Это достигается с помощью ядерных функций, которые работают непосредственно с дискретными структурами, такими как последовательности переменной длины, деревья и графы.

В частности, входные переменные здесь — это последовательности генов, хранящиеся в виде строк переменной длины, состоящих из букв «A», «T», «C» и «G», а выходные переменные — числа с плавающей точкой и метки True/False для задач регрессии и классификации соответственно.

Ядро между последовательностями генов определяется с помощью R-свёртки [1] путём интегрирования бинарного посимвольного ядра по всем парам букв в паре строк.

В этом примере будут созданы три рисунка.

На первом рисунке мы визуализируем значение ядра, то есть сходство последовательностей, с помощью цветовой карты. Более яркий цвет указывает на большее сходство.

На втором рисунке показан результат регрессии на наборе данных из 6 последовательностей. В качестве обучающей выборки используются 1-я, 2-я, 4-я и 5-я последовательности, а предсказания строятся для 3-й и 6-й последовательностей.

На третьем рисунке показана модель классификации, обученная на 6 последовательностях и применённая для предсказаний на ещё 5 последовательностях. Истинная метка здесь указывает лишь на то, содержит ли последовательность хотя бы одну букву «A». Модель верно классифицирует четыре последовательности и ошибается в одном случае.

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import numpy as np

from sklearn.base import clone
from sklearn.gaussian_process import GaussianProcessClassifier, GaussianProcessRegressor
from sklearn.gaussian_process.kernels import GenericKernelMixin, Hyperparameter, Kernel


class SequenceKernel(GenericKernelMixin, Kernel):
    """
    A minimal (but valid) convolutional kernel for sequences of variable
    lengths."""

    def __init__(self, baseline_similarity=0.5, baseline_similarity_bounds="fixed"):
        self.baseline_similarity = baseline_similarity
        self.baseline_similarity_bounds = baseline_similarity_bounds

    @property
    def hyperparameter_baseline_similarity(self):
        return Hyperparameter(
            "baseline_similarity", "numeric", self.baseline_similarity_bounds
        )

    def _f(self, s1, s2):
        """
        kernel value between a pair of sequences
        """
        return sum(
            [1.0 if c1 == c2 else self.baseline_similarity for c1 in s1 for c2 in s2]
        )

    def _g(self, s1, s2):
        """
        kernel derivative between a pair of sequences
        """
        return sum([0.0 if c1 == c2 else 1.0 for c1 in s1 for c2 in s2])

    def __call__(self, X, Y=None, eval_gradient=False):
        if Y is None:
            Y = X

        if eval_gradient:
            return (
                np.array([[self._f(x, y) for y in Y] for x in X]),
                np.array([[[self._g(x, y)] for y in Y] for x in X]),
            )
        else:
            return np.array([[self._f(x, y) for y in Y] for x in X])

    def diag(self, X):
        return np.array([self._f(x, x) for x in X])

    def is_stationary(self):
        return False

    def clone_with_theta(self, theta):
        cloned = clone(self)
        cloned.theta = theta
        return cloned

kernel = SequenceKernel()

Матрица сходства последовательностей для данного ядра

import matplotlib.pyplot as plt

X = np.array(["AGCT", "AGC", "AACT", "TAA", "AAA", "GAACA"])

K = kernel(X)
D = kernel.diag(X)

plt.figure(figsize=(8, 5))
plt.imshow(np.diag(D**-0.5).dot(K).dot(np.diag(D**-0.5)))
plt.xticks(np.arange(len(X)), X)
plt.yticks(np.arange(len(X)), X)
plt.title("Sequence similarity under the kernel")
plt.show()

Регрессия

X = np.array(["AGCT", "AGC", "AACT", "TAA", "AAA", "GAACA"])
Y = np.array([1.0, 1.0, 2.0, 2.0, 3.0, 3.0])

training_idx = [0, 1, 3, 4]
gp = GaussianProcessRegressor(kernel=kernel)
gp.fit(X[training_idx], Y[training_idx])

plt.figure(figsize=(8, 5))
plt.bar(np.arange(len(X)), gp.predict(X), color="b", label="prediction")
plt.bar(training_idx, Y[training_idx], width=0.2, color="r", alpha=1, label="training")
plt.xticks(np.arange(len(X)), X)
plt.title("Regression on sequences")
plt.legend()
plt.show()

Классификация

X_train = np.array(["AGCT", "CGA", "TAAC", "TCG", "CTTT", "TGCT"])
# whether there are 'A's in the sequence
Y_train = np.array([True, True, True, False, False, False])

gp = GaussianProcessClassifier(kernel)
gp.fit(X_train, Y_train)

X_test = ["AAA", "ATAG", "CTC", "CT", "C"]
Y_test = [True, True, False, False, False]

plt.figure(figsize=(8, 5))
plt.scatter(
    np.arange(len(X_train)),
    [1.0 if c else -1.0 for c in Y_train],
    s=100,
    marker="o",
    edgecolor="none",
    facecolor=(1, 0.75, 0),
    label="training",
)
plt.scatter(
    len(X_train) + np.arange(len(X_test)),
    [1.0 if c else -1.0 for c in Y_test],
    s=100,
    marker="o",
    edgecolor="none",
    facecolor="r",
    label="truth",
)
plt.scatter(
    len(X_train) + np.arange(len(X_test)),
    [1.0 if c else -1.0 for c in gp.predict(X_test)],
    s=100,
    marker="x",
    facecolor="b",
    linewidth=2,
    label="prediction",
)
plt.xticks(np.arange(len(X_train) + len(X_test)), np.concatenate((X_train, X_test)))
plt.yticks([-1, 1], [False, True])
plt.title("Classification on sequences")
plt.legend()
plt.show()

Общее время выполнения скрипта: (0 минут 0.186 секунд)

Download Jupyter notebook: plot_gpr_on_structured_data.ipynb

Download Python source code: plot_gpr_on_structured_data.py

Download zipped: plot_gpr_on_structured_data.zip

Похожие примеры

Индуктивная кластеризация

Классификация гауссовским процессом (GPC) на наборе данных iris

Параметры RBF SVM

Регрессия гауссовских процессов: простой вводный пример