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

> Kronos là họ mô hình Python chuyên dự báo chuỗi nến tài chính OHLCV, gồm giá mở cửa, cao nhất, thấp nhất, đóng cửa và khối lượng. Bạn có thể dùng mô hình dựng sẵn để dự báo một hoặc nhiều chuỗi dữ liệu, hoặc tinh chỉnh trên dữ liệu riêng. Cài đặt cơ bản khá thẳng với Python 3.10+ và requirements.txt; quy trình tinh chỉnh cần thêm Qlib và GPU.

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

Kronos là một mô hình nền tảng mã nguồn mở dành cho ngôn ngữ của thị trường tài chính, trong đó ngôn ngữ được biểu diễn bằng các chuỗi nến K-line. Mô hình nhận dữ liệu OHLCV lịch sử và tạo dự báo cho những khoảng thời gian tiếp theo.

Repo phù hợp với lập trình viên, nhóm nghiên cứu định lượng, người xây công cụ phân tích thị trường và doanh nghiệp muốn thử dự báo nhiều mã tài sản. Bạn không cần tự huấn luyện từ đầu để bắt đầu. Repo đã cung cấp các mô hình dựng sẵn trên Hugging Face, lớp `KronosPredictor`, ví dụ chạy dự báo và pipeline tinh chỉnh trên dữ liệu Qlib.

Điểm đáng giá nhất là Kronos xử lý cả chuỗi giá, khối lượng và giá trị giao dịch theo cách chuyên biệt cho dữ liệu tài chính. Tuy nhiên, dự báo của mô hình chỉ là tín hiệu đầu vào cho phân tích hoặc chiến lược. README không coi pipeline mẫu là một hệ thống giao dịch hoàn chỉnh.

```repo
- repo | shiyu-coder/Kronos
- kind | Mô hình
- desc | Mô hình nền tảng mã nguồn mở dự báo chuỗi nến tài chính OHLCV từ dữ liệu của hơn 45 sàn giao dịch.
- stars | 48k
- lang | Python
- license | MIT
```

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

Kronos dùng một tokenizer chuyên biệt để lượng tử hóa dữ liệu nến nhiều chiều thành các token phân cấp. Sau đó, Transformer tự hồi quy học cách dự đoán chuỗi token tiếp theo. Cách thiết kế này giúp mô hình tập trung vào đặc điểm nhiễu cao của dữ liệu tài chính.

### Dự báo chuỗi nến tiếp theo

Bạn đưa vào dữ liệu lịch sử có các cột `open`, `high`, `low`, `close`; hai cột `volume` và `amount` là tùy chọn. Mô hình trả về một DataFrame gồm các giá trị dự báo cho những mốc thời gian tương lai bạn cung cấp.

Điều này phù hợp khi bạn muốn tạo một lớp dự báo cho bảng điều khiển nội bộ, công cụ nghiên cứu hoặc quy trình đánh giá tín hiệu. Mô hình không tự đặt lệnh và README không mô tả chức năng giao dịch trực tiếp.

### Dùng nhiều kích thước mô hình

Repo cung cấp các biến thể `Kronos-mini`, `Kronos-small` và `Kronos-base` trên Hugging Face. `Kronos-mini` có 4,1 triệu tham số và ngữ cảnh 2.048 bước. `Kronos-small` có 24,7 triệu tham số, còn `Kronos-base` có 102,3 triệu tham số; hai mẫu này dùng ngữ cảnh tối đa 512 bước.

`Kronos-large` có 499,2 triệu tham số nhưng được đánh dấu là chưa mở mã nguồn trong bảng model zoo. Vì vậy, khi bắt đầu, bạn nên dùng một mẫu đã có sẵn như `Kronos-small` cùng tokenizer tương ứng.

### Dự báo nhiều chuỗi cùng lúc

`predict_batch` cho phép xử lý nhiều DataFrame trong một lần gọi. Đây là lựa chọn phù hợp khi bạn cần dự báo nhiều mã tài sản hoặc nhiều chuỗi thời gian.

Các chuỗi trong một batch phải có cùng độ dài lịch sử và cùng độ dài dự báo. Mỗi DataFrame vẫn phải có bốn cột OHLC bắt buộc. Nếu thiếu `volume` hoặc `amount`, thư viện sẽ điền bằng số 0.

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

Repo có pipeline mẫu dùng Qlib và dữ liệu thị trường cổ phiếu Trung Quốc. Pipeline gồm chuẩn bị dữ liệu, tinh chỉnh tokenizer, tinh chỉnh predictor rồi backtest trên tập kiểm tra.

Bạn có thể sửa đường dẫn dữ liệu, khoảng thời gian, số epoch, batch size và tên mô hình trong `finetune/config.py`. Cách này phù hợp hơn với nhóm đã có dữ liệu được chuẩn hóa và phần cứng GPU.

### Backtest tín hiệu dự báo

Script `finetune/qlib_test.py` chạy suy luận trên tập kiểm tra, tạo tín hiệu như thay đổi giá dự báo và thực hiện một chiến lược top-K đơn giản. Kết quả được in ra console và có biểu đồ đường lợi nhuận tích lũy so với benchmark.

README nhấn mạnh đây là ví dụ minh họa. Một chiến lược thực tế còn cần quản trị rủi ro, tối ưu danh mục, mô hình hóa phí giao dịch, trượt giá, tác động thị trường và các yếu tố rủi ro.

Hiện repo có khoảng 47.724 sao và 7.902 fork. Repo dùng giấy phép MIT, nhưng phần mô hình và chi phí hạ tầng khi chạy vẫn cần được bạn kiểm tra theo môi trường thực tế.

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

- Python 3.10 trở lên.
- Các thư viện được khai báo trong `requirements.txt`.
- Dữ liệu nến lịch sử dạng pandas DataFrame, có ít nhất các cột `open`, `high`, `low`, `close`.
- Một cột thời gian để chuyển thành pandas Series timestamp. Ví dụ trong README dùng cột `timestamps`.
- Các mô hình và tokenizer dựng sẵn từ Hugging Face nếu bạn chạy ví dụ tải model bằng `from_pretrained`.
- Nếu tinh chỉnh: Qlib, dữ liệu Qlib đã tải và thiết lập cục bộ, cùng các đường dẫn phù hợp trong `finetune/config.py`.
- Nếu tinh chỉnh: môi trường nhiều GPU để chạy các lệnh `torchrun`. README cũng dùng GPU khi chạy suy luận backtest.
- Nếu dùng Comet.ml trong pipeline tinh chỉnh, bạn có thể bật nó. Nếu không dùng, README hướng dẫn đặt `use_comet = False`.

README không nêu yêu cầu API key, tài khoản giao dịch, khóa truy cập sàn hay hệ điều hành cụ thể. README cũng không xác nhận chi tiết mức VRAM cần thiết cho từng model.

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

```steps
- Chuẩn bị Python | Cài Python 3.10 trở lên và mở terminal
- Tải repo | Clone mã nguồn rồi đi vào thư mục Kronos
- Cài phụ thuộc | Chạy requirements.txt bằng pip
- Chạy dự báo mẫu | Tải tokenizer, model và gọi KronosPredictor
- Tinh chỉnh nếu cần | Chuẩn bị Qlib, sửa config rồi chạy pipeline
```

### Chuẩn bị môi trường Python

Cài Python 3.10 trở lên. Sau đó mở PowerShell hoặc terminal tại thư mục bạn muốn lưu mã nguồn. Nếu bạn mới dùng terminal, hãy kiểm tra mình đang đứng đúng thư mục trước khi clone.

README chỉ yêu cầu phiên bản Python và lệnh cài phụ thuộc bên dưới. README không ghi lệnh tạo virtual environment, nên bạn không cần tự đoán thêm tên môi trường hay cờ cài đặt.

### Tải mã nguồn và cài phụ thuộc

Bạn có thể clone repo bằng lệnh phổ thông sau, rồi chạy đúng lệnh cài đặt được ghi trong README:

```bash
git clone https://github.com/shiyu-coder/Kronos.git
cd Kronos
pip install -r requirements.txt
```

`git clone` tải mã nguồn về máy. `cd Kronos` chuyển terminal vào thư mục dự án. `pip install -r requirements.txt` đọc danh sách thư viện trong file `requirements.txt` và cài chúng.

Lỗi người mới hay gặp là chạy `pip install` khi terminal chưa ở thư mục có `requirements.txt`. Khi đó, hãy dùng `cd` để vào đúng thư mục Kronos rồi chạy lại. README không đưa một lệnh cài riêng cho Windows, macOS hoặc Linux.

### Tải tokenizer và model dựng sẵn

Sau khi cài phụ thuộc, bạn có thể tải tokenizer và model bằng các câu lệnh Python trong README:

```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`. Khi chạy lần đầu, model cần được tải từ Hugging Face Hub nên thời gian chờ phụ thuộc vào kết nối mạng và kích thước model.

README không yêu cầu API key cho đoạn tải model này. Nếu máy không thể truy cập nơi lưu model, bạn cần kiểm tra kết nối hoặc xem cách tải model trong môi trường của mình; không nên tự điền một khóa không được README yêu cầu.

### Tạo predictor

Khởi tạo predictor bằng model, tokenizer và giới hạn ngữ cảnh:

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

`max_context=512` phù hợp với `Kronos-small` và `Kronos-base`, vì README ghi đây là độ dài chuỗi tối đa của hai model này. Nếu dữ liệu lịch sử dài hơn, `KronosPredictor` sẽ tự xử lý việc cắt ngữ cảnh. README khuyến nghị `lookback` không vượt quá giới hạn để đạt hiệu quả tốt hơn.

### Chuẩn bị dữ liệu dự báo

DataFrame cần có các cột OHLC. `volume` và `amount` có thể có hoặc không. Bạn cũng cần một Series timestamp cho dữ liệu lịch sử và một Series timestamp cho các kỳ 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']
```

Trong ví dụ, `pd.read_csv` đọc file dữ liệu, còn `pd.to_datetime` chuyển cột thời gian thành kiểu timestamp. `lookback=400` nghĩa là dùng 400 dòng lịch sử. `pred_len=120` nghĩa là dự báo 120 kỳ tiếp theo.

Bạn phải thay đường dẫn `./data/XSHG_5min_600977.csv` bằng đường dẫn đến file dữ liệu của mình. Tên cột cũng phải khớp với yêu cầu của predictor. README có một ví dụ không dùng volume và amount trong thư mục `examples/` nếu nguồn dữ liệu của bạn không có hai trường này.

### Tạo dự báo đầu tiên

Gọi phương thức `predict` như sau:

```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())
```

`T` và `top_p` điều khiển quá trình lấy mẫu. `sample_count` cho biết số đường dự báo được tạo và lấy trung bình. Kết quả `pred_df` là một pandas DataFrame gồm `open`, `high`, `low`, `close`, `volume` và `amount`, được lập chỉ mục bằng `y_timestamp`.

### Dự báo nhiều chuỗi

Khi có nhiều DataFrame, bạn chuẩn bị danh sách dữ liệu và timestamp rồi gọi `predict_batch`:

```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())
```

Kết quả trả về giữ nguyên thứ tự các chuỗi đầu vào. Hãy kiểm tra trước rằng tất cả chuỗi có cùng độ dài lịch sử, cùng `pred_len` và đủ bốn cột OHLC. Nếu thiếu `volume` hoặc `amount`, batch prediction sẽ điền số 0.

### Tinh chỉnh với Qlib

Để chạy pipeline tinh chỉnh, cài thêm Qlib theo đúng README:

```shell
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. Mở `finetune/config.py` và sửa `qlib_data_path`, `dataset_path`, `save_path`, `backtest_result_path`, `pretrained_tokenizer_path` và `pretrained_predictor_path` theo máy của bạn.

Chạy tiền xử lý dữ liệu:

```shell
python finetune/qlib_data_preprocess.py
```

Script này tạo `train_data.pkl`, `val_data.pkl` và `test_data.pkl` trong thư mục được đặt ở `dataset_path`.

Tinh chỉnh tokenizer và predictor bằng `torchrun`. Thay `NUM_GPUS` bằng số GPU bạn muốn dùng:

```shell
# 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
```

```shell
# 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 backtest trên GPU:

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

Các checkpoint tốt nhất được lưu theo đường dẫn cấu hình trong `config.py`. Nếu bạn không dùng Comet.ml, đặt `use_comet = False` trong file cấu hình.

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

Cách kiểm tra cơ bản là đoạn Python tải được tokenizer và model mà không báo lỗi, sau đó `predictor.predict` trả về `pred_df`. Khi in `pred_df.head()`, bạn kỳ vọng thấy các cột dự báo `open`, `high`, `low`, `close`, `volume` và `amount` với index là những timestamp tương lai.

Bạn cũng có thể chạy script hoàn chỉnh `examples/prediction_example.py`. README cho biết script này tải dữ liệu, dự báo và vẽ biểu đồ so sánh dữ liệu thực tế với dự báo. Nếu muốn bỏ qua volume và amount, xem `examples/prediction_wo_vol_example.py`.

Với pipeline tinh chỉnh, kiểm tra thư mục `dataset_path` có ba file `train_data.pkl`, `val_data.pkl` và `test_data.pkl`. Sau backtest, console sẽ in phân tích hiệu suất và script tạo biểu đồ đường lợi nhuận tích lũy của chiến lược so với benchmark.

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

### Chủ shop theo dõi nhu cầu nhập hàng

Chủ shop có thể dùng chuỗi dữ liệu giá hoặc chỉ số thị trường liên quan để thử dự báo ngắn hạn trước khi lập báo cáo nhập hàng. Bạn chuẩn bị CSV có `open`, `high`, `low`, `close` và nếu có thì thêm `volume`, sau đó đưa vào `pd.read_csv` như ví dụ trong README.

Sau khi gọi `predict`, bạn xem các dòng trong `pred_df` cho những timestamp tương lai. Kết quả nên được xem như một tín hiệu tham khảo để lập kế hoạch, không phải cam kết giá hay doanh số.

### Nhân viên văn phòng làm báo cáo thị trường

Nhân viên phân tích có thể tạo báo cáo tự động cho nhiều mã tài sản bằng `predict_batch`. Mỗi mã được đặt trong một DataFrame, các mốc lịch sử và tương lai đặt trong các danh sách tương ứng.

Kết quả `pred_df_list` giữ nguyên thứ tự đầu vào, nên bạn có thể ghép từng DataFrame dự báo với mã tài sản ban đầu rồi xuất sang báo cáo nội bộ. Hãy bảo đảm các mã có cùng độ dài lookback và pred_len trước khi chạy.

### Lập trình viên xây dashboard thử nghiệm

Dev có thể dùng `KronosPredictor` làm lớp dự báo phía sau dashboard. Dữ liệu đầu vào cần được chuyển thành DataFrame và hai Series timestamp. Dashboard có thể hiển thị các cột dự báo hoặc biểu đồ do bạn tự xây dựng từ `pred_df`.

Nếu dùng `Kronos-small` hoặc `Kronos-base`, đặt `max_context=512` và tránh truyền lookback dài hơn mức này khi không cần. README cho biết predictor tự cắt ngữ cảnh dài, nhưng vẫn khuyến nghị đầu vào không vượt giới hạn để có hiệu quả tốt hơn.

### Nhóm định lượng thử nghiệm chiến lược

Nhóm định lượng có thể bắt đầu bằng dữ liệu Qlib, sửa các đường dẫn trong `finetune/config.py`, chạy `qlib_data_preprocess.py`, sau đó tinh chỉnh tokenizer và predictor. Khi có checkpoint, dùng `qlib_test.py --device cuda:0` để đánh giá trên tập kiểm tra.

Kết quả backtest có thể giúp so sánh một thử nghiệm ban đầu với benchmark. Trước khi dùng cho quyết định thật, nhóm cần bổ sung tối ưu danh mục, trung hòa yếu tố rủi ro, sizing vị thế, stop-loss hoặc take-profit, phí giao dịch, trượt giá và tác động thị trường nếu phù hợp.

> Hãy xem Kronos là bộ máy tạo tín hiệu dự báo, không phải hệ thống tự động kiếm lời.
>
> — Ông T

### Người nghiên cứu muốn tái lập ví dụ

Nếu mục tiêu là học cách mô hình hoạt động, hãy bắt đầu với `examples/prediction_example.py`. Script này cho bạn luồng đầy đủ từ đọc dữ liệu, gọi model đến vẽ so sánh giữa dữ liệu thực tế và dự báo.

Đây là cách ít phải tự viết mã nhất để kiểm tra repo. Khi chạy ổn, bạn mới thay file dữ liệu, model hoặc các tham số `T`, `top_p` và `sample_count`.

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

### Không tìm thấy `requirements.txt`

Bạn có thể đang chạy lệnh ở thư mục cha hoặc một thư mục khác. Dùng `cd Kronos` sau khi clone rồi chạy lại `pip install -r requirements.txt`.

### Python không đủ phiên bản

README yêu cầu Python 3.10 trở lên. Nếu pip hoặc Python báo lỗi do phiên bản, hãy kiểm tra lại phiên bản Python đang được terminal sử dụng và chạy bằng Python 3.10+.

### Thiếu cột dữ liệu bắt buộc

DataFrame phải có `open`, `high`, `low`, `close`. `volume` và `amount` là tùy chọn, nhưng dữ liệu thời gian vẫn cần được chuyển thành timestamp và truyền qua `x_timestamp`, `y_timestamp`.

### Dùng lookback quá dài

`Kronos-small` và `Kronos-base` có `max_context` là 512. Hãy giảm lookback hoặc đặt predictor với giới hạn phù hợp. Predictor có thể tự cắt ngữ cảnh dài, nhưng README khuyến nghị không vượt giới hạn này để đạt hiệu quả tốt hơn.

### Batch có các chuỗi không cùng kích thước

`predict_batch` yêu cầu mọi chuỗi có cùng độ dài lịch sử và cùng độ dài dự báo. Hãy kiểm tra danh sách DataFrame và các danh sách timestamp trước khi gọi hàm. Nếu thiếu volume hoặc amount thì không phải lỗi, vì thư viện sẽ điền số 0.

### Tinh chỉnh không chạy được với GPU

Các script tinh chỉnh được thiết kế cho nhiều GPU và dùng `torchrun`. Kiểm tra giá trị `NUM_GPUS`, cấu hình đường dẫn trong `finetune/config.py` và dữ liệu Qlib trước khi chạy. README không cung cấp yêu cầu VRAM cụ thể, nên bạn cần đánh giá theo model và môi trường của mình.

### Kết quả backtest bị hiểu quá mức

Pipeline mẫu dùng tín hiệu thô và một chiến lược top-K đơn giản. Kết quả này không chứng minh một chiến lược có thể giao dịch an toàn ngoài thực tế. Hãy bổ sung kiểm tra dữ liệu, phí, trượt giá, quản trị rủi ro và đánh giá ngoài mẫu trước khi đưa ra quyết định.

```note
Dữ liệu tài chính có rủi ro cao. Không dùng dự báo của Kronos như một cam kết lợi nhuận hoặc lệnh giao dịch tự động. README cũng cảnh báo pipeline backtest chỉ là ví dụ minh họa, chưa phải hệ thống định lượng dùng trong sản xuất.
```

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

Nên dùng nếu bạn cần một mô hình chuyên cho chuỗi nến, muốn thử dự báo OHLCV bằng Python hoặc muốn nghiên cứu tinh chỉnh trên dữ liệu Qlib. Repo có API tương đối rõ, model zoo nhiều kích thước, ví dụ dự báo đơn lẻ, dự báo batch và pipeline tinh chỉnh hoàn chỉnh.

Giấy phép MIT giúp repo phù hợp để nghiên cứu và tích hợp theo điều kiện của giấy phép. Việc có model dựng sẵn cũng giúp bạn bắt đầu mà không phải huấn luyện từ đầu.

Giới hạn lớn là dự báo tài chính vốn nhiễu và không bảo đảm hiệu quả giao dịch. `Kronos-large` được đánh dấu chưa mở mã nguồn, hai model nhỏ và vừa có giới hạn ngữ cảnh 512, còn pipeline tinh chỉnh cần Qlib, dữ liệu đúng định dạng và GPU. README cũng không nêu hỗ trợ hệ điều hành cụ thể, yêu cầu phần cứng chi tiết hay quy trình triển khai production.

Nếu bạn chỉ cần một công cụ lập biểu đồ hoặc báo cáo lịch sử, Kronos có thể là lựa chọn quá nặng. Nếu bạn cần hệ thống giao dịch hoàn chỉnh, hãy dùng Kronos như một thành phần tạo tín hiệu rồi kết hợp với lớp dữ liệu, quản trị rủi ro, tối ưu danh mục và kiểm thử riêng. Nếu mục tiêu là nghiên cứu mô hình dự báo nến và bạn chấp nhận tự kiểm định nghiêm túc, đây là một repo đáng để thử.

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

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

Repo dùng giấy phép MIT và cung cấp một số model dựng sẵn được đánh dấu mở mã nguồn. README không nêu toàn bộ chi phí vận hành, chi phí tải model hoặc hạ tầng GPU, nên chưa thể khẳng định tổng chi phí sử dụng là bằng không.

### Có cần GPU để chạy Kronos không?

README dùng GPU cho dự báo batch và yêu cầu GPU khi chạy backtest với `--device cuda:0`. README không nêu rõ rằng dự báo cơ bản bắt buộc phải có GPU, cũng không cung cấp mức VRAM cụ thể.

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

README chỉ yêu cầu Python 3.10 trở lên và không nêu hệ điều hành được hỗ trợ. Vì vậy, tài liệu được cung cấp chưa đủ để xác nhận riêng khả năng chạy trên Windows.

### Kronos có cần API key hoặc tài khoản sàn không?

Đoạn hướng dẫn tải model và dự báo trong README không yêu cầu API key hay tài khoản giao dịch. Bạn cần tự chuẩn bị dữ liệu nến và có thể tải model từ Hugging Face Hub.

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

DataFrame phải có `open`, `high`, `low`, `close`. `volume` và `amount` là tùy chọn; khi dùng `predict_batch` mà thiếu hai cột này, thư viện sẽ điền bằng số 0. Bạn cũng cần các Series timestamp cho lịch sử và tương lai.

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

Không. README mô tả Kronos là mô hình dự báo và pipeline backtest chỉ là ví dụ minh họa với tín hiệu thô cùng chiến lược top-K đơn giản. Repo không xem đây là hệ thống giao dịch production hay cam kết lợi nhuận.

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

Có. Repo cung cấp pipeline tinh chỉnh, nhưng ví dụ dựa trên Qlib và dữ liệu thị trường cổ phiếu Trung Quốc. Bạn cần cài `pyqlib`, chuẩn bị dữ liệu Qlib, sửa các đường dẫn trong `finetune/config.py` và dùng các script `torchrun` cho tokenizer và predictor.
