데이터의 종류

데이터는 크게 범주형, 수치형 두 가지 분류로 나눌 수 있다.

범주형 데이터는 범주/카테고리를 구분하는 각각의 이름을 갖는 데이터 종류다.

ex) 성별 - 여성, 남성 / 학력 - 초졸, 중졸, 대졸, 대학원졸 / 출신 학교 - 고려대학교, 연세대학교, ...

반면 수치형 데이터는 말그대로 숫자로 표시되는 자료들이다.

ex) 나이 - 1살, 2살, ... / 키 - 160cm, 161cm, ... / 몸무게 - 50kg, 51kg, ...

범주형 데이터(질적 자료)

범주형 데이터는 또 순위형, 명목형이라는 두 가지 하위 분류로 다시 나누어진다.

순위형 데이터는 각 데이터별로 순위가 나누어져 있는 데이터들이다.

예를 들어 만족도 데이터를 생각해보면, 5점과 1점은 동등한 자격을 갖는 데이터가 아니다. 보통 5점이 1점보다 더 높은 순위를 가지기 때문이다. 따라서 만족도 데이터는 순위형 데이터이다.

명목형 데이터는 반대로 각 데이터별 순위가 없는 데이터이다.

성별 데이터는 여성과 남성으로 이루어지는데 둘 사이의 순위를 매길 수 없으므로 명목형 데이터이다.

수치형 데이터(양적 자료)

수치형 데이터 역시 이산형, 연속형이라는 두 하위 분류로 나눌 수 있다.

이산형 데이터는 데이터와 데이터 사이에 끊어짐이 있다.

물건의 개수와 같은 예시를 들 수 있다. 1개와 2개 사이인 개수를 정의할 수 없으므로 물건의 개수는 이산형 데이터이다.

반면 연속형 데이터는 데이터와 데이터 사이에 끊어짐이 없다.

키는 160cm와 161cm 사이에 무수히 많은 값을 가질 수 있으므로, 연속적이라고 볼 수 있으며 따라서 연속형 데이터에 해당한다.

범주형 데이터 시각화

범주형 데이터를 시각화하기 위해서 seaborn, matplotlib을 이용한다.

import seaborn as sns
import matplotlib.pyplot as plt

상단의 파일을 사용하였다.

1) 범주형 변수 1개

범주형 변수를 시각화하기 위해서 막대그래프나 원그래프를 그릴 수 있다.

막대그래프의 경우 pandas의 기능 중 하나인 plot.bar()를 사용할 수 있다.

image = df['grade'].value_counts().plot.bar()

막대그래프를 그리는 다른 방법에는 seaborn의 카운트도표 sns.countplot()이 있다.

sns.countplot(x = 'grade', data = df)

원그래프는 plt.pie()를 이용한다.

plt.pie(x = df['grade'].value_counts(), labels = [1, 2, 3, 4, 5], autopct='%.1f%%')

2) 범주형 변수 + 수치형 변수 시각화

① sns.lineplot(): 명목형 + 수치형(연속형 + 이산형)

② sns.scatterplot(): 명목형 + 수치형(연속형 + 연속형)

③ sns.barplot(): 명목형 + 연속형

④ sns.pointplot(): 명목형 + 연속형

⑤ sns.boxplot(): 명목형 + 연속형 

⑥ sns.violinplot(): 명목형 + 연속형

굉장히 다양한 방법으로 시각화가 가능하므로 때에 따라 적절하게 시각화 방법을 고르면 된다.

이중에서 scatterplot을 한 번 그려보자.

sns.scatterplot(x = 'weight', y = 'height', data = df, hue = 'grade')

weight와 height 사이의 scatterplot을 그렸지만, hue를 통해 grade별로 다르게 표시하였다.

grade는 범주형 변수이고 나머지는 수치형이므로 범주형, 수치형 사이 데이터를 시각화하는 방법이 될 수 있다.

수치형 데이터 시각화

1) 수치형 변수 1개

히스토그램을 그려서 수치형 변수를 시각화해보자. plt.hist()를 이용할 수 있다.

plt.hist(df['height'])

구간의 개수는 hist의 인자인 bins에 값을 넣어주면 된다.

히스토그램에 확률밀도함수를 추가하여 그리는 방법도 있다. sns.displot()를 이용하면 다음과 같다.

sns.distplot(df['weight'])

sns.boxplot()을 통해 박스플롯을 그릴 수 있다. min, max, Q1, Q2, Q3, outlier를 확인할 수 있다.

plt.figure(figsize = (6, 8))
sns.boxplot(y = 'weight', data = df)
plt.show()

2) 수치형 변수 2개

① sns.lineplot(): 연속형 + 이산형

② sns.scatterplot(): 연속형 + 연속형

③ sns.regplot(): 연속형+ 연속형

다양한 방법으로 시각화가 가능하다. 어떤 방법으로 시각화를 했을 때 데이터가 가장 잘 드러나는지는 연습해볼 필요가 있는 것 같다.

선형 회귀 (Linear Regression) 란 무엇인가?

회귀란 x값에 대응하는 y값과 가장 가까운 값(y hat)를 출력하는 함수를 찾는 과정이다. 여기에서 사용하는 함수가 선형 함수라면 선형회귀라고 볼 수 있다.

선형회귀를 사용하는 이유는 그 단순함에 있다. 각 피쳐의 계수와 목표하는 변수 사이의 관계를 보다 더 직관적으로 표현할 수 있기 때문이다.

선형 회귀의 종류

- 단순 선형 회귀

피쳐(x)가 하나뿐인 모델이고 목표 변수와 피쳐가 같은 좌표평면에 나타나는 직선 형태이다. 단순 선형 회귀는 선형 사상에 부합한다. 

- 다중 선형 회귀

피쳐(x)가 여러 개인 모델로 다차원 공간에서 존재하는 직선의 형태로 표현된다. 마찬가지로 선형 사상에 부합한다.

- 다항 회귀 (Polynomial)

피쳐는 1개뿐이지만 다항식의 형태로 나타나므로 곡선의 형태로 표현된다. 다항 회귀의 경우 지수가 늘어날 때마다 급격히 복잡해지므로 회귀 모델에서 오버피팅(overfitting, 과적합)이 발생할 가능성이 높아진다. 

비용함수

머신러닝에서는 주어진 데이터를 모델에 투입함으로써 모델을 적합하게 만드는 학습과정을 거친다. 이때 제대로 적합이 되려면 모델의 예측값과 실제 값을 줄여야 한다. 모델의 예측값과 실제 값의 차이를 비교하는 함수를 비용(cost) 함수라고 부른다. 비용함수는 모델의 특성에 맞게 오차를 측정하는 역할을 하며, 보통 비용함수 값이 작을수록 오차가 작으며 모델이 잘 학습되었다는 것을 의미한다.

다음과 같은 비용함수를 사용할 수 있다.

단순 선형 회귀 구현

sklearn (싸이킷런) 을 이용한다. 모델 코드를 구현할 때 다음과 같은 모듈을 사용하였다.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import r2_score, mean_squared_error

학습, 검증 데이터를 분리하여야 하므로 다음과 같은 함수를 이용한다.

X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state = 156)

x, y는 데이터에서 불러온 각각의 x, y 값들이다.

test_size는 검증 데이터로 분리할 데이터의 비율을 지정해준다. random_state는 아무 숫자나 적는다.

데이터셋들로 학습을 하려면 다음과 같은 과정을 거친다.

lr = LinearRegression(fit_intercept = True)
lr.fit(X_train, y_train)

fit_intercept를 True로 설정하여 단순 선형 회귀 모델에 b0값도 포함시킨다.

이후 lr.fit을 통해 학습시킨다.

lr.coef_ # b값들의 array
lr.coef_[0] # b1 값에 접근
lr.intercept_ # b0 값 (절편)에 접근

모델에서 coef_를 이용하면 b값들의 array를 구할 수 있고, index를 지정하여 각각에 접근할 수 있으며, intercept_는 절편, 즉 b0 값을 알려주는 메서드다.

y_train_pred = lr.predict(X_train)
y_test_pred = lr.predict(X_test)

train_r2 = r2_score(y_train, y_train_pred)
test_r2 = r2_score(y_test, y_test_pred)

lr.score(X_test, y_test)

predict 메서드를 이용하여 결과를 확인한다.

r2_score안의 파라미터는 실제 y값과 모델이 도출한 y hat 값을 받는다. r2_score가 반환하는 값이 클수록 잘 예측하였다는 뜻이다.

lr.score와 같은 방법으로도 test 결과를 확인할 수 있다.

다항 회귀 구현 - 2nd order Polynomial Regression

quad = PolynomialFeatures(degree = 2)
X_quad = quad.fit_transform(x)

quadratic regression은 2차 다항 회귀를 의미한다.

PolynomialFeatures는 파라미터를 degree로 받는데, 여기에 넣어주는 숫자에 따라서 다항회귀의 차수가 결정된다.

X_train, X_test, y_train, y_test = train_test_split(X_quad, y, random_state = 156)

plr = LinearRegression()
plr.fit(X_train, y_train)

y_train_pred = plr.predict(X_train)
y_test_pred = plr.predict(X_test)

plr.score(X_test, y_test)

train_test_split을 통해 학습, 검증데이터를 분리하고 데이터를 모델에 학습시킨다. 다음으로 모델이 얼마나 적합한지 평가할 수 있다.

만약 3차, 4차 등의 다항회귀를 해보고 싶다면 위에서 degree값만 변경시키고 나머지 과정은 똑같이 하면 된다.

Heap의 개념

힙은 트리의 일종인데, "complete tree"이거나 "nearly complete tree"이어야 한다. 그리고 다음 두 가지 종류로 나뉜다.

max-heap의 경우 각 노드의 key 값이 자식 노드들의 key 값보다 크거나 같고, min-heap의 경우 각 노드의 key 값은 자식 노드들의 key 값보다 작거나 같아야 한다.

Heap의 특성

max-heap을 기준으로 살펴보자. 힙의 root는 트리에서 가장 큰 값을 갖고 있으며, root의 왼쪽/오른쪽 서브트리도 같은 특성을 유지한다. 만약 min-heap이라면 힙의 root가 트리에서 가장 작은 값을 갖게 된다.

구현은 주로 linked list보다는 array로 이루어진다.

노드와 자식 간의 관계는 다음과 같이 확인할 수 있다.

index가 i인 노드를 생각해본다면,

1. • i번째 노드 왼쪽 자식: 2i+1
   • i번째 노드 오른쪽 자식: 2i+2
   • i번째 노드의 부모 노드: floor((i-2)/2)
   • j번째 노드가 왼쪽 자식이면, 오른쪽 자식은 j+1

Heap의 연산

Heap에서 자료를 추가하거나 삭제할 수 있으며, 순회, 검색, 출력과 같은 기능도 작동하게 할 수 있다.

다만 힙은 위에서 언급한, root의 key 값이 가장 크거나 (max-heap) 작아야 (min-heap) 하고 그 특성이 모든 서브트리에 대해서도 동일하게 유지되어야 하며, 정의했던 것처럼 (nearly) complete tree라는 특성도 유지해야 한다.

만약 노드를 추가하거나 삭제를 한 후 그냥 가만히 둔다면 힙의 정의를 만족하지 못할 것이다.

따라서 우리는 Reheap up / Reheap down 이라는 함수를 정의해서 heap의 모양을 유지하도록 한다.

수도코드의 경우, 순회, 검색, 출력 자체는 기존 트리에서 구현하는 것과 동일하므로 건너뛰고, 삽입 및 삭제의 경우는 각각 함수의 뒷부분에서 Reheap up, Reheap down함수를 불러오기만 하면 되므로 건너뛰도록 하겠다. 여기에서는 Reheap Up 및 Reheap Down에 대해서만 소개하도록 하겠다.

Reheap Up

삽입 연산을 수행하면서 같이 불러와야 하는 함수로 가장 마지막에 삽입된 요소를 위쪽으로 이동시키면서 올바른 위치에 갈 수 있게 한다. 삽입 자체는 가장 첫 번째 빈 leaf node에 들어가기 때문에 heap의 구조를 유지하기 위해서는 node를 이동시켜주어야 한다.

삽입된 노드의 부모 노드와 key 값을 비교하여, 만약 삽입된 노드가 부모 노드의 key 값보다 크면 서로 위치를 교환한다. 이 과정을 계속 반복하여 heap의 구조를 유지시킨다.

수도코드는 다음과 같다.

void reheapUp (HEAP *heap, NODE *newNode) {
	if (newNode != root) {
		parent = parent->newNode;
		if (newNode->key > parent->key) {
			swap(newNode, parent);
			reheapUp(heap,parent);
		}
	}
}

Reheap Down

heap은 nearly complete tree이므로 root을 바로 삭제하게 되면, heap의 구조가 유지되지 못한다. 따라서 last tree node의 값을 root로 옮긴 후, root를 아래로 이동시켜서 heap의 배열 특성(heap-ordering property)이 충족되도록 위치를 변경해야한다.

root 노드를 삭제할 때, 그냥 삭제하게 되면 heap의 구조가 붕괴되므로, 자식 노드 중 오른쪽 노드와 값을 교환해가며 heap 구조의 마지막 노드로 이동시킨 후 삭제한다.

수도코드는 다음과 같다.

void reheapDown (HEAP *heap, NODE *root, int last) {
	if (root->left) {
		int leftKey = root->left->key;
		if (root->right) {
			int rightKey = root->right->key;
		}
		else {
			int rightKey = NULL;
		}
	}
	if (leftKey > rightKey) {
		largeSubtree = root->left;
	}
	else {
		largeSubtree = root->right;
	}
	if (root->key < largeSubtree->key) {
		swap(root, largeSubtree);
		reheapDown(heap, largeSubtree, last);
	}
}

class & self

class(클래스)란, 데이터와 기능이 함께 묶여 있는 하나의 틀이다. 이 틀을 이용하여 여러 개의 object(객체)를 만들 수 있다. 각각의 객체는 독립적이어서 서로에게 영향을 주지 않는다.

이해하기 쉽게 예를 들어 보자.

클래스는 초콜릿을 만드는 틀과 같다. 녹은 초콜릿을 틀에 부어 초콜릿을 무한정 생산할 수 있다. 이 틀로 만들어진 각각의 초콜릿을 객체라고 생각하면 된다.

각각의 초콜릿은 독립적이므로 초콜릿에 어떤 데코레이션을 올리더라도 다른 초콜릿에는 영향을 주지 않는다.

클래스를 이용하면 같은 기능을 하는 독립적인 여러 객체를 생성할 수 있기 때문에 편리하다. 일기장 프로그램을 작성해야 하는데, 사람마다 다른 일기장을 만들어줄 때 이걸 일일이 코드로 작성하면 시간낭비, 그리고 자원낭비(!)이기 때문이다.

클래스와 객체는 다음과 같이 생성할 수 있다.

class chocoMaker:
	pass
    
a = chocoMaker() # a 객체 생성
b = chocoMaker() # b 객체 생성

아직 chocoMaker라는 클래스에 아무 값이나 기능이 포함되어있지 않다.

클래스에 함수를 포함시키는 방법은 다음과 같다.

class chocoMaker:
    def decorate(self, color, type):
    	self.color = color
        self.type = type
        
a = chocoMaker()
a.decorate('white', 'sprinkle')

클래스 내부의 함수는 method(메서드)라고 부른다.

메서드의 첫 번째 매개변수는 대개 self를 쓴다. self의 역할은 객체 자기 자신을 호출하는 것이다.

객체를 생성하고 메서드를 사용할 때는 위와 같이 객체.메서드(...) 이런 식으로 작성해야 한다. 그런데 첫 번째 매개변수였던 self는 실제로 사용할 때 입력하지 않아도 된다. 객체.메서드(...)에서 객체가 self로 자동으로 전달되기 때문이다.

만약 이 방법이 마음에 들지 않는다면 아래와 같이 작성해도 된다.

a = chocoMaker()
chocoMaker.decorate(a, 'white', 'sprinkle')

decorate 메서드의 수행문을 살펴보자.

a.decorate('white', 'sprinkle')과 같이 작성하면, a라는 객체 내부에 color, type 객체변수가 생성되고, 'white', 'sprinkle'값이 저장된다.

클래스로 만든 여러 가지 객체 간엔 독립성이 보장되므로, 한 객체의 객체변수의 값을 수정했다고 하여 다른 객체의 객체변수 값이 달라지지 않는다.

init/생성자

chocoMaker 클래스에 다른 메서드도 추가해보자.

class chocoMaker:
    def decorate(self, color, type):
    	self.color = color
        self.type = type
    def plate(self):
    	res = self.color + self.type
        return res

plate 메서드를 추가하였다. 이 상황에서 다음과 같이 코드를 작성하면 오류가 발생한다.

b = chocoMaker()
b.plate()

이유는 앞서 만들어두었던 decorate 메서드를 거치지 않고는 plate 메서드를 실행할 수 없기 때문이다.

하지만 decorate 수행 후 plate를 수행하도록 하면 불편하다. 한 번에 해결할 수 있는 방법이 없을까?

우리는 이럴 때 생성자(constructor)를 사용한다. 생성자는 객체를 생성할 때 자동으로 호출되는 메서드를 의미한다. __init__으로 사용할 수 있다.

다음 코드를 살펴보자.

class chocoMaker:
    def __init__(self, color, type):
        self.color = color
        self.type = type
    def decorate(self, color, type):
    	self.color = color
        self.type = type
    def plate(self):
    	res = self.color + self.type
        return res

c = chocoMaker('pink', 'decopen')

c라는 객체를 만들 때, decorate를 불러올 필요 없이 chocoMaker와 함께 원하는 값을 전달할 수 있다.

상속

코드를 짜다 보면 같은 속성을 갖는 새로운 클래스를 생성해야 할 필요가 있다.

예를 들어, 색깔과 데코레이션의 종류만을 갖는 chocoMaker 클래스에서 데코레이션의 개수를 추가한 클래스를 새로 만드는 경우를 생각해보자.

새로운 클래스를 생성하는 것보다 기존의 chocoMaker 클래스를 이용하여 만드는 편이 훨씬 간단하다. 이럴 때 이용하는 것이 super().__init__를 이용한 상속이다.

class superChocoMaker(chocoMaker):
    def __init__(self, color, type, num): # num 추가
        super().__init__(color, type)
        self.num = num
        
    def superPlate(self): # 기존 클래스의 메서드를 상속
        super().plate()

클래스를 생성할 때 클래스 옆 괄호 안에 상속할 클래스의 이름을 적어둔 다음, super().__init__의 input으로 상속할 기존 클래스의 요소의 이름을 적어준다.

때로는 새로 만든 클래스에서 기존의 메서드와 같은 이름을 사용하지만 다른 기능을 하는 메서드를 만들고 싶을 수 있다. 그럴 때에는 그냥 상속받은 (새로 만든) 클래스 내부에서 메서드를 다시 정의하면 된다.

기존 클래스의 메서드를 상속받고 싶을 때는 super().메서드와 같은 방식으로 작성한다.