H_record

오늘까지 해서 3일째 프로젝트를 수행하고 있는데

사실 잘 진행이 잘...ㅎㅎ;; 

심적으로 힘이 드니까 참으로 하루하루가 고역입니다

있는 그대로의 제 상태를 적어 놓는 것도 이 블로그의 특징이니까 가감없이 적고 있어요

나중에 후회나 되지 않을까 걱정도 됩니다

게다가 외부적으로 계속 스트레스 받는 일이 생겨서 

요즘 세상이 나한테 왜이러나 싶기도..

프로젝트를 처음 어떻게 구상해야할지를 정의하는데에 꽤 많은 시간을 들이고 있어요

어떻게 분석해야겠다 라는 틀이 조금씩 갖춰지고 있어요 

욕심내지 않고 배운걸 사용해본다는 생각으로 임하겠습니다. 

오늘은 미분부터 jacobian매트릭스까지 간략하게 정리하여 포스팅하겠습니다~

여담이지만 전 문과생 출신이라서 작년 자코비안 매트릭스에 대해 공부할때 정말 멘탈이 싹 나갔던 기억이 있습니다

구글링해도 개념이 잘 잡히지 않아서 일단 미루고 있었는데 과연

제가 완전하게 이해를 하게 되었을지 끝가지 읽어 주십사 합니다 ㅎㅎ 

*딥러닝에서의 미분이란 뭘까?

흔히 어떤 x가 변화했을때 y의 변화량 이라고 배워왔는데요 

그래도 뭔가 아 그렇구나 하지 와닿지는 않았더라구요 이 수업에서는 딥러닝의 미분을 아래처럼 소개 하였습니다. 

y = 2x^2를 미분하면 y=4x가 됩니다 

하늘색은 x=2를 대입할때 계수가 +8이 나왔고 x=-4를 대입하면 -16이 나왔습니다.

이 둘의 미분계수를 자세히 보겠습니다. 만일 x=2가 아니라 3,4,5 증가하면 y값이 커지게 됩니다. 

x=-4대신 -5-,6,-7 를 넣게 되면 마찬가지로 y값이 커지게 됩니다(그래프에 대입을 하면 간단하게 알수 있습니다)

결국 이 미분계수가 말하는 것은 "Y가 커지는 방향을 가르키고 있습니다"

x 가 음수로 갈수록, 그리고 양수로 갈수록 y값은 어찌됐건 증가 할 수밖에 없습니다. 

우리의 포인트는 증가하는 방향을 알고자 하는게 아닙니다. 바로 감소하는 방향입니다. 왜냐면

딥러닝은 가장 최저점으로 최적화 시켜야 하기 때문이죠. (loss를 줄여야 하니까)

그러면 간단하게 생각해 볼수 있는 것은 f(2)라는 함수에 마이너스를 붙이면 해결이 됩니다~

f(-4)를 -f(-4)로 넣어주면 반대방향으로 바뀌게 됩니다. 

위와 같은 함수가 있을때 편미분을 하면 아래처럼 계산이 됩니다.

이때 x=5, y=-5를 대입하면 (10,-10)이라는 gradient가 나옵니다.

이 (10,-10)이라는 것은 무슨 의미 일까요? 그리고 (5,-5)는 어떻게 해석하면 될까요?

(5,-5)는 단지 점!!입니다. 좌표처럼 점을 나타내는 것에 불과하고 (10,-10)은 아래 그래프를 보면서 설명하겠습니다.

x=10이고 y=-10 이니까 이 두 값이 만나는 지점이 빨간 화살표가 가르키고 있는 곳입니다.

보시다시피 원이 안에서 밖으로 퍼저나가면서 값이 커짐을 알수 있습니다. 

아까 말씀드린 것처럼 미분계수의 값은 Y가 커지는 방향을 나타냅니다.

여기서 우리의 목적은 가장 최저점인 정 가운데 부분으로 가야하기 때문에 음수를 붙여주게 됩니다.

위 같은 경우에는 함수가 스칼라(값이 하나)일 경우에 해당됩니다.

함수가 여러개가 있을수도 있고 independent variable이 여러개 일수도 있습니다. 예를들어 

함수가 하나이고, ndependent variable(변수)가 2개 경우입니다. 

여러개가 모이면 벡터가 됩니다. 선형수학에서의 꽃은 여러개 값을 한번에 계산 한다는 점이라서

이 벡터와 그리고 벡터가 모인 매트릭스 같은 연산에 대해서 잘 이해 해야 합니다 

본론으로 돌아와서

X라는 변수 벡터를 앞으로 θ로 표기하겠습니다. 변수들이 모여서 만든 벡터와, 함수들이 모여서 만들어진 벡터는

아래 이미지처럼 표현이 가능합니다.

그러면 만들수 있는 모든 경의 수를 생각해 봅시다.

그냥 스칼라값을 가진 함수와 변수가 있을테고, 위 이미지처럼 벡터인 함수와 변수가 있으므로 총 네가지의 경의 수가 발생됩니다.

정사각형 박스는 스칼라를, 길쭉한 직사각형은 벡터를 나타냅니다.

왜 이렇게 표현이 되는지는 아래 이미지로 다시 확인해 봅시다

스칼라/스칼라 인 경우는 맨 위에 해봤으니 바로 아래값에 대해 말씀드리겠습니다.

하나의 스칼라 x로 여러개의 함수를 상대해야 하므로 이미지처럼 표현이 가능하겠습니다.

(이때 함수의 갯수는 m개) 

계속해서 오른쪽 부분을 보겠습니다.

맨 위를 보면 X에 화살표가 그러져 있는 걸보니 벡터고, 함수는 스칼라 값입니다.

하나의 함수를 가지고 n개의 변수로 각각 미분을 취하는 형식입니다. 

그리고 대망의 매트릭스/매트릭스 경우인 맨 아래 입니다.

어려울거 없이 함수가 m가 있고, 변수가 n가 있을때 위 처럼 표현 하다는 것입니다.

각 row에 빨간색으로 칠해져 있는데 이 각각을 gradient라고 합니다. 

즉, 가장 큰 값을 가리키는 방향을 나타내는 벡터인 것이죠. 추가로 이 값에 그냥 마이너스를 붙이면 

가장 최저점으로 이동 시 방향을 알려줍니다. 

정리를 한자면 각 row의 gradient는 함수의 가장 큰 값 바양을 나타내므로 이 m*n 매트릭스에 -1를 곱하게 되면

감소하는 방향의 매트릭스가 됩니다.

*딥러닝에서 사용되는 Element-wise Binary operation

그런데 이 자코비안 매트릭스는 특정한 상황에서 특이한 모습을 보입니다.

바로 각 함수가 특정한 변수에만 영향을 받을 경우입니다. 

f1 함수는 θ1에 대해서만 영향이 있고, f2도 θ2에서만 있습니다. 좀더 이해하기 쉽게 다른 예제를 가져오면

알파라는 variable 벡터와 함수 벡터가 있습니다. 식을 보면 함수 하나당 한개 변수로 구성되어 있습니다.

이를 미분한다는 얘기 입니다. 딱 봐도 미분을 하게 되면 뭔가 특이한 모양이 나올거라 예상이 됩니다

위 식 처럼 계산이 이루어 집니다. 식은 복잡해 보여도 한줄 씩 뜯어보면 간단합니다. 이 매트릭스를 미분하게 되면

대각행렬(diagonal matrix)이 나오게 됩니다. 이 대각행렬의 값은 고정은 아니지만 비 대각 성분은 모두 0으로 고정되어 버립니다. 이처럼 한 함수에 한가지 변수만 영향을 주게 되면 위처럼 계산이 됩니다.

또 다른 예를 가져오면

대각성분은 다르게 나오지만 비 대각 성분은 똑같이 0으로 계산되었습니다. 이 연산이 딥러닝에서도 사용이됩니다. 

만일 이 두개를 더해서 자코비안 매트릭스를 구하면 어떻게 표현이 될까요?

바로 위 식대로 연산을 해보겠다는 의미입니다. 모든 식을 나열하기엔 너무 많아서 글로 표현을 하겠습니다. 

벡터끼리 더해지므로 

이렇게 표현이 가능합니다. 이 값을 각각 알파와 베타로 편미분을 하면 되는데, 

당연하게도 알파로 편미분을 하게되면 알파만 있는 f함수에만 적용되고 베타가 있는 g함수는 0으로 처리가 될것입니다

반대로 베타가 포함된 g함수는 적용이 되고 f함수는 0으로 떨어지게 됩니다.

이 개념을 가지고 아래 이미지를 살명하겠습니다.

Z1_1, Z1_2는 각각 n개의 independent variable로 구성되어 있습니다. Z2는 이 두 벡터를 합한 벡터입니다.

그러면 Z2를 각각 Z1_1, Z1_2로 편미분 하게 되면

Z1_2도 같은 모습으로 표현 됩니다. 대각 성분이 1로 통일되였는데 1 값이 달라지면 언제든지 바뀔수 있습니다.

여기까지가 오늘 수업에서 배운 내용을 정리한 내용입니다. 

작년의 벡터로 미분하고 매트릭스가 나온다~ 라는 수업내용을 따라가지 못해서 답답했었는데

이번 강의를 통해서 한번에 깨끗하게 해결되었습니다. 이거 때문에 작년에 서점가서 이공계 수학책을 본적이 있는데

제가 원하는 결과는 얻지 못했어요 워낙 광범위하더라구요 

그래서 이 강의 듣기 전까지는 미분하면 복잡하다 라는 인식이 있었는데 

해결이 된것같아서 뿌듯하고 재미있었습니다

오늘은 딥러닝 수학 강의를 수강하기 시작했습니다. 

chapter1을 수강했는데 간단한 딥러닝 개요와 파이썬 리뷰? 까지 수강했습니다.

class 부분은 제 약점인데 설명을 너무 잘해주셔서 실습하는 동안 신기하면서 재밌게 진행할수 있었어요

처음 class에 대해 배울때는 당최 무슨 말인지 몰랐는데 지금은 한결 수월했어요 

class 외에도 다른 문법들 복습해 보면서 자잘하게 깨달은 부분이 있었어요

내일 모레 부터는 본격적으로 수학에 관련된 내용이 진행됩니다.

수학강의는 따로 D-Day를 정하지 않고 강의 하나하나 신중하게, 이해를 위주로 천천히 곱씹으며 진도를 나갈생각입니다. 강사도 그렇게 하는게 좋다고 하더라구요 

어제는 제가 기록을 못적었지만 dacon 태양광 발전량 예측 프로젝트를 시작했었는데요

요즘들어서 마음잡고 공부하기가 정말 힘들었어요 지금도 마찬가지구욥..

게다가 요즘 부모님과 사이가 좀 틀어져서 

많은 생각들을 하게 만드는 요즘입니다 

내일만 생각하면 한숨이 절로 나오지만 최대한 힘내보도록 하겠습니다 :) ㅎㅇㅌ

남아 있던 실습프로젝트 2개를 마저 복습하면서 포스팅 작업을 진행했습니다.

어제 말씀드린 것처럼 이 강의 덕분에 얻은게 참 많았던 것같아요

자신감도 좀 붙은 것같기도 합니다

내용이 너무 많으면 핵심이 가려질것같아서 요약하여 포스팅했습니다~

만일 이 강의를 듣고 싶은 분이 있다면 패스트캠퍼스 사이트에서 찾을 수 있습니다~^^

일단 강의와 실습만으로는 체득이 안됐기 때문에 데이콘에서 시계열 데이터 관련한 프로젝트를

진행 하려고 합니다 

이미 데이터까지 받아 놔서 진행만 하면 될것같아요 다음주 월요일부터 시작할 생각입니다.

이번 참여 목표는 수상이 아니라 제가 배운 내용을 적용 하는데에 중점을 두고 진행하고자 합니다. 

마지막 실습 코드 내용은 아래에 링크 걸어 놓았습니다 :)

2021.04.16 - [실습 note] - 자전거 수요예측 실습

2021.04.16 - [실습 note] - 주택 가격 예측실습

시계열 데이터 심화 강의의 마지막 단계인 실습프로젝트들 중 주택 가격 예측실습을 포스팅하겠습니다.

본 실습은 성능보다는 어떻게 적용할지에 대한 내용만 간략하게 소개되어 있음을 알립니다.

MLP

# Data Loading
location = './Data/RealestateKorea_Gangnam/Economy.csv'
raw_all = pd.read_csv(location)
raw_all

# feature engineering
raw_all['Date'] = pd.to_Datetime(Raw_all['Date'])
raw_all.index =raw_all['Date']
raw_all = raw_all[raw_all.index >= '200-01-01']
raw_all = raw_all[raw_all.index <= '2017-12-31']
raw_all.fillna(method='bfill', inplace=True)

# Data split
Y_colname =['Price']
X_remove =['Date','price_Sido']
X_colname =[x for x in raw_all.columns if x not in Y_colname+X_remove]
X_train, X_Test, Y_train, Y_test = datasplit_ts(raw_all, Y_colname, X_colname, '2016-01-01')

# Parameters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
# sequence = 34
batch_size = 32
epoch = 20
verbose = 1
dropout_ratio = 0

# Feature Engineering
## Scaling
X_train = scaler_X_tr.fit_transform(X_train)
Y_train = scaler_Y_tr.fit_transform(Y_train)
X_test = scaler_X_tr.transform(X_test)
Y_test = scaler_Y_tr.transform(Y_test)

# MLP
model = Sequential()
model.add(Dense(128, input_shape=(train.shape[1],), activation='relu'))
model.add(Dropout(dropout_ratio))
model.add(Desne(64, activation='relu'))
model.add(Dropout(dropout_ratio))
model.add(Dense(1))
model.complie(optimizer='adam', loss='mean_squared_error')
model.summary()
model_fit=model.fit(X_train. Y_train, batch_size=batch_size,
					epochs=epoch, verbose=verbose)
pd.plot(pd.DataFrame(model_fit.history))
plt.grid(True)
plt.show()

#prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predcit(X_test)

#evaluation
result = model.evaluate(X_test, Y_test_pred)
if scaler !=[]:
	Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_test = scaler_Y_tr.inverse_transform(Y_test)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_MLP, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_train), Y_train_pred.flatten(), 
                                                      pd.DataFrame(Y_test), Y_test_pred.flatten(), graph_on=True)
display(Score_MLP)

RNN

*그래프 결과만 

LSTM

GRU

각 딥러닝 모델에 따른 결과를 출력했습니다. 각자 비슷한 성능을 보이는 가운데 여기서 한번 생각해 봐야 할 점이 있습니다. Y값은 부동산 가격입니다. 그래프를 보면 부동산 가격이 너무 변동이 심하다는 걸 볼수 있습니다. 현실적으로

올해 1억하던 매물이 내년에 갑자기 확 뛰거나 내리는 현상은 위 시각화 처럼 자주 발생하지 않습니다

뭔가 이상하다는 걸 느껴야 합니다. 입력된 데이터에서 뭔가가 잘못되었음을 알수 있습니다.

데이터 원본입니다. 빌딩 타입별로 분류가 되어 있습니다. 또한 2006-01-01의 정보를보면 건물 타입과 지역마다 여러 행으로 분리 되어 있습니다. 즉, 이를 한번에 넣고 모델을 돌리게되면 심각한 정보 왜곡이 발생됩니다. 

여기서 우리가 알고 싶은점은 부동산 가격입니다. 이 데이터는 강남지역의 부동산 데이터인데, 위 처럼 여러개의 y값이 아닌 강남 부동산 가격을 대표할만한 y를 추정해야 합니다. 강의에서는 2가지를 예시로 들었습니다.

아래 코드를 통해 어떤식으로 적용했는지 보겠습니다.

실습에 적용된 모델은 GRU로 모두 동일합니다.

CASE1: year, month의 groupby한 평균값 사용

# Data Loading
location = './Data/RealestateKorea_Gangnam/Economy.csv'
raw_all = pd.read_csv(location)
date = raw_all['Date'].unique()

raw_all = raw_all.groupby(['Year','Month']).mean().rest_index().iloc[:,2:]
raw_all['Date']= date 

# Feature Engineering
raw_all['Date'] = pd.to_datetime(raw_all['Date'])
raw_all.index = raw_all['Date']
raw_all = raw_all[raw_all.index >= '2010-01-01']
raw_all = raw_all[raw_all.index <= '2017-12-31']
raw_all.fillna(method='bfill', inplace=True)

# Data Split
Y_colname = ['Price']

#지역과 빌딩 타입은 숫자의 의미가 없기때문에 삭제
X_remove = ['Date', 'Region', 'Price_Sido', 'Building_Type']
X_colname = [x for x in raw_all.columns if x not in Y_colname+X_remove]
X_train, X_test, Y_train, Y_test = datasplit_ts(raw_all, Y_colname, X_colname, '2016-01-01')

# Parameters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
sequence = 12
batch_size = 32
epoch = 20
verbose = 1
dropout_ratio = 0
# Feature Engineering
## Scaling
X_train_scaled = scaler_X_tr.fit_transform(X_train)
Y_train_scaled = scaler_Y_tr.fit_transform(Y_train)
X_test_scaled = scaler_X_tr.transform(X_test)
Y_test_scaled = scaler_Y_tr.transform(Y_test)

## X / Y Split
X_train, Y_train = [], []
for index in range(len(X_train_scaled) - sequence):
    X_train.append(np.array(X_train_scaled[index: index + sequence]))
    Y_train.append(np.ravel(Y_train_scaled[index + sequence:index + sequence + 1]))
X_train, Y_train = np.array(X_train), np.array(Y_train)
X_test, Y_test = [], []
for index in range(len(X_test_scaled) - sequence):
    X_test.append(np.array(X_test_scaled[index: index + sequence]))
    Y_test.append(np.ravel(Y_test_scaled[index + sequence:index + sequence + 1]))  
X_test, Y_test = np.array(X_test), np.array(Y_test) 

## Retype and Reshape
X_train = X_train.reshape(X_train.shape[0], sequence, -1)
X_test = X_test.reshape(X_test.shape[0], sequence, -1)
print('X_train:', X_train.shape, 'Y_train:', Y_train.shape)
print('X_test:', X_test.shape, 'Y_test:', Y_test.shape)

# GRU
model = Sequential()
model.add(GRU(128, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(256, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(128, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(64, return_sequences=False, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.summary()
model_fit = model.fit(X_train, Y_train, 
                      batch_size=batch_size, epochs=epoch,
                      verbose=verbose)

plt.plot(pd.DataFrame(model_fit.history))
plt.grid(True)
plt.show()

# prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)

# evaluation
result = model.evaluate(X_test, Y_test_pred)
if scaler_Y_tr != []:
    Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test = scaler_Y_tr.inverse_transform(Y_test)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_GRU, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_train), Y_train_pred.flatten(), 
                                                      pd.DataFrame(Y_test), Y_test_pred.flatten(), graph_on=True)
display(Score_GRU)

CASE2: 특정한 지역과 빌딩타입을 선택

# Data Loading
location = './Data/RealestateKorea_Gangnam/Economy.csv'
raw_all = pd.read_csv(location)
raw_all = raw_all[(raw_all['Region'] == 50000) & (raw_all['Buillding_type'] == 0)]

###이하 내용은 위 GRU 실습내용과 같습니다.

case1 보다 case2가 개선된 성능을 보입니다. case2같은 경우에는 처음부터 정보왜곡이 되지 않도록 특정한 범위를 선택한 것에 반해 case1은 평균값이라고 해도 다른 여러 종류의 데이터와 섞이기 때문에 성능에서 차이가 발생했습니다.

이 실습을 통해 강사가 알리고자 한 것은 알고리즘이 전부가 아니다. 알고리즘 만큼 중요한 것이 데이터 자체에 있다는 것이였습니다. 이번 강의를 계기로 원본 데이터를 어떻게 설계하느냐가 분석에 큰 영향을 끼칠수 있다는 걸 깨닫게 되었습니다.  이 포스팅을 끝으로 시계열 데이터 심화 강의 포스팅은 마치겠습니다. 좋은 강의를 만들어주신 강사님에게 감사드립니다~ (꾸벅)

시계열 데이터 심화 강의의 마지막 단계인 실습프로젝트들 중 자전거 수요예측 실습을 포스팅하겠습니다.

본 실습은 성능보다는 어떻게 적용할지에 대한 내용만 간략하게 소개되어 있음을 알립니다.

MLP

# Data Loading
location = './Data/BikeSharingDemand/Bike_Sharing_Demand_Full.csv'
raw_all = pd.read_csv(location)

#Feature Engineering
raw_fe = feature_engineering(raw_all)
#reality
target = ['coount_trend','count_seasonal','count_Day','count_Week','count_diff']
raw_feR = feature_engineering_year_duplicated(raw_fe, target)

#Data Split
#confirm of input and output
Y_colname=['count']
X_remove=['datetime','DateTime','temp_group','casual','registered']
X_colname = [x for x in raw_fe.columns if x not in Y_colname+X_remove]
X_train_feR, X_test_feR, Y_train_feR, Y_test_feR = datasplit_ts(raw_feR, Y_colname, X_colname,'2017-07-01')
#Reality
target=['count_lag1','count_lag2']
X_test_feR =feature_engineering_lag_modified(Y_test_feR, X_test_feR, target)

#Paramters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
batch_size = 32
epoch = 10
verbose = 1
dropout_ratio = 0

# Scaling
X_train = scaler_X_tr.fit_transform(X_train_feR)
Y_train = scaler_Y_tr.fit_transform(Y_train_feR)
X_test = scaler_X_tr.transform(X_test_feR)
Y_test = scaler_Y_tr.fransform(Y_test)
'''
MLP는 시퀀스가 없기때문에 2차원 형식으로 들어가면 된다
'''

# MLP
model = Sequential()
model.add(Dense(128, input_shape=(X_train.shape[1],), activation='relu')
model.add(Dropout(dropout_ratio))
model.add(Dense(256,activation='relu'))
model.add(Dropout(dropout_ratio))
model.add(Dense(128, activation='relu'))
model.add(Dropout(dropout_ratio))
model.add(Dense(64, activation='relu'))
model.add(Dropout(dropout_ratio))
model.add(Dense(1)
model.compile( optimizer='adam', loss='mean_squard_error')
model.summary()
model_fit=model.fit(X_train, Y_train, batch_size=batch_size, epochs = epoch,
					verbose=verbose)
plt.plot(pd.DataFrame(model_fit.history)
plt.grid(True)
plt.show()

#prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)

#evaluation
result = model.evaluate(X_test, Y_Test_pred)
if scaler_T_tr !=[]:
	Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test = scaler.Y_tr.inverse_transform(Y_test)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_MLP, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_Train), Y_train_pred.flatten(),
													pd.DataFrame(Y_test), Y_test_pred.flatten(),graph_on=True)
display(Score_MLP)

RNN

# Data Loading
location = './Data/BikeSharingDemand/Bike_Sharing_Demand_Full.csv'
raw_all = pd.read_csv(location)

# Feature Engineering
raw_fe = feature_engineering(raw_all)
### Reality ###
target = ['count_trend', 'count_seasonal', 'count_Day', 'count_Week', 'count_diff']
raw_feR = feature_engineering_year_duplicated(raw_fe, target)
###############

# Data Split
# Confirm of input and output
Y_colname = ['count']
X_remove = ['datetime', 'DateTime', 'temp_group', 'casual', 'registered']
X_colname = [x for x in raw_fe.columns if x not in Y_colname+X_remove]
X_train_feR, X_test_feR, Y_train_feR, Y_test_feR = datasplit_ts(raw_feR, Y_colname, X_colname, '2012-07-01')
### Reality ###
target = ['count_lag1', 'count_lag2']
X_test_feR = feature_engineering_lag_modified(Y_test_feR, X_test_feR, target)
###############

# Parameters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
sequence = 24
batch_size = 32
epoch = 10
verbose = 1
dropout_ratio = 0

# Feature Engineering
## Scaling
X_train_scaled = scaler_X_tr.fit_transform(X_train_feR)
Y_train_scaled = scaler_Y_tr.fit_transform(Y_train_feR)
X_test_scaled = scaler_X_tr.transform(X_test_feR)
Y_test_scaled = scaler_Y_tr.transform(Y_test_feR)

## X / Y Split
X_train, Y_train = [], []
for index in range(len(X_train_scaled) - sequence):
    X_train.append(np.array(X_train_scaled[index: index + sequence]))
    Y_train.append(np.ravel(Y_train_scaled[index + sequence:index + sequence + 1]))
X_train, Y_train = np.array(X_train), np.array(Y_train)
X_test, Y_test = [], []
for index in range(len(X_test_scaled) - sequence):
    X_test.append(np.array(X_test_scaled[index: index + sequence]))
    Y_test.append(np.ravel(Y_test_scaled[index + sequence:index + sequence + 1]))  
X_test, Y_test = np.array(X_test), np.array(Y_test) 

## Retype and Reshape
X_train = X_train.reshape(X_train.shape[0], sequence, -1)
X_test = X_test.reshape(X_test.shape[0], sequence, -1)
print('X_train:', X_train.shape, 'Y_train:', Y_train.shape)
print('X_test:', X_test.shape, 'Y_test:', Y_test.shape)

# RNN
model = Sequential()
model.add(SimpleRNN(128, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(SimpleRNN(256, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(SimpleRNN(128, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(SimpleRNN(64, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(Flatten())
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.summary()
model_fit = model.fit(X_train, Y_train, 
                      batch_size=batch_size, epochs=epoch,
                      verbose=verbose)

plt.plot(pd.DataFrame(model_fit.history))
plt.grid(True)
plt.show()

# prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)

# evaluation
result = model.evaluate(X_test, Y_test_pred)
if scaler_Y_tr != []:
    Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test = scaler_Y_tr.inverse_transform(Y_test)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_RNN, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_train), Y_train_pred.flatten(), 
                                                      pd.DataFrame(Y_test), Y_test_pred.flatten(), graph_on=True)
display(Score_RNN)

LSTM

# Data Loading
location = './Data/BikeSharingDemand/Bike_Sharing_Demand_Full.csv'
raw_all = pd.read_csv(location)

# Feature Engineering
raw_fe = feature_engineering(raw_all)
### Reality ###
target = ['count_trend', 'count_seasonal', 'count_Day', 'count_Week', 'count_diff']
raw_feR = feature_engineering_year_duplicated(raw_fe, target)
###############

# Data Split
# Confirm of input and output
Y_colname = ['count']
X_remove = ['datetime', 'DateTime', 'temp_group', 'casual', 'registered']
X_colname = [x for x in raw_fe.columns if x not in Y_colname+X_remove]
X_train_feR, X_test_feR, Y_train_feR, Y_test_feR = datasplit_ts(raw_feR, Y_colname, X_colname, '2012-07-01')
### Reality ###
target = ['count_lag1', 'count_lag2']
X_test_feR = feature_engineering_lag_modified(Y_test_feR, X_test_feR, target)
###############

# Parameters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
sequence = 24
batch_size = 32
epoch = 10
verbose = 1
dropout_ratio = 0

# Feature Engineering
## Scaling
X_train_scaled = scaler_X_tr.fit_transform(X_train_feR)
Y_train_scaled = scaler_Y_tr.fit_transform(Y_train_feR)
X_test_scaled = scaler_X_tr.transform(X_test_feR)
Y_test_scaled = scaler_Y_tr.transform(Y_test_feR)

## X / Y Split
X_train, Y_train = [], []
for index in range(len(X_train_scaled) - sequence):
    X_train.append(np.array(X_train_scaled[index: index + sequence]))
    Y_train.append(np.ravel(Y_train_scaled[index + sequence:index + sequence + 1]))
X_train, Y_train = np.array(X_train), np.array(Y_train)
X_test, Y_test = [], []
for index in range(len(X_test_scaled) - sequence):
    X_test.append(np.array(X_test_scaled[index: index + sequence]))
    Y_test.append(np.ravel(Y_test_scaled[index + sequence:index + sequence + 1]))  
X_test, Y_test = np.array(X_test), np.array(Y_test) 

## Retype and Reshape
X_train = X_train.reshape(X_train.shape[0], sequence, -1)
X_test = X_test.reshape(X_test.shape[0], sequence, -1)
print('X_train:', X_train.shape, 'Y_train:', Y_train.shape)
print('X_test:', X_test.shape, 'Y_test:', Y_test.shape)

# LSTM
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(LSTM(256, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(LSTM(128, return_sequences=True, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(LSTM(64, return_sequences=False, activation="relu"))
model.add(Dropout(dropout_ratio)) 
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.summary()
model_fit = model.fit(X_train, Y_train, 
                      batch_size=batch_size, epochs=epoch,
                      verbose=verbose)

plt.plot(pd.DataFrame(model_fit.history))
plt.grid(True)
plt.show()

# prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)

# evaluation
result = model.evaluate(X_test, Y_test_pred)
if scaler_Y_tr != []:
    Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test = scaler_Y_tr.inverse_transform(Y_test)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_LSTM, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_train), Y_train_pred.flatten(), 
                                                      pd.DataFrame(Y_test), Y_test_pred.flatten(), graph_on=True)
display(Score_LSTM)

GRU

# Data Loading
location = './Data/BikeSharingDemand/Bike_Sharing_Demand_Full.csv'
raw_all = pd.read_csv(location)

# Feature Engineering
raw_fe = feature_engineering(raw_all)
### Reality ###
target = ['count_trend', 'count_seasonal', 'count_Day', 'count_Week', 'count_diff']
raw_feR = feature_engineering_year_duplicated(raw_fe, target)
###############

# Data Split
# Confirm of input and output
Y_colname = ['count']
X_remove = ['datetime', 'DateTime', 'temp_group', 'casual', 'registered']
X_colname = [x for x in raw_fe.columns if x not in Y_colname+X_remove]
X_train_feR, X_test_feR, Y_train_feR, Y_test_feR = datasplit_ts(raw_feR, Y_colname, X_colname, '2012-07-01')
### Reality ###
target = ['count_lag1', 'count_lag2']
X_test_feR = feature_engineering_lag_modified(Y_test_feR, X_test_feR, target)
###############

# Parameters
scaler_X_tr = preprocessing.MinMaxScaler()
scaler_Y_tr = preprocessing.MinMaxScaler()
sequence = 24
batch_size = 32
epoch = 10
verbose = 1
dropout_ratio = 0

# Feature Engineering
## Scaling
X_train_scaled = scaler_X_tr.fit_transform(X_train_feR)
Y_train_scaled = scaler_Y_tr.fit_transform(Y_train_feR)
X_test_scaled = scaler_X_tr.transform(X_test_feR)
Y_test_scaled = scaler_Y_tr.transform(Y_test_feR)

## X / Y Split
X_train, Y_train = [], []
for index in range(len(X_train_scaled) - sequence):
    X_train.append(np.array(X_train_scaled[index: index + sequence]))
    Y_train.append(np.ravel(Y_train_scaled[index + sequence:index + sequence + 1]))
X_train, Y_train = np.array(X_train), np.array(Y_train)
X_test, Y_test = [], []
for index in range(len(X_test_scaled) - sequence):
    X_test.append(np.array(X_test_scaled[index: index + sequence]))
    Y_test.append(np.ravel(Y_test_scaled[index + sequence:index + sequence + 1]))  
X_test, Y_test = np.array(X_test), np.array(Y_test) 

## Retype and Reshape
X_train = X_train.reshape(X_train.shape[0], sequence, -1)
X_test = X_test.reshape(X_test.shape[0], sequence, -1)
print('X_train:', X_train.shape, 'Y_train:', Y_train.shape)
print('X_test:', X_test.shape, 'Y_test:', Y_test.shape)

# GRU
model = Sequential()
model.add(GRU(128, input_shape =(X_train.shape[1], X_train.shape[2]), activation='relu',return_sequences=True))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(256, return_sequneces=True, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(128, return_sequences=True, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(GRU(64, return_sequences=False, activation='relu'))
model.add(Dropout(dropout_ratio)) 
model.add(Dense(1, activation='relu')
model.complie( optimizer ='adam', loss='mean_squared_error'))
model.summary()
model_fit = model.fit(X_train, Y_train,batch_size= batch_sizem
					 epochs=epoch, verbose=verbose)
plt.plot(pd.DataFrame(model_fit.history)
plt.grid(True)
plt.show()

#prediction
Y_train_pred = model.predict(X_train)
Y_test_pred = model.predict(X_test)

#evaluation
result = model.evaluation(X_test, Y_test_pred)
if scaler_Y_tr != []:
    Y_train = scaler_Y_tr.inverse_transform(Y_train)
    Y_train_pred = scaler_Y_tr.inverse_transform(Y_train_pred)
    Y_test = scaler_Y_tr.inverse_transform(Y_test)
    Y_test_pred = scaler_Y_tr.inverse_transform(Y_test_pred)
Score_GRU, Residual_tr, Residual_te = evaluation_trte(pd.DataFrame(Y_train), Y_train_pred.flatten(), 
                                                      pd.DataFrame(Y_test), Y_test_pred.flatten(), graph_on=True)
display(Score_GRU)

오늘 드디어 시계열데이터 심화편 강의를 완강했습니다

100강의 정도 되는 분량이였는데 차근차근 하다보니까 완강까지 하게되었습니다

일단 심화편이라서 그런지 정말 많은 정보를 얻을수 있었습니다.

더군다나 시계열데이터는 구글링해도 충분치 못한 영역이라고 생각했어요

잘 정리된 페이지도 있었지만 글로만 보면서 이해를 한다는게 쉽지 않는 공부였습니다. 

이번 기회에 시계열데이터의 흐름을 알게 된것같아서 뿌듯합니다.

완강했다고 끝은 아닙니다. 부족한 점이 군데군데 있습니다. 복습 해야할 부분도 있구요

이 강의 끝으로 자전거 수요와 주택가격 예측 실습을 진행했는데요

이 실습 내용은 내일 올리도록 하겠습니다. 오늘은 마저 못한 bitcoin실습 내용을 포스팅 겸 복습하면서 마무리 

할 생각입니다. 

2021.04.14 - [기록 note] - 2021-04-14(시계열데이터 심화18_bitcoin 실습편)

오늘은 bitcoin 실습을 진행했습니다 

강의는 5개 구성 되어 있어서 짧았는데 중간에 막혀서 몇시간을 고생했습니다

막혔던 부분이 뭐였나면

딥러닝의 input shape 였어요 강사가 이 부분이 중요하다고 중점적으로 말씀을 해주셨는데 

한번에 이해 하기가 힘들었어요 

MLP에서 (train.shape[1],)으로 입력하면 feature 수가 노드 수 만큼 증가되고

시계열 딥러닝은 (train.shape[1],train.shape[2])로 입력하면 feature가 아닌 sequense 길이가 노드 수 만큼 증가가 된다 

라는 얘기는 아직도 무슨얘기인지 이해하지 못했어요 

다른건 해결 했는데 이 부분이 ... 막힌다 말이죠 

대략 무슨 얘기인지는 알것같은데 이런 직감적으로 알것 같은건 100% 알고 있는게 아니라고 생각해요

그래서 찜찜합니다 어떻게 구글링 하면 좋을까 생각도 해보고 있습니다 

내일은 RNN,LSTM,GRU 실습 내용을 까지 포함해서 업데이트 하도록 하겠습니다.

2021.04.14 - [실습 note] - bitcoin 예측 실습