태양광 발전량 예측 AI 경진대회_Dacon(3/3부)

 

태양광 발전량 예측 AI 경진대회_Dacon(3/3부)

 

: 지난 포스팅에서는 1) 태양광 발전량 예측 AI 경진대회 문제 및 데이터와 2) Base model을 소개자료는 아래와 같음

: 이번 포스팅에서는 가장 최고의 성능을 보여주었던 모델을 소개하고자 함(단일 모델)

 

태양광 발전량 예측 AI 경진대회 링크

dacon.io/competitions/official/235680/overview/

태양광 발전량 예측 AI 경진대회

 

태양광 발전량 예측 AI 경진대회_Dacon(1/3부)_ 대회 및 데이터 소개

today-1.tistory.com/40

태양광 발전량 예측 AI 경진대회_Dacon(1/3부)

 

태양광 발전량 예측 AI 경진대회_Dacon(2/3부)_Base model

today-1.tistory.com/42

태양광 발전량 예측 AI 경진대회_Dacon(2/3부)

 

 

1. Champion Model(Input attention NN)

 

: RF, XGB, LGBM, LSTM 등 여러 모델을 비교 실험한 결과 Attention을 활용한 NN이 가장 성능이 좋았음

: Attention Macanism을 활용하여 학습 데이터의 변수들 중 중요한 변수들의 가중치를 높이는input attention 구조 사용

: FE에 따라 LB 순위가 많이 변동됐기 떄문에 입력 변수 선택이 가장 중요하다고 판단

: Dual-stage Attention Macanism에서 Input attention 구조만 활용하여 모델링 진행

 

A Dual-stage attention-Based RNN

arxiv.org/pdf/1704.02971.pdf

---

input attention macanism

---

 

 

2. Champion Model(Input attention NN) CODE

 

: tensorflow 2.4.0을 사용하여 Input attention layer, LSTM layer, Dense layer를 연결

: 콜백으로 1)reduceLR, 2)earlystop, 3)checkpoint를 사용했으며 CV는 5-Fold를 이용

 

코드 참고

https://simpling.tistory.com/12

논문 리뷰: Attention을 활용한 시계열 예측 A Dual-Stage Attention-Based Recurrent Neural Network for Time Series Pre

class Encoder_lstm(Layer):
    def __init__(self, m):
        super(Encoder_lstm, self).__init__(name="encoder_lstm")
        self.lstm = LSTM(m, return_state=True)
        self.initial_state = None

    def call(self, x, training=False):
        h_s, _, c_s = self.lstm(x, initial_state = self.initial_state)
        self.initial_state = [h_s, c_s]

        return h_s, c_s

    def reset_state(self, h0, c0):
        self.initial_state = [h0, c0]


class Input_Attention(Layer):
    def __init__(self,T):
        super(Input_Attention,self).__init__(name = "input_attention")
        self.w1 = Dense(T)
        self.w2 = Dense(T)
        self.v = Dense(1)

    def call(self, h_s, c_s, x):
        query = tf.concat([h_s,c_s],axis=-1)
        query = RepeatVector(x.shape[2])(query)
        x_perm = Permute((2,1))(x)
        score = tf.nn.tanh(self.w1(x_perm) + self.w2(query))
        score = self.v(score)
        score = Permute((2,1))(score)
        attention_weigths = tf.nn.softmax(score)

        return attention_weigths



class Encoder(Layer):
    def __init__(self,T,m):
        super(Encoder,self).__init__(name = 'encoder')
        self.T = T
        self.input_att = Input_Attention(T)
        self.lstm = Encoder_lstm(m)
        self.alpha_t = None

    def call(self, data, h0, c0, training=False):
        self.lstm.reset_state(h0=h0, c0=c0)
        alpha_seq = tf.TensorArray(tf.float32, self.T)

        for t in range(self.T):
            x = data[:, t:t+1, :]
            h_s,c_s = self.lstm(x)
            self.alpha_t = self.input_att(h_s,c_s,data)
            alpha_seq = alpha_seq.write(t, self.alpha_t)

    alpha_seq = tf.reshape(alpha_seq.stack(), (-1, self.T, data.shape[2]))
    output = tf.multiply(data,alpha_seq)

    return output



class input_att_model(Model):
    def __init__(self, T, m):
        super(input_att_model, self).__init__(name="input_att_model")
        self.m = m
        self.encoder = Encoder(T=T, m=m)
        self.lstm = LSTM(m)
        self.dense1 = Dense(1024)
        self.dense2 = Dense(512)
        self.dense3 = Dense(256)
        self.dense4 = Dense(96)

    def call(self, inputs, training=False, mask=None):
        batch = inputs.shape[0]
        h0 = tf.zeros((batch, self.m))
        c0 = tf.zeros((batch, self.m))

        enc_output = self.encoder( inputs, h0=h0, c0=c0, training=training, )
        enc_h = self.lstm(enc_output)
        out1 = self.dense1(enc_h)
        out2 = self.dense2(out1)
        out3 = self.dense3(out2)
        out_put = self.dense4(out3)

        return out_put

 

 

3. Pinball Loss Function(Quantile Loss)

 

: 딥러닝 모델에 Pinball Loss(Quantile loss)를 적용하기 위해 custom loss function을 만들어 사용

 

def cv(y_true, y_pred, q):
    oof_score = y_true-y_pred
    pinball_loss = np.mean([max(i,j) for i,j in zip(oof_score*q, oof_score*(q-1))])

    return pinball_loss

 

 

4. 모델 성능

 

: 모델이 깊지 않아 학습 시간은 상대적으로 짧음

: 해당 모델만 사용하여 제출하면  1.7점 대 LB score를 달성할 수 있음 

: 최종 모델 외 LGBM, RF 모델 3개를 앙상블하여 최종 결과물 제출결과 LB 1위를 달성