이산 데이터 구조에 대한 가우시안 프로세스

소개

가우스 프로세스는 회귀 및 분류 작업에서 머신 러닝에서 인기 있는 도구입니다. 그러나 일반적으로 고정 길이의 특징 벡터 형태의 데이터를 필요로 하며, 특정 응용 분야에서는 제한적일 수 있습니다. 이 실습에서는 유전자 서열과 같은 가변 길이 시퀀스에 가우스 프로세스를 사용하는 방법을 탐색합니다. 이를 위해 이러한 구조에 직접 작용하는 커널 함수를 정의합니다. scikit-learn 을 사용하여 가우스 프로세스 모델을 구현합니다.

VM 팁

VM 시작이 완료되면 왼쪽 상단 모서리를 클릭하여 Notebook 탭으로 전환하여 연습을 위한 Jupyter Notebook에 접근합니다.

때때로 Jupyter Notebook 이 완전히 로드되기까지 몇 초 정도 기다려야 할 수 있습니다. Jupyter Notebook 의 제한으로 인해 작업의 유효성 검사를 자동화할 수 없습니다.

학습 중 문제가 발생하면 Labby 에 문의하십시오. 세션 후 피드백을 제공하면 문제를 신속하게 해결해 드리겠습니다.

SequenceKernel 정의

SequenceKernel 클래스는 scikit-learn 의 Kernel 및 GenericKernelMixin 클래스를 상속합니다. 이 커널은 가변 길이의 시퀀스 간의 유사성 측도를 정의합니다. 문자열 쌍 사이의 모든 문자 쌍에 대해 이진 문자별 커널을 통합하는 R-convolution 을 사용하여 이를 수행합니다. 그런 다음 이 커널을 사용하여 시퀀스에 대한 회귀 및 분류 작업을 수행할 수 있습니다.

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


class SequenceKernel(GenericKernelMixin, Kernel):
    """
    가변 길이 시퀀스에 대한 최소한의 (하지만 유효한) 합성곱 커널입니다.
    """

    def __init__(self, baseline_similarity=0.5, baseline_similarity_bounds=(1e-5, 1)):
        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):
        """
        시퀀스 쌍 간의 커널 값
        """
        return sum(
            [1.0 if c1 == c2 else self.baseline_similarity for c1 in s1 for c2 in s2]
        )

    def _g(self, s1, s2):
        """
        시퀀스 쌍 간의 커널 미분
        """
        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

시퀀스 유사성 행렬 시각화

SequenceKernel을 사용하여 시퀀스 간의 유사성 행렬을 계산할 수 있습니다. 더 밝은 색상이 더 높은 유사성을 나타내는 컬러맵을 사용하여 이 행렬을 플롯합니다.

import matplotlib.pyplot as plt

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

kernel = SequenceKernel()
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("커널 하의 시퀀스 유사성")
plt.show()

시퀀스에 대한 회귀 수행

SequenceKernel을 사용하여 시퀀스에 대한 회귀를 수행할 수 있습니다. 6 개의 시퀀스 데이터 세트를 사용하고 1, 2, 4, 5 번째 시퀀스를 학습 세트로 사용하여 3 번째와 6 번째 시퀀스에 대한 예측을 수행합니다.

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="예측")
plt.bar(training_idx, Y[training_idx], width=0.2, color="r", alpha=1, label="학습")
plt.xticks(np.arange(len(X)), X)
plt.title("시퀀스에 대한 회귀")
plt.legend()
plt.show()

시퀀스 분류 수행

SequenceKernel을 사용하여 시퀀스에 대한 분류를 수행할 수 있습니다. 6 개의 시퀀스 데이터 세트를 사용하고 시퀀스에 'A'가 있는지 여부를 기반으로 학습합니다. 그런 다음 다른 5 개의 시퀀스에 대한 예측을 수행하며, 실제 값은 시퀀스에 적어도 하나의 'A'가 있는지 여부입니다. 여기서 네 개의 분류가 정확하고 하나의 분류가 실패합니다.

X_train = np.array(["AGCT", "CGA", "TAAC", "TCG", "CTTT", "TGCT"])
## 시퀀스에 'A'가 있는지 여부
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="학습",
)
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="실제값",
)
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="예측",
)
plt.xticks(np.arange(len(X_train) + len(X_test)), np.concatenate((X_train, X_test)))
plt.yticks([-1, 1], [False, True])
plt.title("시퀀스 분류")
plt.legend()
plt.show()

요약

이 실험에서는 사용자 지정 커널 함수를 사용하여 가우시안 프로세스를 가변 길이 시퀀스에 적용하는 방법을 보여주었습니다. Scikit-learn 을 사용하여 시퀀스 데이터에 대한 회귀 및 분류 작업을 수행하는 방법을 보여주었습니다.