Métodos em R ou Python para executar a seleção de recursos em aprendizado não supervisionado [fechado]

11

Fechadas. Esta questão está fora de tópico . No momento, não está aceitando respostas.

Deseja melhorar esta pergunta? Atualize a pergunta para que ela esteja no tópico de Validação cruzada.

Fechado há 2 anos .

Quais são os métodos / implementação disponíveis no R / Python para descartar / selecionar recursos importantes / sem importância nos dados? Meus dados não têm rótulos (não supervisionados).

Os dados têm ~ 100 recursos com tipos mistos. Alguns são numéricos, enquanto outros são binários (0/1).

r feature-selection python

— aprendiz
fonte

Que tipo de algoritmo de aprendizado não supervisionado você está usando? Como são os seus dados?

— Max Candocia

@ user1362215, Antes de aplicar qualquer algoritmo não supervisionado, estou tentando encontrar uma maneira de executar a remoção de recursos.

— aluno

Você já viu este cheatsheet do scikit-learn antes? Ele pode ajudar você a começar ...

— Steve S

Por que não usar um método não supervisionado que perfomes a seleção de recursos por si só, como floresta aleatória no modo não supervisionado?

— JEquihua

1

Eu não sou completamente surem, quero dizer floresta aleatória é completamente não paramétrica, então não se preocupe com suposições. O que não tenho certeza é se isso servirá ao seu propósito. O que posso dizer é que existe uma versão da Random Forest apenas para "detecção de anomalias" chamada florestas de isolamento: cs.nju.edu.cn/zhouzh/zhouzh.files/publication/… houve uma implementação em R, mas estou não tenho certeza se está em funcionamento a partir de agora.

— JEquihua

7

Ele tem um ano, mas eu ainda sinto que é relevante, então eu só queria compartilhar minha implementação em python da Principal Feature Analysis (PFA), conforme proposto no artigo ao qual Charles vinculou em sua resposta.

from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from collections import defaultdict
from sklearn.metrics.pairwise import euclidean_distances
from sklearn.preprocessing import StandardScaler

class PFA(object):
    def __init__(self, n_features, q=None):
        self.q = q
        self.n_features = n_features

    def fit(self, X):
        if not self.q:
            self.q = X.shape[1]

        sc = StandardScaler()
        X = sc.fit_transform(X)

        pca = PCA(n_components=self.q).fit(X)
        A_q = pca.components_.T

        kmeans = KMeans(n_clusters=self.n_features).fit(A_q)
        clusters = kmeans.predict(A_q)
        cluster_centers = kmeans.cluster_centers_

        dists = defaultdict(list)
        for i, c in enumerate(clusters):
            dist = euclidean_distances([A_q[i, :]], [cluster_centers[c, :]])[0][0]
            dists[c].append((i, dist))

        self.indices_ = [sorted(f, key=lambda x: x[1])[0][0] for f in dists.values()]
        self.features_ = X[:, self.indices_]

Você pode usá-lo assim:

import numpy as np
X = np.random.random((1000,1000))

pfa = PFA(n_features=10)
pfa.fit(X)

# To get the transformed matrix
X = pfa.features_

# To get the column indices of the kept features
column_indices = pfa.indices_

Isso segue rigorosamente o algoritmo descrito no artigo. Acho que o método tem promessas, mas sinceramente não acho que seja a abordagem mais robusta para a seleção de recursos não supervisionados. Vou postar uma atualização se tiver algo melhor.

— Ulf Aslak
fonte

No método descrito no documento ao qual você vincula, a Etapa 1 é calcular a matriz de covariância e a Etapa 2 é calcular o PCA na matriz de covariância da Etapa 1. Acredito que sua fitfunção ignora a Etapa 1 e executa a PCA no conjunto de dados original .

— user35581

@ user35581 bom ponto. No entanto, o que eles fazem é (1) produzir a matriz de covariância a partir dos dados originais e (2) computar os autovetores e os autovalores da matriz de covariância usando o método SVD. Essas duas etapas combinadas são o que você chama de PCA. Os componentes principais são os autovetores da matriz de covariância dos dados originais.

— Ulf Aslak

@Ulf Aslak, você pode explicar por que você acha que não é a abordagem mais robusta para a seleção de recursos não supervisionados?

— Hipoglucido

1

@hipoglucido honestamente, não consigo explicar meus pensamentos quando escrevi isso. Faz três anos atrás. Revendo o código novamente, sou levado a acreditar que ele tem algo a ver com o uso do KMeans (que não é determinístico). Além disso, gostaria de ver como isso se compara a apenas agrupar os recursos não transformados por PCA.

— Ulf Aslak

2

O pacote sparcl no R executa agrupamentos hierárquicos e esparsos de K-means esparsos. Isso pode ser útil. http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/

— Charles
fonte

1

A Análise de recursos principais parece ser uma solução para a seleção de recursos não supervisionados. Está descrito neste artigo .

— Max Ghenis
fonte

Link está morto. Compartilhou uma implementação em python do método proposto no artigo stats.stackexchange.com/a/203978/76815 .

— Ulf Aslak 27/03

Obrigado, removi o link (ele foi excluído como fora de tópico).

— Max Ghenis 27/03

0

Eu encontrei um link que poderia ser útil, essas são implementações do matlab, elas podem funcionar para você http://www.cad.zju.edu.cn/home/dengcai/Data/MCFS.html é uma seleção de recursos multicluster método, você pode encontrar uma base sólida sobre isso em artigos recentes. Deixe-me saber se funciona para você

— formacero10
fonte

0

Existem muitas opções disponíveis no R. Um bom lugar para procurar é o caretpacote que fornece uma boa interface para muitos outros pacotes e opções. Você pode dar uma olhada no site aqui . Existem muitas opções por aí, mas vou ilustrar uma.

Aqui está um exemplo de uso de um filtro simples usando os Rconjuntos de dados "mtcars" integrados (mostrados abaixo).

                   mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1

Agora, algumas configurações de código (carregamento de pacotes etc.):

# setup a parallel environment
library(doParallel)
cl <- makeCluster(2) # number of cores to use
registerDoParallel(cl)
library(caret)

E podemos ajustar um modelo simples para selecionar variáveis:

fit1 <- sbf(mtcars[, -1], mtcars[, 1],
  sbfControl =
    sbfControl(functions = rfSBF, method = "repeatedcv", repeats = 10)
)

Visualizando os resultados, obtemos:

fit1
Selection By Filter

Outer resampling method: Cross-Validated (10 fold, repeated 10 times) 

Resampling performance:

  RMSE Rsquared RMSESD RsquaredSD
 2.266   0.9224 0.8666     0.1523

Using the training set, 7 variables were selected:
   cyl, disp, hp, wt, vs...

During resampling, the top 5 selected variables (out of a possible 9):
   am (100%), cyl (100%), disp (100%), gear (100%), vs (100%)

On average, 7 variables were selected (min = 5, max = 9)

Finalmente, podemos plotar as variáveis selecionadas (in fit1$optVariables) em relação ao resultado mpg:

library(ggplot2)
library(gridExtra)
do.call(grid.arrange, 
lapply(fit1$optVariables, function(v) {
  ggplot(mtcars, aes_string(x = v, y = "mpg")) +
    geom_jitter()
}))

Resultando neste gráfico: gráficos de dispersão

— Joshua
fonte

1

Isso não é aprendizado não supervisionado, conforme solicitado pelo OP, pois o modelo é usado mpgcomo resultado. Existe uma maneira de usar métodos como estes em modelos não supervisionados?

— precisa saber é o seguinte

0

O nsprcomppacote R fornece métodos para análises esparsas de componentes principais, que podem atender às suas necessidades.

Por exemplo, se você acredita que seus recursos são geralmente correlacionados linearmente e deseja selecionar os cinco principais, você pode executar um PCA escasso com um máximo de cinco recursos e limitar o primeiro componente principal:

m <- nsprcomp(x, scale.=T, k=5, ncomp=1)
m$rotation[, 1]

Como alternativa, se você deseja capturar a natureza ortogonal dos recursos, pode selecionar o recurso principal de cada um dos cinco principais PCs, limitando cada PC a um recurso:

m <- nsprcomp(x, scale.=T, k=1, ncomp=5)
m$rotation

Um conjunto desses também pode ser útil; ou seja, os recursos que chegam ao topo de maneira consistente em diferentes métodos provavelmente explicam uma grande quantidade de variação no espaço do recurso. Tendo brincado nsprcompum pouco, parece que os dois primeiros métodos aumentam ~ 1/2 dos mesmos recursos para o topo. Dito isto, otimizar esse processo pode ser um esforço empírico.

— Max Ghenis
fonte