27 posts tagged with "Python"

import numpy as np
import pandas as pd
from binance.client import Client

# Khởi tạo client
client = Client(api_key, api_secret)

# Lấy dữ liệu
klines = client.get_historical_klines("BTCUSDT", Client.KLINE_INTERVAL_1DAY, "1 year ago UTC")

# Chuyển đổi sang DataFrame
df = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 
                                  'quote_asset_volume', 'number_of_trades', 'taker_buy_base_asset_volume', 
                                  'taker_buy_quote_asset_volume', 'ignore'])

# Xử lý dữ liệu
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df['close'] = pd.to_numeric(df['close'])
df.set_index('timestamp', inplace=True)

# Tính toán trung bình động
df['MA20'] = df['close'].rolling(window=20).mean()
df['MA50'] = df['close'].rolling(window=50).mean()

# Tạo tín hiệu giao dịch
df['signal'] = 0
df['signal'] = np.where(df['MA20'] > df['MA50'], 1, 0)
df['position'] = df['signal'].diff()

# Hiển thị các điểm mua và bán
buy_signals = df[df['position'] == 1]
sell_signals = df[df['position'] == -1]

print("Điểm mua:")
print(buy_signals[['close', 'MA20', 'MA50']])
print("\nĐiểm bán:")
print(sell_signals[['close', 'MA20', 'MA50']])

import pandas as pd
import numpy as np
from binance.client import Client
import talib

# Khởi tạo client
client = Client(api_key, api_secret)

# Lấy dữ liệu
klines = client.get_historical_klines("BTCUSDT", Client.KLINE_INTERVAL_4HOUR, "3 months ago UTC")

# Chuyển đổi sang DataFrame
df = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 
                                  'quote_asset_volume', 'number_of_trades', 'taker_buy_base_asset_volume', 
                                  'taker_buy_quote_asset_volume', 'ignore'])

# Xử lý dữ liệu
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df['close'] = pd.to_numeric(df['close'])
df.set_index('timestamp', inplace=True)

# Tính toán RSI
df['RSI'] = talib.RSI(df['close'].values, timeperiod=14)

# Tạo tín hiệu giao dịch
df['signal'] = 0
df['signal'] = np.where(df['RSI'] < 30, 1, 0)  # Mua khi RSI < 30
df['signal'] = np.where(df['RSI'] > 70, -1, df['signal'])  # Bán khi RSI > 70

# Lọc tín hiệu để tránh nhiều tín hiệu liên tiếp
df['position'] = df['signal'].diff().fillna(0)

# Hiển thị kết quả
buy_signals = df[df['position'] == 1]
sell_signals = df[df['position'] == -1]

print("Tín hiệu mua (RSI quá bán):")
print(buy_signals[['close', 'RSI']])
print("\nTín hiệu bán (RSI quá mua):")
print(sell_signals[['close', 'RSI']])

import numpy as np
import pandas as pd
from binance.client import Client
from binance.enums import *

# Khởi tạo client
client = Client(api_key, api_secret)

# Cấu hình grid trading
symbol = "BTCUSDT"
lower_price = 40000  # Giá dưới của grid
upper_price = 50000  # Giá trên của grid
grid_number = 10     # Số lượng grid
investment = 10000   # Tổng số tiền đầu tư (USDT)

# Tính toán khoảng cách giữa các grid
grid_size = (upper_price - lower_price) / grid_number
grid_investment = investment / grid_number

# Tạo các grid
grids = []
for i in range(grid_number + 1):
    price = lower_price + i * grid_size
    grids.append({
        "price": price,
        "buy_order": None,
        "sell_order": None
    })

# Hàm mô phỏng tạo lệnh mua
def place_buy_order(symbol, price, quantity):
    # Trong thực tế, bạn sẽ sử dụng client.create_order() để tạo lệnh thực tế
    print(f"Đặt lệnh MUA {quantity:.5f} {symbol} tại giá {price:.2f}")
    return {"symbol": symbol, "side": "BUY", "price": price, "quantity": quantity}

# Hàm mô phỏng tạo lệnh bán
def place_sell_order(symbol, price, quantity):
    # Trong thực tế, bạn sẽ sử dụng client.create_order() để tạo lệnh thực tế
    print(f"Đặt lệnh BÁN {quantity:.5f} {symbol} tại giá {price:.2f}")
    return {"symbol": symbol, "side": "SELL", "price": price, "quantity": quantity}

# Thiết lập grid bằng cách đặt các lệnh mua tại các mức giá
for i in range(grid_number):
    price = grids[i]["price"]
    quantity = grid_investment / price
    grids[i]["buy_order"] = place_buy_order(symbol, price, quantity)
    
    # Nếu lệnh mua được khớp, đặt lệnh bán ở mức giá cao hơn
    if i < grid_number:
        sell_price = grids[i+1]["price"]
        grids[i]["sell_order"] = place_sell_order(symbol, sell_price, quantity)

print("\nThiết lập Grid Trading hoàn tất!")
print(f"Phạm vi giao dịch: {lower_price:.2f} - {upper_price:.2f} USDT")
print(f"Kích thước grid: {grid_size:.2f} USDT")
print(f"Đầu tư mỗi grid: {grid_investment:.2f} USDT")

import time
import pandas as pd
from binance.client import Client
from datetime import datetime, timedelta

# Khởi tạo client
client = Client(api_key, api_secret)

# Cấu hình DCA
symbol = "BTCUSDT"
investment_amount = 100  # USD mỗi lần đầu tư
interval_days = 7        # Đầu tư mỗi 7 ngày
total_periods = 10       # Tổng số lần đầu tư

# Lấy thông tin giá hiện tại
def get_current_price(symbol):
    ticker = client.get_symbol_ticker(symbol=symbol)
    return float(ticker['price'])

# Mô phỏng chiến lược DCA
def simulate_dca():
    total_investment = 0
    total_coins = 0
    dca_results = []
    
    # Ngày bắt đầu (giả định từ 70 ngày trước)
    start_date = datetime.now() - timedelta(days=70)
    
    for i in range(total_periods):
        # Ngày đầu tư
        investment_date = start_date + timedelta(days=i * interval_days)
        
        # Lấy dữ liệu giá từ ngày đầu tư
        klines = client.get_historical_klines(
            symbol, 
            Client.KLINE_INTERVAL_1DAY,
            investment_date.strftime("%d %b, %Y 00:00:00"),
            (investment_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
        )
        
        if not klines:
            print(f"Không có dữ liệu cho ngày {investment_date.strftime('%Y-%m-%d')}")
            continue
            
        # Lấy giá đóng cửa
        price = float(klines[0][4])
        
        # Tính lượng tiền điện tử mua được
        coins_bought = investment_amount / price
        
        # Cập nhật tổng
        total_investment += investment_amount
        total_coins += coins_bought
        
        # Ghi nhận kết quả
        dca_results.append({
            "date": investment_date.strftime("%Y-%m-%d"),
            "price": price,
            "investment": investment_amount,
            "coins_bought": coins_bought,
            "total_investment": total_investment,
            "total_coins": total_coins,
            "current_value": total_coins * price,
            "roi": (total_coins * price / total_investment - 1) * 100
        })
    
    # Chuyển kết quả thành DataFrame
    return pd.DataFrame(dca_results)

# Thực hiện mô phỏng
results = simulate_dca()
print(results[["date", "price", "coins_bought", "total_coins", "roi"]])

# Tính toán ROI cuối cùng
current_price = get_current_price(symbol)
final_value = results.iloc[-1]["total_coins"] * current_price
final_roi = (final_value / results.iloc[-1]["total_investment"] - 1) * 100

print(f"\nKết quả cuối cùng tại giá hiện tại ({current_price:.2f} USD):")
print(f"Tổng đầu tư: {results.iloc[-1]['total_investment']:.2f} USD")
print(f"Tổng số coin: {results.iloc[-1]['total_coins']:.8f}")
print(f"Giá trị hiện tại: {final_value:.2f} USD")
print(f"ROI: {final_roi:.2f}%")

import pandas as pd
import numpy as np
from binance.client import Client
from datetime import datetime, timedelta

# Khởi tạo client
client = Client(api_key, api_secret)

# Cấu hình danh mục đầu tư
portfolio = {
    "BTC": 0.5,  # 50% Bitcoin
    "ETH": 0.3,  # 30% Ethereum
    "BNB": 0.2   # 20% Binance Coin
}

initial_investment = 10000  # USD
rebalance_frequency = 30    # Rebalance mỗi 30 ngày

# Lấy giá hiện tại
def get_current_prices(symbols):
    prices = {}
    for symbol in symbols:
        ticker = client.get_symbol_ticker(symbol=symbol+"USDT")
        prices[symbol] = float(ticker['price'])
    return prices

# Mô phỏng chiến lược rebalancing
def simulate_rebalancing():
    # Giả định bắt đầu từ 180 ngày trước
    start_date = datetime.now() - timedelta(days=180)
    current_date = start_date
    end_date = datetime.now()
    
    # Dữ liệu ban đầu
    current_prices = {}
    for symbol in portfolio:
        klines = client.get_historical_klines(
            symbol+"USDT", 
            Client.KLINE_INTERVAL_1DAY,
            start_date.strftime("%d %b, %Y 00:00:00"),
            (start_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
        )
        if klines:
            current_prices[symbol] = float(klines[0][4])
    
    # Tính toán số lượng coin ban đầu
    holdings = {}
    for symbol, allocation in portfolio.items():
        investment_amount = initial_investment * allocation
        holdings[symbol] = investment_amount / current_prices[symbol]
    
    rebalance_results = []
    
    # Ghi nhận trạng thái ban đầu
    initial_holdings_value = sum(holdings[s] * current_prices[s] for s in portfolio)
    rebalance_results.append({
        "date": start_date.strftime("%Y-%m-%d"),
        "action": "Initial",
        "portfolio_value": initial_holdings_value,
        "holdings": holdings.copy(),
        "prices": current_prices.copy()
    })
    
    # Mô phỏng qua thời gian
    while current_date < end_date:
        current_date += timedelta(days=rebalance_frequency)
        
        # Lấy giá mới
        for symbol in portfolio:
            klines = client.get_historical_klines(
                symbol+"USDT", 
                Client.KLINE_INTERVAL_1DAY,
                current_date.strftime("%d %b, %Y 00:00:00"),
                (current_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
            )
            if klines:
                current_prices[symbol] = float(klines[0][4])
        
        # Tính giá trị danh mục hiện tại
        current_value = sum(holdings[s] * current_prices[s] for s in portfolio)
        
        # Tính toán cân bằng lại
        new_holdings = {}
        for symbol, target_allocation in portfolio.items():
            # Giá trị mục tiêu
            target_value = current_value * target_allocation
            # Số lượng coin mới
            new_holdings[symbol] = target_value / current_prices[symbol]
        
        # Ghi nhận kết quả rebalance
        rebalance_results.append({
            "date": current_date.strftime("%Y-%m-%d"),
            "action": "Rebalance",
            "portfolio_value": current_value,
            "holdings": new_holdings.copy(),
            "prices": current_prices.copy()
        })
        
        # Cập nhật holdings
        holdings = new_holdings
    
    # Chuyển kết quả thành DataFrame
    return pd.DataFrame(rebalance_results)

# Thực hiện mô phỏng
results = simulate_rebalancing()

# Hiển thị kết quả
for i, row in results.iterrows():
    print(f"\n--- {row['date']} ({row['action']}) ---")
    print(f"Giá trị danh mục: ${row['portfolio_value']:.2f}")
    
    for symbol in portfolio:
        coin_value = row['holdings'][symbol] * row['prices'][symbol]
        allocation = coin_value / row['portfolio_value'] * 100
        print(f"{symbol}: {row['holdings'][symbol]:.6f} (${coin_value:.2f}, {allocation:.2f}%)")

# Tính ROI
initial_value = results.iloc[0]["portfolio_value"]
final_value = results.iloc[-1]["portfolio_value"]
roi = (final_value / initial_value - 1) * 100

print(f"\nKết quả cuối cùng:")
print(f"Giá trị ban đầu: ${initial_value:.2f}")
print(f"Giá trị cuối cùng: ${final_value:.2f}")
print(f"ROI: {roi:.2f}%")

# Thư viện cần cài đặt
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import yfinance as yf
import scipy.optimize as sco
from scipy import stats
import cvxpy as cp
import warnings

# Thiết lập hiển thị
warnings.filterwarnings('ignore')
plt.style.use('fivethirtyeight')
np.random.seed(777)

def get_stock_data(tickers, start_date, end_date, interval='1d'):
    """
    Thu thập dữ liệu cổ phiếu từ Yahoo Finance
    
    Tham số:
    tickers (list): Danh sách mã cổ phiếu
    start_date (str): Ngày bắt đầu (YYYY-MM-DD)
    end_date (str): Ngày kết thúc (YYYY-MM-DD)
    interval (str): Khoảng thời gian ('1d', '1wk', '1mo')
    
    Trả về:
    pd.DataFrame: DataFrame chứa giá đóng cửa đã điều chỉnh của các cổ phiếu
    """
    data = yf.download(tickers, start=start_date, end=end_date, interval=interval)['Adj Close']
    
    # Xử lý trường hợp chỉ có một mã cổ phiếu
    if isinstance(data, pd.Series):
        data = pd.DataFrame(data)
        data.columns = [tickers]
    
    # Kiểm tra và xử lý dữ liệu thiếu
    if data.isnull().sum().sum() > 0:
        print(f"Có {data.isnull().sum().sum()} giá trị thiếu. Tiến hành điền giá trị thiếu...")
        data = data.fillna(method='ffill').fillna(method='bfill')
    
    return data

# Danh sách các mã cổ phiếu mẫu (đổi thành các mã trên HOSE nếu cần)
tickers = ['AAPL', 'MSFT', 'GOOG', 'AMZN', 'META', 'TSLA', 'NVDA', 'JPM', 'V', 'PG']

# Khoảng thời gian
start_date = '2018-01-01'
end_date = '2023-01-01'

# Thu thập dữ liệu
prices = get_stock_data(tickers, start_date, end_date)
print(prices.head())

# Vẽ biểu đồ giá cổ phiếu (chuẩn hóa)
normalized_prices = prices / prices.iloc[0] * 100
plt.figure(figsize=(12, 8))
normalized_prices.plot()
plt.title('Diễn biến giá cổ phiếu (chuẩn hóa)')
plt.xlabel('Ngày')
plt.ylabel('Giá chuẩn hóa (100 = giá ban đầu)')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()

def calculate_returns(prices, period='daily'):
    """
    Tính lợi nhuận của cổ phiếu
    
    Tham số:
    prices (pd.DataFrame): DataFrame chứa giá cổ phiếu
    period (str): Kỳ hạn lợi nhuận ('daily', 'weekly', 'monthly', 'annual')
    
    Trả về:
    pd.DataFrame: DataFrame chứa lợi nhuận
    """
    if period == 'daily':
        returns = prices.pct_change().dropna()
    elif period == 'weekly':
        returns = prices.resample('W').last().pct_change().dropna()
    elif period == 'monthly':
        returns = prices.resample('M').last().pct_change().dropna()
    elif period == 'annual':
        returns = prices.resample('Y').last().pct_change().dropna()
    else:
        raise ValueError("Kỳ hạn không hợp lệ. Sử dụng 'daily', 'weekly', 'monthly', hoặc 'annual'")
    
    return returns

# Tính lợi nhuận hàng ngày
daily_returns = calculate_returns(prices)

# Thống kê mô tả
desc_stats = daily_returns.describe().T
desc_stats['annualized_return'] = daily_returns.mean() * 252
desc_stats['annualized_vol'] = daily_returns.std() * np.sqrt(252)
desc_stats['sharpe_ratio'] = desc_stats['annualized_return'] / desc_stats['annualized_vol']

print(desc_stats[['mean', 'std', 'annualized_return', 'annualized_vol', 'sharpe_ratio']])

def plot_returns_distribution(returns):
    """
    Vẽ biểu đồ phân phối lợi nhuận
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    plt.figure(figsize=(15, 10))
    
    for i, ticker in enumerate(returns.columns):
        plt.subplot(3, 4, i+1)
        
        # Histogram
        sns.histplot(returns[ticker], kde=True, stat="density", linewidth=0)
        
        # Normal distribution curve
        xmin, xmax = plt.xlim()
        x = np.linspace(xmin, xmax, 100)
        p = stats.norm.pdf(x, returns[ticker].mean(), returns[ticker].std())
        plt.plot(x, p, 'k', linewidth=2)
        
        plt.title(f'Phân phối lợi nhuận {ticker}')
        plt.xlabel('Lợi nhuận hàng ngày')
        plt.ylabel('Mật độ')
    
    plt.tight_layout()

def calculate_risk_metrics(returns, risk_free_rate=0.0):
    """
    Tính toán các thước đo rủi ro cho từng cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_free_rate (float): Lãi suất phi rủi ro (annualized)
    
    Trả về:
    pd.DataFrame: DataFrame chứa các thước đo rủi ro
    """
    # Chuyển đổi lãi suất phi rủi ro sang tỷ lệ hàng ngày
    daily_rf = (1 + risk_free_rate) ** (1/252) - 1
    
    # DataFrame để lưu kết quả
    metrics = pd.DataFrame(index=returns.columns)
    
    # Độ biến động (Volatility) hàng năm
    metrics['volatility'] = returns.std() * np.sqrt(252)
    
    # Tỷ lệ Sharpe
    excess_returns = returns.sub(daily_rf, axis=0)
    metrics['sharpe_ratio'] = (excess_returns.mean() * 252) / metrics['volatility']
    
    # Maximum Drawdown
    cumulative_returns = (1 + returns).cumprod()
    rolling_max = cumulative_returns.cummax()
    drawdown = (cumulative_returns - rolling_max) / rolling_max
    metrics['max_drawdown'] = drawdown.min()
    
    # Value at Risk (VaR) 95%
    metrics['var_95'] = returns.quantile(0.05)
    
    # Conditional Value at Risk (CVaR) 95%
    metrics['cvar_95'] = returns[returns < returns.quantile(0.05)].mean()
    
    # Tỷ lệ Sortino
    negative_returns = returns.copy()
    negative_returns[negative_returns > 0] = 0
    downside_deviation = negative_returns.std() * np.sqrt(252)
    metrics['sortino_ratio'] = (excess_returns.mean() * 252) / downside_deviation
    
    # Beta (so với chỉ số S&P 500)
    sp500 = yf.download('^GSPC', start=returns.index[0], end=returns.index[-1], interval='1d')['Adj Close']
    sp500_returns = sp500.pct_change().dropna()
    
    # Chỉ lấy những ngày trùng khớp
    common_index = returns.index.intersection(sp500_returns.index)
    returns_aligned = returns.loc[common_index]
    sp500_returns_aligned = sp500_returns.loc[common_index]
    
    # Tính beta
    for ticker in returns.columns:
        covariance = np.cov(returns_aligned[ticker], sp500_returns_aligned)[0, 1]
        variance = np.var(sp500_returns_aligned)
        metrics.loc[ticker, 'beta'] = covariance / variance
    
    return metrics

def plot_risk_return(returns, risk_metrics, period=252):
    """
    Vẽ biểu đồ rủi ro-lợi nhuận
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_metrics (pd.DataFrame): DataFrame chứa các thước đo rủi ro
    period (int): Số ngày trong một năm để annualize lợi nhuận
    """
    plt.figure(figsize=(12, 8))
    
    # Tính lợi nhuận trung bình hàng năm
    annual_returns = returns.mean() * period
    
    # Biểu đồ scatter
    plt.scatter(risk_metrics['volatility'], annual_returns, s=200, alpha=0.6)
    
    # Thêm nhãn
    for i, ticker in enumerate(returns.columns):
        plt.annotate(ticker, 
                     (risk_metrics['volatility'][i], annual_returns[i]),
                     xytext=(10, 5),
                     textcoords='offset points',
                     fontsize=12)
    
    # Thêm title và label
    plt.title('Biểu đồ Rủi ro - Lợi nhuận', fontsize=16)
    plt.xlabel('Rủi ro (Độ biến động hàng năm)', fontsize=14)
    plt.ylabel('Lợi nhuận kỳ vọng hàng năm', fontsize=14)
    
    # Thêm đường Linear Regression
    z = np.polyfit(risk_metrics['volatility'], annual_returns, 1)
    p = np.poly1d(z)
    plt.plot(risk_metrics['volatility'], p(risk_metrics['volatility']), "r--", linewidth=2)
    
    plt.tight_layout()

def plot_drawdown(returns):
    """
    Vẽ biểu đồ drawdown cho từng cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    plt.figure(figsize=(12, 8))
    
    for ticker in returns.columns:
        # Tính cumulative returns
        cumulative_returns = (1 + returns[ticker]).cumprod()
        
        # Tính rolling maximum
        rolling_max = cumulative_returns.cummax()
        
        # Tính drawdown
        drawdown = (cumulative_returns - rolling_max) / rolling_max
        
        # Vẽ drawdown
        plt.plot(drawdown, label=ticker)
    
    plt.title('Biểu đồ Drawdown', fontsize=16)
    plt.xlabel('Ngày', fontsize=14)
    plt.ylabel('Drawdown', fontsize=14)
    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
    plt.tight_layout()

def plot_correlation_matrix(returns):
    """
    Vẽ ma trận tương quan giữa các cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    # Tính ma trận tương quan
    corr_matrix = returns.corr()
    
    # Thiết lập kích thước biểu đồ
    plt.figure(figsize=(10, 8))
    
    # Vẽ heatmap
    cmap = sns.diverging_palette(220, 10, as_cmap=True)
    sns.heatmap(corr_matrix, annot=True, cmap=cmap, center=0,
                square=True, linewidths=.5, cbar_kws={"shrink": .8})
    
    plt.title('Ma trận tương quan giữa các cổ phiếu', fontsize=16)
    plt.tight_layout()

def calculate_portfolio_performance(weights, returns):
    """
    Tính toán hiệu suất của danh mục đầu tư
    
    Tham số:
    weights (np.array): Trọng số phân bổ cho từng cổ phiếu
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    
    Trả về:
    tuple: (lợi nhuận kỳ vọng, độ biến động, tỷ lệ Sharpe)
    """
    # Lợi nhuận danh mục
    portfolio_return = np.sum(returns.mean() * weights) * 252
    
    # Độ biến động danh mục
    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))
    
    # Tỷ lệ Sharpe
    sharpe_ratio = portfolio_return / portfolio_volatility
    
    return portfolio_return, portfolio_volatility, sharpe_ratio

def random_portfolios(returns, num_portfolios=10000):
    """
    Tạo ngẫu nhiên các danh mục đầu tư và tính hiệu suất
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    num_portfolios (int): Số lượng danh mục ngẫu nhiên cần tạo
    
    Trả về:
    tuple: (results, weights) - kết quả hiệu suất và trọng số tương ứng
    """
    results = np.zeros((num_portfolios, 3))
    weights_record = np.zeros((num_portfolios, len(returns.columns)))
    
    for i in range(num_portfolios):
        # Tạo trọng số ngẫu nhiên
        weights = np.random.random(len(returns.columns))
        weights /= np.sum(weights)
        weights_record[i, :] = weights
        
        # Tính hiệu suất
        results[i, 0], results[i, 1], results[i, 2] = calculate_portfolio_performance(weights, returns)
    
    return results, weights_record

def plot_efficient_frontier(returns, results, weights_record):
    """
    Vẽ biểu đồ đường biên hiệu quả
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    results (np.array): Mảng kết quả hiệu suất của các danh mục ngẫu nhiên
    weights_record (np.array): Mảng trọng số của các danh mục ngẫu nhiên
    """
    plt.figure(figsize=(12, 8))
    
    # Vẽ các danh mục ngẫu nhiên
    plt.scatter(results[:, 1], results[:, 0], c=results[:, 2], 
                cmap='viridis', marker='o', s=10, alpha=0.3)
    
    # Đánh dấu danh mục có Sharpe ratio cao nhất
    max_sharpe_idx = np.argmax(results[:, 2])
    max_sharpe_portfolio = results[max_sharpe_idx]
    plt.scatter(max_sharpe_portfolio[1], max_sharpe_portfolio[0],
                marker='*', color='r', s=500, label='Danh mục tối ưu theo Sharpe')
    
    # Đánh dấu danh mục có độ biến động thấp nhất
    min_vol_idx = np.argmin(results[:, 1])
    min_vol_portfolio = results[min_vol_idx]
    plt.scatter(min_vol_portfolio[1], min_vol_portfolio[0],
                marker='*', color='g', s=500, label='Danh mục có độ biến động thấp nhất')
    
    # Đánh dấu cổ phiếu riêng lẻ
    for i, ticker in enumerate(returns.columns):
        individual_return = returns.mean()[i] * 252
        individual_volatility = returns.std()[i] * np.sqrt(252)
        plt.scatter(individual_volatility, individual_return, marker='o', s=200,
                   color='black', label=ticker if i == 0 else "")
        plt.annotate(ticker, (individual_volatility, individual_return),
                    xytext=(10, 5), textcoords='offset points')
    
    # Thêm title và label
    plt.colorbar(label='Sharpe ratio')
    plt.title('Đường biên hiệu quả (Efficient Frontier)', fontsize=16)
    plt.xlabel('Độ biến động (Rủi ro)', fontsize=14)
    plt.ylabel('Lợi nhuận kỳ vọng', fontsize=14)
    plt.legend()
    
    # Hiển thị thông tin về danh mục tối ưu
    print("Danh mục tối ưu theo tỷ lệ Sharpe:")
    print(f"Lợi nhuận kỳ vọng: {max_sharpe_portfolio[0]:.4f}")
    print(f"Độ biến động: {max_sharpe_portfolio[1]:.4f}")
    print(f"Tỷ lệ Sharpe: {max_sharpe_portfolio[2]:.4f}")
    print("\nPhân bổ vốn:")
    for i, ticker in enumerate(returns.columns):
        print(f"{ticker}: {weights_record[max_sharpe_idx, i] * 100:.2f}%")
    
    plt.tight_layout()

def optimize_portfolio(returns, risk_free_rate=0.0, target_return=None):
    """
    Tìm danh mục đầu tư tối ưu sử dụng lý thuyết Markowitz
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_free_rate (float): Lãi suất phi rủi ro (annualized)
    target_return (float): Lợi nhuận mục tiêu (annualized), nếu None thì tối đa hóa Sharpe ratio
    
    Trả về:
    tuple: (optimal_weights, expected_return, volatility, sharpe_ratio)
    """
    n = len(returns.columns)
    returns_mean = returns.mean() * 252
    cov_matrix = returns.cov() * 252
    
    # Khai báo biến
    w = cp.Variable(n)
    
    # Khai báo hàm mục tiêu
    if target_return is None:
        # Tối đa hóa tỷ lệ Sharpe
        risk = cp.quad_form(w, cov_matrix)
        ret = returns_mean @ w
        sharpe = (ret - risk_free_rate) / cp.sqrt(risk)
        objective = cp.Maximize(sharpe)
    else:
        # Tối thiểu hóa rủi ro với lợi nhuận mục tiêu
        risk = cp.quad_form(w, cov_matrix)
        objective = cp.Minimize(risk)
    
    # Ràng buộc
    constraints = [
        cp.sum(w) == 1,  # Tổng trọng số bằng 1
        w >= 0            # Không cho phép bán khống
    ]
    
    # Thêm ràng buộc về lợi nhuận mục tiêu nếu cần
    if target_return is not None:
        constraints.append(returns_mean @ w >= target_return)
    
    # Giải bài toán tối ưu
    problem = cp.Problem(objective, constraints)
    problem.solve()
    
    # Lấy kết quả
    optimal_weights = w.value
    expected_return = returns_mean.dot(optimal_weights)
    volatility = np.sqrt(optimal_weights.T @ cov_matrix @ optimal_weights)
    sharpe_ratio = (expected_return - risk_free_rate) / volatility
    
    return optimal_weights, expected_return, volatility, sharpe_ratio

def plot_theoretical_efficient_frontier(returns, risk_free_rate=0.0, points=100):
    """
    Vẽ đường biên hiệu quả lý thuyết
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_free_rate (float): Lãi suất phi rủi ro (annualized)
    points (int): Số điểm để vẽ đường biên hiệu quả
    """
    plt.figure(figsize=(12, 8))
    
    # Tính danh mục có độ biến động thấp nhất
    min_vol_weights, min_vol_return, min_vol_risk, _ = optimize_portfolio(returns, risk_free_rate, target_return=None)
    
    # Tính danh mục có tỷ lệ Sharpe cao nhất
    max_sharpe_weights, max_sharpe_return, max_sharpe_risk, max_sharpe = optimize_portfolio(returns, risk_free_rate)
    
    # Tính các danh mục tối ưu với lợi nhuận mục tiêu khác nhau
    target_returns = np.linspace(min_vol_return, max(returns.mean()) * 252 * 1.2, points)
    efficient_risk = []
    efficient_return = []
    
    for target in target_returns:
        try:
            weights, ret, risk, _ = optimize_portfolio(returns, risk_free_rate, target_return=target)
            efficient_risk.append(risk)
            efficient_return.append(ret)
        except:
            pass
    
    # Vẽ đường biên hiệu quả
    plt.plot(efficient_risk, efficient_return, 'b-', linewidth=3, label='Đường biên hiệu quả')
    
    # Đánh dấu danh mục có độ biến động thấp nhất
    plt.scatter(min_vol_risk, min_vol_return, marker='*', color='g', s=500, 
                label='Danh mục có độ biến động thấp nhất')
    
    # Đánh dấu danh mục có tỷ lệ Sharpe cao nhất
    plt.scatter(max_sharpe_risk, max_sharpe_return, marker='*', color='r', s=500, 
                label='Danh mục tối ưu theo Sharpe')
    
    # Vẽ đường CML (Capital Market Line)
    x_cml = np.linspace(0, max(efficient_risk) * 1.2, 100)
    y_cml = risk_free_rate + x_cml * (max_sharpe_return - risk_free_rate) / max_sharpe_risk
    plt.plot(x_cml, y_cml, 'r--', label='CML')
    
    # Đánh dấu cổ phiếu riêng lẻ
    for i, ticker in enumerate(returns.columns):
        individual_return = returns.mean()[i] * 252
        individual_volatility = returns.std()[i] * np.sqrt(252)
        plt.scatter(individual_volatility, individual_return, marker='o', s=200,
                   color='black')
        plt.annotate(ticker, (individual_volatility, individual_return),
                    xytext=(10, 5), textcoords='offset points')
    
    # Thêm title và label
    plt.title('Đường biên hiệu quả lý thuyết', fontsize=16)
    plt.xlabel('Độ biến động (Rủi ro)', fontsize=14)
    plt.ylabel('Lợi nhuận kỳ vọng', fontsize=14)
    plt.legend()
    
    # Hiển thị thông tin về danh mục tối ưu
    print("Danh mục tối ưu theo tỷ lệ Sharpe:")
    print(f"Lợi nhuận kỳ vọng: {max_sharpe_return:.4f}")
    print(f"Độ biến động: {max_sharpe_risk:.4f}")
    print(f"Tỷ lệ Sharpe: {max_sharpe:.4f}")
    print("\nPhân bổ vốn:")
    for i, ticker in enumerate(returns.columns):
        print(f"{ticker}: {max_sharpe_weights[i] * 100:.2f}%")
    
    plt.tight_layout()