ํฐ์คํ ๋ฆฌ ๋ทฐ
๐ง AI ํฉํฐ ์์ธก ๋ชจ๋ธ ๊ตฌ์ถ – Transformer๋ก ๋ค์ ๋ถ๊ธฐ ์์ต๋ฅ ์์ธกํ๊ธฐ
octo54 2025. 10. 28. 11:59๐ง AI ํฉํฐ ์์ธก ๋ชจ๋ธ ๊ตฌ์ถ – Transformer๋ก ๋ค์ ๋ถ๊ธฐ ์์ต๋ฅ ์์ธกํ๊ธฐ
์ง๊ธ๊น์ง ๋ง๋ ํํธ ์์คํ
์ ๋ฐ์ดํฐ๋ฅผ “ํ์ฉ”ํ๋ ์์ค์ด์์ฃ .
ํ์ง๋ง ์ง์ง ํํธ์ ํ์ ๋ฐ์ดํฐ๋ฅผ **“์์ธก”**ํ๋ ๋ฐ ์์ต๋๋ค.
์ด๋ฒ ๊ธ์์๋ ์ต์ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ธ Transformer๋ฅผ ์ด์ฉํด
๋ค์ ๋ถ๊ธฐ์ ํฉํฐ ์์ต๋ฅ ์ ์์ธกํ๋ AI ๋ชจ๋ธ์ ์ง์ ๋ง๋ค์ด๋ด
๋๋ค.
๐ฏ ๋ชฉํ
- yfinance๋ก ํฉํฐ ์๊ณ์ด ๋ฐ์ดํฐ ์์ง
- Transformer Encoder ๊ธฐ๋ฐ ์์ธก ๋ชจ๋ธ ๊ตฌ์ฑ
- ๊ณผ๊ฑฐ ํฉํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ → ๋ฏธ๋ 1๊ฐ์ ์์ต๋ฅ ์์ธก
- ํ์ต ํ MSE, MAE, R² ๋ฑ ์งํ ํ๊ฐ
๐งฑ 1๏ธโฃ ๋ฐ์ดํฐ ์ค๋น
์ฐ์ ๊ฐ ํฉํฐ(๋ชจ๋ฉํ
, ๊ฐ์น, ํ๋ฆฌํฐ, ์ ๋ณ๋์ฑ ๋ฑ)์ ๋ํด
๊ณผ๊ฑฐ 3๋
๊ฐ์ ์๋ณ ์์ต๋ฅ ๋ฐ์ดํฐ๋ฅผ ๋ง๋ญ๋๋ค.
import yfinance as yf
import pandas as pd
tickers = ["005930.KS", "000660.KS", "035420.KS", "068270.KQ"]
df_list = []
for t in tickers:
data = yf.download(t, period="3y", interval="1mo")
data["ticker"] = t
data["return"] = data["Close"].pct_change()
df_list.append(data)
df = pd.concat(df_list)
df = df.dropna()
df.to_csv("factor_returns.csv", index=False)
print(df.head())
๐ก ์ด๋ ๊ฒ ํ๋ฉด ์๋ณ ์ข ๋ชฉ ์์ต๋ฅ ์ด ๊ณ์ฐ๋์ด “ํฉํฐ ์๊ณ์ด ์ ๋ ฅ”์ผ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค.
๐งฉ 2๏ธโฃ Transformer ๋ชจ๋ธ ๊ฐ๋
Transformer๋ ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋ฐ ๋งค์ฐ ๊ฐ๋ ฅํฉ๋๋ค.
๊ธฐ์กด LSTM๊ณผ ๋ฌ๋ฆฌ ๋ณ๋ ฌ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๊ณ ,
“Self-Attention”์ผ๋ก ์ด๋ค ์์ ์ด ์ค์ํ์ง ์ค์ค๋ก ํ์ตํฉ๋๋ค.
์
๋ ฅ: ๊ณผ๊ฑฐ 12๊ฐ์ ํฉํฐ ์์ต๋ฅ → ์ถ๋ ฅ: ๋ค์ 1๊ฐ์ ์์ธก
โ๏ธ 3๏ธโฃ ๋ชจ๋ธ ๊ตฌํ (PyTorch)
import torch
import torch.nn as nn
import numpy as np
class FactorTransformer(nn.Module):
def __init__(self, input_dim=4, hidden_dim=64, n_heads=4, n_layers=2, dropout=0.1):
super().__init__()
self.encoder_layer = nn.TransformerEncoderLayer(
d_model=hidden_dim, nhead=n_heads, dropout=dropout
)
self.transformer = nn.TransformerEncoder(self.encoder_layer, num_layers=n_layers)
self.input_fc = nn.Linear(input_dim, hidden_dim)
self.output_fc = nn.Linear(hidden_dim, 1)
def forward(self, x):
x = self.input_fc(x)
x = self.transformer(x)
x = x.mean(dim=1)
out = self.output_fc(x)
return out
๐งฎ 4๏ธโฃ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ
12๊ฐ์ ๋จ์ ์๋์ฐ๋ก ๋ฐ์ดํฐ๋ฅผ ๋๋์ด ์ ๋ ฅ(X), ์์ธก(y)์ ๋ง๋ญ๋๋ค.
import torch
from sklearn.preprocessing import StandardScaler
df = pd.read_csv("factor_returns.csv")
pivot = df.pivot_table(index="Date", columns="ticker", values="return").fillna(0)
scaler = StandardScaler()
X_data = []
y_data = []
window = 12
values = scaler.fit_transform(pivot.values)
for i in range(len(values) - window):
X_data.append(values[i:i+window])
y_data.append(values[i+window])
X = torch.tensor(np.array(X_data), dtype=torch.float32)
y = torch.tensor(np.array(y_data), dtype=torch.float32)
๐ง 5๏ธโฃ ํ์ต ๋ฃจํ
model = FactorTransformer(input_dim=X.shape[2])
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()
for epoch in range(100):
model.train()
optimizer.zero_grad()
pred = model(X)
loss = criterion(pred, y.mean(dim=1, keepdim=True))
loss.backward()
optimizer.step()
if epoch % 10 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
๐ 6๏ธโฃ ์์ธก ๊ฒฐ๊ณผ ํ์ธ
model.eval()
preds = model(X).detach().numpy().flatten()
actual = y.mean(dim=1).numpy().flatten()
import matplotlib.pyplot as plt
plt.figure(figsize=(10,5))
plt.plot(preds, label="Predicted Return")
plt.plot(actual, label="Actual Return")
plt.legend()
plt.title("Next-Month Return Prediction (Transformer)")
plt.show()
Transformer ๋ชจ๋ธ์ด ํ์ตํ๋ฉด์ “์์ฅ ํจํด”์ ์ ์ฐจ ๋ฐ๋ผ๊ฐ๊ธฐ ์์ํ๋ฉด
์์ธก๊ณก์ ์ด ์ค์ ์์ต๋ฅ ์ ๋ณ๋ ํ๋ฆ์ ์ ์ ๋ฎ๊ฒ ๋ฉ๋๋ค.
๐งฎ 7๏ธโฃ ํ๊ฐ ์งํ
from sklearn.metrics import mean_squared_error, r2_score
print("MSE:", mean_squared_error(actual, preds))
print("R²:", r2_score(actual, preds))
๐ก MSE๊ฐ ๋ฎ๊ณ R²๊ฐ 0.7 ์ด์์ด๋ฉด ๊ฝค ์์ ์ ์ผ๋ก ํจํด์ ์ก๊ณ ์๋ ๊ฒ์ ๋๋ค.
โก 8๏ธโฃ Flask + Streamlit ์ฐ๋
๋ชจ๋ธ ์์ธก์ API๋ก ์ ๊ณตํฉ๋๋ค.
# Flask API snippet
@app.route("/predict_next")
def predict_next():
pred = model(X[-1:].to(torch.float32)).item()
return jsonify({"next_month_expected_return": float(pred)})
Streamlit์์๋ ์ด API๋ฅผ ํธ์ถํด
๐ “์์ ์์ต๋ฅ ” ์์ญ์ ์ค์๊ฐ์ผ๋ก ํ์ํ ์ ์์ต๋๋ค.
pred = requests.get(f"{API_URL}/predict_next").json()
st.metric("๐ Next Month Predicted Return", f"{pred['next_month_expected_return']:.2%}")
๐ง 9๏ธโฃ ๋ชจ๋ธ ๊ฐ์ ์์ด๋์ด
๊ฐ์ ๋ฐฉํฅ ์ค๋ช
| ๐งฉ Multi-Factor Input | ๋ชจ๋ฉํ , ๋ฐธ๋ฅ, ํ๋ฆฌํฐ, ๋ณ๋์ฑ ๊ฐ๊ฐ์ Feature๋ก ์ถ๊ฐ |
| ๐งฎ Multi-Step Forecast | 1๊ฐ์ → 3๊ฐ์ Ahead ์์ธก |
| ๐ง Transfer Learning | ๊ธ๋ก๋ฒ ETF/์ธ๋ฑ์ค ๋ฐ์ดํฐ๋ฅผ ์ฌ์ ํ์ต ํ Fine-tune |
| ๐งพ Model Ensemble | Transformer + LSTM + XGBoost ๊ฒฐํฉ |
| โ๏ธ ๋ฐฐํฌ | TorchScript or ONNX๋ก ๋ณํ → Flask ์๋ฒ์ ํ์ฌ |
๐ ์ ๋ฆฌ
๋จ๊ณ ๋ด์ฉ
| 1 | yfinance๋ก ํฉํฐ ์๊ณ์ด ๋ฐ์ดํฐ ์์ฑ |
| 2 | Transformer ๋ชจ๋ธ ์ ์ |
| 3 | ์ ๋ ฅ/์ถ๋ ฅ ์๋์ฐ ๊ตฌ์ฑ |
| 4 | ํ์ต ๋ฐ ์๊ฐํ |
| 5 | Flask + Streamlit ํตํฉ |
| 6 | ์์ธก๊ฐ ์ค์๊ฐ ๋ชจ๋ํฐ๋ง ๊ฐ๋ฅ |
์ด์ ํํธ ์์คํ
์ ๋จ์ํ ๊ณผ๊ฑฐ๋ฅผ ์ถ์ ํ๋ ๊ฒ ์๋๋ผ,
๋ค์ ๋ฌ ์์ฅ์ ํ๋ฆ์ ๋ฏธ๋ฆฌ ์์ธกํด ์์ง์ด๋ ์์ค์ ๋๋ฌํ์ต๋๋ค.
๐ ๋ค์ ๊ธ ์๊ณ
๋ค์ ํธ์์๋ **“Transformer + Reinforcement Learning์ ๊ฒฐํฉํ ๋์ ํฌํธํด๋ฆฌ์ค ์กฐ์ ์์คํ
”**์ ๋ค๋ฃน๋๋ค.
์ฆ, AI๊ฐ ์ค์ค๋ก ํ์ตํด ํฌํธํด๋ฆฌ์ค ๋น์ค์ ๋งค์ ์ฌ๊ตฌ์ฑํ๋ “์์จ ์ด์ฉํ ํํธ ๋งค๋์ ”๋ฅผ ๊ตฌํํฉ๋๋ค.
Transformer,๋ฅ๋ฌ๋ํํธ,AIํฌ์๋ชจ๋ธ,ํ์ดํ ์น,์๊ณ์ด์์ธก,ํํธAI,ํฉํฐ์์ธก,๋ฐ์ดํฐํฌ์,ํ์ด์ฌ๋ฅ๋ฌ๋,ํฌํธํด๋ฆฌ์ค์์ธก
'์ฃผ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
- Total
- Today
- Yesterday
- llm
- NestJS
- seo ์ต์ ํ 10๊ฐ
- ํ๋ก ํธ์๋๊ฐ๋ฐ
- Python
- rag
- node.js
- ๊ฐ๋ฐ๋ธ๋ก๊ทธ
- fastapi
- Prisma
- Next.js
- CI/CD
- ์ฟ ๋ฒ๋คํฐ์ค
- Redis
- ์๋ฐ๋ฉด์
- DevOps
- JWT
- Docker
- ๋ฅ๋ฌ๋
- PostgreSQL
- ๋ฐฑ์๋๊ฐ๋ฐ
- JAX
- REACT
- SEO์ต์ ํ
- kotlin
- ai์ฒ ํ
- nextJS
- flax
- ์น๊ฐ๋ฐ
- Express
| ์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
|---|---|---|---|---|---|---|
| 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 |

