4 posts tagged with "quantitative"

# Python là ngôn ngữ phổ biến nhất
import pandas as pd
import numpy as np
import yfinance as yf

# Tải dữ liệu
data = yf.download('AAPL', start='2023-01-01', end='2023-12-31')

# Ví dụ về backtesting đơn giản
def backtest_strategy(data, strategy):
    signals = strategy.generate_signals(data)
    positions = calculate_positions(signals)
    returns = calculate_returns(positions, data)
    return evaluate_performance(returns)

def moving_average_crossover(data, short_window=20, long_window=50):
    # Tính toán các đường trung bình
    data['SMA_short'] = data['Close'].rolling(window=short_window).mean()
    data['SMA_long'] = data['Close'].rolling(window=long_window).mean()
    
    # Tạo tín hiệu
    data['Signal'] = 0
    data.loc[data['SMA_short'] > data['SMA_long'], 'Signal'] = 1
    data.loc[data['SMA_short'] < data['SMA_long'], 'Signal'] = -1
    
    return data

import yfinance as yf
import pandas as pd

# Tải dữ liệu VN30
vn30 = yf.download('^VN30', start='2020-01-01', end='2024-03-21')

# Tính toán các chỉ báo kỹ thuật
vn30['SMA20'] = vn30['Close'].rolling(window=20).mean()
vn30['SMA50'] = vn30['Close'].rolling(window=50).mean()
vn30['RSI'] = calculate_rsi(vn30['Close'])

def generate_signals(df):
    signals = pd.DataFrame(index=df.index)
    signals['signal'] = 0
    
    # Tín hiệu mua khi SMA20 cắt lên SMA50
    signals['signal'][df['SMA20'] > df['SMA50']] = 1
    
    # Tín hiệu bán khi SMA20 cắt xuống SMA50
    signals['signal'][df['SMA20'] < df['SMA50']] = -1
    
    return signals

def backtest_strategy(signals, prices):
    positions = signals['signal'].diff()
    portfolio = pd.DataFrame(index=signals.index)
    portfolio['positions'] = positions
    portfolio['holdings'] = positions.cumsum() * prices['Close']
    portfolio['cash'] = 100000 - (positions * prices['Close']).cumsum()
    portfolio['total'] = portfolio['cash'] + portfolio['holdings']
    portfolio['returns'] = portfolio['total'].pct_change()
    
    return portfolio

import ccxt

exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY'
})

# Đặt lệnh
order = exchange.create_market_buy_order('BTC/USDT', 0.1)

def monitor_performance(portfolio):
    daily_returns = portfolio['returns']
    sharpe_ratio = calculate_sharpe_ratio(daily_returns)
    max_drawdown = calculate_max_drawdown(portfolio['total'])
    
    return {
        'sharpe_ratio': sharpe_ratio,
        'max_drawdown': max_drawdown,
        'total_return': portfolio['total'][-1] / portfolio['total'][0] - 1
    }

import numpy as np

# Tính toán lợi nhuận từ giá
prices = np.array([100, 102, 104, 103, 105])
returns = np.diff(prices) / prices[:-1]
print(f"Lợi nhuận hàng ngày: {returns}")
print(f"Lợi nhuận trung bình: {np.mean(returns)}")
print(f"Độ lệch chuẩn: {np.std(returns)}")

import pandas as pd

# Đọc dữ liệu chuỗi thời gian
df = pd.read_csv('stock_data.csv', parse_dates=['Date'], index_col='Date')

# Tính các chỉ số tài chính cơ bản
df['Returns'] = df['Close'].pct_change()
df['SMA_20'] = df['Close'].rolling(window=20).mean()
df['Volatility'] = df['Returns'].rolling(window=20).std() * np.sqrt(252)  # Volatility hàng năm

print(df.head())

from scipy import stats
from scipy import optimize

# Kiểm định tính chuẩn của lợi nhuận
returns = df['Returns'].dropna().values
k2, p = stats.normaltest(returns)
print(f"p-value cho kiểm định tính chuẩn: {p}")

# Tối ưu hóa danh mục đầu tư
def negative_sharpe(weights, returns, risk_free_rate=0.02):
    portfolio_return = np.sum(returns.mean() * weights) * 252
    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))
    sharpe = (portfolio_return - risk_free_rate) / portfolio_volatility
    return -sharpe  # Tối thiểu hóa âm của Sharpe ratio

# Ví dụ tối ưu hóa danh mục 3 cổ phiếu
stock_returns = pd.DataFrame()  # Giả sử đã có dữ liệu
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})  # Tổng trọng số = 1
bounds = tuple((0, 1) for _ in range(3))  # Trọng số từ 0 đến 1
result = optimize.minimize(negative_sharpe, np.array([1/3, 1/3, 1/3]), 
                         args=(stock_returns,), bounds=bounds, constraints=constraints)

import statsmodels.api as sm
from statsmodels.tsa.arima.model import ARIMA

# Mô hình hồi quy tuyến tính đa biến
X = df[['Feature1', 'Feature2', 'Feature3']]
X = sm.add_constant(X)  # Thêm hằng số
y = df['Returns']
model = sm.OLS(y, X).fit()
print(model.summary())

# Mô hình ARIMA cho dự báo giá
arima_model = ARIMA(df['Close'], order=(5, 1, 0))
arima_result = arima_model.fit()
forecast = arima_result.forecast(steps=30)  # Dự báo 30 ngày

import tables

# Tạo file HDF5 để lưu trữ dữ liệu lớn
class StockData(tables.IsDescription):
    date = tables.StringCol(10)
    symbol = tables.StringCol(10)
    open = tables.Float64Col()
    high = tables.Float64Col()
    low = tables.Float64Col()
    close = tables.Float64Col()
    volume = tables.Int64Col()

h5file = tables.open_file("market_data.h5", mode="w")
table = h5file.create_table("/", 'stocks', StockData)

# Thêm dữ liệu
row = table.row
for data in stock_data:  # Giả sử có dữ liệu sẵn
    row['date'] = data['date']
    row['symbol'] = data['symbol']
    row['open'] = data['open']
    row['high'] = data['high']
    row['low'] = data['low']
    row['close'] = data['close']
    row['volume'] = data['volume']
    row.append()
table.flush()

import bottleneck as bn

# Các phép toán nhanh hơn cho mảng lớn
rolling_mean = bn.move_mean(df['Close'].values, window=20)
rolling_max = bn.move_max(df['Close'].values, window=50)
rolling_median = bn.move_median(df['Close'].values, window=20)

# Tìm kiếm nhanh phần tử lớn nhất, nhỏ nhất
max_idx = bn.argmax(df['Volume'].values)
max_volume_date = df.index[max_idx]

import yfinance as yf

# Tải dữ liệu một cổ phiếu
msft = yf.Ticker("MSFT")
hist = msft.history(period="1y")  # Dữ liệu 1 năm
print(hist.head())

# Tải dữ liệu nhiều cổ phiếu
data = yf.download(["AAPL", "MSFT", "GOOG"], start="2020-01-01", end="2023-01-01")
print(data['Close'].head())

# Lấy thông tin tài chính
info = msft.info
financials = msft.financials

import pandas_datareader.data as web
from datetime import datetime

# Lấy dữ liệu từ Fred (Federal Reserve Economic Data)
fed_data = web.DataReader('GDP', 'fred', start=datetime(2010, 1, 1), end=datetime.now())
print(fed_data.head())

# Lấy dữ liệu từ World Bank
wb_data = web.DataReader('NY.GDP.MKTP.CD', 'wb', start=2010, end=2020)
print(wb_data.head())

from alpha_vantage.timeseries import TimeSeries
from alpha_vantage.techindicators import TechIndicators

# Lấy dữ liệu chuỗi thời gian
ts = TimeSeries(key='YOUR_API_KEY')
data, meta_data = ts.get_daily(symbol='AAPL', outputsize='full')
print(data.head())

# Lấy chỉ báo kỹ thuật
ti = TechIndicators(key='YOUR_API_KEY')
rsi, meta_data = ti.get_rsi(symbol='AAPL', interval='daily', time_period=14, series_type='close')
print(rsi.head())

import quandl

# Đặt API key
quandl.ApiConfig.api_key = 'YOUR_API_KEY'

# Lấy dữ liệu
oil_data = quandl.get('EIA/PET_RWTC_D')  # Giá dầu WTI
print(oil_data.head())

# Lấy dữ liệu với các tùy chọn
data = quandl.get("WIKI/AAPL", start_date="2010-01-01", end_date="2018-12-31")
print(data.head())

import ccxt

# Khởi tạo exchange
binance = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY',
})

# Lấy dữ liệu ticker
ticker = binance.fetch_ticker('BTC/USDT')
print(ticker)

# Lấy dữ liệu OHLCV
ohlcv = binance.fetch_ohlcv('ETH/USDT', '1h')
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
print(df.head())

import pyEX as p

# Khởi tạo client
c = p.Client(api_token='YOUR_API_TOKEN')

# Lấy dữ liệu giá
df = c.chartDF('AAPL')
print(df.head())

# Lấy thông tin công ty
company = c.company('TSLA')
print(company)

import backtrader as bt

class SMACrossStrategy(bt.Strategy):
    params = (
        ('fast_length', 10),
        ('slow_length', 30),
    )
    
    def __init__(self):
        self.fast_ma = bt.indicators.SMA(self.data.close, period=self.params.fast_length)
        self.slow_ma = bt.indicators.SMA(self.data.close, period=self.params.slow_length)
        self.crossover = bt.indicators.CrossOver(self.fast_ma, self.slow_ma)
        
    def next(self):
        if not self.position:  # Không có vị thế
            if self.crossover > 0:  # fast crosses above slow
                self.buy()
        elif self.crossover < 0:  # fast crosses below slow
            self.sell()

# Khởi tạo cerebro
cerebro = bt.Cerebro()
cerebro.addstrategy(SMACrossStrategy)

# Thêm dữ liệu
data = bt.feeds.PandasData(dataname=df)  # Giả sử df là DataFrame pandas với dữ liệu OHLCV
cerebro.adddata(data)

# Thêm vốn ban đầu và chạy backtest
cerebro.broker.setcash(100000)
cerebro.addsizer(bt.sizers.PercentSizer, percents=10)
print(f'Vốn ban đầu: {cerebro.broker.getvalue():.2f}')
cerebro.run()
print(f'Vốn cuối: {cerebro.broker.getvalue():.2f}')

# Vẽ biểu đồ
cerebro.plot()

from pyalgotrade import strategy
from pyalgotrade.barfeed import quandlfeed
from pyalgotrade.technical import ma

class MyStrategy(strategy.BacktestingStrategy):
    def __init__(self, feed, instrument, smaPeriod):
        super(MyStrategy, self).__init__(feed, 100000)
        self.__position = None
        self.__instrument = instrument
        self.__sma = ma.SMA(feed[instrument].getCloseDataSeries(), smaPeriod)
        
    def onBars(self, bars):
        bar = bars[self.__instrument]
        
        if self.__sma[-1] is None:
            return
            
        if self.__position is None:
            if bar.getClose() > self.__sma[-1]:
                self.__position = self.enterLong(self.__instrument, 10)
        elif bar.getClose() < self.__sma[-1] and not self.__position.exitActive():
            self.__position.exitMarket()

# Tạo feed dữ liệu từ Quandl
feed = quandlfeed.Feed()
feed.addBarsFromCSV("orcl", "WIKI-ORCL-2000-quandl.csv")

# Chạy chiến lược
myStrategy = MyStrategy(feed, "orcl", 15)
myStrategy.run()
print("Final portfolio value: $%.2f" % myStrategy.getBroker().getEquity())

from zipline.api import order, record, symbol
from zipline.finance import commission, slippage
import matplotlib.pyplot as plt

def initialize(context):
    context.asset = symbol('AAPL')
    context.sma_fast = 10
    context.sma_slow = 30
    
    # Thiết lập mô hình hoa hồng và trượt giá
    context.set_commission(commission.PerShare(cost=0.001, min_trade_cost=1.0))
    context.set_slippage(slippage.FixedSlippage(spread=0.00))

def handle_data(context, data):
    # Tính SMA
    fast_sma = data.history(context.asset, 'close', context.sma_fast, '1d').mean()
    slow_sma = data.history(context.asset, 'close', context.sma_slow, '1d').mean()
    
    # Chiến lược giao cắt trung bình động
    if fast_sma > slow_sma and context.portfolio.positions[context.asset].amount == 0:
        # Mua 100 cổ phiếu
        order(context.asset, 100)
    elif fast_sma < slow_sma and context.portfolio.positions[context.asset].amount > 0:
        # Bán tất cả
        order(context.asset, -context.portfolio.positions[context.asset].amount)
    
    # Ghi lại các biến cho biểu đồ
    record(fast=fast_sma, slow=slow_sma, price=data.current(context.asset, 'close'))

# Chạy backtest
result = run_algorithm(
    start=pd.Timestamp('2014-01-01', tz='utc'),
    end=pd.Timestamp('2018-01-01', tz='utc'),
    initialize=initialize,
    handle_data=handle_data,
    capital_base=100000,
    data_frequency='daily',
    bundle='quandl'
)

# Vẽ kết quả
plt.figure(figsize=(12, 8))
plt.plot(result.portfolio_value)
plt.title('Portfolio Value')
plt.show()

import talib as ta
import numpy as np

# Dữ liệu cần có các mảng giá Open, High, Low, Close
close_prices = np.array(df['Close'])
high_prices = np.array(df['High'])
low_prices = np.array(df['Low'])
volume = np.array(df['Volume'])

# Các chỉ báo đơn giản
sma = ta.SMA(close_prices, timeperiod=20)
ema = ta.EMA(close_prices, timeperiod=20)
rsi = ta.RSI(close_prices, timeperiod=14)

# Các chỉ báo phức tạp hơn
macd, macdsignal, macdhist = ta.MACD(close_prices, fastperiod=12, slowperiod=26, signalperiod=9)
upper, middle, lower = ta.BBANDS(close_prices, timeperiod=20, nbdevup=2, nbdevdn=2)
slowk, slowd = ta.STOCH(high_prices, low_prices, close_prices, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)

# Mẫu hình nến
doji = ta.CDLDOJI(open_prices, high_prices, low_prices, close_prices)
engulfing = ta.CDLENGULFING(open_prices, high_prices, low_prices, close_prices)
hammer = ta.CDLHAMMER(open_prices, high_prices, low_prices, close_prices)

import pyfolio as pf

# Giả sử chúng ta có chuỗi lợi nhuận từ backtest
returns = result.returns  # Chuỗi pandas của lợi nhuận hàng ngày

# Phân tích hiệu suất
pf.create_full_tear_sheet(returns)

# Phân tích cụ thể
pf.create_returns_tear_sheet(returns)
pf.create_position_tear_sheet(returns, result.positions)
pf.create_round_trip_tear_sheet(returns, result.positions, result.transactions)
pf.create_interesting_times_tear_sheet(returns)

import vectorbt as vbt

# Tải dữ liệu
btc_price = vbt.YFData.download('BTC-USD').get('Close')

# Backtest chiến lược MA Cross
fast_ma = vbt.MA.run(btc_price, 10)
slow_ma = vbt.MA.run(btc_price, 50)
entries = fast_ma.ma_above(slow_ma)
exits = fast_ma.ma_below(slow_ma)

pf = vbt.Portfolio.from_signals(btc_price, entries, exits, init_cash=10000)
stats = pf.stats()
print(stats)

# Vẽ biểu đồ
pf.plot().show()

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Chuẩn bị dữ liệu
data = prepare_features(df)  # Hàm tự định nghĩa tạo đặc trưng
X = data.drop('target', axis=1)
y = data['target']  # Ví dụ target: 1 nếu giá tăng sau 5 ngày, 0 nếu không

# Chia dữ liệu
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Huấn luyện mô hình
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Đánh giá
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Độ chính xác: {accuracy:.2f}")

# Tính quan trọng của đặc trưng
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout
from tensorflow.keras.optimizers import Adam

# Chuẩn bị dữ liệu chuỗi thời gian
def create_sequences(data, seq_length):
    xs, ys = [], []
    for i in range(len(data) - seq_length - 1):
        x = data[i:(i + seq_length)]
        y = data[i + seq_length]
        xs.append(x)
        ys.append(y)
    return np.array(xs), np.array(ys)

# Chuẩn hóa dữ liệu
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(df[['Close']])

# Tạo chuỗi
seq_length = 60
X, y = create_sequences(scaled_data, seq_length)
X = X.reshape(X.shape[0], X.shape[1], 1)

# Chia dữ liệu
X_train, X_test = X[:-100], X[-100:]
y_train, y_test = y[:-100], y[-100:]

# Xây dựng mô hình LSTM
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(seq_length, 1)))
model.add(Dropout(0.2))
model.add(LSTM(50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(1))

model.compile(optimizer=Adam(learning_rate=0.001), loss='mean_squared_error')
model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.1)

# Dự đoán
predictions = model.predict(X_test)
predictions = scaler.inverse_transform(predictions)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Chuẩn bị dữ liệu
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.FloatTensor(y_train).view(-1, 1)
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# Định nghĩa mô hình
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=50, num_layers=2, output_size=1):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

# Khởi tạo mô hình và tối ưu hóa
model = LSTMModel()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Huấn luyện
num_epochs = 20
for epoch in range(num_epochs):
    for data, targets in train_loader:
        optimizer.zero_grad()
        outputs = model(data)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}")

import xgboost as xgb
from sklearn.metrics import mean_squared_error

# Chuẩn bị dữ liệu
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Tạo DMatrix (định dạng dữ liệu cho XGBoost)
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# Thiết lập tham số
params = {
    'objective': 'reg:squarederror',
    'max_depth': 6,
    'alpha': 10,
    'learning_rate': 0.1,
    'n_estimators': 100
}

# Huấn luyện mô hình
model = xgb.train(params, dtrain, num_boost_round=100)

# Dự đoán
y_pred = model.predict(dtest)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
print(f"RMSE: {rmse:.4f}")

# Quan trọng của đặc trưng
importance = model.get_score(importance_type='gain')
sorted_importance = sorted(importance.items(), key=lambda x: x[1], reverse=True)

from prophet import Prophet

# Chuẩn bị dữ liệu cho Prophet
prophet_df = df.reset_index()[['Date', 'Close']].rename(columns={'Date': 'ds', 'Close': 'y'})

# Tạo và huấn luyện mô hình
model = Prophet(daily_seasonality=True)
model.fit(prophet_df)

# Tạo dữ liệu tương lai
future = model.make_future_dataframe(periods=365)  # Dự báo 1 năm

# Dự báo
forecast = model.predict(future)
print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())

# Vẽ biểu đồ
fig1 = model.plot(forecast)
fig2 = model.plot_components(forecast)

import matplotlib.pyplot as plt

# Vẽ biểu đồ giá và MA
plt.figure(figsize=(14, 7))
plt.plot(df.index, df['Close'], label='Giá đóng cửa')
plt.plot(df.index, df['SMA_20'], label='SMA 20 ngày')
plt.plot(df.index, df['SMA_50'], label='SMA 50 ngày')
plt.title('Biểu đồ giá và đường trung bình động')
plt.xlabel('Ngày')
plt.ylabel('Giá ($)')
plt.legend()
plt.grid(True)
plt.show()

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Tạo subplot với 2 hàng
fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
                   vertical_spacing=0.1, subplot_titles=('Giá', 'Khối lượng'),
                   row_heights=[0.7, 0.3])

# Thêm biểu đồ nến
fig.add_trace(
    go.Candlestick(
        x=df.index,
        open=df['Open'],
        high=df['High'],
        low=df['Low'],
        close=df['Close'],
        name='Giá'
    ),
    row=1, col=1
)

# Thêm đường MA
fig.add_trace(
    go.Scatter(
        x=df.index,
        y=df['SMA_20'],
        name='SMA 20',
        line=dict(color='blue', width=1)
    ),
    row=1, col=1
)

# Thêm biểu đồ khối lượng
fig.add_trace(
    go.Bar(
        x=df.index,
        y=df['Volume'],
        name='Khối lượng',
        marker_color='rgba(0, 150, 0, 0.5)'
    ),
    row=2, col=1
)

# Cập nhật layout
fig.update_layout(
    title='Biểu đồ phân tích kỹ thuật',
    yaxis_title='Giá ($)',
    xaxis_title='Ngày',
    height=800,
    width=1200,
    showlegend=True,
    xaxis_rangeslider_visible=False
)

fig.show()

import seaborn as sns

# Vẽ histogram các lợi nhuận hàng ngày
plt.figure(figsize=(10, 6))
sns.histplot(df['Returns'].dropna(), kde=True, bins=50)
plt.title('Phân phối lợi nhuận hàng ngày')
plt.xlabel('Lợi nhuận (%)')
plt.axvline(x=0, color='r', linestyle='--')
plt.show()

# Vẽ heatmap tương quan
plt.figure(figsize=(12, 10))
correlation = df[['Close', 'Volume', 'Returns', 'SMA_20', 'RSI']].corr()
sns.heatmap(correlation, annot=True, cmap='coolwarm', linewidths=0.5)
plt.title('Ma trận tương quan')
plt.show()

import mplfinance as mpf

# Tạo biểu đồ nến với các chỉ báo
mpf.plot(
    df,
    type='candle',
    style='yahoo',
    title='Biểu đồ phân tích kỹ thuật',
    ylabel='Giá ($)',
    volume=True,
    mav=(20, 50),  # Moving averages
    figsize=(12, 8),
    panel_ratios=(4, 1)  # Tỷ lệ panel giá và khối lượng
)

from bokeh.plotting import figure, show, output_notebook
from bokeh.layouts import column
from bokeh.models import HoverTool, CrosshairTool, ColumnDataSource

# Tạo ColumnDataSource
source = ColumnDataSource(data=dict(
    date=df.index,
    open=df['Open'],
    high=df['High'],
    low=df['Low'],
    close=df['Close'],
    volume=df['Volume'],
    sma20=df['SMA_20']
))

# Tạo biểu đồ giá
p1 = figure(x_axis_type="datetime", width=1200, height=500, title="Biểu đồ giá")
p1.line('date', 'sma20', source=source, line_width=2, color='blue', legend_label='SMA 20')
p1.segment('date', 'high', 'date', 'low', source=source, color="black")
p1.rect('date', x_range=0.5, width=0.8, height='open', fill_color="green", line_color="black",
        fill_alpha=0.5, source=source)

# Thêm công cụ hover
hover = HoverTool()
hover.tooltips = [
    ("Ngày", "@date{%F}"),
    ("Mở", "@open{0.2f}"),
    ("Cao", "@high{0.2f}"),
    ("Thấp", "@low{0.2f}"),
    ("Đóng", "@close{0.2f}")
]
hover.formatters = {"@date": "datetime"}
p1.add_tools(hover)

# Tạo biểu đồ khối lượng
p2 = figure(x_axis_type="datetime", width=1200, height=200, x_range=p1.x_range)
p2.vbar('date', 0.8, 'volume', source=source, color="navy", alpha=0.5)
p2.yaxis.axis_label = "Khối lượng"

# Hiển thị
show(column(p1, p2))

import altair as alt

# Tạo biểu đồ tương tác
base = alt.Chart(df.reset_index()).encode(
    x='Date:T',
    tooltip=['Date:T', 'Open:Q', 'High:Q', 'Low:Q', 'Close:Q', 'Volume:Q']
)

# Đường giá
line = base.mark_line().encode(
    y='Close:Q',
    color=alt.value('blue')
)

# Đường SMA
sma = base.mark_line().encode(
    y='SMA_20:Q',
    color=alt.value('red')
)

# Khối lượng
volume = base.mark_bar().encode(
    y='Volume:Q',
    color=alt.value('gray')
).properties(
    height=100
)

# Kết hợp biểu đồ
chart = alt.vconcat(
    (line + sma).properties(title='Giá và SMA'),
    volume.properties(title='Khối lượng')
).properties(
    width=800
)

chart