analyser_hj3415 3.2.1__py3-none-any.whl → 3.3.0__py3-none-any.whl

analyser_hj3415/analyser/tsa/lstm.py

@@ -1,6 +1,3 @@
-"""
-Time Series Analysis
-"""
 import os
 import numpy as np
 import yfinance as yf
@@ -11,16 +8,16 @@ import plotly.graph_objs as go
 from plotly.offline import plot
 import matplotlib.pyplot as plt  # Matplotlib 수동 임포트
 from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Dense, Dropout
-from tensorflow.keras.callbacks import EarlyStopping
-from tensorflow.keras import Input
+from tensorflow.keras.models import Sequential # type: ignore
+from tensorflow.keras.layers import LSTM, Dense, Dropout # type: ignore
+from tensorflow.keras.callbacks import EarlyStopping # type: ignore
+from tensorflow.keras import Input # type: ignore
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from dataclasses import dataclass
 
 from utils_hj3415 import tools, setup_logger
 from db_hj3415 import myredis
-
+from analyser_hj3415.analyser import MIs, tsa
 
 mylogger = setup_logger(__name__,'WARNING')
 expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
@@ -28,6 +25,20 @@ expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 
 @dataclass
 class LSTMData:
+    """
+    LSTM 모델에서 사용할 데이터를 저장하는 데이터 클래스.
+
+    속성:
+        ticker (str): 주식 티커(symbol).
+        data_2d (np.ndarray): 원본 종가 데이터를 저장한 2차원 배열.
+        train_size (int): 학습 데이터 크기.
+        train_data_2d (np.ndarray): 학습 데이터 2차원 배열.
+        test_data_2d (np.ndarray): 테스트 데이터 2차원 배열.
+        X_train_3d (np.ndarray): 학습 데이터 3차원 배열.
+        X_test_3d (np.ndarray): 테스트 데이터 3차원 배열.
+        y_train_1d (np.ndarray): 학습 정답 데이터 1차원 배열.
+        y_test_1d (np.ndarray): 테스트 정답 데이터 1차원 배열.
+    """
     ticker: str
 
     data_2d: np.ndarray
@@ -44,7 +55,16 @@ class LSTMData:
 @dataclass
 class LSTMGrade:
     """
-    딥러닝 모델의 학습 결과를 평가하기 위해 사용하는 데이터 클래스
+    LSTM 모델 학습 결과를 평가하기 위한 데이터 클래스.
+
+    속성:
+        ticker (str): 주식 티커(symbol).
+        train_mse (float): 학습 데이터에 대한 평균 제곱 오차(MSE).
+        train_mae (float): 학습 데이터에 대한 평균 절대 오차(MAE).
+        train_r2 (float): 학습 데이터에 대한 결정 계수(R²).
+        test_mse (float): 테스트 데이터에 대한 평균 제곱 오차(MSE).
+        test_mae (float): 테스트 데이터에 대한 평균 절대 오차(MAE).
+        test_r2 (float): 테스트 데이터에 대한 결정 계수(R²).
     """
     ticker: str
     train_mse: float
@@ -56,6 +76,16 @@ class LSTMGrade:
 
 
 class MyLSTM:
+    """
+    주가 데이터를 기반으로 LSTM 모델을 생성, 학습 및 예측하는 클래스.
+
+    속성:
+        future_days (int): 미래 예측할 일 수. 기본값은 30.
+        scaler (MinMaxScaler): 데이터 정규화를 위한 MinMaxScaler.
+        _ticker (str): 주식 티커(symbol).
+        raw_data (pd.DataFrame): 원본 주가 데이터.
+        lstm_data (LSTMData): LSTM 학습에 사용할 데이터.
+    """
     # 미래 몇일을 예측할 것인가?
     future_days = 30
 
@@ -102,12 +132,11 @@ class MyLSTM:
 
     def initializing(self):
         """
-        LSTM 분석을 위해 데이터를 준비하는 과정
-        get_final_predictions(refresh=True)를 시행하기전에 반드시 먼저 실행해줘아 한다.
+        LSTM 모델 학습을 위한 데이터를 준비합니다.
 
-        Fetches stock price data for the last four years from Yahoo Finance and prepares
-        it for use in an LSTM model by normalizing, splitting into training and testing datasets,
-        and reshaping the data.
+        Yahoo Finance에서 주가 데이터를 가져와 정규화, 학습 및 테스트 데이터로 분리,
+        LSTM 모델 입력 형식으로 변환합니다. `get_final_predictions` 메서드 실행 전에
+        반드시 호출해야 합니다.
         """
         def get_raw_data() -> pd.DataFrame:
             """
@@ -198,34 +227,24 @@ class MyLSTM:
                 y_train_1d=y_train_1d,
                 y_test_1d=y_test_1d,
             )
+
+        self.scaler = MinMaxScaler(feature_range=(0, 1))
+
         self.raw_data = get_raw_data()
         self.lstm_data = preprocessing_for_lstm()
 
     def ensemble_training(self, num) -> Tuple[list, LSTMGrade]:
         """
-        Represents the implementation for training, predicting, and evaluating an LSTM-based deep learning model.
-        Defines functions for LSTM model training, prediction, grading results, and ensemble model training.
+        앙상블 LSTM 모델을 훈련하고, 예측 결과를 생성 및 평가합니다.
 
-        Methods defined:
-        - model_training: Constructs and trains the LSTM model with specified layers and configurations.
-        - prediction: Uses a trained model to perform predictions, restores normalization, and returns results.
-        - grading: Analyzes the training and testing predictions, computes evaluation metrics, and returns grading details.
-        - ensemble_training: Trains multiple LSTM models to create ensemble predictions and future forecasts.
+        매개변수:
+            num (int): 앙상블에 포함할 모델의 수.
 
-        ensemble_training:
-            Trains multiple LSTM models iteratively and forms ensemble predictions for training, testing datasets,
-            and future trend forecasting. Evaluates the models collectively using grading metrics.
+        반환값:
+            Tuple[list, LSTMGrade]: 미래 예측 값 리스트와 학습 결과 평가 데이터.
 
-        Arguments:
-            num: int
-                The number of ensemble LSTM models to train.
-
-        Returns:
-            Tuple[list, LSTMGrade]
-                A list of predicted scaled values for future forecasts and the performance grading object.
-
-        Raises:
-            Does not explicitly raise errors but logs warnings for possible issues during training or prediction.
+        예외:
+            IndexError: 모델 훈련을 위한 데이터가 부족한 경우 경고 로그를 출력합니다.
         """
         def model_training() -> Sequential:
             # LSTM 모델 생성 - 유닛과 드롭아웃의 수는 테스트로 최적화 됨.
@@ -377,25 +396,18 @@ class MyLSTM:
 
     def get_final_predictions(self, refresh: bool, num=5) -> Tuple[dict, LSTMGrade]:
         """
-        Fetch and process predictions for future data.
+        LSTM 모델을 사용하여 미래 주가를 예측하고 평가 데이터를 반환합니다.
 
-        This function fetches predictions from a Redis cache or calculates predictions if the data is
-        not found or if a refresh is requested. Predictions are determined using an ensemble training
-        method which averages predictions to forecast future trends. Additionally, the function checks
-        and caches whether the predicted data demonstrates an increasing trend over time.
+        매개변수:
+            refresh (bool): 데이터 새로고침 여부.
+            num (int): 앙상블 모델의 수. 기본값은 5.
 
-        Args:
-            refresh (bool): If True, forces recalculation and cache refresh of predictions.
-            num (int): Number of times to repeat ensemble training for more consistent predictions.
-                       Defaults to 5.
+        반환값:
+            Tuple[dict, LSTMGrade]: 날짜별 예측 주가와 모델 평가 데이터.
 
-        Returns:
-            Tuple[dict, LSTMGrade]: A tuple containing a dictionary of future date-price pairs and the
-            evaluation grade of the LSTM prediction model.
-
-        Raises:
-            AssertionError: Raised if the lengths of 'future_dates' and 'final_future_predictions' do
-                            not match during the data preparation.
+        로그:
+            - 캐시 데이터 검색 및 새 데이터 생성 과정 출력.
+            - 예측 값의 증가 추세를 분석하여 캐시에 저장.
         """
         print("**** Start get_final_predictions... ****")
         redis_name = f'{self.ticker}_mylstm_predictions'
@@ -416,36 +428,8 @@ class MyLSTM:
             redis_name = f'{self.ticker}_is_lstm_up'
             print(f"redisname: '{redis_name}' / expire_time : {expire_time / 3600}h")
 
-
-            if not future_data_in:
-                # 데이터가 비어있으면 추세를 판단할 수 없음
-                return False
-
-            # 1) 날짜(키) 기준 오름차순 정렬
-            sorted_dates = sorted(future_data_in.keys())
-            values = [future_data_in[d] for d in sorted_dates]
-
-            # 2) x 축을 0,1,2... 형태로 부여 (날짜 간격을 동일하게 가정)
-            x = np.arange(len(values), dtype=float)
-            y = np.array(values, dtype=float)
-
-            # 3) 선형 회귀(최소제곱법)로 기울기(slope) 계산
-            x_mean = np.mean(x)
-            y_mean = np.mean(y)
-
-            # 분자: sum((xi - x_mean) * (yi - y_mean))
-            numerator = np.sum((x - x_mean) * (y - y_mean))
-            # 분모: sum((xi - x_mean)^2)
-            denominator = np.sum((x - x_mean) ** 2)
-
-            if denominator == 0:
-                # 데이터가 1개 이하인 경우 등
-                return False
-
-            slope = numerator / denominator
-
-            # 4) 기울기가 양수면 "우상향 추세"로 판별
-            is_up = slope > 0
+            is_up = tsa.common.is_up_by_OLS(future_data_in)
+            mylogger.debug(f"is_up: {is_up}")
             myredis.Base.set_value(redis_name, is_up, expire_time)
 
         def fetch_final_predictions(num_in) -> tuple:
@@ -472,6 +456,7 @@ class MyLSTM:
                     data[future_dates[i].strftime("%Y-%m-%d")] = final_future_predictions[i][0]
                 return data
 
+            self.initializing()
             # 앙상블 트레이닝 시행
             future_predictions_2d, lstm_grade = self.ensemble_training(num=num_in)
             mylogger.debug(f'future_predictions_2d[:5] : {future_predictions_2d[:5]}')
@@ -492,32 +477,21 @@ class MyLSTM:
 
         return future_data, lstm_grade
 
-    def export(self, refresh=False, to="str", num=5) -> Optional[str]:
+    def export(self, refresh=False, to="html", num=5) -> Optional[str]:
         """
-        Prepares and exports stock price trend graphs based on past and predicted data.
-        The graphs include markers for actual prices along with a line-plot for forecasted prices.
-        The function offers multiple export formats: an HTML string, a PNG file, or an HTML file.
-
-        Parameters
-        ----------
-        refresh : bool, optional
-            Specifies whether to refresh dataset before preparing future data. Defaults to False.
-        to : str, optional
-            Determines the export format of the graph. Valid choices are
-            'str', 'png', or 'htmlfile'. Defaults to 'str'.
-        num : int, optional
-            Specifies the number of future days to include in prediction. Defaults to 5.
-
-        Returns
-        -------
-        Optional[str]
-            A string representation of the graph in HTML format if `to` is set to 'str'.
-            Returns None if `to` is set to either 'png' or 'htmlfile'.
-
-        Raises
-        ------
-        Exception
-            Raised if the `to` parameter does not match the allowed values: 'str', 'png', or 'htmlfile'.
+        과거 및 예측된 주가 데이터를 기반으로 시각화를 생성하고 저장합니다.
+
+        매개변수:
+            refresh (bool): 데이터 새로고침 여부. 기본값은 False.
+            to (str): 그래프 출력 형식 ('hrml', 'png', 'file'). 기본값은 'html'.
+            num (int): 예측 모델 수. 기본값은 5.
+
+        반환값:
+            Optional[str]: HTML 형식의 그래프 문자열(`to='html'`인 경우).
+            None: PNG 또는 HTML 파일로 저장된 경우.
+
+        예외:
+            Exception: 잘못된 `to` 값이 주어졌을 때 발생.
         """
         def prepare_past_data(past_days) -> tuple:
             # 데이터 준비
@@ -599,7 +573,7 @@ class MyLSTM:
             showlegend=False,
         )
 
-        if to == 'str':
+        if to == 'html':
             # 그래프 HTML로 변환 (string 형식으로 저장)
             graph_html = plot(fig, output_type='div')
             return graph_html
@@ -607,7 +581,7 @@ class MyLSTM:
             # 그래프를 PNG 파일로 저장
             fig.write_image(f"myLSTM_{self.ticker}.png")
             return None
-        elif to == 'htmlfile':
+        elif to == 'file':
             # 그래프를 HTML로 저장
             plot(fig, filename=f'myLSTM_{self.ticker}.html', auto_open=False)
             return None
@@ -616,24 +590,13 @@ class MyLSTM:
 
     def visualization(self, refresh=True):
         """
-        Visualizes actual and predicted stock prices, allowing for an evaluation of the
-        predictions made using a Long Short-Term Memory (LSTM) model. The visualization
-        includes plots for both future predicted prices and historical price comparisons
-        for improved insights.
-
-        Parameters
-        ----------
-        refresh : bool, optional
-            Indicates whether to refresh and retrieve the latest predictions before
-            visualizing. Defaults to True.
-
-        Raises
-        ------
-        None
-
-        Returns
-        -------
-        None
+        실제 주가와 예측 주가를 시각화합니다.
+
+        매개변수:
+            refresh (bool): 예측 데이터를 새로고침할지 여부. 기본값은 True.
+
+        반환값:
+            None: 시각화를 출력합니다.
         """
         self.initializing()
         future_data, _ = self.get_final_predictions(refresh=refresh)
@@ -670,18 +633,22 @@ class MyLSTM:
 
     def is_lstm_up(self) -> bool:
         """
-        Determines whether the LSTM model is active or not.
+        LSTM 모델의 추세가 상승인지 여부를 확인합니다.
 
-        This method checks the status of an LSTM model by querying a Redis
-        value identified by a specific code indicating LSTM activity.
-
-        Returns:
-            bool: True if the LSTM model is active (up), False otherwise.
+        반환값:
+            bool: 추세가 상승 상태(True) 또는 추세가 하락 상태(False).
         """
         return myredis.Base.get_value(f'{self.ticker}_is_lstm_up')
 
 
 class CorpLSTM(MyLSTM):
+    """
+    특정 기업 코드를 기반으로 주가를 예측하는 LSTM 클래스.
+
+    속성:
+        code (str): 기업 코드.
+        name (str): 기업명.
+    """
     def __init__(self, code: str):
         assert tools.is_6digit(code), f'Invalid value : {code}'
         self._code = code
@@ -701,11 +668,16 @@ class CorpLSTM(MyLSTM):
 
 
 class MILSTM(MyLSTM):
+    """
+    특정 MI 타입에 따라 주가를 예측하는 LSTM 클래스.
+
+    속성:
+        mi_type (str): MI 타입.
+    """
     def __init__(self, mi_type: str):
-        from analyser_hj3415.analyser.tsa import MIs
-        assert mi_type in MIs.keys(), f"Invalid MI type ({MIs.keys()})"
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
         self._mi_type = mi_type
-        super().__init__(ticker=MIs[mi_type])
+        super().__init__(ticker=getattr(MIs, mi_type))
 
     @property
     def mi_type(self) -> str:
@@ -713,8 +685,7 @@ class MILSTM(MyLSTM):
 
     @mi_type.setter
     def mi_type(self, mi_type: str):
-        from analyser_hj3415.analyser.tsa import MIs
-        assert mi_type in MIs.keys(), f"Invalid MI type ({MIs.keys()})"
+        assert mi_type in MIs._fields, f"Invalid MI type ({MIs._fields})"
         self._mi_type = mi_type
-        self.ticker = MIs[mi_type]
+        self.ticker = getattr(MIs, mi_type)