Utilizando Funções Python como Kernels no SVM

# Utilizando Funções Python como Kernels no SVM: Guia Prático 1.4.6.1.1

Dominando a Criação de Kernels com Funções Python

O tópico 1.4.6.1.1. Using Python functions as kernels representa a essência da flexibilidade nos Support Vector Machines do Scikit-Learn. Atualmente, esta abordagem permite que desenvolvedores implementem soluções altamente específicas para problemas complexos de machine learning.

O Conceito Fundamental: Funções como Kernels

Primeiramente, é crucial compreender que qualquer função Python que atenda aos critérios matemáticos pode ser utilizada como kernel. Analogamente a como funções são passadas como parâmetros em programação funcional, o Scikit-Learn aceita funções personalizadas diretamente no parâmetro kernel.

A Estrutura Básica da Função Kernel

Certamente, a função deve seguir uma assinatura específica. Então, observe a estrutura fundamental:

def minha_funcao_kernel(X, Y):
    """
    X: array-like de shape (n_samples_X, n_features)
    Y: array-like de shape (n_samples_Y, n_features)
    
    Retorna: array de shape (n_samples_X, n_samples_Y)
    """
    # Implementação do kernel
    return kernel_matrix

def minha_funcao_kernel(X, Y):

"""

X: array-like de shape (n_samples_X, n_features)

Y: array-like de shape (n_samples_Y, n_features)

Retorna: array de shape (n_samples_X, n_samples_Y)

"""

# Implementação do kernel

return kernel_matrix

Implementação Passo a Passo

Primordialmente, vamos criar um kernel personalizado completo. Conquanto pareça complexo inicialmente, o processo é sistemático:

import numpy as np
from sklearn import svm
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

def kernel_linear_combinado(X, Y, alpha=0.7, gamma=0.1):
    """
    Kernel personalizado que combina componentes lineares e RBF
    """
    # Componente linear
    linear_kernel = np.dot(X, Y.T)
    
    # Componente RBF
    if X.shape[1] == Y.shape[1]:
        rbf_kernel = np.exp(-gamma * np.sum((X[:, np.newaxis] - Y) ** 2, axis=2))
    else:
        # Para compatibilidade com diferentes formas
        rbf_kernel = np.zeros((X.shape[0], Y.shape[0]))
        for i in range(X.shape[0]):
            for j in range(Y.shape[0]):
                rbf_kernel[i, j] = np.exp(-gamma * np.linalg.norm(X[i] - Y[j]) ** 2)
    
    # Combinação ponderada
    combined_kernel = alpha * linear_kernel + (1 - alpha) * rbf_kernel
    return combined_kernel

# Gerando e preparando dados
X, y = make_classification(n_samples=200, n_features=4, n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Utilizando a função Python como kernel
classificador = svm.SVC(kernel=kernel_linear_combinado)
classificador.fit(X_train, y_train)

# Avaliando o modelo
predicoes = classificador.predict(X_test)
acuracia = accuracy_score(y_test, predicoes)
print(f"Acurácia com kernel personalizado: {acuracia:.4f}")

import numpy as np

from sklearn import svm

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

def kernel_linear_combinado(X, Y, alpha=0.7, gamma=0.1):

"""

Kernel personalizado que combina componentes lineares e RBF

"""

# Componente linear

linear_kernel = np.dot(X, Y.T)

# Componente RBF

if X.shape[1] == Y.shape[1]:

rbf_kernel = np.exp(-gamma * np.sum((X[:, np.newaxis] - Y) ** 2, axis=2))

else:

# Para compatibilidade com diferentes formas

rbf_kernel = np.zeros((X.shape[0], Y.shape[0]))

for i in range(X.shape[0]):

for j in range(Y.shape[0]):

rbf_kernel[i, j] = np.exp(-gamma * np.linalg.norm(X[i] - Y[j]) ** 2)

# Combinação ponderada

combined_kernel = alpha * linear_kernel + (1 - alpha) * rbf_kernel

return combined_kernel

# Gerando e preparando dados

X, y = make_classification(n_samples=200, n_features=4, n_classes=2, random_state=42)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Utilizando a função Python como kernel

classificador = svm.SVC(kernel=kernel_linear_combinado)

classificador.fit(X_train, y_train)

# Avaliando o modelo

predicoes = classificador.predict(X_test)

acuracia = accuracy_score(y_test, predicoes)

print(f"Acurácia com kernel personalizado: {acuracia:.4f}")

Validação Matemática do Kernel

Embora o Scikit-Learn não valide automaticamente, decerto é responsabilidade do desenvolvedor garantir que a função satisfaça as propriedades matemáticas. Portanto, considere esta função de verificação:

def verificar_kernel_positivo_definido(kernel_func, X_amostra):
    """
    Verificação básica de positive definiteness
    """
    K = kernel_func(X_amostra, X_amostra)
    
    # Verificar simetria
    simetrico = np.allclose(K, K.T)
    print(f"Kernel simétrico: {simetrico}")
    
    # Verificar autovalores não-negativos
    autovalores = np.linalg.eigvals(K)
    autovalores_positivos = np.all(autovalores >= -1e-10)  # Tolerância numérica
    print(f"Autovalores não-negativos: {autovalores_positivos}")
    
    return simetrico and autovalores_positivos

# Testando nosso kernel
amostra = X_train[:10]  # Pequena amostra para teste
valido = verificar_kernel_positivo_definido(kernel_linear_combinado, amostra)
print(f"Kernel válido: {valido}")

def verificar_kernel_positivo_definido(kernel_func, X_amostra):

"""

Verificação básica de positive definiteness

"""

K = kernel_func(X_amostra, X_amostra)

# Verificar simetria

simetrico = np.allclose(K, K.T)

print(f"Kernel simétrico: {simetrico}")

# Verificar autovalores não-negativos

autovalores = np.linalg.eigvals(K)

autovalores_positivos = np.all(autovalores >= -1e-10) # Tolerância numérica

print(f"Autovalores não-negativos: {autovalores_positivos}")

return simetrico and autovalores_positivos

# Testando nosso kernel

amostra = X_train[:10] # Pequena amostra para teste

valido = verificar_kernel_positivo_definido(kernel_linear_combinado, amostra)

print(f"Kernel válido: {valido}")

Casos de Uso Avançados

Atualmente, kernels personalizados são aplicados em domínios especializados. Aliás, vejamos exemplos práticos:

Kernel para Dados Textuais

Enquanto kernels padrão funcionam bem para dados numéricos, igualmente podemos criar soluções para texto:

from sklearn.feature_extraction.text import TfidfVectorizer

def kernel_similaridade_textual(X, Y):
    """
    Kernel baseado em similaridade de texto usando TF-IDF
    """
    # Converter para TF-IDF se necessário
    if isinstance(X[0], str):
        vectorizer = TfidfVectorizer(max_features=1000)
        X_vec = vectorizer.fit_transform(X).toarray()
        Y_vec = vectorizer.transform(Y).toarray()
    else:
        X_vec, Y_vec = X, Y
    
    # Calcular similaridade do cosseno
    similaridades = np.dot(X_vec, Y_vec.T)
    normas_X = np.linalg.norm(X_vec, axis=1)[:, np.newaxis]
    normas_Y = np.linalg.norm(Y_vec, axis=1)[np.newaxis, :]
    
    kernel_matrix = similaridades / (normas_X * normas_Y)
    return np.nan_to_num(kernel_matrix)  # Lidar com divisões por zero

# Exemplo com dados textuais
documentos = ["machine learning é fascinante", "python para data science", 
              "algoritmos de classificação", "svm com kernels personalizados"]
labels = [0, 1, 0, 1]

classificador_texto = svm.SVC(kernel=kernel_similaridade_textual)
classificador_texto.fit(documentos, labels)

from sklearn.feature_extraction.text import TfidfVectorizer

def kernel_similaridade_textual(X, Y):

"""

Kernel baseado em similaridade de texto usando TF-IDF

"""

# Converter para TF-IDF se necessário

if isinstance(X[0], str):

vectorizer = TfidfVectorizer(max_features=1000)

X_vec = vectorizer.fit_transform(X).toarray()

Y_vec = vectorizer.transform(Y).toarray()

else:

X_vec, Y_vec = X, Y

# Calcular similaridade do cosseno

similaridades = np.dot(X_vec, Y_vec.T)

normas_X = np.linalg.norm(X_vec, axis=1)[:, np.newaxis]

normas_Y = np.linalg.norm(Y_vec, axis=1)[np.newaxis, :]

kernel_matrix = similaridades / (normas_X * normas_Y)

return np.nan_to_num(kernel_matrix) # Lidar com divisões por zero

# Exemplo com dados textuais

documentos = ["machine learning é fascinante", "python para data science",

"algoritmos de classificação", "svm com kernels personalizados"]

labels = [0, 1, 0, 1]

classificador_texto = svm.SVC(kernel=kernel_similaridade_textual)

classificador_texto.fit(documentos, labels)

Kernel com Lógica de Domínio Específico

Surpreendentemente, podemos incorporar conhecimento de domínio diretamente no kernel:

def kernel_financeiro(X, Y, peso_volatilidade=0.3, peso_correlacao=0.7):
    """
    Kernel personalizado para dados financeiros
    Incorpora volatilidade e correlação temporal
    """
    kernel_matrix = np.zeros((X.shape[0], Y.shape[0]))
    
    for i in range(X.shape[0]):
        for j in range(Y.shape[0]):
            # Componente de similaridade tradicional
            similaridade_base = np.exp(-0.1 * np.linalg.norm(X[i] - Y[j]))
            
            # Componente de volatilidade (assumindo últimos 2 features)
            vol_x = X[i, -2] if X.shape[1] >= 2 else 1.0
            vol_y = Y[j, -2] if Y.shape[1] >= 2 else 1.0
            similaridade_vol = 1.0 / (1.0 + abs(vol_x - vol_y))
            
            # Componente de correlação (assumindo últimos features)
            corr_x = X[i, -1] if X.shape[1] >= 1 else 0.0
            corr_y = Y[j, -1] if Y.shape[1] >= 1 else 0.0
            similaridade_corr = 1.0 - abs(corr_x - corr_y)
            
            # Combinação ponderada
            kernel_matrix[i, j] = (similaridade_base + 
                                 peso_volatilidade * similaridade_vol + 
                                 peso_correlacao * similaridade_corr)
    
    return kernel_matrix

def kernel_financeiro(X, Y, peso_volatilidade=0.3, peso_correlacao=0.7):

"""

Kernel personalizado para dados financeiros

Incorpora volatilidade e correlação temporal

"""

kernel_matrix = np.zeros((X.shape[0], Y.shape[0]))

for i in range(X.shape[0]):

for j in range(Y.shape[0]):

# Componente de similaridade tradicional

similaridade_base = np.exp(-0.1 * np.linalg.norm(X[i] - Y[j]))

# Componente de volatilidade (assumindo últimos 2 features)

vol_x = X[i, -2] if X.shape[1] >= 2 else 1.0

vol_y = Y[j, -2] if Y.shape[1] >= 2 else 1.0

similaridade_vol = 1.0 / (1.0 + abs(vol_x - vol_y))

# Componente de correlação (assumindo últimos features)

corr_x = X[i, -1] if X.shape[1] >= 1 else 0.0

corr_y = Y[j, -1] if Y.shape[1] >= 1 else 0.0

similaridade_corr = 1.0 - abs(corr_x - corr_y)

# Combinação ponderada

kernel_matrix[i, j] = (similaridade_base +

peso_volatilidade * similaridade_vol +

peso_correlacao * similaridade_corr)

return kernel_matrix

Otimização e Boas Práticas

Contudo, kernels personalizados podem ser computacionalmente intensivos. Assim, estratégias de otimização são essenciais:

Vectorização: Utilize operações NumPy vetorizadas sempre que possível
Memoização: Cache de resultados para chamadas repetidas
Parallelização: Use joblib para computação paralela
Validação: Teste rigoroso com diferentes conjuntos de dados

Exemplo com Memoização

from functools import lru_cache

class KernelMemoizado:
    def __init__(self, kernel_func):
        self.kernel_func = kernel_func
        self.cache = {}
    
    def __call__(self, X, Y):
        key = (id(X), id(Y))
        if key not in self.cache:
            self.cache[key] = self.kernel_func(X, Y)
        return self.cache[key]

# Decorando nossa função kernel
@lru_cache(maxsize=128)
def kernel_eficiente(X_tuple, Y_tuple):
    """
    Kernel com memoização para melhor performance
    """
    X = np.array(X_tuple)
    Y = np.array(Y_tuple)
    return kernel_linear_combinado(X, Y)

# Utilização
X_tuple = tuple(map(tuple, X_train))
Y_tuple = tuple(map(tuple, X_test))
kernel_matrix = kernel_eficiente(X_tuple, Y_tuple)

from functools import lru_cache

class KernelMemoizado:

def __init__(self, kernel_func):

self.kernel_func = kernel_func

self.cache = {}

def __call__(self, X, Y):

key = (id(X), id(Y))

if key not in self.cache:

self.cache[key] = self.kernel_func(X, Y)

return self.cache[key]

# Decorando nossa função kernel

@lru_cache(maxsize=128)

def kernel_eficiente(X_tuple, Y_tuple):

"""

Kernel com memoização para melhor performance

"""

X = np.array(X_tuple)

Y = np.array(Y_tuple)

return kernel_linear_combinado(X, Y)

# Utilização

X_tuple = tuple(map(tuple, X_train))

Y_tuple = tuple(map(tuple, X_test))

kernel_matrix = kernel_eficiente(X_tuple, Y_tuple)

Considerações Finais e Aplicações Práticas

Enfim, a capacidade de usar funções Python como kernels abre infinitas possibilidades. Inegavelmente, esta flexibilidade permite:

Sobretudo: Soluções específicas para domínios especializados
Integração de conhecimento de domínio no algoritmo
Experimentação com novas formas de similaridade
Otimização para tipos de dados não convencionais

Afinal, dominar esta técnica transforma o desenvolvedor de usuário para criador de algoritmos. Eventualmente, você encontrará problemas onde apenas um kernel personalizado fornecerá a performance desejada.

Portanto, pratique, experimente e incorpore esta poderosa ferramenta em seu arsenal de machine learning. Inclusive para desafios que anteriormente pareciam intratáveis.

Indice