27 posts tagged with "Python"

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

# Ví dụ chiến lược đơn giản với Python
def moving_average_strategy(prices, short_window=20, long_window=50):
    signals = pd.DataFrame(index=prices.index)
    signals['signal'] = 0.0
    
    # Tạo tín hiệu mua/bán
    signals['short_ma'] = prices.rolling(window=short_window).mean()
    signals['long_ma'] = prices.rolling(window=long_window).mean()
    
    # Tạo tín hiệu (1: mua, 0: không hành động, -1: bán)
    signals['signal'][short_window:] = np.where(
        signals['short_ma'][short_window:] > signals['long_ma'][short_window:], 1.0, 0.0)
    signals['positions'] = signals['signal'].diff()
    
    return signals

# Thu thập dữ liệu
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from backtrader import Cerebro, Strategy

# Lấy dữ liệu
data = yf.download('AAPL', start='2020-01-01', end='2022-12-31')

# Thêm chỉ báo kỹ thuật
data['SMA20'] = data['Close'].rolling(window=20).mean()
data['SMA50'] = data['Close'].rolling(window=50).mean()
data['RSI'] = calculate_rsi(data['Close'], 14)  # Hàm tự định nghĩa

# Trực quan hóa
plt.figure(figsize=(12, 6))
plt.plot(data.index, data['Close'], label='AAPL')
plt.plot(data.index, data['SMA20'], label='SMA20')
plt.plot(data.index, data['SMA50'], label='SMA50')
plt.legend()
plt.show()

# Mô hình học máy
X = data[['SMA20', 'SMA50', 'RSI']].dropna()
y = (data['Close'].shift(-1) > data['Close']).dropna().astype(int)
model = RandomForestClassifier()
model.fit(X[:-30], y[:-30])
predictions = model.predict(X[-30:])

# Backtesting với Backtrader
# (Mã triển khai Strategy và Cerebro)