[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


II. 요인(Factor)

  # 벡터의 일종

  # 차이점 : 집단(group)으로 인식함

  # 1차원 - 하나의 열로 구성

  # 벡터는 집단으로 인식하지 않음

  # factor(vector, labels=, levels=, ordered=) 


  bt(blood type) 예제

1
2
3
> bt = c("ab""ab""a""a""b")
> bt
[1"ab" "ab" "a"  "a"  "b"
cs


  bt를 factor로 바꿔보자

1
2
3
4
> bt_factor <- factor(bt)
> bt_factor
[1] ab ab a  a  b 
Levels: a ab b
cs

  # Levels : a ab b => 3개의 집단(a, ab, b)으로 인식함    


  bt_factor2 - labels

1
2
3
4
5
> bt_factor2 <- factor(bt, 
                       labels = c("A형","AB형","B형"))
> bt_factor2
[1] AB형 AB형 A형  A형  B형 
Levels: A형 AB형 B형
cs

  # labels : 데이터 값과 결과가 바뀜


  bt_factor3 - levels

1
2
3
4
5
> bt_factor3 <- factor(bt,
                       levels = c("b","ab","a"))
> bt_factor3
[1] ab ab a  a  b 
Levels: b ab a
cs

  # levels : 집단의 순서 - 데이터 자체는 바뀌지 않지만 b, ab, a 순으로 Levels이 바뀌게 됨


  bt_factor4 - labels, levels

1
2
3
4
5
6
> bt_factor4 <- factor(bt,
+                      levels = c("b","ab","a"),
+                      labels = c("B형","AB형","A형"))
> bt_factor4
[1] AB형 AB형 A형  A형  B형 
Levels: B형 AB형 A형
cs

  # 2개의 argument 같이 사용할 시 labels의 값들은 levels에 대응되도록 사용해야 한다


  bt_factor5

1
2
3
4
5
6
7
> bt_factor5 <- factor(bt, 
+                      levels  = c("b","ab","a")
+                      labels  = c("A형","AB형","B형"),
+                      ordered = TRUE)
> bt_factor5
[1] AB형 AB형 B형  B형  A형 
Levels: A형 < AB형 < B형
cs

  # ordered : 특정한 결과값을 의미있게 구분할 때 사용 => 부등호가 나타남


 factor의 속성

  (1) levels(요인)

1
2
> levels(bt_factor)
[1"a"  "ab" "b" 
cs

  (2) ordered(요인)

# 집단의 순서가 의미 있도록 변경

1
2
3
> ordered(bt_factor)
[1] ab ab a  a  b 
Levels: a < ab < b
cs

# bt_factor의 속성을 ordered=TRUE로 만들어 주겠다는 것



III. 행렬(Matrix)

  # 행(row)와 열(column)로 구성되어 있음

  # 2차원 (행, 열)

  # 벡터의 확장 -> 1차원에서 2차원으로

  # 벡터의 규칙이 대부분 적용( Recycling Rule, Vectorization )


  1. 행렬을 만드는 방법

(1) rbind(벡터1, 벡터2, ...)  /  cbind(벡터1, 벡터2, ...)

1
2
3
4
5
6
7
> v1 = 1:3
> v2 = 4:6
> M1 = rbind(v1, v2)
> M1
   [,1[,2[,3]
v1    1    2    3
v2    4    5    6
cs

# rbind : row를 기준으로 벡터를 결합하여 생성

# cbind : column을 기준으로 벡터를 결합하여 생성


(2) matrix(vector, nrow=, ncol=, byrow=)

1
2
3
4
> matrix(1:4, nrow=2, ncol=2)
     [,1[,2]
[1,]    1    3
[2,]    2    4
cs

# R에서 행렬은 열(column)이 우선으로 채워진다.


1
2
3
4
> matrix(1:4, nrow=2, ncol=2, byrow=TRUE)
     [,1[,2]
[1,]    1    2
[2,]    3    4
cs

# byrow = TRUE는 행(row)을 우선으로 행렬을 채우는 것



  2. 행렬의 슬라이싱

     # 행렬[ 행index, 열index ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
> M3
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[1]    # 1행
[11 2
 
> M3[2]    # 2행
[13 4
 
> M3[1:2]  #1,2행 
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[ ,1 ]    # 2열
[11 3
 
> M3[ ,1:2 ]  # 1,2열
     [,1[,2]
[1,]    1    2
[2,]    3    4
 
> M3[1,2]   # 1행, 2열
[12
 
cs

  


3. 행렬의 덧셈과 뺄셈

# 형태(shape)가 동일해야 한다. 

# 2x3 은 2x3 끼리만 연산 가능

1
2
3
4
5
6
7
8
9
10
11
12
> A <- matrix(1:4, nrow=2, ncol=2)
> B <- matrix(5:8, nrow=2, ncol=2)
 
> A + B
     [,1[,2]
[1,]    6   10
[2,]    8   12
 
> A - B
     [,1[,2]
[1,]   -4   -4
[2,]   -4   -4
cs


# A*B -> 행렬의 곱셈? 

1
2
3
4
> A * B
     [,1[,2]
[1,]    5   21
[2,]   12   32
cs

# A*B는 단순히 index가 같은 값 끼리 연산하는 것으로 행렬의 곱셈은 아니다.


  4. 행렬의 곱셈

# A_r1,c1 %*% B_r2,c2

# 조건 : c1 = r2 -> 곱하고자 하는 A의 열과 B의 행의 개수가 같아야 한다.

# 최종 결과는 r1xc2 matrix

1
2
3
4
5
6
> A = matrix(1:4, nrow=2, ncol=2)
> B = matrix(5:8, nrow=2, ncol=2)
> A %*% B
     [,1[,2]
[1,]   23   31
[2,]   34   46
cs



  5. 역행렬(Reverse Matrix)

# 조건 1 : 정방행렬(Square Matrix) - 행과 열의 개수가 같음

# 조건 2 : 행렬식이 0이 아니어야 함

ex) 

A( a11, a12

    a21, a22)

# 조건 1 : 2x2 행렬

# 조건 2 : (a11 x a22) - (a12 x a21) != 0

# 조건 2가지가 성립하므로 역행렬 결과는

A( a22, -a12

    -a21, a11)

# 위의 결과에 1/(a11 x a22) - (a12 x a21) 을 곱해줌

# solve() 함수를 사용하여 역행렬을 구함 

1
2
3
4
5
6
7
8
9
10
11
> A1 = matrix(1:4, nrow=2, ncol=2)
> A1
     [,1[,2]
[1,]    1    3
[2,]    2    4
 
> A2 = solve(A1)
> A2
     [,1[,2]
[1,]   -2  1.5
[2,]    1 -0.5
cs


# A1과 A2(A1의 역행렬)을 곱하면 단위행렬이 나옴

1
2
3
4
> A1 %*% A2
     [,1[,2]
[1,]    1    0
[2,]    0    1
cs


# 방정식 계산

2x + y = 3

-x + 3y = 10

1
2
3
4
5
6
> B1 = matrix(c(21-13), nrow=2, ncol=2)
> B2 = matrix(c(310), nrow=2, ncol=1)
> solve(B1) %*% B2
         [,1]
[1,] 2.714286
[2,] 2.428571
cs

 


  6. 전치행렬(Transpose Matrix)

# 행과 열을 바꿈

# t(행렬)

1
2
3
4
5
6
7
8
9
> A
     [,1[,2]
[1,]    1    3
[2,]    2    4
 
> t(A)
     [,1[,2]
[1,]    1    2
[2,]    3    4
cs


[Fast campus] Data Science with R 1기 - 이부일 강사님

공부하면서 배운 내용 복습 겸 정리하는 곳입니다.


※ 데이터의 유형(Type of Data)

1. 벡터(Vector) 

2. 요인(Factor)

3. 행렬(Matrix)

4. 배열(Array)

5. 데이터 프레임(Data.Frame)

6. 리스트(List)

7. 데이터 테이블(Data.Table)

8. 시계열(Time Series)



I. 벡터(Vector)

  # 하나 이상의 값(원소 : element)으로 이루어짐

  # 하나의 열(column)로 되어 있음

  # 하나의 데이터 유형만 가짐 


1. 벡터를 생성하는 방법 -> 원소가 2개 이상일 때 사용하는 방법

  # 벡터를 생성하기 보다는 데이터의 일부를 추출할 때 많이 사용

  (1) c(원소1, 원소2, ...)

# c : combine, concatenate의 약자

# numeric, character, logical 타입의 벡터를 만들 수 있다.

# 원소들 간의 규칙이 없을 경우에 사용

# vector는 하나의 유형만 가진다.

1
2
3
4
5
6
7
> v1 = c(1"Lee"FALSE
> v1
[1"1"  "Lee"  "FALSE"
 
> v2 = c(1TRUEFALSE)
> v2
[11 1 0
cs

# 데이터 유형의 우선 순위 : character > numeric > logical

# 우선 순위가 높은 유형에서 하위 유형으로 변환은 잘 이루어지지 않는다.

# character -> numeric : "숫자" 일 경우 변환 가능

# logical -> numeric : TRUE는 1, FALSE는 0를 반환


  (2) :

# numeric vector에만 적용됨

# 1씩 증가 or 감소되는 숫자로 이루어진 벡터를 생성할 때 사용

# 규칙이 있는 숫자 


# start : end

# start < end : 1씩 증가

# start > end : 1씩 감소

# start = end : start or end


# start부터 시작해서 end를 넘지 않을 때 까지 1씩 증가 or 감소

# 항상 start 부터 시작한다.

1
2
3
4
5
6
7
8
> 1:5
[11 2 3 4 5
 
> -2.3:1
[1-2.3 -1.3 -0.3  0.7
 
> 1:-2.3
[1]  1  0 -1 -2
cs

# start가 실수면 마무리도 실수

# start가 정수면 마무리도 정수


  (3) seq(from=, to=, by=)  

# argument 명은 항상 적어주자

# seq : sequence의 약자 - 수열

# numeric vector에만 사용

# : 의 확장 개념

# from : start  /  to : end  /   by : 증가 or 감소 폭

1
2
3
4
5
6
> seq(from = 1, to = 100, by = 5)
 [1]  1  6 11 16 21 26 31 36 41 46 51 56 61 66
[1571 76 81 86 91 96
 
> seq(from = 1, to = 5, by = 0.5)
[11.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
cs


문제. 5부터 시작해서 1을 넘지 않을 때 까지 0.1씩 감소

1
2
3
> seq(from = 5, to = 3, by = -0.1)
 [15.0 4.9 4.8 4.7 4.6 4.5 4.4 4.3 4.2 4.1 4.0
[123.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0
cs

# by에는 감소는 '-' 부호가 필요하다. 


  (4) sequence(숫자)

# numeric vector 에만 적용됨

# 1 ~ '숫자' 사이의 정수로 이루어진 벡터

1
2
> sequence(10)
 [1]  1  2  3  4  5  6  7  8  9 10
cs


  (5) rep(vector, times=, each=)

# each는 vector 각각의 원소를 반복

# times는 vector를 반복

# argument 우선순위 : each > times

# numeric, character, logical vector에 적용됨

# rep : replicate의 약자


문제. "남자" 3개, "여자" 3개를 가지는 벡터를 생성

1
2
> rep(c("남자","여자"), each = 3)
[1"남자" "남자" "남자" "여자" "여자" "여자"
cs

# ex = c("남자", "여자") 를 생성하고 rep(ex, each=3)로 사용할 시 ex라는 메모리 낭비가 발생

# 필요없는 변수는 만들지 말자


* ?rep의 examples - 반올림 오차(round off error)

1. rep(1, 40*(1-.8)) # length 7 on most platforms

2. rep(1, 40*(1-.8+1e-7) # better

1
2
3
4
5
> rep(140*(1-.8))
[11 1 1 1 1 1 1
 
> rep(140*(1-.8)+1e-7)
[11 1 1 1 1 1 1 1
cs

두 코드를 실행시 1의 출력 개수가 7번, 8번으로 다른 것을 볼 수 있다.

# (1-.8) 이라는 값이 0.2지만 R상에서는 0.2에 근사한 0.199999와 같은 값을 가지는게 아닐까?

# 따라서 rep함수의 argument로 사용시 40*(1-.8)이 7이라는 값으로 인식되어서 반올림오차(round off error)가 발생 하므로,
# 1e-7 이라는 값을 더해서 문제를 해결


  (6) paste(벡터1, 벡터2, ..., sep=)

# 벡터의 각각의 원소들을 합쳐서 character 형태의 원소를 생성

# 결과는 character 형태. sep을 주지 않으면 공백이 들어간다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> paste(11)
[1"1 1"
 
> paste(11, sep="-")
[1"1-1"
 
> paste(11, sep="")
[1"11"
 
> paste("x"1, sep="")
[1"x1"
 
> paste("X"1:4, sep="")
[1"X1" "X2" "X3" "X4"
cs

# 재활용 규칙과 벡터화가 같이 적용됨



2. 벡터의 속성

  (1) length(벡터) 

# 벡터가 가지는 원소의 개수

1
2
3
> age = c(262725)
> length(age)
[13
cs

  (2) names(벡터)

# 원소의 이름

1
2
3
4
5
6
7
8
> age = c(262725)
> age
[126 27 25
 
> names(age) = c("Ha""Jeong""Kim")
> age
   Ha Jeong   Kim 
   26    27    25 
cs

# age는 하나의 열을 가지는 벡터일뿐 names는 age 벡터의 부수적인 설명 역할

# NA(Not Available) - Missing Value = 결측치, 결측값

# 전체에서 특정 부분에 데이터가 없는 경우

# NULL : 객체, 개체(Object) 자체가 없는 경우

# 데이터를 그래프로 나타낼 때 NA는 특정 값이 존재 하지 않는 것이고,

# NULL은 그래프 자체가 없다는 의미



3. 벡터의 슬라이싱(Slicing) = 인덱싱(Indexing)

     # 벡터 중 일부의 원소(들)을 추출

     # 벡터[index]

     # R에서 index는 1부터 시작한다


문제. 1,4,5 번째 원소를 한번에 가져오기

1
2
3
> income = c(50010003500400300)
> income[c(1,4,5)] 
[1500 400 300
cs


문제. 2번째 부터 5번째 가져오기

1
2
> income[2:5
[11000 3500  400  300
cs


문제. 홀수 번째 원소 값 가져오기 

1
2
3
4
> income[seq(from = 1
             to = length(income), 
             by = 2)] 
[1]  500 3500  300
cs



4. 벡터의 연산 : +, -, *, /

     # R의 특징 - 재활용 규칙(Recycling Rule)

1
2
3
4
5
> v1 = 1:3
> v2 = 4:6
> v3 = v1 + v2
> v3
[15 7 9
cs


1
2
3
> v3 = 1:6
> v1 + v3
[12 4 6 5 7 9
cs

# 데이터의 개수 v1 = 3 / v3 = 6

# 연산시 데이터의 개수가 큰 만큼 채워준다.

# Recycling Rule


# Warning message

1
2
3
4
5
6
> v4 = 1:8
> v1 + v4
[1]  2  4  6  5  7  9  8 10
Warning message:
In v1 + v4 :
  longer object length is not a multiple of shorter object length
cs

# Warning message는 R이 결과에 이상이 있는거 같지 않니? 라고 물어봐주는 역할

# 결과에 문제가 없다면 그냥 사용하면 된다.


+ Recent posts