| Bài 8: Xử lý dữ liệu lớn (Big Data): Tối ưu hóa Database tài chính tại HNData

Vì sao dữ liệu sạch là lợi thế cạnh tranh tuyệt đối?

Mọi thuật toán, mọi mô hình AI, mọi chiến lược đều chạy trên dữ liệu. Nếu dữ liệu bẩn (sai, thiếu, trùng, có outliers), kết quả phân tích sẽ sai dù thuật toán tốt đến đâu. Trong Algo Trading, “rác vào — rác ra” (garbage in, garbage out).

Quy trình xử lý Big Data tài chính

1. Data Cleaning

Loại bỏ các điểm dữ liệu dị thường (outliers), xử lý giá trị thiếu (missing), chuẩn hóa định dạng. Ví dụ: loại tick giá âm, giá nhảy bất thường do lỗi nguồn.

2. Storage

Lưu trữ dữ liệu Tick thực quy mô lớn một cách khoa học — dùng cơ sở dữ liệu tối ưu (TimescaleDB, InfluxDB), nén dữ liệu, đánh index hợp lý để truy xuất nhanh.

3. Performance

Nâng cao tốc độ truy xuất dữ liệu để tối ưu hóa quá trình Backtest. Backtest càng nhanh, bạn càng thử được nhiều ý tưởng và tìm được chiến lược tốt hơn.

Bảng so sánh dữ liệu sạch vs bẩn

Tiêu chí	Dữ liệu sạch	Dữ liệu bẩn
Độ tin cậy	Cao	Thấp, dễ sai lệch
Backtest	Kết quả đáng tin	Kết quả “đẹp giả”
Model AI	Học đúng	Học sai, dự báo sai
Quyết định	Tự tin	Rủi ro

Kết luận

Sở hữu dữ liệu sạch chính là sở hữu lợi thế cạnh tranh tuyệt đối. Hãy đầu tư vào quy trình dữ liệu ngay từ đầu để nền tảng trading của bạn vững chắc.

---

📊 Vì Sao Dữ Liệu Sạch Là Lợi Thế Cạnh Tranh Tuyệt Đối?

Mọi thuật toán, mọi mô hình AI, mọi chiến lược đều chạy trên dữ liệu. Nếu dữ liệu bẩn (sai, thiếu, trùng, có outliers), kết quả phân tích sẽ sai dù thuật toán tốt đến đâu. Trong Algo Trading, “rác vào — rác ra” (garbage in, garbage out) là quy luật bất biến.

Algo Trading chuyên nghiệp bắt đầu từ dữ liệu sạch. Tại Hướng Nghiệp Dữ Liệu, chúng tôi nhấn mạnh quy trình xử lý Big Data gồm ba trụ cột: Data Cleaning, Storage, và Performance.

Tiêu chí	Dữ liệu sạch	Dữ liệu bẩn
Độ tin cậy	Cao	Thấp, dễ sai lệch
Backtest	Kết quả đáng tin	Kết quả “đẹp giả”
Model AI	Học đúng	Học sai, dự báo sai
Quyết định	Tự tin	Rủi ro

🧹 1. Data Cleaning — Loại Bỏ Dữ Liệu Dị Thường

Data Cleaning là bước đầu tiên và quan trọng nhất. Mục tiêu: loại bỏ các điểm dữ liệu dị thường (outliers), xử lý giá trị thiếu (missing), chuẩn hóa định dạng.

# [DATA CLEANING - PYTHON]
import pandas as pd

def clean_tick_data(df):
    # 1. Loại bỏ giá âm hoặc bằng 0 (lỗi nguồn)
    df = df[(df["price"] > 0)]

    # 2. Loại bỏ giá nhảy bất thường (outlier)
    # Tick giá thay đổi quá 10% so với tick trước = lỗi
    df["pct_change"] = df["price"].pct_change()
    df = df[df["pct_change"].abs() < 0.10]

    # 3. Xử lý giá trị thiếu (missing)
    df = df.dropna(subset=["price", "volume"])

    # 4. Loại bỏ trùng lặp (duplicate timestamps)
    df = df.drop_duplicates(subset=["timestamp"])

    # 5. Chuẩn hóa định dạng thời gian
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df = df.sort_values("timestamp").reset_index(drop=True)

    return df

Ví dụ cụ thể: loại tick giá âm, giá nhảy bất thường do lỗi nguồn, timestamp trùng lặp do kết nối bị ngắt.

📚 2. Storage — Lưu Trữ Dữ Liệu Tick Quy Mô Lớn

Lưu trữ dữ liệu Tick thực quy mô lớn một cách khoa học — dùng cơ sở dữ liệu tối ưu (TimescaleDB, InfluxDB), nén dữ liệu, đánh index hợp lý để truy xuất nhanh.

So Sánh Các Giải Pháp Lưu Trữ

Giải pháp	Loại	Phù hợp
TimescaleDB	PostgreSQL + Time-series	Dữ liệu Tick, OHLC lớn
InfluxDB	Time-series chuyên dụng	Monitoring, metrics
ClickHouse	Columnar OLAP	Phân tích lớn, backtest nhanh
SQLite	File-based	Thử nghiệm nhỏ, offline
Parquet + DuckDB	File + query engine	Backtest, phân tích local

# [LƯU TRỮ TICK DATA - TIMESCALEDB/POSTGRES]
# Tạo bảng hypertable cho tick data
CREATE TABLE tick_data (
    symbol    TEXT,
    timestamp TIMESTAMPTZ,
    price     DOUBLE PRECISION,
    volume    DOUBLE PRECISION
);

-- Chuyển thành hypertable (TimescaleDB)
SELECT create_hypertable('tick_data', 'timestamp');

-- Index theo symbol + timestamp để truy xuất nhanh
CREATE INDEX idx_symbol_time ON tick_data (symbol, timestamp DESC);

⚡ 3. Performance — Tăng Tốc Truy Xuất Dữ Liệu

Nâng cao tốc độ truy xuất dữ liệu để tối ưu hóa quá trình Backtest. Backtest càng nhanh, bạn càng thử được nhiều ý tưởng và tìm được chiến lược tốt hơn.

# [TRUY XUẤT NHANH - PYTHON]
# Truy vấn dữ liệu trong khoảng thời gian (đã index)
SELECT symbol, timestamp, price
FROM tick_data
WHERE symbol = 'XAUUSD'
  AND timestamp BETWEEN '2026-01-01' AND '2026-01-31'
ORDER BY timestamp;

# Với TimescaleDB: time_bucket để giảm lượng dữ liệu
SELECT time_bucket('1 minute', timestamp) AS bucket,
       AVG(price) AS avg_price
FROM tick_data
WHERE symbol = 'XAUUSD'
GROUP BY bucket
ORDER BY bucket;

🔧 Xử Lý Dữ Liệu Thiếu (Missing Data) Đúng Cách

Trong dữ liệu tài chính thực tế, giá trị thiếu rất phổ biến (ngày nghỉ, giờ nghỉ, lỗi nguồn). Cách xử lý quyết định chất lượng backtest:

• Forward fill: Điền giá trị trước đó — phù hợp dữ liệu giá.
• Linear interpolation: Nội suy tuyến tính giữa hai điểm.
• Drop: Bỏ hàng thiếu — dùng khi thiếu không đáng kể.
• Không tự ý bịa: Dữ liệu giả tạo sẽ làm sai kết quả.

# [XỬ LÝ MISSING - PYTHON]
def handle_missing(df):
    # Forward fill cho giá đóng cửa
    df["close"] = df["close"].ffill()

    # Interpolation cho các cột khác
    df["volume"] = df["volume"].interpolate()

    # Kiểm tra còn thiếu không
    print("Còn NaN:", df.isna().sum().sum())
    return df

📉 Phát Hiện Và Xử Lý Outliers

Outliers (điểm dị thường) có thể do lỗi nguồn hoặc sự kiện thật (tin lớn, flash crash). Phân biệt hai loại này rất quan trọng:

# [PHÁT HIỆN OUTLIERS - PYTHON]
def detect_outliers(series, z_thresh=3):
    # Dùng Z-score để tìm outliers
    mean = series.mean()
    std = series.std()
    z = (series - mean) / std

    # Đánh dấu outliers (|z| > 3)
    return z.abs() > z_thresh

# Lọc bỏ outliers do lỗi (nhảy giá bất thường)
outliers = detect_outliers(df["price"])
df_clean = df[~outliers]
print(f"Loại bỏ {outliers.sum()} điểm dị thường")

🚀 Tối Ưu Hóa Database Tại HNData

Tại HNData, quy trình xử lý Big Data được chuẩn hóa thành pipeline tự động: thu thập → làm sạch → lưu trữ → đánh index → truy xuất. Mỗi bước đều được đo lường và tối ưu liên tục.

1. Thu thập: Streaming từ broker/API (MT5, Binance).
2. Làm sạch: Loại bỏ outliers, xử lý missing, chuẩn hóa.
3. Lưu trữ: TimescaleDB/ClickHouse với nén + index.
4. Đánh index: Tối ưu truy vấn theo symbol + time.
5. Truy xuất: API phục vụ backtest và model AI.

💡 Góc Nhìn Thực Chiến

Sở hữu dữ liệu sạch chính là sở hữu lợi thế cạnh tranh tuyệt đối. Hãy đầu tư vào quy trình dữ liệu ngay từ đầu để nền tảng trading của bạn vững chắc. Một trader có dữ liệu sạch + chiến lược tốt sẽ luôn vượt qua trader có chiến lược hay nhưng dữ liệu bẩn.

• Backtest đáng tin: Kết quả phản ánh đúng thực tế.
• Model AI học đúng: Dự báo chính xác hơn.
• Quyết định tự tin: Giảm rủi ro, tăng hiệu quả.

❓ Câu Hỏi Thường Gặp

Hỏi: Dữ liệu Tick khác dữ liệu OHLC thế nào?
Tick là từng giao dịch (hàng triệu/ngày), OHLC là nến tổng hợp (vài nghìn/ngày). Tick chi tiết hơn nhưng tốn bộ nhớ hơn nhiều.

Hỏi: Cần lưu dữ liệu Tick bao lâu?
Tùy chiến lược. Backtest dài hạn cần 5-10 năm. Lưu trữ đầy đủ rồi nén cũ giúp tiết kiệm chi phí.

Hỏi: TimescaleDB có miễn phí không?
Có bản cộng đồng (open-source). Phù hợp người mới bắt đầu.

Hỏi: Học xử lý dữ liệu tài chính ở đâu?
Tại Hướng Nghiệp Dữ Liệu — chuỗi bài Algo Trading và Big Data thực chiến, được Thầy Đặng Trí Thanh hướng dẫn.

---

🚀 Làm chủ Big Data tài chính: Tham gia khóa học tại Hướng Nghiệp Dữ Liệu để xây dựng pipeline dữ liệu chuyên nghiệp cho hệ thống trading của bạn.

🚀 Quy Trình Xử Lý Big Data Tài Chính Tại HNData

Tại Hướng Nghiệp Dữ Liệu, quy trình xử lý Big Data được chuẩn hóa thành pipeline tự động, đảm bảo dữ liệu luôn sạch, nhanh và đáng tin cậy. Toàn bộ quy trình gồm 5 bước: thu thập, làm sạch, lưu trữ, đánh index, và truy xuất.

1. Thu thập (Ingestion): Kéo dữ liệu từ broker, API, MT5.
2. Làm sạch (Cleaning): Loại outliers, xử lý missing, chuẩn hóa.
3. Lưu trữ (Storage): TimescaleDB/ClickHouse với nén + index.
4. Đánh index (Indexing): Tối ưu truy vấn theo symbol + time.
5. Truy xuất (Query): API phục vụ backtest và AI.

📊 So Sánh Chi Tiết Các Cơ Sở Dữ Liệu Thời Gian

Tiêu chí	TimescaleDB	InfluxDB	ClickHouse
Loại	PostgreSQL + extension	Time-series DBMS	Columnar OLAP
Ngôn ngữ	SQL chuẩn	InfluxQL/Flux	SQL
Hiệu năng ghi	Tốt	Rất tốt	Rất tốt
Hiệu năng đọc	Tốt	Khá	Xuất sắc (aggregation)
Phù hợp	Backtest, phân tích	Monitoring, metrics	Phân tích lớn, BI
Độ phức tạp	Trung bình	Thấp	Cao

Khuyến nghị: người mới nên bắt đầu với TimescaleDB (dùng SQL quen thuộc), chuyển sang ClickHouse khi khối lượng dữ liệu rất lớn.

🧹 Kỹ Thuật Làm Sạch Dữ Liệu Tick Nâng Cao

Dữ liệu Tick có đặc thù: khối lượng khổng lồ (hàng triệu/ngày), nhiễu cao, dễ bị trùng do mất kết nối. Các kỹ thuật làm sạch nâng cao:

# [LÀM SẠCH TICK NÂNG CAO - PYTHON]
def clean_tick_advanced(ticks):
    # 1. Loại tick trùng timestamp (cùng symbol, cùng giá, cùng volume)
    ticks = ticks.drop_duplicates(
        subset=["symbol", "timestamp", "price", "volume"])

    # 2. Loại tick giá ngoài khoảng hợp lý (flash spike)
    for symbol, grp in ticks.groupby("symbol"):
        median = grp["price"].median()
        mad = (grp["price"] - median).abs().median()
        if mad > 0:
            upper = median + 10 * 1.4826 * mad
            lower = median - 10 * 1.4826 * mad
            ticks = ticks[~((ticks["symbol"] == symbol) &
                            ((ticks["price"] > upper) |
                             (ticks["price"]  0]

    return ticks

📉 Chuyển Đổi Tick Thành OHLC — Bước Quan Trọng

Backtest thường dùng dữ liệu OHLC (nến) vì nhẹ và đủ thông tin. Chuyển từ Tick sang OHLC theo khung thời gian:

# [TICK -> OHLC - PYTHON]
def ticks_to_ohlc(ticks, timeframe="1min"):
    ticks = ticks.set_index("timestamp")

    # Resample theo khung thời gian
    ohlc = ticks["price"].resample(timeframe).ohlc()

    # Khối lượng tổng
    ohlc["volume"] = ticks["volume"].resample(timeframe).sum()

    # Loại bỏ nến không có dữ liệu
    ohlc = ohlc.dropna()
    return ohlc

# Ví dụ: 1 triệu tick XAUUSD -> vài nghìn nến 1 phút
# ohlc_1min = ticks_to_ohlc(ticks, "1min")
# Lợi ích: giảm 99% dung lượng, backtest nhanh hơn nhiều

⚡ Tối Ưu Hiệu Năng Truy Vấn Cho Backtest

Backtest càng nhanh, bạn càng thử được nhiều ý tưởng. Các kỹ thuật tăng tốc truy xuất:

# [TỐI ƯU TRUY VẤN - SQL/TIMESCALEDB]
-- 1. Dùng time_bucket để giảm lượng dữ liệu
SELECT time_bucket('5 minutes', timestamp) AS bucket,
       symbol,
       first(price, timestamp) AS open,
       max(price) AS high,
       min(price) AS low,
       last(price, timestamp) AS close,
       sum(volume) AS volume
FROM tick_data
WHERE symbol = 'XAUUSD'
  AND timestamp >= now() - interval '30 days'
GROUP BY bucket, symbol
ORDER BY bucket;

-- 2. Continuous aggregate (chạy nền, lưu trước)
CREATE MATERIALIZED VIEW ohlc_5m
WITH (timescaledb.continuous) AS
SELECT ... FROM tick_data GROUP BY bucket, symbol;

-- 3. Chỉ lấy cột cần thiết, tránh SELECT *

🔍 Xử Lý Dữ Liệu Thiếu (Missing) Đúng Cách

Trong dữ liệu tài chính, giá trị thiếu rất phổ biến (ngày nghỉ, giờ nghỉ, lỗi nguồn). Cách xử lý quyết định chất lượng backtest:

• Forward fill: Điền giá trị trước đó — phù hợp dữ liệu giá.
• Linear interpolation: Nội suy tuyến tính giữa hai điểm.
• Drop: Bỏ hàng thiếu — dùng khi thiếu không đáng kể.
• Không tự ý bịa: Dữ liệu giả tạo sẽ làm sai kết quả.

# [XỬ LÝ MISSING - PYTHON]
def handle_missing(df):
    # Forward fill cho giá đóng cửa
    df["close"] = df["close"].ffill()

    # Interpolation cho các cột khác
    df["volume"] = df["volume"].interpolate()

    # Kiểm tra còn thiếu không
    print("Còn NaN:", df.isna().sum().sum())
    return df

📈 Kiểm Tra Chất Lượng Dữ Liệu Sau Khi Làm Sạch

# [KIỂM TRA CHẤT LƯỢNG - PYTHON]
def validate_data(df):
    checks = []

    # 1. Không có NaN
    checks.append(("Không NaN", df.isna().sum().sum() == 0))

    # 2. Giá dương
    checks.append(("Giá dương", (df["close"] > 0).all()))

    # 3. High >= Low
    checks.append(("High >= Low", (df["high"] >= df["low"]).all()))

    # 4. Không trùng timestamp
    checks.append(("Không trùng time", df["timestamp"].is_unique))

    # 5. Khối lượng không âm
    checks.append(("Volume >= 0", (df["volume"] >= 0).all()))

    for name, ok in checks:
        print(f"{'✅' if ok else '❌'} {name}")
    return all(ok for _, ok in checks)

🚀 Lợi Ích Của Pipeline Dữ Liệu Chuẩn

• Backtest đáng tin: Kết quả phản ánh đúng thực tế.
• Model AI học đúng: Dự báo chính xác hơn.
• Quyết định tự tin: Giảm rủi ro, tăng hiệu quả.
• Tiết kiệm thời gian: Không làm lại dữ liệu mỗi lần.
• Tự động hóa: Dữ liệu mới được xử lý liên tục.

❓ FAQ Mở Rộng

Hỏi: Dữ liệu Tick khác dữ liệu OHLC thế nào?
Tick là từng giao dịch (hàng triệu/ngày), OHLC là nến tổng hợp (vài nghìn/ngày). Tick chi tiết hơn nhưng tốn bộ nhớ hơn nhiều.

Hỏi: Cần lưu dữ liệu Tick bao lâu?
Tùy chiến lược. Backtest dài hạn cần 5-10 năm. Lưu trữ đầy đủ rồi nén cũ giúp tiết kiệm chi phí.

Hỏi: TimescaleDB có miễn phí không?
Có bản cộng đồng (open-source). Phù hợp người mới bắt đầu.

Hỏi: Dữ liệu bẩn có thể làm AI sai đến mức nào?
Nghiêm trọng — model học trên dữ liệu bẩn sẽ đưa ra dự báo sai, dù thuật toán tốt đến đâu (garbage in, garbage out).

---

🚀 Làm chủ Big Data tài chính: Tham gia khóa học tại Hướng Nghiệp Dữ Liệu để xây dựng pipeline dữ liệu chuyên nghiệp cho hệ thống trading của bạn.

📡 Thu Thập Dữ Liệu Tự Động (Data Ingestion)

Bước đầu tiên của pipeline là thu thập dữ liệu liên tục và tự động. Dưới đây là cách xây dựng bộ thu thập dữ liệu giá từ nhiều nguồn:

# [THU THẬP DỮ LIỆU TỰ ĐỘNG - PYTHON]
import time
import urllib.request
import json

def fetch_binance_klines(symbol, interval="1m", limit=1000):
    url = (f"https://api.binance.com/api/v3/klines?"
           f"symbol={symbol}&interval={interval}&limit={limit}")
    data = json.loads(urllib.request.urlopen(url).read().decode())
    # Chuẩn hóa
    rows = []
    for k in data:
        rows.append({
            "timestamp": k[0],
            "open": float(k[1]),
            "high": float(k[2]),
            "low": float(k[3]),
            "close": float(k[4]),
            "volume": float(k[5]),
        })
    return rows

# Vòng lặp thu thập định kỳ
def ingestion_loop(symbols, interval="1m"):
    while True:
        for sym in symbols:
            try:
                rows = fetch_binance_klines(sym, interval)
                save_to_db(sym, rows)  # Lưu vào TimescaleDB
                print(f"{sym}: {len(rows)} nến")
            except Exception as e:
                print(f"{sym} lỗi: {e}")
        time.sleep(60)  # Chờ 1 phút

# ingestion_loop(["BTCUSDT", "ETHUSDT"])

📊 Thiết Kế Schema Database Chuẩn Cho Trading

Schema tốt giúp truy xuất nhanh và dễ mở rộng. Schema chuẩn cho dữ liệu giao dịch:

# [SCHEMA DATABASE - SQL/TIMESCALEDB]
CREATE TABLE ohlc (
    symbol     TEXT,
    timeframe  TEXT,
    timestamp  TIMESTAMPTZ,
    open       DOUBLE PRECISION,
    high       DOUBLE PRECISION,
    low        DOUBLE PRECISION,
    close      DOUBLE PRECISION,
    volume     DOUBLE PRECISION,
    PRIMARY KEY (symbol, timeframe, timestamp)
);

CREATE TABLE trades (
    id          BIGSERIAL PRIMARY KEY,
    symbol      TEXT,
    action      TEXT,       -- BUY / SELL
    lot         DOUBLE PRECISION,
    entry_price DOUBLE PRECISION,
    exit_price  DOUBLE PRECISION,
    pnl         DOUBLE PRECISION,
    open_time   TIMESTAMPTZ,
    close_time  TIMESTAMPTZ,
    strategy    TEXT
);

CREATE TABLE signals (
    id          BIGSERIAL PRIMARY KEY,
    symbol      TEXT,
    strategy    TEXT,
    signal_type TEXT,       -- GOLDEN / DEATH / ...
    strength    DOUBLE PRECISION,
    created_at  TIMESTAMPTZ
);

-- Index tối ưu
CREATE INDEX idx_ohlc_time ON ohlc (symbol, timeframe, timestamp DESC);
CREATE INDEX idx_trades_time ON trades (close_time DESC);

📉 Nén Dữ Liệu (Compression) Tiết Kiệm Chi Phí

Dữ liệu Tick quy mô lớn tốn hàng trăm GB. Nén dữ liệu giúp tiết kiệm đáng kể:

• TimescaleDB compression: Nén cột, giảm 90%+ dung lượng.
• Chunking: Chia dữ liệu theo khoảng thời gian để quản lý.
• Retention policy: Tự động xóa dữ liệu quá cũ không cần.
• Downsampling: Giữ OHLC 1 phút thay vì tick thô sau vài tháng.

# [NÉN DỮ LIỆU - TIMESCALEDB]
-- Kích hoạt nén cho bảng ohlc
ALTER TABLE ohlc SET (
    timescaledb.compress,
    timescaledb.compress_segmentby = 'symbol,timeframe'
);

-- Tự động nén dữ liệu cũ hơn 7 ngày
SELECT add_compression_policy('ohlc', INTERVAL '7 days');

-- Retention: xóa dữ liệu tick cũ hơn 2 năm
SELECT add_retention_policy('tick_data', INTERVAL '2 years');

🚀 Tối Ưu Hiệu Năng Backtest Hàng Triệu Nến

Khi dữ liệu lên tới hàng triệu nến, backtest bằng vòng lặp Python sẽ rất chậm. Các kỹ thuật tăng tốc:

# [BACKTEST NHANH - VECTORIZED + NUMPY]
import numpy as np

def vectorized_backtest(closes, signals, initial=10000):
    closes = np.array(closes)
    signals = np.array(signals)

    # Vector hóa: tính toán trên toàn mảng thay vì vòng lặp
    # Tạo vị thế: 1 = giữ cổ, 0 = không
    position = np.zeros(len(signals))
    pos = 0
    for i, s in enumerate(signals):
        if s == 1:
            pos = 1
        elif s == -1:
            pos = 0
        position[i] = pos

    # Equity = initial * (1 + position * returns) tích lũy
    returns = np.diff(closes) / closes[:-1]
    strat_returns = position[:-1] * returns
    equity = initial * np.cumprod(1 + strat_returns)
    return equity

# NumPy nhanh hơn vòng lặp Python 10-100x cho dữ liệu lớn

📈 Dùng Parquet + DuckDB Cho Backtest Local

Khi làm việc local (không cần server), Parquet + DuckDB là combo mạnh và miễn phí:

# [PARQUET + DUCKDB - PYTHON]
# Lưu dữ liệu dạng Parquet (nén tốt, truy xuất nhanh)
# df.to_parquet("xauusd_h1.parquet")

import duckdb

# Truy vấn nhanh bằng SQL trên file Parquet
conn = duckdb.connect()
sql = ("SELECT symbol, date_trunc('month', timestamp) AS month, "
       "avg(close) AS avg_close FROM 'xauusd_h1.parquet' "
       "WHERE timestamp > '2024-01-01' "
       "GROUP BY symbol, month ORDER BY month")
result = conn.execute(sql).fetchdf()
print(result)

🔍 Xử Lý Dữ Liệu Nhiều Múi Giờ Và Phiên Giao Dịch

Thị trường tài chính hoạt động ở nhiều múi giờ (Sydney, Tokyo, London, New York). Dữ liệu cần chuẩn hóa theo một múi giờ chuẩn:

# [CHUẨN HÓA MÚI GIỜ - PYTHON]
import pandas as pd

def normalize_timezone(df, from_tz="UTC", to_tz="Asia/Ho_Chi_Minh"):
    # Chuyển đổi timestamp về múi giờ chuẩn
    df["timestamp"] = pd.to_datetime(df["timestamp"])
    df["timestamp"] = (df["timestamp"]
                       .dt.tz_localize(from_tz)
                       .dt.tz_convert(to_tz))
    return df

def add_session(df):
    # Gắn nhãn phiên giao dịch
    hour = df["timestamp"].dt.hour
    df["session"] = "Other"
    df.loc[hour.isin([0, 1, 2]), "session"] = "Sydney"
    df.loc[hour.isin([3, 4, 5, 6, 7]), "session"] = "Tokyo"
    df.loc[hour.isin([8, 9, 10, 11]), "session"] = "London"
    df.loc[hour.isin([12, 13, 14, 15, 16, 17, 18, 19]), "session"] = "New York"
    return df

✅ Checklist Kiểm Tra Dữ Liệu Trước Khi Backtest

• ✅ Không có NaN trong cột giá/khối lượng.
• ✅ Giá dương, volume không âm.
• ✅ High >= Low trên mọi nến.
• ✅ Không trùng timestamp.
• ✅ Đã loại bỏ outliers do lỗi nguồn.
• ✅ Múi giờ chuẩn hóa thống nhất.
• ✅ Đã bao gồm đầy đủ khoảng thời gian cần.
• ✅ Kết quả kiểm tra chất lượng (validate) đạt.

❓ Câu Hỏi Bổ Sung

Hỏi: Dữ liệu tài chính nên lưu dạng file hay database?
Khối lượng nhỏ (1-2 GB): file Parquet. Khối lượng lớn, cần đồng bộ nhiều máy: TimescaleDB/ClickHouse.

Hỏi: Backtest cần dữ liệu bao lâu là đủ?
Tối thiểu 3-5 năm, qua các chu kỳ thị trường khác nhau (bull, bear, sideway).

Hỏi: Làm sao biết dữ liệu của tôi đủ sạch?
Chạy hàm validate_data — nếu tất cả check đạt ✅, dữ liệu đủ tốt để backtest.

---

🚀 Làm chủ Big Data tài chính: Tham gia khóa học tại Hướng Nghiệp Dữ Liệu để xây dựng pipeline dữ liệu chuyên nghiệp cho hệ thống trading của bạn.