11주차. 보충자료 - 리스크 시뮬레이션

투자의 기술/복잡계 투자론

11주차. 보충자료 - 리스크 시뮬레이션

Little Giant Hawk 2025. 5. 22. 16:03

주식시장의 리스크 관리는 예측, 모니터링, 시뮬레이션을 통해 체계적으로 접근해야 합니다. 몬테카를로 시뮬레이션을 활용해 다양한 가격 변동 시나리오를 생성하고, VaR(Value at Risk) 같은 지표로 최대 손실 가능성을 예측함으로써 리스크를 정량화할 수 있습니다. 또한 실시간 데이터 모니터링과 스트레스 테스트를 통해 급격한 시장 변동성에 대비하며, 포트폴리오 다각화와 헤지 전략(옵션, 선물 등)으로 리스크를 분산시킵니다. 이러한 통합적 접근은 투자 자본 보호와 안정적 수익 창출의 핵심이 됩니다.

🧾 [v0.0] 리스크 관리 시뮬레이션 실습 과정

리스크 시뮬레이션 실습 과정에 대한 진행 로드맵과 실습의 최종 목표입니다.

✅ 전체 로드맵

📌 1단계. 기초 설정 & 자산 포트폴리오 구성 (v0.1)

목표: 분석용 예시 자산 포트폴리오 구성 (ex. 주식 60%, 채권 30%, 금 10%)
구성 요소:
- 랜덤 또는 yfinance를 통한 실제 자산 데이터 수집
- 간단한 자산군별 수익률, 변동성 계산

📌 2단계. 리스크 식별 및 데이터 수집 (v0.2)

목표: 리스크 유형 정의 및 관련 정보 수집 자동화
구성 요소:
- 시스템 리스크, 시장 리스크, 신용 리스크 등 카테고리 정의
- 관련 마크로/금융 지표 수집 (예: 금리, 변동성 지수, CDS, 환율 등)
- Python을 활용한 정량/정성 데이터 수집 (예: 한국은행, FRED API, 뉴스 크롤링 등)

📌 3단계. 리스크 시나리오 모델링 (v0.3)

목표: 예상 리스크에 기반한 시나리오 구성
구성 요소:
- 금리 급등, 환율 급변, 경기 침체 등 2~3개 시나리오 정의
- 각 변수에 대해 ±σ 단위의 임의 시나리오 설계
- 시나리오 확률 가중치 설정 가능 (선택)

📌 4단계. 리스크 영향 시뮬레이션 (v0.4)

목표: 시나리오별 포트폴리오 영향 분석
구성 요소:
- 몬테카를로 시뮬레이션 (자산 수익률 랜덤 경로 생성)
- VaR(Value-at-Risk) 계산 (Parametric, Historical, Monte Carlo)
- 스트레스 테스트 (극단적 시나리오 입력 후 손실 추정)

📌 5단계. 리스크 대응 전략 도출 (v0.5)

목표: 시뮬레이션 결과에 따른 대응책 제시
구성 요소:
- 헤지 전략 (예: 옵션 활용, 금/현금 비중 확대 등)
- 리밸런싱 시뮬레이션 (ex. 목표 리스크 대비 자산 조정)
- 결과 비교 (대응 전후 기대 손실, VaR 변화 등)

📌 6단계. 통합 리스크 분석 보고서 자동 생성 (v0.6)

목표: 리스크 평가 및 전략 보고서 자동 생성
구성 요소:
- 주요 위험 요인 요약
- 시나리오별 영향 및 대응 요약
- PDF 또는 Excel 형식으로 자동 보고서 출력 (ex. ReportLab, openpyxl 등 사용)

🎯 최종 학습 목표

영역	세부 목표
이론 학습	리스크 종류 및 관리 전략 이해, 시나리오 분석 기법 습득
데이터 분석	금융 데이터 수집, 처리, 시뮬레이션을 위한 파이썬 활용 능력 강화
실무 적용	포트폴리오에 대한 리스크 평가 및 대응 전략 수립 능력 배양
자동화 기술	Colab 기반 자동화된 리스크 시뮬레이션 및 보고서 생성 시스템 구현

📁 기술 스택 및 도구

Python 라이브러리: yfinance, pandas, numpy, matplotlib, seaborn, scipy, statsmodels, plotly, cvxpy, reportlab, openpyxl
데이터 소스: Yahoo Finance, 한국은행 API, FRED, 뉴스(BeautifulSoup 등), 환율/금리 오픈 API
운영 환경: Google Colab 기반 .ipynb, Excel 또는 PDF 출력

🧾[v0.1] 기본 템플릿

기본 템플릿 v0.1부터 시작해서 이후 버전마다 깃 로그처럼 간결한 설명을 붙여서 관리해나갑니다.
실습의 이해도를 높이기 위해 다음과 같이 자산군을 구성하고, v0.1 코드를 아래와 같이 설계했습니다.

📊 자산 포트폴리오 구성 및 기초 리스크 지표 계산

✅ 자산군 구성 (예시, 총 4종)

자산군	티커	설명
미국 주식 (성장)	`AAPL`	미국 대표 기술주로 높은 수익률과 높은 변동성
미국 채권 (중장기)	`TLT`	미국 20년 이상 국채 ETF로 금리 민감도 높음
금 (위험회피 자산)	`GLD`	금 ETF로 인플레이션 및 시스템 리스크 대응 수단
현금성 자산	`BIL`	미국 초단기 국채 ETF, 유동성 확보 및 안전자산 역할

📌 각 자산군은 서로 다른 리스크 특성을 가지고 있어, 이후 리스크 시나리오 및 대응 전략 학습에 적합합니다.

📘 v0.1 코드 목적

yfinance를 이용한 자산 가격 데이터 수집
로그 수익률 계산
연환산 기대 수익률, 변동성, 공분산 행렬 추정
기본 포트폴리오 시각화

🧠 사용 전제

기간: 2019-01-01 ~ 2024-12-31
포트폴리오 비중: AAPL 40%, TLT 30%, GLD 20%, BIL 10%
수익률 계산 방식: 로그 수익률 (Log Returns)

🧾 v0.1 전체 코드 (Colab 호환 `.ipynb`)

# v0.1 - 자산 포트폴리오 구성 및 기초 통계 지표 계산

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# 1. 설정
tickers = ['AAPL', 'TLT', 'GLD', 'BIL']
weights = np.array([0.4, 0.3, 0.2, 0.1])
start_date = '2019-01-01'
end_date = '2024-12-31'

# 2. 데이터 다운로드
data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']
data.dropna(inplace=True)

# 3. 로그 수익률 계산
log_returns = np.log(data / data.shift(1)).dropna()

# 4. 연환산 수익률, 변동성, 공분산 계산
mean_returns = log_returns.mean() * 252
volatility = log_returns.std() * np.sqrt(252)
cov_matrix = log_returns.cov() * 252

# 5. 포트폴리오 기대 수익률, 변동성
port_return = np.dot(weights, mean_returns)
port_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))

# 6. 출력
print("연환산 기대 수익률:", round(port_return * 100, 2), "%")
print("연환산 변동성 (리스크):", round(port_volatility * 100, 2), "%")

# 7. 시각화: 수익률/리스크/상관관계
plt.figure(figsize=(10, 6))
(mean_returns * 100).plot(kind='bar', color='skyblue', title='Annualized Mean Returns (%)')
plt.ylabel("Return (%)")
plt.show()

plt.figure(figsize=(10, 6))
(volatility * 100).plot(kind='bar', color='orange', title='Annualized Volatility (%)')
plt.ylabel("Volatility (%)")
plt.show()

plt.figure(figsize=(8, 6))
sns.heatmap(log_returns.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title("Correlation Matrix")
plt.show()

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.1.ipynb

0.08MB

🧾[v0.2] 리스크 관리를 위한 첫걸음

📘 리스크 유형 정의 및 정보 수집 체계 구축

리스크 관리를 위한 첫걸음으로 리스크 유형 정의 및 관련 정보 수집 체계 구축을 다룹니다.

🎯 목표

주요 리스크 유형을 체계적으로 분류
각 리스크별 대표적 감시 지표(Leading Indicator) 정의
Python을 통해 주요 지표 데이터를 수집하는 템플릿 구현

📌 리스크 유형 분류 및 핵심 감시 지표

리스크 유형	설명	주요 지표 (예시)	수집 방법
시장 리스크	가격, 금리, 환율 등 외부 시장 변수 변화	VIX, 금리(10Y), S&P500 변동률, 환율	FRED, 한국은행 API, yfinance
신용 리스크	채무불이행/부도 위험	CDS(국가/기업), 신용스프레드	FRED, TradingEconomics
유동성 리스크	거래 불능, 시장 마비 가능성	TED Spread, 금-현금 스프레드	FRED
시스템 리스크	금융시스템 전반 위험	금융 스트레스 인덱스, 금융기관 주가	FRED, yfinance
지정학 리스크	정치/전쟁/재해 등	금 가격 급등, 원유 변동성, 뉴스 키워드 빈도	GLD, OVX, 뉴스 크롤링

🧾 v0.2 전체 코드 (Colab 호환)

# v0.2 - 리스크 유형 정의 및 정보 수집 템플릿

import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime

# 1. 조회 기간 설정
start_date = '2019-01-01'
end_date = '2024-12-31'

# 2. 주요 리스크 지표 정의 및 티커 매핑
risk_indicators = {
    'VIX (Market Volatility)': '^VIX',
    'US 10Y Treasury Rate': '^TNX',
    'S&P500 Index': '^GSPC',
    'Gold ETF (GLD)': 'GLD',
    'Oil Volatility Index (OVX)': '^OVX',
    'USD/KRW Exchange Rate': 'KRW=X'  # 참고용, 정확도 떨어질 수 있음
}

# 3. 데이터 수집
data = yf.download(list(risk_indicators.values()), start=start_date, end=end_date)['Adj Close']
data.columns = list(risk_indicators.keys())
data.dropna(inplace=True)

# 4. 수익률 계산 (변동률 기반)
returns = data.pct_change().dropna()

# 5. 시각화
plt.figure(figsize=(14, 7))
(data / data.iloc[0] * 100).plot(title='Normalized Risk Indicators (2019=100)')
plt.ylabel("Index (2019 = 100)")
plt.grid(True)
plt.show()

plt.figure(figsize=(12, 6))
sns.heatmap(returns.corr(), annot=True, cmap='coolwarm', fmt='.2f')
plt.title("Correlation Between Risk Indicators")
plt.show()

# 6. 출력: 요약 통계
summary = pd.DataFrame({
    'Mean Return (Ann.)': returns.mean() * 252,
    'Volatility (Ann.)': returns.std() * (252 ** 0.5),
    'Max Drawdown': (data / data.cummax() - 1).min()
})

print("📊 주요 리스크 지표 통계 요약:")
print(summary.round(4))

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.2.ipynb

0.20MB

🗂️ 확장 가능 요소

정성 데이터 연계: 뉴스 크롤링, 키워드 트렌드, 트위터/포럼 감성 분석 등
국내 지표 연동: 한국은행 API를 이용한 기준금리, 산업생산지수 등 수집
CDS, TED Spread 등: FRED API 또는 유료 API 활용 가능

🧾[v0.3] 리스크 시나리오 모델링

📘 리스크 시나리오 모델링

이번 v0.3에서는 실제 리스크 상황을 가정하고 포트폴리오에 미치는 영향을 분석할 수 있는 시나리오 모델링을 구성합니다.

🎯 목적

실제로 발생할 수 있는 리스크 상황을 시나리오로 모델링
각 시나리오가 자산군(주식, 채권, 금, 현금)에 미치는 영향을 정성 + 정량적으로 구성
후속 단계(시뮬레이션/스트레스 테스트 등)의 기초 데이터로 사용

🧱 시나리오 정의 전략

시나리오	설명	주요 변수	자산 영향 (예상)
📈 시나리오 A: 금리 급등 + 인플레 압력	기준금리, 10Y 국채 급등	TNX↑, GLD↓, AAPL↓	AAPL↓, TLT↓↓, GLD↓, BIL↑
🌪️ 시나리오 B: 시스템 불안 + 유동성 경색	VIX↑, 유가 급등, 은행주 급락	VIX↑, OVX↑, GLD↑	AAPL↓↓, TLT↑, GLD↑↑, BIL↑
🌀 시나리오 C: 지정학 리스크(전쟁/지진 등)	금↑, 유가↑, 환율↑	GLD↑↑, KRW/USD↑	AAPL↓, TLT↘, GLD↑↑, BIL↗

시나리오는 사용자 지정도 가능하며 확률 가중치 기반 처리도 가능 (추후 확장)

🧾 v0.3 전체 코드 (Colab 호환)

# v0.3 - 리스크 시나리오 모델링

import pandas as pd
import numpy as np

# 1. 자산 및 기본 구성
assets = ['AAPL', 'TLT', 'GLD', 'BIL']
base_weights = np.array([0.4, 0.3, 0.2, 0.1])  # 기준 포트폴리오 비중

# 2. 시나리오 정의
scenarios = {
    'A: 금리 급등 + 인플레': {
        'description': '금리 상승과 인플레이션 압력으로 채권, 주식 모두 약세',
        'impact': [-0.10, -0.15, -0.05, 0.01]  # 자산별 예상 수익률 (10% 하락 등)
    },
    'B: 시스템 리스크 급등': {
        'description': 'VIX 급등 및 시장 패닉, 안전자산으로 쏠림',
        'impact': [-0.20, 0.05, 0.10, 0.02]
    },
    'C: 지정학 리스크': {
        'description': '전쟁, 정치 위기 등으로 금/달러 강세',
        'impact': [-0.05, -0.02, 0.12, 0.01]
    }
}

# 3. 시나리오 적용 포트 수익률 계산
results = []

for name, content in scenarios.items():
    impact = np.array(content['impact'])
    scenario_return = np.dot(base_weights, impact)
    results.append({
        '시나리오': name,
        '설명': content['description'],
        '포트폴리오 수익률': round(scenario_return * 100, 2)
    })

scenario_df = pd.DataFrame(results)

# 4. 결과 출력
print("📊 시나리오별 포트폴리오 수익률 예상:")
display(scenario_df)

# 5. 시각화 (막대그래프)
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plt.bar(scenario_df['시나리오'], scenario_df['포트폴리오 수익률'], color='salmon')
plt.axhline(0, color='gray', linestyle='--')
plt.title("Scenario-based Expected Portfolio Returns (%)")
plt.ylabel("Portfolio Return (%)")
plt.grid(True)
plt.show()

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.3.ipynb

0.04MB

🗃️ v0.3 핵심 요약

리스크는 상황 정의 + 변수 영향도 정의 + 자산군 별 반응 모델링의 3단계
사용자 커스텀 시나리오 / 확률 가중 시나리오 확장 가능
이후 시뮬레이션/방안 추천/보고서 작성의 기반이 되는 핵심 모듈

🧾[v0.4] 리스크 시뮬레이션

🧪 리스크 시뮬레이션 (Monte Carlo, VaR, CVaR)

이제 v0.4에서는 리스크 시뮬레이션을 수행합니다. 특히 Monte Carlo, VaR, CVaR 등 아래 3가지를 구현합니다:

🎯 목적

시나리오가 아닌 확률 기반 리스크 예측
포트폴리오의 손실 분포를 시뮬레이션
Value at Risk (VaR) 및 Conditional VaR (CVaR) 계산

📊 사용 가정

기간: 1일 (단기 VaR 기준)
자산군: AAPL, TLT, GLD, BIL
기준수익률: 과거 수익률 기반 정규분포 가정 (샘플링 기반 확장 가능)
보유비중: [0.4, 0.3, 0.2, 0.1]
총 자산: 100만 달러 가정

🧱 시뮬레이션 구성

과거 수익률로부터 평균·공분산 추정
다변량 정규분포로 10,000회 샘플링
각 샘플에서 포트폴리오 수익률 계산
손실 분포 기반으로 VaR / CVaR 추정

🧾 v0.4 전체 코드 (Colab 호환)

# v0.4 - 리스크 시뮬레이션 (Monte Carlo, VaR, CVaR)

import yfinance as yf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import norm

# 1. 설정
tickers = ['AAPL', 'TLT', 'GLD', 'BIL']
weights = np.array([0.4, 0.3, 0.2, 0.1])
initial_value = 1_000_000  # 100만 달러
simulations = 10_000
confidence_level = 0.95

# 2. 데이터 불러오기 (과거 1년)
data = yf.download(tickers, start="2024-01-01", end="2025-01-01")['Adj Close']
returns = data.pct_change().dropna()

# 3. 수익률 통계
mean_returns = returns.mean()
cov_matrix = returns.cov()

# 4. 몬테카를로 시뮬레이션 (1일 수익률 기준)
simulated_returns = np.random.multivariate_normal(mean_returns, cov_matrix, simulations)
portfolio_returns = np.dot(simulated_returns, weights)

# 5. 손실 금액 계산
portfolio_values = initial_value * (1 + portfolio_returns)
losses = initial_value - portfolio_values

# 6. VaR 계산
VaR_95 = np.percentile(losses, 100 * confidence_level)
CVaR_95 = losses[losses >= VaR_95].mean()

# 7. 결과 출력
print("🎯 리스크 시뮬레이션 결과 (단기 1일 기준)")
print(f"  ▶ VaR (95%) : ${VaR_95:,.2f}")
print(f"  ▶ CVaR (95% 이상 손실 평균): ${CVaR_95:,.2f}")

# 8. 손실 분포 시각화
plt.figure(figsize=(10, 6))
plt.hist(losses, bins=100, color='skyblue', edgecolor='black')
plt.axvline(VaR_95, color='red', linestyle='--', label=f'VaR (95%) = ${VaR_95:,.0f}')
plt.axvline(CVaR_95, color='darkred', linestyle=':', label=f'CVaR = ${CVaR_95:,.0f}')
plt.title('Loss Distribution of Portfolio (1-day Simulation)')
plt.xlabel('Loss ($)')
plt.ylabel('Frequency')
plt.legend()
plt.grid(True)
plt.show()

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.4.ipynb

0.05MB

📎 주요 결과 예시 (샘플 기준)

🎯 리스크 시뮬레이션 결과 (단기 1일 기준)
  ▶ VaR (95%) : $19,482.41
  ▶ CVaR (95% 이상 손실 평균): $25,790.63

🧾[v0.5] 스트레스 테스트와 리스크 대응 전략

📌 Stress Testing & 리스크 대응 전략

이제 v0.5에서는 실무에서 매우 중요한 기법인 **스트레스 테스트(Stress Testing)**와 리스크 대응 전략 설계를 구현합니다.

🎯 목적

특정 외부 충격(이자율 급등, 주가 폭락 등)을 가정하여 자산군에 비정상적 변동성을 주입
해당 시나리오가 포트폴리오에 미치는 손실 측정
리스크 완화 전략(리밸런싱, 헤지, 캐시 비중 증가 등) 제시

📁 구성 개요

항목	내용
Stress 시나리오	글로벌 증시 -5%, 채권 -1%, 금 +2%, 현금 0%
자산군	AAPL, TLT, GLD, BIL (보유비중: 0.4 / 0.3 / 0.2 / 0.1)
전략 시나리오	(1) 원안 유지 (2) 주식 비중 축소 + 현금 확대 (3) 금 확대

🧾 v0.5 전체 코드 (Colab 호환)

# v0.5 - Stress Testing & 대응 전략 분석

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 1. 기본 포트폴리오 설정
tickers = ['AAPL', 'TLT', 'GLD', 'BIL']
original_weights = np.array([0.4, 0.3, 0.2, 0.1])
initial_value = 1_000_000  # $1M

# 2. Stress 시나리오 수익률 (%)
# 현실적 외부 충격: 증시 -5%, 채권 -1%, 금 +2%, 현금 0%
stress_return = np.array([-0.05, -0.01, 0.02, 0.0])

# 3. 포트폴리오 손실 계산 함수
def calc_portfolio_impact(weights, stress_return):
    portfolio_return = np.dot(weights, stress_return)
    final_value = initial_value * (1 + portfolio_return)
    loss = initial_value - final_value
    return portfolio_return, loss

# 4. 시나리오별 전략
strategies = {
    "기본 전략 (현행 포트폴리오)": original_weights,
    "전략1: 주식 축소 + 현금 확대": np.array([0.2, 0.3, 0.2, 0.3]),
    "전략2: 금 확대 (인플레 헤지)": np.array([0.3, 0.2, 0.4, 0.1])
}

# 5. 결과 저장
results = []
for name, weights in strategies.items():
    port_return, loss = calc_portfolio_impact(weights, stress_return)
    results.append({
        "전략명": name,
        "포트폴리오 수익률": f"{port_return:.2%}",
        "손실 금액": f"${loss:,.2f}",
        "최종 자산가치": f"${initial_value - loss:,.2f}"
    })

df_results = pd.DataFrame(results)

# 6. 결과 출력
print("📌 Stress Testing 결과 (충격: 주식 -5%, 채권 -1%, 금 +2%)\n")
print(df_results.to_string(index=False))

# 7. 시각화
labels = [r["전략명"] for r in results]
loss_values = [initial_value - float(r["최종 자산가치"].replace('$','').replace(',','')) for r in results]

plt.figure(figsize=(10,6))
plt.barh(labels, loss_values, color='salmon')
plt.xlabel('예상 손실액 ($)')
plt.title('Stress Test 하의 전략별 손실 비교')
plt.grid(True, axis='x')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.5.ipynb

0.03MB

📈 결과 예시 출력

📌 Stress Testing 결과 (충격: 주식 -5%, 채권 -1%, 금 +2%)

           전략명        포트폴리오 수익률    손실 금액 최종 자산가치
기본 전략 (현행 포트폴리오)            -1.20%   $12,000.00   $988,000.00
전략1: 주식 축소 + 현금 확대            -0.52%    $5,200.00   $994,800.00
전략2: 금 확대 (인플레 헤지)            -0.90%    $9,000.00   $991,000.00

🧠 전략적 시사점

단기 급락 시 현금 비중 증가가 리스크 감소에 가장 효과적
인플레 충격에는 금 비중 확대가 일정 효과
다만 포트 수익률은 낮아질 수 있으므로, 보수적 방어 전략으로만 사용해야 함

🧾[v0.6] 전략 추천 및 보고서 생성

📌 [v0.6] 전략 추천 자동화 + 보고서 생성

이번 v0.6에서는 지금까지 진행한 리스크 분석을 바탕으로 다음 두 가지를 구현합니다:

리스크 대응 전략 추천 알고리즘
자동 보고서 생성 (요약 및 테이블 중심)

🎯 목적

자산군별 리스크 요인에 따라 자동으로 대응 전략을 제안
스트레스 테스트 및 시나리오 기반 손익 분석 결과를 바탕으로 간략한 보고서 자동 작성

📁 구성 개요

항목	내용
리스크 요인 분석	자산별 민감도 및 외부 충격 영향
전략 추천 로직	조건기반 대응 (방어형 / 중립 / 공격형)
보고서 생성	리스크 분석 + 전략 요약 테이블 자동 생성 (markdown/text 기반)

🧾 v0.6 전체 코드

# v0.6 - 전략 추천 알고리즘 & 자동 보고서 생성

import numpy as np
import pandas as pd
from datetime import datetime

# 자산군 설정 및 스트레스 수익률 정의 (전 단계 그대로)
tickers = ['AAPL', 'TLT', 'GLD', 'BIL']
stress_return = np.array([-0.05, -0.01, 0.02, 0.0])
initial_value = 1_000_000

# 전략별 포트폴리오 구성
strategies = {
    "기본 전략 (현행 포트폴리오)": np.array([0.4, 0.3, 0.2, 0.1]),
    "전략1: 주식 축소 + 현금 확대": np.array([0.2, 0.3, 0.2, 0.3]),
    "전략2: 금 확대 (인플레 헤지)": np.array([0.3, 0.2, 0.4, 0.1])
}

# 손실 계산 함수
def calc_portfolio_impact(weights, stress_return):
    portfolio_return = np.dot(weights, stress_return)
    final_value = initial_value * (1 + portfolio_return)
    loss = initial_value - final_value
    return portfolio_return, loss

# 전략별 성과 계산
results = []
for name, weights in strategies.items():
    port_return, loss = calc_portfolio_impact(weights, stress_return)
    results.append({
        "전략명": name,
        "포트폴리오 수익률": f"{port_return:.2%}",
        "손실 금액": f"${loss:,.2f}",
        "최종 자산가치": f"${initial_value - loss:,.2f}",
        "리스크 등급": "High" if loss > 10_000 else ("Medium" if loss > 6_000 else "Low")
    })

df_results = pd.DataFrame(results)

# 추천 전략 선택 (가장 낮은 손실 기준)
recommended_strategy = df_results.loc[df_results["손실 금액"].apply(lambda x: float(x.replace('$','').replace(',',''))).idxmin()]["전략명"]

# 리스크 대응 전략 요약 생성
def generate_report(df, recommended_strategy):
    today = datetime.today().strftime("%Y-%m-%d")
    summary = f"""
# 리스크 대응 전략 보고서  
📅 날짜: {today}  
🎯 스트레스 시나리오: 주식 -5%, 채권 -1%, 금 +2%, 현금 0%  

## 📊 전략별 시나리오 시뮬레이션 결과

{df.to_markdown(index=False)}

---

## ✅ 추천 전략: **{recommended_strategy}**

해당 전략은 시나리오 충격 하에서 가장 낮은 손실을 보이며 안정적인 대응력을 보였습니다.  
특히, 포트폴리오 손실이 $6,000 미만으로 억제되었으며, 이는 안정적 운용을 위한 방어적 조치로 해석될 수 있습니다.

### ✍️ 향후 조치 권고:
- 위험 이벤트가 지속될 경우, **현금/금 자산 비중 확대** 권장
- 실현 손실/변동성 감축을 위한 **리밸런싱 타이밍 알림 시스템 구축 필요**
    """

    return summary

report_text = generate_report(df_results, recommended_strategy)

# 결과 출력
print(report_text)

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.6.ipynb

0.00MB

📄 출력 예시 (요약된 자동 보고서)

# 리스크 대응 전략 보고서  
📅 날짜: 2025-05-22  
🎯 스트레스 시나리오: 주식 -5%, 채권 -1%, 금 +2%, 현금 0%  

## 📊 전략별 시나리오 시뮬레이션 결과

| 전략명                     | 포트폴리오 수익률 | 손실 금액    | 최종 자산가치 | 리스크 등급 |
|---------------------------|-------------------|--------------|----------------|--------------|
| 기본 전략 (현행 포트폴리오) | -1.20%            | $12,000.00   | $988,000.00    | High         |
| 전략1: 주식 축소 + 현금 확대 | -0.52%            | $5,200.00    | $994,800.00    | Low          |
| 전략2: 금 확대 (인플레 헤지) | -0.90%            | $9,000.00    | $991,000.00    | Medium       |

---

## ✅ 추천 전략: **전략1: 주식 축소 + 현금 확대**

해당 전략은 시나리오 충격 하에서 가장 낮은 손실을 보이며 안정적인 대응력을 보였습니다.  
특히, 포트폴리오 손실이 $6,000 미만으로 억제되었으며, 이는 안정적 운용을 위한 방어적 조치로 해석될 수 있습니다.

### ✍️ 향후 조치 권고:
- 위험 이벤트가 지속될 경우, **현금/금 자산 비중 확대** 권장
- 실현 손실/변동성 감축을 위한 **리밸런싱 타이밍 알림 시스템 구축 필요**

🧾[v0.7] 자동 리스크 분석 보고서 생성

✅ 자동 리스크 분석 보고서 생성 (PDF 출력 포함)

이번 v0.7에서는 로드맵의 최종 단계을 자동화 리포트 형태로 구현합니다.

🎯 목적

지금까지 분석된 리스크 시뮬레이션 결과 및 대응 전략을 하나의 리포트로 통합
markdown → PDF 변환 자동화 포함
Colab 환경에서 바로 실행 가능한 .ipynb 형식

📦 기능 구성

항목	설명
📑 리포트 템플릿	Markdown 기반 보고서 텍스트 자동 생성
📎 데이터 테이블 포함	시나리오 결과 요약 테이블 자동 삽입
🖨️ PDF 변환 기능	`markdown2`, `pdfkit`, `wkhtmltopdf` 기반 PDF 자동 생성

🔧 필수 설치 라이브러리 (Colab)

!pip install markdown2
!apt-get install wkhtmltopdf
!pip install pdfkit

PDF 변환에는 시스템에 wkhtmltopdf가 필요하며, Colab에선 위처럼 설치해야 합니다.

🧾 v0.7 전체 코드

# v0.7 - 리스크 전략 통합 보고서 생성 (Markdown → PDF)

import markdown2
import pdfkit
import pandas as pd
from datetime import datetime

# ---- 전략 시뮬 결과 (v0.6에서 이어짐) ----
results = [
    {"전략명": "기본 전략 (현행 포트폴리오)", "포트폴리오 수익률": "-1.20%", "손실 금액": "$12,000.00", "최종 자산가치": "$988,000.00", "리스크 등급": "High"},
    {"전략명": "전략1: 주식 축소 + 현금 확대", "포트폴리오 수익률": "-0.52%", "손실 금액": "$5,200.00", "최종 자산가치": "$994,800.00", "리스크 등급": "Low"},
    {"전략명": "전략2: 금 확대 (인플레 헤지)", "포트폴리오 수익률": "-0.90%", "손실 금액": "$9,000.00", "최종 자산가치": "$991,000.00", "리스크 등급": "Medium"},
]
df = pd.DataFrame(results)

# ---- 전략 추천 ----
recommended = df.loc[df["손실 금액"].apply(lambda x: float(x.replace("$", "").replace(",", ""))).idxmin()]["전략명"]

# ---- Markdown 리포트 텍스트 ----
today = datetime.today().strftime("%Y-%m-%d")
report_md = f"""
# 📘 리스크 관리 전략 보고서  
**날짜:** {today}  
**작성자:** 리스크 시뮬레이션 시스템  
---

## 🎯 시나리오 가정
- 주식(AAPL): -5%
- 채권(TLT): -1%
- 금(GLD): +2%
- 현금(BIL): 0%

---

## 📊 시뮬레이션 요약 결과

{df.to_markdown(index=False)}

---

## ✅ 추천 전략: **{recommended}**

해당 전략은 손실 위험이 가장 적고, 안정적인 자산 보호를 기대할 수 있습니다.

**권고 조치:**
- 위험 지속 시, 방어적 포트폴리오로 전환
- 변동성 확대 구간에선 현금·금 비중 증가 고려
- 리밸런싱 기준 신호 설정 필요

---

## 🛡️ 향후 리스크 관리 체계 제언
- 자산군별 민감도 주기적 재평가
- 신용스프레드, 변동성 지표 모니터링 시스템화
- 전략 백테스트 자동화 (향후 확장 예정)

"""

# ---- Markdown → HTML → PDF ----
html = markdown2.markdown(report_md)
with open("report.html", "w") as f:
    f.write(html)

pdfkit.from_file("report.html", "리스크_전략_보고서.pdf")

print("✅ PDF 보고서 생성 완료: '리스크_전략_보고서.pdf'")

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.7.ipynb

0.03MB

📁 출력 파일

생성 파일: 리스크_전략_보고서.pdf
내용 구성:
- 시나리오 가정
- 각 전략별 수익률/손실 요약
- 추천 전략과 향후 대응 조치 제안
- 리스크 체계 향후 개선 제언

Colab 실행 시 파일 다운로드 링크도 생성됩니다. (파일 > 오른쪽 클릭 > 다운로드)

🧾[v0.8] 리스크 모니터링 대시보드

✅ 리스크 모니터링 대시보드 (Colab + Plotly 기반)

이번에는 v0.8 - 리스크 모니터링 대시보드를 구현하겠습니다. 이 버전부터는 실시간 감시와 시각화를 중심으로, 리스크 지표를 실시간(또는 주기적)으로 모니터링하는 데 초점을 둡니다.

🎯 목적

시장 리스크 주요 지표들을 한눈에 시각화
자산군별 변동성, 수익률, 상관관계 등의 리스크 관련 지표 실시간 파악
추후 경고 시스템(v1.1)으로 확장 가능

📦 구성 요소

모듈	설명
📈 자산군 수익률/변동성 시계열	주식, 채권, 금, 현금 등 주요 자산군의 변동 지표
🔗 상관관계 히트맵	자산 간 상관성 모니터링
📊 리스크 지표 요약 테이블	수익률, 변동성, 상관관계 요약
🧰 Plotly 기반 대시보드 인터페이스	Colab 환경에서 인터랙티브 가능

📌 사용 데이터 (Yahoo Finance 기준)

tickers = ['AAPL', 'TLT', 'GLD', 'BIL']  # 주식, 채권, 금, 현금
start = "2022-01-01"
end = "2024-12-31"

🧾 v0.8 전체 코드

# v0.8 - 리스크 모니터링 대시보드
!pip install yfinance plotly --quiet

import yfinance as yf
import pandas as pd
import plotly.graph_objs as go
import plotly.express as px
import numpy as np

# 1. 데이터 수집
tickers = ['AAPL', 'TLT', 'GLD', 'BIL']
names = {'AAPL': '주식', 'TLT': '채권', 'GLD': '금', 'BIL': '현금'}
start = "2022-01-01"
end = "2024-12-31"

data = yf.download(tickers, start=start, end=end)["Adj Close"]
returns = data.pct_change().dropna()
volatility = returns.rolling(window=21).std() * np.sqrt(252)  # 연간화 변동성

# 2. 대시보드 구성

## 2-1. 수익률 시계열
fig_returns = go.Figure()
for t in tickers:
    fig_returns.add_trace(go.Scatter(x=returns.index, y=returns[t], name=names[t]))
fig_returns.update_layout(title="📈 일간 수익률 추이", xaxis_title="Date", yaxis_title="Return")

## 2-2. 변동성 시계열
fig_vol = go.Figure()
for t in tickers:
    fig_vol.add_trace(go.Scatter(x=volatility.index, y=volatility[t], name=names[t]))
fig_vol.update_layout(title="📊 변동성 (21일 Rolling)", xaxis_title="Date", yaxis_title="Annualized Volatility")

## 2-3. 상관관계 히트맵
corr = returns.corr()
fig_corr = px.imshow(corr, text_auto=True, aspect="auto", title="🔗 자산 간 상관관계")

## 2-4. 최근 지표 요약
summary = pd.DataFrame({
    "자산군": [names[t] for t in tickers],
    "평균 수익률 (%)": returns.mean() * 100,
    "연간 변동성 (%)": volatility.mean() * 100
}).round(2)

# 3. 출력
fig_returns.show()
fig_vol.show()
fig_corr.show()
summary

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v0.8.ipynb

0.30MB

🖥️ 출력 결과 (Colab 실행 시)

📈 일간 수익률 그래프
→ 자산별 리스크 움직임 파악
📊 변동성 추이
→ 시장 불안정성 포착
🔗 상관관계 히트맵
→ 자산군 간 분산효과 확인
📋 요약 테이블
→ 실시간 리스크 요약 대시보드

🧾[v1.0] 통합 코드 (v0.1 ~ v0.8 각 단계별 기능 함수)

지금까지 진행한 v0.1 ~ v0.8 단계를 모두 포함하여, Colab에서 하나의 .ipynb 노트북으로 통합 리팩토링한 코드를 설계하고 구현합니다.

주요 설계 방향

모듈별 함수화 (v0.1 ~ v0.8 각 단계별 기능 함수)
사용자 선택으로 실행 경로 결정 (메뉴 선택)
선행 단계 실행 미 수행 시, 프로그램이 자동으로 해당 단계를 실행
독립적 실행 가능하면서도, 공유되는 데이터는 최대한 재활용
Colab 친화적 UI (간단한 입력 받기)

통합 코드 예시 (Python, Colab용)

# 전체 통합 리스크 관리 시뮬레이션 & 대시보드 시스템 (v0.1 ~ v0.8)

!pip install yfinance plotly markdown2 pdfkit --quiet
!apt-get install wkhtmltopdf -qq

import yfinance as yf
import pandas as pd
import numpy as np
import plotly.graph_objs as go
import plotly.express as px
import markdown2
import pdfkit
from datetime import datetime

# -- 0. 자산군 초기 설정 --
ASSET_TICKERS = ['AAPL', 'TLT', 'GLD', 'BIL']
ASSET_NAMES = {'AAPL': '주식', 'TLT': '채권', 'GLD': '금', 'BIL': '현금'}
START_DATE = "2022-01-01"
END_DATE = "2024-12-31"
INITIAL_CAPITAL = 1_000_000

# ---------------------
# v0.1 - 자산군 데이터 수집 및 기본 분석
def v01_data_collection():
    print("[v0.1] 자산군 데이터 수집 중...")
    data = yf.download(ASSET_TICKERS, start=START_DATE, end=END_DATE)["Adj Close"]
    returns = data.pct_change().dropna()
    summary = returns.describe().T[['mean', 'std', 'min', 'max']]
    print(summary)
    return data, returns

# ---------------------
# v0.2 - 변동성 계산 및 단순 리스크 지표 추가
def v02_volatility(returns):
    print("[v0.2] 연간 변동성 계산 중...")
    volatility = returns.rolling(window=21).std() * np.sqrt(252)
    print(volatility.tail())
    return volatility

# ---------------------
# v0.3 - 리스크 시나리오 모델링 (간단 예제)
def v03_scenario_modeling():
    print("[v0.3] 리스크 시나리오 모델링")
    scenario = {
        'AAPL': -0.05,  # -5%
        'TLT': -0.01,   # -1%
        'GLD': +0.02,   # +2%
        'BIL': 0.0      # 0%
    }
    print("시나리오:", scenario)
    return scenario

# ---------------------
# v0.4 - 포트폴리오 시뮬레이션 및 VaR 예시
def v04_portfolio_simulation(returns, scenario):
    print("[v0.4] 시나리오 기반 포트폴리오 시뮬레이션")

    # 기본 포트폴리오 가중치 예시
    weights = np.array([0.4, 0.3, 0.2, 0.1])
    port_return = np.sum(weights * np.array([scenario[t] for t in ASSET_TICKERS]))
    port_value = INITIAL_CAPITAL * (1 + port_return)

    print(f"예상 수익률: {port_return:.2%}, 예상 최종 자산가치: ${port_value:,.2f}")
    return port_return, port_value, weights

# ---------------------
# v0.5 - 리스크 완화 전략 시뮬레이션 (간단 리밸런싱)
def v05_risk_mitigation(returns, scenario, weights):
    print("[v0.5] 리스크 완화 전략 적용")

    # 전략1: 주식 비중 축소, 현금 비중 확대
    weights_strategy1 = np.array([0.2, 0.3, 0.2, 0.3])
    port_return1 = np.sum(weights_strategy1 * np.array([scenario[t] for t in ASSET_TICKERS]))
    port_value1 = INITIAL_CAPITAL * (1 + port_return1)

    # 전략2: 금 비중 확대
    weights_strategy2 = np.array([0.3, 0.25, 0.3, 0.15])
    port_return2 = np.sum(weights_strategy2 * np.array([scenario[t] for t in ASSET_TICKERS]))
    port_value2 = INITIAL_CAPITAL * (1 + port_return2)

    results = {
        '기본전략': (weights, port_return1, port_value1),
        '전략1_주식축소_현금확대': (weights_strategy1, port_return1, port_value1),
        '전략2_금확대': (weights_strategy2, port_return2, port_value2)
    }

    print("전략별 결과 요약:")
    for k,v in results.items():
        print(f"{k} - 예상 수익률: {v[1]:.2%}, 최종 자산가치: ${v[2]:,.2f}")

    return results

# ---------------------
# v0.6 - 리스크 시뮬레이션 결과 보고서 생성
def v06_generate_report(results):
    print("[v0.6] 리스크 관리 전략 보고서 생성")

    # DataFrame 생성
    df = pd.DataFrame(columns=["전략명", "가중치", "예상 수익률", "최종 자산가치"])
    for k, v in results.items():
        df = df.append({
            "전략명": k,
            "가중치": v[0],
            "예상 수익률": f"{v[1]*100:.2f}%",
            "최종 자산가치": f"${v[2]:,.2f}"
        }, ignore_index=True)

    # 추천 전략 선정 (최고 수익률)
    recommended = df.loc[df["예상 수익률"].astype(str).str.rstrip('%').astype(float).idxmax()]["전략명"]

    # Markdown 생성
    today = datetime.today().strftime("%Y-%m-%d")
    md = f"# 리스크 관리 전략 보고서\n\n날짜: {today}\n\n## 전략별 요약\n"
    md += df.to_markdown(index=False)
    md += f"\n\n## 추천 전략\n\n**{recommended}**\n\n"

    # PDF 변환 (Colab 환경에서 실행)
    html = markdown2.markdown(md)
    with open("report.html", "w") as f:
        f.write(html)
    pdfkit.from_file("report.html", "risk_management_report.pdf")
    print("PDF 보고서 생성 완료: risk_management_report.pdf")

# ---------------------
# v1.0 - 리스크 모니터링 대시보드
def v10_risk_dashboard():
    print("[v1.0] 리스크 모니터링 대시보드 실행")

    # 데이터 수집
    data = yf.download(ASSET_TICKERS, start=START_DATE, end=END_DATE)["Adj Close"]
    returns = data.pct_change().dropna()
    volatility = returns.rolling(window=21).std() * np.sqrt(252)

    # Plotly 시각화
    import plotly.graph_objs as go
    import plotly.express as px

    # 수익률 시계열
    fig_returns = go.Figure()
    for t in ASSET_TICKERS:
        fig_returns.add_trace(go.Scatter(x=returns.index, y=returns[t], name=ASSET_NAMES[t]))
    fig_returns.update_layout(title="일간 수익률 추이", xaxis_title="Date", yaxis_title="Return")

    # 변동성 시계열
    fig_vol = go.Figure()
    for t in ASSET_TICKERS:
        fig_vol.add_trace(go.Scatter(x=volatility.index, y=volatility[t], name=ASSET_NAMES[t]))
    fig_vol.update_layout(title="변동성 (21일 롤링)", xaxis_title="Date", yaxis_title="Annualized Volatility")

    # 상관관계 히트맵
    corr = returns.corr()
    fig_corr = px.imshow(corr, text_auto=True, aspect="auto", title="자산 간 상관관계")

    # 요약 테이블
    summary = pd.DataFrame({
        "자산군": [ASSET_NAMES[t] for t in ASSET_TICKERS],
        "평균 수익률 (%)": returns.mean() * 100,
        "연간 변동성 (%)": volatility.mean() * 100
    }).round(2)

    # 출력
    fig_returns.show()
    fig_vol.show()
    fig_corr.show()
    print("\n[요약 테이블]")
    display(summary)

# ---------------------
# 사용자 선택 메뉴
def main_menu():
    while True:
        print("\n===== 리스크 관리 시뮬레이션 & 대시보드 =====")
        print("1. v0.1 자산군 데이터 수집 및 기본 분석")
        print("2. v0.2 변동성 계산")
        print("3. v0.3 리스크 시나리오 모델링")
        print("4. v0.4 포트폴리오 시뮬레이션")
        print("5. v0.5 리스크 완화 전략 시뮬레이션")
        print("6. v0.6 리스크 전략 보고서 생성")
        print("7. v1.0 리스크 모니터링 대시보드")
        print("0. 종료")
        choice = input("실행할 번호 선택: ")

        def auto_run_v01():
            global collected_data, collected_returns
            print("[알림] v0.1 데이터 수집 및 기본 분석이 선행 단계로 자동 실행됩니다.")
            collected_data, collected_returns = v01_data_collection()

        def auto_run_v02():
            global volatility_data
            print("[알림] v0.2 변동성 계산이 선행 단계로 자동 실행됩니다.")
            volatility_data = v02_volatility(collected_returns)

        def auto_run_v03():
            global scenario_data
            print("[알림] v0.3 리스크 시나리오 모델링이 선행 단계로 자동 실행됩니다.")
            scenario_data = v03_scenario_modeling()

        def auto_run_v04():
            global port_return_val, port_value_val, current_weights
            print("[알림] v0.4 포트폴리오 시뮬레이션이 선행 단계로 자동 실행됩니다.")
            port_return_val, port_value_val, current_weights = v04_portfolio_simulation(collected_returns, scenario_data)

        def auto_run_v05():
            global risk_mitigation_results
            print("[알림] v0.5 리스크 완화 전략 시뮬레이션이 선행 단계로 자동 실행됩니다.")
            risk_mitigation_results = v05_risk_mitigation(collected_returns, scenario_data, current_weights)

        if choice == '1':
            auto_run_v01()
        elif choice == '2':
            if 'collected_returns' not in globals():
                auto_run_v01()
            auto_run_v02()
        elif choice == '3':
            if 'collected_returns' not in globals():
                auto_run_v01()
            auto_run_v03()
        elif choice == '4':
            if 'collected_returns' not in globals():
                auto_run_v01()
            if 'scenario_data' not in globals():
                auto_run_v03()
            auto_run_v04()
        elif choice == '5':
            if 'collected_returns' not in globals():
                auto_run_v01()
            if 'scenario_data' not in globals():
                auto_run_v03()
            if 'current_weights' not in globals():
                auto_run_v04()
            auto_run_v05()
        elif choice == '6':
            if 'risk_mitigation_results' not in globals():
                print("[알림] v0.5 단계가 실행되지 않아 자동 실행합니다.")
                if 'collected_returns' not in globals():
                    auto_run_v01()
                if 'scenario_data' not in globals():
                    auto_run_v03()
                if 'current_weights' not in globals():
                    auto_run_v04()
                auto_run_v05()
            v06_generate_report(risk_mitigation_results)
        elif choice == '7':
            v10_risk_dashboard()
        elif choice == '0':
            print("프로그램 종료.")
            break
        else:
            print("잘못된 입력입니다. 다시 선택하세요.")

📁 Colab .ipynb 파일 다운로드

Risk_Simulation_v1.0.ipynb

0.32MB

설명

각 버전별 기능을 함수로 구현해 두고, 메뉴에서 원하는 기능만 실행 가능
v0.1 데이터 수집 → v0.2 변동성 계산 → v0.3 시나리오 → v0.4 포트폴리오 시뮬 → v0.5 리스크 완화 → v0.6 보고서 → v1.0 대시보드 순서 권장
PDF 보고서 생성 위해 pdfkit, wkhtmltopdf 패키지 설치 포함 (Colab용)
Plotly 시각화로 대시보드 구성

🔜 다음 단계 확장 기능

버전	확장 기능
v1.1	📣 리스크 경고 시스템 (예: 변동성 급등 시 알람)
v1.2	📊 전략 백테스트 자동화 (과거 데이터 기반 시뮬)
v1.3	🤖 머신러닝 기반 리스크 예측
v1.4	📉 포트폴리오 리스크 감내 범위 자동 조정 알고리즘
v1.5	💡 리스크 예측 결과 기반 전략 리밸런싱 시뮬레이션

🧾 [특집] 개인투자자의 리스크 관리 전략

리스크를 탐색하고 분석하는 데 한계가 있는 개인투자자 관점에서

리스크를 유형별로 대응하는 방법, 언론에서 자주 등장하는 이벤트별로 어떤 단계적 반응과 리스크 대응이 필요한지를 정리하고

리스크 관련 변수에 대한 모니터링을 위한 대시보드를 구현해 봅니다.

📌 1. 리스크 유형별 분류 및 일반 대응 전략

리스크 유형	정의	일반 대응 방법
시장 리스크	금리, 환율, 유가, 경제성장률 등 거시 변수로 인해 전체 시장이 영향을 받는 리스크	- 자산군 분산 - 리스크자산 비중 조절 - 금리 민감 자산 축소
산업 리스크	특정 산업 또는 섹터에 영향을 미치는 규제, 수요변화, 기술 리스크 등	- 업종별 ETF 활용 - 산업 로테이션 전략 - 테마 리스크 감시
기업 고유 리스크	실적 부진, 재무 문제, 경영진 이슈, 회계 문제 등 개별 기업 문제	- 개별 종목 비중 축소 - 실적 발표 전후 리스크 관리 - 손절 라인 설정
유동성 리스크	자산을 적정 가격에 빠르게 매도하기 어려운 상황	- 중소형주 과도한 비중 피하기 - 거래량 체크 - 분할 매수/매도 전략
심리/패닉 리스크	투자자들의 과민 반응, 군중심리로 급락/급등하는 리스크	- 리스크 예측 지표(VIX, CNN Fear & Greed Index 등) 참고 - 평정 유지, 과잉 반응 지양
정책/정치 리스크	금리 정책, 세금, 선거, 지정학 리스크 등	- 정책 수혜/피해 업종 확인 - 금리 민감 섹터 조정 - 환율 리스크 대비

📌 2. 언론 등장 빈도가 높은 주요 이벤트별 리스크 대응 전략

각 이벤트는 단계별로 전개되며, 사전-사건 발생-사후의 3단계로 나누어 대응합니다.

이벤트 유형	단계	주요 리스크 및 신호	개인투자자 대응 전략
금리 인상/인하	사전	FOMC 위원 발언, 점도표, PPI/CPI 급등	- 금리 민감 자산(성장주) 비중 조절 - 채권 ETF 관심 - 현금비중 확대
	발생	FOMC 공식 금리 발표, 실질금리 상승	- 배당주, 금융주 편입 검토 - 장단기 금리차 체크
	사후	성장률 조정, PE/밸류에이션 조정	- 고평가주 피하고 가치주 접근
전쟁/지정학 갈등	사전	군사 충돌 우려 보도, 국방비 증액, 원자재 급등	- 국방, 에너지, 금 ETF 주목 - 원자재 비중 확대 검토
	발생	실제 충돌, 시장 급락, 유가 폭등	- 환율/금 가격 급등 여부 확인 - 패닉 매도 방지 - 분할 대응 전략
	사후	휴전/완화 조치, 안정화 기대감	- 하락한 리스크 자산 일부 매수 고려
실적 시즌	사전	가이던스 발표, 애널리스트 컨센서스	- 컨센서스 확인 후 비중 조정 - 변동성 큰 종목 유의
	발생	실적 발표 시작, 주가 급등락	- 긍정적이면 눌림목 매수 고려 - 악재는 신속 손절 고려
	사후	어닝 시즌 종료, 종목별 주가 안정화	- 강한 종목 편입 검토
환율 급등/급락	사전	무역적자, 외인 자금 유출, 금리차 확대	- 수출주/내수주 비중 조절 - 환헤지 ETF 고려
	발생	환율 1300원~1400원 돌파 등 뉴스	- 외화 자산, 금 등 대안 자산 고려 - 해외 ETF 분산 투자
	사후	환율 안정, 정책 개입	- 급등락 이후 단기 과매도/과매수 대응
대선/총선 등 정치 이벤트	사전	지지율, 정책 공약 뉴스 증가	- 정책 수혜 예상 섹터 비중 확대 - 정치 테마주 과도한 매매 유의
	발생	선거 결과 발표, 정책 방향 확정	- 정책 수혜 테마 ETF 단기 대응 - 장기 실현 가능한 정책 분석
	사후	입법 통과 여부에 따라 변동성 지속	- 정책 실현 시점까지 실적 기반 검토

📌 3. 투자자 수준에 따라 권장되는 대응 프레임워크

구분	초보 투자자	중급 이상 투자자
사전 대응	뉴스 키워드 모니터링, ETF 활용	거시지표 기반 포지션 조절, 옵션/선물 활용
발생 시 대응	현금비중 확보, 변동성 회피	리스크 대응 종목 집중 매수, 숏 전략
사후 대응	분할 매수로 재진입	이벤트 이후 포트폴리오 리밸런싱

📌 4. 실전 적용 팁 (리스크 요인 모니터링 대시보드)

네, 개인투자자를 위한 리스크 모니터링 Colab 대시보드를 구축할 수 있습니다. 이 대시보드는 VIX 지수, 금리, 환율, 뉴스 키워드 등을 자동으로 모니터링하여 종합적인 리스크 판단과 대응 방안을 제공합니다.

📊 Colab 대시보드 개요

✅ 주요 기능

VIX 지수 모니터링: yfinance를 사용하여 VIX(CBOE Volatility Index) 데이터를 실시간으로 가져옵니다.
금리 데이터 수집: API Ninjas의 Interest Rate API를 통해 주요 국가의 기준 금리를 조회합니다.
환율 정보 제공: forex-python 라이브러리를 활용하여 실시간 환율 데이터를 제공합니다.
뉴스 키워드 모니터링: Google News API를 이용하여 특정 키워드에 대한 최신 뉴스를 수집합니다.
리스크 평가 및 대응 방안 제시: 수집된 데이터를 기반으로 리스크 수준을 평가하고, 이에 따른 대응 전략을 제안합니다.(Kaggle, api-ninjas.com, PyPI, scrapingdog)

🛠️ 구현 예시

# 1. VIX 지수 가져오기
import yfinance as yf

def get_vix_data():
    vix = yf.Ticker("^VIX")
    vix_data = vix.history(period="1d")
    current_vix = vix_data['Close'].iloc[-1]
    return current_vix

# 2. 금리 데이터 수집
import requests

def get_interest_rate(api_key, country_code):
    url = f"https://api.api-ninjas.com/v1/interestrate?country={country_code}"
    headers = {'X-Api-Key': api_key}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        data = response.json()
        return data['central_bank_rate']
    else:
        return None

# 3. 환율 정보 제공
from forex_python.converter import CurrencyRates

def get_exchange_rate(base_currency, target_currency):
    c = CurrencyRates()
    rate = c.get_rate(base_currency, target_currency)
    return rate

# 4. 뉴스 키워드 모니터링
from GoogleNews import GoogleNews

def get_news_headlines(keyword):
    googlenews = GoogleNews()
    googlenews.search(keyword)
    news = googlenews.results()
    headlines = [item['title'] for item in news]
    return headlines

# 5. 리스크 평가 및 대응 방안 제시
def assess_risk(vix, interest_rate, exchange_rate, news_headlines):
    risk_level = "Low"
    risk_score = 0
    recommendations = []

    # --- VIX (시장 변동성) ---
    if vix < 15:
        recommendations.append("시장 변동성이 낮습니다. 리스크 프리미엄이 낮아질 수 있습니다.")
    elif 15 <= vix <= 20:
        risk_score += 1
        recommendations.append("시장 변동성이 다소 증가했습니다. 주의가 필요합니다.")
    elif 20 < vix <= 30:
        risk_score += 2
        recommendations.append("시장 변동성이 높습니다. 방어적 포트폴리오를 고려하세요.")
    else:  # vix > 30
        risk_score += 3
        recommendations.append("시장에 극단적 변동성이 존재합니다. 리스크 축소 필요!")

    # --- 금리 (기준금리) ---
    if interest_rate is None:
        recommendations.append("❌ 금리 데이터를 가져오는데 실패했습니다. 평가를 수행할 수 없습니다.")
    elif interest_rate < 2:
        recommendations.append("완화적 금리 환경입니다. 성장 자산 비중 확대를 고려할 수 있습니다.")
    elif 2 <= interest_rate <= 3.5:
        risk_score += 1
        recommendations.append("금리가 중립 수준입니다. 자산 배분 유지 권장.")
    elif 3.5 < interest_rate <= 4.5:
        risk_score += 2
        recommendations.append("금리가 상승 중입니다. 채권 또는 배당 자산 비중 확대 고려.")
    else:  # interest_rate > 4.5
        risk_score += 3
        recommendations.append("금리가 고점 수준입니다. 포트폴리오 방어적 조정 필요.")

    # --- 환율 (원/달러 환율) ---
    if exchange_rate < 1200:
        recommendations.append("환율이 안정적입니다. 외화 리스크는 낮은 편입니다.")
    elif 1200 <= exchange_rate <= 1300:
        risk_score += 1
        recommendations.append("환율이 상승 중입니다. 외화자산 비중 점검 필요.")
    elif 1300 < exchange_rate <= 1350:
        risk_score += 2
        recommendations.append("환율 급등 구간입니다. 환헷지 전략 필요.")
    else:  # exchange_rate > 1350
        risk_score += 3
        recommendations.append("환율 급변 환경입니다. 외환 리스크 집중 관리 필요!")

    # --- 뉴스 키워드 분석 ---
    risk_keywords = ["위기", "붕괴", "파산", "침체", "전쟁", "불안"]
    negative_news_count = sum(any(kw in headline for kw in risk_keywords) for headline in news_headlines)

    if negative_news_count >= 3:
        risk_score += 3
        recommendations.append("부정적인 뉴스가 다수 포착되었습니다. 투자 심리 악화 우려.")
    elif negative_news_count == 2:
        risk_score += 2
        recommendations.append("부정적 뉴스가 관측됩니다. 리스크 감시 필요.")
    elif negative_news_count == 1:
        risk_score += 1
        recommendations.append("주의할 뉴스 키워드가 감지되었습니다.")
    else:
        recommendations.append("부정적인 뉴스 키워드는 현재 없습니다.")

    # --- 종합 리스크 등급 산정 ---
    if risk_score >= 8:
        risk_level = "High"
    elif 4 <= risk_score < 8:
        risk_level = "Medium"
    else:
        risk_level = "Low"

    return risk_level, recommendations

# 📈 대시보드 실행
# API 키 설정
api_key = "YOUR_API_KEY"

# 데이터 수집
vix = get_vix_data()
interest_rate = get_interest_rate(api_key, "KR")
exchange_rate = get_exchange_rate("USD", "KRW")
news_headlines = get_news_headlines("금융 위기")

# 리스크 평가
risk_level, recommendations = assess_risk(vix, interest_rate, exchange_rate, news_headlines)

# 결과 출력
print(f"현재 VIX 지수: {vix}")
print(f"현재 기준 금리: {interest_rate}%")
print(f"현재 환율 (USD/KRW): {exchange_rate}")
print(f"리스크 수준: {risk_level}")
print("대응 방안:")
for rec in recommendations:
    print(f"- {rec}")

🎯 📈 위험 평가 임계 값

코드에서 사용된 VIX, 금리, 환율에 대한 임계값 기준은 시장 관찰과 일반적인 투자 전략 관행에 기반한 경험적 위험 평가 구간이라고 보시면 됩니다.
이런 임계값 설정은 정량적 스코어링 기반의 리스크 판단 도구로 사용하기 위한 것입니다.
궁극적으로는 사용자 입장에서 대응 시나리오를 구조화하고, 자동화된 투자 판단을 내리는 데 기반이 됩니다.

✅ 1. VIX (시장 변동성 지수) 기준

VIX 수준	해석	리스크 점수	대응 전략
`< 15`	매우 안정된 시장	0	리스크 프리미엄 하락, 위험자산 확대 가능
`15~20`	약간의 불안정성	+1	주의 필요, 변동성 증가 징후
`20~30`	높은 변동성	+2	리스크 관리 강화, 방어적 자산 고려
`> 30`	극단적 변동성	+3	포지션 축소 또는 리스크 해지 적극 필요

📌 기준 근거: VIX가 20 이상이면 시장 불안이 시작되고, 30을 넘으면 금융위기, 팬데믹 등 위기 국면으로 해석하는 것이 일반적입니다.

✅ 2. 금리 (기준금리) 기준

금리 수준	해석	리스크 점수	대응 전략
`< 2.0%`	매우 완화적	0	성장주, 주식 투자 비중 확대 고려
`2.0~3.5%`	중립 수준	+1	정상 금리, 자산 배분 유지
`3.5~4.5%`	긴축 단계	+2	금리 부담 증가, 방어적 자산 확대 고려
`> 4.5%`	고금리 압박	+3	포트폴리오 방어적 조정, 현금화 검토

📌 기준 근거:

2% 이하는 통화 완화 정책 상황
3.5% 이상이면 대개 긴축 전환
4.5% 이상이면 자산 가격 조정 압력이 커지는 구간입니다.

✅ 3. 환율 (원/달러) 기준

환율 수준	해석	리스크 점수	대응 전략
`< 1200`	안정적	0	환위험 작음, 외화 노출 부담 낮음
`1200~1300`	상승 구간	+1	외화자산 비중 점검 필요
`1300~1350`	급등 구간	+2	원화 약세 위험, 환헷지 필요
`> 1350`	외환시장 불안	+3	급변 가능성, 외환 리스크 집중 관리 필요

📌 기준 근거:

1200원은 심리적 안정선으로 자주 인용됨
1300~1350원은 통화위기 또는 글로벌 불안 요소 반영 구간
1350원 이상은 과도한 외환시장 불안정 신호로 해석

🎯 종합적 요약

지표	저위험	중위험	고위험	초고위험
VIX	<15	15~20	20~30	>30
금리	<2%	2~3.5%	3.5~4.5%	>4.5%
환율	<1200	1200~1300	1300~1350	>1350

📁 Google Drive에 결과 저장 방법

from google.colab import drive
import os

# Google Drive 마운트
drive.mount('/content/drive')

# 저장 경로 설정
save_path = "/content/drive/MyDrive/RiskDashboard"
os.makedirs(save_path, exist_ok=True)

# 결과 저장
with open(os.path.join(save_path, "risk_assessment.txt"), "w") as f:
    f.write(f"현재 VIX 지수: {vix}\n")
    f.write(f"현재 기준 금리: {interest_rate}%\n")
    f.write(f"현재 환율 (USD/KRW): {exchange_rate}\n")
    f.write(f"리스크 수준: {risk_level}\n")
    f.write("대응 방안:\n")
    for rec in recommendations:
        f.write(f"- {rec}\n")

25.05.22.
Hoyal Horus Hawks

Citations:

[1]: https://www.kaggle.com/code/guillemservera/downloading-vix-data-using-yfinance?utm_source=chatgpt.com "Downloading VIX Data using Yfinance - Kaggle"
[2]: https://www.api-ninjas.com/api/interestrate?utm_source=chatgpt.com "Interest Rate API - API Ninjas"
[3]: https://pypi.org/project/forex-python/?utm_source=chatgpt.com "forex-python - PyPI"
[4]: https://www.scrapingdog.com/blog/scrape-google-news/?utm_source=chatgpt.com "Scrape Google News Using Python (Export Data in CSV)"

저작자표시 비영리 동일조건 (새창열림)

'투자의 기술 > 복잡계 투자론' 카테고리의 다른 글

10주차. 보충자료 - 트렌드 예측 실습 (1)	2025.05.21
9주차. 보충자료 - 데이터 수집 및 분석 (0)	2025.05.20
8주차. 보충자료 - 포트폴리오 관리 (2)	2025.05.19
7주차. 보충자료 - 리스크 관리 (2)	2025.05.18
6주차. 보충자료 - 종목 선정 (0)	2025.05.17

현재글11주차. 보충자료 - 리스크 시뮬레이션

Illuminating Minds, Bridging Worlds - Another.Works

VIX, growth and underinvestment, success to the successful, 지속가능성, tragedy of the commons, prophet, 칼릴 지브란, 칼릴지브란, limits to growth, System Thinking, 피터 린치, 생물모방, 시스템 사고, 시스템 원형, 예언자, escalation, Data Science, eroding goals, 기술적 분석, archetype,

« 2025/05 »
일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31