Motivation

• 많은 머신러닝 문헌은 데이터가 IID 라는 가정하에서 진행하는데 사용하는 데이터를 보면 이런 가정은 비현실적
• 위의 문제를 해결하기 위해서 Data Structures, Labeling 을 통해 해결하고자 했음

issue

• Labeling 에서 제안하 Triple Barrier를 활용학 되면 Overlapping outcomes 문제가 발생하게 됨

• i와 j 두 개의 구간에서 각각 feature(X), label(y)이 있다고 가정.

  • 
  • 
  • 위와 같은 조건에선 y_i, y_j는위의 return에 종속되게 됨. 즉 y_i가 i={1... I} 까지 있을 때 연속 결과에서 중첩이 지속적으로 발생할 수 있다는 얘기이고 이는 데이터가 IID와 멀어진다는 것을 얘기함.
    • 엄밀하게는 하나의 중첩만 있어도 IID가 아님.

solution

• sol(1) : 베팅 가능한 horizon을 제한하는 방법
  • 
  • 중첩만을 위해 일부 train data를 제거한다는 것은 간단하지만 이전의 데이터에 관한 심도 깊은 전처리 작업들에 큰 해를 끼치므로 좋은 방법은 아님.
• sol(2) : 평균 고유성(average uniqueness) 활용
  • train data의 모든 row를 활용해서 model에 넣어주는 것이 아니라 average uniqueness를 계산하여 해당 비율만큼 sampling 하여 중첩 효과를 줄이는 방식
• sol(3) : 순차적 부트스트랩(sequential bootstrap) 활용
  • train data의 row를 sampling할 때 순차적으로 진행하며 1회 진행할 때마다 나머지 row들에 대한 추출 확률분포를 변경해가면서 다음 추출을 이어나가는 방식.

Number of Concurrent Labels

Concept

• 공존(Concurrent)의 정의 : 두 개의 label이 하나의 중첩 수익률을 가지는 경우를 의미함. 위에서 설명했든 시간 구간이 완벽하게 동일하진 않아도 되고 중첩하기만 하면 공존한다고 표현.
  • 
• 공존(Concurrent)의 수식 표현
  • 
  • 
  • 
  • 
    • t는 시간 포인트를 의미하고 i는 레이블(train data의 row)의 넘버링을 의미한다. t와i를 구별하여 생각하는 것이 중요.
      • i에는 triple barrier를 위한 [시작점 시간, 끝점 시간]이 쌓여있고 t는 i에 쌓여있는 시간을 하나의 리스트로 flat하게 만든 후 sort한 집합의 원소
    • {1_(t,i)}_ i라는 이진 행렬(T x I)을 구성하고 벡터 1_(t,i) (1 X T) 는 [t_(i,0) , t_(i,1)]과 [t-1, t]가 중첩하는 경우(=triple barrier의 시간 구간)에는 해당 i th 이진 행 값에 1을 부여하고 중첩하지 않으면 0을 부여한다. 벡터 값을 설정하는 경우엔 i가 고정되어 있고 t가 1-T까지 변하면서 체크
      • 행렬{1_(t,i)} :
    • 위의 작업을 하고 나면 I개의 벡터가 만들어지고 이것을 활용해 '공존 레이블 개수(the number of labels concurrent)'를 다음과 같이 정의 (행렬의 행의 합)
    • 
      • 시점 t 하나에 대해선 그 시간에 triple barrier가 몇개가 동시에 공존하고 있는 지를 나타내고 이는 C_(t=10) = 4 이런 식이 될 것이다. t=1~T까지는 C_t 벡터가 된다. (compute c_t for t in price.index)

Code

def mpNumCoEvents(priceIdx, tl, molecule):
    """
    refer to the explanation on Snippet 4.1
    :param priceIdx:
    :param tl: time limit
    :param molecule: events.index if numThreads=1 or subset otherwise
    :return: compute c_t for t in price.index
    """

    tl = tl.fillna(priceIdx[-1])
    tl = tl[tl >= molecule[0]]
    tl = tl.loc[:tl[molecule].max()]

    iloc = priceIdx.searchsorted(np.array([tl.index[0], tl.max()]))
    count = pd.Series(0, index=priceIdx[iloc[0]:iloc[1]+1])
    for tIn, tOut in tl.iteritems():
        count.loc[tIn:tOut] += 1

    return count.loc[molecule[0]:tl[molecule].max()]

Average Uniqueness of a Label

Concept

• '공존(Concurrent)'의 개념을 정의했고 이를 정량화하였다. 목적은 train data에 중첩성이 존재하고 이 중첩성을 '공존 레이블 개수(the number of labels concurrent)'로 표현했다. 이것을 시각 t, 레이블 i에서의 '고유성(Uniqueness)'을 표현해보면 다음과 같이 정의할 수 있다.

• 

  • u_(t,i) & 1_(t,i) 는 scalar, c_t는 vector

• triple barrier 구간 안에서 여러 개의 u_(t,i)가 존재하므로 이를 '평균 고유성(Average Uniqueness)'으로 다음과 같이 표현 할 수 있다.

• issue

  • 평균 고유성을 계산하는 과정에서 미래의 알 수 없는 정보를 사용하게 됨
    • 문제가 되지 않는 이유 : 1) training set에서만 활용되고 test set에서 사용되는 것은 아님. 2) 평균 고유성이 레이블 예측에 직접 사용되진 않음.
    • 정말 아예 누수(leakage)가 없는 걸까? 개인적으로 그렇진 않다고 봄. but 데이터를 최대한 IID화 한 것 + 추후에 백테스트를 할 때 퍼지-엠바고(purge-embargo)를 활용하기 때문에 그 영향도가 적기에 무시해도 된다로 해석.

Code

def mpSampleTW(tl, numCoEvents, molecule):
    """
    :param tl: events['tl']
    :param numCoEvents: pd.Series with index 
    :param molecule: events.index if numThreads=1 or subset otherwise
    :return: compute u_i_bar for i in events.index
    """

    wght = pd.Series(index=molecule)

    for tIn, tOut in tl.loc[wght.index].iteritems():
        wght.loc[tIn] = (1./numCoEvents.loc[tIn:tOut]).mean()

    return wght

• 비교 : price.index vs event.index(=molecule) vs tl (triple barrier : [[t1,t2],[t3,t4]....]
• numCoEvents.loc[tIn:tOut]
  • 
• .mean()
  • 

Bagging Classifiers and Uniqueness

Application of average uniquensess

• Bagging 알고리즘 : n 크기의 train set 'A'가 있다고 가정. m개의 샘플을 복원 추출 진행. 추출할 때 기본적으로 균등 확률분포를 가정하여 A_i 크기 n' (n' < n)을 갖는 train set m개 생성. m개의 train set으로 m개의 model을 생성하고 이를 averaging(regression case)/voting(classification case) 하여 최종 결과 값을 산출
  • Issue
    • 위에서 얘기하는 Bagging 알고리즘에 대한 설명은 ML쪽에서 데이터들이 IID하다는 가정을 하고 이야기한다. 서로 다른 모델이지만 근원적으론 같은 source인 A에서 나온 bootstrap sample을 이용한 것이므로 '중복성'이 발생하게 된다.
    • 다만, source가 IID 할 때는 100개의 모델을 만들어도 중복성이 심각하지 않지만 source가 IID와 멀어질 수록 소수의 모델로만으로도 이미 중복성이 심각해지고 사용하는 연산량에 비해 최종 output 값의 유효성은 변화가 없게 된다. 그러므로 보유하고 있는 train set을 극대화 시켜서 사용하는 방법은 train set을 최대한 IID한 상태로 만들어 놓는 것이 핵심.
  • Solution
    • 평균 고유성(average uniqueness)을 활용한 1차적인 해결책 보유하고 있는 train set의 평균적인 고유성을 수치화한 후 해당 비율의 크기로만 bootstrap sample을 만들어 내도록 제한하는 것이다.
    • 예를들면, sklearn의 BaggingClassifier의 파라미터 중 max_samples(비율)의 값으로 평균고유성(average uniqueness)을 활용하는 것이다. sklearn.ensemble.BaggingClassifier 참고 링크

Code

self._model = self.model_generator.model(type=self._config['model_type'],
                                                 n_estimators=self._config['n estimators'],
                                                 max_samples=self.model_generator.sampleTw.mean(), oob_score=True,
                                                 random_state=self._config['bagg random state'],
                                                 base_random_state=self._config['base random state'], base_n_estimators=self._config['base n estimators'])

• model은 bagging과 비슷한 알고리즘 모두가 해당.
• max_samples 부분은 self.model_generator.sampleTw.mean()을 통해 해당 source의 평균고유성을 대입

Sequential Bootstrap

• Concept
  • 핵심은 train set을 IID화 하고 train set에서 bootstrap sample 간의 중복성을 최대한 낮춰 놓는 것이 가장 중요하다. 어떤 model을 사용할 것인지는 그 다음 문제이다. 위의 해결책은 '균등 확률 분포'를 유지하면서 'max_samples'를 제한하는 식이지만 Sequential Bootstrap은 근본적으로 '확률 분포'를 손 보는 방법이다.
• Sequential Bootstrap Process
  1. 
  2. 
  3. 
  4. 
  5. 
  6. 
  7. 
  8. 
  9. 
     • 초기 Bootstrap sampling은 균등확률 분포에서 시작해야 함. i의 확률은 1/I로 시작
     • i 추출로 인해 높은 중첩성을 보이는 임의의 X_j Bootstrap의 확률을 낮추려고 함. (물론, 가장 높은 중첩성을 보이는 것은 j=i일때)
     • sampling sequence를 기록하기 위해 phi를 정의
     • 임의의 j에 대해 추출된 i의 정보를 반영하여 고유성과 평균 고유성을 계산 (이에 대한 설명은 위의 목차를 참고)
     • 임의의 j의 평균 고유성을 기반으로 확률 분포 업데이트 및 스케일링
     • 두 번째 갱신된 확률 분포를 활용하여 추출 진행
     • 총 Bootstrap Sample이 I개가 될 때까지 진행
       • issue : Sequential Bootstrap도 여전히 중첩 가능성은 존재하지만 확률적으로 감소할 가능성이 높아서 가설적인 측면에서 더 좋은 방법임.
         • MonteCarlo 실험을 통해서 2,3번 Solution간의 고유성 퍼포먼스를 비교할 수 있음.

Code

def getIndMatrix(barIx, tl):
    """
    refer to chapter 4.5.3 a numerical example
    :param barIx: price.index
    :param tl: events['tl']
    :return:
    """
    indM = pd.DataFrame(0, index=barIx, columns=range(tl.shape[0]))
    for i, (t0, t1) in enumerate(tl.iteritems()):
        indM.loc[t0:t1, i] = 1

    return indM

def getAvgUniqueness(indM):
    c = indM.sum(axis=1)
    u = indM.div(c, axis=0)
    avgU = u[u>0].mean()
    return avgU

def seqBootstrap(indM, sLength=None):
    """
    refer to Chapter 4.5.3 numerical example!
    """
    if sLength is None:
        sLength = indM.shape[1]
    phi = []
    while len(phi) < sLength:
        avgU = pd.Series()
        for i in indM:
            indM_ = indM[phi+[i]]
            # 새로 넣은 i column에 대한 AvgUniqueness는 getAvgUniquenses에 의해 return되는 series의 맨 끝 값에 있음!
            avgU.loc[i] = getAvgUniqueness(indM_).iloc[-1]
        prob = avgU / avgU.sum()
        phi += [np.random.choice(indM.columns, p=prob)]
        print(phi)
    return phi

Return Attribution

• Concept
  • IID에 근접한 Bootstrap sample을 했다는 가정 하에 이를 바로 Model에 훈련 시킬 수도 있겠지만 한 번 더 처리를 함으로써 Model 학습의 유효성을 더 높일 수 있다. 이번 처리하는 방법의 가설은 "모든 표본의 중요성이 동일하지 않다"를 바탕으로 한다.
  • 즉, 특정 레이블 행은 절대 수익률의 크기가 큰 경우가 있고, 다른 행은 작은 경우가 있다. 이런 경우, 절대 수익률의 크기가 큰 경우에 집중해서 학습하는게 바람직하다고 볼 수 있다.
  • 수능 기출 문제에서 배점이 큰 항목을 중점적으로 공부하는게 훨씬 중요하다는 뜻과 일맥상통한다. Return Attribution은 수익률의 크기를 정량화하여 표본 가중값을 설정하는 방식이다.
• Mathematical Expression
  1. 
  2. 
  3. 
  4. 
  • triple barrier를 통해 Labeling을 진행했고 이는 life span이 존재하고 이를 t_(i,0),t_(i,1)로 정의했고 해당 label에 평균 고유성(average uniqueness)과 스케일링을 반영하여 w_i를 정의할 수 있다.
  • 대부분의 ML model 라이브러리가 제공하는 모델은 표본 가중 값을 동일하게 default로 제공하는데 해당 vector를 parameter로 넣어줌에 따라 이를 반영할 수 있다.

Code

def mpSampleW(tl, numCoEvents, price, molecule):
    """

    :param tl: events['tl']
    :param numCoEvents: c_t for t in price.index
    :param price: volume / dollar bar price
    :param molecule: events.index if numThreads=1 or subset otherwise
    :return: compute \tilde{w_i} for i in events.index (refer to formula right before snippet 4.10)
    """
    ret = np.log(price).diff()
    wght = pd.Series(index=molecule)
    for tIn, tOut in tl.loc[wght.index].iteritems():
        wght.loc[tIn] = (ret.loc[tIn:tOut] / numCoEvents[tIn: tOut]).sum()
    return wght.abs()

fit = clf.fit(train_input, train_label, sample_weight=train_weight) # train_weight = mpSampleW의 output

• 평균 고유성만 return하는 함수를 변형하여 평균고유성+수익률 가중을 고려한 벡터를 산출하는 함수

Time Decay

• Concept
  • Adaptive Markets (Lo, A. 2017) 의 가설인 "과거의 예제는 새로운 것보다 연관성이 떨어진다"를 바탕으로 가중값을 한 번 더 줄 수 있다. 간단한 모형인 선형-감쇄 모델을 활용한다.
• Issue
  • 데이터를 IID화 하여 만드는데 Time-Decay를 고려한다는 건 모순이 아닌가?
    • 진정한 IID라는 것은 없고 preprocessing을 통해서 최대한 stationary하게 만들어 IID스럽게 만드는 것일 뿐이다. IID의 정의를 생각해보면 금융 데이터의 source를 보건대 진정한 IID를 만들 순 없다.
    • 다만, 모델의 효율적이고 유효한 학습과 output의 안정성을 위해서 전처리를 하는 것이다. 이를 고려해보면, 아직 덜 처리된 부분이 남아있을 것이고 이러한 부분은 time-dependent한 부분이 있다. 이 부분에 관해선 Time-Decay를 통해서 개선할 수 있다고 본다.
  • 실전 application 측면에서 sample 개수에 따라 weights가 계속 바뀌게 되기 때문에 walk-forward하게 model을 업데이트 하는 경우에 reproducibility를 만족시키기 쉽지 않다. 즉, 모니터링 결과와 실전 결과를 같게 만들려면 기술적으로 더 많은 작업이 요구된다.
    • 고민해보면 DB 설계를 할 때 이를 위한 부분을 만들어야 하고 일정 시간 단위로 weights 정보 table을 계속 쌓아야 한다.

Code

    def __getTimeDecay(self, tW, clfLastW=1.):
        clfW = tW.sort_index().cumsum()
        slope = (1-clfLastW) / clfW.iloc[-1] if clfLastW >= 0 else 1./((clfLastW+1)*clfW.iloc[-1])
        const = 1 - slope*clfW.iloc[-1]
        clfW = const + slope*clfW
        clfW[clfW < 0] = 0
        print(f'constant: {const:.2f}, slope: {slope:.2f}, look back sample : {len(clfW[clfW!=0])} total : {len(clfW)}')
        return clfW

Class Weights

• Concept
  • 표본 가중값(sample weights) vs 부류,클래스 가중값 (class weights)를 고민해보자. 특정 class가 몇 번 나오지 않는 경우에 유용하다.
  • 트레이딩 측면에선 long(1), short(-1) 두개의 부류가 있거나 혹은 중립(0)까지 있는 경우를 고려해볼 때, 레이블이 1,-1만 있다면 굳이 class weights를 고려할 필요가 없어보인다. 실전 경험상 0은 가끔 labeling하다 나오는데 0에 관해선 class weight를 낮게 주든 높게 주든 작업을 할 수 있을 것이다.
  • 실전에서 얼마나 유용할지는 의문.