이지훈님의 블로그

MakeFile 튜토리얼

개발자입니다. — Tue, 28 Aug 2018 22:35:06 +0900

우선 빌드할 c파일을 생성한다.

gcc option

-o	output 파일 이름 지정
-c	object 파일 생성
-I	header file 위치 지정 -I<폴더이름>
-l	라이브러리 파일 지정 -l<파일이름>
-L	라이브러리 폴더 지정 -L<폴더이름>

main.c

#include 
int main() {
    printf("Hello World\n");
 	return 0;
}

이 파일을 빌드하기 위해서는 다음의 gcc를 이용해 실행파일을 만들어야 한다.

gcc -c main.c
gcc -o main.out main.o

gcc를 이용해 실행파일을 만들어야 한다.

이를 조금 매끄럽게 처리하는 Makefile을 생성한다.

Makefile

main.out : main.o
	gcc -o main.out main.o
	
main.o : main.c
	gcc -c main.c

Makefile은 목표(target)가 되는 main.out이 있고, 전제조건(prerequisite)이 되는 main.o, 그리고 gcc -o main.out main.o 처럼 타겟을 만들 수 있도록 하는 방법(recipe)가 있다.

< Make Rule >

< Make Rule Example >

이제 main.c를 hello word를 출력하는 hello.c, hello.h로 파일을 분리하자.

main.c

#include "hello.h" 
int main() {
    HelloWorld();
    return 0;
}

hello.c

#include 
    void HelloWorld() {
        printf("Hello World\n");
}

hello.h

void HelloWorld();

Makefile을 수정한다.

main.out : main.o hello.o
	gcc -o main.out main.o hello.o

main.o : main.c
	gcc -c main.c

hello.o : hello.c
	gcc -c hello.c

셀에서 ls를 실행하면 폴더가 복잡해진 것을 볼 수 있다. 이제 폴더를 조금 깔끔하게 정리해보자.

hello폴더를 생성하고 hello.c, hello.h를 이동시킨다.

그리고 object 파일들을 생성할 hello폴더와 라이브러리를 가지고 있는 lib폴더를 생성한다.

ROOT_DIR:=$(PWD)
HELLO_DIR=$(ROOT_DIR)/hello
OBJ_DIR=$(ROOT_DIR)/object
LIB_DIR=$(ROOT_DIR)/lib

main.out : main.o hello.o hello.a
	gcc -o main.out main.o $(LIB_DIR)/hello.a

main.o : main.c
	gcc -c main.c -o main.o -I$(HELLO_DIR)
	
hello.a : hello.o
	ar rc $(LIB_DIR)/hello.a $(OBJ_DIR)/hello.o
	
hello.o : $(HELLO_DIR)/hello.c
	gcc -c $(HELLO_DIR)/hello.c -o $(OBJ_DIR)/hello.o

Naive Bayesian Classification (python code)

개발자입니다. — Tue, 18 Jul 2017 17:57:11 +0900

Naive Bayesian Classification < 위키피디아 >

나이브 베이즈 분류는 특성들 사이의 독립을 가정하는 베이즈 정리를 적용한 확률 분류기의 일종이다.

베이즈 정리 설명 전에 기본적인 확률에 개념을 확인해보자.

조건부 확률 (Conditional probability) < 위키피디아 >

어떤 사건 B가 일어났을 때 사건 A가 일어날 확률을 의미한다. 사건 B가 발생했을 때 사건 A가 발생할 확률은 사건 B의 영향을 받아 변하는데 이를 조건부 확률이라 한다.

사건 A와 B가 독립사건일 경우

결합 확률 (Joint Probability)

두 사건이 동시에 일어날 확률이다.

두 사건이 서로 독립이라면

독립이 아니라면

아래 그림은 Probability Tree이다.

우도 (Likelihood) < AI_STUDY >

가설 (hypothesis) H 에 대한 우도란, 어떤 시행의 결과 (Evidence) E 가 주어졌다 할 때, 만일 주어진 가설 H 가 참이라면, 그러한 결과 E 가 나올 정도는 얼마나 되겠느냐 하는 것이다. 우도는 관찰되지 않는 요인에 대해 영향을 받지 않는다.

사전확률(Priori)

특정 사상이 일어나기 전의 확률을 뜻한다. 베이즈 추론에서 관측자가 관측을 하기 전에 가지고 있는 확률 분포를 의미한다.

사후확률(Posteriori)

확률변수 관측에 대한 조건부 확률, 어떤 사건이 발생하였고, 이 사건이 나온 이유가 무엇인지 식으로 나타낸 것이다. P(A|B)로 표현한다.

(B는 관측한 사건, A는 B가 나올 수 있게 한 과거의 사건)

베이즈 정리 < 위키피디아 >

두 확률 변수의 사전 확률과 사후 확률 사이의 관계를 나타내는 정리다. 베이즈 확률론 해석에 따르면 베이즈 정리는 사전확률로 부터 사후확률을 구할 수 있다.

P(B)는 B의 사전확률, 정규화 상수의 역할을 한다.

P(A)는 A의 사전확률로

P(B|A)는 우도, 사건 A가 발생한 경우 사건 B의 확률

P(A|B)는 B값이 주어진 경우에 대한 A의 사후확률

Naive Bayes

likelihood를 구하면서 분자, 분모에 +1, +2를 더해주었다. 위의 그림처럼 likelihood를 구하는 중 학습데이터가 없는 곳을 그냥 지나친다면 당연히 P(X|Y)는 0이 나온다. 때문에 특정 값을 더하여 0이 나오는 것을 방지해한다. 또한 분모에 2를 더하여 likelihood가 1이 되는 것을 막는다.

underflow 방지

likelihood는 0~1 사이의 실수이다. likelihood를 수십번 곱하다보면 underflow가 발생할 수 있다.

때문에 로그를 취하여 log( P(X|C ) + log( P(X|C ) log( P(X|C )... 으로 계산될 수 있게 바꿔주자.

Train 과정을 통해 label 1에 대한 likelihood가 위와 같다면 계산은

log(1-0.1) + log(1-0.1) + log(1-0.1)+ log(1-0.1) + log(1-0.1)+ log(1-0.1) + log(0.8) +.... + log(P(1)) 이 된다.

1-likelihood 에 대한 계산도 필요하다.

Code < Github >

train acc는 83%, test acc는 84%이다.

import numpy as np
from pathlib import Path
import os

class Naive_Bayes:
    def __init__(self, input_size, label_size):
        self.input_size = input_size
        self.label_size = label_size

    def add_label_index(self, Y):
        label_index = np.hstack( (np.arange(Y.shape[0]).reshape(Y.shape), Y) )
        return label_index

    def get_count(self, X, label_index):
        likelihood = np.ones((self.label_size, self.input_size), dtype=np.float)
        priori = np.ones((self.label_size), dtype=np.float)

        for i in range(self.label_size):
            indices = (np.where(label_index[:,1]==i)[0])
            priori[i] += len(indices)
            total = priori[i] + 1
            likelihood[i] += np.sum(X[indices], axis=0)
            likelihood[i] /= total
        priori /= label_index.shape[0]
        return likelihood, priori

    def train(self, X, Y):
        label_idnex = self.add_label_index(Y)
        likelihood, priori = self.get_count(X, label_idnex)
        self.likelihood = np.log(likelihood)
        self.zero_likelihood = np.log(1-likelihood)
        self.priori = np.log(priori)

    def test(self, X, Y):
        predict = np.zeros( (X.shape[0], self.label_size) )
        for i in range(self.label_size):
            score = np.multiply (X, self.likelihood[i])
            score += np.multiply (X==0, self.zero_likelihood[i])
            score = np.sum(score, axis=1) + self.priori[i]
            predict[:, i] = score
        predict = (np.argmax(predict, axis=1) == Y.flatten())
        acc =  len(np.where(predict == True)[0]) / Y.shape[0]
        return acc

def load(path):
    train_data = np.genfromtxt(path+'/train_data.csv', delimiter=',', dtype=float)
    train_label = np.genfromtxt(path+'/train_label.csv', delimiter=',', dtype=float)

    test_data = np.genfromtxt(path+'/test_data.csv', delimiter=',', dtype=float)
    test_label = np.genfromtxt(path+'/test_label.csv', delimiter=',', dtype=float)
    return train_data, train_label.reshape(train_label.shape[0],1), test_data, test_label.reshape(test_label.shape[0],1)


path = Path(os.path.dirname(os.path.abspath(__file__))).parent
train_data, train_label, test_data, test_label = load(str(path) + '/data')

inpust_size = train_data.shape[1]
label_size = 10
nb = Naive_Bayes(inpust_size, label_size)
nb.train(train_data, train_label)
print ('train acc > %f' %(nb.test(train_data, train_label)))
print ('test acc > %f' %(nb.test(test_data, test_label)))

Logistic Regression

개발자입니다. — Mon, 10 Jul 2017 03:51:36 +0900

Logistic Regression < 위키피디아 >

독립 변수의 선형 결합을 이용하여 사건의 발생 가능성을 예측하는데 사용되는 통계 기법이다.

Logistic Regression은 Regression(회귀)이름이 붙어있지만 Classification문제[비가온다 vs 비가 안온다, 종양이다 vs 아니다]를 해결한다.

선형회귀를 이용해서 분류를 한다면? < 참 고1, 참고2 >

0.7을 기준으로 비가 온다(y = 1), 비가 오지않는다(y=0)로 구분한다고 가정하자.

[그림 1]과 같은 경우로 결과가 나왔으면 '괜찮네'라고 생각할 수 있다.

하지만 [ 그림 2 ] 와 같이 오른쪽에 특이한 녀석을 추가하여 학습하면 분류는 실패할 것이다.

또한 선형회귀는 0과 1 사이의 값을 가지지 않을수도 있다. (우리가 원하는 것은 0또는 1이다.)

반면에 Logistic Regression은 0과 1사이의 값으로 제한하는 로지스틱 곡선(Sigmoid Function, Logistic Function)을 사용한다. 로지스틱 회귀는 선형회귀와 유사하지만 오즈비의 로그변환을 사용한다.

로지스틱 곡선

x의 값에 상관없이 y는 무조건 0과 1사이의 값을 갖는다.

본격적인 Logistic Regression 설명 전에 오즈비에 대한 설명부터 하겠다.

오즈비 < 정말 잘 설명한 블로그 >

오즈비란 x가 한 단위 증가할 때, y = 1일 확률과 Y = 0일 확률의 비의 증가율이다.

조금 더 쉽게 설명하면 오즈비 = p / 1- p 로

사건이 발생할 확률 / 사건이 발생하지 않을 확률로 표현할 수 있다.

여기서 우리가 원하는건 x의 범위는 [-∞, ∞], y의 범위는 [0. 1] 이다.

오즈비를 조금 변환해야 한다.

오즈비에 자연로그(자연상수 e를 밑으로 하는 로그)를 취한다.

(독립 변수들의 선형 결합)

이제 x의 범위는 [0,1] y의 범위는 [-∞, ∞]이다.

식을 변형하자.

역수를 취하고 p에 대한 함수로 만들어야 한다.

Data (다운로드, 데이터셋 보기 )

아래 데이터를 분류해보자. (Income항목과 Residence Length항목은 정규화가 필요해 보인다.)

Maximum Likelihood Estimation ( 최대우도법 )

어떤 확률변수에서 표집한 값들을 토대로 그 확률변수의 모수를 구하는 방법이다. 어떤 모수가 주어졌을 때, 원하는 값들이 나올 가능도를 최대로 만드는 모수를 선택하는 방법이다. ( 'X-variable 대해 likelihood를 가장 크게 해 주는 theta를 찾는 것', )

방법은 위키피디아의 설명을 붙여넣겠다.

아래 그림에서 가능도가 최대가 되기 위해서는 Buy(1)과 같이 target이 0인 경우에는 ( 1 - target )을 해준다. 만약 ( 1 - target )을 하지 않으면 가능도는 0.1 X 0.9가 되므로 적절치 않다. 이걸 수식으로 나타내면

Gradient Descent

Hypothesis

h(x)는 hypothesis(가설)이다.

hypothesis의 의미는 우리가 원하는 y값을 예측해주는 모델이다.

머신러닝에서 Hypothesis와 Model은 종종 동일한 의미로 사용된다.

Cost Function

최대우도법을 사용하여 log함수로 만들어 주고, 양변에 -을 곱하여 최대값 문제를 최소값으로 만들어준다.

그리고 cost는 모든 데이터들로부터의 평균 비용을 구하기 때문에 1/m을 붙여준다.

Partial Derivation < 참고 >

g′(z)=ddz11+e−z=1(1+e−z)2e−z=1+e−z−1(1+e−z)2=11+e−z−1(1+e−z)2=11+e−z(1−11+e−z)=g(z)(1−g(z)

복잡하다....

Code

이제 위의 데이터셋을 학습해보자.

처음에는 아무생각없이 했는데 알고보니까 label이 너무 불균형(imbalance)하다.

때문에 neg와 pos를 랜덤하게 25개씩 뽑아서 학습시켰다.

이런경우 다른 처리방법도 많은데.. 일단 빨리 끝내기위해 위와 같은 방법을 사용했다.

acc는 80~90사이

소스가 깔끔하지 않다는 것에 주의하자. (ㅠㅠ)

github : https://github.com/jihoonLee/Simple-MachineLearning

import os
import numpy as np
import math
import random

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def predict(x):
    if x > 0.5:
        return 1.
    else :
        return 0.

def shuffle_data(pos, neg, size):
    pos_tmp = pos[np.random.choice(pos.shape[0], size=(size,))]
    neg_tmp = neg[np.random.choice(neg.shape[0], size=(size,))]
    shuffle = np.concatenate( (pos_tmp, neg_tmp), axis=0 )
    np.random.shuffle(shuffle)
    return shuffle[:, 2:], shuffle[:, 1]

def load(path):
    train_data = []
    train_label = []

    csv = np.genfromtxt(path, delimiter=',', dtype=float, skip_header=1)
    length = csv.shape[0]
    tmp_arr = np.ones((length, 1))
    csv = np.hstack((csv, tmp_arr))
    csv[:,2] = csv[:,2]/csv[:,2].max()
    csv[:,9] = csv[:,9]/csv[:,9].max()

    pos = csv[np.where(csv[:,1]==1.)]
    neg = csv[np.where(csv[:,1]==0.)]

    for i in range(20):
        data, label = shuffle_data(pos, neg, 25)
        train_data.append(data)
        train_label.append(label)
    test_data, test_label = shuffle_data(pos, neg, 50)
    return train_data, train_label, test_data, test_label

path = os.path.dirname(os.path.abspath(__file__)) + '/KidCreative.csv'
train_data, train_label, test_data, test_label = load(path)
learning_rate = 0.00001
m, n = train_data[0].shape
weight = np.ones(n)

for i in range(100000):
    if i%1000==0 and i!=0:
        print ('iteration : %d' %(i))

    for data, label in zip(train_data, train_label):
        acc = 0.
        weight_tmp = np.zeros(n)
        for x, y in zip(data, label):
            h = sigmoid(np.dot(x, weight))
            error = (h - y)
            weight_tmp += (1./m * learning_rate * x * error)
        weight = weight - weight_tmp

acc=0.
for x, y in zip(data, label):
    h = sigmoid(np.dot(x, weight))
    error = (h - y)
    weight_tmp += (1./m * learning_rate * x * error)
    if predict(h) == y:
        acc += 1
print ('acc - %.2f' % (acc/m))

Decision Tree + C4.5알고리즘

개발자입니다. — Mon, 3 Jul 2017 21:27:22 +0900

Decision Tree + C4.5알고리즘

c4.5 특징

1. 수치형 자료를 처리한다.

2. 불완전한 데이터를 처리한다.

3; 가지치기로 과적합을 해결한다.

GainRatio < 참고1, 참고2>

Information Gain의 문제점은 많은 측정값을 가진 속성으로 편향된다는 것이다. ID_CODE와 Outlook의 Information Gain을 구해보자.

Gain(Outlook) = E(Play) - E(Play, OutLook) = 0.94 - 0.69

Gain(ID_CODE) = E(Play) - E(Play, ID_CODE) = 0.94 - 0

ID_CODE	Outlook	Play?
1	sunny	No
2	sunny	No
3	overcast	Yes
4	rain	Yes
5	rain	Yes
6	rain	No
7	overcast	Yes
8	sunny	No
9	sunny	Yes
10	rain	Yes
11	sunny	Yes
12	overcast	Yes
13	overcast	Yes
14	rain	No

Gain Ratio는 Gain을 split info로 나누어준다. 수식을 보자.

SplitInfo에 대한 설명은 번역하기 애매해서 원문 그대로 적겠다.

The split information value represents the potential information generated by splitting the training data set D into v partitions, corresponding to v outcomes on attribute A.

Gain(A)는 이전 글에서 Gain을 구하는 방법과 똑같다. (예 : E(Play) - (Play, OutLook))

Gain(OutLook) = 0.25

SplitInfo는 Sunny 항목 5개, Overcast 4개, Rain 5개로,

GainRatio(OutLook) = 0.1585, GainRatio(ID_CODE) = 0.25이다. Gain(Outlook) = 0.25, Gain(ID_CODE) =0.97보다 GainRatio가 더 변별력(?) 있다. 하지만 GainRatio(ID_CODE)가 가장 높은 수치이다. 이런 경우 직접 속성을 제거해야한다...ㅠㅠ;;

수치형 자료의 엔트로피 계산

Humidity	Play?
85	No
90	No
78	Yes
96	Yes
80	Yes
70	No
65	Yes
95	No
70	Yes
80	Yes
70	Yes
90	Yes
75	Yes
80	No

속성을 정렬(Sort)한다.

Humidity = {65, 70, 75, 78, 80, 85, 90, 95}

각각 수치별로 Gain을 구한다.

		Humidity
		X<=65	X>65
PLAY	YES	1	8
PLAY	NO	0	5

이런식으로 모두 구하면

80을 기준으로 나누는게 가장 큰 Entropy를 가지므로, Gain(T, Humidity)는 0.102가 된다.

불완전한 데이터 처리 < 참고 >

Outlook	Play?
sunny	No
?	No
?	Yes
rain	Yes
rain	Yes
rain	No
overcast	Yes
?	No
?	Yes
?	Yes
?	Yes
overcast	Yes
overcast	Yes
rain	No

엔트로피 계산은 누락값을 제외하고 계산한다.

Gain은 속성의 누락값을 제외한 비율로 가중된다.

SplitInfo는 누락값을 하나의 항목으로 생각하고 계산하면 된다.

가지치기 ( pessimistic pruning ) < 참고 >

pessimistic pruning은 통계적 보정방법을 사용하며 에러를 측정하기위해 Validation set과 test set을 필요로하지 않는다.

상위 신뢰한계를 사용하여 오류를 추정한다.

z-score부분은 나중에 보충해야겠다.ㅠㅠ

그림으로 이해하자.

Decision Tree + ID3알고리즘

개발자입니다. — Sat, 1 Jul 2017 23:18:58 +0900

Decision Tree(결정트리)

어떤 항목에 대한 관측값과 목표값을 연결시켜주는 예측 모델로써 결정 트리를 사용한다.

장점

1. 결과를 해석하고 이해하기 쉽다.간략한 설명만으로 결정 트리를 이해하는 것이 가능하다.

2. 자료를 가공할 필요가 거의 없다.다른 기법들의 경우 자료를 정규화하거나 임의의 변수를 생성하거나 값이 없는 변수를 제거해야 하는 경우가 있다.

3. 수치 자료와 범주 자료 모두에 적용할 수 있다.

4. 대규모 데이터 세트도 잘 동작한다.

한계

1. 휴리스틱 기법을 기반하기 때문에 최적 결정트리라고 보장할 수 없다.

2. 너무 복잡한 결정트리를 만들 수 있다.

3. 약간의 차이에 따라 (레코드의 개수의 약간의 차이) 트리의 모양이 많이 달라질 수 있다. 두 변수가 비슷한 수준의 정보력을 갖는다고 했을 때, 약간의 차이에 의해 다른 변수가 선택되면 이 후의 트리 구성이 크게 달라질 수 있다.

알고리즘 : ID3, C4.5, CART 등이 있다.

ID3알고리즘 (범주형 자료만 분류 가능)

1. 루트노드 생성

2. 현재 트리에서 모든 단말노드에 대해서 아래를 반복한다.

A. 해당 노드의 샘플들이 같은 클래스이면, 해당 노드는 단말노드가 되고, 해당 클래스로 레이블을 부여

B. 더 이상 사용할 수 있는 속성이 없으면 수행 종료

C. Information Gain이 높은 속성을 선택해서 노드를 분할

Entropy (평균 정보량)

출력값을 나타내기 위해 필요한 평균 비트 수

확률분포에 대한 기대값

공이 8개가 있다.

여기서 어떤 하나의 공을 뽑을 확률은 1/8이고, 이 때 정보량은 3(bit)이다. 어떤 공인지 찾기 위해 3번의 질문이 필요하다는 의미이다.

문제를 바꿔서, 빨간공이 3개, 파란공이 5개 있을 경우의 엔트로피를 계산해보자.

이 때의 엔트로피는 약 0.953이다. 정보량에 해당 공을 뽑을 확률을 한 번 더 곱해줘야 한다.

즉 가중평균으로 엔트로피를 구한다.

엔트로피 참고자료 : http://www.aistudy.com/control/information_theory.htm

Information Gain

원래의 엔트로피와 세부 클래스로 분할된 후의 엔트로피의 차이이다.

information Gain이 클수록 분류하기 좋다는 것을 의미

ID3알고리즘은 Information Gain를 사용하여 노드를 결정한다.

직접 Information Gain을 계산해보자. Outlook, Temp, Humidity, Windy 등을 보고 언제 테니스를 치는지에 대해 분류하는 예제이다.

Outlook	Temperature	Humidity	Windy	Play?
sunny	hot	high	FALSE	No
sunny	hot	high	TRUE	No
overcast	hot	high	FALSE	Yes
rain	mild	high	FALSE	Yes
rain	cool	normal	FALSE	Yes
rain	cool	normal	TRUE	No
overcast	cool	normal	TRUE	Yes
sunny	mild	high	FALSE	No
sunny	cool	normal	FALSE	Yes
rain	mild	normal	FALSE	Yes
sunny	mild	normal	TRUE	Yes
overcast	mild	high	TRUE	Yes
overcast	hot	normal	FALSE	Yes
rain	mild	high	TRUE	No

Play의 엔트로피 계산

E(Play, Outlook)

		Play
		Yes	No	Total
Outlook	sunny	3	2	5
	overcast	4	0	4
	rain	3	2	5

E(Play,Temperature )

		Play
		Yes	No	Total
Temp..	hot	2	2	4
	mild	4	2	6
	cool	3	1	4

E(Play, Humidity)

		Play
		Yes	No	Total
Humidity	high	3	4	7
Humidity	normal	6	1	7

E(Play, Windy)

		Play
		Yes	No	Total
Windy	TRUE	3	3	6
Windy	FALSE	6	2	8

이제 Information Gain을 구해보자.

Infomation Gain이 가장 큰 것은 Outlook이다. Outlook으로 분류하자.

이제 Sunny에서 분류를 하자.

Outlook	Temperature	Humidity	Windy	Play?
sunny	hot	high	FALSE	No
sunny	hot	high	TRUE	No
sunny	mild	high	FALSE	No
sunny	cool	normal	FALSE	Yes
sunny	mild	normal	TRUE	Yes

Humidity를 선택할 경우 Information Gain이 가장크다. Humidity를 가지로 선택한다.

이제 트리는 다음과 같은 모양을 가지게 된다.

Humidity에 속하는 클래스들은 모드 같은 레코드를 가지므로 Humidity에서 더 이상 가지를 만들지 않는다.

Outlook	Temperature	Humidity	Windy	Play?
sunny	hot	high	FALSE	No
sunny	hot	high	TRUE	No
sunny	mild	high	FALSE	No

Outlook	Temperature	Humidity	Windy	Play?
sunny	cool	normal	FALSE	Yes
sunny	mild	normal	TRUE	Yes

이제 Outlook에서 Overcast를 선택했을 때를 보자. 이 경우도 Play가 모두 Yes로 같은 class를 가지므로 넘어간다.

Outlook	Temperature	Humidity	Windy	Play?
overcast	hot	high	FALSE	Yes
overcast	cool	normal	TRUE	Yes
overcast	mild	high	TRUE	Yes
overcast	hot	normal	FALSE	Yes

트리에 가능한 가지는 Temperature, Windy 두 속성이 남았다.

Outlook	Temperature	Windy	Play?
rain	mild	FALSE	Yes
rain	cool	FALSE	Yes
rain	cool	TRUE	No
rain	mild	FALSE	Yes
rain	mild	TRUE	No

Rainy를 선택했을 때, Windy가 가지가 된다. 그리고 Windy의 속성에 따라 Play가 모두 같은 class를 가지므로 더 이상 가지를 만들지 않는다.

더 뻗어나갈 가지가 없으므로 트리는 아래 그림으로 완성된다.

주성분분석 (Principal Component Analysis)

개발자입니다. — Thu, 29 Jun 2017 21:19:23 +0900

주성분분석 (PCA) <위키피디아>

고차원의 데이터를 저차원의 데이터로 환원시키는 기법이다. 새로운 변수를 원 변수의 선형결합으로 만들어 변수를 축약한다.

장점 : 고차원의 데이터를 큰 정보손실없이 변환해 준다.시각화 편리

-> 변수를 줄임

-> 학습집합의 크기를 줄여줌

-> 학습 시 빠름

한계 : 특징벡터의 Label을 고려하지 않음.

결과값이 특징구분을 좋게한다는 보장은 없음.

PCA분석을 이해하기 위해서는 공분산, 고유벡터와 고유값에 대한 개념이 필요하다.

공분산 <위키피디아>

2개의 확률변수의 상관정도를 나타내는 값이다.

cov(x, y) > 0 이면 x가 증가할 때 y도 증가

cov(x, y) < 0 이면 x가 증가할 때 y는 감소

cov(x, y) = 0 이면 상관관계가 없음

다른 차원과의 공분산을 모두 구하고 행렬에 넣어준다. 즉, 아래와 같은 매트릭스를 만들어 준다.

고유값과 고유벡터 <위키피디아>

A는 N*N(정방행렬)일 때,

를 만족하는 0이 아닌 벡터 x가 존재하면 λ를 고유값, 벡터 x를 고유벡터라고 한다.

아래 식에서 행렬 (3, 2)는 고유벡터, 4는 고유값이 된다.

PCA분석 (IRIS)

	sepal_len	sepal_wid	petal_len	petal_wid
145	6.7	3.0	5.2	2.3
146	6.3	2.5	5.0	1.9
147	6.5	3.0	5.2	2.0
148	6.2	3.4	5.4	2.3
149	5.9	3.0	5.1	1.8

0. 데이터를 불러온다.

import numpy as np
import numpy.linalg as linalg
from sklearn.preprocessing import StandardScaler
from numpy import genfromtxt

iris_data = genfromtxt('iris.csv', delimiter=',')
iris_data = np.array(iris_data[:,:4], dtype=np.float64)

1 .데이터를 표준화한다.

PCA는 축을 따라 분산을 최대화하는 피쳐 부분 공간을 산출하기 때문에 특히 다른 척도로 측정 된 경우 데이터를 표준화하는 것이 좋다. 아이리스 데이터 세트의 모든 기능은 센티미터 단위로 측정되었지만 많은 기계 학습 알고리즘의 최적 성능을 위해서는 단위 크기 (평균 = 0 및 분산 = 1)로 데이터를 변환한다.

iris_std = StandardScaler().fit_transform(iris_data)

2. 공분산을 구하고, 공분산의 고유벡터, 고유값을 구한다.

iris_cov = (np.cov(iris_std.T))
eig_vals, eig_vecs = np.linalg.eig(iris_cov)

3. 고유벡터와 표준화한 데이터와 행렬연산을 하여 PC1, PC2.. 등의 새로운 값을 만들어준다.

마지막 print는 확인작업이다.

PC1으로 생성된 값의 공분산은 선택한 고유벡터의 고유값과 같아야 한다.

eig_vals_sum = np.sum(eig_vals)
for eig_val in eig_vals:
    print ("contain " + str(eig_val/eig_vals_sum))

PC1 = iris_std.dot(np.reshape(eig_vecs.T[0], (4, 1)))

print (eig_vals[0])
print (np.cov(PC1.T))

전체코드

import numpy as np
import numpy.linalg as linalg
from sklearn.preprocessing import StandardScaler
from numpy import genfromtxt

iris_data = genfromtxt('iris.csv', delimiter=',')
iris_data = np.array(iris_data[:,:4], dtype=np.float64)
iris_std = StandardScaler().fit_transform(iris_data)
iris_cov = (np.cov(iris_std.T))
eig_vals, eig_vecs = np.linalg.eig(iris_cov)

eig_vals_sum = np.sum(eig_vals)
for eig_val in eig_vals:
    print ("contain " + str(eig_val/eig_vals_sum))

PC1 = iris_std.dot(np.reshape(eig_vecs.T[0], (4, 1)))

print (eig_vals[0])
print (np.cov(PC1.T))

참고자료

<영문 자료: 링크 1>

<한글 자료: 링크 2>

Python 종목코드 가져오기

개발자입니다. — Mon, 19 Jun 2017 17:02:42 +0900

Python 종목코드 가져오기

다음 금융의 코스피 시가총액 페이지에 있는 종목과 코드를 긁어온다.

sudo pip3 install urllib3
sudo pip3 install beautifulsoup4

Code

urllib로 html문서를 가져왔고, beautifulsoup을 사용해 필요한 데이터를 찾았다.

종목코드와 종목이름을 list에 넣어 파일로 저장한다.

numpy의 savatxt를 사용하려고 했지만 atom에서 자꾸 인코딩 에러가 나서 codecs를 사용해 저장했다.

#-*- coding: utf-8 -*-
from bs4 import BeautifulSoup
import numpy as np
import urllib.request
import sys
import io
import os
import codecs

download_path = os.getenv("HOME") + '/code/Korea_Finance_Analysis/data/market/KOSPI'

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

stock_code_list = list()
stock_name_list = list()
for i in range(1, 11):
    page = urllib.request.urlopen('http://finance.daum.net/quote/marketvalue.daum?stype=P&page=' + str(i) + '&col=listprice&order=desc')
    soup = BeautifulSoup(page.read().decode('utf-8'), "html.parser", from_encoding='utf-8')
    elements = soup.findAll('td', {'class' : 'txt'})
    for e in elements:
        stock_code = e.find('a')['href'][-6:]
        stock_name = e.find('a').contents[0]
        stock_code_list.append(stock_code)
        stock_name_list.append(stock_name)

f = codecs.open(download_path, 'w', "utf-8")
for code, name in zip(stock_code_list, stock_name_list):
    f.write(str(code) + ',' + str(name) + '\n')
f.close()

Python 주가데이터 가져오기

개발자입니다. — Mon, 19 Jun 2017 14:32:11 +0900

Python 주가데이터 가져오기

yahoo finance가 historical data를 제공해주지 않아 URL을 사용해 csv파일을 받는 방법이나, 파이썬의 yahoo_finacne 패키지로 데이터를 가져오는 방법 등을 더 이상 사용할 수가 없게 되었다. 열심히 구글링을 하는 중 fix_yahoo_finance 패키지를 발견했다.

fix_yahoo_finance : https://github.com/ranaroussi/fix-yahoo-finance

Requirements

Python >=3.4
Pandas (tested to work with >=0.18.1)
Numpy >= 1.11.1
requests >= 2.14.2
multitasking >= 0.0.3

Install

pip3 install fix_yahoo_finance --upgrade --no-cache-dir

Code

kospi데이터를 가져오기 위해서는 종목코드.KS를 붙여야 한다. 코스닥이라면 KQ이다.

예 : pdr.get_data_yahoo('005930.KS')

sys.stdout, sys.stderr 부분은 개발환경에서 인코딩에 문제가 없으면 삭제해도 된다.

from pandas_datareader import data as pdr
import fix_yahoo_finance
import os
import sys
import io

sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')

def download(stock_list, download_path):
    market = 'KS'
    stock_num = ''
    for stock_info in stock_list:
        stock_num = stock_info.split(',')[0]
        stock_name = stock_info.split(',')[1]
        data = pdr.get_data_yahoo(stock_num + '.' + market, start='2012-01-01', end='2017-05-31')
        data.to_csv(download_path + stock_name + '.csv')

download_path = os.getenv("HOME") + '/code/Korea_Finance_Analysis/data/stock/'
market_path = os.getenv("HOME") + '/code/Korea_Finance_Analysis/data/market/KOSPI'
f = open(market_path, encoding='utf-8')
download(f.readlines(), download_path)

Linear Regression

개발자입니다. — Thu, 20 Apr 2017 23:14:32 +0900

Linear Regression

1. 개요

통계학에서, 선형 회귀는 종속 변수 y와 한 개 이상의 독립변수 X와의 선형 상관관계를 모델링하는 회귀분석 기법 - 위키피디아 < 선형회귀 >

X = [1, 2, 3, 4, 5]

Y = [1, 2, 3, 4, 5]

Y = aX + b로 가정, 이것을 hypothesis라고 한다.

위처럼 X와 Y의 값을 가질 때, 사람은 Y = X 관계이며 만약 X가 6일때 Y가 6의 값을 가지는 것도 알 수 있음.

하지만 컴퓨터는 Y = X의 관계를 바로 찾을 수 없음.

즉 컴퓨터로 학습을 통해 독립변수 X가 들어왔을 때, Y가 어떤 값을 가질수 있는지 구하는 가장 간단한 방법이 선형회귀임.

2. 방법

0) 데이터

총 4개의 데이터가 있고 각각 (x, y) 2차원 좌표로 이루어짐. 우리의 목표는 2차원 그래프에서 X에 맞는 Y를 나타내는 1차원 선을 구하는 것!

1번 데이터 ( 2,   5 ) 
2번 데이터 ( 3,  7 )
3번 데이터 ( 4,  9 )
4번 데이터 ( 5 , 11)

1) 일단 대입

1차원 직선 y = aX+b에 난수를 넣자. [ a = 1, b = 10으로 가정]

Y = 1X + 10 그래프임.

1번 데이터의 X를 대입 y = 1 * (2) + 10 , y = 12

2번 데이터의 X를 대입 y = 1 * (3) + 10, y = 13

3번 데이터를 X를 대입 y = 1 * (4) + 10, y = 14

4번 데이터를 X를 대입 y = 1 * (5) + 10 y = 15

데이터를 보면 Y는 [5, 7, 9, 11]이 나옴. 하지만 Y = 1X + 10의 식으로 계산하면 [12, 13, 14, 15]가 나옴

2) 오차를 구하자.

오차는???

정답이 되어야할 값 [5, 7, 9 , 11]에서 식에서 나온 값 [12, 13, 14, 15]를 빼고 제곱을 함.

[ -7, -6, -5, -4 ] > [ 49, 36, 25, 16 ]

제곱을 하는 이유는???

제곱을 함으로 방향이 없어짐. 오차가 마이너스 값이든 플러스 값이든 생각할 필요없이 0에 가까울수록 오차가 줄어든다는 것을 알 수 있음.

오차의 합을 구함
오차의 합은 126
오차의 제곱의 합이 최소가 되도록 하는 방법을 최소자승법이라고 함
위키피디아 <최소자승법 설명>

오차의 평균을 구함
평균은 126/4 = 31.5
이것을 평균제곱오차(Mean Square Error)라고 함.
위키피디아 < Mean Square Error>

오차의 평균이 작을수록 데이터에 맞는 직선임..

3) 오차의 평균이 최소가 되로록 Gradient Descent

Gradient Descent는 경사하강법이라고 하며, Gradient의 반대방향으로 이동하면서 최소값을 구할 수 있는 방법임.

여기서 오차를 Cost, Loss라 하며, mean을 구하는 식(함수)을 Cost Fucntion 또는 Loss Function으로 정의함.

Cost Function, Loss Function을 최소화 하는 값을 찾아야함. 평가함수라고도 함.

다시 정리하면 비용을 구하기 위한 방법, 비용이 최소화되는지 평가하는 함수.

말들이 너무 어렵....

아래는 오차, 오차의 합, 오차의 평균을 구하는 식.

왜 평균은 2/n일까는 밑에서 설명하겠음.

이제 Mean의 식에서 a, b로 편미분을 함.

편미분 과정에서 2/n이 1/n으로 바뀌면서 식이 깔끔해짐.

계산의 편의를 위해 2를 넣는거임. ( * 안넣어도 상관없음.)

a와 b로 편미분 함으로

평가함수에서 a의 변화량, b의 변화량을 구할 수 있음.

비용함수가 최소가 되도록 a와 b의 기울기 반대 방향으로 내려가야함.

왜 반대방향인지 이해를 돕기위해 링크 첨부함.

< 알고리즘 설명 >

위 링크의 설명대로 반대 방향으로 쭉!! 가다보면 최소값을 찾을 수 있음.

근데 그냥 가다보면이 아니라 learningrate(학습율) 와 변화량만큼 이동함.

그 이유는 너무 많이 이동하면 최소가 되는 지점을 지나칠 수 있음.

최종적으로

설명이 많이 부족.

글로 이해가 안되면 코드를 참조

4) 구현

언어 : 파이썬

import random
size = 4.
dataset_x = [2, 3, 4, 5]
dataset_y = [5, 7, 9, 11]
learning_rate = 0.01
repeat = 10000

def grading_descent(a, b):
	move_a = 0
	move_b = 0
	for x, y in zip(dataset_x, dataset_y):
		move_a +=  (1 / size) * ( (-x)  *  ( y- (a * x) - b) )
		move_b +=  (1 / size) * ( (-1)  *  (y - (a * x) - b) )
	a = a - learning_rate * move_a
	b = b - learning_rate * move_b

	return a, b

if __name__ == '__main__':
	
	a = random.random()
	b = random.random()
	for i in range(repeat):
		new_a, new_b = grading_descent(a, b)
		a = new_a
		b = new_b	

	print a
	print b

Linear Classifier

개발자입니다. — Wed, 13 Jul 2016 19:00:33 +0900

Linear Classifier

1. 개요

기계학습 분야에서 통계적 분류는 개체의 속성을 이용하여 그 개체가 속하는 그룹, 또는 클래스를 판별하는 것을 목표로 한다. 선형 분류에서는 주어진 속성의 선형결합을 바탕으로 분류를 수행한다. 개체의 속성은 피쳐 값이라고 부르기도 하는데, 보통 피쳐 벡터라는 벡터 형태로 제공한다. - 위키피디아 < 선형분류 >

<그림 : 선형분류>

선형분류는 두 개의 집합(혹은 그 이상)을 나눌 때 사용할 수 있다. 분류를 할 때 주로 Neural Network, SVM을 많이 사용하지만, 개인적인 생각이지만 가장 간단한 Linear Classifier을 먼저 이해하고 neuralnet이나 다른 머신러닝 알고리즘을 공부하는 것이 더 효율적인 것 같다.

2. 방법

2차원 그래프 위에 두 집합의 특징을 나타내는 (X, Y)의 점들이 있을 때 사람은 두 집합을 분류하는 직선을 쉽게 그릴 수 있을 것이다. 하지만 컴퓨터는 직관적으로 두 집합을 구별할 수 없을 것이다. 컴퓨터가 두 집합을 나눌 수 있는 선을 그리려면 어떻게 해야 할까?

0) 데이터

총 4개의 데이터가 있고 각각 x, y, label(답)이 있다. 우리의 목표는 2차원 그래프에서 사람과 동물을 나누는 하나의 선을 찾는 것이다.

1번 데이터 x:2.9781 y:4.5651 label:사람
2번 데이터 x:3.0357 y:3.3165 label:사람
3번 데이터 x:1.5841 y:3.3575 label:동물
4번 데이터 x:2.0103 y:3.2039 label:동물

1) 로지스틱 함수를 이용하여 확률의 개념으로 바꾼다.

로지스틱 함수는 아래의 2차원 그래프에서 아래의 그림처럼 완만한 곡선모양을 이룬다. 로지스틱 함수에서 상수e(exp)는 탄젠트 곡선의 기울기에서 유도되는 특정한 실수이다.

로지스틱 함수 f(x)는 0과 1사이의 값을 가지므로 함수의 결과를 확률이라고 생각하자. 우리가 구해야 할 직선 ax+by+c를 로지스틱함수의 독립변수(입력값) x라고 생각하자.

함수의 출력값은 1번데이터가 사람이라면 1에 가깝도록, 동물이라면 0에 가깝도록 a, b, c를 바꿔야 한다.

만약 a,b,c의 값이 0.37, 1, -4일 때 직선은 0.37x+y-4가 된다. f(x)에 1번 데이터(사람)와 3번 데이터(동물)가 입력되었을 때 출력값을 확인해 보자.

P는 Probability의 약자이다.

2) 전체 확률이 최대가 되도록 해보자.

label이 동물일 때의 P(X)의 값은 0에 가깝게 a, b, c를 수정한다고 하였다. 확률 값이 최대가 되기 위해서는 label이 동물일 때는

1-P(X)를 해주어야만 최대가 되는 확률을 구할 수 있다.

1-P(X)를 정리해보자.

사람일 때는 label을 1, 동물일때는 label을 -1로 지정해주면 전체 확률의 곱은 a, b, c가 알맞은 값일 수록 1에 가까울 것이다.

3) neagtive log likelihood로 바꿔준다.

위의 수식에서 양변에 로그를 취힌다. 로그를 취하는 이유는 underflow를 피하기 위해서이다.

argmax는 함수를 최대로 하는 값을 찾는다는 의미이다.

이제 양변에 -1(negative)을 곱해주어 최대값을 찾는문제를 최소값을 찾는 문제로 바꿔준다.

negative로 만들어주는 이유는 optimization problem이 전부 minimum을 구하기 때문에, 여기서도 negative로 바꿔줘야 arg max가 arg min으로 바뀐다고 한다. - 출처

마지막으로 수식은 아래와 같이 정리가 된다. L은 loss function(손실함수) 혹은 cost function(비용함수)이라고 한다.

비용이 최소화될수록 a,b,c를 잘 찾은 것이다. 이제 a, b, c를 찾아보자.

4) Gradient Descent(경사하강법)

Gradient Descent 참고 1

Gradient Descent 참고 2

Gradient Descent란 미분을 하여 함수의 기울기를 구하고 기울기의 반대방향으로 조금씩 이동하여 최소값에 이를 때 까지 이를 반복하는 것이다.

Gradient를 구하고, 학습률(LearningLate)를 조절하여 a, b, c를 구하면 된다.

주의사항은 Graident를 모두 구하고 a, b, c를 한번에 업데이트 해야한다.

코드와 학습데이터를 첨부하였으니 이해가 가지 않으면 참고하자.

LinearClassfier.zip

이지훈님의 블로그

MakeFile 튜토리얼

Naive Bayesian Classification (python code)

Logistic Regression

Decision Tree + C4.5알고리즘

Decision Tree + ID3알고리즘

주성분분석 (Principal Component Analysis)

Python 종목코드 가져오기

Python 주가데이터 가져오기

Linear Regression

Linear Regression

1. 개요

2. 방법

0) 데이터

1번 데이터 ( 2, 5 ) 2번 데이터 ( 3, 7 )3번 데이터 ( 4, 9 )4번 데이터 ( 5 , 11)

1) 일단 대입

2) 오차를 구하자.

3) 오차의 평균이 최소가 되로록 Gradient Descent

4) 구현

Linear Classifier

Linear Classifier

1. 개요

2. 방법

0) 데이터

1번 데이터 x:2.9781 y:4.5651 label:사람2번 데이터 x:3.0357 y:3.3165 label:사람3번 데이터 x:1.5841 y:3.3575 label:동물4번 데이터 x:2.0103 y:3.2039 label:동물

1) 로지스틱 함수를 이용하여 확률의 개념으로 바꾼다.

2) 전체 확률이 최대가 되도록 해보자.

3) neagtive log likelihood로 바꿔준다.

argmax는 함수를 최대로 하는 값을 찾는다는 의미이다.

4) Gradient Descent(경사하강법)

1번 데이터 ( 2, 5 )
2번 데이터 ( 3, 7 )
3번 데이터 ( 4, 9 )
4번 데이터 ( 5 , 11)

1번 데이터 x:2.9781 y:4.5651 label:사람
2번 데이터 x:3.0357 y:3.3165 label:사람
3번 데이터 x:1.5841 y:3.3575 label:동물
4번 데이터 x:2.0103 y:3.2039 label:동물