실패한? LPPL 파이썬 코드입니다

모든 시점에 모든 자산에서 0%가 나오는 듯... ㅠㅜ

어쩌면 야후 파이낸스 데이터 문제일지도

일단 도전해봤다는 것에 의의를 둡니다

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from scipy.linalg import lstsq
from datetime import datetime, timedelta
import warnings
import os
import time

warnings.filterwarnings('ignore')

class LPPL:
    def __init__(self, observations):
        """
        LPPL 모델 초기화.
        
        Parameters:
            observations (pd.DataFrame): 'Close' 가격 데이터와 DatetimeIndex를 포함하는 DataFrame.
        """
        self.observations = observations
        self.t = self.get_days_since_start()  # 시작일로부터의 일수 계산
        self.price = self.observations['Close'].values
        self.log_price = np.log(self.price)
        self.ts = self.t / self.t[-1]  # 최적화를 위해 t를 [0,1] 범위로 스케일 조정
        self.bounds = [
            (0.01, 0.99),   # m의 범위
            (6, 13),        # omega의 범위
            (0, 2 * np.pi), # phi의 범위
            # tc의 범위는 fit()에서 추가
        ]

    def get_days_since_start(self):
        """
        DatetimeIndex를 시작일로부터의 일수 배열로 변환.
        
        Returns:
            np.array: 시작일로부터의 일수를 나타내는 정수 배열.
        """
        start_date = self.observations.index[0]
        return (self.observations.index - start_date).days.values

    def lppl_matrix(self, t, tc, m, omega, phi):
        """
        주어진 파라미터에 대해 LPPL 행렬을 계산.
        이 버전은 다음과 같은 3항식 형태를 사용합니다:
            log(p(t)) = A + B*(tc-t)^m + C*(tc-t)^m * cos(omega * log(tc-t) - phi)
        
        Args:
            t (np.ndarray): 스케일 조정된 시간 배열 (0~1).
            tc (float): 임계 시간.
            m (float): 버블 성장 지수.
            omega (float): 진동 주파수.
            phi (float): 위상 이동.
        
        Returns:
            np.ndarray: (n, 3) 모양의 LPPL 행렬.
        """
        t = np.array(t)
        dt = (tc - t).clip(0)  # 음수가 되지 않도록 함
        dt_pow_m = dt**m
        oscillatory = dt_pow_m * np.cos(omega * np.log(dt + 1e-8) - phi)
        return np.vstack((np.ones_like(t), dt_pow_m, oscillatory)).T

    def _func_(self, x, *args):
        """
        최적화에서 최소화할 목적 함수 (비선형 파라미터에 대해).
        
        Args:
            x (np.ndarray): 비선형 파라미터 [m, omega, phi, tc] 배열.
            *args: 추가 인자 (t, log_price).
        
        Returns:
            float: 제곱 오차 합.
        """
        m, omega, phi, tc = x
        t, log_price = args
        lppl_m = self.lppl_matrix(t, tc, m, omega, phi)
        try:
            coefs = lstsq(lppl_m, log_price)[0]
        except np.linalg.LinAlgError:
            return 1e10  # lstsq 실패 시 큰 값을 반환
        return np.sum((log_price - lppl_m @ coefs) ** 2)

    def fit(self):
        """
        L-BFGS-B 최적화 기법을 사용하여 가격 데이터에 LPPL 모델을 피팅.
        
        Returns:
            dict: 피팅된 파라미터와 기타 지표를 포함하는 딕셔너리.
        """
        t_end = self.ts[-1]
        # tc의 경계: 마지막 데이터 이후로 설정
        bounds = self.bounds + [(t_end + 0.01, t_end + 5)]
        init_guess = np.array([np.random.uniform(low, high) for low, high in bounds])

        opt = minimize(
            self._func_,
            x0=init_guess,
            args=(self.ts, self.log_price),
            method='L-BFGS-B',
            bounds=bounds,
        )

        m, omega, phi, tc = opt.x
        lppl_m = self.lppl_matrix(self.ts, tc, m, omega, phi)
        coefs = lstsq(lppl_m, self.log_price)[0]
        A, B, C = coefs[0], coefs[1], coefs[2]

        model = lppl_m @ coefs
        residuals = self.log_price - model
        mse = np.mean(residuals**2)
        damping_factor = abs(B) / abs(C) if C != 0 else np.inf
        num_oscillations = omega / (2 * np.pi) * np.log((tc - self.ts[0]) / (tc - self.ts[-1]))
        rel_error = np.std(residuals) / np.std(self.log_price)

        params = {
            'A': A,
            'B': B,
            'C': C,
            'm': m,
            'omega': omega,
            'phi': phi,
            'tc': tc,
            'tc_date': self.observations.index[0] + pd.Timedelta(days=int(tc * self.t[-1])),
            'mse': mse,
            'damping_factor': damping_factor,
            'num_oscillations': num_oscillations,
            'rel_error': rel_error,
            'fit_success': opt.success,
            'residuals': residuals
        }
        return params

    def check_bubble_conditions(self, params):
        """
        피팅된 파라미터가 버블 조건을 만족하는지 확인.
        
        Parameters:
            params (dict): 피팅된 LPPL 파라미터 딕셔너리.
   ...