Az R statisztikai számításokra és adatok ábrázolásra létrehozott programnyelv. Teljes mértékben ingyenes és nyílt forráskódú, illetve egyaránt használható Unix/Linux, MS Windows és MacOS operációs rendszereken.

Ebben a notebookban a teljesség igénye nélkül betekintőt adunk az R használatáról. A notebook tartalmának megértéséhez szükséges, hogy a hallgatók tisztában legyenek az alapvető numerikus és statisztikai módszerekkel.

Hasznos linkek az R programozásról:

R alapok:

Minden a segítséggel kezdődik:

A help() vagy a ? parancs elindítja a központi keresőfelületet.

In [1]:
help(median)
In [2]:
?median

Csomagok

Az R-ben a külső csomagokat a library("csomag neve") parancs segítségével lehet betölteni:

In [3]:
library(base)

A kernel indításakor a base nevű csomag automatikusan betöltésre kerül. Ebben a notebookban a base csomag függvényeivel és adat struktúráival fogunk megismerkedni.

Segítség a csomagokról:

In [4]:
library(help = base)

R mint számológép (ez olyan mint a python):

Az R-ben a számok alapműveletek és néhány előre definiált mathematikai konstans a python-ban már megszokott módon működnek:

In [5]:
4+3
7
In [6]:
pi*100  # a pi itt is pi
314.159265358979
In [7]:
5/7
0.714285714285714
In [8]:
3^2 # A hatvanyozas a ^-al történik!
9

Figylem a log a természetes logaritmus! A log10 adja a 10-s alapú logaritmust.

In [9]:
log(exp(1))
1

Értékadás eltér a Python-tól!

Az értékadásra R-ben a megszokott = helyett a <- konstrukció használandó!

In [10]:
a<- 13 # Így adunk értéket R-ben!!
a
13
In [11]:
print(a)

[1] 13

R-ben az = szimbólumot, ahogy ez lenneb is látni fogjuk, fügvény argumentumok megadására használjuk.

Változótípusok (objektumok) az R-ben

Alapegység az R-ben a vector

A R változók a python-hoz hasonlóan több típusba sorolhatóak. Lehetnek numeric (valós számok), logical (bool típusú változók), integer (egész számok), complex (komplex számok), character (betű illetve általánosabb karakter változók), list (hasonlóan a python list-hez), ezeken kívül létezik a raw ritkán használt változó típus is.

Az R alapvető származtatott adatstruktúrája a vector. Vectorok definiálására a c() függvényt célszerű használni:

In [12]:
vec <- c(1,2,3)
In [13]:
print(vec) # a vec változó kiiratása

[1] 1 2 3

Fontos az R-ben nem nullától indexelünk, hanem 1-től!

In [14]:
vec[0] # ez nem dob hibát de nem is tartalmaz semmit se!!
In [15]:
vec[1]
1
In [16]:
# ha integer-t szeretnénk, írjunk a szám után egy L betűt
egesz_szam <- 1L
In [17]:
egesz_szam
1

Az str() paranccsal megnézhetjük egy "objektum" minden tulajdonságát:

In [18]:
str(egesz_szam) # itt 1 darab int számról van csak szó

 int 1
In [19]:
valos_szam <- 1
str(valos_szam) # A numeric változó valós számot jelent (pythonban ezek a float számok)

 num 1
In [20]:
szavak <- c('cica', 'kutya', 'kigyó', 'alien', 'predator')
szavak
  1. 'cica'
  2. 'kutya'
  3. 'kigyó'
  4. 'alien'
  5. 'predator'
In [21]:
str(words)

Error in str(words): object 'words' not found
Traceback:

1. str(words)

A python-os példákban láttuk hogy számtalanszor előfordul az, hogy egy probléma megoldása során szükségünk van számok sorozatainak előállítására. Erre R-ben az alábbi "eleje:vege" konstrucióval van lehetőség:

In [22]:
sor<- 100:90
sor
  1. 100
  2. 99
  3. 98
  4. 97
  5. 96
  6. 95
  7. 94
  8. 93
  9. 92
  10. 91
  11. 90
In [23]:
str(sor)

 int [1:11] 100 99 98 97 96 95 94 93 92 91 ...

A python dict-ek hez hasonó konstrukciót kapunk ha a vector elemeit nevekkel definiáljuk őket (python dict-eknél kulcsoknak hívtuk ezeket a neveket ):

In [24]:
vec <- c(first = 1, second = 3, third = 6, fourth = 10) 
vec
first
1
second
3
third
6
fourth
10
In [25]:
str(vec) # Itt megjelent az objektumok attribútom tulajdonásga, akit jobban érdekel nézzen utána

 Named num [1:4] 1 3 6 10
 - attr(*, "names")= chr [1:4] "first" "second" "third" "fourth"

Ezen túl a nevekkel vagy a megfelelő index-el is hivatkozhatunk a megfelelő elemre:

In [26]:
vec[2]
second: 3
In [27]:
vec['second']
second: 3

A summary() parancs összegzi a fontos tulajdonságokat a változóról (mint az átlag, szórás, ...). Nagy előnye a különbözö függványek kiértékelésekor lesz.

In [28]:
summary(vec)

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
    1.0     2.5     4.5     5.0     7.0    10.0
In [29]:
summary(szavak)

   Length     Class      Mode 
        5 character character

Ha adott lépésközzel szeretnénk vektort létrehozni, akkor használjuk a seq() parancsot:

In [30]:
seq(100,0,-5)
  1. 100
  2. 95
  3. 90
  4. 85
  5. 80
  6. 75
  7. 70
  8. 65
  9. 60
  10. 55
  11. 50
  12. 45
  13. 40
  14. 35
  15. 30
  16. 25
  17. 20
  18. 15
  19. 10
  20. 5
  21. 0

Az R objektum-osztályai

Az R vector objektumokból az alábbi bonyolultabb objektumok származnak:

  • matrix (két index-es tömbök)
  • array (több indexes tömbök)
  • list (különböző objektumokat tartalmazó tömbök )
  • data frame (Ez olyan mint a pandas dataframe )
  • hiányzó értékek (NaN/NA értékek)

Mátrixok - azaz 2 dimenziós vektor

Matrix-okat a matrix() függvénnyel definiálunk:

In [31]:
mat <- matrix(1:8, nrow = 2, ncol = 4)
mat
1357
2468

A dim() paranccsal megnézhető a dimneziója a mátrixnak:

In [32]:
dim(mat)
  1. 2
  2. 4

Vektorból is létrehozható:

In [33]:
newmat <- 3:6
dim(newmat) <- c(2, 2)
newmat
35
46

Array - azaz sok diemnziós mtrixok (vektorok)

In [34]:
arr <- array(1:12, c(3, 2, 2)) # array-nel vektorral adjuk meg a dimenziokat
dim(arr)
  1. 3
  2. 2
  3. 2
In [35]:
mat <- matrix(1:8, 2, 4)
mat
1357
2468

Ha egy matrix dimenzióját megválltoztatjuk (ügyelve arra hogy az elemszám megmaradjon) akkor a matrixból array lesz:

In [36]:
arr <- mat
is.matrix(arr)
TRUE
In [37]:
dim(arr) <- c(2, 2, 2) # átszabjuk a dimenziókat 
is.matrix(arr) # az arr valtozó mar nem matrix!
is.array(arr)  # hanem array
FALSE
TRUE

Faktorok - vectorok véges érték készlettel

A factorok olyan vector-ok amelyeknek az elemei egy véges halamzból vesznek fel értékeket. Gondoljunk itt például egy osztály tanulóinak a nemére. Factorokat, nem túl meglepő módon a factor() segéd függvénnyel definiálhatunk:

In [38]:
fac <- factor(c("male", "male", "male", "female", "female", "male", "female"))
fac
  1. male
  2. male
  3. male
  4. female
  5. female
  6. male
  7. female

A labels kulcsszóval felül definiálhatjuk az értékkészlet címkéit:

In [39]:
newfac<-factor(c(1,1,1,2,2,1,2), labels=c("male","female"))
newfac
  1. male
  2. male
  3. male
  4. female
  5. female
  6. male
  7. female

Listák

A listák speciális vektor melyek vegyesen tartalmazhatnak különböző típusú elemeket (vektort, array-t, listát, stb.)

In [40]:
mylist <- vector("list", 2) # "ures"" lista letrehozasa
mylist
  1. NULL
  2. NULL
In [41]:
newlist <- list(a = 1, b = FALSE, letters[1:5]) # kozvetlen megadas
newlist

$a
[1] 1

$b
[1] FALSE

[[3]]
[1] "a" "b" "c" "d" "e"

Data frame

A data frame-ek speciális listák, amely azonos hosszúságú vektorokból állnak. A data frame-ek inspirálták a python pandas moduljának adatstruktúráját.

In [42]:
datfr <- data.frame(digits = 10:6, characters = letters[1:5])
datfr
digitscharacters
10a
9b
8c
7d
6e

Hiányzó értékek

Megkülönöztetjük a NA (not available) vagy a NaN (not a number) értékeket

Fontos: minden NaN NA, de nem minden NA NaN

In [43]:
x <- c(1, 3, 4, NaN, 5, NA)
x
  1. 1
  2. 3
  3. 4
  4. NaN
  5. 5
  6. NA

Változó tipusának ellenőrzése, és tipuskonverzió:

Az is.X() (itt X helyére a konkrét tipust kell írni) kifejezéssel ellenőrizhető, egy változó az adott tipusú-e:

In [44]:
x <- c(1, 3, 4, NaN, 5, NA)
is.numeric(x)
TRUE
In [45]:
is.na(x)
  1. FALSE
  2. FALSE
  3. FALSE
  4. TRUE
  5. FALSE
  6. TRUE
In [46]:
arr <- array(1:12, c(3, 2, 2)) 
is.array(arr)
TRUE
In [47]:
is.numeric(arr)
TRUE
In [48]:
is.factor(arr)
FALSE

Objektumok kombinálása

Legegyszerűbben a c() szintaxissal lehet összekombinálni két változót:

cbind, c, rbind, abind,

In [49]:
a<- 1:10
b<- 11:20
lista<-c(a,b)
lista
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20

Ha van két vektorunk/mátrix/array akkor ezek kombinálása történhet oszlop szereint (cbind()) vagy sorok mentén (rbind()):

In [50]:
cbind(x = 1:3, y = 4:6) # ket vektor osszeillesztese egy-egy oszlopba
xy
14
25
36
In [51]:
mat2 <- matrix(1:4, 2, 2)
mat3 <- matrix(5:8, 2, 2)
cbind(mat2, mat3) # Figyelem mátrixoknál a sorok a sorok számának egyezni kell!
1357
2468
In [52]:
rbind(x = 1:3, y = 4:6) #kombinálás sorok mentén
x123
y456

Elemek indexelése hasonló a Pythonhoz, de itt 1-től kezdődik az indexelés

(Kivéve listák és data.frame-k esetében!)

In [53]:
vec <- c(1:2, 4)
vec[2:3]
  1. 2
  2. 4
In [54]:
mat <- matrix((1:8)^2, 2, 4)
mat[1, ]
  1. 1
  2. 9
  3. 25
  4. 49
In [55]:
mat[, 2]
  1. 9
  2. 16
In [56]:
mat[1:5]
  1. 1
  2. 4
  3. 9
  4. 16
  5. 25

Listák és data.frame-ek indexelése

Ez eltér a pythontól, mivel itt lehetőség van attribútomok kezelésével (nevet adni mondjuk az adattábla oszlopainak). Ez a szintaxis a python pandas csomaghoz hasonló

Ha névvel akarunk hivatkozni az elemekre, a "$ jelet kell használni:

In [57]:
x<-c('A','B')
y<-6:9
z<-1:8
d<-data.frame(x,y,z)
d
xyz
A61
B72
A83
B94
A65
B76
A87
B98
In [58]:
str(d)

'data.frame':	8 obs. of  3 variables:
 $ x: Factor w/ 2 levels "A","B": 1 2 1 2 1 2 1 2
 $ y: int  6 7 8 9 6 7 8 9
 $ z: int  1 2 3 4 5 6 7 8
In [59]:
attributes(d)
$names
  1. 'x'
  2. 'y'
  3. 'z'
$row.names
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
$class
'data.frame'
In [60]:
d$x
  1. A
  2. B
  3. A
  4. B
  5. A
  6. B
  7. A
  8. B
In [61]:
d$y[2:5]
  1. 7
  2. 8
  3. 9
  4. 6
In [62]:
c(2:20:2)

Warning message in 2:20:2:
“numerical expression has 19 elements: only the first used”
2
In [63]:
d$z[2:5]
  1. 2
  2. 3
  3. 4
  4. 5

Függvények:

A függvényeket a "function" paranccsal hozhatjuk létre:

In [64]:
simpleAdd <- function(x, y) x + y
In [65]:
# ha megadjuk az argumentum nevét, a sorrend lényegtelen
simpleAdd(y = 4, x = 2)
6
In [66]:
fv_ertek <- simpleAdd(y = 4, x = 2)
str(fv_ertek)

 num 6

Bonyolúltabb dolgokat "{}"-k közé kell rendezni. Ez eltér a Python-tól!

In [67]:
func2<-function(x,y){
    z=x+y
    return(z)
}
In [68]:
func2(1,2)
3

Elágazás az R-ben (if)

Alap szintaxis:

if (test_expression) {
   statement
}

Vagy else ággal:

if (test_expression) {
   statement1
} else {
   statement2
}
In [69]:
x <- -5
if(x > 0){
   print("Non-negative number")
} else {
   print("Negative number")
}

[1] "Negative number"

Elemeken végigmenő ciklus: for ciklus az R-ben

Alap szintaxis:

for (val in sequence)
{
    statement
}

Feltétel vizsgálattal futó cilus: while ciklus az R-ben

Alap szintaxis:

while (test_expression)
{
   statement
}
In [70]:
i <- 1

while (i < 6) {
   print(i)
   i = i+1
}

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

Vezérléis elemek kombinálása:

In [71]:
# ha az 'y' argumentum hiányzik, adja össze az 'x' vektor elemeit
advAdd <- function(x, y) {
    if (missing(y)) {
    out <- sum(x)
    } else {
    out <- x + y
    }
    return(out)
}
In [72]:
# ha nem adunk meg argumentumnevet, akkor a függvény
# argumentumainak eredeti sorrendje számít
simpleAdd(2, 4)
6

Fájlműveletek R-ben

Az R-ben számos módszer létezik fájlok kezelésére. Most a leggakrabban használt módot mutatjuk meg szöveges adatfájlok beolvasására.

Első lépésben megadható a munkakönvtár a setwd(".."), amit most ne változtassunk meg. A getwd() paranccsal lekérdezhető az aktuális munkakönyvtár:

In [73]:
getwd()
'/home/oroszlany/tmp/Package10'
In [74]:
dir() # megjeleníti a könyvtár tartalmát
  1. 'data'
  2. 'Feladatok_R.html'
  3. 'Feladatok.html'
  4. 'feladatok10.html'
  5. 'feladatokmegoldassal.html'
  6. 'kicsiadat.dat'
  7. 'magic.html'
  8. 'mintapelda10.html'
  9. 'octave-workspace'
  10. 'octave.html'
  11. 'R.html'
  12. 'svd.svg'

Adatok beolvasása

Adatfájlokat többek között a read.csv paranccsal tudunk megtenni. Ez a parancs alapértelmezésben vesszővel elválaszott fájlokat olvas be, illetve alapértelmezett úgy veszi, hogy a fájlnak van fejléce.

Nézzük meg a működését az ismert "h_vs_t.txt" fájlon (Baumgartner-es példafeledat volt).

In [75]:
dat_txt <- read.csv(file = "data/h_vs_t.txt")
In [76]:
str(dat_txt)

'data.frame':	323 obs. of  1 variable:
 $ X0.565056.38969: Factor w/ 323 levels "1.88208 38969",..: 1 169 253 282 298 307 315 10 18 27 ...

Ez így nem lesz jó, hiszen az első sor nem a fejléc volt. Használjuk a "hearder=False" kapcsolót:

In [77]:
dat_txt <- read.csv(file = "data/h_vs_t.txt", header=F) # False rövidíthető egy "F" billentyűvel (True pedig "T"-vel)
In [78]:
str(dat_txt)

'data.frame':	324 obs. of  1 variable:
 $ V1: Factor w/ 324 levels "0.565056 38969",..: 1 2 170 254 283 299 308 316 11 19 ...

Még mindig nem jó, hiszen számokról van szó, és a faktor tipus nem erre utal. Ahhoz hogy a szóközzel elválasztott oszlopkat kezelni tdjuk, használjuk a sep=" " parancsot:

In [79]:
dat_txt <- read.csv(file = "data/h_vs_t.txt", header=F, sep = " ")
In [80]:
str(dat_txt)

'data.frame':	324 obs. of  2 variables:
 $ V1: num  0.565 1.882 3.199 4.516 5.833 ...
 $ V2: int  38969 38969 38969 38969 38968 38954 38926 38879 38815 38734 ...
In [81]:
head(dat_txt$V1) # a head() parancsat hasznolóan működik, mint a Pythonban
  1. 0.565056
  2. 1.88208
  3. 3.19911
  4. 4.51614
  5. 5.83317
  6. 7.1502

Adatok ábrázolása

Az adatok egyszerű ábrázolása a plot() paranccsal történik:

In [82]:
plot(dat_txt)

Számos lehetőség van a plot parancsal módosítására, ám a Pythonnal ellentétben, itt a plot parancson belül kell többségüket kiadni.

  • main=" .. ": Ábra
  • xlab=" .. ", ylab=" .. ": X/Y tenegylefelirat
  • log="x", log="y", log="xy": Logaritmikus tenegly beállítsa, csak x, csak y vagy x-y tengelyre
  • xlim=c(A,B), ylim=c(A,B): X-Y limitek beállítása (A,B számok)
  • type: Mivel akarunk ábárzolni ("p" pontok, "l" vonal, "b" pont és vonal)
  • col=" .. ": Szín beállítása (pl. "red", "green", "blue3")
  • pch=SZAM: adatokok szimbóluma (kereszt: 3, kör: 1, négyzet: 0, kör kereszttel: 10, telt kör:16)
In [83]:
help(plot)
In [84]:
plot(dat_txt, xlab="Idő [s]", ylab="Magasság [m]", main="Ugrás",
    log="xy", xlim=c(0.1,1000), col="blue3", pch=2, type="b")

Ábramagyarázat és több adat ábrázolása

Ábramagyarázatot a legend() paranccsal tudunk elhelyezni.

Szintakxisa:

legend(Pozició,Nevek, ...)

Több adatsort úgy lehet 1 ábrán megmutatni, hogy külön plot parancsokat használunk, és a plot parancsok közé kitesszük:

par(new=True)

parancsot! Itt figyelni kell a tengelyfeliratok beállítására. A második ábáránál célszerű a semmit ("") megadni.

In [85]:
plot(dat_txt$V1, xlab="Idő [s]", ylab="Magasság [m]", main="Ugrás",
   xlim=c(0,400),ylim=c(0,40000), col="green", pch=16, type="b")
par(new=T)
plot(dat_txt$V2, xlab="", ylab="",
   xlim=c(0,400),ylim=c(0,40000), col="orange", pch=16, type="b")
legend(300, 40000, c("Magasság", "Eltelt idő"), col=c("orange", "green"), pch = 16)

Illesztés az adatokra

Most csak a lineáris illesztést mutatjuk be, de lehetőség van egyéb görbék illesztésére is.

A lineáris illesztést az lm() paranccsal lehet elvégezni:

In [86]:
x<-dat_txt[dat_txt>=210 & dat_txt<=240,1]
y<-dat_txt[dat_txt>=210 & dat_txt<=240,2]
In [87]:
lm(y ~ x)

Call:
lm(formula = y ~ x)

Coefficients:
(Intercept)            x  
   18573.15       -61.39

Figyeljünk oda, hogy a kimenet egy komplex objektum:

In [88]:
fit<-lm(y~x)
str(fit)

List of 12
 $ coefficients : Named num [1:2] 18573.2 -61.4
  ..- attr(*, "names")= chr [1:2] "(Intercept)" "x"
 $ residuals    : Named num [1:22] 4.72 4.57 5.42 -3.73 2.12 ...
  ..- attr(*, "names")= chr [1:22] "1" "2" "3" "4" ...
 $ effects      : Named num [1:22] -2.23e+04 -2.41e+03 3.92 -5.13 8.22e-01 ...
  ..- attr(*, "names")= chr [1:22] "(Intercept)" "x" "" "" ...
 $ rank         : int 2
 $ fitted.values: Named num [1:22] 5602 5521 5441 5360 5279 ...
  ..- attr(*, "names")= chr [1:22] "1" "2" "3" "4" ...
 $ assign       : int [1:2] 0 1
 $ qr           :List of 5
  ..$ qr   : num [1:22, 1:2] -4.69 0.213 0.213 0.213 0.213 ...
  .. ..- attr(*, "dimnames")=List of 2
  .. .. ..$ : chr [1:22] "1" "2" "3" "4" ...
  .. .. ..$ : chr [1:2] "(Intercept)" "x"
  .. ..- attr(*, "assign")= int [1:2] 0 1
  ..$ qraux: num [1:2] 1.21 1.26
  ..$ pivot: int [1:2] 1 2
  ..$ tol  : num 1e-07
  ..$ rank : int 2
  ..- attr(*, "class")= chr "qr"
 $ df.residual  : int 20
 $ xlevels      : Named list()
 $ call         : language lm(formula = y ~ x)
 $ terms        :Classes 'terms', 'formula'  language y ~ x
  .. ..- attr(*, "variables")= language list(y, x)
  .. ..- attr(*, "factors")= int [1:2, 1] 0 1
  .. .. ..- attr(*, "dimnames")=List of 2
  .. .. .. ..$ : chr [1:2] "y" "x"
  .. .. .. ..$ : chr "x"
  .. ..- attr(*, "term.labels")= chr "x"
  .. ..- attr(*, "order")= int 1
  .. ..- attr(*, "intercept")= int 1
  .. ..- attr(*, "response")= int 1
  .. ..- attr(*, ".Environment")=<environment: R_GlobalEnv> 
  .. ..- attr(*, "predvars")= language list(y, x)
  .. ..- attr(*, "dataClasses")= Named chr [1:2] "numeric" "numeric"
  .. .. ..- attr(*, "names")= chr [1:2] "y" "x"
 $ model        :'data.frame':	22 obs. of  2 variables:
  ..$ y: int [1:22] 5607 5526 5446 5356 5281 5201 5116 5035 4951 4871 ...
  ..$ x: num [1:22] 211 213 214 215 217 ...
  ..- attr(*, "terms")=Classes 'terms', 'formula'  language y ~ x
  .. .. ..- attr(*, "variables")= language list(y, x)
  .. .. ..- attr(*, "factors")= int [1:2, 1] 0 1
  .. .. .. ..- attr(*, "dimnames")=List of 2
  .. .. .. .. ..$ : chr [1:2] "y" "x"
  .. .. .. .. ..$ : chr "x"
  .. .. ..- attr(*, "term.labels")= chr "x"
  .. .. ..- attr(*, "order")= int 1
  .. .. ..- attr(*, "intercept")= int 1
  .. .. ..- attr(*, "response")= int 1
  .. .. ..- attr(*, ".Environment")=<environment: R_GlobalEnv> 
  .. .. ..- attr(*, "predvars")= language list(y, x)
  .. .. ..- attr(*, "dataClasses")= Named chr [1:2] "numeric" "numeric"
  .. .. .. ..- attr(*, "names")= chr [1:2] "y" "x"
 - attr(*, "class")= chr "lm"

Próbáljuk meg használni a korábban már bemutatott summary() parancsot. Itt már kihasználhatjuk az R statisztikai képességeit, hiszen az illesztésről megtudjuk mennyire szignifikáns a fit. Látható, hogy ebben az esetben az illesztés hibája kicsi, és annak az esélye, hogy véletlenül lehet egyenest illeszteni $<2\cdot10^{-16}$, azaz nulla.

In [89]:
summary(fit)

Call:
lm(formula = y ~ x)

Residuals:
    Min      1Q  Median      3Q     Max 
-5.7883 -3.6136 -0.5898  3.1087  5.5534 

Coefficients:
              Estimate Std. Error t value Pr(>|t|)    
(Intercept)  1.857e+04  2.243e+01   828.1   <2e-16 ***
x           -6.139e+01  9.956e-02  -616.6   <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.902 on 20 degrees of freedom
Multiple R-squared:  0.9999,	Adjusted R-squared:  0.9999 
F-statistic: 3.802e+05 on 1 and 20 DF,  p-value: < 2.2e-16

FIGYELEM: Az illesztett egyenes ábrázolása kicsit körülményes:

Az illesztett adatok a változó "coefficients" nevő listájában vannak. Az első elem az y tengelymetszet, míg a második elem a meredeksés, azaz:

  • Meredekség: fit$coefficients[2]
  • Tengelymetszet: fit$coefficients[1]
In [90]:
plot(x,x*fit$coefficients[2]+fit$coefficients[1], type="l", col="red"
     , xlab="", ylab="",xlim=c(210,240),ylim=c(3500,6000))
par(new=T)
plot(x,y, pch=3, col="green", xlab="Idő [s]", ylab="Magasság [m]",xlim=c(210,240),
    ylim=c(3500,6000), main="Illesztés")

Alternatív módszer a predict() parancs használatával:

In [91]:
plot(x,predict(fit), type="l", col="red"
     , xlab="", ylab="",xlim=c(210,240),ylim=c(3500,6000))
par(new=T)
plot(x,y, pch=3, col="green", xlab="Idő [s]", ylab="Magasság [m]",xlim=c(210,240),
    ylim=c(3500,6000), main="Illesztés")

Korreláció számítása

Az R-ben könnyen kiszámolható a:

korrelációk a cor() paranccsal. Alapértelmezetten a "pearson" korrelációt adja meg a függvény.

In [92]:
cor(x,y)
-0.999973700432787
In [93]:
cor.test(x,y)

	Pearson's product-moment correlation

data:  x and y
t = -616.62, df = 20, p-value < 2.2e-16
alternative hypothesis: true correlation is not equal to 0
95 percent confidence interval:
 -0.9999893 -0.9999354
sample estimates:
       cor 
-0.9999737
In [94]:
cor(x,y, method = "spearman")
-1

Statisztika az R-ben

Egyszerű leíró statisztika a summary paranccsal lekérdezhető:

In [95]:
random<-runif(n = 20, min = 10, max = 30) # runif normál eloszlású véletlen számokat gerenál
In [96]:
summary(random)

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  10.44   16.62   21.02   20.56   23.77   29.75

A medián, az átlag, a szórás (sztenerd hiba) illetve a variancia (szórásnégyzet) számítására vannak külön parancsok is:

In [97]:
median(x) # Medián
225.1185
In [98]:
mean(x) # Számtani átlag
225.1185
In [99]:
sd(x) # Normál hiba (szórás)
8.55205352532361
In [100]:
var(x) # Variancia, ennek a gyöke a szórás
73.1376195

Véletelen egész számok generálására használjuk a sample függvényt. Ez a függvény használatos, ha egy listából véletlenszerűen szeretnénk kiválasztani elemeket. A replace = True opcióval pedig visszatevéses kiválasztást/generálást is végre lehet hasjtani.

In [101]:
sample(x=10)
  1. 10
  2. 9
  3. 3
  4. 2
  5. 7
  6. 4
  7. 6
  8. 1
  9. 5
  10. 8
In [102]:
sample(y, size = 5, replace = T)
  1. 4630
  2. 5526
  3. 4310
  4. 4231
  5. 4788

Listák sorbarendezésére használatos a sort() függvény.

In [103]:
random<-runif(20)
sort(random)
  1. 0.0600320098455995
  2. 0.0742365957703441
  3. 0.13665665499866
  4. 0.181749905226752
  5. 0.221267357701436
  6. 0.295819088816643
  7. 0.296470059314743
  8. 0.314731129910797
  9. 0.402614923892543
  10. 0.42593721114099
  11. 0.468832379672676
  12. 0.487839704845101
  13. 0.495539406314492
  14. 0.506296699633822
  15. 0.538032811135054
  16. 0.551218152046204
  17. 0.592391935875639
  18. 0.666928938124329
  19. 0.691940538585186
  20. 0.782649149885401
In [104]:
sort(random,decreasing = T) #ez csökkenő sorrendeben rendez
  1. 0.782649149885401
  2. 0.691940538585186
  3. 0.666928938124329
  4. 0.592391935875639
  5. 0.551218152046204
  6. 0.538032811135054
  7. 0.506296699633822
  8. 0.495539406314492
  9. 0.487839704845101
  10. 0.468832379672676
  11. 0.42593721114099
  12. 0.402614923892543
  13. 0.314731129910797
  14. 0.296470059314743
  15. 0.295819088816643
  16. 0.221267357701436
  17. 0.181749905226752
  18. 0.13665665499866
  19. 0.0742365957703441
  20. 0.0600320098455995

Itt lehetőség van a sorbarendezési indexeket is megnézni az index.return=True beálítással:

In [105]:
sort(random,index.return=T)
$x
  1. 0.0600320098455995
  2. 0.0742365957703441
  3. 0.13665665499866
  4. 0.181749905226752
  5. 0.221267357701436
  6. 0.295819088816643
  7. 0.296470059314743
  8. 0.314731129910797
  9. 0.402614923892543
  10. 0.42593721114099
  11. 0.468832379672676
  12. 0.487839704845101
  13. 0.495539406314492
  14. 0.506296699633822
  15. 0.538032811135054
  16. 0.551218152046204
  17. 0.592391935875639
  18. 0.666928938124329
  19. 0.691940538585186
  20. 0.782649149885401
$ix
  1. 2
  2. 18
  3. 17
  4. 19
  5. 8
  6. 3
  7. 5
  8. 11
  9. 4
  10. 14
  11. 1
  12. 9
  13. 10
  14. 7
  15. 20
  16. 6
  17. 13
  18. 16
  19. 12
  20. 15

Ismert eloszlások R-ben

Az R ismeri a legfontosabb eloszlástipusokat, mint a normál, binominális, $\chi^2$, cauchy, exponenciális és még sok mást.

In [106]:
x<-seq(-3,3,0.1)
In [107]:
plot(x,dnorm(x),type="l",main="dnorm()")

Statisztika tesztek az R-ben

Az R számos statisztikai tesztet ismer az R:

  • Student t-teszt
  • $\chi^2$-teszt$
  • Kolmogorov Smirnov Teszt
  • Shapiro-Wilk Normality Teszt
  • ...

Példa T-próbára:

Egy gyárban egy gépnek 500 g töltőanyagot kell a konzervekbe juttatnia minden töltéskor. A töltőanyag egyenetlenségéből adódóan a gép néha kicsit többet, néha kicsit kevesebbet tölt, mint 500 g. Arra vagyunk kíváncsiak, hogy a gép átlagos "teljesítménye" 500 g-nak mondható-e. Kiveszünk 10 konzervet a futószalagról és megmérjük mindben a töltőanyag súlyát. Az eredmények rendre 483, 502, 498, 496, 502, 483, 494, 491, 505, 486.

Vizsgáljuk meg, hogy szignifikánsan eltér-e az átlagtól a termelés?

In [108]:
x<- c(483, 502, 498, 496, 502, 483, 494, 491, 505, 486)
t.test(x, mu=500, conf.level = 0.05) # A táblázatbeli határérték 95%-os szignifikancia szinten: 1.833

	One Sample t-test

data:  x
t = -2.3554, df = 9, p-value = 0.04292
alternative hypothesis: true mean is not equal to 500
5 percent confidence interval:
 493.8358 494.1642
sample estimates:
mean of x 
      494

A nullhipotézist elvetjük, az egymintás t-próba szerint az átlagos töltőtömeg szignifikánsan eltér (p = 0,05-ös szignifikancia szint mellett) az 500 g-tól.

A Kolmogorov–Szmirnov próba egy olyan statisztikai teszt, ami két minta eloszlásának összehasonlítására alkalmas. Alkalmas arra, hogy két valószínűségi változó eloszlását összehasonlítsuk, vagy ellenőrizzük, hogy egy valószínűségi változónak csakugyan az az eloszlása, amit feltételeztünk.

In [109]:
x <- c(1,2,2,3,3,3,3,4,5,6)
y <- c(2,3,4,5,5,6,6,6,6,7)
z <- c(12,13,14,15,15,16,16,16,16,17)

ks.test(x,y)

Warning message in ks.test(x, y):
“cannot compute exact p-value with ties”
	Two-sample Kolmogorov-Smirnov test

data:  x and y
D = 0.5, p-value = 0.1641
alternative hypothesis: two-sided
In [110]:
ks.test(x,z)

Warning message in ks.test(x, z):
“cannot compute exact p-value with ties”
	Two-sample Kolmogorov-Smirnov test

data:  x and z
D = 1, p-value = 9.08e-05
alternative hypothesis: two-sided

A Shapiro-Wilk teszt azt vizsgálja, hogy a minták normál eloszlásból származik-e?

In [111]:
shapiro.test(x)

	Shapiro-Wilk normality test

data:  x
W = 0.93644, p-value = 0.5141
In [112]:
shapiro.test(y)

	Shapiro-Wilk normality test

data:  y
W = 0.89893, p-value = 0.2132
In [113]:
shapiro.test(z)

	Shapiro-Wilk normality test

data:  z
W = 0.89893, p-value = 0.2132
In [114]:
shapiro.test(dnorm(x)) # Ez így egy nomrális eloszlásű adatsort vizsgál

	Shapiro-Wilk normality test

data:  dnorm(x)
W = 0.55502, p-value = 1.617e-05

Korreláció tesztelése

Két változó korrelációjnak tesztelésére a cor.test használandó. A korreláció kiszámolásának mintájára, itt is többféle korrelációt vizsgálhatunk.

In [115]:
x<-dat_txt[dat_txt>=210 & dat_txt<=240,1]
y<-dat_txt[dat_txt>=210 & dat_txt<=240,2]

cor.test(x,y)

	Pearson's product-moment correlation

data:  x and y
t = -616.62, df = 20, p-value < 2.2e-16
alternative hypothesis: true correlation is not equal to 0
95 percent confidence interval:
 -0.9999893 -0.9999354
sample estimates:
       cor 
-0.9999737
In [116]:
cor.test(x,y, method = "spearman")

	Spearman's rank correlation rho

data:  x and y
S = 3542, p-value = 2.438e-06
alternative hypothesis: true rho is not equal to 0
sample estimates:
rho 
 -1