1. Titanic 데이터에 대한 시그모이드와 교차 엔트로피를 통한 이진 분류

https://cjstntjd.tistory.com/4

3. 이진 판단 문제

https://cjstntjd.tistory.com/5

4. 시그모이드 함수

https://cjstntjd.tistory.com/6

5. 확률 분포와 정보엔트로피

알아본대로 동작하는지 확인을 해보자

타이타닉 데이터에 대한 시그모이드의 교차엔트로피를 통한 단츨 퍼셉트론 연산을 한다.

 

import pandas as pd
import numpy as np

np.random.seed(1234)
def randomize():
    np.random.seed(time.time())

# 하이퍼 파라미터
RND_MEAN = 0
RND_STD = 0.0030

LEARNING_RATE = 0.001

캐글에 제출할게 아니라 시그모이드와 교차엔트로피에 대한 동작 여부 등에 대한 간단한 실험 이니까 EDA를 빡세게 하지는 않는다. 

그냥 필요 없는거 날리고 빈칸 채우고 라벨링 다시 하는 정도로 빨리 하고 넘어간다.

 

def load_and_basic_EDA():
    global data
    train_df = pd.read_csv('train.csv')
    test_df = pd.read_csv('test.csv')

    train_df.drop(['Name','Age','Ticket','Fare','Cabin'],inplace= True,axis=1)
    test_df.drop(['Name','Age','Ticket','Fare','Cabin'],inplace= True,axis=1)

    data=[train_df,test_df]
    for dataset in data:
        dataset.Embarked=dataset.Embarked.fillna('S')

    genderMap={"male": 0,"female" :1}
    embarkedMap={"S": 0,"C" :1,"Q" :2}
    data=[train_df,test_df]
    for dataset in data:
        dataset['Sex']=dataset['Sex'].map(genderMap)
        dataset['Embarked']=dataset['Embarked'].map(embarkedMap)

    data=train_df.drop(['PassengerId'],axis=1)


    data = np.asarray(data)

 

메인 함수는 이렇다. 

 

def titanic_exac(epoch_cnt=300,mb_size=100,report=1):
    load_and_basic_EDA()
    init_model()
    train_test(epoch_cnt,mb_size,report)

데이터에 대한 기본 작업만 실시해서 입력으로서 동작만 하는 정도로 만든다. 

마지막에 상단 칼럼을 제거 하기 위해 asarray를 반드시 붙여주자 

 

def init_model():
    global weight,bias,input_cnt, output_cnt
    input_cnt, output_cnt = 5, 1

    weight = np.random.normal(RND_MEAN,RND_STD,[input_cnt, output_cnt])
    bias = np.zeros([output_cnt])

출력은 [1,5]행렬이다. 여러 칼럼을 날렸다는 점을 기억하자

 

def train_test(epoch_count, mb_size, report):
    step_count = arrange_data(mb_size)
    test_x, test_y = get_test_data()
    
    for epoch in range(epoch_count):
        losses, accs = [], []
        
        for n in range(step_count):
            train_x, train_y = get_train_data(mb_size, n)
            loss, acc = run_train(train_x, train_y)
            losses.append(loss)
            accs.append(acc)
            
        if report > 0 and (epoch+1) % report == 0:
            acc = run_test(test_x, test_y)
            print('Epoch {}: loss={:5.3f}, accuracy={:5.3f}/{:5.3f}]'.format(epoch+1, np.mean(losses), np.mean(accs), acc))
            
    final_acc = run_test(test_x, test_y)
    print('\nFinal Test: final accuracy = {:5.3f}'.format(final_acc))

학습과 테스트는 다음과 같다. 

 

데이터를 mb_size 만큼 가져와 학습하고 정확도와 loss를 뽑아낸다. 

그리고 그 학습한 모델을 테스트 데이터 셋으로 검증 한다. 

 

def arrange_data(mb_size):
    global data, shuffle_map, test_begin_idx
    shuffle_map = np.arange(data.shape[0])
    np.random.shuffle(shuffle_map)
    step_count = int(data.shape[0] * 0.8) // mb_size
    test_begin_idx = step_count * mb_size
    return step_count

데이터를 뽑아 셔플하고 인덱스를 넘기는 과정을 위와 같다. 

 

def get_test_data():
    global data, shuffle_map, test_begin_dix, output_cnt
    test_data = data[shuffle_map[test_begin_idx:]]
    return test_data[:, :-output_cnt], test_data[:, -output_cnt:]

def get_train_data(mb_size, nth):
    global data, shuffle_map, test_begin_idx, output_cnt
    if nth == 0:
        np.random.shuffle(shuffle_map[:test_begin_idx])
    train_data = data[shuffle_map[mb_size*nth:mb_size*(nth+1)]]
    return train_data[:, :-output_cnt], train_data[:, -output_cnt:]

학습,테스트 데이터를 가져와 라벨을 분리 하고 

def forward_neuralnet(x):
    global weight, bias
    output = np.matmul(x, weight) + bias
    return output, x

def forward_postproc(output, y):
    entropy = sigmoid_cross_entropy_with_logits(y, output)
    loss = np.mean(entropy)
    return loss, [y, output, entropy]

def backprop_postproc(G_loss, aux):
    y, output, entropy = aux
    
    g_loss_entropy = 1.0 / np.prod(entropy.shape)
    g_entropy_output = sigmoid_cross_entropy_with_logits_derv(y, output)
    
    G_entropy = g_loss_entropy * G_loss
    G_output = g_entropy_output * G_entropy
    
    return G_output

def backprop_neuralnet(G_output, x):
    global weight, bias
    g_output_w = x.transpose()
    
    G_w = np.matmul(g_output_w, G_output)
    G_b = np.sum(G_output, axis=0)
    
    weight -= LEARNING_RATE * G_w
    bias -= LEARNING_RATE * G_b

순차 학습 및 역전파 , 가중치 갱신은 위와 같다. 

 

def run_train(x,y):
    output, aux_nn = forward_neuralnet(x)
    loss, aux_pp = forward_postproc(output, y)
    accuracy = eval_accuracy(output, y)
    
    G_loss = 1.0
    G_output = backprop_postproc(G_loss, aux_pp)
    backprop_neuralnet(G_output, aux_nn)
    
    return loss, accuracy


def run_test(x,y):
    output, _ = forward_neuralnet(x)
    accuracy = eval_accuracy(output, y)
    return accuracy

학습 결과에 대한 테스트를 진행하고 정확도를 뽑아낸다. 

 

def relu(x):
    return np.maximum(x, 0)

def sigmoid(x):
    return np.exp(-relu(-x)) / (1.0 + np.exp(-np.abs(x)))

def sigmoid_derv(x,y):
    return y * (1 - y)

def sigmoid_cross_entropy_with_logits(z, x):
    return relu(x) - x * z + np.log(1 + np.exp(-np.abs(x)))

def sigmoid_cross_entropy_with_logits_derv(z, x):
    return -z + sigmoid(x)

앞전 포스트에서 배운 시그모이드와 크로스 엔트로피를 학습 결과 뒤에 붙여 평가한다. 

 

def eval_accuracy(output, y):
    estimate = np.greater(output, 0)
    answer = np.greater(y, 0.5)
    correct = np.equal(estimate, answer)
    return np.mean(correct)

학습하고 난 결과를 뽑아 보면 이렇게 된다.

 

좋은 수치는 아니지만 학습이 이루어 진다는 걸 확인 했다는데 의의를 두자