From 67a9b23fa58213d8809f28ae6e3a70135f5b6fea Mon Sep 17 00:00:00 2001 From: Ayuriel Date: Sun, 30 Mar 2025 21:19:41 +0900 Subject: [PATCH] =?UTF-8?q?feat:=20=EA=B5=AC=EC=A1=B0=20=EB=A6=AC=ED=8C=A9?= =?UTF-8?q?=ED=86=A0=EB=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 124 ++++++++- src/app.py | 44 +++ src/backtest/__init__.py | 0 src/backtest/engine.py | 48 ++++ src/data/__init__.py | 1 + src/data/financial.py | 114 ++++++++ src/data/krx.py | 193 ++++++++++++++ src/data/prices.py | 83 ++++++ src/db/__init__.py | 1 + src/db/common.py | 140 ++++++++++ src/strategies/__init__.py | 1 + src/strategies/composite/__init__.py | 1 + src/strategies/composite/magic_formula.py | 77 ++++++ src/strategies/composite/multi_factor.py | 251 ++++++++++++++++++ src/strategies/composite/super_quality.py | 67 +++++ .../composite/super_value_momentum.py | 3 + src/strategies/factors/__init__.py | 1 + src/strategies/factors/all_value.py | 37 +++ src/strategies/factors/f_score.py | 104 ++++++++ src/strategies/factors/momentum.py | 88 ++++++ src/strategies/factors/quality.py | 58 ++++ src/strategies/factors/value.py | 27 ++ src/strategies/utils.py | 80 ++++++ src/ui/__init__.py | 1 + src/ui/pages/__init__.py | 1 + src/ui/pages/data_page.py | 60 +++++ src/ui/pages/quality_page.py | 118 ++++++++ src/ui/pages/value_momentum_page.py | 146 ++++++++++ streamlit_quant/app.py | 2 +- streamlit_quant/crawling.py | 2 +- streamlit_quant/super_quality.py | 2 +- streamlit_quant/super_value_momentum.py | 2 +- 32 files changed, 1865 insertions(+), 12 deletions(-) create mode 100644 src/app.py create mode 100644 src/backtest/__init__.py create mode 100644 src/backtest/engine.py create mode 100644 src/data/__init__.py create mode 100644 src/data/financial.py create mode 100644 src/data/krx.py create mode 100644 src/data/prices.py create mode 100644 src/db/__init__.py create mode 100644 src/db/common.py create mode 100644 src/strategies/__init__.py create mode 100644 src/strategies/composite/__init__.py create mode 100644 src/strategies/composite/magic_formula.py create mode 100644 src/strategies/composite/multi_factor.py create mode 100644 src/strategies/composite/super_quality.py create mode 100644 src/strategies/composite/super_value_momentum.py create mode 100644 src/strategies/factors/__init__.py create mode 100644 src/strategies/factors/all_value.py create mode 100644 src/strategies/factors/f_score.py create mode 100644 src/strategies/factors/momentum.py create mode 100644 src/strategies/factors/quality.py create mode 100644 src/strategies/factors/value.py create mode 100644 src/strategies/utils.py create mode 100644 src/ui/__init__.py create mode 100644 src/ui/pages/__init__.py create mode 100644 src/ui/pages/data_page.py create mode 100644 src/ui/pages/quality_page.py create mode 100644 src/ui/pages/value_momentum_page.py diff --git a/README.md b/README.md index 6034df6..480cbff 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,117 @@ -# 실행 -streamlit run app.py --server.port=20000 +# 콴트 매니저 (Quant Manager) -# pre- -Go to Build Tools for Visual Studio 2017 -Select free download under Visual Studio Community 2017. This will download the installer. Run the installer. -Select what you need under workload tab: -a. Under Windows, there are three choices. Only check Desktop development with C++. -b. Under Web & Cloud, there are seven choices. Only check Python development (I believe this is optional, but I have done it). \ No newline at end of file +한국 주식 시장을 위한 퀀트 투자 도구입니다. + +## 프로젝트 구조 + +``` +make-quant-py/ +├── data/ # 데이터 수집 관련 코드 +│ ├── krx.py # 한국거래소 데이터 수집 +│ ├── prices.py # 가격 데이터 수집 +│ ├── financial.py # 재무제표 데이터 수집 +│ └── crawling.py # 웹 크롤링 유틸리티 +├── db/ # 데이터베이스 유틸리티 +│ └── common.py # DB 연결 및 쿼리 공통 기능 +├── strategies/ # 전략 구현 +│ ├── factors/ # 개별 요소 모듈 +│ │ ├── value.py # 가치 전략 +│ │ ├── quality.py # 퀄리티 전략 +│ │ ├── momentum.py # 모멘텀 전략 +│ │ ├── f_score.py # F-Score 전략 +│ │ └── all_value.py # 종합 가치 전략 +│ ├── composite/ # 복합 전략 구현 +│ │ ├── magic_formula.py # 마법공식 전략 +│ │ ├── multi_factor.py # 멀티팩터 전략 +│ │ ├── super_quality.py # 슈퍼 퀄리티 전략 +│ │ └── super_value_momentum.py # 슈퍼 밸류 모멘텀 전략 +│ └── utils.py # 전략 공통 유틸리티 +├── backtest/ # 백테스트 도구 +│ └── engine.py # 백테스트 구현 +└── streamlit/ # Streamlit 웹 앱 + ├── app.py # 메인 앱 + ├── pages/ # 개별 페이지 + │ ├── data_page.py # 데이터 수집 페이지 + │ ├── quality_page.py # 슈퍼 퀄리티 전략 페이지 + │ └── value_momentum_page.py # 밸류 모멘텀 전략 페이지 + └── components/ # 재사용 가능한 UI 컴포넌트 + └── charts.py # 시각화 컴포넌트 +``` + +## 설치 및 설정 + +### 필수 요구사항 + +- Python 3.8 이상 +- MySQL 또는 MariaDB + +Windows에서 필요한 빌드 도구: +- Visual Studio Build Tools 2017 이상 + - Desktop development with C++ 워크로드 선택 + - (선택사항) Python development 워크로드 선택 + +### 가상환경 설정 + +가상환경 생성: +``` +python -m venv .venv +``` + +가상환경 활성화: +- Windows: `.venv\Scripts\activate` +- Linux/Mac: `. .venv/bin/activate` + +패키지 설치: +``` +pip install -r requirements.txt +``` + +가상환경 종료: +``` +deactivate +``` + +### 환경 변수 설정 + +프로젝트 루트에 `.env` 파일을 생성하고 다음 환경 변수를 설정하세요: + +``` +DB_USER=your_db_user +DB_PW=your_db_password +DB_HOST=localhost +DB_PORT=3306 +DB_DB=your_db_name +``` + +## 실행 방법 + +Streamlit 앱 실행: +``` +streamlit run src/app.py --server.port=20000 +``` + +## 모듈 + +### 데이터 수집 + +- `data/krx.py`: 한국거래소(KRX)에서 주식 데이터를 수집합니다. +- `data/prices.py`: 네이버 금융에서 주가 데이터를 수집합니다. +- `data/financial.py`: FnGuide에서 재무제표 데이터를 수집합니다. + +### 투자 전략 + +#### 개별 요소 전략 +- `strategies/factors/value.py`: PER, PBR 등 가치 지표 기반 전략 +- `strategies/factors/quality.py`: ROE, GPA 등 퀄리티 지표 기반 전략 +- `strategies/factors/momentum.py`: 주가 모멘텀 기반 전략 +- `strategies/factors/f_score.py`: Piotroski의 F-Score 계산 전략 + +#### 복합 전략 +- `strategies/composite/magic_formula.py`: Joel Greenblatt의 마법공식 전략 +- `strategies/composite/multi_factor.py`: 다중 요소 통합 전략 +- `strategies/composite/super_quality.py`: F-Score와 GP/A를 결합한 슈퍼 퀄리티 전략 +- `strategies/composite/super_value_momentum.py`: 가치와 모멘텀을 결합한 전략 + +### 백테스트 + +- `backtest/engine.py`: bt 패키지를 사용한 백테스트 기능 구현 \ No newline at end of file diff --git a/src/app.py b/src/app.py new file mode 100644 index 0000000..9c55f74 --- /dev/null +++ b/src/app.py @@ -0,0 +1,44 @@ +""" +Main Streamlit application for the Quant Manager. +""" +import streamlit as st +from ui.pages.data_page import render_data_page +from ui.pages.quality_page import render_quality_page +from ui.pages.value_momentum_page import render_value_momentum_page + +# Configure the application +st.set_page_config( + page_title="콴트 매니저", + page_icon="📊", + layout="wide", + initial_sidebar_state="expanded" +) + +# Define the sidebar navigation +def main(): + """Main application function.""" + # Create sidebar navigation + st.sidebar.title("콴트 매니저") + + # Navigation options + pages = { + "데이터 수집": render_data_page, + "슈퍼 퀄리티 전략": render_quality_page, + "슈퍼 밸류 모멘텀 전략": render_value_momentum_page + } + + # Select page + selection = st.sidebar.radio("메뉴", list(pages.keys())) + + # Render the selected page + pages[selection]() + + # Footer + st.sidebar.markdown("---") + st.sidebar.info( + "© 2023-2025 콴트 매니저\n\n" + "한국 주식 시장을 위한 퀀트 투자 도구" + ) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/backtest/__init__.py b/src/backtest/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/backtest/engine.py b/src/backtest/engine.py new file mode 100644 index 0000000..63e27af --- /dev/null +++ b/src/backtest/engine.py @@ -0,0 +1,48 @@ +import bt +import matplotlib.pyplot as plt + +import pandas as pd + +from db.common import DBManager +import streamlit_quant.strategy.multi_factor as multi_factor +import streamlit_quant.strategy.magic_formula as magic_formula + + +qc = DBManager() +mf = multi_factor.get_multi_factor_top(qc, 20) +magic_formula = magic_formula.get_magic_formula_top(20) + +codes = ','.join(magic_formula['종목코드'].array) +price = qc.get_price_list_by_code(codes) + +# price = price.set_index(['날짜']) +# price.rename(columns={"날짜": "Date"}) +price["Date"] = pd.to_datetime(price["날짜"]) + +pivot_df = price.pivot(index="Date", columns="종목코드", values="종가") + +# print(pivot_df.tail) + +strategy = bt.Strategy("Asset_EW", [ + bt.algos.SelectAll(), # 모든 데이터 사용 + bt.algos.WeighEqually(), # 동일 비중 투자 + bt.algos.RunMonthly(), # 매 월말 리밸런싱 + bt.algos.Rebalance() # 계산된 비중에 따라 리밸런싱 +]) + +# 가격 데이터 중 시작 시점이 모두 다르므로, dropna() 함수를 통해 NA를 모두 제거하여 시작 시점을 맞춤 +pivot_df.dropna(inplace=True) + +# 백테스트 생성 +backtest = bt.Backtest(strategy, pivot_df) + +# 백테스트 실행 +result = bt.run(backtest) +# prices: 누적 수익률이 데이터프레임 형태로 나타나며, 시작 시점을 100으로 환산하여 계산 +# to_returns: 수익률 계산 +# print(result.prices.to_returns()) + +result.plot(figsize=(10, 6), legend=False) +plt.show() + +result.display() \ No newline at end of file diff --git a/src/data/__init__.py b/src/data/__init__.py new file mode 100644 index 0000000..5a2c0f1 --- /dev/null +++ b/src/data/__init__.py @@ -0,0 +1 @@ +__all__ = ['financial', 'krx', 'prices'] \ No newline at end of file diff --git a/src/data/financial.py b/src/data/financial.py new file mode 100644 index 0000000..39aa7ec --- /dev/null +++ b/src/data/financial.py @@ -0,0 +1,114 @@ +import re +import time + +import pandas as pd +import requests as rq +from bs4 import BeautifulSoup +from tqdm import tqdm + +from db.common import DBManager + + +# 재무제표 크롤링 +# 재무제표 클렌징 함수 +def clean_fs(df, ticker, frequency): + df = df[~df.loc[:, ~df.columns.isin(['계정'])].isna().all(axis=1)] + df = df.drop_duplicates(['계정'], keep='first') + df = pd.melt(df, id_vars='계정', var_name='기준일', value_name='값') + df = df[~pd.isnull(df['값'])] + df['계정'] = df['계정'].replace({'계산에 참여한 계정 펼치기': ''}, regex=True) + df['기준일'] = pd.to_datetime(df['기준일'], + format='%Y/%m') + pd.tseries.offsets.MonthEnd() + df['종목코드'] = ticker + df['공시구분'] = frequency + + return df + + +# ticker 별 재무제표 조회해서 DB에 저장 +def process_for_fs(): + ticker_list = DBManager().get_ticker_list() + # DB 연결 + db_manager = DBManager() + engine = db_manager.create_engine() + con = db_manager.connect() + mycursor = con.cursor() + + # DB 저장 쿼리 + query = """ + insert into kor_fs (계정, 기준일, 값, 종목코드, 공시구분) + values (%s,%s,%s,%s,%s) as new + on duplicate key update + 값=new.값 + """ + + # 오류 발생시 저장할 리스트 생성 + error_list = [] + + # for loop + for i in tqdm(range(0, len(ticker_list))): + + # 티커 선택 + ticker = ticker_list['종목코드'][i] + + # 오류 발생 시 이를 무시하고 다음 루프로 진행 + try: + # url 생성 + url = f'https://comp.fnguide.com/SVO2/ASP/SVD_Finance.asp?pGB=1&gicode=A{ticker}' + + # 데이터 받아오기 + data = pd.read_html(url, displayed_only=False) + + # 연간 데이터 + data_fs_y = pd.concat([ + data[0].iloc[:, ~data[0].columns.str.contains('전년동기')], data[2], + data[4] + ]) + data_fs_y = data_fs_y.rename(columns={data_fs_y.columns[0]: "계정"}) + + # 결산년 찾기 + page_data = rq.get(url) + page_data_html = BeautifulSoup(page_data.content, 'html.parser') + + fiscal_data = page_data_html.select('div.corp_group1 > h2') + fiscal_data_text = fiscal_data[1].text + fiscal_data_text = re.findall('[0-9]+', fiscal_data_text) + + # 결산년에 해당하는 계정만 남기기 + data_fs_y = data_fs_y.loc[:, (data_fs_y.columns == '계정') | ( + data_fs_y.columns.str[-2:].isin(fiscal_data_text))] + + # 클렌징 + data_fs_y_clean = clean_fs(data_fs_y, ticker, 'y') + + # 분기 데이터 + data_fs_q = pd.concat([ + data[1].iloc[:, ~data[1].columns.str.contains('전년동기')], data[3], + data[5] + ]) + data_fs_q = data_fs_q.rename(columns={data_fs_q.columns[0]: "계정"}) + + data_fs_q_clean = clean_fs(data_fs_q, ticker, 'q') + + # 두개 합치기 + data_fs_bind = pd.concat([data_fs_y_clean, data_fs_q_clean]) + + # 재무제표 데이터를 DB에 저장 + args = data_fs_bind.values.tolist() + mycursor.executemany(query, args) + con.commit() + + except: + # 오류 발생시 해당 종목명을 저장하고 다음 루프로 이동 + print(ticker) + error_list.append(ticker) + + # 타임슬립 적용 + time.sleep(2) + + # DB 연결 종료 + engine.dispose() + con.close() + +if __name__ == '__main__': + process_for_fs() \ No newline at end of file diff --git a/src/data/krx.py b/src/data/krx.py new file mode 100644 index 0000000..1a1e9e2 --- /dev/null +++ b/src/data/krx.py @@ -0,0 +1,193 @@ +import re +import time +from io import BytesIO + +import numpy as np +import pandas as pd +import requests as rq +from tqdm import tqdm +from bs4 import BeautifulSoup +from dotenv import load_dotenv +from db.common import DBManager + +load_dotenv() + +GEN_OTP_URL = 'http://data.krx.co.kr/comm/fileDn/GenerateOTP/generate.cmd' +DOWN_URL = 'http://data.krx.co.kr/comm/fileDn/download_csv/download.cmd' + +# 최근 영업일을 가져옴 +def get_latest_biz_day(): + url = 'https://finance.naver.com/sise/sise_deposit.nhn' + data = rq.post(url) + data_html = BeautifulSoup(data.content, 'lxml') + parse_day = data_html.select_one('div.subtop_sise_graph2 > ul.subtop_chart_note > li > span.tah').text + biz_day = re.findall('[0-9]+', parse_day) + biz_day = ''.join(biz_day) + return biz_day + + +# 업종 분류 현황 가져옴 +def get_stock_data(biz_day, mkt_id): + # logging.basicConfig(level=logging.DEBUG) + gen_otp_data = { + 'locale': 'ko_KR', + 'mktId': mkt_id, # STK: 코스피, KSQ: 코스닥 + 'trdDd': biz_day, + 'money': '1', + 'csvxls_isNo': 'false', + 'name': 'fileDown', + 'url': 'dbms/MDC/STAT/standard/MDCSTAT03901' + } + headers = { + 'Referer': 'http://data.krx.co.kr/contents/MDC/MDI/mdiLoader/index.cmd?menuId=MDC0201050201', + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36' + } + + otp = rq.post(url=GEN_OTP_URL, data=gen_otp_data, headers=headers, verify=False) + # # 요청 디버깅 + # print("===== Request Details =====") + # print(f"Method: {otp.request.method}") + # print(f"URL: {otp.request.url}") + # print(f"Headers: {otp.request.headers}") + # print(f"Body: {otp.request.body}") + # + # # 응답 디버깅 + # print("===== Response Details =====") + # print(f"Status Code: {otp.status_code}") + # print(f"Headers: {otp.headers}") + # print(f"Body: {otp.text}") + + down_sector = rq.post(url=DOWN_URL, data={'code': otp.text}, headers=headers) + return pd.read_csv(BytesIO(down_sector.content), encoding='EUC-KR') + + +# 개별 지표 조회 +def get_ind_stock_data(biz_day): + gen_otp_data = { + 'locale': 'ko_KR', + 'searchType': '1', + 'mktId': 'ALL', + 'trdDd': biz_day, + 'csvxls_isNo': 'false', + 'name': 'fileDown', + 'url': 'dbms/MDC/STAT/standard/MDCSTAT03501' + } + headers = { + 'Referer': 'http://data.krx.co.kr/contents/MDC/MDI/mdiLoader/index.cmd?menuId=MDC0201050201', + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36' + } + + otp = rq.post(url=GEN_OTP_URL, data=gen_otp_data, headers=headers, verify=False) + + down_ind_sector = rq.post(url=DOWN_URL, data={'code': otp.text}, headers=headers) + return pd.read_csv(BytesIO(down_ind_sector.content), encoding='EUC-KR') + + +def process_for_total_stock(biz_day): + # 업종 분류 현황(코스피, 코스닥) + sector_stk = get_stock_data(biz_day, 'STK') + sector_ksq = get_stock_data(biz_day, 'KSQ') + # 각각 조회 후 합침 + krx_sector = pd.concat([sector_stk, sector_ksq]).reset_index(drop=True) + krx_sector['종목명'] = krx_sector['종목명'].str.strip() + krx_sector['기준일'] = biz_day + + # 개별 지표 조회 + krx_ind = get_ind_stock_data(biz_day) + krx_ind['종목명'] = krx_ind['종목명'].str.strip() + krx_ind['기준일'] = biz_day + + # 데이터 정리 + # 종목, 개별 중 한군데만 있는 데이터 삭제(선박펀드, 광물펀드, 해외종목 등) + diff = list(set(krx_sector['종목명']).symmetric_difference(set(krx_ind['종목명']))) + + kor_ticker = pd.merge(krx_sector, + krx_ind, + on=krx_sector.columns.intersection( + krx_ind.columns).tolist(), + how='outer') + # 일반적인 종목과 SPAC, 우선주, 리츠, 기타 주식을 구분 + kor_ticker['종목구분'] = np.where(kor_ticker['종목명'].str.contains('스팩|제[0-9]+호'), '스팩', + np.where(kor_ticker['종목코드'].str[-1:] != '0', '우선주', + np.where(kor_ticker['종목명'].str.endswith('리츠'), '리츠', + np.where(kor_ticker['종목명'].isin(diff), '기타', + '보통주')))) + kor_ticker = kor_ticker.reset_index(drop=True) + kor_ticker.columns = kor_ticker.columns.str.replace(' ', '') + kor_ticker = kor_ticker[['종목코드', '종목명', '시장구분', '종가', + '시가총액', '기준일', 'EPS', '선행EPS', 'BPS', '주당배당금', '종목구분']] + kor_ticker = kor_ticker.replace({np.nan: None}) + kor_ticker['기준일'] = pd.to_datetime(kor_ticker['기준일']) + + save_ticker(kor_ticker) + + +def save_ticker(ticker): + con = DBManager().connect() + + mycursor = con.cursor() + query = f""" + insert into kor_ticker (종목코드,종목명,시장구분,종가,시가총액,기준일,EPS,선행EPS,BPS,주당배당금,종목구분) + values (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) as new + on duplicate key update + 종목명=new.종목명,시장구분=new.시장구분,종가=new.종가,시가총액=new.시가총액,EPS=new.EPS,선행EPS=new.선행EPS, + BPS=new.BPS,주당배당금=new.주당배당금,종목구분 = new.종목구분; + """ + + args = ticker.values.tolist() + + mycursor.executemany(query, args) + con.commit() + + con.close() + + +# WICS 기준 섹터정보 크롤링 +def process_for_wics(biz_day): + sector_code = [ + 'G25', 'G35', 'G50', 'G40', 'G10', 'G20', 'G55', 'G30', 'G15', 'G45' + ] + + data_sector = [] + + # 모든 섹터에 대한 데이터 받아서 가공 + for i in tqdm(sector_code): + url = f'''http://www.wiseindex.com/Index/GetIndexComponets?ceil_yn=0&dt={biz_day}&sec_cd={i}''' + data = rq.get(url).json() + data_pd = pd.json_normalize(data['list']) + + data_sector.append(data_pd) + + time.sleep(2) + + kor_sector = pd.concat(data_sector, axis=0) + kor_sector = kor_sector[['IDX_CD', 'CMP_CD', 'CMP_KOR', 'SEC_NM_KOR']] + kor_sector['기준일'] = biz_day + kor_sector['기준일'] = pd.to_datetime(kor_sector['기준일']) + save_sector(kor_sector) + + +def save_sector(sector): + con = DBManager().connect() + + mycursor = con.cursor() + query = f""" + insert into kor_sector (IDX_CD, CMP_CD, CMP_KOR, SEC_NM_KOR, 기준일) + values (%s,%s,%s,%s,%s) as new + on duplicate key update + IDX_CD = new.IDX_CD, CMP_KOR = new.CMP_KOR, SEC_NM_KOR = new.SEC_NM_KOR + """ + + args = sector.values.tolist() + + mycursor.executemany(query, args) + con.commit() + + con.close() + + +if __name__ == '__main__': + # sector와 ticker 갱신 + latest_biz_day = get_latest_biz_day() + process_for_total_stock(latest_biz_day) + process_for_wics(latest_biz_day) diff --git a/src/data/prices.py b/src/data/prices.py new file mode 100644 index 0000000..9e7f634 --- /dev/null +++ b/src/data/prices.py @@ -0,0 +1,83 @@ +import time +from datetime import date +from io import BytesIO + +import pandas as pd +import requests as rq +from tqdm import tqdm + +from db.common import DBManager + + +# 주가 크롤링 +def process_for_price(): + ticker_list = DBManager().get_ticker_list() + # DB 저장 쿼리 + query = """ + insert into kor_price (날짜, 시가, 고가, 저가, 종가, 거래량, 종목코드) + values (%s,%s,%s,%s,%s,%s,%s) as new + on duplicate key update + 시가 = new.시가, 고가 = new.고가, 저가 = new.저가, + 종가 = new.종가, 거래량 = new.거래량; + """ + + # DB 연결 + common = DBManager() + engine = common.create_engine() + con = common.connect() + + mycursor = con.cursor() + # 오류 발생시 저장할 리스트 생성 + error_list = [] + + # 전종목 주가 다운로드 및 저장 + for i in tqdm(range(0, len(ticker_list))): + + # 티커 선택 + ticker = ticker_list['종목코드'][i] + + # todo: 날짜 범위 수정 + # 시작일과 종료일 + # fr = (date.today() + relativedelta(years=-5)).strftime("%Y%m%d") + to = (date.today()).strftime("%Y%m%d") + fr = '20250125' + + # 오류 발생 시 이를 무시하고 다음 루프로 진행 + try: + + # url 생성 + url = f'''https://fchart.stock.naver.com/siseJson.nhn?symbol={ticker}&requestType=1 + &startTime={fr}&endTime={to}&timeframe=day''' + + # 데이터 다운로드 + data = rq.get(url).content + data_price = pd.read_csv(BytesIO(data)) + + # 데이터 클렌징 + price = data_price.iloc[:, 0:6] + price.columns = ['날짜', '시가', '고가', '저가', '종가', '거래량'] + price = price.dropna() + price['날짜'] = price['날짜'].str.extract("(\d+)") + price['날짜'] = pd.to_datetime(price['날짜']) + price['종목코드'] = ticker + + # 주가 데이터를 DB에 저장 + args = price.values.tolist() + mycursor.executemany(query, args) + con.commit() + + except: + + # 오류 발생시 error_list에 티커 저장하고 넘어가기 + print(ticker) + error_list.append(ticker) + + # 타임슬립 적용 + time.sleep(2) + + # DB 연결 종료 + engine.dispose() + con.close() + +if __name__ == '__main__': + process_for_price() \ No newline at end of file diff --git a/src/db/__init__.py b/src/db/__init__.py new file mode 100644 index 0000000..c2ea5ed --- /dev/null +++ b/src/db/__init__.py @@ -0,0 +1 @@ +__all__ = ['common'] \ No newline at end of file diff --git a/src/db/common.py b/src/db/common.py new file mode 100644 index 0000000..4cf0947 --- /dev/null +++ b/src/db/common.py @@ -0,0 +1,140 @@ +import os +from urllib.parse import quote_plus + +import pandas as pd +import pymysql +from dotenv import load_dotenv +from sqlalchemy import create_engine + + +class DBManager: + def __init__(self): + load_dotenv() + self.user = os.getenv('DB_USER') + self.pw = os.getenv('DB_PW') + self.engine_for_pw = quote_plus(self.pw) + self.host = os.getenv('DB_HOST') + self.port = int(os.getenv('DB_PORT')) + self.db = os.getenv('DB_DB') + + def create_engine(self): + return create_engine(f'mysql+pymysql://{self.user}:{self.engine_for_pw}@{self.host}:{self.port}/{self.db}') + + def connect(self): + return pymysql.connect(user=self.user, + passwd=self.pw, + host=self.host, + port=self.port, + db=self.db, + charset='utf8') + + def get_ticker_list(self): + engine = self.create_engine() + + try: + ticker_list = pd.read_sql(""" + select * from kor_ticker + where 기준일 = (select max(기준일) from kor_ticker) + and 종목구분 = '보통주'; + """, con=engine) + finally: + engine.dispose() + + return ticker_list + + def get_value_list(self): + engine = self.create_engine() + + try: + value_list = pd.read_sql(""" + select * from kor_value + where 기준일 = (select max(기준일) from kor_value); + """, con=engine) + finally: + engine.dispose() + + return value_list + + def get_price_list(self, interval_month): + engine = self.create_engine() + + try: + price_list = pd.read_sql(f""" + select 날짜, 종가, 종목코드 + from kor_price + where 날짜 >= (select (select max(날짜) from kor_price) - interval {interval_month} month); + """, con=engine) + finally: + engine.dispose() + + return price_list + + def get_price_list_by_code(self, codes): + engine = self.create_engine() + + try: + price_list = pd.read_sql(f""" + select * from kor_price + where 종목코드 in ({codes}); + """, con=engine) + finally: + engine.dispose() + + return price_list + + def get_fs_list(self): + engine = self.create_engine() + + try: + fs_list = pd.read_sql(""" + select * from kor_fs + where 계정 in ('당기순이익', '매출총이익', '영업활동으로인한현금흐름', '자산', '자본') + and 공시구분 = 'q'; + """, con=engine) + finally: + engine.dispose() + + return fs_list + + def get_fs_list_by_account_and_date(self, account, date): + engine = self.create_engine() + + try: + fs_list = pd.read_sql(f""" + select * from kor_fs + where 계정 in ({account}) + and 기준일 in ({date}) + and 공시구분 = 'y'; + """, con=engine) + finally: + engine.dispose() + + return fs_list + + def get_expanded_fs_list(self): + engine = self.create_engine() + + try: + fs_list = pd.read_sql(""" + select * from kor_fs + where 계정 in ('매출액', '당기순이익', '법인세비용', '이자비용', '현금및현금성자산', + '부채', '유동부채', '유동자산', '비유동자산', '감가상각비') + and 공시구분 = 'q'; + """, con=engine) + finally: + engine.dispose() + + return fs_list + + def get_sector_list(self): + engine = self.create_engine() + + try: + sector_list = pd.read_sql(""" + select * from kor_sector + where 기준일 = (select max(기준일) from kor_sector); + """, con=engine) + finally: + engine.dispose() + + return sector_list \ No newline at end of file diff --git a/src/strategies/__init__.py b/src/strategies/__init__.py new file mode 100644 index 0000000..9c945c0 --- /dev/null +++ b/src/strategies/__init__.py @@ -0,0 +1 @@ +__all__ = ['composite', 'factors', 'utils'] \ No newline at end of file diff --git a/src/strategies/composite/__init__.py b/src/strategies/composite/__init__.py new file mode 100644 index 0000000..763d7fb --- /dev/null +++ b/src/strategies/composite/__init__.py @@ -0,0 +1 @@ +__all__ = ['multi_factor', 'multi_factor', 'super_quality', 'super_value_momentum'] \ No newline at end of file diff --git a/src/strategies/composite/magic_formula.py b/src/strategies/composite/magic_formula.py new file mode 100644 index 0000000..b7d57e9 --- /dev/null +++ b/src/strategies/composite/magic_formula.py @@ -0,0 +1,77 @@ +import numpy as np +from db.common import DBManager + + +# 마법 공식 포트폴리오. 밸류와 퀄리티의 조합. 조엘 그린블라트의 '마법공식' +def get_magic_formula_top(count): + db = DBManager() + ticker_list = db.get_ticker_list() + fs_list = db.get_expanded_fs_list() + + fs_list = fs_list.sort_values(['종목코드', '계정', '기준일']) + # TTM 값을 구하기 위해서 rolling() 메소드를 통해 4분기 합 구함. 4분기 데이터가 없는 경우 제외하기 위해서 min_periods=4 + fs_list['ttm'] = fs_list.groupby(['종목코드', '계정'], as_index=False)['값'].rolling( + window=4, min_periods=4).sum()['값'] + fs_list_clean = fs_list.copy() + # 재무상태표 현황(부채, 유동부채, 유동자산, 비유동자산)은 평균값 사용 + fs_list_clean['ttm'] = np.where( + fs_list_clean['계정'].isin(['부채', '유동부채', '유동자산', '비유동자산']), + fs_list_clean['ttm'] / 4, fs_list_clean['ttm']) + + fs_list_clean = fs_list_clean.groupby(['종목코드', '계정']).tail(1) + fs_list_pivot = fs_list_clean.pivot(index='종목코드', columns='계정', values='ttm') + + data_bind = ticker_list[['종목코드', '종목명', '시가총액']].merge(fs_list_pivot, + how='left', + on='종목코드') + # 티커 테이블에 있는 시가총액은 원, 제무제표 테이블은 억 단위이므로 단위를 맞춤 + data_bind['시가총액'] = data_bind['시가총액'] / 100000000 + + # 이익수익률 계산식: 이자 및 법인세 차감전 이익(EBIT) / 가입가치(시가총액 + 순차입금) + # 분자(EBIT) + magic_ebit = data_bind['당기순이익'] + data_bind['법인세비용'] + data_bind['이자비용'] + + # 분모 + magic_cap = data_bind['시가총액'] + magic_debt = data_bind['부채'] + + ## 분모: 여유자금 + magic_excess_cash = data_bind['유동부채'] - data_bind['유동자산'] + data_bind[ + '현금및현금성자산'] + magic_excess_cash[magic_excess_cash < 0] = 0 + magic_excess_cash_final = data_bind['현금및현금성자산'] - magic_excess_cash + + magic_ev = magic_cap + magic_debt - magic_excess_cash_final + + # 이익수익률 + magic_ey = magic_ebit / magic_ev + + # 투하자본 수익률 + magic_ic = (data_bind['유동자산'] - data_bind['유동부채']) + (data_bind['비유동자산'] - + data_bind['감가상각비']) + magic_roc = magic_ebit / magic_ic + + # 열 입력하기 + data_bind['이익 수익률'] = magic_ey + data_bind['투하자본 수익률'] = magic_roc + + magic_rank = (magic_ey.rank(ascending=False, axis=0) + + magic_roc.rank(ascending=False, axis=0)).rank(axis=0) + return data_bind.loc[magic_rank <= 20, ['종목코드', '종목명', '이익 수익률', '투하자본 수익률']].round(4) + + # data_bind['투자구분'] = np.where(magic_rank <= 20, '마법공식', '기타') + # + # plt.rc('font', family='Malgun Gothic') + # plt.subplots(1, 1, figsize=(10, 6)) + # sns.scatterplot(data=data_bind, + # x='이익 수익률', + # y='투하자본 수익률', + # hue='투자구분', + # style='투자구분', + # s=200) + # plt.xlim(0, 1) + # plt.ylim(0, 1) + # plt.show() + +if __name__ == '__main__': + print(get_magic_formula_top(20)) \ No newline at end of file diff --git a/src/strategies/composite/multi_factor.py b/src/strategies/composite/multi_factor.py new file mode 100644 index 0000000..a0d9139 --- /dev/null +++ b/src/strategies/composite/multi_factor.py @@ -0,0 +1,251 @@ +import pandas as pd +import numpy as np +import statsmodels.api as sm +from scipy.stats import zscore +import matplotlib.pyplot as plt +import seaborn as sns + +# 멀티 팩터 포트폴리오. +# 퀄리티: 자기자본이익률(ROE), 매출총이익(GPA), 영업활동현금흐름(CFO) +# 밸류: PER, PBR, PSR, PCR, DY +# 모멘텀: 12개월 수익률, K-Ratio +# 각 섹터별 아웃라이어를 제거한 후 순위와 z-score를 구하는 함수 +def col_clean(df, cutoff=0.01, asc=False): + + q_low = df.quantile(cutoff) + q_hi = df.quantile(1 - cutoff) + + # 이상치 데이터 제거 + df_trim = df[(df > q_low) & (df < q_hi)] + + df_z_score = df_trim.rank(axis=0, ascending=asc).apply( + zscore, nan_policy='omit') + + return df_z_score + + +def plot_rank(df): + ax = sns.relplot(data=df, + x='rank', + y=1, + col='variable', + hue='invest', + size='size', + sizes=(10, 100), + style='invest', + markers={'Y': 'X','N': 'o'}, + palette={'Y': 'red','N': 'grey'}, + kind='scatter') + ax.set(xlabel=None) + ax.set(ylabel=None) + + plt.show() + + +def get_multi_factor_top(qc, count): + ticker_list = qc.get_ticker_list() + fs_list = qc.get_fs_list() + value_list = qc.get_value_list() + price_list = qc.get_price_list(12) + sector_list = qc.get_sector_list() + + # 퀄리티 지표 계산 + fs_list = fs_list.sort_values(['종목코드', '계정', '기준일']) + fs_list['ttm'] = fs_list.groupby(['종목코드', '계정'], as_index=False)['값'].rolling( + window=4, min_periods=4).sum()['값'] + fs_list_clean = fs_list.copy() + fs_list_clean['ttm'] = np.where(fs_list_clean['계정'].isin(['자산', '자본']), + fs_list_clean['ttm'] / 4, fs_list_clean['ttm']) + fs_list_clean = fs_list_clean.groupby(['종목코드', '계정']).tail(1) + + fs_list_pivot = fs_list_clean.pivot(index='종목코드', columns='계정', values='ttm') + fs_list_pivot['ROE'] = fs_list_pivot['당기순이익'] / fs_list_pivot['자본'] + fs_list_pivot['GPA'] = fs_list_pivot['매출총이익'] / fs_list_pivot['자산'] + fs_list_pivot['CFO'] = fs_list_pivot['영업활동으로인한현금흐름'] / fs_list_pivot['자산'] + + fs_list_pivot.round(4).head() + + value_list.loc[value_list['값'] <= 0, '값'] = np.nan + value_pivot = value_list.pivot(index='종목코드', columns='지표', values='값') + + value_pivot.head() + + # 가치 지표 계산 + # 음수를 제거하고 행으로 긴 형태로 변경 + price_pivot = price_list.pivot(index='날짜', columns='종목코드', values='종가') + ret_list = pd.DataFrame(data=(price_pivot.iloc[-1] / price_pivot.iloc[0]) - 1, + columns=['12M']) + + ret = price_pivot.pct_change().iloc[1:] + ret_cum = np.log(1 + ret).cumsum() + + x = np.array(range(len(ret))) + k_ratio = {} + + for i in range(0, len(ticker_list)): + ticker = ticker_list.loc[i, '종목코드'] + + try: + y = ret_cum.loc[:, price_pivot.columns == ticker] + reg = sm.OLS(y, x).fit() + res = float(reg.params / reg.bse) + except: + res = np.nan + + k_ratio[ticker] = res + + k_ratio_bind = pd.DataFrame.from_dict(k_ratio, orient='index').reset_index() + k_ratio_bind.columns = ['종목코드', 'K_ratio'] + + k_ratio_bind.head() + + # 가격 테이블을 이용해서 최근 12개월 수익률을 구하고 + # 로그 누적 수익률을 통해 각 종목별 K-Ratio를 계산 + data_bind = ticker_list[['종목코드', '종목명']].merge( + sector_list[['CMP_CD', 'SEC_NM_KOR']], + how='left', + left_on='종목코드', + right_on='CMP_CD').merge( + fs_list_pivot[['ROE', 'GPA', 'CFO']], how='left', + on='종목코드').merge(value_pivot, how='left', + on='종목코드').merge(ret_list, how='left', + on='종목코드').merge(k_ratio_bind, + how='left', + on='종목코드') + + data_bind.loc[data_bind['SEC_NM_KOR'].isnull(), 'SEC_NM_KOR'] = '기타' + data_bind = data_bind.drop(['CMP_CD'], axis=1) + + data_bind.round(4).head() + + # 종목코드와 섹터정보(SEC_NM_KOR)를 인덱스로 설정한 후, 섹터에 따른 그룹을 묶어준다. + data_bind_group = data_bind.set_index(['종목코드', + 'SEC_NM_KOR']).groupby('SEC_NM_KOR', as_index=False) + + data_bind_group.head(1).round(4) + + # 퀄리티 지표의 z-score를 계산 + # 퀄리티 지표에 해당하는 열(ROE, GPA, CFO) 선택해서 col_clean() 적용한 후 순위의 z-score 계산 + # sum() 함수를 통해 z-score의 합을 구하며, to_frame() 메소드를 통해 데이터프레임 형태로 변경 + z_quality = data_bind_group[['ROE', 'GPA', 'CFO' + ]].apply(lambda x: col_clean(x, 0.01, False)).sum( + axis=1, skipna=False).to_frame('z_quality') + # data_bind 테이블과 합치며, z_quality 열에는 퀄리티 지표의 z-score가 표시 + data_bind = data_bind.merge(z_quality, how='left', on=['종목코드', 'SEC_NM_KOR']) + + data_bind.round(4).head() + + # 가치 지표의 z-score 계산 + # 가치 지표에 해당하는 열(PBR, PCR, PER, PSR) 선택해서 col_clean() 적용, 오름차순 + value_1 = data_bind_group[['PBR', 'PCR', 'PER', + 'PSR']].apply(lambda x: col_clean(x, 0.01, True)) + # DY(배당수익률)의 경우 내림차순으로 계산 + value_2 = data_bind_group[['DY']].apply(lambda x: col_clean(x, 0.01, False)) + + # 두 결과를 합쳐 z-score의 합을 구한 후, 데이터프레임 형태로 변경 + z_value = value_1.merge(value_2, on=['종목코드', 'SEC_NM_KOR' + ]).sum(axis=1, + skipna=False).to_frame('z_value') + # data_bind 테이블과 합치며, z_value 열에는 밸류 지표의 z-score가 표시 + data_bind = data_bind.merge(z_value, how='left', on=['종목코드', 'SEC_NM_KOR']) + + data_bind.round(4).head() + + # 모멘텀 지표의 z-score 계산 + # 모멘텀 지표에 해당하는 열(12M, K_ratio) 선택 후 col_clean() 적용 + z_momentum = data_bind_group[[ + '12M', 'K_ratio' + ]].apply(lambda x: col_clean(x, 0.01, False)).sum( + axis=1, skipna=False).to_frame('z_momentum') + # data_bind 테이블과 합치며, z_momentum 열에는 모멘텀 지표의 z-score가 표시 + data_bind = data_bind.merge(z_momentum, how='left', on=['종목코드', 'SEC_NM_KOR']) + + data_bind.round(4).head() + + # 팩터 분포를 시각화 + data_z = data_bind[['z_quality', 'z_value', 'z_momentum']].copy() + + fig, axes = plt.subplots(3, 1, figsize=(10, 6), sharex=True, sharey=True) + for n, ax in enumerate(axes.flatten()): + ax.hist(data_z.iloc[:, n]) + ax.set_title(data_z.columns[n], size=12) + fig.tight_layout() + # plt.show() + + # 팩터 분포가 동일하지 않으니 z-score를 다시 계산해서 분포의 넓이를 비슷하게 맞춤 + # 종목 코드와 각 팩터의 z-score만 선택한 후, 종목 코드를 인덱스로 설정 + # apply()를 통해서 z-score 다시 계산 + data_bind_final = data_bind[['종목코드', 'z_quality', 'z_value', 'z_momentum' + ]].set_index('종목코드').apply(zscore, + nan_policy='omit') + # 열 이름 설정 + data_bind_final.columns = ['quality', 'value', 'momentum'] + + plt.rc('font', family='Malgun Gothic') + plt.rc('axes', unicode_minus=False) + fig, axes = plt.subplots(3, 1, figsize=(10, 6), sharex=True, sharey=True) + for n, ax in enumerate(axes.flatten()): + ax.hist(data_bind_final.iloc[:, n]) + ax.set_title(data_bind_final.columns[n], size=12) + fig.tight_layout() + # plt.show() + + # 각 팩터간 상관 관계 확인 + mask = np.triu(data_bind_final.corr()) + fig, ax = plt.subplots(figsize=(10, 6)) + sns.heatmap(data_bind_final.corr(), + annot=True, + mask=mask, + annot_kws={"size": 16}, + vmin=0, + vmax=1, + center=0.5, + cmap='coolwarm', + square=True) + ax.invert_yaxis() + # plt.show() + + # 각 팩터간 상관관계가 매우 낮으며, 여러 팩터를 동시에 고려함으로써 분산효과를 기대할 수 있다. + # 이제 계산된 팩터들을 토대로 최종 포트폴리오를 구성해 보자. + # 각 팩터를 동일 비중으로 설정. 0.2, 0.4, 0.4 등 중요하다고 생각되는 팩터에 비중을 다르게도 지정할 수 있음 + wts = [0.3, 0.3, 0.3] + # 위에서 설정한 비율을 반영해서 데이터프레임 형태로 변경 + data_bind_final_sum = (data_bind_final * wts).sum(axis=1, + skipna=False).to_frame() + data_bind_final_sum.columns = ['qvm'] + # 기본 테이블(data_bind)과 합침 + port_qvm = data_bind.merge(data_bind_final_sum, on='종목코드') + # 최종 z-score의 합(qvm) 기준 순위가 20위 이내인 경우 투자 종목에 해당하니 Y로 표시, 나머진 N + port_qvm['invest'] = np.where(port_qvm['qvm'].rank() <= count, 'Y', 'N') + + # round()는 DataFrame 객체 내의 요소를 반올림하는 메서드 + return port_qvm[port_qvm['invest'] == 'Y'].round(4) + + # 이하 선택된 종목과 선택되지 않은 종목들 간의 특성을 그리기 위한 코드 + # data_melt = port_qvm.melt(id_vars='invest', + # value_vars=[ + # 'ROE', 'GPA', 'CFO', 'PER', 'PBR', 'PCR', 'PSR', + # 'DY', '12M', 'K_ratio' + # ]) + # + # data_melt['size'] = data_melt['invest'].map({'Y': 100, 'N': 10}) + # data_melt.head() + # + # hist_quality = data_melt[data_melt['variable'].isin(['ROE', 'GPA', + # 'CFO'])].copy() + # hist_quality['rank'] = hist_quality.groupby('variable')['value'].rank( + # ascending=False) + # plot_rank(hist_quality) + # + # hist_value = data_melt[data_melt['variable'].isin( + # ['PER', 'PBR', 'PCR', 'PSR', 'DY'])].copy() + # hist_value['value'] = np.where(hist_value['variable'] == 'DY', + # 1 / hist_value['value'], hist_value['value']) + # hist_value['rank'] = hist_value.groupby('variable')['value'].rank() + # plot_rank(hist_value) + # + # hist_momentum = data_melt[data_melt['variable'].isin(['12M', 'K_ratio'])].copy() + # hist_momentum['rank'] = hist_momentum.groupby('variable')['value'].rank(ascending = False) + # plot_rank(hist_momentum) + # + # port_qvm[port_qvm['invest'] == 'Y']['종목코드'].to_excel('model.xlsx', index=False) \ No newline at end of file diff --git a/src/strategies/composite/super_quality.py b/src/strategies/composite/super_quality.py new file mode 100644 index 0000000..77fae72 --- /dev/null +++ b/src/strategies/composite/super_quality.py @@ -0,0 +1,67 @@ +from datetime import datetime +from src import ui as st + +from strategies.factors import f_score +from db.common import DBManager + + +# st.write(""" +# '신F-스코어 3점 + 고GP/A 전략'을 '강환국 슈퍼 퀄리티 전략'이라 명명한다. +# 이 전략은 신F-스코어가 3점인 종목을 매수하되, GP/A로 순위를 매겨서 순위가 높은 종목만 매수하는 것이다. +# 이 경우 한국에서 수익이 어땠을지 분석해보자. +# 연도별로 신F-스코어 3점을 충족하는 종목은 600-700개였다.\n +# 신F-스코어 3점 기업 내에서도 GP/A가 높은 종목이 3점 종목 평균보다 CAGR 기준으로 3-4% 더 높았다. +# 반대로 GP/A가 낮은 종목의 수익률은 상대적으로 저조했다.\n\n +# --- +# 투자 전략: 강환국 슈퍼 퀄리티 전략 1.0\n +# 레벨: 초, 중급\n +# 스타일: 퀄리티\n +# 기대 CAGR: 약 20%\n +# 매수 전략: +# - 신F-스코어 3점 종목만 매수\n +# - 여기에 GP/A 순위를 부여, 순위 높은 20-30종목을 매수\n +# 매도 전략: 연 1회 리밸런싱\n\n\n +# --- +# 지금까지 소개한 거의 모든 전략에서 소형주 전략이 전체 주식 수익률보다 높았다. +# 시가총액 하위 20% 종목의 CAGR을 분석해보았다.\n\n +# --- +# 투자 전략: 강환국 슈퍼 퀄리티 전략 2.0\n +# 레벨: 초, 중급\n +# 스타일: 퀄리티\n +# 기대 CAGR: 20% 이상\n +# 매수 전략: +# 아래 조건을 만족하는 20-30종목 매수\n +# - 신F-스코어 3점 종목만 매수\n +# - 여기에 GP/A 순위를 부여, 순위 높은 종목만 매수\n +# - 단, 소형주(시가총액 최저 20%)만 매수\n +# 매도 전략: 연 1회 리밸런싱\n +# --- +# 소형주 중 신F-스코어가 3점인 종목을 찾아보니 2004-2016년 구간에 80-100개 종목이 남았다. +# 그 주식들을 통째로 매수해도 CAGR 34.55%를 벌수 있었다! +# 정말 상당한 수익이다. +# 이 종목들을 다 샀으면 총 1,159개 종목 중 14개가 파산했다.(1.2%) +# 또 1년간 마이너스 수익을 기록한 종목이 29.7%였다.\n +# 신F-스코어가 3점인 종목 중 GP/A가 높은 종목 위주로 매수했으면 (1) CAGR도 조금 개선되고 (2) 최상 30개 종목을 매수했을 경우 선택받은 종목 360개 중 파산한 기업은 단 1개였다. +# F-스코어와 GP/A는 엄청난 잠재력을 지닌 콤비네이션임이 분명하다. +# """) + +def get_last_year_end(): + # 현재 날짜 가져오기 (2025년 3월 16일 기준) + today = datetime.now() + + # 작년 연도 계산 + last_year = today.year - 1 + + # 작년 12월 31일 생성 + last_year_end = datetime(last_year, 12, 31) + + return last_year_end.date() + +st.write("투자 전략: 강환국 슈퍼 퀄리티 전략 2.0") + +date = get_last_year_end() +data = f_score.get_f_score(DBManager(), date) + +config = {} + +st.dataframe(data, column_config=config, use_container_width=True) diff --git a/src/strategies/composite/super_value_momentum.py b/src/strategies/composite/super_value_momentum.py new file mode 100644 index 0000000..e433935 --- /dev/null +++ b/src/strategies/composite/super_value_momentum.py @@ -0,0 +1,3 @@ +from src import ui as st + +st.write("슈퍼 밸류 모멘텀 전략 2.0") \ No newline at end of file diff --git a/src/strategies/factors/__init__.py b/src/strategies/factors/__init__.py new file mode 100644 index 0000000..efc80f3 --- /dev/null +++ b/src/strategies/factors/__init__.py @@ -0,0 +1 @@ +__all__ = ['all_value', 'f_score', 'momentum', 'quality', 'value'] \ No newline at end of file diff --git a/src/strategies/factors/all_value.py b/src/strategies/factors/all_value.py new file mode 100644 index 0000000..aed74f8 --- /dev/null +++ b/src/strategies/factors/all_value.py @@ -0,0 +1,37 @@ +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns +from db.common import DBManager + + +#가치주 포트폴리오. PER, PBR, PCR, PSR, DY +def get_all_value_top(count): + db = DBManager() + ticker_list = db.get_ticker_list() + value_list = db.get_value_list() + + # 가치 지표가 0이하인 경우 nan으로 변경 + value_list.loc[value_list['값'] <= 0, '값'] = np.nan + # 가치지표 테이블을 가로로 긴 형태로 변경 + value_pivot = value_list.pivot(index='종목코드', columns='지표', values='값') + # 티커 테이블과 가치 지표 테이블을 합침 + data_bind = ticker_list[['종목코드', '종목명']].merge(value_pivot, + how='left', + on='종목코드') + value_list_copy = data_bind.copy() + # DY(배당수익률)만 높을수록 좋은 지표라서 역수 + value_list_copy['DY'] = 1 / value_list_copy['DY'] + value_list_copy = value_list_copy[['PER', 'PBR', 'PCR', 'PSR', 'DY']] + value_rank_all = value_list_copy.rank(axis=0) + mask = np.triu(value_rank_all.corr()) + + fig, ax = plt.subplots(figsize=(10, 6)) + sns.heatmap(value_rank_all.corr(),annot=True,mask=mask, annot_kws={"size": 16}, vmin=0, vmax=1, center=0.5,cmap='coolwarm',square=True) + ax.invert_yaxis() + # plt.show() + value_sum_all = value_rank_all.sum(axis=1, skipna=False).rank() + + return data_bind.loc[value_sum_all <= count] + +if __name__ == '__main__': + print(get_all_value_top(20)) \ No newline at end of file diff --git a/src/strategies/factors/f_score.py b/src/strategies/factors/f_score.py new file mode 100644 index 0000000..31cd8dc --- /dev/null +++ b/src/strategies/factors/f_score.py @@ -0,0 +1,104 @@ +from datetime import datetime +import pandas as pd +from db.common import DBManager + + +# 흑자 기업이면 1점(당기순이익) +def calc_net_income(qc, base_date): + net_income_list = qc.get_fs_list_by_account_and_date("'당기순이익'", f"'{base_date}'") + net_income_list['score1'] = (net_income_list['값'] > 0).astype(int) + + return net_income_list[['종목코드', 'score1']] + + +# CFO(영업활동현금흐름) 흑자 기업이면 1점 +def calc_cfo(qc, base_date): + cfo_list = qc.get_fs_list_by_account_and_date("'*영업에서창출된현금흐름'", f"'{base_date}'") + cfo_list['score2'] = (cfo_list['값'] > 0).astype(int) + + return cfo_list[['종목코드', 'score2']] + + +# 신규 주식 발행(유상증사): 전년 없음인 경우 1점 +# 제작년과 작년 자본금 변화가 없는 경우로 체크 +def calc_capital(qc, base_date): + last_year = datetime(base_date.year - 1, base_date.month, base_date.day).date() + capital_date = f"'{last_year}', '{base_date}'" + + # 자본금 + capital_list = qc.get_fs_list_by_account_and_date("'자본금'", capital_date) + + # 기준일별로 피벗 테이블 생성 + pivot_df = capital_list.pivot_table( + values='값', + index='종목코드', + columns='기준일', + aggfunc='first' + ) + pivot_df = pivot_df.dropna() + + # 값 차이 계산 및 score 부여 + pivot_df['diff'] = pivot_df[base_date] - pivot_df[last_year] + pivot_df['score3'] = (pivot_df['diff'] == 0).astype(int) + + # 결과 정리 + return pivot_df.reset_index()[['종목코드', 'score3']] + + +def calc_gpa(qc, base_date): + fs_list = qc.get_fs_list_by_account_and_date("'매출총이익', '자산'", f"'{base_date}'") + fs_list_pivot = fs_list.pivot(index='종목코드', columns='계정', values='값') + fs_list_pivot['GPA'] = fs_list_pivot['매출총이익'] / fs_list_pivot['자산'] + + # 결과 정리 + return fs_list_pivot.reset_index()[['종목코드', 'GPA']] + +def get_ticker_list(qc): + ticker_list = qc.get_ticker_list() + # 시가총액을 기준으로 정렬 + ticker_list['분류'] = pd.qcut(ticker_list['시가총액'], + q=[0, 0.2, 0.8, 1.0], # 0-20%, 20-80%, 80-100% 구간 + labels=['소형주', '중형주', '대형주']) + + return ticker_list[['종목코드', '종목명', '분류', '종가']] + +def get_f_score(qc, base_date): + ticker_list = get_ticker_list(qc) + score1_list = calc_net_income(qc, base_date) + score2_list = calc_cfo(qc, base_date) + score3_list = calc_capital(qc, base_date) + gpa_list = calc_gpa(qc, base_date) + + # score 1 병합 + NaN인 경우 기본값 0 + merge_score1 = ticker_list.merge(score1_list, on='종목코드', how='left') + merge_score1['score1'] = merge_score1['score1'].fillna(0).astype(int) + + # score 2 병합 + NaN인 경우 기본값 0 + merge_score2 = merge_score1.merge(score2_list, on='종목코드', how='left') + merge_score2['score2'] = merge_score2['score2'].fillna(0).astype(int) + + # score 3 병합 + NaN인 경우 기본값 0 + merge_score3 = merge_score2.merge(score3_list, on='종목코드', how='left') + merge_score3['score3'] = merge_score3['score3'].fillna(0).astype(int) + + # 개별 점수들로 신f-score 계산 + merge_score3['f-score'] = merge_score3['score1'] + merge_score3['score2'] + merge_score3['score3'] + + # GPA 병합 + NaN인 경우 기본 값 -1(내림차순 정렬 시에 하위 순위를 받게 하려고) + final_df = merge_score3.merge(gpa_list, on='종목코드', how='left') + final_df['GPA'] = final_df['GPA'].fillna(-1).astype(float) + + f_score3 = final_df[final_df['f-score'] == 3].round(4) + result = f_score3[f_score3['분류'] == '소형주'].sort_values('GPA', ascending=False) + + # print(f_score3) + # fs_list_copy = f_score3[['GPA']].copy() + # # print(fs_list_copy) + # fs_rank = fs_list_copy.rank(ascending=False, axis=0) + # # print(fs_rank) + # return f_score3.loc[fs_rank['GPA'] <= 20, ['종목코드', '종목명', '분류', 'f-score', 'GPA']].round(4) + return result + +if __name__ == '__main__': + date = datetime(2024, 12, 31).date() + print(get_f_score(DBManager(), date).head(30)) \ No newline at end of file diff --git a/src/strategies/factors/momentum.py b/src/strategies/factors/momentum.py new file mode 100644 index 0000000..bedcdda --- /dev/null +++ b/src/strategies/factors/momentum.py @@ -0,0 +1,88 @@ +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +import statsmodels.api as sm +import numpy as np +from db.common import DBManager + + +def print_graph(values): + plt.rc('font', family='Malgun Gothic') + g = sns.relplot(data=values, + x='날짜', + y='종가', + col='종목코드', + col_wrap=5, + kind='line', + facet_kws={ + 'sharey': False, + 'sharex': True + }) + g.set(xticklabels=[]) + g.set(xlabel=None) + g.set(ylabel=None) + g.fig.set_figwidth(15) + g.fig.set_figheight(8) + plt.subplots_adjust(wspace=0.5, hspace=0.2) + plt.show() + +# strategy/momentum에 구현 +# 모멘텀 포트폴리오. 최근 12개월 수익률이 높은 주식 +def get_momentum_top(count): + db = DBManager() + ticker_list = db.get_ticker_list() + price_list = db.get_price_list(interval_month=12) + + price_pivot = price_list.pivot(index='날짜', columns='종목코드', values='종가') + + # 가격 테이블에서 (가장 끝 행 / 가장 첫 행)으로 각 종목의 12개월 수익률을 구함 + ret_list = pd.DataFrame(data=(price_pivot.iloc[-1] / price_pivot.iloc[0]) - 1, + columns=['return']) + data_bind = ticker_list[['종목코드', '종목명']].merge(ret_list, how='left', on='종목코드') + + # 12개월 수익률 열 순위를 구함. 지표가 높을 수록 좋으니 ascending=False + momentum_rank = data_bind['return'].rank(axis=0, ascending=False) + # 모멘텀만 가지고 순위 측정 + price_momentum = price_list[price_list['종목코드'].isin( + data_bind.loc[momentum_rank <= count, '종목코드'])] + # 해당 종목들(모멘텀 상위 count 개)의 가격 그래프 확인 + # print_graph(price_momentum) + + # k-ratio(모멘텀의 꾸준함 지표) + # pct_change() 함수로 각 종목의 수익률 계산하고 수익률이 곗나되지 않는 첫 번째 행은 제외 + ret = price_pivot.pct_change().iloc[1:] + # 로그 누적 수익률 계산 + ret_cum = np.log(1 + ret).cumsum() + + # x축은 기간 + x = np.array(range(len(ret))) + k_ratio = {} + + for i in range(0, len(ticker_list)): + + ticker = data_bind.loc[i, '종목코드'] + + try: + y = ret_cum.loc[:, price_pivot.columns == ticker] + reg = sm.OLS(y, x).fit() + res = float(reg.params / reg.bse) + except: + res = np.nan + + k_ratio[ticker] = res + + k_ratio_bind = pd.DataFrame.from_dict(k_ratio, orient='index').reset_index() + k_ratio_bind.columns = ['종목코드', 'K_ratio'] + + k_ratio_bind.head() + + data_bind = data_bind.merge(k_ratio_bind, how='left', on='종목코드') + k_ratio_rank = data_bind['K_ratio'].rank(axis=0, ascending=False) + momentum_top = data_bind[k_ratio_rank <= count] + + k_ratio_momentum = price_list[price_list['종목코드'].isin(data_bind.loc[k_ratio_rank <= count, '종목코드'])] + print_graph(k_ratio_momentum) + return momentum_top + +if __name__ == '__main__': + print(get_momentum_top(20)) \ No newline at end of file diff --git a/src/strategies/factors/quality.py b/src/strategies/factors/quality.py new file mode 100644 index 0000000..2b74004 --- /dev/null +++ b/src/strategies/factors/quality.py @@ -0,0 +1,58 @@ +import numpy as np +import matplotlib.pyplot as plt +import seaborn as sns +from db.common import DBManager + + +# 퀄리티(우량주) 포트폴리오. 영업수익성이 높은 주식 +def get_quality_top(count): + qc = DBManager() + ticker_list = qc.get_ticker_list() + fs_list = qc.get_fs_list() + + fs_list = fs_list.sort_values(['종목코드', '계정', '기준일']) + # TTM 값을 구하기 위해서 rolling() 메소드를 통해 4분기 합 구함. 4분기 데이터가 없는 경우 제외하기 위해서 min_periods=4 + fs_list['ttm'] = fs_list.groupby(['종목코드', '계정'], as_index=False)['값'].rolling( + window=4, min_periods=4).sum()['값'] + fs_list_clean = fs_list.copy() + # 자산과 자본은 재무상태표 항목이므로 합이 아닌 평균을 구하며, 나머지 항목은 합을 그대로 사용 + fs_list_clean['ttm'] = np.where(fs_list_clean['계정'].isin(['자산', '자본']), + fs_list_clean['ttm'] / 4, fs_list_clean['ttm']) + # tail(1)을 통해 종목코드와 계정별 최근 데이터만 선택 + fs_list_clean = fs_list_clean.groupby(['종목코드', '계정']).tail(1) + + fs_list_pivot = fs_list_clean.pivot(index='종목코드', columns='계정', values='ttm') + # 수익성 지표에 해당하는 ROE, GPA, CFO 계산 + fs_list_pivot['ROE'] = fs_list_pivot['당기순이익'] / fs_list_pivot['자본'] + fs_list_pivot['GPA'] = fs_list_pivot['매출총이익'] / fs_list_pivot['자산'] + fs_list_pivot['CFO'] = fs_list_pivot['영업활동으로인한현금흐름'] / fs_list_pivot['자산'] + + # 티커 테이블과 합침 + quality_list = ticker_list[['종목코드', '종목명']].merge(fs_list_pivot, + how='left', + on='종목코드') + # quality_list.round(count).head() + + quality_list_copy = quality_list[['ROE', 'GPA', 'CFO']].copy() + quality_rank = quality_list_copy.rank(ascending=False, axis=0) + + mask = np.triu(quality_rank.corr()) + fig, ax = plt.subplots(figsize=(10, 6)) + sns.heatmap(quality_rank.corr(), + annot=True, + mask=mask, + annot_kws={"size": 16}, + vmin=0, + vmax=1, + center=0.5, + cmap='coolwarm', + square=True) + ax.invert_yaxis() + + # 위에서 구한 3개 지표들의 순위를 더한 후 다시 순위를 매김 + quality_sum = quality_rank.sum(axis=1, skipna=False).rank() + # 최종 순위가 낮은 종목 선택 + return quality_list.loc[quality_sum <= count, ['종목코드', '종목명', 'ROE', 'GPA', 'CFO']].round(4) + +if __name__ == '__main__': + print(get_quality_top(20)) \ No newline at end of file diff --git a/src/strategies/factors/value.py b/src/strategies/factors/value.py new file mode 100644 index 0000000..7b6efdd --- /dev/null +++ b/src/strategies/factors/value.py @@ -0,0 +1,27 @@ +import numpy as np + +from db.common import DBManager + + +#가치주 포트폴리오. PER, PBR이 낮은 회사 20개 +def get_value_top(count): + db = DBManager() + ticker_list = db.get_ticker_list() + value_list = db.get_value_list() + + # 가치 지표가 0이하인 경우 nan으로 변경 + value_list.loc[value_list['값'] <= 0, '값'] = np.nan + # 가치지표 테이블을 가로로 긴 형태로 변경 + value_pivot = value_list.pivot(index='종목코드', columns='지표', values='값') + # 티커 테이블과 가치 지표 테이블을 합침 + data_bind = ticker_list[['종목코드', '종목명']].merge(value_pivot, + how='left', + on='종목코드') + # rank() 함수로 PER, PBR 열의 순위를 구함. axis=0을 입력하여 순위는 열 방향으로 구함.(PER, PBR 각각 순위) + value_rank = data_bind[['PER', 'PBR']].rank(axis = 0) + # axis=1을 통해서 위에서 구한 순위 랭크를 합침. 합친 것을 다시 rank() + value_sum = value_rank.sum(axis = 1, skipna = False).rank() + return data_bind.loc[value_sum <= count, ['종목코드', '종목명', 'PER', 'PBR']] + +if __name__ == '__main__': + print(get_value_top(20)) \ No newline at end of file diff --git a/src/strategies/utils.py b/src/strategies/utils.py new file mode 100644 index 0000000..ef1daa8 --- /dev/null +++ b/src/strategies/utils.py @@ -0,0 +1,80 @@ +""" +Common utilities for quantitative investment strategies. +""" +import pandas as pd +from db.common import DBManager + + +def get_sector_data(): + """Get sector data for all stocks.""" + db = DBManager() + return db.get_sector_list() + + +def get_stock_data(): + """Get stock data for all available stocks.""" + db = DBManager() + return db.get_ticker_list() + + +def get_financial_data(): + """Get financial statement data.""" + db = DBManager() + return db.get_fs_list() + + +def get_expanded_financial_data(): + """Get expanded financial statement data.""" + db = DBManager() + return db.get_expanded_fs_list() + + +def get_price_data(interval_months=60): + """Get price data for the specified interval.""" + db = DBManager() + return db.get_price_list(interval_months) + + +def get_value_metrics(): + """Get value metrics for all stocks.""" + db = DBManager() + return db.get_value_list() + + +def calculate_zscore(series): + """Calculate z-score for a pandas series.""" + return (series - series.mean()) / series.std() + + +def rank_by_metric(df, metric, ascending=True): + """Rank stocks by a metric.""" + return df.sort_values(by=metric, ascending=ascending) + + +def rank_combined(df, metrics, weights=None, ascending=True): + """Rank stocks by combined metrics. + + Args: + df: DataFrame with stock data + metrics: List of column names to use for ranking + weights: Optional weights for each metric + ascending: Direction for ranking (True = smaller is better) + + Returns: + DataFrame with combined rank + """ + if weights is None: + weights = [1] * len(metrics) + + # Calculate rank for each metric + ranks = pd.DataFrame(index=df.index) + for i, metric in enumerate(metrics): + ranks[f'rank_{metric}'] = df[metric].rank(ascending=ascending) * weights[i] + + # Calculate combined rank + ranks['combined_rank'] = ranks.mean(axis=1) + + # Combine with original data + result = pd.concat([df, ranks['combined_rank']], axis=1) + + return result.sort_values('combined_rank') \ No newline at end of file diff --git a/src/ui/__init__.py b/src/ui/__init__.py new file mode 100644 index 0000000..72cdbda --- /dev/null +++ b/src/ui/__init__.py @@ -0,0 +1 @@ +__all__ = ['components', 'pages'] \ No newline at end of file diff --git a/src/ui/pages/__init__.py b/src/ui/pages/__init__.py new file mode 100644 index 0000000..ee9cde0 --- /dev/null +++ b/src/ui/pages/__init__.py @@ -0,0 +1 @@ +__all__ = ['data_page', 'quality_page', 'value_momentum_page'] \ No newline at end of file diff --git a/src/ui/pages/data_page.py b/src/ui/pages/data_page.py new file mode 100644 index 0000000..f8fd868 --- /dev/null +++ b/src/ui/pages/data_page.py @@ -0,0 +1,60 @@ +""" +Data collection page for the Streamlit Quant application. +""" +import streamlit as st +from data import financial, krx, prices + + +def render_data_page(): + """Render the data collection page interface.""" + st.title("데이터 수집") + + col1, col2 = st.columns(2) + + with col1: + if st.button(label='주식 데이터 수집', help="KOSPI, KOSDAQ 주식 데이터 수집"): + with st.spinner('주식 데이터 수집중...'): + try: + # Call the krx data collection function + biz_day = krx.get_latest_biz_day() + krx.process_for_total_stock(biz_day) + krx.process_for_wics(biz_day) + # Show success message + st.success('종목 데이터 수집 완료') + except Exception as e: + st.error(f"데이터 수집 실패: {e}") + + if st.button(label='가격 데이터 수집', help="주가 데이터 수집"): + with st.spinner('가격 데이터 수집중...'): + try: + # Call the price data collection function + prices.process_for_price() + # Show success message + st.success(f'가격 데이터 수집 완료') + except Exception as e: + st.error(f"데이터 수집 실패: {e}") + + with col2: + if st.button(label='재무제표 데이터 수집', help="재무제표 데이터 수집"): + with st.spinner('재무제표 데이터 수집중...'): + try: + # Call the financial data collection function + financial.process_for_fs() + # Show success message + st.success(f'재무제표 데이터 수집 완료') + except Exception as e: + st.error(f"데이터 수집 실패: {e}") + + if st.button(label='데이터 업데이트', help="모든 데이터 업데이트"): + with st.spinner('데이터 업데이트중...'): + try: + # Call all data collection functions + # biz_day = krx.get_latest_biz_day() + # stock_data = krx.get_stock_data(biz_day) + # sector_data = krx.get_sector_data(biz_day) + # price_data = prices.crawl_price() + # financial_data = financial.crawl_fs() + # Show success message + st.success('모든 데이터 업데이트 완료') + except Exception as e: + st.error(f"데이터 업데이트 실패: {e}") \ No newline at end of file diff --git a/src/ui/pages/quality_page.py b/src/ui/pages/quality_page.py new file mode 100644 index 0000000..d06c645 --- /dev/null +++ b/src/ui/pages/quality_page.py @@ -0,0 +1,118 @@ +""" +Super Quality strategy page for the Streamlit Quant application. +""" +import streamlit as st +from datetime import datetime +from strategies.factors.f_score import get_f_score +from db.common import DBManager + +def render_quality_page(): + """Render the Super Quality strategy page.""" + st.title("슈퍼 퀄리티 전략") + + with st.expander("전략 설명", expanded=False): + st.write(""" + '신F-스코어 3점 + 고GP/A 전략'을 '강환국 슈퍼 퀄리티 전략'이라 명명한다. + 이 전략은 신F-스코어가 3점인 종목을 매수하되, GP/A로 순위를 매겨서 순위가 높은 종목만 매수하는 것이다. + 이 경우 한국에서 수익이 어땠을지 분석해보자. + 연도별로 신F-스코어 3점을 충족하는 종목은 600-700개였다. + + 신F-스코어 3점 기업 내에서도 GP/A가 높은 종목이 3점 종목 평균보다 CAGR 기준으로 3-4% 더 높았다. + 반대로 GP/A가 낮은 종목의 수익률은 상대적으로 저조했다. + + --- + 투자 전략: 강환국 슈퍼 퀄리티 전략 1.0 + 레벨: 초, 중급 + 스타일: 퀄리티 + 기대 CAGR: 약 20% + 매수 전략: + - 신F-스코어 3점 종목만 매수 + - 여기에 GP/A 순위를 부여, 순위 높은 20-30종목을 매수 + 매도 전략: 연 1회 리밸런싱 + + --- + 지금까지 소개한 거의 모든 전략에서 소형주 전략이 전체 주식 수익률보다 높았다. + 시가총액 하위 20% 종목의 CAGR을 분석해보았다. + + --- + 투자 전략: 강환국 슈퍼 퀄리티 전략 2.0 + 레벨: 초, 중급 + 스타일: 퀄리티 + 기대 CAGR: 20% 이상 + 매수 전략: + 아래 조건을 만족하는 20-30종목 매수 + - 신F-스코어 3점 종목만 매수 + - 여기에 GP/A 순위를 부여, 순위 높은 종목만 매수 + - 단, 소형주(시가총액 최저 20%)만 매수 + 매도 전략: 연 1회 리밸런싱 + --- + 소형주 중 신F-스코어가 3점인 종목을 찾아보니 2004-2016년 구간에 80-100개 종목이 남았다. + 그 주식들을 통째로 매수해도 CAGR 34.55%를 벌수 있었다! + 정말 상당한 수익이다. + 이 종목들을 다 샀으면 총 1,159개 종목 중 14개가 파산했다.(1.2%) + 또 1년간 마이너스 수익을 기록한 종목이 29.7%였다. + + 신F-스코어가 3점인 종목 중 GP/A가 높은 종목 위주로 매수했으면 (1) CAGR도 조금 개선되고 (2) 최상 30개 종목을 매수했을 경우 선택받은 종목 360개 중 파산한 기업은 단 1개였다. + F-스코어와 GP/A는 엄청난 잠재력을 지닌 콤비네이션임이 분명하다. + """) + + # Strategy implementation + st.write("## 슈퍼 퀄리티 전략 2.0 포트폴리오") + + # Get data + date = get_last_year_end() + db = DBManager() + data = get_f_score(db, date) + + # Display options + col1, col2 = st.columns([1, 2]) + + with col1: + st.write("### 설정") + min_f_score = st.slider("최소 F-스코어", min_value=0, max_value=3, value=3) + include_small_caps = st.checkbox("소형주만 포함", value=True) + num_stocks = st.slider("포트폴리오 종목수", min_value=5, max_value=50, value=20) + + # Filter data + filtered_data = data[data['f-score'] >= min_f_score].copy() + + if include_small_caps: + # Sort by market cap and keep only the bottom 20% + filtered_data = filtered_data.sort_values('시가총액') + filtered_data = filtered_data.head(int(len(filtered_data) * 0.2)) + + # Sort by GP/A in descending order + filtered_data = filtered_data.sort_values('GP/A', ascending=False) + + # Get top N stocks + portfolio = filtered_data.head(num_stocks) + + # Display portfolio + with col2: + st.write(f"### 선택된 {len(portfolio)} 종목") + st.dataframe(portfolio, use_container_width=True) + + # Display metrics + st.write("### 포트폴리오 지표") + col1, col2, col3, col4 = st.columns(4) + + with col1: + st.metric(label="평균 F-스코어", value=f"{portfolio['f-score'].mean():.2f}") + + with col2: + st.metric(label="평균 GP/A", value=f"{portfolio['GP/A'].mean():.2f}%") + + with col3: + avg_market_cap = portfolio['시가총액'].mean() / 1_000_000_000 + st.metric(label="평균 시가총액", value=f"{avg_market_cap:.1f}십억원") + + with col4: + st.metric(label="종목 수", value=len(portfolio)) + + +def get_last_year_end(): + """Get the last year's end date.""" + today = datetime.now() + last_year = today.year - 1 + last_year_end = datetime(last_year, 12, 31) + return last_year_end.date() \ No newline at end of file diff --git a/src/ui/pages/value_momentum_page.py b/src/ui/pages/value_momentum_page.py new file mode 100644 index 0000000..8d26de6 --- /dev/null +++ b/src/ui/pages/value_momentum_page.py @@ -0,0 +1,146 @@ +""" +Super Value Momentum strategy page for the Streamlit Quant application. +""" +import streamlit as st +import pandas as pd +from db.common import DBManager +from strategies.factors.value import get_value_top +from strategies.factors.momentum import get_momentum_top + + +def render_value_momentum_page(): + """Render the Super Value Momentum strategy page.""" + st.title("슈퍼 밸류 모멘텀 전략") + + with st.expander("전략 설명", expanded=False): + st.write(""" + 슈퍼 밸류 모멘텀 전략은 밸류와 모멘텀 요소를 결합한 전략입니다. + + - 밸류 요소: PER, PBR과 같은 가치 지표가 낮은 종목 선택 + - 모멘텀 요소: 최근 가격 상승세가 강한 종목 선택 + + 두 요소를 결합함으로써 저평가된 종목 중에서도 상승 모멘텀이 있는 종목만 선택하여 + 가치 함정(value trap)을 피하고 더 나은 성과를 기대할 수 있습니다. + + **밸류 요소 지표** + - PER (주가수익비율): 주가 / 주당순이익 + - PBR (주가순자산비율): 주가 / 주당순자산 + + **모멘텀 요소 지표** + - 6개월 수익률 + - 12개월 수익률 + """) + + # Strategy implementation + st.write("## 슈퍼 밸류 모멘텀 포트폴리오") + + # Settings + col1, col2 = st.columns([1, 2]) + + with col1: + st.write("### 설정") + value_weight = st.slider("밸류 가중치 (%)", min_value=0, max_value=100, value=50) + momentum_weight = 100 - value_weight + st.write(f"모멘텀 가중치: {momentum_weight}%") + + num_stocks = st.slider("포트폴리오 종목수", min_value=5, max_value=50, value=20) + + min_market_cap = st.number_input("최소 시가총액 (억원)", min_value=0, value=500) + + exclude_industries = st.multiselect( + "제외할 산업", + options=["금융업", "보험", "은행", "증권", "지주사"], + default=["금융업", "보험", "은행", "증권"] + ) + + # Get data + db = DBManager() + + try: + with st.spinner("데이터 로딩 중..."): + # Get value portfolio + value_portfolio = get_value_top(20) + + # Get momentum portfolio + momentum_portfolio = get_momentum_top(20) + + # Get stock info for filtering + stocks = db.get_ticker_list() + sectors = db.get_sector_list() + except Exception as e: + st.error(f"데이터 로딩 실패: {e}") + return + + # Merge data + stocks = pd.merge(stocks, sectors, on='종목코드', how='left') + + # Filter by market cap + stocks = stocks[stocks['시가총액'] >= min_market_cap * 100000000] + + # Filter by industry + if exclude_industries: + excluded_mask = stocks['산업'].isin(exclude_industries) + stocks = stocks[~excluded_mask] + + # Combine value and momentum scores + combined_df = pd.DataFrame(index=stocks['종목코드']) + + # Add value rank (normalized to 0-100, lower is better) + if not value_portfolio.empty: + value_ranks = value_portfolio.set_index('종목코드')['rank'] + max_rank = value_ranks.max() + combined_df['value_score'] = value_ranks.reindex(combined_df.index).fillna(max_rank) + combined_df['value_score'] = 100 - (combined_df['value_score'] / max_rank * 100) + + # Add momentum rank (normalized to 0-100, higher is better) + if not momentum_portfolio.empty: + momentum_ranks = momentum_portfolio.set_index('종목코드')['rank'] + max_rank = momentum_ranks.max() + combined_df['momentum_score'] = momentum_ranks.reindex(combined_df.index).fillna(max_rank) + combined_df['momentum_score'] = 100 - (combined_df['momentum_score'] / max_rank * 100) + + # Calculate combined score + combined_df['combined_score'] = ( + combined_df['value_score'] * (value_weight / 100) + + combined_df['momentum_score'] * (momentum_weight / 100) + ) + + # Sort by combined score + combined_df = combined_df.sort_values('combined_score', ascending=False) + + # Get top N stocks + top_stocks = combined_df.head(num_stocks) + + # Merge with stock info + portfolio = pd.merge( + top_stocks.reset_index(), + stocks, + on='종목코드', + how='left' + ) + + # Display portfolio + with col2: + st.write(f"### 선택된 {len(portfolio)} 종목") + display_cols = ['종목코드', '종목명', '현재가', '시가총액', 'PER', 'PBR', + 'value_score', 'momentum_score', 'combined_score'] + st.dataframe(portfolio[display_cols], use_container_width=True) + + # Display metrics + st.write("### 포트폴리오 지표") + col1, col2, col3, col4 = st.columns(4) + + with col1: + avg_per = portfolio['PER'].replace([float('inf'), -float('inf')], float('nan')).mean() + st.metric(label="평균 PER", value=f"{avg_per:.2f}") + + with col2: + avg_pbr = portfolio['PBR'].replace([float('inf'), -float('inf')], float('nan')).mean() + st.metric(label="평균 PBR", value=f"{avg_pbr:.2f}") + + with col3: + avg_market_cap = portfolio['시가총액'].mean() / 1_000_000_000 + st.metric(label="평균 시가총액", value=f"{avg_market_cap:.1f}십억원") + + with col4: + st.metric(label="종목 수", value=len(portfolio)) \ No newline at end of file diff --git a/streamlit_quant/app.py b/streamlit_quant/app.py index 24380ea..2b3ef78 100644 --- a/streamlit_quant/app.py +++ b/streamlit_quant/app.py @@ -1,4 +1,4 @@ -import streamlit as st +from src import streamlit as st crawling_page = st.Page("crawling.py", title="크롤링") super_quality_page = st.Page("super_quality.py", title="슈퍼 퀄리티 전략") diff --git a/streamlit_quant/crawling.py b/streamlit_quant/crawling.py index a2869ba..614233a 100644 --- a/streamlit_quant/crawling.py +++ b/streamlit_quant/crawling.py @@ -1,4 +1,4 @@ -import streamlit as st +from src import streamlit as st st.button(label='동작1') st.button(label='동작2') diff --git a/streamlit_quant/super_quality.py b/streamlit_quant/super_quality.py index 76b967b..84ada85 100644 --- a/streamlit_quant/super_quality.py +++ b/streamlit_quant/super_quality.py @@ -1,5 +1,5 @@ from datetime import datetime -import streamlit as st +from src import streamlit as st from strategy import f_score import quantcommon diff --git a/streamlit_quant/super_value_momentum.py b/streamlit_quant/super_value_momentum.py index 79d5a69..e75c644 100644 --- a/streamlit_quant/super_value_momentum.py +++ b/streamlit_quant/super_value_momentum.py @@ -1,3 +1,3 @@ -import streamlit as st +from src import streamlit as st st.write("슈퍼 밸류 모멘텀 전략 2.0") \ No newline at end of file