matrix comandi - Tutti i livelli di un fattore in una matrice modello in R




manuale con (8)

Ho un data.frame costituito da variabili numeriche e fattoriali come visto di seguito.

testFrame <- data.frame(First=sample(1:10, 20, replace=T),
           Second=sample(1:20, 20, replace=T), Third=sample(1:10, 20, replace=T),
           Fourth=rep(c("Alice","Bob","Charlie","David"), 5),
           Fifth=rep(c("Edward","Frank","Georgia","Hank","Isaac"),4))

Voglio costruire una matrix che assegni le variabili dummy al fattore e lasci da solo le variabili numeriche.

model.matrix(~ First + Second + Third + Fourth + Fifth, data=testFrame)

Come previsto quando si esegue lm questo lascia un livello di ciascun fattore come livello di riferimento. Tuttavia, voglio costruire una matrix con una variabile dummy / indicatore per ogni livello di tutti i fattori. Sto costruendo questa matrice per glmnet quindi non sono preoccupato per la multicollinearità.

C'è un modo per avere model.matrix creare il manichino per ogni livello del fattore?


Answers

Utilizzo del pacchetto R "CatEncoders"

library(CatEncoders)
testFrame <- data.frame(First=sample(1:10, 20, replace=T),
           Second=sample(1:20, 20, replace=T), Third=sample(1:10, 20, replace=T),
           Fourth=rep(c("Alice","Bob","Charlie","David"), 5),
           Fifth=rep(c("Edward","Frank","Georgia","Hank","Isaac"),4))

fit <- OneHotEncoder.fit(testFrame)

z <- transform(fit,testFrame,sparse=TRUE) # give the sparse output
z <- transform(fit,testFrame,sparse=FALSE) # give the dense output


È necessario ripristinare i contrasts per le variabili fattore:

model.matrix(~ Fourth + Fifth, data=testFrame, 
        contrasts.arg=list(Fourth=contrasts(testFrame$Fourth, contrasts=F), 
                Fifth=contrasts(testFrame$Fifth, contrasts=F)))

o, con un po 'meno di battitura e senza i nomi propri:

model.matrix(~ Fourth + Fifth, data=testFrame, 
    contrasts.arg=list(Fourth=diag(nlevels(testFrame$Fourth)), 
            Fifth=diag(nlevels(testFrame$Fifth))))

Ok. Basta leggere quanto sopra e mettere tutto insieme. Supponiamo di volere la matrice, ad esempio "X.factors", che si moltiplica per il vettore del coefficiente per ottenere il predittore lineare. Ci sono ancora un paio di passaggi aggiuntivi:

X.factors = 
  model.matrix( ~ ., data=X, contrasts.arg = 
    lapply(data.frame(X[,sapply(data.frame(X), is.factor)]),
                                             contrasts, contrasts = FALSE))

(Notare che è necessario trasformare X [*] di nuovo in un frame di dati nel caso in cui si disponga di una sola colonna del fattore.)

Quindi dì che ottieni qualcosa del genere:

attr(X.factors,"assign")
[1]  0  1  **2**  2  **3**  3  3  **4**  4  4  5  6  7  8  9 10 #emphasis added

Vogliamo sbarazzarci dei ** ** livelli di riferimento di ciascun fattore

att = attr(X.factors,"assign")
factor.columns = unique(att[duplicated(att)])
unwanted.columns = match(factor.columns,att)
X.factors = X.factors[,-unwanted.columns]
X.factors = (data.matrix(X.factors))

Sto attualmente imparando il modello di Lasso e glmnet::cv.glmnet() , model.matrix() e Matrix::sparse.model.matrix() (per la matrice ad alte dimensioni, usando model.matrix si ucciderà il nostro tempo come suggerito dal autore di glmnet .).

Basta condividere ci ha un codice in ordine per ottenere la stessa risposta di @fabians e la risposta di @ Gavin. Nel frattempo, @ asdf123 ha introdotto anche un'altra library('CatEncoders') pacchetti library('CatEncoders') .

> require('useful')
> # always use all levels
> build.x(First ~ Second + Fourth + Fifth, data = testFrame, contrasts = FALSE)
> 
> # just use all levels for Fourth
> build.x(First ~ Second + Fourth + Fifth, data = testFrame, contrasts = c(Fourth = FALSE, Fifth = TRUE))

Fonte: R per tutti: Analytics e grafica avanzata (pagina 273)


model.matrix(~ First + Second + Third + Fourth + Fifth - 1, data=testFrame)

o

model.matrix(~ First + Second + Third + Fourth + Fifth + 0, data=testFrame)

dovrebbe essere il più diretto

F


caret implementato una bella funzione dummyVars per ottenere questo risultato con 2 linee:

library(caret) dmy <- dummyVars(" ~ .", data = testFrame) testFrame2 <- data.frame(predict(dmy, newdata = testFrame))

Controllo delle colonne finali:

colnames(testFrame2)

"First"  "Second"         "Third"          "Fourth.Alice"   "Fourth.Bob"     "Fourth.Charlie" "Fourth.David"   "Fifth.Edward"   "Fifth.Frank"   "Fifth.Georgia"  "Fifth.Hank"     "Fifth.Isaac"   

Il punto più bello qui è ottenere il frame di dati originale, oltre alle variabili dummy che hanno escluso quelle originali utilizzate per la trasformazione.

Maggiori informazioni: http://amunategui.github.io/dummyVar-Walkthrough/


Ecco un breve riassunto sugli algoritmi di rilevamento della comunità attualmente implementati in igraph:

  • edge.betweenness.community è un processo di decomposizione gerarchico in cui i bordi vengono rimossi nell'ordine decrescente dei loro punteggi di interlinea (ovvero il numero di percorsi più brevi che attraversano un dato spigolo). Ciò è motivato dal fatto che i bordi che connettono gruppi diversi hanno maggiori probabilità di essere contenuti in percorsi multipli più brevi semplicemente perché in molti casi sono l'unica opzione per passare da un gruppo all'altro. Questo metodo produce buoni risultati, ma è molto lento a causa della complessità computazionale dei calcoli di spigolo e perché i punteggi delle concordanze devono essere ricalcolati dopo ogni rimozione del bordo. I grafici con ~ 700 vertici e ~ 3500 spigoli si trovano intorno al limite superiore di dimensioni dei grafici che è possibile analizzare con questo approccio. Un altro svantaggio è che edge.betweenness.community costruisce un dendrogramma completo e non fornisce alcuna indicazione su dove tagliare il dendrogramma per ottenere i gruppi finali, quindi dovrai usare qualche altra misura per decidere che (ad esempio, la modularità punteggio delle partizioni ad ogni livello del dendrogramma).

  • fastgreedy.community è un altro approccio gerarchico, ma è bottom-up anziché top-down. Cerca di ottimizzare una funzione di qualità chiamata modularità in maniera avida. Inizialmente, ogni vertice appartiene a una comunità separata e le comunità vengono unite in modo iterativo in modo tale che ogni unione sia localmente ottimale (ovvero produce il maggiore aumento del valore corrente della modularità). L'algoritmo si interrompe quando non è più possibile aumentare la modularità, quindi fornisce un raggruppamento e un dendrogramma. Il metodo è veloce ed è il metodo che di solito viene provato come prima approssimazione perché non ha parametri da regolare. Tuttavia, è noto che soffre di un limite di risoluzione, cioè le comunità al di sotto di una determinata soglia di dimensione (a seconda del numero di nodi e spigoli se ricordo bene) saranno sempre unite con le comunità vicine.

  • walktrap.community è un approccio basato su passeggiate casuali. L'idea generale è che se si eseguono camminate casuali sul grafico, è più probabile che le passeggiate rimangano all'interno della stessa comunità perché ci sono solo alcuni spigoli che portano fuori da una determinata comunità. Walktrap esegue brevi passeggiate casuali di 3-4-5 passaggi (a seconda di uno dei suoi parametri) e utilizza i risultati di queste passeggiate casuali per unire comunità separate in un modo bottom-up come fastgreedy.community . Di nuovo, puoi usare il punteggio di modularità per selezionare dove tagliare il dendrogramma. È un po 'più lento dell'approccio avido ma anche un po' più accurato (secondo la pubblicazione originale).

  • spinglass.community è un approccio dalla fisica statistica, basato sul cosiddetto modello di Potts. In questo modello, ogni particella (cioè vertice) può essere in uno degli stati di rotazione c , e le interazioni tra le particelle (cioè i bordi del grafico) specificano quali coppie di vertici preferirebbero rimanere nello stesso stato di rotazione e quali preferiscono avere diversi stati di spin. Il modello viene quindi simulato per un determinato numero di passaggi e gli stati di rotazione delle particelle nella parte finale definiscono le comunità. Le conseguenze sono le seguenti: 1) Alla fine non ci saranno mai più di c comunità, sebbene sia possibile impostare c per un massimo di 200, che è probabile che sia sufficiente per i propri scopi. 2) Alla fine potrebbero esserci meno comunità in quanto alcuni stati di spin potrebbero diventare vuoti. 3) Non è garantito che i nodi in parti completamente remote (o sconcertate) delle reti abbiano stati di spin diversi. È più probabile che questo sia un problema solo per i grafici scollegati, quindi non mi preoccuperei di ciò. Il metodo non è particolarmente veloce e non deterministico (a causa della simulazione stessa), ma ha un parametro di risoluzione regolabile che determina le dimensioni del cluster. Una variante del metodo spinglass può anche prendere in considerazione i collegamenti negativi (cioè i collegamenti i cui endpoint preferiscono essere in diverse comunità).

  • leading.eigenvector.community è un approccio gerarchico top-down che ottimizza nuovamente la funzione di modularità. In ogni fase, il grafico è suddiviso in due parti in modo che la separazione stessa determini un aumento significativo della modularità. La divisione viene determinata valutando l'autovettore principale della cosiddetta matrice di modularità e vi è anche una condizione di arresto che impedisce di dividere ulteriormente i gruppi strettamente collegati. A causa dei calcoli di autovalori coinvolti, potrebbe non funzionare su grafici degenerati in cui il risolutore di autovettori ARPACK è instabile. Sui grafici non degenerati, è probabile che produca un punteggio di modularità più elevato rispetto al metodo avido veloce, sebbene sia un po 'più lento.

  • label.propagation.community è un approccio semplice in cui a ogni nodo viene assegnata una delle k etichette. Il metodo procede quindi in modo iterativo e riassegna le etichette ai nodi in modo che ogni nodo assuma l'etichetta più frequente dei suoi vicini in modo sincrono. Il metodo si interrompe quando l'etichetta di ciascun nodo è una delle etichette più frequenti nel suo quartiere. È molto veloce ma produce risultati diversi in base alla configurazione iniziale (che viene decisa casualmente), quindi si dovrebbe eseguire il metodo un gran numero di volte (ad esempio, 1000 volte per un grafico) e quindi creare un'etichettatura di consenso, che potrebbe essere noioso.

igraph 0.6 includerà anche l'algoritmo di rilevamento della comunità di Infomap, che si basa su principi teorici dell'informazione; prova a costruire un raggruppamento che fornisce la lunghezza di descrizione più breve per una passeggiata casuale sul grafico, dove la lunghezza della descrizione è misurata dal numero previsto di bit per vertice richiesto per codificare il percorso di una passeggiata casuale.

Ad ogni modo, probabilmente andrei con fastgreedy.community o walktrap.community come prima approssimazione e poi walktrap.community altri metodi quando si scopre che questi due non sono adatti per un particolare problema per qualche motivo.





r matrix model indicator