# Kronos: dự báo nến tài chính bằng AI — hướng dẫn cài đặt và dùng

> Kronos là mô hình nền tảng dành riêng cho chuỗi nến tài chính OHLCV, được huấn luyện trên dữ liệu từ hơn 45 sàn giao dịch toàn cầu. Bạn có thể dùng mô hình có sẵn để dự báo, chạy dự báo hàng loạt hoặc tinh chỉnh trên dữ liệu riêng; phần cài đặt cơ bản cần Python 3.10+ và các gói trong requirements.txt.

- Tác giả: Ông T (https://ongt.vn/gioi-thieu)
- Chủ đề: Repo & Skill
- Đăng: 2026-11-03 · Cập nhật: 2026-11-14
- URL: https://ongt.vn/bai-viet/kronos-du-bao-nen-tai-chinh-bang-ai-2

Kronos là một mô hình nền tảng mã nguồn mở dành cho dữ liệu nến tài chính, còn gọi là K-line. Mô hình nhận chuỗi dữ liệu mở cửa, cao nhất, thấp nhất, đóng cửa, khối lượng và giá trị giao dịch để dự báo các nến tiếp theo.

Repo này phù hợp với lập trình viên, nhóm nghiên cứu định lượng và người làm phân tích dữ liệu muốn thử dự báo nhiều bước mà không phải tự xây dựng mô hình từ đầu. Điểm đáng giá là Kronos có sẵn nhiều kích thước mô hình, có lớp `KronosPredictor` xử lý tiền xử lý dữ liệu và hoàn nguyên kết quả, đồng thời hỗ trợ dự báo một chuỗi hoặc nhiều chuỗi cùng lúc.

Kronos không phải một hệ thống giao dịch tự động hoàn chỉnh. README cung cấp ví dụ dự báo và một quy trình tinh chỉnh, kiểm thử đơn giản. Bạn nên xem kết quả là tín hiệu nghiên cứu, không phải cam kết lợi nhuận.

```repo
- repo | shiyu-coder/Kronos
- kind | Mô hình
- desc | Kronos là mô hình nền tảng mã nguồn mở dùng dữ liệu nến tài chính để dự báo nhiều bước giá và khối lượng.
- stars | 48k
- lang | Python
- license | MIT
```

## Kronos làm được gì

Kronos được thiết kế riêng cho “ngôn ngữ” của thị trường tài chính. Thay vì dùng một mô hình chuỗi thời gian chung, repo mã hóa dữ liệu nến OHLCV thành các token rời rạc theo cấu trúc phân cấp, sau đó dùng Transformer tự hồi quy để học quy luật trong chuỗi đó. Cách tiếp cận này phù hợp hơn với dữ liệu tài chính có nhiều nhiễu.

### Dự báo các nến tương lai

Bạn đưa vào dữ liệu lịch sử và các mốc thời gian tương lai, sau đó nhận về một `pandas DataFrame` chứa các giá trị dự báo cho `open`, `high`, `low`, `close`, `volume` và `amount`. Kết quả được lập chỉ mục theo các mốc trong `y_timestamp`, nên thuận tiện để nối vào bảng dữ liệu hoặc vẽ biểu đồ.

`lookback` quyết định số nến lịch sử làm ngữ cảnh. `pred_len` quyết định số nến cần dự báo. Với Kronos-small và Kronos-base, độ dài ngữ cảnh tối đa là 512. Nếu đưa vào dài hơn, `KronosPredictor` sẽ tự xử lý việc cắt ngữ cảnh.

### Chọn mô hình theo năng lực máy

Model Zoo có Kronos-mini, Kronos-small, Kronos-base và Kronos-large. Kronos-mini có 4,1 triệu tham số và ngữ cảnh 2048; Kronos-small có 24,7 triệu tham số và ngữ cảnh 512; Kronos-base có 102,3 triệu tham số và ngữ cảnh 512. Kronos-large có 499,2 triệu tham số.

README ghi Kronos-mini, Kronos-small và Kronos-base có mô hình mở trên Hugging Face. Kronos-large được liệt kê nhưng không có trạng thái mở trong bảng. Người mới nên bắt đầu với Kronos-small để giảm yêu cầu tài nguyên và kiểm tra quy trình trước.

### Dự báo xác suất bằng lấy mẫu

Khi gọi `predict`, bạn có thể điều chỉnh `T`, `top_p` và `sample_count`. Các tham số này điều khiển quá trình lấy mẫu. `sample_count` có thể dùng để tạo nhiều đường dự báo rồi lấy trung bình, thay vì chỉ tạo một đường duy nhất.

Điều này hữu ích khi bạn muốn quan sát sự không chắc chắn của dự báo. Tuy nhiên, README không cung cấp cam kết về độ chính xác hay cách biến các đường dự báo thành quyết định mua bán.

### Dự báo nhiều tài sản bằng GPU

`predict_batch` cho phép xử lý nhiều DataFrame cùng lúc. Kết quả trả về theo đúng thứ tự dữ liệu đầu vào. Phương thức này tận dụng khả năng xử lý song song của GPU và tự chuẩn hóa, hoàn nguyên dữ liệu riêng cho từng chuỗi.

Các chuỗi trong cùng một batch phải có cùng độ dài lịch sử và cùng độ dài dự báo. Mỗi DataFrame phải có `open`, `high`, `low`, `close`. Hai cột `volume` và `amount` là tùy chọn; nếu thiếu, chúng được điền bằng số 0.

### Tinh chỉnh trên dữ liệu riêng

Repo có pipeline tinh chỉnh dựa trên ví dụ dữ liệu cổ phiếu A-share và Qlib. Pipeline gồm chuẩn bị dữ liệu, tinh chỉnh tokenizer, tinh chỉnh predictor rồi chạy backtest đơn giản.

Bạn có thể chỉnh đường dẫn dữ liệu, thư mục lưu dataset, nơi lưu checkpoint, mô hình khởi đầu, mã công cụ, khoảng thời gian huấn luyện, số epoch và batch size trong `finetune/config.py`. README cũng cho phép tắt Comet.ml bằng cách đặt `use_comet = False` nếu bạn không dùng dịch vụ này.

## Cần chuẩn bị gì

Bạn cần Python 3.10 trở lên. README yêu cầu cài các thư viện phụ thuộc từ file `requirements.txt`.

Bạn cần dữ liệu nến lịch sử ở dạng `pandas DataFrame`. Bốn cột bắt buộc là `open`, `high`, `low`, `close`. Hai cột `volume` và `amount` không bắt buộc khi dự báo; nếu dùng dự báo batch mà thiếu hai cột này, Kronos sẽ điền số 0.

Để tải mô hình có sẵn, mã nguồn sử dụng các tên mô hình trên Hugging Face như `NeoQuasar/Kronos-Tokenizer-base` và `NeoQuasar/Kronos-small`. README không yêu cầu API key cho quy trình tải mô hình cơ bản.

Nếu chỉ chạy dự báo, README không nêu rõ yêu cầu phần cứng tối thiểu. Phần dự báo batch có tận dụng GPU. Nếu muốn tinh chỉnh, hai lệnh huấn luyện dùng `torchrun` cho nhiều GPU, nên bạn cần chuẩn bị môi trường PyTorch và số GPU phù hợp với cấu hình của mình.

Nếu chạy pipeline tinh chỉnh, bạn cần cài thêm `pyqlib`, chuẩn bị dữ liệu Qlib cục bộ và chỉnh các đường dẫn trong `finetune/config.py`. Ví dụ của repo giả định dữ liệu Qlib ở tần suất ngày.

README không nêu yêu cầu cụ thể cho hệ điều hành, dung lượng RAM, loại GPU, phiên bản CUDA hay chi phí sử dụng. Vì vậy, bạn nên kiểm tra môi trường Python và PyTorch thực tế trước khi chạy mô hình lớn.

## Cài đặt từng bước

```steps
- Tải mã nguồn | Lấy repo về máy và mở terminal trong thư mục dự án
- Cài Python và thư viện | Dùng Python 3.10+ rồi cài requirements.txt
- Kiểm tra mã mẫu | Mở các ví dụ trong examples/ để chuẩn bị dữ liệu đầu vào
- Chạy dự báo | Tải tokenizer, model và gọi KronosPredictor
- Tinh chỉnh nếu cần | Cài Qlib, sửa config rồi chạy pipeline finetune
```

### Tải mã nguồn

Mở PowerShell hoặc terminal tại thư mục bạn muốn lưu dự án. Có thể dùng lệnh Git phổ thông sau:

```bash
git clone https://github.com/shiyu-coder/Kronos.git
cd Kronos
```

Sau lệnh `git clone`, thư mục `Kronos` sẽ chứa `README.md`, `model/`, `examples/`, `finetune/`, `tests/` và các file liên quan. Lệnh `cd Kronos` rất quan trọng: nếu chạy lệnh cài đặt ở thư mục khác, terminal có thể không tìm thấy `requirements.txt`.

### Cài Python và thư viện

Cài Python 3.10 trở lên, sau đó mở terminal trong thư mục gốc của repo và chạy đúng lệnh README cung cấp:

```bash
pip install -r requirements.txt
```

Lệnh này đọc danh sách phụ thuộc từ `requirements.txt` và cài chúng vào môi trường Python hiện tại. Nếu máy có nhiều bản Python, hãy chắc rằng `pip` đang trỏ vào Python 3.10 trở lên. README không cung cấp lệnh tạo virtual environment, nên phần này chưa có hướng dẫn riêng trong tài liệu gốc.

### Chuẩn bị dữ liệu nến

Dữ liệu đưa vào `predict` phải là một DataFrame có các cột bắt buộc `open`, `high`, `low`, `close`. Ví dụ README đọc dữ liệu từ file CSV, chuyển cột thời gian sang kiểu ngày giờ rồi tách phần lịch sử và phần tương lai:

```python
import pandas as pd

# Load your data
df = pd.read_csv("./data/XSHG_5min_600977.csv")
df['timestamps'] = pd.to_datetime(df['timestamps'])

# Define context window and prediction length
lookback = 400
pred_len = 120

# Prepare inputs for the predictor
x_df = df.loc[:lookback-1, ['open', 'high', 'low', 'close', 'volume', 'amount']]
x_timestamp = df.loc[:lookback-1, 'timestamps']
y_timestamp = df.loc[lookback:lookback+pred_len-1, 'timestamps']
```

Đường dẫn `./data/XSHG_5min_600977.csv` là đường dẫn ví dụ trong README. Bạn cần thay bằng file dữ liệu của mình; không nên hiểu đây là file chắc chắn đã có trong repo. Kiểm tra tên cột trước khi chạy. `x_timestamp` phải tương ứng với dữ liệu lịch sử, còn `y_timestamp` phải chứa các mốc muốn dự báo.

### Tải tokenizer và model

Trong một file Python chạy từ thư mục gốc repo, tải tokenizer và model như sau:

```python
from model import Kronos, KronosTokenizer, KronosPredictor

# Load from Hugging Face Hub
tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
```

Tokenizer và model phải tương thích với nhau. Ví dụ trên dùng `Kronos-Tokenizer-base` cùng `Kronos-small`, đúng theo mẫu README. Lần đầu tải, máy cần truy cập được nơi lưu mô hình trên Hugging Face. README không nói rằng bạn phải điền API key.

### Khởi tạo bộ dự báo và chạy lần đầu

Tạo predictor với độ dài ngữ cảnh phù hợp:

```python
# Initialize the predictor
predictor = KronosPredictor(model, tokenizer, max_context=512)
```

Sau đó gọi `predict`:

```python
# Generate predictions
pred_df = predictor.predict(
    df=x_df,
    x_timestamp=x_timestamp,
    y_timestamp=y_timestamp,
    pred_len=pred_len,
    T=1.0,          # Temperature for sampling
    top_p=0.9,      # Nucleus sampling probability
    sample_count=1  # Number of forecast paths to generate and average
)

print("Forecasted Data Head:")
print(pred_df.head())
```

Trong ví dụ, `lookback` là 400 và `pred_len` là 120, nên phần lịch sử không vượt giới hạn 512 của Kronos-small. Nếu bạn tăng `lookback` lên trên 512, predictor sẽ tự cắt ngữ cảnh, nhưng README khuyến nghị không đưa đầu vào dài hơn giới hạn này.

### Chạy dự báo batch

Khi có nhiều tài sản hoặc nhiều giai đoạn cần dự báo, chuẩn bị ba danh sách có cùng thứ tự:

```python
# Prepare multiple datasets for batch prediction
df_list = [df1, df2, df3]  # List of DataFrames
x_timestamp_list = [x_ts1, x_ts2, x_ts3]  # List of historical timestamps
y_timestamp_list = [y_ts1, y_ts2, y_ts3]  # List of future timestamps

# Generate batch predictions
pred_df_list = predictor.predict_batch(
    df_list=df_list,
    x_timestamp_list=x_timestamp_list,
    y_timestamp_list=y_timestamp_list,
    pred_len=pred_len,
    T=1.0,
    top_p=0.9,
    sample_count=1,
    verbose=True
)

# pred_df_list contains prediction results in the same order as input
for i, pred_df in enumerate(pred_df_list):
    print(f"Predictions for series {i}:")
    print(pred_df.head())
```

Nếu một chuỗi thiếu `volume` hoặc `amount`, README cho biết hai cột này sẽ được điền bằng 0. Dù vậy, bạn vẫn phải bảo đảm các chuỗi có cùng `lookback` và `pred_len`.

### Chạy ví dụ có sẵn

README chỉ rõ script hoàn chỉnh nằm tại `examples/prediction_example.py`. Ngoài ra có `examples/prediction_wo_vol_example.py` cho trường hợp không có dữ liệu volume và amount. Hãy mở hai file này để xem cách repo nối phần đọc dữ liệu, dự báo và vẽ biểu đồ. README không đưa một lệnh chạy cụ thể cho hai file này, nên không nên tự suy đoán thêm cờ lệnh.

### Chuẩn bị tinh chỉnh bằng Qlib

Trước hết cài Qlib bằng lệnh trong README:

```bash
pip install pyqlib
```

Sau đó chuẩn bị dữ liệu Qlib cục bộ theo hướng dẫn chính thức của Qlib và sửa các đường dẫn trong `finetune/config.py`. Các đường dẫn quan trọng gồm `qlib_data_path`, `dataset_path`, `save_path`, `backtest_result_path`, `pretrained_tokenizer_path` và `pretrained_predictor_path`.

Chạy tiền xử lý:

```bash
python finetune/qlib_data_preprocess.py
```

Sau khi hoàn tất, các file `train_data.pkl`, `val_data.pkl` và `test_data.pkl` sẽ nằm trong thư mục `dataset_path`.

### Huấn luyện và backtest

Tinh chỉnh tokenizer bằng `torchrun`:

```bash
# Replace NUM_GPUS with the number of GPUs you want to use (e.g., 2)
torchrun --standalone --nproc_per_node=NUM_GPUS finetune/train_tokenizer.py
```

Thay `NUM_GPUS` bằng số GPU bạn muốn dùng. Tiếp tục tinh chỉnh predictor:

```bash
# Replace NUM_GPUS with the number of GPUs you want to use (e.g., 2)
torchrun --standalone --nproc_per_node=NUM_GPUS finetune/train_predictor.py
```

Cuối cùng chạy đánh giá:

```bash
# Specify the GPU for inference
python finetune/qlib_test.py --device cuda:0
```

Các checkpoint được lưu theo đường dẫn cấu hình trong `config.py`. README mô tả backtest này là ví dụ đơn giản, không phải hệ thống giao dịch sẵn sàng cho môi trường sản xuất.

## Kiểm tra đã chạy được chưa

Cách kiểm tra cơ bản là chạy đoạn mã dự báo với dữ liệu có cấu trúc đúng. Nếu tokenizer và model tải thành công, predictor được khởi tạo và `predict` hoàn tất, màn hình sẽ in:

```text
Forecasted Data Head:
```

Sau đó là vài dòng đầu của `pred_df`. Kết quả phải là một DataFrame có các cột dự báo `open`, `high`, `low`, `close`, `volume`, `amount`, với chỉ mục lấy từ `y_timestamp`.

Khi chạy batch, vòng lặp sẽ in các dòng dạng `Predictions for series 0:` rồi in phần đầu kết quả tương ứng. Thứ tự kết quả phải khớp với thứ tự `df_list`.

Với ví dụ trực quan, `examples/prediction_example.py` tạo biểu đồ so sánh dữ liệu thực tế với dự báo của mô hình. Với pipeline tinh chỉnh, lệnh backtest in phân tích hiệu suất trong console và tạo biểu đồ đường lợi nhuận tích lũy của chiến lược so với benchmark.

```note
Dự báo tài chính không đồng nghĩa với lợi nhuận. README cảnh báo pipeline backtest chỉ là ví dụ. Hãy kiểm tra chi phí giao dịch, trượt giá, tác động thị trường, quản trị rủi ro và dữ liệu ngoài mẫu trước khi dùng kết quả cho quyết định thật.
```

## Dùng vào việc thật

### Dev xây dashboard theo dõi một mã

Một dev có thể lấy dữ liệu nến của một mã, đặt `lookback = 400`, `pred_len = 120`, rồi gọi `predict`. Kết quả `pred_df` có thể được đưa vào phần biểu đồ của dashboard để hiển thị vùng thời gian dự báo tiếp theo.

Cách này phù hợp khi cần một bản thử nghiệm nghiên cứu. Bạn cần bảo đảm dữ liệu đầu vào có đúng bốn cột OHLC và các mốc thời gian được sắp xếp đúng. README không cung cấp API lấy dữ liệu thị trường, nên phần thu thập dữ liệu phải do bạn tự chuẩn bị.

### Nhân viên phân tích so sánh nhiều tài sản

Một chuyên viên phân tích có thể chuẩn bị `df_list` gồm dữ liệu của nhiều tài sản, cùng độ dài lịch sử và cùng số bước tương lai. Sau đó gọi `predict_batch` để tạo dự báo trong một lần xử lý.

Kết quả `pred_df_list` giữ nguyên thứ tự đầu vào, nên bạn có thể ghép phần tử thứ nhất với mã tài sản thứ nhất, phần tử thứ hai với mã thứ hai. Batch đặc biệt hữu ích khi cần khảo sát nhanh nhiều chuỗi thay vì gọi model từng lần.

### Nhà nghiên cứu thử nhiều kịch bản dự báo

Nhà nghiên cứu có thể chạy cùng một dữ liệu với các giá trị `T`, `top_p` hoặc `sample_count` khác nhau. `sample_count` lớn hơn 1 cho phép tạo nhiều đường dự báo và lấy trung bình theo cơ chế của predictor.

Bạn có thể lưu các DataFrame trả về để so sánh sai số hoặc vẽ nhiều đường dự báo. README chỉ mô tả tham số điều khiển lấy mẫu, chưa cung cấp một bộ chỉ số đánh giá bắt buộc, nên phần đánh giá cần được thiết kế phù hợp với bài toán.

### Nhóm định lượng tinh chỉnh theo dữ liệu riêng

Nhóm nghiên cứu có dữ liệu Qlib và muốn mô hình thích nghi với một phạm vi công cụ cụ thể có thể sửa `finetune/config.py`, chạy `qlib_data_preprocess.py`, rồi tinh chỉnh tokenizer và predictor.

Sau khi huấn luyện, `qlib_test.py --device cuda:0` giúp chạy inference trên tập kiểm thử và backtest chiến lược top-K đơn giản. Kết quả này có thể dùng làm mốc nghiên cứu ban đầu. README khuyến nghị khi đưa vào thực tế phải bổ sung tối ưu danh mục, trung hòa yếu tố rủi ro, định cỡ vị thế và mô hình hóa chi phí giao dịch.

> Hãy xem Kronos như một bộ máy tạo dự báo để nghiên cứu, không phải nút bấm mua bán tự động.
>
> — Ông T

## Lỗi hay gặp và cách xử lý

### `pip` cài nhầm môi trường Python

Bạn có thể cài thành công nhưng khi chạy mã lại báo thiếu thư viện. Nguyên nhân thường là terminal dùng một Python khác với Python đã chạy `pip`. Hãy kiểm tra lại phiên bản Python và bảo đảm đang đứng trong đúng môi trường trước khi chạy mã; README chỉ yêu cầu Python 3.10+ và `pip install -r requirements.txt`.

### Không tìm thấy `requirements.txt` hoặc thư mục `model`

Lỗi này thường xảy ra khi bạn chạy lệnh ngoài thư mục gốc của repo. Hãy mở terminal trong thư mục chứa `README.md`, `requirements.txt` và `model/`, rồi chạy lại. Không tự đổi tên hoặc di chuyển các thư mục mà mã nguồn đang sử dụng.

### Thiếu cột dữ liệu đầu vào

`predict` bắt buộc cần `open`, `high`, `low`, `close`. Nếu file chỉ có giá đóng cửa hoặc dùng tên cột khác, bạn cần chuyển đổi dữ liệu trước khi gọi model. `volume` và `amount` có thể bỏ qua, nhưng trong trường hợp đó repo sẽ dùng số 0 cho các cột này.

### Kích thước chuỗi trong batch không giống nhau

`predict_batch` yêu cầu mọi chuỗi có cùng độ dài lịch sử và cùng `pred_len`. Hãy cắt hoặc chuẩn hóa các DataFrame trước khi đưa vào `df_list`. Nếu cần xử lý các độ dài khác nhau, hãy tách thành các batch phù hợp.

### Huấn luyện thất bại khi dùng `torchrun`

Hai script tinh chỉnh được thiết kế cho huấn luyện nhiều GPU. Hãy thay `NUM_GPUS` bằng số GPU thực tế và kiểm tra các đường dẫn trong `finetune/config.py`. Nếu bạn không có môi trường GPU phù hợp, nên bắt đầu bằng dự báo với model có sẵn thay vì tự sửa lệnh huấn luyện; README không cung cấp quy trình huấn luyện CPU thay thế.

### Kết quả backtest trông quá tốt

Backtest mẫu của repo chỉ dùng chiến lược top-K đơn giản và được README mô tả là ví dụ. Hãy kiểm tra cách chia train, validation, test, dữ liệu rò rỉ, chi phí giao dịch, trượt giá và tác động thị trường trước khi kết luận. Không nên dùng một biểu đồ lợi nhuận tích lũy duy nhất để quyết định triển khai.

## Có nên dùng không

Kronos đáng thử nếu bạn cần mô hình chuyên biệt cho dữ liệu nến tài chính, muốn bắt đầu bằng model đã huấn luyện hoặc muốn nghiên cứu quy trình tinh chỉnh trên dữ liệu Qlib. Repo có cấu trúc tương đối rõ, ví dụ dự báo cụ thể, hỗ trợ dự báo batch và có nhiều kích thước model. Giấy phép của dự án là MIT.

Điểm mạnh lớn nhất là mô hình tập trung vào K-line thay vì xử lý tài chính như một chuỗi thời gian thông thường. Lớp `KronosPredictor` cũng giảm phần việc thủ công vì đảm nhiệm tiền xử lý, chuẩn hóa, dự báo và hoàn nguyên kết quả. Việc có cả ví dụ không dùng volume và amount giúp thử nghiệm với dữ liệu đơn giản hơn.

Giới hạn cần cân nhắc là README không nêu yêu cầu phần cứng chi tiết, độ chính xác chuẩn, benchmark đầy đủ cho từng thị trường hay hướng dẫn triển khai sản xuất. Kronos-large không được đánh dấu là model mở trong bảng Model Zoo. Pipeline Qlib chỉ là demo, còn phần bình luận trong thư mục `finetune/` có thể chứa nội dung do AI tạo và README khuyên xem code là nguồn logic chính.

Bạn nên chọn Kronos khi mục tiêu là nghiên cứu, thử nghiệm dự báo hoặc xây nguyên mẫu phân tích. Nếu cần hệ thống giao dịch vận hành thật, bạn sẽ cần bổ sung nguồn dữ liệu đáng tin cậy, kiểm định ngoài mẫu, quản trị rủi ro, tối ưu danh mục, giám sát và mô hình hóa chi phí. Nếu bài toán của bạn không dùng dữ liệu nến OHLCV hoặc cần dự báo chuỗi thời gian tổng quát, một mô hình chuyên dụng khác có thể phù hợp hơn.

## Câu hỏi thường gặp

### Kronos có miễn phí không?

Repo được phát hành với giấy phép MIT. README cho biết Kronos-mini, Kronos-small và Kronos-base có model mở trên Hugging Face; README không nêu chi phí hạ tầng, tải mô hình hay dịch vụ liên quan.

### Kronos có cần GPU không?

README không nêu GPU là yêu cầu bắt buộc cho dự báo cơ bản. Tuy nhiên, dự báo batch tận dụng GPU và hai script tinh chỉnh được thiết kế cho huấn luyện nhiều GPU bằng `torchrun`.

### Kronos chạy được trên Windows không?

README không nêu hệ điều hành được hỗ trợ hoặc hướng dẫn riêng cho Windows. Tài liệu chỉ yêu cầu Python 3.10+, cài `requirements.txt` và cung cấp các lệnh Python, pip, torchrun.

### Dữ liệu đầu vào phải có những cột nào?

DataFrame bắt buộc có `open`, `high`, `low`, `close`. `volume` và `amount` là tùy chọn; khi thiếu trong dự báo batch, chúng được điền bằng số 0.

### Kronos có tự giao dịch hoặc đảm bảo lợi nhuận không?

Không. README mô tả Kronos là mô hình dự báo và gọi pipeline backtest là ví dụ đơn giản, không phải hệ thống giao dịch sản xuất. Tín hiệu cần được kết hợp với quản trị rủi ro, tối ưu danh mục và kiểm định kỹ.

### Có thể tinh chỉnh Kronos trên dữ liệu riêng không?

Có. Repo cung cấp pipeline dựa trên Qlib, gồm chuẩn bị dữ liệu, tinh chỉnh tokenizer, tinh chỉnh predictor và backtest. Bạn cần cài `pyqlib`, chuẩn bị dữ liệu Qlib và sửa đường dẫn trong `finetune/config.py`.

### Kronos-small và Kronos-base khác nhau thế nào?

Kronos-small có 24,7 triệu tham số, còn Kronos-base có 102,3 triệu tham số. Cả hai dùng ngữ cảnh tối đa 512 theo README; lựa chọn phù hợp còn phụ thuộc tài nguyên máy và mục tiêu thử nghiệm.
