Procesos Gaussianos en Estructuras de Datos Discretos

Introducción

Los procesos gaussianos son una herramienta popular en el aprendizaje automático para tareas de regresión y clasificación. Sin embargo, generalmente requieren que los datos estén en forma de vector de características de longitud fija, lo que puede ser limitante en ciertas aplicaciones. En este laboratorio, exploraremos cómo se pueden utilizar los procesos gaussianos en secuencias de longitud variable, como secuencias genéticas, definiendo una función de kernel que opere directamente en estas estructuras. Utilizaremos scikit-learn para implementar nuestros modelos de procesos gaussianos.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje comentarios después de la sesión y resolveremos rápidamente el problema para usted.

Skills Graph

Define SequenceKernel

Definimos una clase SequenceKernel que hereda de las clases Kernel y GenericKernelMixin de scikit-learn. Este kernel define una medida de similitud entre secuencias de longitud variable. Lo hace utilizando la R-convolución, que implica integrar un kernel binario por letra sobre todos los pares de letras entre un par de cadenas. Luego podemos utilizar este kernel para realizar tareas de regresión y clasificación en secuencias.

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):
    """
    Un kernel convolucional mínimo (pero válido) para secuencias de
    longitudes variables."""

    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", "numérico", self.baseline_similarity_bounds
        )

    def _f(self, s1, s2):
        """
        Valor del kernel entre un par de secuencias
        """
        return sum(
            [1.0 if c1 == c2 else self.baseline_similarity for c1 in s1 for c2 in s2]
        )

    def _g(self, s1, s2):
        """
        Derivada del kernel entre un par de secuencias
        """
        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

Visualize Sequence Similarity Matrix

Podemos utilizar nuestro SequenceKernel para calcular la matriz de similitud entre secuencias. Representaremos esta matriz utilizando una mapa de colores, donde los colores más brillantes indican una mayor similitud.

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("Sequence similarity under the kernel")
plt.show()

Realizar regresión en secuencias

Podemos utilizar nuestro SequenceKernel para realizar regresión en secuencias. Utilizaremos un conjunto de datos de 6 secuencias y usaremos las 1ª, 2ª, 4ª y 5ª secuencias como conjunto de entrenamiento para hacer predicciones sobre las 3ª y 6ª secuencias.

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="predicción")
plt.bar(training_idx, Y[training_idx], width=0.2, color="r", alpha=1, label="entrenamiento")
plt.xticks(np.arange(len(X)), X)
plt.title("Regresión en secuencias")
plt.legend()
plt.show()

Realizar clasificación en secuencias

Podemos utilizar nuestro SequenceKernel para realizar clasificación en secuencias. Utilizaremos un conjunto de datos de 6 secuencias y entrenaremos sobre la presencia o ausencia de 'A's en la secuencia. Luego haremos predicciones sobre otras 5 secuencias, donde la verdadera situación es simplemente si hay al menos un 'A' en la secuencia. Aquí, hacemos cuatro clasificaciones correctas y fallamos en una.

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="entrenamiento",
)
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="verdad",
)
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="predicción",
)
plt.xticks(np.arange(len(X_train) + len(X_test)), np.concatenate((X_train, X_test)))
plt.yticks([-1, 1], [False, True])
plt.title("Clasificación en secuencias")
plt.legend()
plt.show()

Resumen

En este laboratorio, demostramos cómo utilizar procesos gaussianos en secuencias de longitud variable utilizando una función de kernel personalizada. Mostramos cómo realizar tareas de regresión y clasificación en datos de secuencias utilizando scikit-learn.