Programmering i R - Fra variabler til visualiseringer

Denne artikkelen ble publisert som en del av Data Science Blogathon

R programmeringsspråk ble utviklet for statistisk databehandling og grafikk som gjør det til en av de ønskede kandidatene for datavitenskap og analyse. Selv om det kanskje ikke er så populært blant nykommerne i feltet, favoriserer mange veteraner og erfarne dataforskere R fremfor Python.

Selv om meningene kan variere fra individ til individ, er her en fin artikkel som sammenligner de viktigste forskjellene mellom språkene og diskuterer hvorfor det er denne pågående krigen om tittelen Beste programmeringsspråk for datavitenskap:

R eller Python? Årsaker bak denne skykrigen | Shankar_DK

Selv om jeg ikke er på langt nær så kvalifisert til å kommentere dette emnet, vil jeg si at hver nybegynner skal prøve begge språkene og bestemme selv hva de vil, i stedet for å følge mengden. Etter mine egne råd begynte jeg nylig å lære R ettersom semesteret mitt er over og jeg ikke hadde noe bedre å gjøre, og tenkte å dele læringsveien min med leserne mine.

Som jeg sa, jeg lærer R for første gang selv, så hvis det er noen feil, eller forbedringer, eller noen forslag, vil jeg gjerne høre fra dere i kommentarfeltet nedenfor. Jeg er sikker på at denne opplæringen vil være veldig nyttig for nybegynnerleserne mine, så la oss komme i gang!

Datasett brukt:

1. Titanic - Maskinlæring fra katastrofe

2. Irisarter

3. Boligpriser – avanserte regresjonsteknikker

1. Introduksjon

2) Variabler og tildeling

3) Datastrukturer

• vektor
• Matriser og matriser
• lister
• Faktorer
• Datarammer

4) Indeksering, skjæring og skritt

• Vektorer og matriser
• Lister og datarammer

5) Importere data

6) Kontrollerklæringer

• uttalelse
• If/else If/else-erklæringen
• Mens sløyfe
• neste og bryte uttalelse
• For sløyfe
• Nestet for løkke

7) Funksjoner

8) DataFrame-manipulasjon ved hjelp av dplyr

• å velge()
• filter()
• arrangere()
• endre navn på ()
• mutere()

9) Plotte med R

• histogram
• Boksplott
• Scatterplot
• Linjeplott
• Barplot
• Kake diagram

10) Visualisering ved hjelp av ggplot2

• Scatterplot
• histogram
• Boksplott
• Barplot
• Tetthet Plot
• Fiolinplot
• Kake diagram
• Linjeplott
• Kart

11) Korrelasjon varmekart ved hjelp av korrplott

12) Sluttnotert

Introduksjon

R er et programmeringsspråk i tillegg til et gratis statistisk databehandlingsmiljø. Den ble utgitt i 1993 og er en dialekt av S programmeringsspråk. Akkurat som Python, har R rundt 13000 bibliotekpakker for dataanalyse, statistiske metoder og visualiseringer. Les de offisielle dokumentene for flere detaljer, og nå er det tid for det tekniske og spennende!

Variabler og tildeling i R

I R er oppdragsoperatøren <-

x <- 21 # tilordne verdien 5 til variabel xx # skriv ut verdien av x

produksjon:

21

Vi bruker parentes () for å tilordne en verdi og skrive den ut samtidig.

(y <- 5) # tildeler verdi 5 til variabelen y og skriver ut verdien

produksjon:

5

Datastrukturer i R

Akkurat som alle andre programmeringsspråk, har R sine beholdere kalt datatyper for å lagre verdier eller informasjon. R har 5 primære datatyper:

1. heltall
2. dobles
3. logisk
4. tegn
5. komplekse

Bortsett fra disse er det sekundære datatyper i R, som er mer nyttige og ofte brukt

• vektor: sekvens av primære datatyper
• Matriser og matriser: en flerdimensjonal samling av homogene vektorer
• lister: vektorer med enten homogen eller heterogen type (dvs. kan inneholde forskjellige eller lignende typer grunnleggende datatyper)
• Faktorer: kategoriske eller ordinære data
• Dataramme: flerdimensjonalt utvalg av mulige heterogene datatyper

La oss se på noen eksempler på disse sekundære datatypene:

1) Vektor

Det er en sekvens av lignende datatyper. Sammenknyttingsfunksjonen c() kan brukes til å slå sammen data for å lage vektorer. Enkle sekvenser kan opprettes ved å bruke kolon ':'-operatoren.

a <- c(0.1, 0.9) # numerisk a b <- c(TRUE, FALSE) # logisk b d <- c("a", "b", "c") # tegn d e <- 1:10 # heltall e f <- c(2+4i) # kompleks f

produksjon:

De seq() funksjon kan også brukes til å lage en vektor med en bestemt sekvens. Denne funksjonen godtar også en trinnstørrelse med standardverdi 1.

# En sekvens av tall fra 1 til 10 med en trinnstørrelse på 1. seq(1, 10)

produksjon:

# En sekvens av tall i trinnstørrelse på 2 seq(0, 20, by=2)

produksjon:

# En sekvens av tall fra 10 til 20 med lengde 5 (de er like fordelt) seq(10, 20, len=5)

produksjon:

De rep() funksjon brukes til å lage en vektor ved å replikere spesifiserte verdier

rep(1:3, ganger=3) # repetisjon (1,2,3) 3x rep(4:6, 2) # repetisjon (4,5,6) 2x rep(1:3, hver=3) # repetisjon hver av (1,2,3) 3x rep(c('one', 'to', 'TRUE'), ganger=1:3) # repeat ('one', 'to', 'TRUE') første element 1x, andre element 2x og tredje element 3x

produksjon:

2) Matriser og matriser

Funksjonen array () brukes til å lage arrays og matrise() for matriser. Matriser kan konverteres til matriser ved å endre svak() attributt.

Rad- eller kolonnematriser kan opprettes ved hjelp av rbind() og cbind() funksjoner.

matte <- matrise(1:12, nrow=3, ncol=4) mat dim(mat)

produksjon:

arr <- array(1:12) arr

produksjon:

dim(arr) <- c(3,4) arr

produksjon: 

x <- 1:5 y <- 6:10 cbind(x, y) rbind(x, y)

produksjon:

3) Lister

Akkurat som python-lister, er listene i R heterogene beholdere og opprettes ved hjelp av liste() funksjon.

L <- list(10, 'navn', TRUE, 0.5) L

produksjon:

1. 10
2. 'Navn'
3. TRUE
4. 0.5

l <- liste(x=1:3, y=c('a', 'b', 'c'), z=c(T, F, F)) l

produksjon:

4) Faktorer

Kategoriske og ordinære data er representert ved å bruke faktorer i R ved å bruke faktor() funksjon. Faktornivåer inneholder alle mulige verdier elementene kan ta.

f1 <- faktor(rep(1:3, ganger=2)) f1 f2 <- faktor(c('a', 7, 'blå', 'blå')) f2

produksjon:

x <- faktor(c("Sant", "Usant", "Usant", "Sant", "Sant"), nivåer = c("Usant", "Sant")) x

produksjon: 

z <- factor( c("Thr", "Thr", "Fre", "Thr", "ons", "ons", "man", "tir"), levels = c("man", "tirs ", "ons", "tor", "fre"), bestilt = TRUE ) z

produksjon:

faktor(c("H", "H", "T", "H", "T")) table(faktor(c("H", "H", "T", "H", "T" )))

produksjon:

5) Datarammer

i motsetning til Python, har R en innebygd DataFrame-beholder og fungerer på samme måte som den i Pandas. Vi bruker data.frame()-funksjonen der argumentene er vektorer:

d <- c(1,2,3,4) e <- c('rød', 'gul', 'grønn', NA) f <- c(TRUE, TRUE, FALSE, TRUE) mindataramme <- data. ramme(d,e,f) mindataramme

produksjon:

Vi kan redigere navnene på kolonnen ved å bruke navn() funksjon:

names(mydataframe) <- c("ID", "Farge", "Bestått")

mydataframe

produksjon:

Eller du kan inkludere navnet på tidspunktet for opprettelse av dataramme:

dataframe3 <- data.frame(Alder=c(50,35,71), Navn=c('Joe', 'April', 'Brown'), Passed=c(TRUE, FALSE, TRUE)) dataramme3

produksjon:

Vi kan få tilgang til de individuelle kolonnene (vektorene) ved å bruke $-tegnet og navnet på vektoren:

# får 'Color'-vektoren fra DataFrame mydataframe$Color

produksjon:

'rød' . 'gul'. 'grønn'. NA

Indeksering, skjæring og skritt i R

For å indeksere eller velge elementer bruker vi [, [[ eller $-operatoren.

1) Vektorer og matriser

vi kan i hovedsak sette 4 typer verdier i parentes [

• en vektor av positive heltall, i hvilket tilfelle de spesifiserte elementene trekkes ut,
• en vektor av negative heltall, der disse elementene er fjernet,
• en logisk operator med samme lengde som den aktuelle vektoren returnerer en boolsk, eller
• en tegnvektor, hvor elementer trekkes ut

x 10 # returnerer logisk (T/F) hvis elementet av x er større enn 10 x[x>10] # trekker ut elementer av x som er større enn 10

produksjon:

x <- 1:5 # tilordne en sekvens på 0 til 20 i trinn på 2 til variabel x navn(x) <- c("a", "b", "c", "d", "e") # tilordne navn til vektor x x # print x x[c("a","c","e")] # trekke ut deler av vektor x etter navn

produksjon:

Tilsvarende indeksering kan gjøres på matriser og matriser. Her brukes kommaene for å spesifisere dimensjonen:

a <- 1:10 # array dim(a) <- c(2, 5) # gjør det til en matrise aa[1,1] # trekk ut element av matrise a ved rad=1, col=1 a[2, ] # trekk ut den andre raden med matrise a a[, 5] # trekk ut den femte kolonnen i matrise a (alle rader) a[, 2:4] # trekk ut kolonnene 2 til 4 i matrise a (alle rader)

produksjon:

2) Lister og DataFrame

Når vi bruker lister og DF bruker vi [[ og $ også.

mylist <- liste(Logikk = c(TRUE, FALSE, TRUE), Verdi = 1:3, Navn = c("eple", "mac", "pc")) mylist # skriv ut listen minliste[1] # skriv ut det første elementet i listen mylist$Name # skrives ut med navn

produksjon:

mylist[2] # trekker ut det andre elementet av mylist typeof(mylist[2]) # sjekker typen mylist[2] mylist[[2]] # verdier av mylist[2] typeof(mylist[[2]]) # type myliste[2]

produksjon:

Importere data i R

1. Den read.table() funksjonen brukes til å importere tabelldata som en dataramme.

2. format – read.table( file_path , header = True, sep=” , ” )

3. header = True forteller R at dataene har et navn på kolonnene og bruker dermed den første raden i filen som kolonnenavn. False er standardverdien hvis den ikke er spesifisert, da vil programmet anta at filen ikke har noen overskrift.

4. september spesifiserer skilletegnet som brukes i kildefilen, for eksempel .csv filer brukes til å lagre data i Kaggle, derfor skal vi bruke kommaet ” ,” som skilletegn for å laste inn dataene for koden vår nedenfor.

Eksempel: Importere Iris-datasettet og se de første 5 oppføringene:

path_iris = '../input/iris/Iris.csv' iris <- read.table(file=path_iris, header= TRUE, sep =',') iris[1:5, ]

produksjon:

Importere Titanic-datasett og se de første 5 oppføringene:

path_titanic = '../input/titanic/train.csv' titanic <- read.table(file=path_titanic, header= TRUE, sep =',') titanic[1:5, ]

produksjon:

Kontrolluttalelser

Controloll-setninger lar oss introdusere logikk i kodene våre. Utsagnene liker Hvis, hvis annet og løkker kjøres på samme måte som Python, så denne delen kan være enklere for de som allerede er kjent med den.

1) If()-setning

Syntaks:

if (Tilstand)

{ Erklæring }

{statement}-delen av koden kjøres bare hvis {condition}-delen av If-setningen er oppfylt. Hvis betingelsen ikke er oppfylt, hopper R-tolken over det segmentet av koden.

Eksempel:

if (1 == 1) { print("ja!!") }

produksjon:

ja!!

OBS:

• If()-setningen kan bare kontrollere et enkelt element, ikke en vektor. Hvis det brukes på en vektor, vil det bare sjekke om det første elementet tilfredsstiller betingelsen.
• Hvis det første elementet ikke tilfredsstiller betingelsen, vil ingen av setningene bli utført, og en ikke-dødelig advarsel vil bli utstedt som indikerer at hoveddelen av if()-setningen ikke er utført. any() eller all() funksjon skal brukes for å sjekke sannheten på en vektor.
• For enkeltlinjede utsagn kan de krøllete tannreguleringene utelates, men det er god praksis å beholde dem.

Eksempel:

x =5) {x^2}

x 0)) {x^2} x =10)) {x^2}

produksjon:

2) If/else If/else-erklæringen

Syntaks:

if (Tilstand) { Statement }

eller hvis { Erklæring }

ellers { Erklæring }

(x <- runif(1, 0, 10)) # tegne et tilfeldig tall fra en enhetlig dist s/h 0 nd 1 if(x < 3) { # if x <3 tilordne verdi 10 til variabel yy 3 && x < 6) { # else hvis x er mellom 3 og 6, tilordne verdi 0 til variabel yy <- 0 } else { # else tilordne -10 til variabel yy <- -10 } y

produksjon:

2.79287837212905 10

3) Mens loop

En while-løkke starter med å sjekke en tilstand. Hvis oppfylt, begynner loopen og alle setningene inne i kroppen blir utført. Når kroppen slutter, kontrolleres tilstanden igjen, og hvis den er fornøyd, fortsetter løkken.

Syntaks:

i = 0

mens (i<5) {

print(i^2)

i = i + xnumx

}

i = 0 # initialiser i while (i < 10){ # mens i = 10 }

produksjon:

[1] "hei" [1] "hei" [1] "hei" [1] "hei" [1] "hei" [1] "hei" [1] "hei" [1] "hei" [1] ] "hei" [1] "hei"

4) neste og bryte uttalelse

• neste brukes til å hoppe over en enkelt iterasjon av en sløyfe
• bryte brukes til å gå ut av løkken der og da

# Hopp over de første 5 iterasjonene for(i i 1:10) { if(i <= 5) { next } print(i^2) }

produksjon:

[1] 36 [1] 49 [1] 64 [1] 81 [1] 100

# skriv ut i til 5 og stopp sløyfen for(i i 1:10) { print(i) if(i > 5) { break } }

produksjon:

[1] 1 [1] 2 [1] 3 [1] 4 [1] 5 [1] 6

5) For loop

For løkker har et forhåndsbestemt antall iterasjoner og bruk en variabel for å gjøre det. Mest brukt til å iterere over gjentakbare objekter akkurat som python.

Syntaks:

forum (iterator) {
Uttalelse }

for (i i 1:5){ print(i + 1) }

produksjon:

[1] 2 [1] 3 [1] 4 [1] 5 [1] 6

De seq_along() funksjonen er analog med len () funksjon i python, brukes til å generere en heltallssekvens basert på lengden på iteratoren.

produksjon:

[1] "man" [1] "tir" [1] "ons" [1] "tor" [1] "fre" [1] "lør" [1] "søn"

6) Nestet for løkker

• Nested for loops brukes til å jobbe med høyere dimensjonale objekter som lister eller matriser.
• Men for mye hekking kan ødelegge lesbarheten til koden, så det anbefales vanligvis å holde antall reir på maks. 2-3.

x <- matrise(1:6, 2, 3) for(i in seq_len(nrow(x))) { for(j in seq_len(ncol(x))) { print(x[i, j]) } }

produksjon:

[1] 1 [1] 3 [1] 5 [1] 2 [1] 4 [1] 6

Funksjoner

Funksjoner er en bunt med kommandoer som brukes for å oppnå et bestemt resultat. De brukes vanligvis til å redusere redundans i kode.

Syntaksen for å lage en funksjon i R er:

min funksjon <- funksjon(arg1, arg2)
{
kode for å utføre
}

Navnet på denne funksjonen er min funksjon og godtar 2 argumenter. Funksjoner kan enten utføre noen instruksjoner eller kan brukes til å returnere verdier. For å bruke funksjonen skriver vi ganske enkelt:

min funksjon(var1, var2)

Eksempel 1:

La oss lage en funksjon ved å bruke Pythagoras-teoremet. Teoremet sier det "Kvadraten av lengden på hypotenusen til en rettvinklet trekant er lik summen av kvadratene av lengden på de to andre sidene."

Hvor a, b og c er sidene i den rettvinklede trekanten. La oss nå lage en funksjon for å finne hypotenusen når sidene er gitt:

pyth <- function(x, y) { return(sqrt((x)^2 +(y)^2)) } pyth(3, 4)

produksjon:

5

Eksempel 2:

La oss skrive en funksjon for å beregne standardavviket til alle elementene i en vektor.

stdev <- function(x) { s <- sqrt(sum((x - mean(x))^2)/(lengde(x)-1)) s } z <- rnorm(20) stdev(z)

produksjon:

1.0321309737329

DataFrame-manipulasjon ved hjelp av dplyr i R

I den forrige artikkelen lærte vi hvordan du importerer strukturerte data i form av DataFrame til notatboken vår ved å bruke base R. I denne delen vil vi lære hvordan du manipulerer disse dataene for å trekke ut slutninger og lage visualiseringer.

dplyr kan tenkes på som pandaer av R. Det er mye man kan gjøre med en DataFrame, og det blir hektisk å gjøre det i native R, det er der dplyr kommer inn. Den har et sett med "verb", et begrep laget av dem selv, som vil hjelpe brukeren til å løse de fleste vanlige manipulasjonsutfordringene. Noen av disse "verbene" er:

• select()   -  velger variabler i henhold til navnene deres
• filter()   -  velger saker i henhold til deres verdier
• arrange()  -   omorganiserer rader
• mutate()   -   legger til og bevarer en eksisterende variabel
• summarise()-  oppretter en oppsummeringsverdi fra flere verdier
• group_by() -  hjelper til med å utføre batchoperasjoner på grupper

Nå skal vi demonstrere bruken av de ovennevnte "verbene"

# importerer bibliotekbibliotek(dplyr)

importere data:

path_iris = '../input/iris/Iris.csv' iris <- read.table(file=path_iris, header= TRUE, sep =',') iris[1:5, ] path_titanic = '../input/ titanic/train.csv' titanic <- read.table(file=path_titanic, header= TRUE, sep =',') titanic[1:5, ]

produksjon:

1. velg()

data(iris) names(iris)[1:3] # trekk ut de tre første kolonnene i iris-datasettet

produksjon:

'Begerbladlengde' . 'Sepal.Width' . 'Petal.Length'

df <- select(iris, sepal.Length:Petal.Length) head(df)

produksjon:

vi bruker tegnet '-' inni å velge() å utelate variabler vi ikke vil ha.

df <- select(iris, -(Art)) head(df, 3)

produksjon:

En annen fantastisk funksjon ved select() er at den lar oss velge rader basert på bestemte mønstre. Dette gjøres ved hjelp av "begynner med"() og "slutter med"()

df_sepal <- select(iris, "starts_with"('Sepal')) head(df_sepal, 3)

2. filter()

Akkurat som å velge() ble brukt til å trekke ut kolonner, filter() brukes til å trekke ut rader i DataFrame. Det ligner på delsett() funksjon i opprinnelig R.

# filtrer observasjonene med begerbladlengde mer enn 6 cm iris_filt 6.0) str(iris_filt)

produksjon:

data(iris) iris_filt 6.0 & Petal.Length < 6.0 ) head(iris_filt)

produksjon:

3. arrangere()

Denne funksjonen brukes til å omorganisere DataFrame i henhold til en bestemt kolonne. Standard er stigende rekkefølge. La oss omorganisere vår titaniske DataFrame etter alder, fra yngste til eldste.

titanic_age_arraned <- arrange(titanic_age_arraned, Age) head(titanic_age_arraned, 3) tail(titanic_age_arraned, 3)

produksjon:

4. gi nytt navn ()

Rename()-funksjonen brukes til å endre kolonnenavnene. syntaksen er:

dataramme <- rename( dataramme, 'nytt_navn_1′ = gammelt_navn_1', 'nytt_navn_2' = gammelt_navn_2'….)

her er et eksempel:

hode (iris, 3)

produksjon:

iris <- rename(iris, 'sepal_length_[cm]'= Sepal.Length, 'sepal_width_[cm]'=Sepal.Width, 'petal_length_[cm]'=Petal.Length, 'petal_width_[cm]'=Petal.Width ) hode(iris, 3)

produksjon:

5. mutere()

mutere() brukes til å utlede en ny kolonne fra en eksisterende kolonne, uten å endre den overordnede kolonnen. La oss for eksempel lage en ny kolonne i Iris-datarammen som viser lengde-til-bredde-forholdet mellom kronblader og begerblader for alle oppføringene.

data(iris) iris <- mutate(iris, 'Petal_L2W_ratio' = Petal.Length/Petal.Width, 'Sepal_L2W_ratio' = Sepal.Length/Sepal.Width) head(iris, )

produksjon:

Det er en lignende funksjon, transmute() som i hovedsak gjør det samme som mutere(), men sletter alle kolonner som forblir ikke-transformerte :

iris <- transmute(iris, 'Petal_L2W_ratio' = Petal.Length/Petal.Width, 'Sepal_L2W_ratio' = Sepal.Length/Sepal.Width) head(iris, 3)

produksjon:

Plotte med R

Visualisering av data er en svært viktig del av ethvert datavitenskapelig prosjekt. Det hjelper oss å formidle budskapet og historien dataene forteller. R har sitt eget bibliotek for visualisering kalt ggplot2 som er et av de beste visualiseringsbibliotekene der ute. Vi skal dekke ggplot2 senere i denne artikkelen, men først, la oss bli kjent med visualiseringsteknikkene som er hjemmehørende i R-språket.

1. Histogram

alder <- titanic$Age hist(age, xlab='Age', main="Histogram of passengers Age")

2. Boksplott

y <- rnorm(100, gjennomsnitt=80, sd=3) boxplot(y, xlab='Y-variable', main='boxplot of random variabel')

3. Scatterplot

x <- runif(20) y <- 2 +3*x + rnorm(20) plot(x, y, xlab='x-axis', ylab='y-axis', main='Tittel her takk', )

4. Linjeplott

x <- seq(-4, 4, len=100) y <- dnorm(x, mean=0, sd=1) plot(x, y, type='l', col='blue') title(' Tetthet av standard normal')

5. Barplot

data <- data.frame( name=c("A","B","C","D","E") , value=c(3,12,5,18,45) ) barplot(data $value, names.arg=data$name, horiz=FALSE, xlab='Names', ylab='Value', main='Barplot')

6. Piechart

skiver <- c(36448.797, 26288.683, 23596.661, 3028.636, 2605.979, 1895.095) etiketter <- c("Asia", "Nord-Amerika", "Europa", "Sør-Amerika", "Africa" skiver, etiketter = etiketter, radius = 2.0, main="2021 Nominell BNP (Bilions of $)")

Visualisering ved hjelp av ggplot2

ggplot2-biblioteket er bygget rundt ideene introdusert i en bok kalt Grammatikken for grafikk (statistikk og databehandling) Det hjelper oss å lage komplekse plott med letthet ved å bruke 3 hovedkomponenter: data, koordinatsystem, og geometri. Vi kan også fortelle ggplot2 hvilken estetikk som skal brukes som farge, form, størrelse osv.

syntaks:

ggplot(data, aes())+
geom()

data – datasett brukt

aes() – estetikk

geom() – geometri. her har du mange alternativer. Jeg foreslår at du sjekker ut dette jukseark for en mye bedre forståelse av dette konseptet

La oss komme i gang!

# importer ggplot2 bibliotekbibliotek(ggplot2)

1. Scatterplot

p1 <- ggplot(iris, aes(x = Sepal.Length, y = Sepal.Width, color = Species)) + geom_point() p1

2. Histogram

p2 <- ggplot(iris, aes(x = Kronblad.Lengde, fyll = Art)) + geom_histogram(binwidth=0.2, alfa=0.75) p2

3. Boksplott

p3 <- ggplot(iris, aes(x = Art, y = Sepal.Length, fill = Art)) + geom_boxplot() p3

4. Barplot

karakterer <- c('A', 'B', 'C', 'D', 'F') teller <- c(8, 26, 44, 15, 7) data_grades <- data.frame(x = karakterer , y = count) p4 <- ggplot(data_grades, aes(x = grades, y = count, fill = grades)) + geom_col(alpha=0.6) p4

5. Tetthetsplott

p5 <- ggplot(iris, aes(x = Sepal.Length, fill = Art)) + geom_density(alpha=0.35) p5

6. Fiolinplott

p6 <- ggplot(iris, aes(x = Art, y = Begerblad. Lengde, fyll = Art)) + geom_fiolin(alfa=0.6) p6

7. Sektordiagram

OBS: For å lage et kakediagram må vi bruke en kombinasjon av geom_bar() og coord_polar()

skiver <- c(36448.797, 26288.683, 23596.661, 3028.636, 2605.979, 1895.095) etiketter <- c("Asia", "Nord-Amerika", "Europa", "Sør-Amerika", "Og-Africa"), data - data.frame( verdier = skiver, grupper = etiketter ) ggplot(data_gdp, aes(x="", y=verdier, fyll=grupper)) + geom_bar(stat="identitet", alpha=0.5) + coord_polar(" y", start=0) + theme_void() # denne linjen brukes til å tømme bakgrunnsnettet

8. Linjeplot

# opprette et nytt datasett x <- seq(0, 1000, len=500) y <- log(x + 1) data <- data.frame( x = x, y = y) # linjeplott ggplot(data, aes (x=x, y=y))+ geom_line()

9. Kart

## tilpasning av https://www.maths.usyd.edu.au/u/UG/SM/STAT3022/r/current/Misc/data-visualization-2.1.pdf data <- data.frame(assault = USArrests$ Assault, state = tolower(rownames(USAarrests))) map <- map_data("state") map_plot <- ggplot(data, aes(fill = assault)) + geom_map(aes(map_id = state), map = map,) + expand_limits(x = map$lang, y = map$lat)+ scale_fill_continuous(low = "lyseblå", høy = "laks") map_plot

Korrelasjon Heatmap ved hjelp av korrplott

Et korrelasjonsvarmekart er nyttig for å plotte korrelasjonen mellom flere variabler. I dette eksemplet skal vi bruke biblioteket korrplott å lage et korrelasjonsvarmekart på husprisdatasettet.

#importing library library(corrplot)

options(repr.plot.width = 10, repr.plot.height = 10) numeric_var <- names(house)[which(sapply(house, is.numeric))] house_cont <- house[numeric_var] korrelasjoner <- cor( na.omit(house_cont[,-1])) corrplot(correlations, method="square", type='lower', diag=FALSE)

sluttnoter

I denne artikkelen startet vi med det grunnleggende og så hva som er variabler og hvordan du tilordner verdier til dem. Deretter ble vi kjent med de opprinnelige datatypene og vanlige datastrukturene som brukes i R. Deretter lærte vi hvordan vi kunne trekke ut ønskede deler fra disse datastrukturene. Så lærte vi endelig hvordan man importerer data og hvordan man bruker forskjellige kontrollstrukturer som løkker og betingede utsagn i R.

Deretter ble vi kjent med dataanalysedelen av bruk av R. Vi lærte å lage tollfunksjoner og begynte deretter med å manipulere datarammer ved hjelp av dplyr. Deretter dykket vi inn i visualiseringer ved å bruke både native R og et robust viz-bibliotek kalt gglot2. Takk for at du leste artikkelen min. Jeg håper du likte den.

Du kan lese mine andre artikler på:

Sion | Forfatter ved Analytics Vidhya

Referanser

Bilde 1: https://www.r-project.org/logo/

Media vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn.

Kilde: https://www.analyticsvidhya.com/blog/2021/09/programming-in-r-from-variables-to-visualizations/