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

analyser_hj3415/analyser/eval/red.py

@@ -1,5 +1,5 @@
 import os
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from typing import Tuple
 import math
 
@@ -16,34 +16,31 @@ expire_time = tools.to_int(os.getenv('DEFAULT_EXPIRE_TIME_H', 48)) * 3600
 @dataclass
 class RedData:
     """
-    A data structure for financial data representation and calculations.
-
-    This class is designed to encapsulate financial details related to a company,
-    including calculations for business value, property value, debt evaluation, and
-    associated metrics. It validates specific attributes upon initialization and is
-    useful for financial data analysis.
-
-    Attributes:
-        code (str): A 6-digit numeric string representing the company or entity's code.
-        name (str): The name of the company or entity.
-        사업가치 (float): Business value calculated as net income attributable to controlling
-            shareholders divided by expected return rate.
-        지배주주당기순이익 (float): Net income attributable to controlling shareholders.
-        expect_earn (float): Expected return rate.
-        재산가치 (float): Property value calculated as current assets minus 1.2
-            times current liabilities, plus fixed assets under investment properties.
-        유동자산 (float): Current assets of the company.
-        유동부채 (float): Current liabilities of the company.
-        투자자산 (float): Investment assets within fixed assets.
-        투자부동산 (float): Investment real estate property.
-        부채평가 (float): Debt evaluation, specifically focusing on non-current liabilities.
-        발행주식수 (int): Number of issued shares by the company.
-        date (list): List of dates relevant to the financial data.
-        red_price (float): Red price associated with the company or entity.
-        score (int): Score or rating given to the company or entity.
-
-    Raises:
-        ValueError: If the 'code' attribute is not a 6-digit numeric string.
+    재무 데이터를 표현하고 계산하기 위한 데이터 구조.
+
+    이 클래스는 기업의 재무 데이터를 관리하며, 사업가치, 재산가치, 부채평가 등 다양한 재무
+    지표를 포함합니다. 초기화 시 특정 속성 값을 검증하며, 재무 데이터 분석에 유용하게 활용됩니다.
+
+    속성:
+        code (str): 기업의 6자리 숫자 코드.
+        name (str): 기업명.
+        사업가치 (float): 지배주주 당기순이익 / 기대수익률로 계산된 사업가치.
+        지배주주당기순이익 (float): 지배주주에게 귀속된 당기순이익.
+        expect_earn (float): 기대수익률.
+        재산가치 (float): 유동자산 - (유동부채 * 1.2) + 고정자산(투자자산, 투자부동산)으로 계산된 재산가치.
+        유동자산 (float): 기업의 유동자산.
+        유동부채 (float): 기업의 유동부채.
+        투자자산 (float): 투자자산.
+        투자부동산 (float): 투자부동산.
+        부채평가 (float): 비유동부채를 평가한 값.
+        발행주식수 (int): 발행된 주식 수.
+        date (list): 재무 데이터와 관련된 날짜 목록.
+        주가 (float): 최근 주가.
+        red_price (float): 계산된 레드 가격.
+        score (int): 최근 주가와 레드 가격 간 괴리율로 산출된 점수.
+
+    예외:
+        ValueError: 'code'가 6자리 숫자 문자열이 아닌 경우 발생.
     """
     code: str
     name: str
@@ -78,17 +75,18 @@ class RedData:
 
 class Red:
     """
-    Represents a financial analysis object with methods to calculate metrics
-    and gather data related to a specific code.
-
-    The Red class is designed to interact with specific data sources and provide
-    tools for financial calculations and analysis. This includes fetching and
-    processing information related to liabilities, assets, stock prices, and
-    other financial indicators. The class facilitates both specific calculations
-    such as 비유동부채(Non-current Liability) and the generation of comprehensive
-    financial datasets.
-    """
+    특정 기업의 재무 데이터를 계산하고 분석하기 위한 클래스.
+
+    이 클래스는 주어진 종목 코드에 대해 데이터를 가져오고, 사업가치, 재산가치, 부채평가 등 다양한
+    재무 지표를 계산하며, Redis 캐시를 활용하여 데이터 저장 및 재사용을 관리합니다.
 
+    속성:
+        c101 (myredis.C101): 기업 정보 및 데이터 접근을 위한 객체.
+        c103 (myredis.C103): 재무 상태표 데이터 접근을 위한 객체.
+        name (str): 기업명.
+        recent_price (float): 최근 주가.
+        expect_earn (float): 기대수익률. 기본값은 0.06 (6%).
+    """
 
     def __init__(self, code: str, expect_earn: float = 0.06):
         assert tools.is_6digit(code), f'Invalid value : {code}'
@@ -121,10 +119,23 @@ class Red:
         self._code = code
 
     def _calc비유동부채(self, refresh: bool) -> Tuple[str, float]:
-        """유효한 비유동부채 계산
+        """
+        비유동부채를 계산합니다.
+
+        기본적으로 재무 상태표에서 비유동부채 데이터를 가져오며, 만약 데이터가 누락되었거나 NaN인 경우
+        직접 계산하여 반환합니다.
+
+        매개변수:
+            refresh (bool): 데이터 새로고침 여부. True일 경우 최신 데이터를 가져옵니다.
 
-        일반적인 경우로 비유동부채를 찾아서 반환한다.\n
-        금융기관의 경우는 간접적으로 계산한다.\n
+        반환값:
+            Tuple[str, float]: 가장 최근 날짜와 계산된 비유동부채 값.
+
+        예외:
+            ValueError: 필요한 데이터가 누락된 경우 발생.
+
+        로그:
+            - 비유동부채 데이터가 없을 경우 경고 메시지를 출력합니다.
         """
         mylogger.info(f'In the calc비유동부채... refresh : {refresh}')
         self.c103.page = 'c103재무상태표q'
@@ -154,11 +165,18 @@ class Red:
             return d, 비유동부채
 
     def _score(self, red_price: int) -> int:
-        """red price와 최근 주가의 괴리율 파악
+        """
+        최근 주가와 레드 가격 간 괴리율을 계산하여 점수를 반환합니다.
+
+        매개변수:
+            red_price (int): 계산된 레드 가격.
+
+        반환값:
+            int: 괴리율 기반 점수. 양수는 저평가, 음수는 과대평가를 나타냅니다.
 
-            Returns:
-                int : 주가와 red price 비교한 괴리율
-            """
+        로그:
+            - 최근 주가와 레드 가격, 괴리율, 계산된 점수를 출력합니다.
+        """
         if math.isnan(self.recent_price):
             return 0
 
@@ -174,6 +192,24 @@ class Red:
         return score
 
     def _generate_data(self, refresh: bool) -> RedData:
+        """
+        RedData 객체를 생성하기 위해 재무 데이터를 계산합니다.
+
+        내부적으로 사업가치, 재산가치, 비유동부채 등을 계산하며, 계산된 결과를 RedData 객체로 반환합니다.
+
+        매개변수:
+            refresh (bool): 데이터 새로고침 여부. True일 경우 최신 데이터를 가져옵니다.
+
+        반환값:
+            RedData: 계산된 재무 데이터를 포함하는 RedData 객체.
+
+        예외:
+            ZeroDivisionError: 발행 주식 수가 0인 경우 발생.
+            ValueError: 필요한 날짜 데이터가 없는 경우 발생.
+
+        로그:
+            - 각 단계의 계산 결과와 주요 값을 출력합니다.
+        """
         d1, 지배주주당기순이익 = Tools.calc당기순이익(self.c103, refresh)
         mylogger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
         d2, 유동자산 = Tools.calc유동자산(self.c103, refresh)
@@ -230,35 +266,28 @@ class Red:
 
     def get(self, refresh = False, verbose = True) -> RedData:
         """
-        RedData 형식의 데이터를 계산하여 리턴하고 레디스 캐시에 저장한다.
-
-        redis_name = f"{self.code}_red_data"
-
-        Fetch or create RedData from Redis cache.
+        RedData 객체를 Redis 캐시에서 가져오거나, 새로 계산하여 반환합니다.
 
-        This function attempts to retrieve the RedData from a Redis cache. If the data is
-        not available or if a refresh is requested, it generates new data and caches
-        them back in Redis. The function logs its operations and can provide
-        verbose output when specified.
+        캐시에서 데이터를 검색하고, 없을 경우 `_generate_data`를 호출하여 새로운 데이터를 생성한 후,
+        캐시에 저장합니다.
 
-        Parameters:
-        refresh : bool, optional
-            Whether to refresh and generate new data instead of using the cached data.
-        verbose : bool, optional
-            Whether to enable verbose logging/display of additional runtime information.
+        매개변수:
+            refresh (bool, optional): 캐시 데이터를 무시하고 새로 계산 여부. 기본값은 False.
+            verbose (bool, optional): 실행 중 상세 정보를 출력 여부. 기본값은 True.
 
-        Returns:
-        RedData
-            The RedData object either retrieved from the cache or newly generated.
+        반환값:
+            RedData: Redis 캐시에서 가져오거나 새로 생성된 RedData 객체.
 
+        로그:
+            - 캐시 검색 상태와 새로 계산된 데이터를 출력합니다.
         """
         redis_name = f"{self.code}_red_data"
         mylogger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / expect_earn: {self.expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
-        def fetch_generate_data(refresh_in: bool) -> dict:
-            return asdict(self._generate_data(refresh_in))
+        def fetch_generate_data(refresh_in: bool) -> RedData:
+            return self._generate_data(refresh_in) # type: ignore
 
-        return RedData(**myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time))
+        return myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_generate_data, refresh, timer=expire_time)
 

analyser_hj3415/analyser/tsa/__init__.py

@@ -1,3 +1,3 @@
 from analyser_hj3415.analyser.tsa.lstm import *
 from analyser_hj3415.analyser.tsa.prophet import *
-
+from analyser_hj3415.analyser.tsa import common

analyser_hj3415/analyser/tsa/common.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+
+def is_up_by_OLS(data: dict) -> bool:
+    if not data:
+        # 데이터가 비어있으면 추세를 판단할 수 없음
+        return False
+
+    # 1) 날짜(키) 기준 오름차순 정렬
+    sorted_dates = sorted(data.keys())
+    values = [data[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) 기울기가 양수면 "우상향 추세"로 판별
+    return slope > 0

analyser_hj3415/analyser/tsa/lstm.py

@@ -8,17 +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
-
+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
@@ -26,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
@@ -42,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
@@ -54,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
 
@@ -100,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:
             """
@@ -196,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 모델 생성 - 유닛과 드롭아웃의 수는 테스트로 최적화 됨.
@@ -375,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'
@@ -414,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:
@@ -470,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]}')
@@ -490,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:
             # 데이터 준비
@@ -597,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
@@ -605,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
@@ -614,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)
@@ -668,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
@@ -699,10 +668,16 @@ class CorpLSTM(MyLSTM):
 
 
 class MILSTM(MyLSTM):
+    """
+    특정 MI 타입에 따라 주가를 예측하는 LSTM 클래스.
+
+    속성:
+        mi_type (str): MI 타입.
+    """
     def __init__(self, mi_type: str):
-        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:
@@ -710,7 +685,7 @@ class MILSTM(MyLSTM):
 
     @mi_type.setter
     def mi_type(self, mi_type: str):
-        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)