앤드류응 교수님 딥러닝 학습일지 실습-(2) (부제:야옹~난 고양이야!)

 

딥러닝에 대한 애정이 떨어지고 있던 찰나였습니다. 정말 간단한 회귀 분석 모델 만들라는 실습을 해결하지 못한지가 일주일째...하지만 이해해 버렸읍니다..! 설레는 마음을 갖고 과정을 기록해보겠습니다.

---

실습의 전체적인 과정은 다음과 같습니다. 고양이인지 아닌지 구분하는 간단한 알고리즘을 선형회귀로 구현하는 것입니다. 209개의 train set 와 50개의 test set가 주어집니다. Train set 각각의 그림에는 x 데이터와 y 데이터가 있습니다. x데이터는 그림의 픽셀 값이며, y데이터는 고양이인지, 아닌지를 0과1을 통해 나타내는 값입니다.

---

본격적인 학습을 시작하기전에 train_set를 만지는 과정이 필요합니다. train set를 조절하는 과정은 다음과 같습니다.

1.train_set와 test_set의 dimemsion 파악하기

2.하나의 열 벡터로 reshape해주기 (ex.(64*64*3,1))로 만들어주기

3.data를 standardize해주기

 

코드로 나타내면 다음과 같습니다.

from lr_utils import load_dataset
train_set_x_orig,train_set_y,test_set_x_orig,test_set_y,classes=load_dataset()

 

일단 강의 사이트에서 다운 받은 lr_utils을 통해 데이터를 불러줍니다.

input 데이터의 경우 

차원을 파악하고, reshape하고, 올바르게 가공하는 과정이 필요합니다.

#차원 파악
m_train=train_set_x_orig.shape[0]
m_test=test_set_x_orig.shape[0]
num_px=train_set_x_orig.shape[1]
#reshape
train_set_x_flatten=train_set_x_orig.reshape(train_set_x_orig.shape[1]*train_set_x_orig.shape[2]*train_set_x_orig.shape[3],train_set_x_orig.shape[0])
test_set_x_flatten=test_set_x_orig.reshape(test_set_x_orig.shape[1]*test_set_x_orig.shape[2]*test_set_x_orig.shape[3],test_set_x_orig.shape[0])
#재정의
train_set_x=train_set_x_flatten/255
test_set_x=test_set_x_flatten/255

 

다음으로는 파라미터를 초기화 해줍니다.

선형회귀에서는 0으로 초기화 해줘도 아무 상관이 없습니다.

def initialize_with_zeros(dim):
    w=np.zeros((dim,1))
    b=0
    assert(w.shape==(dim,1))
    assert(isinstance(b,float) or isinstance(b,int))
    return w,b

 

다음으로는 propagate를 해줍니다.

(정방향을 통한 계산, 역방향을 통한 미분)

def propagate(w,b,X,Y):
    #front propagtion
    m=X.shape[1]
    A=sigmoid(np.dot(w.T,X)+b)
    cost=np.sum(Y*np.log(A)+(1-Y)*np.log(1-A))/-m
    #backward propagation
    dw=np.dot(X,(A-Y).T)/m
    db=(np.sum(A-Y))/m
    assert (dw.shape == w.shape)
    assert (db.dtype == float)
    cost = np.squeeze(cost)
    assert (cost.shape == ())

    grads = {"dw": dw,
             "db": db}

    return grads, cost

 

미분계수를 구했으면 값을 업데이트 해줘야하죠.

def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost=False):
    costs=[]
    for i in range(num_iterations):
        grads,cost=propagate(w,b,X,Y)
        dw=grads['dw']
        db=grads['db']

        w=w-(learning_rate*dw)
        b=b-(learning_rate*db)
        if i % 100 ==0:
            costs.append(cost)
        if print_cost and i % 100 ==0:
            print("cost after iteration %i %f" % (i,cost))
    params={"w":w,
            "b":b}
    grads={"dw":dw,
           "db":db}
    return params,grads,costs

 

결과값이 0.5이상이면 고양이고 아니면 고양이가 아닌 함수를 정의해줍니다.

def predict(w,b,X):
    m=X.shape[1] #number of training sets
    Y_prediction=np.zeros((1,m))
    w=w.reshape(X.shape[0],1)
    A = sigmoid(np.dot(w.T, X) + b)
    for i in range(A.shape[1]):
        if A[0,i]>=0.5:
            Y_prediction[0,i]=1
        else:
            Y_prediction[0,i]=0
    return Y_prediction

 

이제 이걸 하나로 합치면

def model(X_train,Y_train,X_test,Y_test,num_iterations=2000,learning_rate=0.5,print_cost=False):
    w,b=initialize_with_zeros(X_train.shape[0])
    parameters,grads,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)
    w=parameters['w']
    b=parameters['b']
    Y_prediction_test=predict(w,b,X_test)
    Y_prediction_train=predict(w,b,X_train)
    print("train_accurary:{}%".format(100-np.mean(np.abs(Y_prediction_train-Y_train))*100))
    print("train_accurary:{}%".format(100-np.mean(np.abs(Y_prediction_test - Y_test))*100))
    d = {"costs": costs,
         "Y_prediction_test": Y_prediction_test,
         "Y_prediction_train": Y_prediction_train,
         "w": w,
         "b": b,
         "learning_rate": learning_rate,
         "num_iterations": num_iterations}

    return d
d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 100000, learning_rate = 0.005, print_cost = False)

 

뿅! 완성

70%의 정확도를 가지는 아주 간단한 이미지 인식 알고리즘이 생긴겁니다. 이렇게나 쉽다니...하지만 선형회귀로는 명확한 한계가 존재합니다. 다음 시간 실습으로 확인해보시죠.