Suche…


Syntax

  1. Faktor (x = Zeichen (), Ebenen, Beschriftungen = Ebenen, ausschließen = NA, geordnet = ist.geordnet (X), nmax = NA)
  2. Run ?factor oder Online- Dokumentation .

Bemerkungen

Ein Objekt mit dem Klasse - factor ist ein Vektor mit einem bestimmten Satz von Eigenschaften.

  1. Es wird intern als integer gespeichert.
  2. Es verwaltet ein levels , das die Zeichendarstellung der Werte zeigt.
  3. Ihre Klasse wird als factor gespeichert

Lassen Sie uns zur Veranschaulichung aus einem Satz von Farben einen Vektor von 1.000 Beobachtungen erzeugen.

set.seed(1)
Color <- sample(x = c("Red", "Blue", "Green", "Yellow"), 
                size = 1000, 
                replace = TRUE)
Color <- factor(Color)

Wir können jede der oben aufgeführten Eigenschaften von Color beobachten:

#* 1. It is stored internally as an `integer` vector
typeof(Color)
[1] "integer"
#* 2. It maintains a `levels` attribute the shows the character representation of the values.
#* 3. Its class is stored as `factor`
attributes(Color)
$levels
[1] "Blue"   "Green"  "Red"    "Yellow"

$class
[1] "factor"

Der Hauptvorteil eines Faktorobjekts ist die Effizienz bei der Datenspeicherung. Eine Ganzzahl erfordert weniger Speicherplatz als ein Zeichen. Eine solche Effizienz war äußerst wünschenswert, wenn viele Computer über weitaus geringere Ressourcen als derzeitige Computer verfügten (für eine genauere Beschreibung der Gründe für die Verwendung von Faktoren siehe stringsAsFactors : eine nicht autorisierte Biografie ). Der Unterschied bei der Speichernutzung ist sogar in unserem Color Objekt sichtbar. Wie Sie sehen können, erfordert das Speichern von Color als Zeichen etwa 1,7-mal so viel Speicher wie das Faktorobjekt.

#* Amount of memory required to store Color as a factor.
object.size(Color)
4624 bytes
#* Amount of memory required to store Color as a character
object.size(as.character(Color))
8232 bytes

Die Ganzzahl der Ebene zuordnen

Während die interne Berechnung von Faktoren das Objekt als Ganzzahl sieht, ist die gewünschte Darstellung für den menschlichen Konsum die Zeichenebene. Zum Beispiel,

head(Color)
[1] Blue   Blue   Green  Yellow Red    Yellow  
Levels: Blue Green Red Yellow

ist für das menschliche Verständnis einfacher als

head(as.numeric(Color))
[1] 1 1 2 4 3 4

Eine ungefähre Darstellung, wie R die Zeichendarstellung an den internen Integerwert anpasst, ist:

head(levels(Color)[as.numeric(Color)])
[1] "Blue"   "Blue"   "Green"  "Yellow" "Red"    "Yellow"

Vergleichen Sie diese Ergebnisse mit

head(Color)
[1] Blue   Blue   Green  Yellow Red    Yellow  
Levels: Blue Green Red Yellow

Moderne Nutzung von Faktoren

Im Jahr 2007 führte R eine Hashmethode für Zeichen ein, um die Speicherlast von Zeichenvektoren zu reduzieren (ref: stringsAsFactors : a Unauthorized Biography ). Wenn wir festgestellt haben, dass Zeichen 1,7-mal mehr Speicherplatz benötigen als Faktoren, wurde dies in einer aktuellen Version von R berechnet, was bedeutet, dass der Speicherverbrauch von Zeichenvektoren vor 2007 noch mehr belastend war.

Aufgrund des Hash-Verfahrens in modernen R und der weitaus größeren Speicherressourcen in modernen Computern wurde das Problem der Speichereffizienz beim Speichern von Zeichenwerten auf ein sehr kleines Problem reduziert. Die vorherrschende Einstellung in der R-Gemeinschaft ist in den meisten Situationen eine Bevorzugung von Zeichenvektoren gegenüber Faktoren. Die Hauptursachen für die Abkehr von Faktoren sind

  1. Die Zunahme unstrukturierter und / oder lose kontrollierter Zeichendaten
  2. Die Tendenz von Faktoren, sich nicht wie gewünscht zu verhalten, wenn der Benutzer vergisst, dass er mit einem Faktor und nicht mit einem Charakter zu tun hat

Im ersten Fall macht es keinen Sinn, Freitext oder offene Antwortfelder als Faktoren zu speichern, da es unwahrscheinlich ist, dass ein Muster vorhanden ist, das mehr als eine Beobachtung pro Ebene zulässt. Alternativ, wenn die Datenstruktur nicht sorgfältig gesteuert wird, ist es möglich, mehrere Ebenen zu erhalten, die derselben Kategorie entsprechen (z. B. "blau", "blau" und "blau"). In solchen Fällen ziehen es viele vor, diese Diskrepanzen als Zeichen zu verwalten, bevor sie in einen Faktor umgewandelt werden (wenn überhaupt eine Konvertierung erfolgt).

Im zweiten Fall, wenn der Benutzer der Meinung ist, dass er mit einem Zeichenvektor arbeitet, reagieren bestimmte Methoden möglicherweise nicht wie erwartet. Dieses grundlegende Verständnis kann beim Debuggen von Skripts und Codes zu Verwirrung und Frustration führen. Genau genommen kann dies als Verschulden des Benutzers betrachtet werden. Die meisten Benutzer verzichten jedoch gerne auf Faktoren und vermeiden diese Situationen insgesamt.

Grundlegende Faktorenbildung

Faktoren sind eine Möglichkeit, kategoriale Variablen in R darzustellen. Ein Faktor wird intern als Vektor von Ganzzahlen gespeichert. Die eindeutigen Elemente des gelieferten Zeichenvektors werden als Stufen des Faktors bezeichnet. Wenn die Ebenen nicht vom Benutzer angegeben werden, generiert R standardmäßig die Menge der eindeutigen Werte im Vektor, sortiert diese Werte alphanumerisch und verwendet sie als Ebenen.

 charvar <- rep(c("n", "c"), each = 3)
 f <- factor(charvar)
 f
 levels(f)

> f
[1] n n n c c c
Levels: c n
> levels(f)
[1] "c" "n"

Wenn Sie die Reihenfolge der Ebenen ändern möchten, können Sie die Ebenen manuell mit einer Option festlegen:

levels(factor(charvar, levels = c("n","c")))

> levels(factor(charvar, levels = c("n","c")))
[1] "n" "c"

Faktoren haben eine Reihe von Eigenschaften. Beispielsweise können Ebenen Beschriftungen erhalten:

> f <- factor(charvar, levels=c("n", "c"), labels=c("Newt", "Capybara"))
> f
[1] Newt     Newt     Newt     Capybara Capybara Capybara
Levels: Newt Capybara

Eine weitere Eigenschaft, die zugewiesen werden kann, ist die Anordnung des Faktors:

> Weekdays <- factor(c("Monday", "Wednesday", "Thursday", "Tuesday", "Friday", "Sunday", "Saturday"))
> Weekdays
[1] Monday    Wednesday Thursday  Tuesday   Friday    Sunday    Saturday 
Levels: Friday Monday Saturday Sunday Thursday Tuesday Wednesday
> Weekdays <- factor(Weekdays, levels=c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"), ordered=TRUE)
> Weekdays
[1] Monday    Wednesday Thursday  Tuesday   Friday    Sunday    Saturday 
Levels: Monday < Tuesday < Wednesday < Thursday < Friday < Saturday < Sunday

Wenn eine Stufe des Faktors nicht mehr verwendet wird, können Sie sie mit der Funktion droplevels() :

> Weekend <- subset(Weekdays, Weekdays == "Saturday" |  Weekdays == "Sunday")
> Weekend
[1] Sunday   Saturday
Levels: Monday < Tuesday < Wednesday < Thursday < Friday < Saturday < Sunday
> Weekend <- droplevels(Weekend)
> Weekend
[1] Sunday   Saturday
Levels: Saturday < Sunday

Faktorstufen mit einer Liste konsolidieren

Es gibt Zeiten, in denen es wünschenswert ist, die Faktorstufen in weniger Gruppen zusammenzufassen, möglicherweise aufgrund spärlicher Daten in einer der Kategorien. Es kann auch vorkommen, wenn Sie unterschiedliche Schreibweisen oder Großschreibung für die Kategorienamen verwenden. Betrachten Sie den Faktor als Beispiel

set.seed(1)
colorful <- sample(c("red", "Red", "RED", "blue", "Blue", "BLUE", "green", "gren"),
                   size = 20,
                   replace = TRUE)
colorful <- factor(colorful)

Da R die Groß- und Kleinschreibung berücksichtigt, erscheint eine Frequenztabelle dieses Vektors wie folgt.

table(colorful)
colorful  
blue  Blue  BLUE green  gren   red   Red   RED  
   3     1     4     2     4     1     3     2

Diese Tabelle stellt jedoch nicht die tatsächliche Verteilung der Daten dar, und die Kategorien können effektiv auf drei Typen reduziert werden: Blau, Grün und Rot. Drei Beispiele werden bereitgestellt. Die erste veranschaulicht eine scheinbar naheliegende Lösung, die jedoch keine wirkliche Lösung bietet. Die zweite gibt eine funktionierende Lösung, ist aber ausführlich und rechenintensiv. Die dritte ist keine offensichtliche Lösung, aber sie ist relativ kompakt und recheneffizient.

Ebenen über factor konsolidieren ( factor_approach )

factor(as.character(colorful),
       levels = c("blue", "Blue", "BLUE", "green", "gren", "red", "Red", "RED"),
       labels = c("Blue", "Blue", "Blue", "Green", "Green", "Red", "Red", "Red"))
 [1] Green Blue  Red   Red   Blue  Red   Red   Red   Blue  Red   Green Green Green Blue  Red   Green
[17] Red   Green Green Red  
Levels: Blue Blue Blue Green Green Red Red Red
Warning message:
In `levels<-`(`*tmp*`, value = if (nl == nL) as.character(labels) else paste0(labels,  :
  duplicated levels in factors are deprecated

Beachten Sie, dass es doppelte Ebenen gibt. Wir haben immer noch drei Kategorien für "Blau", was unsere Aufgabe der Konsolidierung der Ebenen nicht vollständig erfüllt. Darüber hinaus gibt es eine Warnung, dass doppelte Ebenen veraltet sind, was bedeutet, dass dieser Code in Zukunft einen Fehler erzeugen kann.

Ebenen mit ifelse konsolidieren ( ifelse_approach )

factor(ifelse(colorful %in% c("blue", "Blue", "BLUE"),
       "Blue",
       ifelse(colorful %in% c("green", "gren"),
              "Green",
              "Red")))
 [1] Green Blue  Red   Red   Blue  Red   Red   Red   Blue  Red   Green Green Green Blue  Red   Green
[17] Red   Green Green Red  
Levels: Blue Green Red

Dieser Code generiert das gewünschte Ergebnis, erfordert jedoch die Verwendung geschachtelter ifelse Anweisungen. Obwohl an diesem Ansatz nichts falsch ist, kann das Verwalten verschachtelter ifelse Anweisungen eine langwierige Aufgabe sein und muss sorgfältig ausgeführt werden.

list_approach mit einer Liste list_approach ( list_approach )

Eine weniger offensichtliche Möglichkeit zur Konsolidierung von Ebenen besteht in der Verwendung einer Liste, in der der Name jedes Elements der gewünschte Kategoriename ist und das Element ein Zeichenvektor der Ebenen des Faktors ist, der der gewünschten Kategorie zugeordnet werden sollte. Dies hat den zusätzlichen Vorteil, dass Sie direkt mit dem levels des Faktors arbeiten, ohne neue Objekte zuweisen zu müssen.

levels(colorful) <- 
     list("Blue" = c("blue", "Blue", "BLUE"),
          "Green" = c("green", "gren"),
          "Red" = c("red", "Red", "RED"))
 [1] Green Blue  Red   Red   Blue  Red   Red   Red   Blue  Red   Green Green Green Blue  Red   Green
[17] Red   Green Green Red  
Levels: Blue Green Red

Benchmarking für jeden Ansatz

Die für die Ausführung dieser Ansätze erforderliche Zeit ist unten zusammengefasst. (Aus Platzgründen wird der Code zum Generieren dieser Zusammenfassung nicht angezeigt.)

Unit: microseconds
          expr     min      lq      mean   median      uq     max neval cld
        factor  78.725  83.256  93.26023  87.5030  97.131 218.899   100  b 
        ifelse 104.494 107.609 123.53793 113.4145 128.281 254.580   100   c
 list_approach  49.557  52.955  60.50756  54.9370  65.132 138.193   100 a

Der ifelse etwa doppelt so schnell wie der ifelse Ansatz. Mit Ausnahme von sehr, sehr großen Datenmengen werden die Unterschiede in der Ausführungszeit jedoch wahrscheinlich entweder in Mikrosekunden oder Millisekunden gemessen. Bei so kleinen Zeitunterschieden muss die Effizienz nicht die Entscheidung über den zu verwendenden Ansatz bestimmen. Verwenden Sie stattdessen einen vertrauten und komfortablen Ansatz, den Sie und Ihre Mitarbeiter bei der zukünftigen Überprüfung verstehen werden.

Faktoren

Faktoren sind eine Methode zur Darstellung kategorialer Variablen in R. Wenn ein Vektor x dessen Werte mit as.character() in Zeichen umgewandelt werden können, as.character() die Standardargumente für factor() und as.factor() jedem einzelnen Element von eine Ganzzahl zu der Vektor sowie ein Ebenenattribut und ein Beschriftungsattribut. Level sind die Werte, die x möglicherweise annehmen kann, und Labels können entweder das angegebene Element sein oder vom Benutzer festgelegt werden.

Um zu zeigen, wie Faktoren funktionieren, erstellen wir einen Faktor mit Standardattributen, benutzerdefinierten Ebenen und benutzerdefinierten Ebenen und Beschriftungen.

# standard
factor(c(1,1,2,2,3,3))
[1] 1 1 2 2 3 3
Levels: 1 2 3

Es kann vorkommen, dass der Benutzer weiß, dass die Anzahl der möglichen Werte, die ein Faktor annehmen kann, größer ist als die aktuellen Werte im Vektor. Dazu weisen wir die Stufen selbst in factor() .

factor(c(1,1,2,2,3,3),
         levels = c(1,2,3,4,5))
[1] 1 1 2 2 3 3
Levels: 1 2 3 4 5

Zu Stilzwecken möchte der Benutzer möglicherweise jeder Ebene Beschriftungen zuweisen. Standardmäßig sind Beschriftungen die Zeichendarstellung der Ebenen. Hier weisen wir für jede der möglichen Ebenen im Faktor Beschriftungen zu.

factor(c(1,1,2,2,3,3),
       levels = c(1,2,3,4,5),
       labels = c("Fox","Dog","Cow","Brick","Dolphin"))
[1] Fox Fox Dog Dog Cow Cow
Levels: Fox Dog Cow Brick Dolphin

Normalerweise können Faktoren nur mit == und != Verglichen werden, wenn die Faktoren die gleichen Pegel haben. Der folgende Vergleich von Faktoren schlägt fehl, obwohl sie gleich erscheinen, da die Faktoren unterschiedliche Faktorstufen haben.

factor(c(1,1,2,2,3,3),levels = c(1,2,3)) == factor(c(1,1,2,2,3,3),levels = c(1,2,3,4,5))
Error in Ops.factor(factor(c(1, 1, 2, 2, 3, 3), levels = c(1, 2, 3)),  : 
  level sets of factors are different

Dies ist sinnvoll, da aufgrund der zusätzlichen Pegel in der RHS nicht genügend Informationen zu jedem Faktor vorhanden sind, um sie sinnvoll miteinander zu vergleichen.

Die Operatoren < , <= , > und >= nur für geordnete Faktoren verwendet werden. Diese können kategoriale Werte darstellen, die noch eine lineare Reihenfolge haben. Ein geordneter Faktor kann erstellt werden, indem für die ordered = TRUE das ordered = TRUE Argument factor wird oder einfach die ordered Funktion verwendet wird.

x <- factor(1:3, labels = c('low', 'medium', 'high'), ordered = TRUE)
print(x)
[1] low    medium high  
Levels: low < medium < high

y <- ordered(3:1, labels = c('low', 'medium', 'high'))
print(y)
[1] high   medium low   
Levels: low < medium < high

x < y
[1]  TRUE FALSE FALSE

Weitere Informationen finden Sie in der Factor-Dokumentation .

Faktoren ändern und neu ordnen

Wenn Faktoren mit as.character erstellt werden, werden die levels von as.character auf die Eingaben angewendeten as.character gebildet und alphabetisch geordnet.

charvar <- rep(c("W", "n", "c"), times=c(17,20,14))
f <- factor(charvar)
levels(f)
# [1] "c" "n" "W"

In einigen Situationen ist die Behandlung der Standardreihenfolge der levels (alphabetische / lexikalische Reihenfolge) akzeptabel. Zum Beispiel, wenn man justs wollen plot die Frequenzen, wird dies das Ergebnis sein:

plot(f,col=1:length(levels(f)))

Geben Sie hier die Bildbeschreibung ein

Wenn Sie jedoch eine andere Reihenfolge der levels wünschen, müssen Sie dies im Parameter " levels oder " labels angeben (wobei darauf zu achten ist, dass sich die Bedeutung von "Reihenfolge" hier von den geordneten Faktoren unterscheidet, siehe unten). Es gibt viele Alternativen, um diese Aufgabe abhängig von der Situation auszuführen.

1. Definieren Sie den Faktor neu

Wenn es möglich ist, können wir den Faktor mithilfe des levels in der gewünschten Reihenfolge neu erstellen.

ff <- factor(charvar, levels = c("n", "W", "c"))
levels(ff)
# [1] "n" "W" "c"
 
gg <- factor(charvar, levels = c("W", "c", "n"))
levels(gg)
# [1] "W" "c" "n"

Wenn sich die Eingangspegel von den gewünschten Ausgangspegeln unterscheiden, verwenden wir den labels Parameter, der bewirkt, dass der levels Parameter ein "Filter" für akzeptable Eingabewerte wird, aber die endgültigen Werte für "Level" für den Faktor-Vektor als Argument belassen labels :

fm <- factor(as.numeric(f),levels = c(2,3,1),
             labels = c("nn", "WW", "cc"))
levels(fm)
# [1] "nn" "WW" "cc"

fm <- factor(LETTERS[1:6], levels = LETTERS[1:4],  # only 'A'-'D' as input
                 labels = letters[1:4])            # but assigned to 'a'-'d'
fm
#[1] a    b    c    d    <NA> <NA>
#Levels: a b c d

2. Verwenden Sie die relevel Funktion

Wenn eine bestimmte level die erste sein muss, können wir relevel . Dies geschieht beispielsweise im Rahmen der statistischen Analyse, wenn eine base zum Testen der Hypothese erforderlich ist.

g<-relevel(f, "n") # moves n to be the first level
levels(g)
# [1] "n" "c" "W"  

Wie zu bestätigen ist, sind f und g gleich

all.equal(f, g)
# [1] "Attributes: < Component “levels”: 2 string mismatches >"
all.equal(f, g, check.attributes = F)
# [1] TRUE

3. Umordnungsfaktoren

Es gibt Fälle , in denen wir müssen reorder die levels auf einer Reihe basieren, ein Teilergebnis, eine berechnete Statistik oder frühere Berechnungen. Lassen Sie uns basierend auf den Frequenzen der levels neu ordnen

table(g)
# g
#  n  c  W 
# 20 14 17 

Die reorder ist generisch (siehe help(reorder) ), benötigt aber in diesem Zusammenhang: x , in diesem Fall den Faktor; X ein numerischer Wert der gleichen Länge wie x ; und FUN , eine Funktion, die auf X anzuwenden ist und nach dem Pegel des x berechnet wird, der die Reihenfolge der levels , standardmäßig erhöht. Das Ergebnis ist derselbe Faktor, wenn die Ebenen neu angeordnet werden.

g.ord <- reorder(g,rep(1,length(g)), FUN=sum) #increasing
levels(g.ord)
# [1] "c" "W" "n"

Um die Reihenfolge zu verringern, betrachten wir negative Werte ( -1 )

g.ord.d <- reorder(g,rep(-1,length(g)), FUN=sum)
levels(g.ord.d)
# [1] "n" "W" "c"

Wieder ist der Faktor derselbe wie bei den anderen.

data.frame(f,g,g.ord,g.ord.d)[seq(1,length(g),by=5),] #just same lines
#    f g g.ord g.ord.d
# 1  W W     W       W
# 6  W W     W       W
# 11 W W     W       W
# 16 W W     W       W
# 21 n n     n       n
# 26 n n     n       n
# 31 n n     n       n
# 36 n n     n       n
# 41 c c     c       c
# 46 c c     c       c
# 51 c c     c       c

Wenn es eine quantitative Variable gibt, die sich auf die Faktorvariable bezieht, könnten wir andere Funktionen verwenden, um die levels neu zu ordnen. Lets nehmen die iris ( help("iris") für weitere Informationen), zum Neuordnen der Species Faktor sein Mittelwert mit Sepal.Width .

miris <- iris  #help("iris") # copy the data
with(miris, tapply(Sepal.Width,Species,mean))
#    setosa versicolor  virginica 
#     3.428      2.770      2.974 

miris$Species.o<-with(miris,reorder(Species,-Sepal.Width))
levels(miris$Species.o)
# [1] "setosa"     "virginica"  "versicolor"

Das übliche boxplot (sprich: with(miris, boxplot(Petal.Width~Species) ) zeigt die Spezies in dieser Reihenfolge: setosa , versicolor und virginica . Sepal.Width den geordneten Faktor verwenden, erhalten wir die Art nach ihrem mittleren Sepal.Width :

boxplot(Petal.Width~Species.o, data = miris,
        xlab = "Species", ylab = "Petal Width",
        main = "Iris Data, ordered by mean sepal width", varwidth = TRUE,
        col = 2:4) 

Geben Sie hier die Bildbeschreibung ein

Außerdem können Sie die Namen von levels ändern, sie in Gruppen zusammenfassen oder neue levels hinzufügen. Dafür verwenden wir die Funktion der gleichen levels .

f1<-f
levels(f1)
# [1] "c" "n" "W"
levels(f1) <- c("upper","upper","CAP") #rename and grouping
levels(f1)
# [1] "upper" "CAP" 

f2<-f1
levels(f2) <- c("upper","CAP", "Number") #add Number level, which is empty
levels(f2)
# [1] "upper"  "CAP"    "Number"
f2[length(f2):(length(f2)+5)]<-"Number" # add cases for the new level
table(f2)
# f2
#  upper    CAP Number 
#     33     17      6 

f3<-f1
levels(f3) <- list(G1 = "upper", G2 = "CAP", G3 = "Number") # The same using list
levels(f3)
# [1] "G1" "G2" "G3"
f3[length(f3):(length(f3)+6)]<-"G3" ## add cases for the new level
table(f3)
# f3
# G1 G2 G3 
# 33 17  7 

- geordnete Faktoren

Schließlich wissen wir, dass ordered Faktoren sich von den factors unterscheiden. Der erste wird zur Darstellung von Ordinaldaten verwendet , der zweite für die Arbeit mit Solldaten . Zunächst ist es nicht sinnvoll, die Reihenfolge der levels für geordnete Faktoren zu ändern, aber wir können die labels ändern.

ordvar<-rep(c("Low", "Medium", "High"), times=c(7,2,4))

of<-ordered(ordvar,levels=c("Low", "Medium", "High"))
levels(of)
# [1] "Low"    "Medium" "High" 

of1<-of
levels(of1)<- c("LOW", "MEDIUM", "HIGH")
levels(of1)
# [1] "LOW"    "MEDIUM" "HIGH"
is.ordered(of1)
# [1] TRUE
of1
# [1] LOW    LOW    LOW    LOW    LOW    LOW    LOW    MEDIUM MEDIUM HIGH   HIGH   HIGH   HIGH  
# Levels: LOW < MEDIUM < HIGH

Wiederherstellungsfaktoren von Null

Problem

Faktoren werden verwendet, um Variablen darzustellen, die Werte aus einer Reihe von Kategorien annehmen, die als Pegel in R bekannt sind. Zum Beispiel könnte ein Experiment durch das Energieniveau einer Batterie mit vier Stufen charakterisiert werden: leer, niedrig, normal und voll. Für fünf verschiedene Probenahmestellen könnten diese Werte wie folgt definiert werden:

voll , voll , normal , leer , niedrig

In Datenbanken oder anderen Informationsquellen erfolgt die Handhabung dieser Daten normalerweise über willkürliche, ganzzahlige Indizes, die den Kategorien oder Ebenen zugeordnet sind. Wenn wir davon ausgehen, dass wir für das gegebene Beispiel die Indizes wie folgt zuordnen würden: 1 = leer, 2 = niedrig, 3 = normal, 4 = voll, dann könnten die 5 Abtastwerte wie folgt codiert werden:

4 , 4 , 3 , 1 , 2

Es kann vorkommen, dass Sie aus Ihrer Informationsquelle, z. B. einer Datenbank, nur die codierte Liste von Ganzzahlen und den Katalog haben, der jede Ganzzahl mit jedem Stufenschlüsselwort verknüpft. Wie kann aus diesen Informationen ein Faktor von R rekonstruiert werden?

Lösung

Wir simulieren einen Vektor von 20 Ganzzahlen, der die Stichproben darstellt, von denen jede einen von vier verschiedenen Werten haben kann:

set.seed(18)
ii <- sample(1:4, 20, replace=T)
ii

[1] 4 3 4 1 1 3 2 3 2 1 3 4 1 2 4 1 1

Der erste Schritt besteht darin, aus der vorherigen Reihenfolge einen Faktor zu erstellen, in dem die Ebenen oder Kategorien genau die Zahlen von 1 bis 4 sind.

fii <- factor(ii, levels=1:4) # it is necessary to indicate the numeric levels
fii

[1] 4 3 4 1 1 3 2 3 2 1 3 4 1 2 4 1 1
Stufen: 1 2 3 4

Jetzt einfach, müssen Sie den Faktor kleiden bereits mit dem Index - Tags erstellt:

levels(fii) <- c("empty", "low", "normal", "full")
fii

[1] full normal full empty leer normal niedrig normal niedrig leer
[11] normal voll leer niedrig voll leer normal leer voll leer
Levels: leer niedrig normal voll



Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow