analyser_hj3415 2.8.2__py2.py3-none-any.whl → 2.9.0__py2.py3-none-any.whl

analyser_hj3415/cli.py

@@ -41,15 +41,22 @@ def analyser_manager():
     parser = argparse.ArgumentParser(description="Analyser Commands")
     type_subparsers = parser.add_subparsers(dest='type', help='분석 타입')
 
-    # tsa 명령어 서브파서
-    tsa_parser = type_subparsers.add_parser('tsa', help='Time serial analysis 타입')
-    tsa_subparser = tsa_parser.add_subparsers(dest='command', help='tsa 관련된 명령')
-    # red - ranking 파서
-    ranking_parser = red_subparser.add_parser('ranking', help='red 랭킹 책정 및 레디스 저장')
-    ranking_parser.add_argument('-e', '--expect_earn', type=float, help='기대수익률 (실수 값 입력)')
+    # prophet 명령어 서브파서
+    prophet_parser = type_subparsers.add_parser('prophet', help='MyProphet 타입')
+    prophet_subparser = prophet_parser.add_subparsers(dest='command', help='prophet 관련된 명령')
+    # ranking 파서
+    ranking_parser = prophet_subparser.add_parser('ranking', help='prophet 랭킹 책정 및 레디스 저장')
     ranking_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
     ranking_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
 
+    # lstm 명령어 서브파서
+    lstm_parser = type_subparsers.add_parser('lstm', help='MyLSTM 타입')
+    lstm_subparser = lstm_parser.add_subparsers(dest='command', help='lstm 관련된 명령')
+    # caching 파서
+    caching_parser = lstm_subparser.add_parser('caching', help='lstm 랭킹 책정 및 레디스 저장')
+    caching_parser.add_argument('-r', '--refresh', action='store_true', help='래디스 캐시를 사용하지 않고 강제로 재계산 할지')
+    caching_parser.add_argument('-n', '--noti', action='store_true', help='작업 완료 후 메시지 전송 여부')
+
     # red 명령어 서브파서
     red_parser = type_subparsers.add_parser('red', help='red 타입')
     red_subparser = red_parser.add_subparsers(dest='command', help='red 관련된 명령')
@@ -110,7 +117,7 @@ def analyser_manager():
 
     args = parser.parse_args()
 
-    from analyser_hj3415 import eval
+    from analyser_hj3415 import eval, tsa
 
     if args.type == 'red':
         if args.command == 'get':
@@ -204,7 +211,17 @@ def analyser_manager():
                 pprint.pprint(growth.get(args.refresh))
             if args.noti:
                 noti.telegram_to('manager', f"오늘의 Growth({args.code})를 레디스 캐시에 저장했습니다.(유효 12시간)")
-
+    elif args.type == 'prophet':
+        if args.command == 'ranking':
+            result = tsa.MyProphet.ranking(refresh=args.refresh)
+            print(result)
+            if args.noti:
+                noti.telegram_to('manager', "오늘의 prophet ranking을 레디스캐시에 저장했습니다.(유효 24시간)")
+    elif args.type == 'lstm':
+        if args.command == 'caching':
+            result = tsa.MyLSTM('005930').caching_based_on_prophet_ranking(refresh=args.refresh)
+            if args.noti:
+                noti.telegram_to('manager', "오늘의 lstm caching을 레디스캐시에 저장했습니다.(유효 24시간)")
     elif args.type == 'setting':
         if args.command == 'set':
             settings_manager.set_value(args.title, args.value)

analyser_hj3415/eval.py

@@ -8,7 +8,7 @@ from analyser_hj3415.cli import AnalyserSettingsManager
 from collections import OrderedDict
 import logging
 
-analyser_logger = helpers.setup_logger('analyser_logger', logging.WARNING)
+eval_logger = helpers.setup_logger('eval_logger', logging.WARNING)
 
 expire_time = 3600 * 12
 
@@ -48,30 +48,30 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 당기순이익 계산.. refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 당기순이익 계산.. refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d1, 지배당기순이익 = c103.latest_value_pop2('*(지배)당기순이익', refresh)
-        analyser_logger.debug(f"*(지배)당기순이익: {지배당기순이익}")
+        eval_logger.debug(f"*(지배)당기순이익: {지배당기순이익}")
 
         if math.isnan(지배당기순이익):
-            analyser_logger.warning(f"{c103.code} / {name} - (지배)당기순이익이 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{c103.code} / {name} - (지배)당기순이익이 없는 종목. 수동으로 계산합니다.")
             c103.page = 'c103손익계산서q'
             d2, 최근4분기당기순이익 = c103.sum_recent_4q('당기순이익', refresh)
-            analyser_logger.debug(f"{c103.code} / {name} - 최근4분기당기순이익 : {최근4분기당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 최근4분기당기순이익 : {최근4분기당기순이익}")
             c103.page = 'c103재무상태표y'
             d3, 비지배당기순이익 = c103.latest_value_pop2('*(비지배)당기순이익', refresh)
-            analyser_logger.debug(f"{c103.code} / {name} - 비지배당기순이익y : {비지배당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 비지배당기순이익y : {비지배당기순이익}")
             # 가변리스트 언패킹으로 하나의 날짜만 사용하고 나머지는 버린다.
             # 여기서 *_는 “나머지 값을 다 무시하겠다”는 의미
-            analyser_logger.debug(f"d2:{d2}, d3: {d3}")
+            eval_logger.debug(f"d2:{d2}, d3: {d3}")
             try:
                 date, *_ = Tools.date_set(d2, d3)
             except ValueError:
                 # 날짜 데이터가 없는경우
                 date = ''
             계산된지배당기순이익= round(최근4분기당기순이익 - utils.nan_to_zero(비지배당기순이익), 1)
-            analyser_logger.debug(f"{c103.code} / {name} - 계산된 지배당기순이익 : {계산된지배당기순이익}")
+            eval_logger.debug(f"{c103.code} / {name} - 계산된 지배당기순이익 : {계산된지배당기순이익}")
             return date, 계산된지배당기순이익
         else:
             return d1, 지배당기순이익
@@ -85,20 +85,20 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 유동자산계산... refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 유동자산계산... refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d, 유동자산 = c103.sum_recent_4q('유동자산', refresh)
         if math.isnan(유동자산):
-            analyser_logger.warning(f"{c103.code} / {name} - 유동자산이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
+            eval_logger.warning(f"{c103.code} / {name} - 유동자산이 없는 종목. 수동으로 계산합니다(금융관련업종일 가능성있음).")
             d1, v1 = c103.latest_value_pop2('현금및예치금', refresh)
             d2, v2 = c103.latest_value_pop2('단기매매금융자산', refresh)
             d3, v3 = c103.latest_value_pop2('매도가능금융자산', refresh)
             d4, v4 = c103.latest_value_pop2('만기보유금융자산', refresh)
-            analyser_logger.debug(f'{c103.code} / {name} 현금및예치금 : {d1}, {v1}')
-            analyser_logger.debug(f'{c103.code} / {name} 단기매매금융자산 : {d2}, {v2}')
-            analyser_logger.debug(f'{c103.code} / {name} 매도가능금융자산 : {d3}, {v3}')
-            analyser_logger.debug(f'{c103.code} / {name} 만기보유금융자산 : {d4}, {v4}')
+            eval_logger.debug(f'{c103.code} / {name} 현금및예치금 : {d1}, {v1}')
+            eval_logger.debug(f'{c103.code} / {name} 단기매매금융자산 : {d2}, {v2}')
+            eval_logger.debug(f'{c103.code} / {name} 매도가능금융자산 : {d3}, {v3}')
+            eval_logger.debug(f'{c103.code} / {name} 만기보유금융자산 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -107,7 +107,7 @@ class Tools:
                 date = ''
             계산된유동자산value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4),1)
 
-            analyser_logger.info(f"{c103.code} / {name} - 계산된 유동자산 : {계산된유동자산value}")
+            eval_logger.info(f"{c103.code} / {name} - 계산된 유동자산 : {계산된유동자산value}")
             return date, 계산된유동자산value
         else:
             return d, 유동자산
@@ -121,20 +121,20 @@ class Tools:
         """
         name = myredis.Corps(c103.code, 'c101').get_name(refresh=refresh)
 
-        analyser_logger.info(f'{c103.code} / {name} Tools : 유동부채계산... refresh : {refresh}')
+        eval_logger.info(f'{c103.code} / {name} Tools : 유동부채계산... refresh : {refresh}')
         c103.page = 'c103재무상태표q'
 
         d, 유동부채 = c103.sum_recent_4q('유동부채', refresh)
         if math.isnan(유동부채):
-            analyser_logger.warning(f"{c103.code} / {name} - 유동부채가 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{c103.code} / {name} - 유동부채가 없는 종목. 수동으로 계산합니다.")
             d1, v1 = c103.latest_value_pop2('당기손익인식(지정)금융부채', refresh)
             d2, v2 = c103.latest_value_pop2('당기손익-공정가치측정금융부채', refresh)
             d3, v3 = c103.latest_value_pop2('매도파생결합증권', refresh)
             d4, v4 = c103.latest_value_pop2('단기매매금융부채', refresh)
-            analyser_logger.debug(f'{c103.code} / {name} 당기손익인식(지정)금융부채 : {d1}, {v1}')
-            analyser_logger.debug(f'{c103.code} / {name} 당기손익-공정가치측정금융부채 : {d2}, {v2}')
-            analyser_logger.debug(f'{c103.code} / {name} 매도파생결합증권 : {d3}, {v3}')
-            analyser_logger.debug(f'{c103.code} / {name} 단기매매금융부채 : {d4}, {v4}')
+            eval_logger.debug(f'{c103.code} / {name} 당기손익인식(지정)금융부채 : {d1}, {v1}')
+            eval_logger.debug(f'{c103.code} / {name} 당기손익-공정가치측정금융부채 : {d2}, {v2}')
+            eval_logger.debug(f'{c103.code} / {name} 매도파생결합증권 : {d3}, {v3}')
+            eval_logger.debug(f'{c103.code} / {name} 단기매매금융부채 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -143,7 +143,7 @@ class Tools:
                 date = ''
             계산된유동부채value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4), 1)
 
-            analyser_logger.info(f"{c103.code} / {name} - 계산된 유동부채 : {계산된유동부채value}")
+            eval_logger.info(f"{c103.code} / {name} - 계산된 유동부채 : {계산된유동부채value}")
             return date, 계산된유동부채value
         else:
             return d, 유동부채
@@ -192,7 +192,7 @@ class Red:
 
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Red : 초기화 ({code})")
+        eval_logger.debug(f"Red : 초기화 ({code})")
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103재무상태표q')
 
@@ -209,7 +209,7 @@ class Red:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Red : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Red : 종목코드 변경({self.code} -> {code})")
         self.c101.code = code
         self.c103.code = code
 
@@ -222,21 +222,21 @@ class Red:
         일반적인 경우로 비유동부채를 찾아서 반환한다.\n
         금융기관의 경우는 간접적으로 계산한다.\n
         """
-        analyser_logger.info(f'In the calc비유동부채... refresh : {refresh}')
+        eval_logger.info(f'In the calc비유동부채... refresh : {refresh}')
         self.c103.page = 'c103재무상태표q'
 
         d, 비유동부채 = self.c103.sum_recent_4q('비유동부채', refresh)
         if math.isnan(비유동부채):
-            analyser_logger.warning(f"{self} - 비유동부채가 없는 종목. 수동으로 계산합니다.")
+            eval_logger.warning(f"{self} - 비유동부채가 없는 종목. 수동으로 계산합니다.")
             # 보험관련업종은 예수부채가 없는대신 보험계약부채가 있다...
             d1, v1 = self.c103.latest_value_pop2('예수부채', refresh)
             d2, v2 = self.c103.latest_value_pop2('보험계약부채(책임준비금)', refresh)
             d3, v3 = self.c103.latest_value_pop2('차입부채', refresh)
             d4, v4 = self.c103.latest_value_pop2('기타부채', refresh)
-            analyser_logger.debug(f'예수부채 : {d1}, {v1}')
-            analyser_logger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
-            analyser_logger.debug(f'차입부채 : {d3}, {v3}')
-            analyser_logger.debug(f'기타부채 : {d4}, {v4}')
+            eval_logger.debug(f'예수부채 : {d1}, {v1}')
+            eval_logger.debug(f'보험계약부채(책임준비금) : {d2}, {v2}')
+            eval_logger.debug(f'차입부채 : {d3}, {v3}')
+            eval_logger.debug(f'기타부채 : {d4}, {v4}')
 
             try:
                 date, *_ = Tools.date_set(d1, d2, d3, d4)
@@ -244,7 +244,7 @@ class Red:
                 # 날짜 데이터가 없는경우
                 date = ''
             계산된비유동부채value = round(utils.nan_to_zero(v1) + utils.nan_to_zero(v2) + utils.nan_to_zero(v3) + utils.nan_to_zero(v4),1)
-            analyser_logger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
+            eval_logger.info(f"{self} - 계산된 비유동부채 : {계산된비유동부채value}")
             return date, 계산된비유동부채value
         else:
             return d, 비유동부채
@@ -266,13 +266,13 @@ class Red:
         else:
             score = utils.to_int(math.log10(deviation + 1) * 33)  # desmos그래프상 33이 제일 적당한듯(최대100점에 가깝게)
 
-        analyser_logger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {utils.to_int(deviation)} score : {score}")
+        eval_logger.debug(f"최근주가 : {recent_price} red가격 : {red_price} 괴리율 : {utils.to_int(deviation)} score : {score}")
 
         return score
 
     def _generate_data(self, refresh: bool) -> RedData:
         d1, 지배주주당기순이익 = Tools.calc당기순이익(self.c103, refresh)
-        analyser_logger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
+        eval_logger.debug(f"{self} 지배주주당기순이익: {지배주주당기순이익}")
         d2, 유동자산 = Tools.calc유동자산(self.c103, refresh)
         d3, 유동부채 = Tools.calc유동부채(self.c103, refresh)
         d4, 부채평가 = self._calc비유동부채(refresh)
@@ -331,7 +331,7 @@ class Red:
         :return:
         """
         redis_name = f"{self.code}_red"
-        analyser_logger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} RedData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         expire_time = 3600 * 12
         if verbose:
             print(f"{self} redisname: '{redis_name}' / expect_earn: {Red.expect_earn} / refresh : {refresh} / expire_time : {expire_time/3600}h")
@@ -355,11 +355,11 @@ class Red:
         # expect_earn 및 refresh 설정
         if expect_earn is None:
             expect_earn = cls.expect_earn
-        analyser_logger.info(f"기대수익률을 {expect_earn}으로 설정합니다.")
+        eval_logger.info(f"기대수익률을 {expect_earn}으로 설정합니다.")
         previous_expect_earn = float(AnalyserSettingsManager().get_value('RED_RANKING_EXPECT_EARN'))
-        analyser_logger.debug(f"previous red ranking expect earn : {previous_expect_earn}")
+        eval_logger.debug(f"previous red ranking expect earn : {previous_expect_earn}")
         if previous_expect_earn != expect_earn:
-            analyser_logger.warning(f"expect earn : {expect_earn} / RED_RANKING_EXPECT_EARN : {previous_expect_earn} 두 값이 달라 refresh = True")
+            eval_logger.warning(f"expect earn : {expect_earn} / RED_RANKING_EXPECT_EARN : {previous_expect_earn} 두 값이 달라 refresh = True")
             refresh = True
 
         redis_name = 'red_ranking'
@@ -422,7 +422,7 @@ class MilData:
 class Mil:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Mil : 종목코드 ({code})")
+        eval_logger.debug(f"Mil : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103현금흐름표q')
@@ -442,7 +442,7 @@ class Mil:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Mil : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Mil : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c103.code = code
@@ -459,7 +459,7 @@ class Mil:
         """
         c101r = self.c101.get_recent(refresh)
         시가총액 = int(utils.to_int(c101r.get('시가총액', math.nan)) / 100000000)
-        analyser_logger.debug(f"시가총액: {시가총액}억원")
+        eval_logger.debug(f"시가총액: {시가총액}억원")
         return 시가총액
 
     def _calc주주수익률(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float]:
@@ -469,7 +469,7 @@ class Mil:
             주주수익률 = round((재무활동현금흐름 / 시가총액_억 * -100), 2)
         except ZeroDivisionError:
             주주수익률 = math.nan
-            analyser_logger.warning(f'{self} 주주수익률: {주주수익률} 재무활동현금흐름: {재무활동현금흐름}')
+            eval_logger.warning(f'{self} 주주수익률: {주주수익률} 재무활동현금흐름: {재무활동현금흐름}')
         return d, 주주수익률, 재무활동현금흐름
 
     def _calc이익지표(self, 시가총액_억: float, refresh: bool) -> Tuple[str, float, float, float]:
@@ -480,7 +480,7 @@ class Mil:
             이익지표 = round(((지배주주당기순이익 - 영업활동현금흐름) / 시가총액_억) * 100, 2)
         except ZeroDivisionError:
             이익지표 = math.nan
-            analyser_logger.warning(f'{self} 이익지표: {이익지표} 영업활동현금흐름: {영업활동현금흐름} 지배주주당기순이익: {지배주주당기순이익}')
+            eval_logger.warning(f'{self} 이익지표: {이익지표} 영업활동현금흐름: {영업활동현금흐름} 지배주주당기순이익: {지배주주당기순이익}')
         try:
             date, *_ = Tools.date_set(d1, d2)
         except ValueError:
@@ -521,15 +521,15 @@ class Mil:
         self.c103.page = 'c103재무상태표y'
         _, capex = self.c103.find('*CAPEX', remove_yoy=True, del_unnamed_key=True, refresh=refresh)
 
-        analyser_logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
-        analyser_logger.debug(f'CAPEX {capex}')
+        eval_logger.debug(f'영업활동현금흐름 {영업활동현금흐름_dict}')
+        eval_logger.debug(f'CAPEX {capex}')
 
         if len(영업활동현금흐름_dict) == 0:
             return {}
 
         if len(capex) == 0:
             # CAPEX 가 없는 업종은 영업활동현금흐름을 그대로 사용한다.
-            analyser_logger.warning(f"{self} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
+            eval_logger.warning(f"{self} - CAPEX가 없는 업종으로 영업현금흐름을 그대로 사용합니다..")
             return 영업활동현금흐름_dict
 
         # 영업 활동으로 인한 현금 흐름에서 CAPEX 를 각 연도별로 빼주어 fcf 를 구하고 리턴값으로 fcf 딕셔너리를 반환한다.
@@ -543,7 +543,7 @@ class Mil:
                 if 영업활동현금흐름date == CAPEXdate:
                     fcf_dict[영업활동현금흐름date] = round(영업활동현금흐름value - CAPEXvalue, 2)
 
-        analyser_logger.debug(f'fcf_dict {fcf_dict}')
+        eval_logger.debug(f'fcf_dict {fcf_dict}')
         # 연도순으로 정렬해서 딕셔너리로 반환한다.
         return dict(sorted(fcf_dict.items(), reverse=False))
 
@@ -556,7 +556,7 @@ class Mil:
                 https://www.investopedia.com/terms/p/pricetofreecashflow.asp
             """
         if math.isnan(시가총액_억):
-            analyser_logger.warning(f"{self} - 시가총액이 nan으로 pFCF를 계산할수 없습니다.")
+            eval_logger.warning(f"{self} - 시가총액이 nan으로 pFCF를 계산할수 없습니다.")
             return {}
 
         # pfcf 계산
@@ -569,7 +569,7 @@ class Mil:
 
         pfcf_dict = mymongo.C1034.del_unnamed_key(pfcf_dict)
 
-        analyser_logger.debug(f'pfcf_dict : {pfcf_dict}')
+        eval_logger.debug(f'pfcf_dict : {pfcf_dict}')
         return pfcf_dict
 
     def _calc가치지표(self, 시가총액_억: float, refresh: bool) -> tuple:
@@ -585,15 +585,15 @@ class Mil:
         return [0,]
 
     def _generate_data(self, refresh: bool) -> MilData:
-        analyser_logger.info(f"In generate_data..refresh : {refresh}")
+        eval_logger.info(f"In generate_data..refresh : {refresh}")
         시가총액_억 = self.get_marketcap억(refresh)
-        analyser_logger.info(f"{self} 시가총액(억) : {시가총액_억}")
+        eval_logger.info(f"{self} 시가총액(억) : {시가총액_억}")
 
         d1, 주주수익률, 재무활동현금흐름 = self._calc주주수익률(시가총액_억, refresh)
-        analyser_logger.info(f"{self} 주주수익률 : {주주수익률}, {d1}")
+        eval_logger.info(f"{self} 주주수익률 : {주주수익률}, {d1}")
 
         d2, 이익지표, 영업활동현금흐름, 지배주주당기순이익 = self._calc이익지표(시가총액_억, refresh)
-        analyser_logger.info(f"{self} 이익지표 : {이익지표}, {d2}")
+        eval_logger.info(f"{self} 이익지표 : {이익지표}, {d2}")
 
         d3, roic_r, roic_dict, roe_r, roe106, roa_r = self._calc투자수익률(refresh)
         d4, fcf_dict, pfcf_dict, pcr_dict = self._calc가치지표(시가총액_억, refresh)
@@ -640,7 +640,7 @@ class Mil:
         :return:
         """
         redis_name = f"{self.code}_mil"
-        analyser_logger.info(f"{self} MilData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} MilData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
@@ -677,7 +677,7 @@ class BlueData:
 class Blue:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Blue : 종목코드 ({code})")
+        eval_logger.debug(f"Blue : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c103 = myredis.C103(code, 'c103재무상태표q')
@@ -696,7 +696,7 @@ class Blue:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Blue : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Blue : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c103.code = code
@@ -711,11 +711,11 @@ class Blue:
         c104q에서 최근유동비율 찾아보고 유효하지 않거나 \n
         100이하인 경우에는수동으로 계산해서 다시 한번 평가해 본다.\n
         """
-        analyser_logger.info(f'In the calc유동비율... refresh : {refresh}')
+        eval_logger.info(f'In the calc유동비율... refresh : {refresh}')
         self.c104.page = 'c104q'
 
         유동비율date, 유동비율value = self.c104.latest_value('유동비율', pop_count=pop_count)
-        analyser_logger.info(f'{self} 유동비율 : {유동비율value}/({유동비율date})')
+        eval_logger.info(f'{self} 유동비율 : {유동비율value}/({유동비율date})')
 
         if math.isnan(유동비율value) or 유동비율value < 100:
             유동자산date, 유동자산value = Tools.calc유동자산(self.c103, refresh)
@@ -723,23 +723,23 @@ class Blue:
 
             self.c103.page = 'c103현금흐름표q'
             추정영업현금흐름date, 추정영업현금흐름value = self.c103.sum_recent_4q('영업활동으로인한현금흐름', refresh)
-            analyser_logger.debug(f'{self} 계산전 유동비율 : {유동비율value} / ({유동비율date})')
+            eval_logger.debug(f'{self} 계산전 유동비율 : {유동비율value} / ({유동비율date})')
 
             계산된유동비율 = 0
             try:
                 계산된유동비율 = round(((유동자산value + 추정영업현금흐름value) / 유동부채value) * 100, 2)
             except ZeroDivisionError:
-                analyser_logger.info(f'유동자산: {유동자산value} + 추정영업현금흐름: {추정영업현금흐름value} / 유동부채: {유동부채value}')
+                eval_logger.info(f'유동자산: {유동자산value} + 추정영업현금흐름: {추정영업현금흐름value} / 유동부채: {유동부채value}')
                 계산된유동비율 = float('inf')
             finally:
-                analyser_logger.debug(f'{self} 계산된 유동비율 : {계산된유동비율}')
+                eval_logger.debug(f'{self} 계산된 유동비율 : {계산된유동비율}')
 
                 try:
                     date, *_ = Tools.date_set(유동자산date, 유동부채date, 추정영업현금흐름date)
                 except ValueError:
                     # 날짜 데이터가 없는경우
                     date = ''
-                analyser_logger.warning(f'{self} 유동비율 이상(100 이하 또는 nan) : {유동비율value} -> 재계산 : {계산된유동비율}')
+                eval_logger.warning(f'{self} 유동비율 이상(100 이하 또는 nan) : {유동비율value} -> 재계산 : {계산된유동비율}')
                 return date, 계산된유동비율
         else:
             return 유동비율date, 유동비율value
@@ -749,7 +749,7 @@ class Blue:
 
     def _generate_data(self, refresh: bool) -> BlueData:
         d1, 유동비율 = self._calc유동비율(pop_count=3, refresh=refresh)
-        analyser_logger.info(f'유동비율 {유동비율} / [{d1}]')
+        eval_logger.info(f'유동비율 {유동비율} / [{d1}]')
 
         재고자산회전율_c106 = myredis.C106.make_like_c106(self.code, 'c104q', '재고자산회전율', refresh)
 
@@ -766,16 +766,16 @@ class Blue:
         d9, 순부채비율_r = self.c104.latest_value_pop2('순부채비율', refresh)
 
         if len(이자보상배율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 이자보상배율 : {이자보상배율_r} / {이자보상배율_dict}')
+            eval_logger.warning(f'empty dict - 이자보상배율 : {이자보상배율_r} / {이자보상배율_dict}')
 
         if len(순운전자본회전율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율_r} / {순운전자본회전율_dict}')
+            eval_logger.warning(f'empty dict - 순운전자본회전율 : {순운전자본회전율_r} / {순운전자본회전율_dict}')
 
         if len(재고자산회전율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율_r} / {재고자산회전율_dict}')
+            eval_logger.warning(f'empty dict - 재고자산회전율 : {재고자산회전율_r} / {재고자산회전율_dict}')
 
         if len(순부채비율_dict) == 0:
-            analyser_logger.warning(f'empty dict - 순부채비율 : {순부채비율_r} / {순부채비율_dict}')
+            eval_logger.warning(f'empty dict - 순부채비율 : {순부채비율_r} / {순부채비율_dict}')
 
         score = self._score()
 
@@ -813,7 +813,7 @@ class Blue:
         :return:
         """
         redis_name = f"{self.code}_blue"
-        analyser_logger.info(f"{self} BlueData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} BlueData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 
@@ -841,7 +841,7 @@ class GrowthData:
 class Growth:
     def __init__(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Growth : 종목코드 ({code})")
+        eval_logger.debug(f"Growth : 종목코드 ({code})")
 
         self.c101 = myredis.C101(code)
         self.c104 = myredis.C104(code, 'c104q')
@@ -860,7 +860,7 @@ class Growth:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.debug(f"Growth : 종목코드 변경({self.code} -> {code})")
+        eval_logger.debug(f"Growth : 종목코드 변경({self.code} -> {code})")
 
         self.c101.code = code
         self.c104.code = code
@@ -879,7 +879,7 @@ class Growth:
         self.c104.page = 'c104q'
         d2, 매출액증가율_r = self.c104.latest_value_pop2('매출액증가율')
 
-        analyser_logger.info(f'매출액증가율 : {매출액증가율_r} {매출액증가율_dict}')
+        eval_logger.info(f'매출액증가율 : {매출액증가율_r} {매출액증가율_dict}')
 
         # c106 에서 타 기업과 영업이익률 비교
         self.c106.page = 'c106y'
@@ -913,7 +913,7 @@ class Growth:
         :return:
         """
         redis_name = f"{self.code}_growth"
-        analyser_logger.info(f"{self} GrowthData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
+        eval_logger.info(f"{self} GrowthData를 레디스캐시에서 가져오거나 새로 생성합니다.. refresh : {refresh}")
         if verbose:
             print(f"{self} redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time/3600}h")
 

analyser_hj3415/tsa.py

@@ -1,6 +1,7 @@
 """
 Time Series Analysis
 """
+import numpy as np
 import yfinance as yf
 from datetime import datetime, timedelta
 import pandas as pd
@@ -14,11 +15,20 @@ import matplotlib.pyplot as plt  # Matplotlib 수동 임포트
 from db_hj3415 import myredis
 from collections import OrderedDict
 from analyser_hj3415 import eval
+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 sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from dataclasses import dataclass
+import itertools
 
 import logging
-analyser_logger = helpers.setup_logger('analyser_logger', logging.WARNING)
 
-expire_time = 3600 * 12
+tsa_logger = helpers.setup_logger('tsa_logger', logging.WARNING)
+
+expire_time = 3600 * 24
 
 class MyProphet:
     def __init__(self, code: str):
@@ -39,7 +49,7 @@ class MyProphet:
     @code.setter
     def code(self, code: str):
         assert utils.is_6digit(code), f'Invalid value : {code}'
-        analyser_logger.info(f'change code : {self.code} -> {code}')
+        tsa_logger.info(f'change code : {self.code} -> {code}')
         self.model = Prophet()
         self._code = code
         self.name = myredis.Corps(code, 'c101').get_name()
@@ -110,15 +120,24 @@ class MyProphet:
         """
         df = self.df_forecast
         last_real_date = self.df_real.iloc[-1]['ds']
-        analyser_logger.info(last_real_date)
+        tsa_logger.info(last_real_date)
         yhat_dict = df[df['ds']==last_real_date].iloc[0][['ds', 'yhat_lower', 'yhat_upper', 'yhat']].to_dict()
-        analyser_logger.info(yhat_dict)
+        tsa_logger.info(yhat_dict)
         return yhat_dict
 
-    def export_to(self, to="str") -> Optional[str]:
+    def visualization(self):
+        # 예측 결과 출력
+        print(self.df_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
+        # 예측 결과 시각화 (Matplotlib 사용)
+        fig = self.model.plot(self.df_forecast)
+        # 추세 및 계절성 시각화
+        fig2 = self.model.plot_components(self.df_forecast)
+        plt.show()  # 시각화 창 띄우기
+
+    def export(self, to="str") -> Optional[str]:
         """
         prophet과 plotly로 그래프를 그려서 html을 문자열로 반환
-        :param to: str, png, htmlfile, show
+        :param to: str, png, htmlfile
         :return:
         """
         # Plotly를 사용한 시각화
@@ -153,19 +172,12 @@ class MyProphet:
             return graph_html
         elif to == 'png':
             # 그래프를 PNG 파일로 저장
-            fig.write_image("plotly_graph.png")
+            fig.write_image(f"myprophet_{self.code}.png")
+            return None
         elif to == 'htmlfile':
             # 그래프를 HTML로 저장
-            plot(fig, filename='graph_plotly.html', auto_open=False)
+            plot(fig, filename=f'myprophet_{self.code}.html', auto_open=False)
             return None
-        elif to == 'show':
-            # 예측 결과 출력
-            print(self.df_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())
-            # 예측 결과 시각화 (Matplotlib 사용)
-            fig = self.model.plot(self.df_forecast)
-            # 추세 및 계절성 시각화
-            fig2 = self.model.plot_components(self.df_forecast)
-            plt.show()  # 시각화 창 띄우기
         else:
             Exception("to 인자가 맞지 않습니다.")
 
@@ -191,7 +203,7 @@ class MyProphet:
                 recent_price = last_real_data['y']
                 recent_date = datetime.strftime(last_real_data['ds'], '%Y-%m-%d')
                 yhat_dict = p.get_yhat()
-                analyser_logger.info(f'recent_price: {recent_price}, yhat_dict: {yhat_dict}')
+                tsa_logger.info(f'recent_price: {recent_price}, yhat_dict: {yhat_dict}')
                 yhat_lower = int(yhat_dict['yhat_lower'])
                 if recent_price < yhat_lower:
                     deviation = int(eval.Tools.cal_deviation(recent_price, yhat_lower))
@@ -203,5 +215,401 @@ class MyProphet:
 
         return OrderedDict(sorted(data_dict.items(), key=lambda item: item[1], reverse=True))
 
+@dataclass
+class LSTMData:
+    code: str
+
+    data_2d: np.ndarray
+    train_size: int
+    train_data_2d: np.ndarray
+    test_data_2d: np.ndarray
+
+    X_train_3d: np.ndarray
+    X_test_3d: np.ndarray
+    y_train_1d: np.ndarray
+    y_test_1d: np.ndarray
+
+@dataclass
+class LSTMGrade:
+    """
+    딥러닝 모델의 학습 결과를 평가하기 위해 사용하는 데이터 클래스
+    """
+    code: str
+
+    mean_train_prediction_2d: np.ndarray
+    mean_test_predictions_2d: np.ndarray
+
+    train_mse: float
+    train_mae: float
+    train_r2: float
+    test_mse: float
+    test_mae: float
+    test_r2: float
+
+class MyLSTM:
+    """
+    LSTM(Long Short-Term Memory)
+    """
+    # 미래 몇일을 예측할 것인가?
+    future_days = 30
+
+    def __init__(self, code: str):
+        assert utils.is_6digit(code), f'Invalid value : {code}'
+        self._code = code
+        self.name = myredis.Corps(code, 'c101').get_name()
+        self.scaler = MinMaxScaler(feature_range=(0, 1))
+        self.raw_data = self._get_raw_data()
+        self.lstm_data = self._preprocessing_for_lstm()
+
+    @property
+    def code(self) -> str:
+        return self._code
+
+    @code.setter
+    def code(self, code: str):
+        assert utils.is_6digit(code), f'Invalid value : {code}'
+        tsa_logger.info(f'change code : {self.code} -> {code}')
+
+        self._code = code
+        self.name = myredis.Corps(code, 'c101').get_name()
+        self.scaler = MinMaxScaler(feature_range=(0, 1))
+        self.raw_data = self._get_raw_data()
+        self.lstm_data = self._preprocessing_for_lstm()
+
+    def _get_raw_data(self) -> pd.DataFrame:
+        """
+        야후에서 해당 종목의 4년간 주가 raw data를 받아온다.
+        :return:
+        """
+        # 오늘 날짜 가져오기
+        today = datetime.today()
+
+        # 4년 전 날짜 계산 (4년 = 365일 * 4)
+        four_years_ago = today - timedelta(days=365 * 4)
+        tsa_logger.info(f'start: {four_years_ago.strftime('%Y-%m-%d')}, end: {today.strftime('%Y-%m-%d')}')
+
+        return yf.download(
+            self.code + '.KS',
+            start=four_years_ago.strftime('%Y-%m-%d'),
+            end=today.strftime('%Y-%m-%d')
+        )
+
+    def _preprocessing_for_lstm(self) -> LSTMData:
+        """
+        lstm이 사용할 수 있도록 데이터 준비(정규화 및 8:2 훈련데이터 검증데이터 분리 및 차원변환)
+        :return:
+        """
+        # 필요한 열만 선택 (종가만 사용) - 2차웜 배열로 변환
+        data_2d = self.raw_data['Close'].values.reshape(-1, 1)
+        tsa_logger.debug(data_2d)
+
+        # 데이터 정규화 (0과 1 사이로 스케일링)
+        scaled_data_2d = self.scaler.fit_transform(data_2d)
+
+        # 학습 데이터 생성
+        # 주가 데이터를 80%는 학습용, 20%는 테스트용으로 분리하는 코드
+        train_size = int(len(scaled_data_2d) * 0.8)
+        train_data_2d = scaled_data_2d[:train_size]
+        test_data_2d = scaled_data_2d[train_size:]
+        tsa_logger.info(f'총 {len(data_2d)}개 데이터, train size : {train_size}')
+
+        # 학습 데이터에 대한 입력(X)과 정답(y)를 생성
+        def create_dataset(data, time_step=60):
+            X, y = [], []
+            for i in range(len(data) - time_step):
+                X.append(data[i:i + time_step, 0])
+                y.append(data[i + time_step, 0])
+            return np.array(X), np.array(y)
+
+        X_train, y_train_1d = create_dataset(train_data_2d)
+        X_test, y_test_1d = create_dataset(test_data_2d)
+
+        # LSTM 모델 입력을 위해 데이터를 3차원으로 변환
+        X_train_3d = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+        X_test_3d = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
+
+        tsa_logger.debug(f'n_dim - X_train_3d : {X_train_3d.ndim}, X_test_3d : {X_test_3d.ndim}, y_train : {y_train_1d.ndim}, y_test : {y_test_1d.ndim}')
+        tsa_logger.debug(f'len - X_train_3d : {len(X_train_3d)}, X_test_3d : {len(X_test_3d)}, y_train : {len(y_train_1d)}, y_test : {len(y_test_1d)}')
+
+        return LSTMData(
+            code=self.code,
+            data_2d=data_2d,
+            train_size=train_size,
+            train_data_2d=train_data_2d,
+            test_data_2d=test_data_2d,
+            X_train_3d=X_train_3d,
+            X_test_3d=X_test_3d,
+            y_train_1d=y_train_1d,
+            y_test_1d=y_test_1d,
+        )
+
+    def _model_training(self) -> Sequential:
+        # LSTM 모델 생성 - 유닛과 드롭아웃의 수는 테스트로 최적화 됨.
+        model = Sequential()
+        # Input(shape=(50, 1))는 50개의 타임스텝을 가지는 입력 데이터를 처리하며, 각 타임스텝에 1개의 특성이 있다는 것을 의미
+        model.add(Input(shape=(self.lstm_data.X_train_3d.shape[1], 1)))  # 입력 레이어에 명시적으로 Input을 사용
+        model.add(LSTM(units=150, return_sequences=True))
+        model.add(Dropout(0.2))
+        model.add(LSTM(units=75, return_sequences=False))
+        model.add(Dropout(0.2))
+        model.add(Dense(units=25))
+        model.add(Dropout(0.3))
+        model.add(Dense(units=1))
+
+        # 모델 요약 출력
+        # model.summary()
+
+        # 모델 컴파일 및 학습
+        model.compile(optimizer='adam', loss='mean_squared_error')
+
+        # 조기 종료 설정
+        early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
+
+        # 모델 학습 - 과적합 방지위한 조기종료 세팅
+        model.fit(self.lstm_data.X_train_3d, self.lstm_data.y_train_1d,
+                  epochs=75, batch_size=32, validation_data=(self.lstm_data.X_test_3d, self.lstm_data.y_test_1d),
+                  callbacks=[early_stopping])
+        return model
+
+    def ensemble_training(self, num) -> tuple:
+        """
+        딥러닝을 num 회 반복하고 평균을 사용하는 함수
+        :param num: 앙상블 모델 수
+        :return:
+        """
+        def prediction(model_in: Sequential, data: np.ndarray) -> np.ndarray:
+            """
+            훈련될 모델을 통해 예측을 시행하여 정규화를 복원하고 결과 반환한다.
+            :param model_in:
+            :param data:
+            :return:
+            """
+            predictions_2d = model_in.predict(data)
+            predictions_scaled_2d = self.scaler.inverse_transform(predictions_2d)  # 스케일링 복원
+            tsa_logger.info(f'predictions_scaled_2d : ndim - {predictions_scaled_2d.ndim} len - {len(predictions_scaled_2d)}')  # numpy.ndarray 타입
+            tsa_logger.debug(predictions_scaled_2d)
+            return predictions_scaled_2d
+
+        ensemble_train_predictions_2d = []
+        ensemble_test_predictions_2d = []
+        ensemble_future_predictions_2d = []
+
+        for i in range(num):
+            print(f"Training model {i + 1}/{num}...")
+            model = self._model_training()
+
+            # 훈련 데이터 예측
+            train_predictions_scaled_2d = prediction(model, self.lstm_data.X_train_3d)
+            ensemble_train_predictions_2d.append(train_predictions_scaled_2d)
+
+            # 테스트 데이터 예측
+            test_predictions_scaled_2d = prediction(model, self.lstm_data.X_test_3d)
+            ensemble_test_predictions_2d.append(test_predictions_scaled_2d)
+
+            # 8. 미래 30일 예측
+            # 마지막 60일간의 데이터를 기반으로 미래 30일을 예측
+
+            last_60_days_2d = self.lstm_data.test_data_2d[-60:]
+            last_60_days_3d = last_60_days_2d.reshape(1, -1, 1)
+
+            future_predictions = []
+            for _ in range(self.future_days):
+                predicted_price_2d = model.predict(last_60_days_3d)
+                future_predictions.append(predicted_price_2d[0][0])
+
+                # 예측값을 다시 입력으로 사용하여 새로운 예측을 만듦
+                predicted_price_reshaped = np.reshape(predicted_price_2d, (1, 1, 1))  # 3D 배열로 변환
+                last_60_days_3d = np.append(last_60_days_3d[:, 1:, :], predicted_price_reshaped, axis=1)
+
+            # 예측된 주가를 다시 스케일링 복원
+            future_predictions_2d = np.array(future_predictions).reshape(-1, 1)
+            future_predictions_scaled_2d = self.scaler.inverse_transform(future_predictions_2d)
+            ensemble_future_predictions_2d.append(future_predictions_scaled_2d)
+
+        return ensemble_train_predictions_2d, ensemble_test_predictions_2d, ensemble_future_predictions_2d
+
+    def grading(self, ensemble_train_predictions_2d: list, ensemble_test_predictions_2d: list) -> LSTMGrade:
+        """
+        딥러닝 결과를 분석하기 위한 함수
+        :param ensemble_train_predictions_2d:
+        :param ensemble_test_predictions_2d:
+        :return:
+        """
+        # 예측값을 평균내서 최종 예측값 도출
+        mean_train_prediction_2d = np.mean(ensemble_train_predictions_2d, axis=0)
+        mean_test_predictions_2d = np.mean(ensemble_test_predictions_2d, axis=0)
+
+        # y값(정답) 정규화 해제
+        y_train_scaled_2d = self.scaler.inverse_transform(self.lstm_data.y_train_1d.reshape(-1, 1))
+        y_test_scaled_2d = self.scaler.inverse_transform(self.lstm_data.y_test_1d.reshape(-1, 1))
+
+        # 평가 지표 계산
+        train_mse = mean_squared_error(y_train_scaled_2d, mean_train_prediction_2d)
+        train_mae = mean_absolute_error(y_train_scaled_2d, mean_train_prediction_2d)
+        train_r2 = r2_score(y_train_scaled_2d, mean_train_prediction_2d)
+
+        test_mse = mean_squared_error(y_test_scaled_2d, mean_test_predictions_2d)
+        test_mae = mean_absolute_error(y_test_scaled_2d, mean_test_predictions_2d)
+        test_r2 = r2_score(y_test_scaled_2d, mean_test_predictions_2d)
+
+        # 평가 결과 출력
+        print("Training Data:")
+        print(f"Train MSE: {train_mse}, Train MAE: {train_mae}, Train R²: {train_r2}")
+        print("\nTesting Data:")
+        print(f"Test MSE: {test_mse}, Test MAE: {test_mae}, Test R²: {test_r2}")
+        # mse, mae는 작을수록 좋으며 R^2은 0-1 사이값 1에 가까울수록 정확함
+        # 과적합에 대한 평가는 train 과 test를 비교하여 test가 너무 않좋으면 과적합 의심.
+
+        return LSTMGrade(
+            code=self.code,
+            mean_train_prediction_2d=mean_train_prediction_2d,
+            mean_test_predictions_2d=mean_test_predictions_2d,
+            train_mse=train_mse,
+            train_mae=train_mae,
+            train_r2=train_r2,
+            test_mse=test_mse,
+            test_mae=test_mae,
+            test_r2=test_r2,
+        )
+
+    def get_final_predictions(self, refresh, num=5) -> tuple:
+        """
+        미래 예측치를 레디스 캐시를 이용하여 반환함
+        :param refresh:
+        :param num: 앙상블 반복횟수
+        :return:
+        """
+        print("**** Start get_final_predictions... ****")
+        redis_name = f'{self.code}_mylstm_predictions'
+
+        print(
+            f"redisname: '{redis_name}' / refresh : {refresh} / expire_time : {expire_time / 3600}h")
+
+        def fetch_final_predictions(num_in) -> tuple:
+            """
+            앙상블법으로 딥러닝을 모델을 반복해서 평균을 내서 미래를 예측한다. 평가는 래시스 캐시로 반환하기 어려워 일단 디버그 용도로만 사용하기로
+            :param num_in:
+            :return:
+            """
+            # 앙상블 테스트와 채점
+            _, _, ensemble_future_predictions_2d = self.ensemble_training(
+                num=num_in)
+
+            """if grading:
+                lstm_grade = self.grading(ensemble_train_predictions_2d, ensemble_test_predictions_2d)
+            else:
+                lstm_grade = None"""
+
+            # 시각화를 위한 준비 - 날짜 생성 (미래 예측 날짜), 미래예측값 평균
+            last_date = self.raw_data.index[-1]
+            future_dates = pd.date_range(last_date, periods=self.future_days + 1).tolist()[1:]
+
+            # Timestamp 객체를 문자열로 변환
+            future_dates_str= [date.strftime('%Y-%m-%d') for date in future_dates]
+
+            final_future_predictions = np.mean(ensemble_future_predictions_2d, axis=0)
+            tsa_logger.info(f'num - future dates : {len(future_dates_str)} future data : {len(final_future_predictions)}')
+
+            assert len(future_dates_str) == len(final_future_predictions), "future_dates 와 final_future_predictions 개수가 일치하지 않습니다."
+
+            return future_dates_str, final_future_predictions.tolist()
+
+        future_dates_str, final_future_predictions = myredis.Base.fetch_and_cache_data(redis_name, refresh, fetch_final_predictions, num, timer=expire_time)
+
+        # 문자열을 날짜 형식으로 변환
+        future_dates = [datetime.strptime(date, '%Y-%m-%d') for date in future_dates_str]
+
+        # 리스트를 다시 NumPy 배열로 변환
+        final_future_predictions = np.array(final_future_predictions)
+
+        return future_dates, final_future_predictions
+
+    def export(self, refresh=False, to="str") -> Optional[str]:
+        """
+        prophet과 plotly로 그래프를 그려서 html을 문자열로 반환
+        :param refresh:
+        :param to: str, htmlfile, png
+        :return:
+        """
+        future_dates, final_future_predictions = self.get_final_predictions(refresh=refresh)
+        final_future_predictions = final_future_predictions.reshape(-1) # 차원을 하나 줄인다.
+
+        # Plotly를 사용한 시각화
+        fig = go.Figure()
+
+        # 실제 데이터
+        fig.add_trace(go.Scatter(x=self.raw_data.index[-120:], y=self.raw_data['Close'][-120:], mode='markers', name='실제주가'))
+        tsa_logger.debug(f"self.raw_data.index[-120:] - {self.raw_data.index[-120:]}")
+        tsa_logger.debug(f"self.raw_data['Close'][-120:] - {self.raw_data['Close'][-120:]}")
+        # 예측 데이터
+        fig.add_trace(go.Scatter(x=future_dates, y=final_future_predictions, mode='lines+markers', name='예측치(30일)'))
+        tsa_logger.debug(f"future_dates - {future_dates}")
+        tsa_logger.debug(f"final_future_predictions - {final_future_predictions}")
+
+        fig.update_layout(
+            # title=f'{self.code} {self.name} 주가 예측 그래프(prophet)',
+            xaxis_title='일자',
+            yaxis_title='주가(원)',
+            xaxis = dict(
+                tickformat='%Y/%m',  # X축을 '연/월' 형식으로 표시
+            ),
+            yaxis = dict(
+                tickformat=".0f",  # 소수점 없이 원래 숫자 표시
+            )
+        )
+
+        if to == 'str':
+            # 그래프 HTML로 변환 (string 형식으로 저장)
+            graph_html = plot(fig, output_type='div')
+            return graph_html
+        elif to == 'png':
+            # 그래프를 PNG 파일로 저장
+            fig.write_image(f"myLSTM_{self.code}.png")
+            return None
+        elif to == 'htmlfile':
+            # 그래프를 HTML로 저장
+            plot(fig, filename=f'myLSTM_{self.code}.html', auto_open=False)
+            return None
+        else:
+            Exception("to 인자가 맞지 않습니다.")
+
+    def visualization(self, refresh=True):
+        future_dates, final_future_predictions = self.get_final_predictions(refresh=refresh)
+
+        # 시각화1
+        plt.figure(figsize=(10, 6))
+
+        # 실제 주가
+        plt.plot(self.raw_data.index, self.raw_data['Close'], label='Actual Price')
+
+        # 미래 주가 예측
+        plt.plot(future_dates, final_future_predictions, label='Future Predicted Price', linestyle='--')
+
+        plt.xlabel('Date')
+        plt.ylabel('Stock Price')
+        plt.legend()
+        plt.title('Apple Stock Price Prediction with LSTM')
+        plt.show()
+
+        """# 시각화2
+        plt.figure(figsize=(10, 6))
+        plt.plot(self.raw_data.index[self.lstm_data.train_size + 60:], self.lstm_data.data_2d[self.lstm_data.train_size + 60:], label='Actual Price')
+        plt.plot(self.raw_data.index[self.lstm_data.train_size + 60:], lstm_grade.mean_test_predictions_2d, label='Predicted Price')
+        plt.xlabel('Date')
+        plt.ylabel('Price')
+        plt.legend()
+        plt.title('Stock Price Prediction with LSTM Ensemble')
+        plt.show()"""
+
+    def caching_based_on_prophet_ranking(self, refresh: bool, top=20):
+        ranking_topn = OrderedDict(itertools.islice(MyProphet.ranking().items(), top))
+        tsa_logger.info(ranking_topn)
+        print(f"*** LSTM prediction redis cashing top{top} items ***")
+        for i, (code, _) in enumerate(ranking_topn.items()):
+            print(f"{i+1}. {self.code}/{self.name}")
+            self.code = code
+            self.get_final_predictions(refresh=refresh, num=5)
+
+
 
 

{analyser_hj3415-2.8.2.dist-info → analyser_hj3415-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: analyser_hj3415
-Version: 2.8.2
+Version: 2.9.0
 Summary: Stock analyser and database processing programs
 Author-email: Hyungjin Kim <hj3415@gmail.com>
 Description-Content-Type: text/markdown

{analyser_hj3415-2.8.2.dist-info → analyser_hj3415-2.9.0.dist-info}/RECORD

@@ -1,16 +1,15 @@
 analyser_hj3415/.DS_Store,sha256=qr9-0FPn5CFKe6kEu8_dWCNhzQ0sN7bwQgffKsaJEEo,6148
 analyser_hj3415/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-analyser_hj3415/cli.py,sha256=SnIcejcjbXR9rMA7zIm-hIXgbIIlFJkZPMUCvo_AgtQ,11725
-analyser_hj3415/eval.py,sha256=4F0GIknCogAhv_iTq8auLrmwW20u8kH0HY0fP4SaVa4,39099
-analyser_hj3415/tsa.py,sha256=3mZ0hjUNt202MAytnjAYAoG1Cj9Zl6S_Rmz39_0iC98,7875
+analyser_hj3415/cli.py,sha256=EW0-lIrpZHNNeDKksxC4qDBCiHPkYMGMHsZhAg6VsS8,12870
+analyser_hj3415/eval.py,sha256=WWIvB4BebjW9GNGcF8rMd-MLL-lPXUBOH01_FpSq95I,38811
+analyser_hj3415/tsa.py,sha256=fAC4hsqWMkzoHrRr9Ulcq0s6lVfbQE7vTP_ulJmXkcQ,25097
 analyser_hj3415/workroom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-analyser_hj3415/workroom/lstm.py,sha256=b0ICzIVeCODcH4tAkVyrHVJLXwf21wmkIambKPHaZMQ,4155
 analyser_hj3415/workroom/mysklearn.py,sha256=wJXKz5MqqTzADdG2mqRMMzc_G9RzwYjj5_j4gyOopxQ,2030
 analyser_hj3415/workroom/mysklearn2.py,sha256=1lIy6EWEQHkOzDS-av8U0zQH6DuCLKWMI73dnJx5KRs,1495
 analyser_hj3415/workroom/score.py,sha256=P6nHBJYmyhigGtT4qna4BmNtvt4B93b7SKyzdstJK24,17376
 analyser_hj3415/workroom/trash.py,sha256=zF-W0piqkGr66UP6-iybo9EXh2gO0RP6R1FnIpsGkl8,12262
-analyser_hj3415-2.8.2.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
-analyser_hj3415-2.8.2.dist-info/LICENSE,sha256=QVKTp0dTnB5xG8RLgG17LwSWCKNEzYoVVM6KjoCPKc0,1079
-analyser_hj3415-2.8.2.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-analyser_hj3415-2.8.2.dist-info/METADATA,sha256=czwwaazkGIYfdqgPoz6AOleeIQgsLuR_99Xd-8OtV0o,6607
-analyser_hj3415-2.8.2.dist-info/RECORD,,
+analyser_hj3415-2.9.0.dist-info/entry_points.txt,sha256=ZfjPnJuH8SzvhE9vftIPMBIofsc65IAWYOhqOC_L5ck,65
+analyser_hj3415-2.9.0.dist-info/LICENSE,sha256=QVKTp0dTnB5xG8RLgG17LwSWCKNEzYoVVM6KjoCPKc0,1079
+analyser_hj3415-2.9.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+analyser_hj3415-2.9.0.dist-info/METADATA,sha256=i3FwxTCib11QDlFyxVKM_mKBxH8fXmTxP82gjttoiYE,6607
+analyser_hj3415-2.9.0.dist-info/RECORD,,

analyser_hj3415/workroom/lstm.py

@@ -1,115 +0,0 @@
-import yfinance as yf
-import numpy as np
-import pandas as pd
-from sklearn.preprocessing import MinMaxScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Dense, Dropout
-import matplotlib.pyplot as plt
-
-# 1. 데이터 다운로드 (애플 주식 데이터를 사용)
-#stock_data = yf.download('AAPL', start='2020-01-01', end='2023-01-01')
-# 삼성전자 주식 데이터 가져오기 (KOSPI 상장)
-#stock_data = yf.download('005930.KS', start='2019-01-01', end='2024-10-11')
-# 크래프톤 주식 데이터 가져오기 (KOSPI 상장)
-stock_data = yf.download('259960.KS', start='2020-01-01', end='2024-10-11')
-# 하이닉스 주식 데이터 가져오기 (KOSPI 상장)
-#stock_data = yf.download('000660.KS', start='2019-01-01', end='2024-10-11')
-
-stock_data = yf.download('004490.KS', start='2020-01-01', end='2024-10-15')
-
-
-# 2. 필요한 열만 선택 (종가만 사용)
-data = stock_data['Close'].values.reshape(-1, 1)
-
-# 3. 데이터 정규화 (0과 1 사이로 스케일링)
-scaler = MinMaxScaler(feature_range=(0, 1))
-scaled_data = scaler.fit_transform(data)
-
-# 4. 학습 데이터 생성
-# 주가 데이터를 80%는 학습용, 20%는 테스트용으로 분리하는 코드
-train_size = int(len(scaled_data) * 0.8)
-train_data = scaled_data[:train_size]
-test_data = scaled_data[train_size:]
-
-
-# 학습 데이터에 대한 입력(X)과 출력(y)를 생성
-def create_dataset(data, time_step=60):
-    X, y = [], []
-    for i in range(len(data) - time_step):
-        X.append(data[i:i + time_step, 0])
-        y.append(data[i + time_step, 0])
-    return np.array(X), np.array(y)
-
-
-X_train, y_train = create_dataset(train_data)
-X_test, y_test = create_dataset(test_data)
-
-# LSTM 모델 입력을 위해 데이터를 3차원으로 변환
-X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
-X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
-
-# 5. LSTM 모델 생성
-model = Sequential()
-model.add(LSTM(units=200, return_sequences=True, input_shape=(X_train.shape[1], 1)))
-model.add(Dropout(0.2))
-model.add(LSTM(units=100, return_sequences=False))
-model.add(Dropout(0.2))
-model.add(Dense(units=50))
-model.add(Dropout(0.3))
-model.add(Dense(units=1))
-
-# 6. 모델 컴파일 및 학습
-model.compile(optimizer='adam', loss='mean_squared_error')
-model.fit(X_train, y_train, epochs=20, batch_size=32)
-
-# 7. 테스트 데이터 예측
-predictions = model.predict(X_test)
-predictions = scaler.inverse_transform(predictions)  # 스케일링 복원
-
-# 8. 미래 30일 예측
-# 마지막 60일간의 데이터를 기반으로 미래 30일을 예측
-future_days = 30
-last_60_days = test_data[-60:]
-last_60_days = last_60_days.reshape(1, -1, 1)
-
-future_predictions = []
-for _ in range(future_days):
-    predicted_price = model.predict(last_60_days)
-    future_predictions.append(predicted_price[0][0])
-
-    # 예측값을 다시 입력으로 사용하여 새로운 예측을 만듦
-    predicted_price_reshaped = np.reshape(predicted_price, (1, 1, 1))  # 3D 배열로 변환
-    last_60_days = np.append(last_60_days[:, 1:, :], predicted_price_reshaped, axis=1)
-
-# 예측된 주가를 다시 스케일링 복원
-future_predictions = np.array(future_predictions).reshape(-1, 1)
-future_predictions = scaler.inverse_transform(future_predictions)
-
-# 9. 날짜 생성 (미래 예측 날짜)
-last_date = stock_data.index[-1]
-future_dates = pd.date_range(last_date, periods=future_days + 1).tolist()[1:]
-
-# 10. 시각화
-plt.figure(figsize=(10, 6))
-
-# 실제 주가
-plt.plot(stock_data.index, stock_data['Close'], label='Actual Price')
-
-# 미래 주가 예측
-plt.plot(future_dates, future_predictions, label='Future Predicted Price', linestyle='--')
-
-plt.xlabel('Date')
-plt.ylabel('Stock Price')
-plt.legend()
-plt.title('Apple Stock Price Prediction with LSTM')
-plt.show()
-
-# 8. 시각화
-plt.figure(figsize=(10, 6))
-plt.plot(stock_data.index[train_size + 60:], data[train_size + 60:], label='Actual Price')
-plt.plot(stock_data.index[train_size + 60:], predictions, label='Predicted Price')
-plt.xlabel('Date')
-plt.ylabel('Price')
-plt.legend()
-plt.title('Apple Stock Price Prediction with LSTM')
-plt.show()