6 posts tagged with "quantitative-trading"

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

# Tính toán lợi nhuận
def calculate_returns(portfolio_values):
    returns = portfolio_values.pct_change()
    return returns

# Ví dụ
portfolio_values = pd.Series([100, 105, 110, 108, 115])
returns = calculate_returns(portfolio_values)
print("Lợi nhuận hàng ngày:")
print(returns)

def calculate_volatility(returns, annualization_factor=252):
    volatility = returns.std() * np.sqrt(annualization_factor)
    return volatility

# Ví dụ
volatility = calculate_volatility(returns)
print(f"\nĐộ biến động hàng năm: {volatility:.2%}")

def calculate_sharpe_ratio(returns, risk_free_rate=0.02, annualization_factor=252):
    excess_returns = returns - risk_free_rate/annualization_factor
    sharpe_ratio = np.sqrt(annualization_factor) * excess_returns.mean() / returns.std()
    return sharpe_ratio

# Ví dụ
sharpe = calculate_sharpe_ratio(returns)
print(f"\nTỷ số Sharpe: {sharpe:.2f}")

def calculate_sortino_ratio(returns, risk_free_rate=0.02, annualization_factor=252):
    excess_returns = returns - risk_free_rate/annualization_factor
    downside_returns = returns[returns < 0]
    sortino_ratio = np.sqrt(annualization_factor) * excess_returns.mean() / downside_returns.std()
    return sortino_ratio

# Ví dụ
sortino = calculate_sortino_ratio(returns)
print(f"\nTỷ số Sortino: {sortino:.2f}")

def calculate_drawdown(portfolio_values):
    rolling_max = portfolio_values.expanding().max()
    drawdown = (portfolio_values - rolling_max) / rolling_max
    return drawdown

# Ví dụ
drawdown = calculate_drawdown(portfolio_values)
print("\nDrawdown:")
print(drawdown)

def calculate_var(returns, confidence_level=0.95):
    var = np.percentile(returns, (1 - confidence_level) * 100)
    return var

# Ví dụ
var_95 = calculate_var(returns)
print(f"\nVaR 95%: {var_95:.2%}")

def analyze_performance_by_time(returns):
    # Phân tích theo tháng
    monthly_returns = returns.resample('M').mean()
    # Phân tích theo quý
    quarterly_returns = returns.resample('Q').mean()
    # Phân tích theo năm
    yearly_returns = returns.resample('Y').mean()
    
    return monthly_returns, quarterly_returns, yearly_returns

# Ví dụ
monthly, quarterly, yearly = analyze_performance_by_time(returns)
print("\nLợi nhuận theo tháng:")
print(monthly)

def analyze_correlation(returns, benchmark_returns):
    correlation = returns.corr(benchmark_returns)
    return correlation

# Ví dụ
benchmark_returns = pd.Series([0.01, 0.02, -0.01, 0.03, 0.01])
correlation = analyze_correlation(returns, benchmark_returns)
print(f"\nTương quan với benchmark: {correlation:.2f}")

def generate_performance_report(returns, portfolio_values):
    report = {
        'Tổng lợi nhuận': (portfolio_values[-1] / portfolio_values[0] - 1),
        'Lợi nhuận trung bình': returns.mean(),
        'Độ biến động': returns.std(),
        'Tỷ số Sharpe': calculate_sharpe_ratio(returns),
        'Tỷ số Sortino': calculate_sortino_ratio(returns),
        'VaR 95%': calculate_var(returns),
        'Drawdown tối đa': calculate_drawdown(portfolio_values).min()
    }
    return report

# Ví dụ
report = generate_performance_report(returns, portfolio_values)
print("\nBáo cáo hiệu suất:")
for metric, value in report.items():
    print(f"{metric}: {value:.2%}")

def plot_performance(portfolio_values, benchmark_values=None):
    plt.figure(figsize=(12, 6))
    plt.plot(portfolio_values.index, portfolio_values, label='Portfolio')
    if benchmark_values is not None:
        plt.plot(benchmark_values.index, benchmark_values, label='Benchmark')
    plt.title('Hiệu suất danh mục')
    plt.xlabel('Thời gian')
    plt.ylabel('Giá trị')
    plt.legend()
    plt.grid(True)
    plt.show()

# Ví dụ
plot_performance(portfolio_values)

def plot_returns_distribution(returns):
    plt.figure(figsize=(12, 6))
    sns.histplot(returns, kde=True)
    plt.title('Phân phối lợi nhuận')
    plt.xlabel('Lợi nhuận')
    plt.ylabel('Tần suất')
    plt.show()

# Ví dụ
plot_returns_distribution(returns)

class MarketConnector:
    def __init__(self, exchange_config):
        self.exchange = self.initialize_exchange(exchange_config)
        self.data_feeds = {}
        self.order_router = None
    
    def initialize_exchange(self, config):
        """Khởi tạo kết nối với sàn giao dịch"""
        try:
            exchange = ccxt.create_market(
                config['exchange'],
                {
                    'apiKey': config['api_key'],
                    'secret': config['api_secret'],
                    'enableRateLimit': True
                }
            )
            return exchange
        except Exception as e:
            self.log_error(f"Failed to initialize exchange: {e}")
            return None
    
    def setup_data_feeds(self, symbols, timeframes):
        """Thiết lập các luồng dữ liệu"""
        for symbol in symbols:
            for timeframe in timeframes:
                feed = self.create_data_feed(symbol, timeframe)
                self.data_feeds[f"{symbol}_{timeframe}"] = feed

class OrderManager:
    def __init__(self, exchange):
        self.exchange = exchange
        self.active_orders = {}
        self.order_history = []
    
    def place_order(self, symbol, order_type, side, amount, price=None):
        """Đặt lệnh giao dịch"""
        try:
            order = self.exchange.create_order(
                symbol=symbol,
                type=order_type,
                side=side,
                amount=amount,
                price=price
            )
            
            self.active_orders[order['id']] = order
            self.order_history.append(order)
            
            return order
        except Exception as e:
            self.log_error(f"Failed to place order: {e}")
            return None
    
    def cancel_order(self, order_id):
        """Hủy lệnh giao dịch"""
        try:
            result = self.exchange.cancel_order(order_id)
            if order_id in self.active_orders:
                del self.active_orders[order_id]
            return result
        except Exception as e:
            self.log_error(f"Failed to cancel order: {e}")
            return None

class SignalProcessor:
    def __init__(self, strategy):
        self.strategy = strategy
        self.signal_queue = Queue()
        self.signal_history = []
    
    def process_market_data(self, data):
        """Xử lý dữ liệu thị trường và tạo tín hiệu"""
        try:
            # Áp dụng chiến lược
            signal = self.strategy.generate_signal(data)
            
            # Kiểm tra tính hợp lệ của tín hiệu
            if self.validate_signal(signal):
                self.signal_queue.put(signal)
                self.signal_history.append(signal)
            
            return signal
        except Exception as e:
            self.log_error(f"Error processing market data: {e}")
            return None
    
    def validate_signal(self, signal):
        """Kiểm tra tính hợp lệ của tín hiệu"""
        # Kiểm tra các điều kiện
        if not signal:
            return False
        
        if signal['type'] not in ['buy', 'sell']:
            return False
        
        if signal['amount'] <= 0:
            return False
        
        return True

class PositionManager:
    def __init__(self, exchange):
        self.exchange = exchange
        self.positions = {}
        self.position_history = []
    
    def update_positions(self):
        """Cập nhật thông tin vị thế"""
        try:
            positions = self.exchange.fetch_positions()
            for position in positions:
                symbol = position['symbol']
                self.positions[symbol] = position
            return positions
        except Exception as e:
            self.log_error(f"Error updating positions: {e}")
            return None
    
    def calculate_position_size(self, signal, account_balance):
        """Tính toán kích thước vị thế"""
        risk_per_trade = 0.02  # 2% rủi ro mỗi giao dịch
        max_position_size = account_balance * risk_per_trade
        
        return min(signal['amount'], max_position_size)

class PositionLimiter:
    def __init__(self, max_position_size, max_leverage):
        self.max_position_size = max_position_size
        self.max_leverage = max_leverage
    
    def check_position_limit(self, symbol, size, price):
        """Kiểm tra giới hạn vị thế"""
        position_value = size * price
        
        # Kiểm tra kích thước vị thế
        if position_value > self.max_position_size:
            return False
        
        # Kiểm tra đòn bẩy
        leverage = position_value / self.get_account_equity()
        if leverage > self.max_leverage:
            return False
        
        return True

class StopLossManager:
    def __init__(self, max_loss_percent):
        self.max_loss_percent = max_loss_percent
        self.stop_orders = {}
    
    def place_stop_loss(self, position, entry_price):
        """Đặt lệnh stop loss"""
        if position['side'] == 'long':
            stop_price = entry_price * (1 - self.max_loss_percent)
        else:
            stop_price = entry_price * (1 + self.max_loss_percent)
        
        stop_order = self.place_order(
            position['symbol'],
            'stop',
            'sell' if position['side'] == 'long' else 'buy',
            position['amount'],
            stop_price
        )
        
        self.stop_orders[position['id']] = stop_order

class PerformanceMonitor:
    def __init__(self):
        self.metrics = {}
        self.alerts = []
    
    def track_performance(self, portfolio):
        """Theo dõi hiệu suất giao dịch"""
        # Tính toán các chỉ số
        self.metrics['total_return'] = self.calculate_total_return(portfolio)
        self.metrics['sharpe_ratio'] = self.calculate_sharpe_ratio(portfolio)
        self.metrics['max_drawdown'] = self.calculate_max_drawdown(portfolio)
        
        # Kiểm tra các ngưỡng cảnh báo
        self.check_alert_thresholds()
    
    def check_alert_thresholds(self):
        """Kiểm tra các ngưỡng cảnh báo"""
        if self.metrics['max_drawdown'] > 0.1:  # 10% drawdown
            self.alerts.append({
                'type': 'drawdown',
                'value': self.metrics['max_drawdown'],
                'timestamp': datetime.now()
            })

class ErrorHandler:
    def __init__(self):
        self.error_log = []
        self.recovery_procedures = {}
    
    def handle_error(self, error, context):
        """Xử lý lỗi hệ thống"""
        error_record = {
            'error': str(error),
            'context': context,
            'timestamp': datetime.now()
        }
        
        self.error_log.append(error_record)
        
        # Thực hiện quy trình khôi phục
        if error.type in self.recovery_procedures:
            self.recovery_procedures[error.type](error, context)
        
        # Gửi cảnh báo
        self.send_error_alert(error_record)

class DataCollector:
    def __init__(self):
        self.data_sources = {}
    
    def fetch_historical_data(self, symbol, timeframe, start_date, end_date):
        """Thu thập dữ liệu lịch sử"""
        data = pd.DataFrame()
        
        for source in self.data_sources.values():
            try:
                source_data = source.get_historical_data(
                    symbol, timeframe, start_date, end_date
                )
                data = pd.concat([data, source_data])
            except Exception as e:
                self.log_error(f"Error fetching data from {source}: {e}")
        
        return data.drop_duplicates()
    
    def validate_data(self, data):
        """Kiểm tra tính hợp lệ của dữ liệu"""
        # Kiểm tra missing values
        missing = data.isnull().sum()
        
        # Kiểm tra outliers
        outliers = self.detect_outliers(data)
        
        # Kiểm tra tính liên tục của dữ liệu
        gaps = self.find_data_gaps(data)
        
        return {
            'missing': missing,
            'outliers': outliers,
            'gaps': gaps
        }

class DataProcessor:
    def __init__(self):
        self.processors = {}
    
    def clean_data(self, data):
        """Làm sạch dữ liệu"""
        # Xử lý missing values
        data = self.handle_missing_values(data)
        
        # Xử lý outliers
        data = self.handle_outliers(data)
        
        # Chuẩn hóa dữ liệu
        data = self.normalize_data(data)
        
        return data
    
    def engineer_features(self, data):
        """Tạo các đặc trưng mới"""
        features = pd.DataFrame()
        
        # Tính toán các chỉ báo kỹ thuật
        features['sma'] = self.calculate_sma(data)
        features['rsi'] = self.calculate_rsi(data)
        features['macd'] = self.calculate_macd(data)
        
        # Tạo các đặc trưng thống kê
        features['returns'] = self.calculate_returns(data)
        features['volatility'] = self.calculate_volatility(data)
        
        return features

class SignalGenerator:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def generate_signals(self, data):
        """Tạo tín hiệu giao dịch"""
        signals = pd.DataFrame(index=data.index)
        
        # Áp dụng chiến lược
        signals['position'] = self.strategy.apply(data)
        
        # Tạo tín hiệu mua/bán
        signals['signal'] = signals['position'].diff()
        
        return signals
    
    def validate_signals(self, signals):
        """Kiểm tra tính hợp lệ của tín hiệu"""
        # Kiểm tra tín hiệu trùng lặp
        duplicate_signals = self.find_duplicate_signals(signals)
        
        # Kiểm tra tín hiệu đối lập
        conflicting_signals = self.find_conflicting_signals(signals)
        
        return {
            'duplicates': duplicate_signals,
            'conflicts': conflicting_signals
        }

class TradeSimulator:
    def __init__(self, initial_capital):
        self.initial_capital = initial_capital
        self.positions = {}
        self.trades = []
    
    def execute_trades(self, signals, data):
        """Mô phỏng thực hiện giao dịch"""
        portfolio = pd.DataFrame(index=signals.index)
        portfolio['capital'] = self.initial_capital
        
        for timestamp, signal in signals.iterrows():
            if signal['signal'] != 0:
                # Thực hiện giao dịch
                trade = self.execute_trade(
                    timestamp,
                    signal['signal'],
                    data.loc[timestamp]
                )
                self.trades.append(trade)
            
            # Cập nhật vốn
            portfolio.loc[timestamp, 'capital'] = self.calculate_portfolio_value(
                timestamp, data
            )
        
        return portfolio

class PerformanceAnalyzer:
    def __init__(self):
        self.metrics = {}
    
    def calculate_returns(self, portfolio):
        """Tính toán các chỉ số lợi nhuận"""
        returns = pd.Series(index=portfolio.index)
        
        # Tổng lợi nhuận
        returns['total_return'] = (
            portfolio['capital'].iloc[-1] / portfolio['capital'].iloc[0] - 1
        )
        
        # Lợi nhuận hàng năm
        returns['annual_return'] = self.calculate_annual_return(portfolio)
        
        # Tỷ lệ Sharpe
        returns['sharpe_ratio'] = self.calculate_sharpe_ratio(portfolio)
        
        return returns
    
    def analyze_drawdowns(self, portfolio):
        """Phân tích drawdown"""
        # Tính toán drawdown
        drawdown = self.calculate_drawdown(portfolio)
        
        # Phân tích thống kê
        stats = {
            'max_drawdown': drawdown.min(),
            'avg_drawdown': drawdown.mean(),
            'drawdown_duration': self.calculate_drawdown_duration(drawdown)
        }
        
        return stats

class RiskAnalyzer:
    def __init__(self):
        self.risk_metrics = {}
    
    def calculate_risk_metrics(self, portfolio):
        """Tính toán các chỉ số rủi ro"""
        metrics = {}
        
        # Độ biến động
        metrics['volatility'] = self.calculate_volatility(portfolio)
        
        # Value at Risk
        metrics['var'] = self.calculate_var(portfolio)
        
        # Expected Shortfall
        metrics['expected_shortfall'] = self.calculate_expected_shortfall(portfolio)
        
        return metrics
    
    def analyze_risk_attribution(self, portfolio):
        """Phân tích nguồn gốc rủi ro"""
        # Phân tích rủi ro theo tài sản
        asset_risk = self.analyze_asset_risk(portfolio)
        
        # Phân tích rủi ro theo yếu tố
        factor_risk = self.analyze_factor_risk(portfolio)
        
        return {
            'asset_risk': asset_risk,
            'factor_risk': factor_risk
        }

class ParameterOptimizer:
    def __init__(self, strategy):
        self.strategy = strategy
        self.optimization_methods = {}
    
    def optimize_parameters(self, data, param_grid):
        """Tối ưu hóa tham số"""
        results = []
        
        for params in self.generate_param_combinations(param_grid):
            # Chạy backtest với bộ tham số
            performance = self.run_backtest(data, params)
            
            # Đánh giá hiệu suất
            score = self.evaluate_performance(performance)
            
            results.append({
                'params': params,
                'score': score,
                'performance': performance
            })
        
        return self.select_best_parameters(results)
    
    def validate_optimization(self, results):
        """Kiểm tra tính hợp lệ của kết quả tối ưu"""
        # Kiểm tra overfitting
        overfitting = self.check_overfitting(results)
        
        # Kiểm tra tính ổn định
        stability = self.check_parameter_stability(results)
        
        return {
            'overfitting': overfitting,
            'stability': stability
        }

class WalkForwardAnalyzer:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def perform_walk_forward_analysis(self, data, window_size):
        """Thực hiện phân tích walk-forward"""
        results = []
        
        for i in range(len(data) - window_size):
            # Chia dữ liệu
            train_data = data.iloc[i:i+window_size]
            test_data = data.iloc[i+window_size:i+window_size+1]
            
            # Tối ưu hóa trên tập train
            optimal_params = self.optimize_parameters(train_data)
            
            # Kiểm tra trên tập test
            performance = self.test_strategy(test_data, optimal_params)
            
            results.append({
                'train_period': train_data.index,
                'test_period': test_data.index,
                'params': optimal_params,
                'performance': performance
            })
        
        return self.analyze_walk_forward_results(results)

class MetricsCollector:
    def __init__(self):
        self.metrics = {
            'trading': {},
            'system': {},
            'performance': {}
        }
    
    def collect_trading_metrics(self):
        # Thu thập metrics giao dịch
        self.metrics['trading'].update({
            'open_positions': self.get_open_positions(),
            'daily_pnl': self.calculate_daily_pnl(),
            'win_rate': self.calculate_win_rate()
        })
    
    def collect_system_metrics(self):
        # Thu thập metrics hệ thống
        self.metrics['system'].update({
            'cpu_usage': psutil.cpu_percent(),
            'memory_usage': psutil.virtual_memory().percent,
            'disk_usage': psutil.disk_usage('/').percent
        })

import logging
from logging.handlers import RotatingFileHandler

class LogManager:
    def __init__(self, log_file='trading_bot.log'):
        self.logger = logging.getLogger('TradingBot')
        self.logger.setLevel(logging.INFO)
        
        # File handler
        file_handler = RotatingFileHandler(
            log_file,
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5
        )
        
        # Format
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        file_handler.setFormatter(formatter)
        
        self.logger.addHandler(file_handler)

import dash
from dash import dcc, html
import plotly.graph_objs as go

class TradingDashboard:
    def __init__(self):
        self.app = dash.Dash(__name__)
        
        self.app.layout = html.Div([
            html.H1('Trading Bot Dashboard'),
            
            # PnL Chart
            dcc.Graph(id='pnl-chart'),
            
            # System Metrics
            dcc.Graph(id='system-metrics'),
            
            # Trading Metrics
            dcc.Graph(id='trading-metrics'),
            
            # Auto-refresh
            dcc.Interval(
                id='interval-component',
                interval=60*1000,  # 60 seconds
                n_intervals=0
            )
        ])
    
    def update_charts(self):
        # Cập nhật biểu đồ
        self.app.callback(
            [Output('pnl-chart', 'figure'),
             Output('system-metrics', 'figure'),
             Output('trading-metrics', 'figure')],
            [Input('interval-component', 'n_intervals')]
        )(self._update_charts)

class AlertSystem:
    def __init__(self):
        self.alert_levels = {
            'info': 0,
            'warning': 1,
            'error': 2,
            'critical': 3
        }
        self.alert_channels = {
            'email': self.send_email_alert,
            'telegram': self.send_telegram_alert,
            'slack': self.send_slack_alert
        }
    
    def check_alerts(self, metrics):
        # Kiểm tra các ngưỡng
        for metric, value in metrics.items():
            if self.is_threshold_breached(metric, value):
                self.trigger_alert(metric, value)
    
    def trigger_alert(self, metric, value):
        # Gửi cảnh báo qua các kênh
        alert_message = self.format_alert_message(metric, value)
        for channel, send_func in self.alert_channels.items():
            send_func(alert_message)

class ReportGenerator:
    def __init__(self):
        self.template = self.load_template()
    
    def generate_daily_report(self):
        # Thu thập dữ liệu
        trading_data = self.collect_trading_data()
        performance_data = self.collect_performance_data()
        
        # Tạo báo cáo
        report = {
            'date': datetime.now().strftime('%Y-%m-%d'),
            'trading_summary': self.summarize_trading(trading_data),
            'performance_metrics': self.calculate_metrics(performance_data),
            'charts': self.generate_charts(trading_data)
        }
        
        return report

class PerformanceAnalyzer:
    def analyze_performance(self, data):
        # Tính toán các chỉ số
        metrics = {
            'total_return': self.calculate_total_return(data),
            'sharpe_ratio': self.calculate_sharpe_ratio(data),
            'max_drawdown': self.calculate_max_drawdown(data),
            'win_rate': self.calculate_win_rate(data)
        }
        
        # Phân tích rủi ro
        risk_metrics = {
            'var': self.calculate_var(data),
            'expected_shortfall': self.calculate_expected_shortfall(data),
            'beta': self.calculate_beta(data)
        }
        
        return {**metrics, **risk_metrics}

class DatabaseManager:
    def __init__(self, db_url):
        self.engine = create_engine(db_url)
        self.Session = sessionmaker(bind=self.engine)
    
    def store_metrics(self, metrics):
        session = self.Session()
        try:
            metric_record = MetricsRecord(
                timestamp=datetime.now(),
                metrics=metrics
            )
            session.add(metric_record)
            session.commit()
        finally:
            session.close()
    
    def query_metrics(self, start_date, end_date):
        session = self.Session()
        try:
            return session.query(MetricsRecord)\
                .filter(MetricsRecord.timestamp.between(start_date, end_date))\
                .all()
        finally:
            session.close()

class TradingBot:
    def __init__(self, api_key, api_secret, symbol):
        self.api_key = api_key
        self.api_secret = api_secret
        self.symbol = symbol
        self.position = None
        self.orders = []
        
    def connect(self):
        # Kết nối với sàn giao dịch
        self.exchange = ccxt.binance({
            'apiKey': self.api_key,
            'secret': self.api_secret
        })

    def check_connection(self):
        try:
            self.exchange.fetch_balance()
            return True
        except Exception as e:
            log_error(f"Lỗi kết nối: {e}")
            return False
            
    def reconnect(self):
        max_attempts = 3
        for attempt in range(max_attempts):
            if self.check_connection():
                return True
            time.sleep(5)
        return False

    def fetch_market_data(self, timeframe='1m', limit=100):
        try:
            ohlcv = self.exchange.fetch_ohlcv(
                self.symbol,
                timeframe=timeframe,
                limit=limit
            )
            df = pd.DataFrame(
                ohlcv,
                columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
            )
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            return df
        except Exception as e:
            log_error(f"Lỗi lấy dữ liệu: {e}")
            return None

    def process_signals(self, data):
        # Áp dụng chiến lược giao dịch
        data = self.strategy.generate_signals(data)
        
        # Lọc tín hiệu mới nhất
        latest_signal = data['Signal'].iloc[-1]
        
        return latest_signal

    def place_order(self, side, amount, price=None):
        try:
            if price:
                order = self.exchange.create_limit_order(
                    self.symbol,
                    side,
                    amount,
                    price
                )
            else:
                order = self.exchange.create_market_order(
                    self.symbol,
                    side,
                    amount
                )
            
            self.orders.append(order)
            return order
        except Exception as e:
            log_error(f"Lỗi đặt lệnh: {e}")
            return None

    def manage_position(self, signal):
        if signal == 1 and not self.position:  # Tín hiệu mua
            amount = self.calculate_position_size()
            self.place_order('buy', amount)
            self.position = 'long'
            
        elif signal == -1 and self.position == 'long':  # Tín hiệu bán
            amount = self.get_position_size()
            self.place_order('sell', amount)
            self.position = None

    def check_market_conditions(self):
        # Kiểm tra biến động giá
        volatility = self.calculate_volatility()
        if volatility > self.max_volatility:
            return False
            
        # Kiểm tra thanh khoản
        liquidity = self.check_liquidity()
        if liquidity < self.min_liquidity:
            return False
            
        return True

    def manage_capital(self):
        # Tính toán vốn có sẵn
        balance = self.exchange.fetch_balance()
        available = balance['free'][self.base_currency]
        
        # Kiểm tra giới hạn rủi ro
        if available < self.min_capital:
            return False
            
        return True