Méthodes en R ou Python pour effectuer la sélection des fonctionnalités dans un apprentissage non supervisé [fermé]

Quelles sont les méthodes / implémentations disponibles dans R / Python pour éliminer / sélectionner les fonctionnalités non importantes / importantes dans les données? Mes données n'ont pas d'étiquettes (non supervisées).

Les données ont environ 100 fonctionnalités avec des types mixtes. Certains sont numériques tandis que d'autres sont binaires (0/1).

Cela fait un an mais je pense toujours que c'est pertinent, donc je voulais juste partager mon implémentation python de l'analyse des fonctionnalités principales (PFA) comme proposé dans le document auquel Charles a lié dans sa réponse.

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_]

Vous pouvez l'utiliser comme ceci:

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_

Ceci suit strictement l'algorithme décrit dans l'article. Je pense que la méthode est prometteuse, mais honnêtement, je ne pense pas que ce soit l'approche la plus robuste pour la sélection de fonctionnalités non supervisées. Je publierai une mise à jour si je trouve quelque chose de mieux.

Le package sparcl dans R effectue un clustering hiérarchique et K-means clairsemé. Cela peut être utile. http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2930825/

L'analyse des fonctionnalités principales semble être une solution à la sélection non supervisée des fonctionnalités. Il est décrit dans cet article .

J'ai trouvé un lien qui pourrait être utile, ce sont des implémentations matlab, elles peuvent fonctionner pour vous http://www.cad.zju.edu.cn/home/dengcai/Data/MCFS.html c'est une sélection de fonctionnalités multicluster méthode, vous pouvez trouver des bases solides à ce sujet dans des articles récents Faites-moi savoir si cela fonctionne pour vous

Il existe de nombreuses options disponibles dans R. Un bon endroit pour regarder est le caretpackage qui fournit une interface agréable à de nombreux autres packages et options. Vous pouvez consulter le site Web ici . Il existe de nombreuses options, mais je vais en illustrer une.

Voici un exemple d'utilisation d'un filtre simple utilisant les Rjeux de données intégrés «mtcars» (illustrés ci-dessous).

                   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

Maintenant, une configuration de code (chargement de packages, etc.):

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

Et nous pouvons adapter un modèle simple pour sélectionner des variables:

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

En consultant les résultats, nous obtenons:

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)

Enfin, nous pouvons tracer les variables sélectionnées (in fit1$optVariables) par rapport au résultat mpg:

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

Résultat dans ce graphique:

Le nsprcomppackage R fournit des méthodes d'analyse clairsemée des composants principaux, qui pourraient répondre à vos besoins.

Par exemple, si vous pensez que vos fonctionnalités sont généralement corrélées linéairement et que vous souhaitez sélectionner les cinq premières, vous pouvez exécuter une PCA clairsemée avec un maximum de cinq fonctionnalités, et limiter au premier composant principal:

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

Alternativement, si vous souhaitez capturer la nature orthogonale des entités, vous pouvez sélectionner l'entité supérieure de chacun des cinq premiers PC, en limitant chaque PC à une seule entité:

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

Un ensemble de ces éléments pourrait également être utile; c'est-à-dire que les caractéristiques qui arrivent constamment au sommet à travers différentes méthodes sont susceptibles d'expliquer une grande quantité de variance dans l'espace des caractéristiques. Après avoir joué avec nsprcompun peu, il semble que les deux premières méthodes élèvent ~ 1/2 des mêmes fonctionnalités vers le haut. Cela dit, l'optimisation de ce processus peut être un effort empirique.